@urbicon-ui/design 6.3.7 → 6.3.9

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli/index.ts
-import { readFile as readFile10 } from "node:fs/promises";
-import { resolve as resolve10 } from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { resolve as resolve11 } from "node:path";
 
 // src/cli/args.ts
 var BOOLEAN_FLAGS = new Set([
@@ -762,7 +764,7 @@ function extractSection2(content, section) {
 }
 // src/cli/content.ts
 import { readFile as readFile4 } from "node:fs/promises";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { dirname as dirname2, resolve as resolve3 } from "node:path";
 
 // ../design-content/src/content-loader.ts
@@ -803,7 +805,7 @@ function ensureContentDir() {
   if (process.env.URBICON_CONTENT_DIR)
     return;
   try {
-    const require2 = createRequire(import.meta.url);
+    const require2 = createRequire2(import.meta.url);
     const pkgJson = require2.resolve("@urbicon-ui/design-content/package.json");
     process.env.URBICON_CONTENT_DIR = resolve3(dirname2(pkgJson), "content");
   } catch {}
@@ -2401,19 +2403,303 @@ Fix the issues above and re-save. — urbicon design gate`);
   return HOOK_BLOCK;
 }
 
+// src/cli/commands/i18n.ts
+import { readdir as readdir2, readFile as readFile6, stat as stat2 } from "node:fs/promises";
+import { basename, join as join3, relative as relative2, resolve as resolve6, sep as sep2 } from "node:path";
+import { pathToFileURL } from "node:url";
+var CHECKS = ["parity", "unused", "hardcoded", "audit"];
+var isCheck = (value) => CHECKS.includes(value);
+var SKIP_DIRS2 = new Set([
+  "node_modules",
+  ".svelte-kit",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "coverage"
+]);
+var MAX_DEPTH2 = 24;
+var DEFAULT_CONFIG = {
+  sources: ["src"],
+  translations: ["src/lib/translations"]
+};
+function label(abs) {
+  return relative2(process.cwd(), abs).split(sep2).join("/") || abs;
+}
+function listFlag(flags, key) {
+  const raw = stringFlag(flags, key);
+  if (raw === undefined)
+    return;
+  const items = raw.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length ? items : undefined;
+}
+async function loadConfig(flags, sourceDirs) {
+  let fileConfig = {};
+  const explicit = stringFlag(flags, "config");
+  const candidate = explicit ?? "i18n.audit.json";
+  try {
+    fileConfig = JSON.parse(await readFile6(resolve6(candidate), "utf-8"));
+  } catch (error) {
+    if (explicit)
+      throw new Error(`cannot read config "${explicit}": ${error.message}`);
+  }
+  const merged = { ...DEFAULT_CONFIG, ...fileConfig };
+  if (sourceDirs.length)
+    merged.sources = sourceDirs;
+  merged.functionNames = listFlag(flags, "function-names") ?? merged.functionNames;
+  merged.dynamicKeys = listFlag(flags, "dynamic-keys") ?? merged.dynamicKeys;
+  merged.ignoreKeys = listFlag(flags, "ignore-keys") ?? merged.ignoreKeys;
+  merged.ignoreStrings = listFlag(flags, "ignore-strings") ?? merged.ignoreStrings;
+  merged.baseLocale = stringFlag(flags, "base-locale") ?? merged.baseLocale;
+  merged.translations = listFlag(flags, "translations") ?? merged.translations;
+  merged.runtimeUsage = stringFlag(flags, "runtime-usage") ?? merged.runtimeUsage;
+  return merged;
+}
+async function collectFiles(dir, extensions, depth = 0) {
+  if (depth > MAX_DEPTH2)
+    return [];
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const full = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith("."))
+        continue;
+      files.push(...await collectFiles(full, extensions, depth + 1));
+    } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext)) && !/\.(test|spec)\.|\.d\.ts$/.test(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+var BUNDLE_EXT = /\.(ts|js|mjs)$/;
+async function loadBundleGroups(dirs, isSupportedLocale) {
+  const groups = [];
+  const errors = [];
+  for (const dir of dirs) {
+    const abs = resolve6(dir);
+    let candidates;
+    try {
+      const info = await stat2(abs);
+      candidates = info.isDirectory() ? (await readdir2(abs)).filter((f) => BUNDLE_EXT.test(f) && !f.endsWith(".d.ts")).map((f) => join3(abs, f)) : [abs];
+    } catch {
+      errors.push(`translations path not found: ${label(abs)}`);
+      continue;
+    }
+    const bundles = {};
+    let localeFiles = 0;
+    for (const file of candidates) {
+      const locale = basename(file).replace(BUNDLE_EXT, "");
+      if (!isSupportedLocale(locale))
+        continue;
+      localeFiles++;
+      if (bundles[locale]) {
+        errors.push(`duplicate locale "${locale}" in ${label(abs)} — ${label(file)} ignored`);
+        continue;
+      }
+      try {
+        const mod = await import(pathToFileURL(file).href);
+        if (mod.default && typeof mod.default === "object") {
+          bundles[locale] = mod.default;
+        } else {
+          errors.push(`bundle ${label(file)} has no object default export`);
+        }
+      } catch (error) {
+        errors.push(`cannot load bundle ${label(file)}: ${error.message}`);
+      }
+    }
+    if (Object.keys(bundles).length)
+      groups.push({ name: label(abs), bundles });
+    else if (localeFiles === 0)
+      errors.push(`no locale bundles (en/de/…) in: ${label(abs)}`);
+  }
+  return { groups, errors };
+}
+function runParity(audit, config, groups) {
+  const lines = [];
+  let errors = 0;
+  let warnings = 0;
+  const allFindings = [];
+  for (const group of groups) {
+    const report = audit.auditTranslations(group.name, group.bundles, {
+      baseLocale: config.baseLocale,
+      ignoreKeys: config.ignoreKeys
+    });
+    errors += report.errors.length;
+    warnings += report.warnings.length;
+    allFindings.push(...report.findings);
+    for (const finding of report.findings) {
+      const icon = finding.severity === "error" ? "✗" : "!";
+      lines.push(`  ${icon} [${finding.code}] ${finding.locale} — ${finding.detail}`);
+    }
+  }
+  return { lines, errors, warnings, json: { findings: allFindings } };
+}
+async function runUnused(audit, config, groups, sources) {
+  const defined = new Set;
+  for (const group of groups) {
+    const base = group.bundles.en ?? Object.values(group.bundles)[0];
+    if (base)
+      for (const key of audit.collectDeepKeys(base))
+        defined.add(key);
+  }
+  let runtimeUsedKeys;
+  if (config.runtimeUsage) {
+    try {
+      const parsed = JSON.parse(await readFile6(resolve6(config.runtimeUsage), "utf-8"));
+      if (Array.isArray(parsed))
+        runtimeUsedKeys = parsed.filter((k) => typeof k === "string");
+    } catch (error) {
+      printError(`ignoring unreadable runtime-usage file: ${error.message}`);
+    }
+  }
+  const { scan, errors: scanErrors } = await audit.scanSources(sources, {
+    functionNames: config.functionNames
+  });
+  const report = audit.findUnusedKeys(defined, scan, {
+    dynamicKeys: config.dynamicKeys,
+    ignoreKeys: config.ignoreKeys,
+    runtimeUsedKeys
+  });
+  const lines = [];
+  for (const error of scanErrors)
+    lines.push(`  ! could not parse ${error.file}: ${error.message}`);
+  for (const finding of report.usedButUndefined) {
+    lines.push(`  ✗ used but undefined: ${finding.key} (${finding.sites[0]?.file}:${finding.sites[0]?.line})`);
+  }
+  for (const finding of report.unused) {
+    lines.push(`  ! unused (${finding.tier}): ${finding.key}`);
+  }
+  return {
+    lines,
+    errors: report.usedButUndefined.length,
+    warnings: report.unused.length,
+    json: {
+      unused: report.unused,
+      usedButUndefined: report.usedButUndefined,
+      dynamicPrefixCoverage: report.dynamicPrefixCoverage,
+      opaqueSiteCount: report.opaqueSiteCount,
+      scanErrors
+    }
+  };
+}
+async function runHardcoded(audit, config, sources) {
+  const lines = [];
+  const all = [];
+  let warnings = 0;
+  for (const source of sources) {
+    if (!source.file.endsWith(".svelte"))
+      continue;
+    try {
+      const findings = await audit.findHardcodedStrings(source.code, source.file, {
+        ignoreStrings: config.ignoreStrings
+      });
+      warnings += findings.length;
+      all.push(...findings);
+      for (const f of findings) {
+        const where = f.kind === "attribute" ? `@${f.attribute}` : "text";
+        lines.push(`  ! hardcoded ${where}: "${f.text}" (${f.file}:${f.line})`);
+      }
+    } catch (error) {
+      lines.push(`  ! could not parse ${source.file}: ${error.message}`);
+    }
+  }
+  return { lines, errors: 0, warnings, json: { findings: all } };
+}
+async function runI18n(positionals, flags) {
+  const first = positionals[0];
+  const check = first && isCheck(first) ? first : "audit";
+  const dirArgs = (first && isCheck(first) ? positionals.slice(1) : positionals).filter(Boolean);
+  const asJson = boolFlag(flags, "json");
+  const strict = boolFlag(flags, "strict");
+  let audit;
+  try {
+    audit = await import("@urbicon-ui/i18n/audit");
+  } catch (error) {
+    printError(`cannot load @urbicon-ui/i18n/audit — is @urbicon-ui/i18n installed? (${error.message})`);
+    return EXIT.FAIL;
+  }
+  let config;
+  try {
+    config = await loadConfig(flags, dirArgs);
+  } catch (error) {
+    printError(error.message);
+    return EXIT.USAGE;
+  }
+  const wantsParity = check === "parity" || check === "audit";
+  const wantsUnused = check === "unused" || check === "audit";
+  const wantsHardcoded = check === "hardcoded" || check === "audit";
+  let sources = [];
+  if (wantsUnused || wantsHardcoded) {
+    const files = (await Promise.all(config.sources.map((dir) => collectFiles(resolve6(dir), [".ts", ".js", ".svelte"])))).flat();
+    sources = await Promise.all(files.map(async (file) => ({ file: label(file), code: await readFile6(file, "utf-8") })));
+  }
+  let groups = [];
+  let bundleErrors = [];
+  if (wantsParity || wantsUnused) {
+    const loaded = await loadBundleGroups(config.translations, audit.isLocaleSupported);
+    groups = loaded.groups;
+    bundleErrors = loaded.errors;
+  }
+  const sections = {};
+  if (wantsParity)
+    sections.parity = runParity(audit, config, groups);
+  if (wantsUnused)
+    sections.unused = await runUnused(audit, config, groups, sources);
+  if (wantsHardcoded)
+    sections.hardcoded = await runHardcoded(audit, config, sources);
+  const totalErrors = Object.values(sections).reduce((sum, s) => sum + s.errors, 0);
+  const totalWarnings = Object.values(sections).reduce((sum, s) => sum + s.warnings, 0);
+  const bundleFailed = (wantsParity || wantsUnused) && bundleErrors.length > 0;
+  const failed = totalErrors > 0 || bundleFailed || strict && totalWarnings > 0;
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: !failed,
+      check,
+      strict,
+      bundleErrors,
+      ...Object.fromEntries(Object.entries(sections).map(([k, v]) => [k, v.json]))
+    }, null, 2));
+    return failed ? EXIT.FAIL : EXIT.OK;
+  }
+  for (const error of bundleErrors)
+    printError(error);
+  for (const [name, section] of Object.entries(sections)) {
+    console.log(`
+${name}:`);
+    if (section.lines.length === 0)
+      console.log("  ✓ no findings");
+    else
+      for (const line of section.lines)
+        console.log(line);
+  }
+  const bundleNote = bundleErrors.length ? `, ${bundleErrors.length} bundle error(s)` : "";
+  console.log(`
+${totalErrors} error(s), ${totalWarnings} advisory finding(s)${bundleNote}${strict ? " (--strict: advisory gates)" : ""}.`);
+  if (failed)
+    console.log("FAIL.");
+  return failed ? EXIT.FAIL : EXIT.OK;
+}
+
 // src/cli/commands/init.ts
-import { mkdir, readFile as readFile7, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname5, join as join3, relative as relative2, resolve as resolve7 } from "node:path";
+import { mkdir, readFile as readFile8, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname5, join as join4, relative as relative3, resolve as resolve8 } from "node:path";
 
 // src/cli/package-root.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { dirname as dirname4, resolve as resolve6 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function findPackageRoot() {
   let dir = dirname4(fileURLToPath2(import.meta.url));
   for (let i = 0;i < 6; i++) {
     try {
-      const pkg = JSON.parse(await readFile6(resolve6(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(await readFile7(resolve7(dir, "package.json"), "utf-8"));
       if (pkg.name === "@urbicon-ui/design")
         return dir;
     } catch {}
@@ -2452,11 +2738,11 @@ async function readTemplate(name) {
   const root = await findPackageRoot();
   if (!root)
     throw new Error("could not locate the @urbicon-ui/design package root");
-  return readFile7(join3(root, "templates", name), "utf-8");
+  return readFile8(join4(root, "templates", name), "utf-8");
 }
 async function readOrNull(path) {
   try {
-    return await readFile7(path, "utf-8");
+    return await readFile8(path, "utf-8");
   } catch {
     return null;
   }
@@ -2471,14 +2757,14 @@ function upsertBlock(existing, block) {
     const content = existing.slice(0, startIdx) + block.trim() + existing.slice(endIdx + BLOCK_END.length);
     return { content, replaced: true };
   }
-  const sep2 = existing.length === 0 ? "" : existing.endsWith(`
+  const sep3 = existing.length === 0 ? "" : existing.endsWith(`
 
 `) ? "" : existing.endsWith(`
 `) ? `
 ` : `
 
 `;
-  return { content: `${existing}${sep2}${block.trim()}
+  return { content: `${existing}${sep3}${block.trim()}
 `, replaced: false };
 }
 async function mergeHook(settingsPath) {
@@ -2507,7 +2793,7 @@ async function mergeHook(settingsPath) {
 }
 async function runInit(_positionals, flags) {
   const cwd = process.cwd();
-  const rel = (p) => relative2(cwd, p) || p;
+  const rel = (p) => relative3(cwd, p) || p;
   const done = [];
   const skipped = [];
   let block;
@@ -2517,7 +2803,7 @@ async function runInit(_positionals, flags) {
     printError(err.message);
     return EXIT.FAIL;
   }
-  const agentsPath = resolve7(stringFlag(flags, "agents-file") ?? "AGENTS.md");
+  const agentsPath = resolve8(stringFlag(flags, "agents-file") ?? "AGENTS.md");
   const existingAgents = await readOrNull(agentsPath) ?? "";
   let upserted;
   try {
@@ -2537,7 +2823,7 @@ async function runInit(_positionals, flags) {
     done.push(`${rel(manifestPath)} — scaffolded`);
   }
   if (boolFlag(flags, "hook")) {
-    const settingsPath = resolve7(".claude", "settings.json");
+    const settingsPath = resolve8(".claude", "settings.json");
     try {
       const result = await mergeHook(settingsPath);
       (result === "added" ? done : skipped).push(`${rel(settingsPath)} — ${result === "added" ? "wired" : "already has"} the PostToolUse \`urbicon hook\``);
@@ -2546,7 +2832,7 @@ async function runInit(_positionals, flags) {
     }
   }
   if (boolFlag(flags, "ci")) {
-    const ciPath = resolve7(".github", "workflows", "design-gate.yml");
+    const ciPath = resolve8(".github", "workflows", "design-gate.yml");
     if (await readOrNull(ciPath)) {
       skipped.push(`${rel(ciPath)} — already present`);
     } else {
@@ -2658,9 +2944,9 @@ async function runSyncManifest(_positionals, flags) {
 }
 
 // src/cli/commands/validate.ts
-import { readdir as readdir2, readFile as readFile8, stat as stat2 } from "node:fs/promises";
-import { join as join4, relative as relative3, resolve as resolve8, sep as sep2 } from "node:path";
-var SKIP_DIRS2 = new Set([
+import { readdir as readdir3, readFile as readFile9, stat as stat3 } from "node:fs/promises";
+import { join as join5, relative as relative4, resolve as resolve9, sep as sep3 } from "node:path";
+var SKIP_DIRS3 = new Set([
   "node_modules",
   ".svelte-kit",
   ".git",
@@ -2670,27 +2956,27 @@ var SKIP_DIRS2 = new Set([
   ".turbo",
   "coverage"
 ]);
-var MAX_DEPTH2 = 24;
-function label(abs) {
-  return relative3(process.cwd(), abs).split(sep2).join("/") || abs;
+var MAX_DEPTH3 = 24;
+function label2(abs) {
+  return relative4(process.cwd(), abs).split(sep3).join("/") || abs;
 }
 async function collectSvelte(dir, depth = 0) {
-  if (depth > MAX_DEPTH2)
+  if (depth > MAX_DEPTH3)
     return [];
   let entries;
   try {
-    entries = await readdir2(dir, { withFileTypes: true });
+    entries = await readdir3(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith("."))
+      if (SKIP_DIRS3.has(entry.name) || entry.name.startsWith("."))
         continue;
-      files.push(...await collectSvelte(join4(dir, entry.name), depth + 1));
+      files.push(...await collectSvelte(join5(dir, entry.name), depth + 1));
     } else if (entry.isFile() && entry.name.endsWith(".svelte")) {
-      files.push(join4(dir, entry.name));
+      files.push(join5(dir, entry.name));
     }
   }
   return files;
@@ -2711,20 +2997,20 @@ async function gather(positionals) {
       units.push({ label: "<stdin>", code: await readStdin2() });
       continue;
     }
-    const abs = resolve8(p);
+    const abs = resolve9(p);
     let info;
     try {
-      info = await stat2(abs);
+      info = await stat3(abs);
     } catch {
       printError(`cannot read "${p}"`);
       return null;
     }
     if (info.isDirectory()) {
       for (const file of await collectSvelte(abs)) {
-        units.push({ label: label(file), code: await readFile8(file, "utf-8") });
+        units.push({ label: label2(file), code: await readFile9(file, "utf-8") });
       }
     } else {
-      units.push({ label: label(abs), code: await readFile8(abs, "utf-8") });
+      units.push({ label: label2(abs), code: await readFile9(abs, "utf-8") });
     }
   }
   return units;
@@ -2785,7 +3071,7 @@ ${reports.length} file(s) · ${totals.error} error(s), ` + `${totals.warning} wa
   }
   if (extraTokens.length > 0) {
     console.log(`
-${extraTokens.length} project token override(s) applied from ${relative3(process.cwd(), manifestPath).split(sep2).join("/")}.`);
+${extraTokens.length} project token override(s) applied from ${relative4(process.cwd(), manifestPath).split(sep3).join("/")}.`);
   }
   if (gate.slopBreaches.length > 0) {
     console.log(`
@@ -2802,12 +3088,12 @@ FAIL — ${reason}.`);
 }
 
 // src/cli/commands/verb.ts
-import { readdir as readdir3, readFile as readFile9 } from "node:fs/promises";
-import { resolve as resolve9 } from "node:path";
+import { readdir as readdir4, readFile as readFile10 } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
 var SAFE_VERB = /^[a-z][a-z0-9-]*$/;
 async function resolveVerbsDir() {
   const root = await findPackageRoot();
-  return root ? resolve9(root, "skill", "verbs") : null;
+  return root ? resolve10(root, "skill", "verbs") : null;
 }
 function purposeOf(body) {
   const heading = body.split(`
@@ -2823,7 +3109,7 @@ async function runVerbList(_positionals, _flags) {
   }
   let files;
   try {
-    files = (await readdir3(dir)).filter((f) => f.endsWith(".md")).sort();
+    files = (await readdir4(dir)).filter((f) => f.endsWith(".md")).sort();
   } catch {
     printError(`no verb recipes found at ${dir}`);
     return EXIT.FAIL;
@@ -2833,7 +3119,7 @@ async function runVerbList(_positionals, _flags) {
     const name = file.replace(/\.md$/, "");
     let purpose = "";
     try {
-      purpose = purposeOf(await readFile9(resolve9(dir, file), "utf-8"));
+      purpose = purposeOf(await readFile10(resolve10(dir, file), "utf-8"));
     } catch {}
     console.log(`  ${name.padEnd(10)} ${purpose}`);
   }
@@ -2855,7 +3141,7 @@ async function runVerb(positionals, _flags) {
     return EXIT.FAIL;
   }
   try {
-    console.log(await readFile9(resolve9(dir, `${name}.md`), "utf-8"));
+    console.log(await readFile10(resolve10(dir, `${name}.md`), "utf-8"));
     return EXIT.OK;
   } catch {
     printError(`unknown verb "${name}" — list the available verbs with \`urbicon verbs\``);
@@ -2917,6 +3203,18 @@ Commands:
                         --src <dir>        Source tree to scan (default ./src).
                         --manifest <path>  Manifest file (default ./design.manifest.md).
                         --json             Emit the scan result as JSON.
+  i18n [check] [dirs…]  Audit @urbicon-ui/i18n usage. check = parity | unused |
+                        hardcoded | audit (all, default). Run under Bun.
+                        --translations <d> Locale-bundle dir(s), comma-separated
+                                           (default src/lib/translations).
+                        --config <path>    i18n.audit.json (default ./i18n.audit.json).
+                        --dynamic-keys <g> Key globs built dynamically (errors.*).
+                        --ignore-keys <g>  Key globs to skip entirely.
+                        --ignore-strings   Hardcoded-string globs to skip.
+                        --base-locale <l>  Parity base (default en).
+                        --json / --strict  Machine-readable / gate advisory too.
+                        Gates on parity errors + used-but-undefined; unused,
+                        hardcoded and parity warnings are advisory.
   verbs                 List the design verbs (recipes over the design loop).
   verb <name>           Print one verb recipe, e.g. "urbicon verb compose".
   help                  Show this help.
@@ -2938,7 +3236,7 @@ async function readVersion() {
   if (!root)
     return "unknown";
   try {
-    const pkg = JSON.parse(await readFile10(resolve10(root, "package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile11(resolve11(root, "package.json"), "utf-8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -2971,6 +3269,8 @@ async function main(argv) {
       return runRecordDecision(positionals, flags);
     case "sync-manifest":
       return runSyncManifest(positionals, flags);
+    case "i18n":
+      return runI18n(positionals, flags);
     case "verbs":
       return runVerbList(positionals, flags);
     case "verb":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urbicon-ui/design",
-  "version": "6.3.7",
+  "version": "6.3.9",
   "description": "The urbicon CLI — version-pinned design validation and design-manifest tooling for projects built with Urbicon UI. Wraps @urbicon-ui/design-engine for editor hooks and CI.",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,7 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "bun build ./src/cli/index.ts --target node --outfile dist/cli.js",
+    "build": "bun build ./src/cli/index.ts --target node --outfile dist/cli.js --external @urbicon-ui/i18n",
     "dev": "bun run --watch src/cli/index.ts",
     "start": "bun run src/cli/index.ts",
     "check": "tsc --noEmit",
@@ -38,8 +38,9 @@
     "test:run": "vitest run"
   },
   "dependencies": {
-    "@urbicon-ui/design-content": "6.3.7",
-    "@urbicon-ui/design-engine": "6.3.7"
+    "@urbicon-ui/design-content": "6.3.9",
+    "@urbicon-ui/design-engine": "6.3.9",
+    "@urbicon-ui/i18n": "6.3.9"
   },
   "devDependencies": {
     "typescript": "^6.0.3",

package/templates/ci-github.yml

@@ -24,3 +24,9 @@ jobs:
       # fails below the floor); add --record to append a drift point to the
       # design.manifest.history.ndjson sidecar.
       - run: bunx urbicon validate src/ --json
+      # i18n audit — gates on translation-parity errors + keys used in code but
+      # missing from the bundles. Unused keys and hardcoded UI strings are
+      # advisory (add --strict to gate them too). Loads .ts locale bundles, so it
+      # needs Bun; point --translations at your bundle dir(s). Drop this step if
+      # the project does not use @urbicon-ui/i18n.
+      - run: bunx urbicon i18n audit src/ --translations src/lib/translations