basalt-ui 1.20.0 → 1.22.0

package/dist/cli/waiver-audit.test.d.ts

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

package/dist/cli/waiver-audit.test.d.ts.map

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

package/dist/guard/index.d.ts

@@ -8,6 +8,37 @@ import type { Finding, GuardConfig, GuardKind, GuardSeverity } from './types.js'
 export type { Finding, GuardConfig, GuardKind, GuardSeverity };
 /** Shared default config — CLI and tests import this to avoid duplication. */
 export declare const DEFAULT_GUARD_CONFIG: GuardConfig;
+/** One `exemptRules` entry that suppressed nothing, and why — see {@link unmatchedExemptPatterns}. */
+export type UnmatchedExemptPattern = {
+    readonly kind: string;
+    readonly pattern: string;
+    readonly reason: 'unknown-kind' | 'no-match';
+};
+/**
+ * Every `exemptRules` entry that matched no scanned file, so a run can say so instead of passing.
+ *
+ * An exemption is a claim ("this rule does not apply here"), and a claim that resolves to nothing is
+ * not harmless — it reads as coverage in a config review while enforcing exactly as much as an empty
+ * object. rollhook's `["public/site.webmanifest"]` was correct, matched nothing under the
+ * segments-only matcher, and reported no diagnostic; the finding it was written for kept failing the
+ * build with the config sitting right there looking like the answer. A silent no-op exemption is the
+ * same false-green family as a guard that reports green while enforcing nothing.
+ *
+ * Called once per run by the CLI with every relative path it scanned. Kind keys are checked too: a
+ * typo'd kind name is an exemption for a rule that does not exist.
+ */
+export declare function unmatchedExemptPatterns(cfg: GuardConfig, scannedRelPaths: readonly string[]): UnmatchedExemptPattern[];
+/**
+ * The oxlint plugin's rule ids. Not guard kinds — they can never suppress a `checkSource` finding —
+ * but they ARE valid ids in a `theme-allow`, so an annotation scoped to one of them must parse as
+ * accountable rather than be reported as unscoped. Kept as a literal list because the plugin is a
+ * standalone `.js` file this module must not import (see the plugin's own header).
+ *
+ * Exported for `check-theme --audit-allows`: an annotation naming one of these is outside the
+ * guard's reach, and judging it needs a `oxlint` run rather than a `checkSource` one. Keep in step
+ * with the plugin's own `KNOWN_RULE_IDS`; `configs/oxlint-plugin.test.ts` asserts the two agree.
+ */
+export declare const PLUGIN_RULE_IDS: ReadonlySet<string>;
 /**
  * The exact first line of every stylesheet the CLI emits — the contract between `basalt-ui
  * tokens:css` / `fonts:css` and this scanner, and the single source of truth for it (`src/cli`
@@ -178,13 +209,13 @@ export declare const GUARD_RULES: {
     readonly 'theme-allow-unscoped': {
         readonly kind: "theme-allow-unscoped";
         readonly pattern: RegExp;
-        readonly message: "theme-allow without a usable rule id and a reason. Write `theme-allow <rule-id> — <why>`: the id scopes the exception to that one kind (a bare comment waives EVERY kind on the line, including ones added later), and the reason is what makes it reviewable in a diff. An id that names no rule is a typo, not a blanket waiver — it suppresses nothing.";
+        readonly message: "theme-allow without a usable rule id and a reason. Write `theme-allow <rule-id> — <why>`: the id scopes the exception to that one kind (a bare comment waives EVERY kind on the line, including ones added later), and the reason is what makes it reviewable in a diff. An id that names no rule is a typo, not a blanket waiver — it suppresses nothing. `theme-allow-file <rule-id> — <why>` declares the whole file, and must name its ids: a bare one waives nothing.";
     };
     readonly 'surface-shadow-override': {
         readonly kind: "surface-shadow-override";
         readonly pattern: RegExp;
         readonly enabled: (cfg: GuardConfig) => boolean;
-        readonly message: "Token-composed boxShadow that REPLACES card depth — a card whose shadow drops --vx-shadow-card is the one card in the app with no depth. Compose with it (`${VX.shadowCard}, <your ring>`) rather than instead of it.";
+        readonly message: "Token-composed boxShadow that REPLACES surface depth — a card whose shadow drops --vx-shadow-card is the one card in the app with no depth. Compose with the depth token for its tier (`${VX.shadowCard}, <your ring>`; a fixed/floating surface wants --vx-shadow-overlay) rather than instead of it.";
     };
     readonly 'css-raw-surface': {
         readonly kind: "css-raw-surface";
@@ -206,6 +237,31 @@ export declare const GUARD_RULES: {
         readonly message: "Raw font-size literal — route through VX.text.* (numbers) / --vx-text-* (CSS), or the Mantine fz token. Same rule the oxlint plugin enforces as basalt/no-raw-font-size; this is the half a check-theme-only CI can see.";
     };
 };
+/**
+ * The one-line remedy for `kind`, as a report reads it: `raw-hex: Route color through VX.* / …`.
+ *
+ * The registry has always carried a remedy per kind; `check-theme`'s `Fix:` epilogue read a
+ * hand-duplicated subset instead, and the subset was missing every kind added at 1.20.0. Since all
+ * five of those ship `warn` under grace, the findings whose whole argument is "this looks correct
+ * and is not" arrived with no argument at all — just "add a `theme-allow`", which reads as advice to
+ * waive. Sourcing the epilogue from here retires the duplicate rather than extending it.
+ */
+export declare function guardKindRemedy(kind: GuardKind): string;
+/**
+ * How to waive a finding **in this file's syntax** — the closer a report prints under `Fix:`.
+ *
+ * `check-theme` printed one closer for every file class, and from 1.20.0 (when the scan reached
+ * `.webmanifest` / `.json`) it prescribed a `theme-allow` comment to files that cannot hold a
+ * comment. Two consumers read that, found no route, and fell back to a blanket `exemptRules` entry —
+ * the un-reviewable shape the release was spent retiring.
+ *
+ * A manifest gets the sharper answer first, because a hex there can never be *right*: a manifest
+ * cannot reference a CSS custom property, so the value is a hand-copy of a token that drifts the day
+ * the palette moves (which is exactly what both consumers found — two dead colours). The remedy is
+ * to stop hand-writing the file: `basaltAppPlugin` emits it from `SURFACE.bg`. The annotation is the
+ * fallback for a manifest basalt does not generate.
+ */
+export declare function guardWaiverHint(relPath: string): string;
 /**
  * Scan ONE file's text for theme-guard violations. Pure: same (text, relPath, cfg) → same Finding[].
  * No FS, no walk, no console. The 3 dynamic regexes (forbiddenAccent, spacing, radius) are derived
@@ -217,4 +273,60 @@ export declare const GUARD_RULES: {
  * if (findings.some((f) => f.kind === 'raw-hex')) { ... }
  */
 export declare function checkSource(text: string, relPath: string, cfg: GuardConfig): Finding[];
