@urbicon-ui/mcp-server 6.1.4

package/src/tools/sync-design-manifest.ts

@@ -0,0 +1,92 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import {
+  createManifestTemplate,
+  scanMarkers,
+  upsertUsagesSection
+} from '../design-manifest/index.js';
+import { getProjectManifestPath, getProjectSourceDir, isWithinProjectDir } from '../utils/paths.js';
+
+export function registerSyncDesignManifestTool(server: McpServer): void {
+  server.tool(
+    'sync_design_manifest',
+    'Scan the project source for `data-design-pattern="…"` markers and regenerate the Pattern Usages section of design.manifest.md. Run after adding, moving, or removing pattern-following pages so the usage index stays accurate — this is what makes a pattern change tractable (grep the markers → migrate every listed file). Creates the manifest if missing.',
+    {
+      sourceDir: z
+        .string()
+        .optional()
+        .describe('Directory to scan recursively. Defaults to ./src in the project root.'),
+      manifestPath: z
+        .string()
+        .optional()
+        .describe('Path to design.manifest.md. Defaults to the project root.')
+    },
+    { readOnlyHint: false },
+    async ({ sourceDir, manifestPath }) => {
+      const path = manifestPath ?? getProjectManifestPath();
+      if (!path.endsWith('.md')) {
+        return {
+          content: [
+            { type: 'text' as const, text: `Refusing to write: "${path}" is not a .md file.` }
+          ],
+          isError: true
+        };
+      }
+      if (manifestPath && !isWithinProjectDir(manifestPath)) {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Refusing to write outside the project root: "${path}".`
+            }
+          ],
+          isError: true
+        };
+      }
+      const src = sourceDir ?? getProjectSourceDir();
+
+      // Files in the manifest are relative to the project root (the manifest's directory).
+      const usages = await scanMarkers(src, dirname(path));
+
+      let content: string;
+      let created = false;
+      try {
+        content = await readFile(path, 'utf-8');
+      } catch {
+        content = createManifestTemplate({});
+        created = true;
+      }
+
+      const updated = upsertUsagesSection(content, usages);
+      try {
+        await writeFile(path, updated, 'utf-8');
+      } catch (err) {
+        return {
+          content: [
+            { type: 'text' as const, text: `Failed to write ${path}: ${(err as Error).message}` }
+          ],
+          isError: true
+        };
+      }
+
+      const byPattern = new Map<string, number>();
+      for (const u of usages) byPattern.set(u.pattern, (byPattern.get(u.pattern) ?? 0) + 1);
+
+      let text = `Synced \`${path}\`${created ? ' (created it)' : ''} — scanned \`${src}\`, found ${usages.length} marker(s)`;
+      if (byPattern.size > 0) {
+        const summary = [...byPattern]
+          .sort((a, b) => a[0].localeCompare(b[0]))
+          .map(([p, n]) => `${p} (${n})`)
+          .join(', ');
+        text += ` across ${byPattern.size} pattern(s): ${summary}.`;
+      } else {
+        text +=
+          '. No markers yet — add `data-design-pattern="<name>"` to the root element of pages that follow a composition pattern.';
+      }
+
+      return { content: [{ type: 'text' as const, text }] };
+    }
+  );
+}

package/src/tools/validate-design.ts

@@ -0,0 +1,84 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { Finding, LintReport, Severity } from '../design-linter/index.js';
+import { lintDesign } from '../design-linter/index.js';
+
+const SEVERITY_LABEL: Record<Severity, string> = {
+  error: '🔴 Errors',
+  warning: '🟠 Warnings',
+  info: '🔵 Heuristics'
+};
+
+function renderFindings(findings: Finding[], severity: Severity): string {
+  const group = findings.filter((f) => f.severity === severity);
+  if (group.length === 0) return '';
+
+  let md = `### ${SEVERITY_LABEL[severity]} (${group.length})\n\n`;
+  for (const f of group) {
+    const loc = f.line ? `L${f.line}` : '—';
+    const where = f.match ? ` \`${f.match}\`` : '';
+    md += `- **[${f.ruleId}]** ${loc}${where} — ${f.message}\n`;
+    md += `  ↳ ${f.fix}\n`;
+  }
+  return `${md}\n`;
+}
+
+function renderReport(report: LintReport): string {
+  const { score, counts, findings, filename } = report;
+  const hardFails = counts.error + counts.warning;
+  const verdict = hardFails === 0 ? '✅ PASS' : '❌ NEEDS FIXES';
+
+  let md = `# Design Validation — ${verdict}\n\n`;
+  if (filename) md += `> \`${filename}\`\n\n`;
+  md += `**Score: ${score}/100** · ${counts.error} error(s), ${counts.warning} warning(s), ${counts.info} heuristic note(s)\n\n`;
+
+  if (findings.length === 0) {
+    md +=
+      'No issues found. Tokens are valid, no `dark:`/`focus:`/hardcoded z-index, and the distribution heuristics are satisfied.\n';
+    return md;
+  }
+
+  if (counts.error > 0) {
+    md +=
+      'Errors are deterministic defects (broken output or token-system bypass) — fix all of them before shipping.\n\n';
+  }
+  md += renderFindings(findings, 'error');
+  md += renderFindings(findings, 'warning');
+  md += renderFindings(findings, 'info');
+
+  md += '---\n\n**Next steps:**\n';
+  md += '- `get_css_reference()` — exact valid token names (fixes hallucinated tokens)\n';
+  md +=
+    '- `get_design_principles(as="rubric")` — score the design qualitatively after the linter passes\n';
+  md += '- Re-run `validate_design` after fixing to confirm.\n';
+  return md;
+}
+
+export function registerValidateDesignTool(server: McpServer): void {
+  server.tool(
+    'validate_design',
+    'Lint generated Svelte/HTML markup against the Urbicon UI design rules. Deterministic checks (raw Tailwind colours, `dark:`/`focus:` misuse, hardcoded z-index, broken dynamic classes, hallucinated tokens) plus distribution heuristics (intent-colour rainbow, uniform spacing, identical Cards, missing radius strategy). Returns a 0–100 score (each error −10, warning −5, heuristic −2, floored at 0) and per-finding fixes. Run this in a generate → validate → fix loop after producing UI code.',
+    {
+      code: z
+        .string()
+        .describe(
+          'The Svelte/HTML/JSX source to validate (the markup of a generated page or component).'
+        ),
+      filename: z
+        .string()
+        .optional()
+        .describe('Optional label echoed back in the report (e.g. "dashboard/+page.svelte").'),
+      skipHeuristics: z
+        .boolean()
+        .optional()
+        .describe(
+          'Skip the advisory distribution heuristics; report only deterministic violations. Default: false.'
+        )
+    },
+    { readOnlyHint: true },
+    async ({ code, filename, skipHeuristics }) => {
+      const report = lintDesign(code, { filename, skipHeuristics });
+      return { content: [{ type: 'text' as const, text: renderReport(report) }] };
+    }
+  );
+}

package/src/transports/http.ts

@@ -0,0 +1,79 @@
+import { createServer as createHttpServer } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createServer as createMcpServer } from '../server.js';
+
+export async function startHttpTransport(port: number): Promise<void> {
+  const sessions = new Map<string, StreamableHTTPServerTransport>();
+
+  const httpServer = createHttpServer(async (req, res) => {
+    const url = new URL(req.url || '/', `http://localhost:${port}`);
+
+    if (url.pathname !== '/mcp') {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('Urbicon UI MCP Server');
+      return;
+    }
+
+    const sessionId = req.headers['mcp-session-id'] as string | undefined;
+
+    if (req.method === 'POST') {
+      if (sessionId && sessions.has(sessionId)) {
+        await sessions.get(sessionId)!.handleRequest(req, res);
+      } else if (!sessionId) {
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => crypto.randomUUID()
+        });
+        transport.onclose = () => {
+          if (transport.sessionId) sessions.delete(transport.sessionId);
+        };
+        const server = createMcpServer();
+        await server.connect(transport);
+        await transport.handleRequest(req, res);
+        if (transport.sessionId) sessions.set(transport.sessionId, transport);
+      } else {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32600, message: 'Invalid session' },
+            id: null
+          })
+        );
+      }
+    } else if (req.method === 'GET') {
+      if (sessionId && sessions.has(sessionId)) {
+        await sessions.get(sessionId)!.handleRequest(req, res);
+      } else {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32600, message: 'Missing or invalid session' },
+            id: null
+          })
+        );
+      }
+    } else if (req.method === 'DELETE') {
+      if (sessionId && sessions.has(sessionId)) {
+        await sessions.get(sessionId)!.handleRequest(req, res);
+        sessions.delete(sessionId);
+      } else {
+        res.writeHead(204);
+        res.end();
+      }
+    } else {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          jsonrpc: '2.0',
+          error: { code: -32600, message: 'Method not allowed' },
+          id: null
+        })
+      );
+    }
+  });
+
+  httpServer.listen(port, () => {
+    console.error(`Urbicon UI MCP Server listening on http://localhost:${port}/mcp`);
+  });
+}

