basalt-ui 1.22.0 → 1.23.1

package/dist/cli/index.js

@@ -160,6 +160,16 @@ function hasBasaltProject(dir) {
     return false;
   }
 }
+function descendantProjects(cwd, depth = 2) {
+  if (depth === 0) return [];
+  const out = [];
+  for (const name of subdirNames(cwd, { skipDotDirs: true })) {
+    const dir = resolve(cwd, name);
+    if (hasBasaltProject(dir)) out.push(dir);
+    else out.push(...descendantProjects(dir, depth - 1));
+  }
+  return out;
+}
 function resolveProjectDir(cwd) {
   const override = process.env["BASALT_CWD"];
   if (override !== void 0 && override.length > 0) {
@@ -167,7 +177,8 @@ function resolveProjectDir(cwd) {
     return { dir, relocatedFrom: dir === cwd ? null : cwd, ambiguous: null };
   }
   if (hasBasaltProject(cwd)) return { dir: cwd, relocatedFrom: null, ambiguous: null };
-  const candidates = collectWorkspacePackages(cwd).packages.filter((pkg) => pkg.dir !== cwd && hasBasaltProject(pkg.dir)).map((pkg) => pkg.dir);
+  const declared = collectWorkspacePackages(cwd).packages.filter((pkg) => pkg.dir !== cwd && hasBasaltProject(pkg.dir)).map((pkg) => pkg.dir);
+  const candidates = declared.length > 0 ? declared : descendantProjects(cwd);
   if (candidates.length === 1) {
     return { dir: candidates[0], relocatedFrom: cwd, ambiguous: null };
   }
@@ -239,7 +250,7 @@ function checkTheme(invocationCwd = process.cwd(), flags = []) {
   const project = resolveProjectDir(invocationCwd);
   if (project.ambiguous !== null) {
     console.error(
-      `\u2716 basalt-ui check-theme: no basalt config at ${invocationCwd}, and ${project.ambiguous.length} workspace packages carry one (${project.ambiguous.map((d) => relativePosix(invocationCwd, d)).join(", ")}) \u2014 run it from one of them, or set BASALT_CWD to pick.`
+      `\u2716 basalt-ui check-theme: no basalt config at ${invocationCwd}, and ${project.ambiguous.length} packages below it carry one (${project.ambiguous.map((d) => relativePosix(invocationCwd, d)).join(", ")}) \u2014 run it from one of them, or set BASALT_CWD to pick.`
     );
     return 1;
   }
@@ -565,8 +576,9 @@ basalt.exemptRules entries (${exemptCount}):`);
     `
 ${live} live, ${dead} dead, ${outOfReach} unjudgeable, ${unaccountable} unaccountable (reported as theme-allow-unscoped by a normal run).`
   );
+  const includes = cfg.include ?? [];
   lines.push(
-    `Scope: the ${scanned.length} file(s) check-theme scans under basalt.roots (${resolveRoots(cfg).join(", ")}). A waiver outside them is not audited \u2014 widen roots to cover it, or accept that nothing polices that file.`
+    `Scope: the ${scanned.length} file(s) check-theme scans \u2014 everything under basalt.roots (${resolveRoots(cfg).join(", ")}), plus each root's sibling index.html and public/ tree, ` + (includes.length === 0 ? "plus anything named in basalt.include (none). " : `plus basalt.include (${includes.join(", ")}). `) + "A waiver in a file none of those reach is not audited \u2014 widen roots, or name it in basalt.include, or accept that nothing polices that file."
   );
   if (dead > 0) {
     lines.push(
@@ -605,9 +617,13 @@ function readFrameworkVersion(pkgRoot) {
     return "0.0.0";
   }
 }
+function basaltBinCommand(install, cwd) {
+  if (install.dir === null) return "bunx basalt-ui";
+  const binDir = resolve(install.dir, "..", ".bin");
+  return `${relativePosix(cwd, binDir).replace(/^\.\//, "")}/basalt-ui`;
+}
 function buildTemplateVars(pkgRoot, cwd, cfg) {
   const install = findBasaltInstall(cwd);
-  const binDir = install.dir === null ? null : resolve(install.dir, "..", ".bin");
   return {
     APP_NAME: readPackageName(cwd),
     BASALT_VERSION: readFrameworkVersion(pkgRoot),
@@ -616,7 +632,7 @@ function buildTemplateVars(pkgRoot, cwd, cfg) {
     ROOTS_GLOBS: resolveRoots(cfg).map(toRootGlob).join(" "),
     OXLINT_PRESET_PATH: shippedAssetPath(install, cwd, "configs/oxlint.json"),
     LEFTHOOK_PRESET_PATH: shippedAssetPath(install, cwd, "configs/lefthook.yml"),
-    BASALT_BIN: binDir === null ? "bunx basalt-ui" : `${relativePosix(cwd, binDir).replace(/^\.\//, "")}/basalt-ui`
+    BASALT_BIN: basaltBinCommand(install, cwd)
   };
 }
 function fillTemplate(tpl, vars) {
@@ -860,6 +876,16 @@ function migrateLegacyOxfmt(cwd, pkgRoot, manifest) {
   const shipped = readSource(pkgRoot, "configs/oxfmt.json");
   if (shipped !== null && onDisk === shipped) unlinkSync(legacyAbs);
 }
+const DESIGN_VERSION_LINE = /^(> Managed by basalt-ui) \(\d+\.\d+\.\d+\)\./m;
+function migrateDesignVersionLine(cwd) {
+  const dest = resolve(cwd, "DESIGN.md");
+  const onDisk = readIfExists(dest);
+  if (onDisk === null || !DESIGN_VERSION_LINE.test(onDisk)) return;
+  writeFileEnsuringDir(
+    dest,
+    onDisk.replace(DESIGN_VERSION_LINE, "$1 \u2014 run `basalt-ui doctor` for the version.")
+  );
+}
 function writeFileEnsuringDir(abs, content) {
   mkdirSync(dirname(abs), { recursive: true });
   writeFileSync(abs, content);
@@ -1246,7 +1272,7 @@ Theme guard hook: add to .claude/settings.json \u2192 hooks.PreToolUse to catch
     "PreToolUse": [
       {
         "matcher": "Write|Edit|MultiEdit",
-        "hooks": [{ "type": "command", "command": "bunx basalt-ui guard-hook" }]
+        "hooks": [{ "type": "command", "command": "${ctx.vars.BASALT_BIN} guard-hook" }]
       }
     ]
   }`
@@ -1277,6 +1303,9 @@ function readOxlintPresetPlugins(pkgRoot) {
     return [];
   }
 }
+function parentInstallAdvice(cwd, parent, verb) {
+  return `This repo's install is at ${relativePosix(cwd, parent)} (${parent}) \u2014 run ${verb} there, or set BASALT_CWD to it.`;
+}
 function findManifestAbove(dir) {
   let current = resolve(dir, "..");
   for (; ; ) {
@@ -1287,10 +1316,15 @@ function findManifestAbove(dir) {
   }
 }
 function sync(opts = {}, invocationCwd = process.cwd()) {
+  const syncFlags = opts.flags ?? [];
+  if (conflictingProfileFlags(syncFlags)) {
+    console.error("basalt-ui sync: --tokens-only and --framework are alternatives \u2014 pass one.");
+    return 1;
+  }
   const project = resolveProjectDir(invocationCwd);
   if (project.ambiguous !== null) {
     console.error(
-      `\u2716 basalt-ui sync: no basalt config at ${invocationCwd}, and ${project.ambiguous.length} workspace packages carry one (${project.ambiguous.map((d) => relativePosix(invocationCwd, d)).join(", ")}) \u2014 run it from one of them, or set BASALT_CWD to pick.`
+      `\u2716 basalt-ui sync: no basalt config at ${invocationCwd}, and ${project.ambiguous.length} packages below it carry one (${project.ambiguous.map((d) => relativePosix(invocationCwd, d)).join(", ")}) \u2014 run it from one of them, or set BASALT_CWD to pick.`
     );
     return 1;
   }
@@ -1300,18 +1334,27 @@ function sync(opts = {}, invocationCwd = process.cwd()) {
       `basalt-ui sync: no basalt config at ${project.relocatedFrom} \u2014 running in ${relativePosix(project.relocatedFrom, cwd)}, where it lives.`
     );
   }
+  if (declaredProfile(readBasaltConfig(cwd), syncFlags) === "tokens-only") {
+    console.log(
+      `basalt-ui sync: ${MANIFEST_PATH}: n/a \u2014 a tokens-only consumer has no scaffold to reconcile. The token layer is refreshed by re-running \`basalt-ui tokens:css\`, and \`tokens:css --check\` is its drift gate. Pass --framework to force the full profile.`
+    );
+    return 0;
+  }
   if (!existsSync(resolve(cwd, MANIFEST_PATH))) {
     const elsewhere = findManifestAbove(cwd);
     const wouldWrite = managedFiles(resolvePeerFlags(cwd, {}), resolvePlacement(cwd)).length;
     console.error(
-      `\u2716 basalt-ui sync: no ${MANIFEST_PATH} at ${cwd} \u2014 refusing to scaffold. \`sync\` refreshes an EXISTING basalt install; creating one is \`basalt-ui init\`'s decision, and continuing here would write ${wouldWrite} managed file(s) into this directory.` + (elsewhere === null ? " No manifest exists at any ancestor either \u2014 run `basalt-ui init` here if this package really is meant to be a consumer." : ` This repo's install is at ${relativePosix(cwd, elsewhere)} (${elsewhere}) \u2014 run sync there, or set BASALT_CWD to it.`)
+      `\u2716 basalt-ui sync: no ${MANIFEST_PATH} at ${cwd} \u2014 refusing to scaffold. \`sync\` refreshes an EXISTING basalt install; creating one is \`basalt-ui init\`'s decision, and continuing here would write ${wouldWrite} managed file(s) into this directory.` + (elsewhere === null ? " No manifest exists at any ancestor either \u2014 run `basalt-ui init` here if this package really is meant to be a consumer." : ` ${parentInstallAdvice(cwd, elsewhere, "sync")}`)
     );
     return 1;
   }
   const rootsState = reconcileRoots(cwd, { write: opts.check !== true });
   const ctx = renderContext(cwd);
   const manifest = readManifest(cwd);
-  if (!opts.check) migrateLegacyOxfmt(cwd, ctx.pkgRoot, manifest);
+  if (!opts.check) {
+    migrateLegacyOxfmt(cwd, ctx.pkgRoot, manifest);
+    migrateDesignVersionLine(cwd);
+  }
   const peers = resolvePeerFlags(cwd, {});
   const placement = resolvePlacement(cwd);
   const files = managedFiles(peers, placement);
@@ -1634,7 +1677,7 @@ function doctor(invocationCwd = process.cwd(), flags = []) {
       `
 basalt-ui doctor \u2014 ${invocationCwd}
 
-  \u2716 no basalt config at ${invocationCwd}, and ${project.ambiguous.length} workspace packages carry one (${project.ambiguous.map((d) => relativePosix(invocationCwd, d)).join(", ")}) \u2014 run doctor from one of them, or set BASALT_CWD to pick.
+  \u2716 no basalt config at ${invocationCwd}, and ${project.ambiguous.length} packages below it carry one (${project.ambiguous.map((d) => relativePosix(invocationCwd, d)).join(", ")}) \u2014 run doctor from one of them, or set BASALT_CWD to pick.
 
 1 hard failure(s), 0 warning(s).
 `
@@ -1670,6 +1713,7 @@ basalt-ui doctor \u2014 ${cwd}
   }
   const manifestAbs = resolve(cwd, MANIFEST_PATH);
   const manifestExists = existsSync(manifestAbs);
+  const parentInstall = manifestExists ? null : findManifestAbove(cwd);
   const profile = inferredProfile(cwd, cfg, flags);
   if (profile === "tokens-only") {
     lines.push(
@@ -1685,6 +1729,10 @@ basalt-ui doctor \u2014 ${cwd}
     pass(`${MANIFEST_PATH}: n/a \u2014 a tokens-only consumer has no scaffold to reconcile`);
   } else if (manifestExists) {
     pass(`${MANIFEST_PATH} exists`);
+  } else if (parentInstall !== null) {
+    fail(
+      `${MANIFEST_PATH} missing here, but this is not an unscaffolded consumer. ${parentInstallAdvice(cwd, parentInstall, "doctor")} \`basalt-ui init\` is NOT the fix: it would scaffold a SECOND consumer beside the real one.`
+    );
   } else {
     fail(`${MANIFEST_PATH} missing \u2014 run \`basalt-ui init\` to scaffold the consumer repo`);
   }
@@ -1780,7 +1828,7 @@ basalt-ui doctor \u2014 ${cwd}
     const oxlintrcRaw = readIfExists(resolve(cwd, ".oxlintrc.json"));
     if (oxlintrcRaw === null) {
       fail(
-        ".oxlintrc.json missing \u2014 the shipped oxlint preset (the basalt/* design rules) is not active. Run `basalt-ui init` to seed it."
+        ".oxlintrc.json missing \u2014 the shipped oxlint preset (the basalt/* design rules) is not active. " + (parentInstall === null ? "Run `basalt-ui init` to seed it." : `${parentInstallAdvice(cwd, parentInstall, "doctor")} The preset is seeded once, at the install \u2014 not per package.`)
       );
     } else {
       const parsed = parseJsonc(oxlintrcRaw);
@@ -1828,30 +1876,43 @@ basalt-ui doctor \u2014 ${cwd}
     );
   } else if (lefthookGate.kind === "absent") {
     warn(
-      `${lefthookGate.file}: \`lefthook dump\` resolves the merged config and NO pre-commit command runs check-theme \u2014 the theme guard is not gating commits. Either add "extends: [${lefthookCorrect}]", or add your own command running \`bunx basalt-ui check-theme\` (with \`root:\` if it must run in a subdirectory).`
+      `${lefthookGate.file}: \`lefthook dump\` resolves the merged config and NO pre-commit command runs check-theme \u2014 the theme guard is not gating commits. Either add "extends: [${lefthookCorrect}]", or add your own command running \`${basaltBinCommand(install, cwd)} check-theme\` (with \`root:\` if it must run in a subdirectory).`
     );
   } else {
     warn(
-      `${lefthookGate.file} names no basalt gate and \`lefthook dump\` could not be run here, so this check cannot tell a missing gate from one wired through an \`include:\` or a remote config it never read \u2014 treat it as advisory. If the guard really is unwired, add "extends: [${lefthookCorrect}]" or your own command running \`bunx basalt-ui check-theme\`.`
+      `${lefthookGate.file} names no basalt gate and \`lefthook dump\` could not be run here, so this check cannot tell a missing gate from one wired through an \`include:\` or a remote config it never read \u2014 treat it as advisory. If the guard really is unwired, add "extends: [${lefthookCorrect}]" or your own command running \`${basaltBinCommand(install, cwd)} check-theme\`.`
     );
   }
   const publicDir = resolve(cwd, "public");
   if (profile === "framework" && existsSync(publicDir)) {
-    const iconFiles = [
-      "favicon.ico",
-      "favicon.svg",
-      "favicon-96x96.png",
-      "apple-touch-icon.png",
-      "web-app-manifest-192x192.png",
-      "web-app-manifest-512x512.png"
-    ];
-    const missingIcons = iconFiles.filter((f) => !existsSync(resolve(publicDir, f)));
-    if (missingIcons.length > 0) {
-      warn(
-        `public/ is missing basaltAppPlugin icon file(s): ${missingIcons.join(", ")} \u2014 generate them (e.g. via realfavicongenerator.net) and place them at the public/ root.`
+    const icons = readAppIconsOption(cwd);
+    if (icons.kind === "none") {
+      pass("basaltAppPlugin is configured with no icons \u2014 nothing to check");
+    } else if (icons.kind === "explicit") {
+      const missing = icons.sources.filter(
+        (src) => !existsSync(resolve(publicDir, src.replace(/^\//, "")))
       );
+      if (missing.length > 0) {
+        warn(
+          `basaltAppPlugin declares icon(s) that are not in public/: ${missing.join(", ")} \u2014 the manifest and the head links will point at a 404. Place them, or drop them from the \`icons\` array.`
+        );
+      } else {
+        pass(
+          `public/ has all ${icons.sources.length} icon file(s) basaltAppPlugin's \`icons\` option names`
+        );
+      }
     } else {
-      pass("public/ has all of basaltAppPlugin's default icon files");
+      const dir = icons.kind === "default" ? icons.dir : null;
+      const iconRoot = dir === null ? publicDir : resolve(publicDir, dir.replace(/^\//, ""));
+      const shown = dir === null ? "public/" : `public/${dir.replace(/^\//, "")}`;
+      const missingIcons = DEFAULT_APP_ICON_FILES.filter((f) => !existsSync(resolve(iconRoot, f)));
+      if (missingIcons.length > 0) {
+        warn(
+          `${shown} is missing basaltAppPlugin icon file(s): ${missingIcons.join(", ")} \u2014 generate them (e.g. via realfavicongenerator.net) and place them at the ${shown} root, or name the icons this app really has via the plugin's \`icons\` array.`
+        );
+      } else {
+        pass(`${shown} has all of basaltAppPlugin's default icon files`);
+      }
     }
   }
   const workspaceWalk = collectWorkspacePackages(cwd);
@@ -1972,6 +2033,68 @@ basalt-ui v${pkgVersion} \u2014 published surface
   console.log("");
   return 0;
 }
+const DEFAULT_APP_ICON_FILES = [
+  "favicon.ico",
+  "favicon.svg",
+  "favicon-96x96.png",
+  "apple-touch-icon.png",
+  "web-app-manifest-192x192.png",
+  "web-app-manifest-512x512.png"
+];
+const VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.cts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.cjs"
+];
+function balancedSpan(text, open) {
+  const pairs = { "(": ")", "{": "}", "[": "]" };
+  const closer = pairs[text[open]];
+  if (closer === void 0) return null;
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === text[open]) depth++;
+    else if (ch === closer) {
+      depth--;
+      if (depth === 0) return text.slice(open, i + 1);
+    }
+  }
+  return null;
+}
+function readAppIconsOption(cwd) {
+  const configPath = VITE_CONFIG_FILES.map((f) => resolve(cwd, f)).find((f) => existsSync(f));
+  if (configPath === void 0) return { kind: "unknown" };
+  const text = readIfExists(configPath);
+  if (text === null) return { kind: "unknown" };
+  const call = text.indexOf("basaltAppPlugin(");
+  if (call === -1) return { kind: "unknown" };
+  const args = balancedSpan(text, call + "basaltAppPlugin".length);
+  if (args === null) return { kind: "unknown" };
+  const key = args.search(/\bicons\s*:/);
+  if (key === -1) return { kind: "default", dir: null };
+  const valueStart = args.indexOf(":", key) + 1;
+  const rest = args.slice(valueStart).trimStart();
+  if (rest.startsWith("false")) return { kind: "none" };
+  const offset = args.length - rest.length;
+  if (rest.startsWith("[")) {
+    const list = balancedSpan(args, offset);
+    if (list === null) return { kind: "unknown" };
+    const sources = [...list.matchAll(/\bsrc\s*:\s*['"`]([^'"`]+)['"`]/g)].map(
+      (m) => m[1]
+    );
+    return sources.length === 0 ? { kind: "none" } : { kind: "explicit", sources };
+  }
+  if (rest.startsWith("{")) {
+    const obj = balancedSpan(args, offset);
+    if (obj === null) return { kind: "unknown" };
+    const dir = /\bdir\s*:\s*['"`]([^'"`]+)['"`]/.exec(obj);
+    return { kind: "default", dir: dir === null ? null : dir[1] };
+  }
+  return { kind: "unknown" };
+}
 function flagValue(flags, name) {
   const i = flags.indexOf(name);
   if (i === -1) return void 0;
@@ -1985,6 +2108,12 @@ function generatedHeader(version, command, flags) {
 /* basalt-ui ${version} \u2014 \`basalt-ui ${invocation}\` */
 `;
 }
+function withoutProvenanceLine(css) {
+  const lines = css.split("\n");
+  if (lines.length < 2) return css;
+  lines[1] = "";
+  return lines.join("\n");
+}
 function normalizeColorFunctions(css) {
   return css.replace(/\b(rgba?|hsla?)\(([^()]*)\)/g, (_match, fn, args) => {
     const parts = args.split(",").map((part) => normalizeCssNumber(part.trim()));
@@ -2019,12 +2148,15 @@ function emitGeneratedCss(content, flags, cwd, command) {
       );
       return 1;
     }
-    if (onDisk === content) {
-      console.log(`\u2713 ${command} --check: ${shown} is up to date.`);
+    if (withoutProvenanceLine(onDisk) === withoutProvenanceLine(content)) {
+      const staleProvenance = onDisk.split("\n")[1] !== content.split("\n")[1];
+      console.log(
+        `\u2713 ${command} --check: ${shown} is up to date.` + (staleProvenance ? " (Its provenance line still names an older basalt-ui; that line is deliberately not gated \u2014 re-run without --check whenever you want it refreshed.)" : "")
+      );
       return 0;
     }
     console.error(
-      `\u2716 ${command} --check: ${shown} differs from what \`basalt-ui ${command}\` emits today (on disk ${onDisk.split("\n").length} lines, emitted ${content.split("\n").length}) \u2014 re-run the same command without --check and commit the result.`
+      `\u2716 ${command} --check: ${shown} differs from what \`basalt-ui ${command}\` emits today (on disk ${onDisk.split("\n").length} lines, emitted ${content.split("\n").length}) \u2014 re-run the same command without --check and commit the result. The \`@generated\` header's provenance line is excluded from this comparison, so a version bump alone never trips it.`
     );
     return 1;
   }
@@ -2205,13 +2337,71 @@ async function guardHook(cwd = process.cwd()) {
   }
   return 0;
 }
-const USAGE = "Usage: basalt-ui <init [--with-router] [--with-query] [--merge-lint] | sync [--force] [--check] |\n                  check-theme [--audit-allows] | check-coverage | info [--json] |\n                  doctor [--tokens-only|--framework] | guard-hook | tokens:css | fonts:css | help>\n\ncheck-theme [--tokens-only|--framework] [--audit-allows]\n  --audit-allows reports instead of scanning: every `theme-allow` annotation and every\n  `basalt.exemptRules` entry, with what each one still suppresses \u2014 proved by re-running the\n  guard with that one waiver neutralized, not by reading its text. Exits 1 on a waiver that\n  suppresses nothing (dead), which is what makes it usable as a CI gate.\n\ntokens:css [--out <path>] [--check] [--selector-attribute <attr> | --selector-class <class>]\n           [--light-class <class>] [--dark-value <v>] [--light-value <v>]\n           [--default-scheme <dark|light|none>] [--media-fallback] [--only <core|all>]\n           [--no-legacy-aliases]\n  Emit the --vx-* stylesheet (stdout unless --out). Defaults reproduce basalt-ui/tokens.css.\n  --selector-class emits `:root.dark` instead of an attribute selector (the Tailwind convention).\n  --check writes nothing and exits 1 when --out differs from what would be emitted (a CI gate).\n  --no-legacy-aliases drops the deprecated camelCase spellings (--vx-accentFill and friends),\n  which are emitted by default as aliases of the canonical kebab-case names.\n\nfonts:css [--out <path>] [--check]\n  Emit the shipped --basalt-font-* stacks as plain CSS \u2014 the typeface half of the token layer,\n  otherwise reachable only by importing styles.css.\n\ndoctor [--tokens-only|--framework]\n  Auto-detects a tokens-only consumer (no manifest + no @mantine/core) and checks only what\n  applies. A check that cannot RUN is reported as SKIPPED and exits non-zero.\n\ncheck-theme / doctor honour BASALT_CWD, and relocate to the single workspace package carrying a\nbasalt config when invoked from a repo root that has none \u2014 several carrying one is ambiguous\nand exits 1 in BOTH. --tokens-only and --framework are alternatives; passing both is an error.\n\nEvery subcommand accepts --help / -h to print this message and exit without running.";
+const COMMAND_FLAGS = {
+  init: ["--with-router", "--with-query", "--merge-lint"],
+  sync: ["--force", "--check", "--tokens-only", "--framework"],
+  "check-theme": ["--audit-allows", "--tokens-only", "--framework"],
+  "check-coverage": [],
+  info: ["--json"],
+  doctor: ["--tokens-only", "--framework"],
+  "guard-hook": [],
+  "tokens:css": [
+    "--out",
+    "--check",
+    "--selector-attribute",
+    "--selector-class",
+    "--light-class",
+    "--dark-value",
+    "--light-value",
+    "--default-scheme",
+    "--media-fallback",
+    "--only",
+    "--no-legacy-aliases"
+  ],
+  "fonts:css": ["--out", "--check"]
+};
+const VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--out",
+  "--selector-attribute",
+  "--selector-class",
+  "--light-class",
+  "--dark-value",
+  "--light-value",
+  "--default-scheme",
+  "--only"
+]);
+function unknownFlag(cmd, flags) {
+  const allowed = COMMAND_FLAGS[cmd];
+  if (allowed === void 0) return null;
+  for (let i = 0; i < flags.length; i++) {
+    const flag = flags[i];
+    if (!flag.startsWith("-")) continue;
+    if (!allowed.includes(flag)) return flag;
+    if (VALUE_FLAGS.has(flag)) i++;
+  }
+  return null;
+}
+const USAGE = "Usage: basalt-ui <--version | init [--with-router] [--with-query] [--merge-lint] |\n                  sync [--force] [--check] [--tokens-only|--framework] |\n                  check-theme [--audit-allows] | check-coverage | info [--json] |\n                  doctor [--tokens-only|--framework] | guard-hook | tokens:css | fonts:css | help>\n\ncheck-theme [--tokens-only|--framework] [--audit-allows]\n  --audit-allows reports instead of scanning: every `theme-allow` annotation and every\n  `basalt.exemptRules` entry, with what each one still suppresses \u2014 proved by re-running the\n  guard with that one waiver neutralized, not by reading its text. Exits 1 on a waiver that\n  suppresses nothing (dead), which is what makes it usable as a CI gate.\n\ntokens:css [--out <path>] [--check] [--selector-attribute <attr> | --selector-class <class>]\n           [--light-class <class>] [--dark-value <v>] [--light-value <v>]\n           [--default-scheme <dark|light|none>] [--media-fallback] [--only <core|all>]\n           [--no-legacy-aliases]\n  Emit the --vx-* stylesheet (stdout unless --out). Defaults reproduce basalt-ui/tokens.css.\n  --selector-class emits `:root.dark` instead of an attribute selector (the Tailwind convention).\n  --check writes nothing and exits 1 when --out differs from what would be emitted (a CI gate).\n  --no-legacy-aliases drops the deprecated camelCase spellings (--vx-accentFill and friends),\n  which are emitted by default as aliases of the canonical kebab-case names.\n\nfonts:css [--out <path>] [--check]\n  Emit the shipped --basalt-font-* stacks as plain CSS \u2014 the typeface half of the token layer,\n  otherwise reachable only by importing styles.css.\n\ndoctor [--tokens-only|--framework]\n  Auto-detects a tokens-only consumer (no manifest + no @mantine/core) and checks only what\n  applies. A check that cannot RUN is reported as SKIPPED and exits non-zero.\n\nsync [--force] [--check] [--tokens-only|--framework]\n  Refreshes an EXISTING install; it never creates one (that is init). A tokens-only consumer\n  has no scaffold to reconcile, so sync reports n/a and exits 0 there \u2014 as doctor does.\n\ncheck-theme / doctor / sync all resolve their project the same way: they honour BASALT_CWD, and\nrelocate to the single package below the cwd carrying a basalt config when invoked from a repo\nroot that has none \u2014 several carrying one is ambiguous and exits 1 in ALL THREE.\n--tokens-only and --framework are alternatives; passing both is an error.\n\nEvery subcommand accepts --help / -h to print this message and exit without running.\n--version / -v prints the resolved package version and exits 0 \u2014 the one command that proves\nWHICH basalt-ui ran, which a `bunx` cache can otherwise make a lie. An unknown command or an\nunrecognized flag exits 1 and names what it did not understand; neither is ever ignored.";
 function run(argv, cwd = process.cwd()) {
   const [cmd, ...flags] = argv;
   if (cmd === "help" || cmd === "--help" || cmd === "-h" || flags.includes("--help") || flags.includes("-h")) {
     console.log(USAGE);
     return 0;
   }
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    console.log(readFrameworkVersion(packageRoot()));
+    return 0;
+  }
+  if (cmd !== void 0) {
+    const bad = unknownFlag(cmd, flags);
+    if (bad !== null) {
+      console.error(
+        `basalt-ui ${cmd}: unrecognized flag '${bad}'. Accepted: ${(COMMAND_FLAGS[cmd] ?? []).join(" ") || "(none)"} --help
+`
+      );
+      return 1;
+    }
+  }
   switch (cmd) {
     case "init":
       return init(cwd, {
@@ -2220,7 +2410,10 @@ function run(argv, cwd = process.cwd()) {
         mergeLint: flags.includes("--merge-lint")
       });
     case "sync":
-      return sync({ force: flags.includes("--force"), check: flags.includes("--check") }, cwd);
+      return sync(
+        { force: flags.includes("--force"), check: flags.includes("--check"), flags },
+        cwd
+      );
     case "check-theme":
       return checkTheme(cwd, flags);
     case "check-coverage":
@@ -2236,6 +2429,10 @@ function run(argv, cwd = process.cwd()) {
     case "fonts:css":
       return fontsCss(flags, cwd);
     default:
+      console.error(
+        cmd === void 0 ? "basalt-ui: no command given.\n" : `basalt-ui: unknown command '${cmd}'.
+`
+      );
       console.error(USAGE);
       return 1;
   }

package/dist/cli/shipped-versions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shipped-versions.test.d.ts.map

package/dist/cli/shipped-versions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipped-versions.test.d.ts","sourceRoot":"","sources":["../../src/cli/shipped-versions.test.ts"],"names":[],"mappings":""}

package/dist/guard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guard/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guard/index.ts"],"names":[],"mappings":"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"}

package/dist/guard/index.js

@@ -108,8 +108,28 @@ const RADIUS_PROP_RE = /\bradius=(?:\{[0-9]+\}|"[0-9]+")/g;
 const MOTION_TRANSITION_NUMERIC = /\btransition\s*=\s*\{\{[^}]*\b(?:duration|stiffness|damping|mass)\s*:\s*-?\d/g;
 const MOTION_TRANSITION_EASE_ARRAY = /\btransition\s*=\s*\{\{[^}]*\bease\s*:\s*\[/g;
 const RAW_CHART_LEGEND_ARRAY = /<ChartLegend\b[^>]*?\bitems\s*=\s*\{\s*\[/g;
-const CHART_ENTRY_POINT_TAG = /<(?:MultiLine|Bars|Donut|DualPanel|Heatmap|ZonedLine|StackedArea|LineSparkline|BarSparkline)\b(?:<[^<>]*>)?(?:=>|[^>])*?>/g;
+const CHART_ENTRY_POINT_TAG = /<(MultiLine|Bars|BandStrip|Donut|DualPanel|Heatmap|MirroredBars|ZonedLine|StackedArea|LineSparkline|BarSparkline)\b(?:<[^<>]*>)?(?:=>|[^>])*?>/g;
 const HAS_ARIA_LABEL_PROP = /\bariaLabel\s*=/;
+const LOCAL_COMPONENT_DEF = /(?:^|[\n;}])\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var)\s+([A-Z]\w*)/g;
+const BASALT_NAMED_IMPORT = /import\s+(?:type\s+)?\{([^}]*)\}\s+from\s+['"]basalt-ui(?:\/[^'"]*)?['"]/g;
+function localComponentNames(codeText) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of codeText.matchAll(LOCAL_COMPONENT_DEF)) out.add(m[1]);
+  return out;
+}
+function basaltImportedNames(codeText) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of codeText.matchAll(BASALT_NAMED_IMPORT)) {
+    for (const raw of m[1].split(",")) {
+      const spec = raw.trim().replace(/^type\s+/, "");
+      if (spec.length === 0) continue;
+      const parts = spec.split(/\s+as\s+/);
+      const bound = parts[parts.length - 1].trim();
+      if (bound.length > 0) out.add(bound);
+    }
+  }
+  return out;
+}
 const RAW_FORM_CONTROL = /<(?:input|select|textarea)\b/g;
 const RAW_FORM_CONTROL_TAG = /<(?:input|select|textarea)\b(?:=>|[^>])*?>/g;
 const STYLES_INPUT_PART = /\bstyles\s*=\s*\{\{\s*input\s*:\s*\{([^}]*)\}/g;
@@ -250,10 +270,23 @@ function parseAllowAnnotation(rest, scope) {
   return { rules, unknownRules, hasReason: reason.length >= MIN_ALLOW_REASON_LENGTH, scope };
 }
 const MAX_CSS_CONTINUATION_LINES = 8;
-const MAX_COMMENT_BLOCK_LINES = 8;
+function commentBlockEnd(lines, index, tokenAt, syntax) {
+  const line = lines[index] ?? "";
+  if (syntax === "ts" && /\/\/\s*$/.test(line.slice(0, tokenAt))) return index;
+  const closer = syntax === "markup" ? "-->" : "*/";
+  if (line.slice(tokenAt).includes(closer)) return index;
+  for (let ahead = index + 1; ahead < lines.length; ahead++) {
+    if ((lines[ahead] ?? "").includes(closer)) return ahead;
+  }
+  return index;
+}
 const COMMENT_OPENER_BEFORE = /(?:\/\/|\/\*|<!--)\s*$/;
 const COMMENT_ONLY_LINE = /^\s*(?:\{\s*\/\*|\/\/|\/\*|\*|<!--)/;
 const JSX_COMMENT_CLOSE = /\*\/\s*\}\s*$/;
+function isCommentOnly(raw, stripped) {
+  const code = stripped.trim();
+  return code === "" || COMMENT_ONLY_LINE.test(raw) || code === "}" && JSX_COMMENT_CLOSE.test(raw);
+}
 const ANNOTATION_PREFIX = /(?:^|\/\/|\/\*\*?|<!--|^\s*\*)\s*$/;
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -273,7 +306,7 @@ function collectAllowAnnotations(lines, codeLines, allowComment, syntax) {
     list.push(annotation);
     byLine.set(index, list);
   };
-  const record = (index, annotation, trailing) => {
+  const record = (index, annotation, trailing, tokenAt) => {
     declared.push({ line: index + 1, annotation });
     if (annotation.scope === "file") {
       fileScoped.push(annotation);
@@ -281,11 +314,14 @@ function collectAllowAnnotations(lines, codeLines, allowComment, syntax) {
     }
     add(index, annotation);
     if (!trailing) {
-      for (let ahead = 1; ahead <= MAX_COMMENT_BLOCK_LINES; ahead++) {
-        const raw = lines[index + ahead] ?? "";
-        add(index + ahead, annotation);
-        if (raw.trim() !== "" && (codeLines[index + ahead] ?? "").trim() !== "") break;
+      const closesAt = commentBlockEnd(lines, index, tokenAt, syntax);
+      for (let ahead = 1; index + ahead < lines.length; ahead++) {
+        const at = index + ahead;
+        add(at, annotation);
+        if (at <= closesAt) continue;
+        const raw = lines[at] ?? "";
         if (raw.trim() === "") break;
+        if (!isCommentOnly(raw, codeLines[at] ?? "")) break;
       }
       return;
     }
@@ -301,11 +337,15 @@ function collectAllowAnnotations(lines, codeLines, allowComment, syntax) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i] ?? "";
     const stripped = codeLines[i] ?? "";
-    const code = stripped.trim();
-    const isCommentOnlyLine = code === "" || COMMENT_ONLY_LINE.test(line) || code === "}" && JSX_COMMENT_CLOSE.test(line);
+    const isCommentOnlyLine = isCommentOnly(line, stripped);
     if (syntax === "markup") {
       for (const m of line.matchAll(jsonKey)) {
-        record(i, parseAllowAnnotation(m[2] ?? "", m[1] === void 0 ? "line" : "file"), false);
+        record(
+          i,
+          parseAllowAnnotation(m[2] ?? "", m[1] === void 0 ? "line" : "file"),
+          false,
+          m.index
+        );
       }
     }
     for (const m of line.matchAll(token)) {
@@ -317,7 +357,8 @@ function collectAllowAnnotations(lines, codeLines, allowComment, syntax) {
       record(
         i,
         parseAllowAnnotation(rest, m[1] === void 0 ? "line" : "file"),
-        !isCommentOnlyLine
+        !isCommentOnlyLine,
+        at
       );
     }
   }
@@ -943,15 +984,21 @@ function checkSource(text, relPath, cfg) {
       });
     }
   }
-  if (GUARD_RULES["unframed-chart"].enabled(cfg) && ruleApplies("unframed-chart", relPath)) {
+  const unframedChartRuns = GUARD_RULES["unframed-chart"].enabled(cfg) && ruleApplies("unframed-chart", relPath);
+  const ariaLabelRuns = GUARD_RULES["chart-missing-aria-label"].enabled(cfg) && ruleApplies("chart-missing-aria-label", relPath);
+  const localNames = unframedChartRuns || ariaLabelRuns ? localComponentNames(codeText) : /* @__PURE__ */ new Set();
+  const basaltNames = unframedChartRuns || ariaLabelRuns ? basaltImportedNames(codeText) : /* @__PURE__ */ new Set();
+  const isShippedTag = (tag) => basaltNames.has(tag) || !localNames.has(tag);
+  if (unframedChartRuns && isShippedTag("ChartLegend")) {
     for (const m of codeText.matchAll(RAW_CHART_LEGEND_ARRAY)) {
       const lineNo = codeText.slice(0, (m.index ?? 0) + m[0].length).split("\n").length;
       push("unframed-chart", lineNo, "items={[");
     }
   }
-  if (GUARD_RULES["chart-missing-aria-label"].enabled(cfg) && ruleApplies("chart-missing-aria-label", relPath)) {
+  if (ariaLabelRuns) {
     for (const m of codeText.matchAll(CHART_ENTRY_POINT_TAG)) {
       const tagText = m[0];
+      if (!isShippedTag(m[1])) continue;
       if (HAS_ARIA_LABEL_PROP.test(tagText)) continue;
       const startLine = codeText.slice(0, m.index ?? 0).split("\n").length;
       const endLine = startLine + (tagText.split("\n").length - 1);