+/**
+ * One `theme-allow` annotation as WRITTEN, classified by whose reach its ids fall in.
+ *
+ * `guardKinds` is what `checkSource` can judge by re-running itself with the annotation
+ * neutralized. `pluginRules` is what only an `oxlint` run can judge. `unknownRules` names no rule
+ * at all. All three empty with `bare: true` is the legacy blanket form.
+ */
+export type AllowAnnotationSite = {
+    /** 1-based line the annotation is written on. */
+    readonly line: number;
+    /** `'file'` for the `theme-allow-file` declaration form, `'line'` otherwise. */
+    readonly scope: 'line' | 'file';
+    /** Every id the annotation names that resolves to a real rule, `basalt/` prefix stripped. */
+    readonly rules: readonly string[];
+    /** The subset of `rules` `checkSource` owns. */
+    readonly guardKinds: readonly GuardKind[];
+    /** The subset of `rules` the oxlint plugin owns — outside `checkSource`'s reach. */
+    readonly pluginRules: readonly string[];
+    /** Words that occupied the id slot but name no rule. Their presence makes the parse fail closed. */
+    readonly unknownRules: readonly string[];
+    /** A written reason follows the ids. */
+    readonly hasReason: boolean;
+    /** The legacy blanket form — no ids at all, known or unknown. Only covers anything at line scope. */
+    readonly bare: boolean;
+    /** The source line, verbatim. */
+    readonly text: string;
+};
+/**
+ * Every allow annotation in one file, with the ids it names classified by reach.
+ *
+ * Pure, and it shares `collectAllowAnnotations` with {@link checkSource} — so a caller enumerating
+ * annotations sees exactly the set the scan honours, rather than a second regex that can drift from
+ * it. `--audit-allows` carried such a mirror and it was already one alternation behind.
+ *
+ * A file-scoped declaration appears once, at the line it is written on.
+ *
+ * @example
+ * for (const site of findAllowAnnotations(text, rel, cfg)) {
+ *   if (site.pluginRules.length > 0) probeWithOxlint(neutralizeAllowAnnotation(text, site.line, cfg))
+ * }
+ */
+export declare function findAllowAnnotations(text: string, relPath: string, cfg: GuardConfig): AllowAnnotationSite[];
+/** The token a neutralized annotation is rewritten to. Shares no substring with `theme-allow`. */
+export declare const NEUTRALIZED_ALLOW_TOKEN = "basalt-audit-neutralized";
+/**
+ * `text` with the allow token on ONE (1-based) line rewritten to {@link NEUTRALIZED_ALLOW_TOKEN},
+ * leaving every other annotation intact.
+ *
+ * The probe half of an audit: re-scan the result and the findings that appear are exactly what that
+ * one annotation suppresses. Shipped rather than left to each caller so the guard probe and the
+ * oxlint probe neutralize identically — a `--audit-allows` verdict that differs between the two
+ * halves by a substitution detail is worse than no verdict.
+ *
+ * A line with no token comes back unchanged.
+ */
+export declare function neutralizeAllowAnnotation(text: string, line: number, cfg: GuardConfig): string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guard/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE7E,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA;AAuW9D,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,EAAE,WAoBlC,CAAA;AAuVD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,gGACwD,CAAA;AA8F1F;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,SAAS,CAqB5D,CAAA;AA2NF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;gCA0BL,WAAW;;;;;;;gCAcX,WAAW;;;;;gCAMX,WAAW;;;;;;;gCAaX,WAAW;;;;;;;gCAQX,WAAW;;;;;;gCAOX,WAAW;;;;;;;gCASX,WAAW;;;;;;gCAOX,WAAW;;;;;;;gCAaX,WAAW;;;;;;gCAMX,WAAW;;;;;;;gCAaX,WAAW;;;;;;;gCAUX,WAAW;;;;;;;gCAUX,WAAW;;;;;;;gCASX,WAAW;;;;;;;gCASX,WAAW;;;;;;;gCAUX,WAAW;;;;;;;;;;;;gCAgBX,WAAW;;;;;;gCAOX,WAAW;;;;;;;gCASX,WAAW;;;;;;;;;CAWmB,CAAA;AAUjD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,EAAE,CAyVtF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guard/index.ts"],"names":[],"mappings":"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"}