package/src/transports/stdio.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+export async function startStdioTransport(server: McpServer): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/utils/format-catalog.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest';
+import type { ComponentCatalogEntry, RecipeEntry } from '../data/catalog-loader.js';
+import { filterInternalComponents, formatCompactCatalog } from './format-catalog.js';
+
+function makeEntry(
+  overrides: Partial<ComponentCatalogEntry> & Pick<ComponentCatalogEntry, 'name' | 'slug'>
+): ComponentCatalogEntry {
+  return {
+    package: '@urbicon-ui/blocks',
+    group: 'primitives',
+    description: 'desc',
+    tags: [],
+    import: `import { ${overrides.name} } from '@urbicon-ui/blocks';`,
+    llmTxtPath: '',
+    variants: [],
+    keyProps: [],
+    keyPropTypes: {},
+    slots: [],
+    hasExamples: false,
+    relatedComponents: [],
+    ...overrides
+  };
+}
+
+describe('filterInternalComponents', () => {
+  it('removes docs-site-internal components from the list', () => {
+    const entries = [
+      makeEntry({ name: 'Button', slug: 'button' }),
+      makeEntry({ name: 'ApiReference', slug: 'api-reference' }),
+      makeEntry({ name: 'PlaygroundConfigurator', slug: 'playground-configurator' }),
+      makeEntry({ name: 'Input', slug: 'input' })
+    ];
+    const result = filterInternalComponents(entries);
+    expect(result.map((e) => e.name)).toEqual(['Button', 'Input']);
+  });
+
+  it('returns an empty list when all entries are internal', () => {
+    const entries = [
+      makeEntry({ name: 'DocsLayout', slug: 'docs-layout' }),
+      makeEntry({ name: 'InfoCard', slug: 'info-card' })
+    ];
+    expect(filterInternalComponents(entries)).toEqual([]);
+  });
+});
+
+describe('formatCompactCatalog', () => {
+  const button = makeEntry({
+    name: 'Button',
+    slug: 'button',
+    description: 'Click to do things',
+    tags: ['action'],
+    variants: [{ name: 'intent', values: ['primary', 'danger'] }]
+  });
+  const input = makeEntry({
+    name: 'Input',
+    slug: 'input',
+    description: 'Text field',
+    tags: ['form'],
+    relatedComponents: ['Textarea']
+  });
+  const alert = makeEntry({
+    name: 'Alert',
+    slug: 'alert',
+    description: 'Inline message',
+    tags: ['feedback']
+  });
+  const orphan = makeEntry({
+    name: 'Mystery',
+    slug: 'mystery',
+    description: 'No primary tag here',
+    tags: ['unknown']
+  });
+
+  it('outputs a markdown document with the component count', () => {
+    const md = formatCompactCatalog([button, input]);
+    expect(md).toContain('# Urbicon UI Components');
+    expect(md).toContain('> 2 components available.');
+    expect(md).toContain('get_component');
+  });
+
+  it('groups components by their primary tag in the canonical order', () => {
+    const md = formatCompactCatalog([alert, button, input]);
+    const actionIdx = md.indexOf('## Actions');
+    const formsIdx = md.indexOf('## Forms');
+    const feedbackIdx = md.indexOf('## Feedback & Status');
+    expect(actionIdx).toBeGreaterThan(-1);
+    expect(formsIdx).toBeGreaterThan(actionIdx);
+    expect(feedbackIdx).toBeGreaterThan(formsIdx);
+  });
+
+  it('puts components with unrecognised primary tags in the Other bucket', () => {
+    const md = formatCompactCatalog([orphan]);
+    expect(md).toContain('## Other');
+    expect(md).toContain('Mystery');
+  });
+
+  it('renders variant details when a non-boolean variant is present', () => {
+    const md = formatCompactCatalog([button]);
+    expect(md).toContain('intent: primary/danger');
+  });
+
+  it('omits boolean-only variants from the rendered line', () => {
+    const withBool = makeEntry({
+      name: 'Toggle',
+      slug: 'toggle',
+      description: 'On/off',
+      tags: ['form'],
+      variants: [{ name: 'checked', values: ['true', 'false'] }]
+    });
+    const md = formatCompactCatalog([withBool]);
+    expect(md).not.toContain('checked: true/false');
+  });
+
+  it('renders a Related hint when related components exist', () => {
+    const md = formatCompactCatalog([input]);
+    expect(md).toContain('Related: Textarea');
+  });
+
+  it('filters by the tags option', () => {
+    const md = formatCompactCatalog([button, input, alert], { tags: ['form'] });
+    // Matching the bold-component-bullet prefix avoids false positives from
+    // the Quick-Setup section (which itself references `Button` in code).
+    expect(md).toContain('- **Input**');
+    expect(md).not.toContain('- **Button**');
+    expect(md).not.toContain('- **Alert**');
+  });
+
+  it('appends a Recipes section when recipes are supplied', () => {
+    const recipes: RecipeEntry[] = [
+      {
+        id: 'login-form',
+        title: 'Login',
+        description: 'Login screen',
+        components: ['Input', 'Button'],
+        code: '',
+        features: []
+      }
+    ];
+    const md = formatCompactCatalog([button, input], { recipes });
+    expect(md).toContain('## Recipes');
+    expect(md).toContain('**login-form**');
+    expect(md).toContain('Input, Button');
+  });
+});

package/src/utils/format-catalog.ts

@@ -0,0 +1,130 @@
+import type { ComponentCatalogEntry, RecipeEntry } from '../data/catalog-loader.js';
+
+const INTERNAL_COMPONENTS = new Set([
+  'ApiReference',
+  'CodeExample',
+  'DocsLayout',
+  'InfoCard',
+  'PlaygroundConfigurator',
+  'Section',
+  'TableOfContents',
+  'TypesReference'
+]);
+
+const TAG_ORDER = ['action', 'form', 'layout', 'feedback', 'navigation', 'display', 'data'];
+
+const TAG_LABELS: Record<string, string> = {
+  action: 'Actions',
+  form: 'Forms',
+  layout: 'Layout & Containers',
+  feedback: 'Feedback & Status',
+  navigation: 'Navigation',
+  display: 'Display & Overlays',
+  data: 'Data'
+};
+
+export function filterInternalComponents(
+  components: ComponentCatalogEntry[]
+): ComponentCatalogEntry[] {
+  return components.filter((c) => !INTERNAL_COMPONENTS.has(c.name));
+}
+
+export function formatCompactCatalog(
+  components: ComponentCatalogEntry[],
+  options?: { recipes?: RecipeEntry[]; tags?: string[] }
+): string {
+  let filtered = filterInternalComponents(components);
+
+  if (options?.tags && options.tags.length > 0) {
+    const tagSet = new Set(options.tags.map((t) => t.toLowerCase()));
+    filtered = filtered.filter((c) => c.tags.some((t) => tagSet.has(t.toLowerCase())));
+  }
+
+  const grouped = new Map<string, ComponentCatalogEntry[]>();
+  const ungrouped: ComponentCatalogEntry[] = [];
+
+  for (const comp of filtered) {
+    const primaryTag = comp.tags[0];
+    if (primaryTag && TAG_LABELS[primaryTag]) {
+      if (!grouped.has(primaryTag)) grouped.set(primaryTag, []);
+      grouped.get(primaryTag)!.push(comp);
+    } else {
+      ungrouped.push(comp);
+    }
+  }
+
+  let md = '# Urbicon UI Components\n\n';
+  md += `> ${filtered.length} components available.\n`;
+  md += '> For full API docs on any component: use `get_component` tool.\n\n';
+
+  md += '## Quick Setup\n\n';
+  md += 'Install from npm:\n';
+  md += '```bash\nbun add @urbicon-ui/blocks @urbicon-ui/i18n\n```\n';
+  md +=
+    'CSS setup (root layout or entry CSS) — your app owns the Tailwind import and it comes first:\n';
+  md += '```css\n';
+  md += "@import 'tailwindcss';\n";
+  md +=
+    "@import '@urbicon-ui/blocks/style/index.css'; /* tokens + @source directives — import this, NOT the foundation/semantic/interaction subfiles, and add no manual @source */\n";
+  md += '```\n';
+  md += "Import: `import { Button, Card } from '@urbicon-ui/blocks';` (always from package root)\n";
+  md +=
+    'Dark mode: automatic via `prefers-color-scheme` — semantic tokens switch automatically. For manual control, use `ThemeSwitcher` or `data-theme="dark"` on `<html>`.\n\n';
+
+  for (const tag of TAG_ORDER) {
+    const comps = grouped.get(tag);
+    if (!comps || comps.length === 0) continue;
+
+    md += `## ${TAG_LABELS[tag]}\n`;
+    for (const comp of comps) {
+      md += formatComponentLine(comp);
+    }
+    md += '\n';
+  }
+
+  if (ungrouped.length > 0) {
+    md += '## Other\n';
+    for (const comp of ungrouped) {
+      md += formatComponentLine(comp);
+    }
+    md += '\n';
+  }
+
+  if (options?.recipes && options.recipes.length > 0) {
+    md += '## Recipes\n';
+    md += '> Full production-ready code examples. Use `get_recipe` tool with the recipe id.\n';
+    for (const recipe of options.recipes) {
+      md += `- **${recipe.id}** — ${recipe.description} (${recipe.components.join(', ')})\n`;
+    }
+    md += '\n';
+  }
+
+  return md;
+}
+
+function isBooleanVariant(values: string[]): boolean {
+  const sorted = [...values].sort();
+  return (
+    (sorted.length === 1 && (sorted[0] === 'true' || sorted[0] === 'false')) ||
+    (sorted.length === 2 && sorted[0] === 'false' && sorted[1] === 'true')
+  );
+}
+
+function formatComponentLine(comp: ComponentCatalogEntry): string {
+  const variants = comp.variants
+    .filter((v) => !isBooleanVariant(v.values))
+    .map((v) => `${v.name}: ${v.values.join('/')}`)
+    .join(' · ');
+
+  const related =
+    comp.relatedComponents.length > 0 ? ` | Related: ${comp.relatedComponents.join(', ')}` : '';
+
+  const pkg = comp.package !== '@urbicon-ui/blocks' ? ` _(from \`${comp.package}\`)_` : '';
+
+  let line = `- **${comp.name}**${pkg} — ${comp.description}`;
+  if (variants) line += ` | ${variants}`;
+  line += related;
+  line += '\n';
+
+  return line;
+}