package/dist/guard/index.js

@@ -54,6 +54,38 @@ const INLINE_SPACING = new RegExp(
   "g"
 );
 const MICRO_SPACING_CEILING_PX = 10;
+const STYLE_ATTRIBUTE_OPENER = /\b(?:style|styles|sx|css)\s*=\s*\{?\s*$/;
+const OBJECT_DECLARATION = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::([^=]*))?=\s*$/;
+const STYLE_OBJECT_NAME = /(?:Style|Styles|Css)$|^(?:style|styles|css|sx)$/;
+const STYLE_OBJECT_TYPE = /\bCSS(?:Properties|Object)\b|\bStyle(?:s|Prop)?\b/;
+const STYLE_BOUND_IDENTIFIER = /\b(?:style|styles|sx|css)=\{\s*([A-Za-z_$][\w$]*)\s*\}/g;
+const NESTED_OBJECT_KEY = /(?:[\w$]+|'[^']*'|"[^"]*"|\[[^\]]*\])\s*:\s*$/;
+const MAX_STYLE_CONTEXT_SCAN = 4e3;
+function isStyleObjectContext(codeText, at, styleIdentifiers) {
+  let depth = 0;
+  const stop = Math.max(0, at - MAX_STYLE_CONTEXT_SCAN);
+  for (let i = at - 1; i >= stop; i--) {
+    const ch = codeText[i];
+    if (ch === "}") depth++;
+    else if (ch === "{") {
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      const before = codeText.slice(Math.max(0, i - 120), i);
+      if (STYLE_ATTRIBUTE_OPENER.test(before)) return true;
+      const declaration = OBJECT_DECLARATION.exec(before);
+      if (declaration !== null) {
+        const [, name = "", annotation = ""] = declaration;
+        return STYLE_OBJECT_NAME.test(name) || STYLE_OBJECT_TYPE.test(annotation) || styleIdentifiers.has(name);
+      }
+      if (before.endsWith("{")) continue;
+      if (NESTED_OBJECT_KEY.test(before)) continue;
+      return false;
+    }
+  }
+  return false;
+}
 const ROOT_FONT_SIZE_PX = 16;
 function isSubScaleCssSpacing(line, matchIndex) {
   const colon = line.indexOf(":", matchIndex);
@@ -129,13 +161,52 @@ const EXEMPT_RULE_ALIASES = {
   "surface-shadow-override": "raw-surface",
   "css-raw-surface": "raw-surface"
 };
+function normalizeExemptPattern(pattern) {
+  return pattern.trim().replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function exemptGlobToRegExp(pattern) {
+  const body = pattern.split(/(\*\*\/|\*\*|\*|\?)/).map((part) => {
+    if (part === "**/") return "(?:.*/)?";
+    if (part === "**") return ".*";
+    if (part === "*") return "[^/]*";
+    if (part === "?") return "[^/]";
+    return part.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }).join("");
+  return new RegExp(`^${body}$`);
+}
+function exemptPatternMatches(pattern, relPath) {
+  const p = normalizeExemptPattern(pattern);
+  if (p === "") return false;
+  if (relPath === p || relPath.startsWith(`${p}/`)) return true;
+  if (/[*?]/.test(p)) {
+    const re = exemptGlobToRegExp(p);
+    if (re.test(relPath)) return true;
+    if (!p.includes("/") && re.test(relPath.split("/").pop() ?? "")) return true;
+    return false;
+  }
+  return !p.includes("/") && relPath.split("/").includes(p);
+}
 function isRuleExempt(kind, relPath, exemptRules) {
   const alias = EXEMPT_RULE_ALIASES[kind];
   if (alias !== void 0 && isRuleExempt(alias, relPath, exemptRules)) return true;
   const patterns = exemptRules?.[kind];
   if (patterns === void 0 || patterns.length === 0) return false;
-  const segments = relPath.split("/");
-  return patterns.some((pattern) => segments.includes(pattern.replace(/\/$/, "")));
+  return patterns.some((pattern) => exemptPatternMatches(pattern, relPath));
+}
+function unmatchedExemptPatterns(cfg, scannedRelPaths) {
+  const out = [];
+  for (const [kind, patterns] of Object.entries(cfg.exemptRules ?? {})) {
+    const known = Object.hasOwn(GUARD_RULES, kind);
+    for (const pattern of patterns ?? []) {
+      if (!known) {
+        out.push({ kind, pattern, reason: "unknown-kind" });
+        continue;
+      }
+      if (scannedRelPaths.some((relPath) => exemptPatternMatches(pattern, relPath))) continue;
+      out.push({ kind, pattern, reason: "no-match" });
+    }
+  }
+  return out;
 }
 const PLUGIN_RULE_IDS = /* @__PURE__ */ new Set([
   "no-raw-font-size",
@@ -157,7 +228,7 @@ const PLUGIN_RULE_IDS = /* @__PURE__ */ new Set([
   "ai-sdk-major"
 ]);
 const MIN_ALLOW_REASON_LENGTH = 4;
-function parseAllowAnnotation(rest) {
+function parseAllowAnnotation(rest, scope) {
   const rules = [];
   const unknownRules = [];
   let remainder = rest.replace(/^[\s,]+/, "");
@@ -176,51 +247,89 @@ function parseAllowAnnotation(rest) {
     inIdSlot = /^\s*,/.test(after);
   }
   const reason = remainder.replace(/^(?:—|–|-{1,2}|:)\s*/, "").trim();
-  return { rules, unknownRules, hasReason: reason.length >= MIN_ALLOW_REASON_LENGTH };
+  return { rules, unknownRules, hasReason: reason.length >= MIN_ALLOW_REASON_LENGTH, scope };
 }
 const MAX_CSS_CONTINUATION_LINES = 8;
+const MAX_COMMENT_BLOCK_LINES = 8;
 const COMMENT_OPENER_BEFORE = /(?:\/\/|\/\*|<!--)\s*$/;
 const COMMENT_ONLY_LINE = /^\s*(?:\{\s*\/\*|\/\/|\/\*|\*|<!--)/;
-const ANNOTATION_PREFIX = /(?:^|\/\/|\/\*|<!--|^\s*\*)\s*$/;
+const JSX_COMMENT_CLOSE = /\*\/\s*\}\s*$/;
+const ANNOTATION_PREFIX = /(?:^|\/\/|\/\*\*?|<!--|^\s*\*)\s*$/;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function allowTokenRe(allowComment) {
+  return new RegExp(`${escapeRegExp(allowComment)}(-file)?(?![\\w-])`, "g");
+}
+function jsonAllowKeyRe(allowComment) {
+  return new RegExp(`"basalt:${escapeRegExp(allowComment)}(-file)?"\\s*:\\s*"([^"]*)"`, "g");
+}
 function collectAllowAnnotations(lines, codeLines, allowComment, syntax) {
   const byLine = /* @__PURE__ */ new Map();
+  const fileScoped = [];
   const declared = [];
   const add = (index, annotation) => {
     const list = byLine.get(index) ?? [];
     list.push(annotation);
     byLine.set(index, list);
   };
+  const record = (index, annotation, trailing) => {
+    declared.push({ line: index + 1, annotation });
+    if (annotation.scope === "file") {
+      fileScoped.push(annotation);
+      return;
+    }
+    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;
+        if (raw.trim() === "") break;
+      }
+      return;
+    }
+    if (syntax !== "css") return;
+    for (let back = 1; back <= MAX_CSS_CONTINUATION_LINES; back++) {
+      const previous = (codeLines[index - back] ?? "").trim();
+      if (previous === "" || /[;{}]$/.test(previous)) break;
+      add(index - back, annotation);
+    }
+  };
+  const token = allowTokenRe(allowComment);
+  const jsonKey = jsonAllowKeyRe(allowComment);
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i] ?? "";
     const stripped = codeLines[i] ?? "";
-    const isCommentOnlyLine = stripped.trim() === "" || COMMENT_ONLY_LINE.test(line);
-    let from = 0;
-    for (; ; ) {
-      const at = line.indexOf(allowComment, from);
-      if (at === -1) break;
-      from = at + allowComment.length;
-      if (stripped[at] !== " " && !COMMENT_OPENER_BEFORE.test(line.slice(0, at))) continue;
-      const annotation = parseAllowAnnotation(line.slice(from));
-      if (ANNOTATION_PREFIX.test(line.slice(0, at))) declared.push({ line: i + 1, annotation });
-      add(i, annotation);
-      if (isCommentOnlyLine) {
-        add(i + 1, annotation);
-        continue;
-      }
-      if (syntax !== "css") continue;
-      for (let back = 1; back <= MAX_CSS_CONTINUATION_LINES; back++) {
-        const previous = (codeLines[i - back] ?? "").trim();
-        if (previous === "" || /[;{}]$/.test(previous)) break;
-        add(i - back, annotation);
+    const code = stripped.trim();
+    const isCommentOnlyLine = code === "" || COMMENT_ONLY_LINE.test(line) || code === "}" && JSX_COMMENT_CLOSE.test(line);
+    if (syntax === "markup") {
+      for (const m of line.matchAll(jsonKey)) {
+        record(i, parseAllowAnnotation(m[2] ?? "", m[1] === void 0 ? "line" : "file"), false);
       }
     }
+    for (const m of line.matchAll(token)) {
+      const at = m.index;
+      const before = line.slice(0, at);
+      if (stripped[at] !== " " && !COMMENT_OPENER_BEFORE.test(before)) continue;
+      if (!ANNOTATION_PREFIX.test(before)) continue;
+      const rest = line.slice(at + m[0].length);
+      record(
+        i,
+        parseAllowAnnotation(rest, m[1] === void 0 ? "line" : "file"),
+        !isCommentOnlyLine
+      );
+    }
   }
-  return { waivers: byLine, declared };
+  return { waivers: byLine, fileScoped, declared };
+}
+function annotationCovers(annotation, kind) {
+  if (annotation.rules.includes(kind)) return true;
+  if (annotation.scope === "file") return false;
+  return annotation.rules.length === 0 && annotation.unknownRules.length === 0;
 }
 function annotationsCover(annotations, kind) {
-  return (annotations ?? []).some(
-    (a) => a.rules.length === 0 && a.unknownRules.length === 0 || a.rules.includes(kind)
-  );
+  return (annotations ?? []).some((a) => annotationCovers(a, kind));
 }
 function guardSyntaxFor(relPath) {
   if (relPath.endsWith(".css")) return "css";
@@ -606,14 +715,14 @@ const GUARD_RULES = {
     kind: "theme-allow-unscoped",
     pattern: /theme-allow/,
     // handled inline (annotation pass); entry keeps the registry complete
-    message: "theme-allow without a usable rule id and a reason. Write `theme-allow <rule-id> \u2014 <why>`: the id scopes the exception to that one kind (a bare comment waives EVERY kind on the line, including ones added later), and the reason is what makes it reviewable in a diff. An id that names no rule is a typo, not a blanket waiver \u2014 it suppresses nothing."
+    message: "theme-allow without a usable rule id and a reason. Write `theme-allow <rule-id> \u2014 <why>`: the id scopes the exception to that one kind (a bare comment waives EVERY kind on the line, including ones added later), and the reason is what makes it reviewable in a diff. An id that names no rule is a typo, not a blanket waiver \u2014 it suppresses nothing. `theme-allow-file <rule-id> \u2014 <why>` declares the whole file, and must name its ids: a bare one waives nothing."
   },
   "surface-shadow-override": {
     kind: "surface-shadow-override",
     pattern: SHADOW_DECL,
     // handled inline (value is judged, not just matched)
     enabled: (cfg) => cfg.rawSurface,
-    message: "Token-composed boxShadow that REPLACES card depth \u2014 a card whose shadow drops --vx-shadow-card is the one card in the app with no depth. Compose with it (`${VX.shadowCard}, <your ring>`) rather than instead of it."
+    message: "Token-composed boxShadow that REPLACES surface depth \u2014 a card whose shadow drops --vx-shadow-card is the one card in the app with no depth. Compose with the depth token for its tier (`${VX.shadowCard}, <your ring>`; a fixed/floating surface wants --vx-shadow-overlay) rather than instead of it."
   },
   "css-raw-surface": {
     kind: "css-raw-surface",
@@ -638,6 +747,19 @@ const GUARD_RULES = {
     message: "Raw font-size literal \u2014 route through VX.text.* (numbers) / --vx-text-* (CSS), or the Mantine fz token. Same rule the oxlint plugin enforces as basalt/no-raw-font-size; this is the half a check-theme-only CI can see."
   }
 };
+function guardKindRemedy(kind) {
+  return `${kind}: ${GUARD_RULES[kind].message}`;
+}
+const JSON_FAMILY_FILE = /\.(?:webmanifest|json)$/;
+function guardWaiverHint(relPath) {
+  if (relPath.endsWith(".webmanifest")) {
+    return 'A manifest cannot reference a CSS variable, so a hex here is a hand-copy that drifts: let basaltAppPlugin emit it (`manifest: { \u2026 }` in vite.config.ts) instead of hand-writing it. For a manifest basalt does not generate, declare the exception with a `"basalt:theme-allow-file": "raw-hex \u2014 <why>"` member.';
+  }
+  if (JSON_FAMILY_FILE.test(relPath)) {
+    return 'JSON has no comments \u2014 declare a deliberate exception with a `"basalt:theme-allow-file": "<rule-id> \u2014 <why>"` member.';
+  }
+  return "Add a `theme-allow <rule-id> \u2014 <why>` comment for a deliberate exception (`theme-allow-file` declares the whole file).";
+}
 function ruleApplies(kind, relPath) {
   const appliesTo = GUARD_RULES[kind].appliesTo;
   return appliesTo === void 0 || appliesTo(relPath);
@@ -655,8 +777,19 @@ function checkSource(text, relPath, cfg) {
   const syntax = guardSyntaxFor(relPath);
   const codeText = syntax === "markup" ? stripMarkupComments(text) : stripComments(text, syntax);
   const codeLines = codeText.split("\n");
-  const { waivers, declared } = collectAllowAnnotations(lines, codeLines, cfg.allowComment, syntax);
-  const isAllowed = (line, kind) => annotationsCover(waivers.get(line - 1), kind);
+  const { waivers, fileScoped, declared } = collectAllowAnnotations(
+    lines,
+    codeLines,
+    cfg.allowComment,
+    syntax
+  );
+  const fileWaived = /* @__PURE__ */ new Set();
+  for (const annotation of fileScoped) {
+    for (const rule of annotation.rules) {
+      if (Object.hasOwn(GUARD_RULES, rule)) fileWaived.add(rule);
+    }
+  }
+  const isAllowed = (line, kind) => fileWaived.has(kind) || annotationsCover(waivers.get(line - 1), kind);
   const isAllowedInRange = (start, end, kind) => {
     for (let n = start; n <= end; n++) if (isAllowed(n, kind)) return true;
     return false;
@@ -678,6 +811,14 @@ function checkSource(text, relPath, cfg) {
     });
   }
   const rawHtmlLayoutLines = /* @__PURE__ */ new Set();
+  const lineStarts = [];
+  for (let n = 0, i = 0; i < codeLines.length; i++) {
+    lineStarts.push(n);
+    n += (codeLines[i] ?? "").length + 1;
+  }
+  const styleIdentifiers = new Set(
+    [...codeText.matchAll(STYLE_BOUND_IDENTIFIER)].map((m) => m[1] ?? "")
+  );
   for (let i = 0; i < lines.length; i++) {
     const line = codeLines[i] ?? "";
     for (const m of line.matchAll(GUARD_RULES["raw-hex"].pattern)) {
@@ -751,6 +892,9 @@ function checkSource(text, relPath, cfg) {
     if (GUARD_RULES["inline-spacing"].enabled(cfg)) {
       for (const m of line.matchAll(GUARD_RULES["inline-spacing"].pattern)) {
         if (syntax === "css" && isSubScaleCssSpacing(line, m.index)) continue;
+        const hasUnit = /^[a-z%]/.test(line.slice(m.index + m[0].length));
+        if (syntax === "ts" && !hasUnit && !isStyleObjectContext(codeText, lineStarts[i] + m.index, styleIdentifiers))
+          continue;
         push("inline-spacing", i + 1, m[0]);
       }
     }
@@ -855,10 +999,49 @@ function checkSource(text, relPath, cfg) {
     severity: severityOf(f.kind, cfg)
   }));
 }
+function findAllowAnnotations(text, relPath, cfg) {
+  const lines = text.split("\n");
+  const syntax = guardSyntaxFor(relPath);
+  const codeText = syntax === "markup" ? stripMarkupComments(text) : stripComments(text, syntax);
+  const { declared } = collectAllowAnnotations(
+    lines,
+    codeText.split("\n"),
+    cfg.allowComment,
+    syntax
+  );
+  return declared.map(({ line, annotation }) => ({
+    line,
+    scope: annotation.scope,
+    rules: [...annotation.rules],
+    guardKinds: annotation.rules.filter((id) => Object.hasOwn(GUARD_RULES, id)),
+    pluginRules: annotation.rules.filter(
+      (id) => !Object.hasOwn(GUARD_RULES, id) && PLUGIN_RULE_IDS.has(id)
+    ),
+    unknownRules: [...annotation.unknownRules],
+    hasReason: annotation.hasReason,
+    bare: annotation.rules.length === 0 && annotation.unknownRules.length === 0,
+    text: lines[line - 1] ?? ""
+  }));
+}
+const NEUTRALIZED_ALLOW_TOKEN = "basalt-audit-neutralized";
+function neutralizeAllowAnnotation(text, line, cfg) {
+  const lines = text.split("\n");
+  const target = lines[line - 1];
+  if (target === void 0) return text;
+  lines[line - 1] = target.replaceAll(cfg.allowComment, NEUTRALIZED_ALLOW_TOKEN);
+  return lines.join("\n");
+}
 export {
   DEFAULT_GUARD_CONFIG,
   GENERATED_HEADER_LINE,
   GUARD_RULES,
+  NEUTRALIZED_ALLOW_TOKEN,
+  PLUGIN_RULE_IDS,
   TOKENS_ONLY_DISABLED_KINDS,
-  checkSource
+  checkSource,
+  findAllowAnnotations,
+  guardKindRemedy,
+  guardWaiverHint,
+  neutralizeAllowAnnotation,
+  unmatchedExemptPatterns
 };

package/dist/router-tanstack/multi-search-param-store.d.ts

@@ -8,6 +8,7 @@
  * 2. `useStore` — React hook: `const [values, persist] = store.useStore()`.
  *    Call `persist(next)` alongside `navigate` so the selection survives navigation.
  * 3. `readStored` — plain function for non-React contexts (tests, guards).
+ * 4. `linkSearch` — the click-time `search:` thunk for a nav link, ready-made.
  *
  * Headless — no Mantine, no JSX. Same tier as `createSearchParamStore`.
  *
@@ -73,6 +74,18 @@ export type MultiSearchParamStore<T extends string, P extends string = string> =
     useStore: () => readonly [readonly T[], (next: readonly T[]) => void];
     /** Plain read — for use outside React (tests, guards, fallback reads). */
     readStored: () => readonly T[] | null;
+    /**
+     * The click-time `search:` thunk for a nav link — `() => ({ [param]: readStored() ?? fallback })`.
+     * Pass it BY REFERENCE (`search: store.linkSearch`), never call it; see `createSearchParamStore`
+     * for why a module-scope literal silently defeats the store.
+     *
+     * No dev warning rides on this one, unlike the single-value store: an empty array in the URL is
+     * indistinguishable from an absent param here (`validateSearch` falls back to storage for both),
+     * so a link declaring `{ tags: [] }` restores correctly and there is no broken state to detect.
+     */
+    linkSearch: () => {
+        [K in P]: readonly T[];
+    };
 };
 export declare function createMultiSearchParamStore<const T extends string, const P extends string>(opts: MultiSearchParamStoreOptions<T, P>): MultiSearchParamStore<T, P>;
 //# sourceMappingURL=multi-search-param-store.d.ts.map

package/dist/router-tanstack/multi-search-param-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multi-search-param-store.d.ts","sourceRoot":"","sources":["../../src/router-tanstack/multi-search-param-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAMH,MAAM,MAAM,4BAA4B,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IACtF,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAA;IACX,6DAA6D;IAC7D,KAAK,EAAE,CAAC,CAAA;IACR,0FAA0F;IAC1F,MAAM,EAAE,SAAS,CAAC,EAAE,CAAA;IACpB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,CAAA;IACvB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAC/E;;;OAGG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK;SAAG,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,EAAE;KAAE,CAAA;IAC/E;;;OAGG;IACH,QAAQ,EAAE,MAAM,SAAS,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC,CAAA;IACrE,0EAA0E;IAC1E,UAAU,EAAE,MAAM,SAAS,CAAC,EAAE,GAAG,IAAI,CAAA;CACtC,CAAA;AAID,wBAAgB,2BAA2B,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,MAAM,EACxF,IAAI,EAAE,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,GACvC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAoC7B"}
+{"version":3,"file":"multi-search-param-store.d.ts","sourceRoot":"","sources":["../../src/router-tanstack/multi-search-param-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAMH,MAAM,MAAM,4BAA4B,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IACtF,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAA;IACX,6DAA6D;IAC7D,KAAK,EAAE,CAAC,CAAA;IACR,0FAA0F;IAC1F,MAAM,EAAE,SAAS,CAAC,EAAE,CAAA;IACpB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,CAAA;IACvB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAC/E;;;OAGG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK;SAAG,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,EAAE;KAAE,CAAA;IAC/E;;;OAGG;IACH,QAAQ,EAAE,MAAM,SAAS,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC,CAAA;IACrE,0EAA0E;IAC1E,UAAU,EAAE,MAAM,SAAS,CAAC,EAAE,GAAG,IAAI,CAAA;IACrC;;;;;;;;OAQG;IACH,UAAU,EAAE,MAAM;SAAG,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,EAAE;KAAE,CAAA;CAC7C,CAAA;AAID,wBAAgB,2BAA2B,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,MAAM,EACxF,IAAI,EAAE,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,GACvC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAwC7B"}

package/dist/router-tanstack/multi-search-param-store.js

@@ -16,6 +16,9 @@ function createMultiSearchParamStore(opts) {
     if (!Array.isArray(raw)) return null;
     return normalize(raw);
   };
+  const linkSearch = () => {
+    return { [opts.param]: readStored() ?? fallback };
+  };
   const validateSearch = (search) => {
     const fromUrl = normalize(search[opts.param]);
     if (fromUrl.length > 0) {
@@ -28,7 +31,7 @@ function createMultiSearchParamStore(opts) {
     version,
     initial: fallback
   });
-  return { validateSearch, useStore, readStored };
+  return { validateSearch, useStore, readStored, linkSearch };
 }
 export {
   createMultiSearchParamStore

package/dist/router-tanstack/search-param-store.d.ts

@@ -9,6 +9,19 @@
  *    Call `persist(next)` alongside `navigate` so the selection survives
  *    navigation away from and back to the route.
  * 3. `readStored` — plain function for non-React contexts (tests, guards).
+ * 4. `linkSearch` — the click-time `search:` thunk a nav link needs, ready-made.
+ *
+ * ## The half that is easy to skip
+ *
+ * `validateSearch` restores the value when you navigate TO the route with no param. It cannot do
+ * anything about a nav link that declares the param itself — and a link written as
+ * `search: { range: '30d' }` at module scope pins the fallback on every click, which silently
+ * defeats the whole store. The reference consumer shipped exactly that: three features adopted the
+ * persistence, the reader had ZERO call sites, and "remember my window" had never once worked.
+ *
+ * `linkSearch` exists so that failure is unreachable from the API rather than only warned about in
+ * this comment — the mistake is made while typing `search:`, so the remedy has to be something
+ * autocomplete offers at that keystroke. The JSDoc was already here when it happened.
  *
  * Headless — no Mantine, no JSX. Same tier as `useBasaltNav` and
  * `useRouterBreadcrumbs`.
@@ -51,17 +64,18 @@
  *
  * **5. Nav links** — carry the param across sub-pages, set per destination in
  * the nav definition so only the dashboard sub-tree inherits it and every
- * other link stays clean. Use a CLICK-TIME THUNK over `readStored`:
- *
- *     const dashSearch = () => ({ range: dashboardRange.readStored() ?? '30d' })
+ * other link stays clean. Pass `linkSearch` BY REFERENCE — it is the click-time thunk:
  *
  *     navGroup({ id: 'dash', label: 'Dashboard' }, [
  *       { id: 'dash-overview', label: 'Overview', icon: <IconHome />,
- *         link: linkOptions({ to: '/dashboard', search: dashSearch }) },
+ *         link: linkOptions({ to: '/dashboard', search: dashboardRange.linkSearch }) },
  *       { id: 'dash-activity', label: 'Activity', icon: <IconPulse />,
- *         link: linkOptions({ to: '/dashboard/activity', search: dashSearch }) },
+ *         link: linkOptions({ to: '/dashboard/activity', search: dashboardRange.linkSearch }) },
  *     ])
  *
+ * `linkSearch` IS that thunk (`() => ({ [param]: readStored() ?? fallback })`) — hand-rolling it
+ * over `readStored` still works and is what you need when the link also carries other params.
+ *
  * NOT `search: true`. That flag means "keep the current search" and TanStack
  * only offers it where the target's search is OPTIONAL — a route wired to a
  * store's `validateSearch` always returns the param, so the router requires a
@@ -97,6 +111,16 @@ export type SearchParamStore<T extends string, P extends string = string> = {
     useStore: () => readonly [T, (next: T) => void];
     /** Plain read — for use outside React (tests, guards, fallback reads). */
     readStored: () => T | null;
+    /**
+     * The click-time `search:` thunk for a nav link — `() => ({ [param]: readStored() ?? fallback })`.
+     *
+     * Pass it BY REFERENCE (`search: store.linkSearch`), never call it: `<Link>` re-evaluates the
+     * thunk on every click, so arriving from outside the sub-tree restores the last selection,
+     * whereas a value computed once at module scope goes stale immediately and pins the fallback.
+     */
+    linkSearch: () => {
+        [K in P]: T;
+    };
 };
 export declare function createSearchParamStore<const T extends string, const P extends string>(opts: SearchParamStoreOptions<T, P>): SearchParamStore<T, P>;
 //# sourceMappingURL=search-param-store.d.ts.map

package/dist/router-tanstack/search-param-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-param-store.d.ts","sourceRoot":"","sources":["../../src/router-tanstack/search-param-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAMH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IACjF,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAA;IACX,mEAAmE;IACnE,KAAK,EAAE,CAAC,CAAA;IACR,2DAA2D;IAC3D,MAAM,EAAE,SAAS,CAAC,EAAE,CAAA;IACpB,kEAAkE;IAClE,QAAQ,EAAE,CAAC,CAAA;IACX,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAC1E;;;OAGG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,CAAA;IACpE;;;OAGG;IACH,QAAQ,EAAE,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,CAAA;IAC/C,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CAC3B,CAAA;AAID,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,MAAM,EACnF,IAAI,EAAE,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,GAClC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAyBxB"}
+{"version":3,"file":"search-param-store.d.ts","sourceRoot":"","sources":["../../src/router-tanstack/search-param-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AAMH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IACjF,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAA;IACX,mEAAmE;IACnE,KAAK,EAAE,CAAC,CAAA;IACR,2DAA2D;IAC3D,MAAM,EAAE,SAAS,CAAC,EAAE,CAAA;IACpB,kEAAkE;IAClE,QAAQ,EAAE,CAAC,CAAA;IACX,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAC1E;;;OAGG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,CAAA;IACpE;;;OAGG;IACH,QAAQ,EAAE,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,CAAA;IAC/C,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IAC1B;;;;;;OAMG;IACH,UAAU,EAAE,MAAM;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,CAAA;CAClC,CAAA;AAgCD,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,MAAM,EACnF,IAAI,EAAE,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,GAClC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAyDxB"}