package/src/utils/paths.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  getCatalogPath,
+  getComponentLlmPath,
+  getDataDir,
+  getRecipeDir,
+  getTemplateDir,
+  getTemplatePath,
+  isWithinProjectDir
+} from './paths.js';
+
+describe('paths', () => {
+  const originalDataDir = process.env.DATA_DIR;
+
+  afterEach(() => {
+    if (originalDataDir === undefined) {
+      delete process.env.DATA_DIR;
+    } else {
+      process.env.DATA_DIR = originalDataDir;
+    }
+  });
+
+  describe('isWithinProjectDir', () => {
+    const original = process.env.DESIGN_PROJECT_DIR;
+    beforeEach(() => {
+      process.env.DESIGN_PROJECT_DIR = '/home/user/app';
+    });
+    afterEach(() => {
+      if (original === undefined) delete process.env.DESIGN_PROJECT_DIR;
+      else process.env.DESIGN_PROJECT_DIR = original;
+    });
+
+    it('accepts paths inside the project root', () => {
+      expect(isWithinProjectDir('/home/user/app/design.manifest.md')).toBe(true);
+      expect(isWithinProjectDir('/home/user/app/docs/design.manifest.md')).toBe(true);
+    });
+    it('rejects paths outside the project root', () => {
+      expect(isWithinProjectDir('/etc/motd.md')).toBe(false);
+      expect(isWithinProjectDir('/home/user/app/../other/x.md')).toBe(false);
+      expect(isWithinProjectDir('/home/user/application/x.md')).toBe(false); // prefix-but-not-child
+    });
+  });
+
+  describe('getDataDir', () => {
+    beforeEach(() => {
+      delete process.env.DATA_DIR;
+    });
+
+    it('defaults to apps/docs/static relative to the package', () => {
+      const dir = getDataDir();
+      expect(dir.endsWith('/apps/docs/static')).toBe(true);
+    });
+
+    it('honours DATA_DIR env override', () => {
+      process.env.DATA_DIR = '/custom/data/dir';
+      expect(getDataDir()).toBe('/custom/data/dir');
+    });
+  });
+
+  describe('getTemplateDir / getRecipeDir / getTemplatePath / getCatalogPath', () => {
+    it('returns absolute paths rooted in the monorepo', () => {
+      expect(getTemplateDir()).toMatch(/\/packages\/docs-gen\/templates$/);
+      expect(getRecipeDir()).toMatch(/\/apps\/docs\/src\/routes\/recipes$/);
+      expect(getTemplatePath()).toMatch(/\/packages\/docs-gen\/templates\/llms-full-template\.md$/);
+      expect(getCatalogPath()).toMatch(/\/mcp\/component-catalog\.json$/);
+    });
+  });
+
+  describe('getComponentLlmPath', () => {
+    it('resolves a valid slug to a path inside the data dir', () => {
+      const p = getComponentLlmPath('primitives', 'button');
+      expect(p).toMatch(/\/primitives\/button\/llm\.txt$/);
+    });
+
+    it('accepts multi-word hyphenated slugs', () => {
+      const p = getComponentLlmPath('components', 'date-picker');
+      expect(p).toMatch(/\/components\/date-picker\/llm\.txt$/);
+    });
+
+    it('rejects uppercase in the slug', () => {
+      expect(() => getComponentLlmPath('primitives', 'Button')).toThrow(/Invalid component slug/);
+    });
+
+    it('rejects whitespace', () => {
+      expect(() => getComponentLlmPath('primitives', 'bad slug')).toThrow(/Invalid component slug/);
+    });
+
+    it('rejects leading or trailing hyphens', () => {
+      expect(() => getComponentLlmPath('primitives', '-bad')).toThrow(/Invalid component slug/);
+      expect(() => getComponentLlmPath('primitives', 'bad-')).toThrow(/Invalid component slug/);
+    });
+
+    it('rejects path traversal attempts', () => {
+      // Any dotted segment fails the SAFE_SLUG regex first.
+      expect(() => getComponentLlmPath('primitives', '..')).toThrow(/Invalid component slug/);
+      expect(() => getComponentLlmPath('primitives', '../../../etc/passwd')).toThrow(
+        /Invalid component slug/
+      );
+    });
+  });
+});