@dereekb/dbx-components-mcp 13.10.6 → 13.10.7

package/dbx-components-mcp.js

@@ -5,7 +5,7 @@ const require = __createRequire(import.meta.url);
 // packages/dbx-components-mcp/package.json
 var package_default = {
   name: "@dereekb/dbx-components-mcp",
-  version: "13.10.6",
+  version: "13.10.7",
   type: "module",
   bin: {
     "dbx-components-mcp": "dbx-components-mcp.js"
@@ -1987,13 +1987,13 @@ function parseDecoratorInput(property) {
     }
   }
   const required = requiredFromDecorator ?? !property.hasQuestionToken();
-  const type65 = property.getTypeNode()?.getText() ?? "unknown";
+  const type68 = property.getTypeNode()?.getText() ?? "unknown";
   const initializer = property.getInitializer();
   const defaultValue = initializer === void 0 ? void 0 : initializer.getText();
   return {
     propertyName,
     alias: alias ?? propertyName,
-    type: type65,
+    type: type68,
     required,
     description: readPropertyDescription(property),
     ...defaultValue === void 0 ? {} : { defaultValue }
@@ -2059,22 +2059,22 @@ function parseDecoratorOutput(property) {
     alias = decoratorArg.getLiteralText();
   }
   const initializer = property.getInitializer();
-  let type65 = "unknown";
+  let type68 = "unknown";
   if (initializer !== void 0 && Node4.isNewExpression(initializer)) {
     const typeArgs = initializer.getTypeArguments();
     if (typeArgs.length > 0) {
-      type65 = typeArgs[0].getText();
+      type68 = typeArgs[0].getText();
     }
   } else {
     const explicit = property.getTypeNode()?.getText();
     if (explicit !== void 0) {
-      type65 = explicit;
+      type68 = explicit;
     }
   }
   return {
     propertyName,
     name: alias ?? propertyName,
-    type: type65,
+    type: type68,
     description: readPropertyDescription(property)
   };
 }
@@ -2089,7 +2089,7 @@ function parseSignalOutput(property) {
   }
   const propertyName = property.getName();
   const typeArgs = initializer.getTypeArguments();
-  const type65 = typeArgs.length > 0 ? typeArgs[0].getText() : "void";
+  const type68 = typeArgs.length > 0 ? typeArgs[0].getText() : "void";
   const args = initializer.getArguments();
   let alias;
   if (args.length > 0 && Node4.isObjectLiteralExpression(args[0])) {
@@ -2098,7 +2098,7 @@ function parseSignalOutput(property) {
   return {
     propertyName,
     name: alias ?? propertyName,
-    type: type65,
+    type: type68,
     description: readPropertyDescription(property)
   };
 }
@@ -2704,7 +2704,13 @@ var DbxMcpConfig = type13({
   "forgeFields?": ClusterSection,
   "pipes?": ClusterSection,
   "actions?": ClusterSection,
-  "filters?": ClusterSection
+  "filters?": ClusterSection,
+  "tokens?": ClusterSection,
+  "uiSmellCheck?": {
+    "projectConventions?": {
+      "cardWrapperClasses?": "string[]"
+    }
+  }
 });
 
 // packages/dbx-components-mcp/src/config/load-config.ts
@@ -4140,11 +4146,241 @@ async function loadSemanticTypeRegistry(input) {
   return result;
 }
 
-// packages/dbx-components-mcp/src/manifest/load-ui-components-registry.ts
+// packages/dbx-components-mcp/src/manifest/load-tokens-registry.ts
 import { existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname6, isAbsolute as isAbsolute6, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
+// packages/dbx-components-mcp/src/registry/tokens-runtime.ts
+function createTokenRegistry(loaded) {
+  const entries = Array.from(loaded.entries.values()).sort((a, b) => a.cssVariable.localeCompare(b.cssVariable));
+  return createTokenRegistryFromEntries({ entries, loadedSources: loaded.loadedSources });
+}
+function createTokenRegistryFromEntries(input) {
+  const all = [...input.entries].sort((a, b) => a.cssVariable.localeCompare(b.cssVariable));
+  const bySource = /* @__PURE__ */ new Map();
+  const byRole = /* @__PURE__ */ new Map();
+  const byCssVariable = /* @__PURE__ */ new Map();
+  const byScssVariable = /* @__PURE__ */ new Map();
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const entry of all) {
+    pushInto6(bySource, entry.source, entry);
+    pushInto6(byRole, entry.role, entry);
+    if (!byCssVariable.has(entry.cssVariable)) {
+      byCssVariable.set(entry.cssVariable, entry);
+    }
+    if (entry.scssVariable !== void 0 && !byScssVariable.has(entry.scssVariable)) {
+      byScssVariable.set(entry.scssVariable, entry);
+    }
+    if (entry.componentScope !== void 0) {
+      pushInto6(byComponent, entry.componentScope, entry);
+    }
+  }
+  const bySourceImmutable = freezeBuckets(bySource);
+  const byRoleImmutable = freezeBuckets(byRole);
+  const registry = {
+    all,
+    loadedSources: [...input.loadedSources],
+    bySource: bySourceImmutable,
+    byRole: byRoleImmutable,
+    findByCssVariable(name) {
+      return byCssVariable.get(name);
+    },
+    findByScssVariable(name) {
+      return byScssVariable.get(name);
+    },
+    findByIntent(query, role) {
+      const trimmed = query.trim().toLowerCase();
+      let matches;
+      if (trimmed.length === 0) {
+        matches = [];
+      } else {
+        const candidates = role !== void 0 ? byRoleImmutable.get(role) ?? [] : all;
+        matches = [];
+        for (const entry of candidates) {
+          let best = 0;
+          for (const intent of entry.intents) {
+            const lower = intent.toLowerCase();
+            let score = 0;
+            if (lower === trimmed) {
+              score = 10;
+            } else if (lower.includes(trimmed)) {
+              score = 5;
+            } else if (trimmed.includes(lower) && lower.length > 0) {
+              score = 3;
+            }
+            if (score > best) {
+              best = score;
+            }
+          }
+          if (best > 0) {
+            matches.push({ entry, score: best });
+          }
+        }
+        matches.sort((a, b) => b.score - a.score);
+      }
+      return matches;
+    },
+    findByValue(value, role) {
+      const trimmed = value.trim();
+      let matches;
+      if (trimmed.length === 0) {
+        matches = [];
+      } else {
+        const candidates = role !== void 0 ? byRoleImmutable.get(role) ?? [] : all;
+        matches = [];
+        for (const entry of candidates) {
+          let score = 0;
+          if (entry.defaults.light !== void 0 && entry.defaults.light === trimmed) score = 10;
+          if (entry.defaults.dark !== void 0 && entry.defaults.dark === trimmed && score < 10) score = 9;
+          if (score === 0 && entry.defaults.light !== void 0 && entry.defaults.light.includes(trimmed)) score = 4;
+          if (score === 0 && entry.defaults.dark !== void 0 && entry.defaults.dark.includes(trimmed)) score = 3;
+          if (score > 0) {
+            matches.push({ entry, score });
+          }
+        }
+        matches.sort((a, b) => b.score - a.score);
+      }
+      return matches;
+    },
+    findByComponent(component) {
+      return byComponent.get(component) ?? [];
+    }
+  };
+  return registry;
+}
+var EMPTY_TOKEN_REGISTRY = createTokenRegistryFromEntries({ entries: [], loadedSources: [] });
+function pushInto6(map, key, entry) {
+  const existing = map.get(key);
+  if (existing === void 0) {
+    map.set(key, [entry]);
+  } else {
+    existing.push(entry);
+  }
+}
+function freezeBuckets(map) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, list] of map) {
+    out.set(key, [...list]);
+  }
+  return out;
+}
+
+// packages/dbx-components-mcp/src/manifest/tokens-schema.ts
+import { type as type20 } from "arktype";
+var TOKEN_ROLES = ["color", "text-color", "surface", "spacing", "radius", "elevation", "shadow", "typography", "motion", "state-layer", "size", "breakpoint", "misc"];
+var TOKEN_SOURCES = ["dbx-web", "mat-sys", "mdc", "app"];
+var TokenDefaults = type20({
+  "light?": "string",
+  "dark?": "string"
+});
+var TokenSourceLocation = type20({
+  file: "string",
+  line: "number"
+});
+var TokenEntry = type20({
+  cssVariable: "string",
+  "scssVariable?": "string",
+  source: '"dbx-web" | "mat-sys" | "mdc" | "app"',
+  role: '"color" | "text-color" | "surface" | "spacing" | "radius" | "elevation" | "shadow" | "typography" | "motion" | "state-layer" | "size" | "breakpoint" | "misc"',
+  intents: "string[]",
+  description: "string",
+  "antiUseNotes?": "string",
+  defaults: TokenDefaults,
+  "utilityClasses?": "string[]",
+  "componentScope?": "string",
+  "recommendedPrimitive?": "string",
+  "seeAlso?": "string[]",
+  "sourceLocation?": TokenSourceLocation
+});
+var TokenManifest = type20({
+  version: "1",
+  source: "string",
+  module: "string",
+  generatedAt: "string",
+  generator: "string",
+  entries: TokenEntry.array()
+});
+
+// packages/dbx-components-mcp/src/manifest/tokens-loader.ts
+async function loadTokenManifests(input) {
+  const { entries, indexMap, warnings, loadedSources } = await loadManifestsBase(input, {
+    name: "loadTokenManifests",
+    schema: TokenManifest,
+    extractIndexValue: (entry) => entry.role,
+    buildEntryKey: (_manifest, entry) => `${entry.source}::${entry.cssVariable}`
+  });
+  return { entries, roleIndex: indexMap, warnings, loadedSources };
+}
+
+// packages/dbx-components-mcp/src/manifest/load-tokens-registry.ts
+var DEFAULT_BUNDLED_FILENAMES6 = ["dereekb-dbx-web.tokens.mcp.generated.json", "angular-material-m3.tokens.mcp.generated.json", "angular-material-mdc.tokens.mcp.generated.json"];
+function findPackageRoot6(startUrl) {
+  const startPath = fileURLToPath6(startUrl);
+  let dir = dirname6(startPath);
+  let result;
+  while (result === void 0) {
+    if (existsSync6(resolve12(dir, "package.json"))) {
+      result = dir;
+    } else {
+      const parent = dirname6(dir);
+      if (parent === dir) {
+        throw new Error(`findPackageRoot: no package.json found above ${startPath}`);
+      }
+      dir = parent;
+    }
+  }
+  return result;
+}
+var DEFAULT_BUNDLED_PATHS6 = () => {
+  const packageRoot = findPackageRoot6(import.meta.url);
+  return DEFAULT_BUNDLED_FILENAMES6.map((name) => resolve12(packageRoot, "generated", name));
+};
+async function loadTokenRegistry(input) {
+  const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS6, readFile: readFile20 } = input;
+  const bundledSources = bundledManifestPaths().map((path) => ({ origin: "bundled", path }));
+  const configResult = await findAndLoadConfig({ cwd, readFile: readFile20 });
+  const externalSources = [];
+  if (configResult.config !== null && configResult.configPath !== null) {
+    const baseDir = dirname6(configResult.configPath);
+    const tokensCluster = configResult.config.tokens;
+    const declaredSources = tokensCluster?.sources ?? [];
+    for (const source of declaredSources) {
+      const absolute = isAbsolute6(source) ? source : resolve12(baseDir, source);
+      externalSources.push({ origin: "external", path: absolute });
+    }
+    const declaredScans = tokensCluster?.scan ?? [];
+    for (const scan of declaredScans) {
+      const out = scan.out;
+      if (typeof out === "string" && out.length > 0) {
+        const absolute = isAbsolute6(out) ? out : resolve12(baseDir, out);
+        externalSources.push({ origin: "external", path: absolute });
+      }
+    }
+  }
+  let registry = EMPTY_TOKEN_REGISTRY;
+  let loaderWarnings = [];
+  const sources = [...bundledSources, ...externalSources];
+  if (sources.length > 0) {
+    const loaded = await loadTokenManifests({ sources, readFile: readFile20 });
+    registry = createTokenRegistry(loaded);
+    loaderWarnings = loaded.warnings;
+  }
+  const result = {
+    registry,
+    configPath: configResult.configPath,
+    configWarnings: configResult.warnings,
+    loaderWarnings,
+    externalSourceCount: externalSources.length
+  };
+  return result;
+}
+
+// packages/dbx-components-mcp/src/manifest/load-ui-components-registry.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute7, resolve as resolve13 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
+
 // packages/dbx-components-mcp/src/registry/ui-components-runtime.ts
 function createUiComponentRegistry(loaded) {
   const entries = Array.from(loaded.entries.values()).sort((a, b) => a.slug.localeCompare(b.slug));
@@ -4159,10 +4395,10 @@ function createUiComponentRegistryFromEntries(input) {
   const byClassName = /* @__PURE__ */ new Map();
   const bySelectorToken = /* @__PURE__ */ new Map();
   for (const entry of all) {
-    pushInto6(bySlug, entry.slug, entry);
-    pushInto6(byCategory, entry.category, entry);
-    pushInto6(byKind, entry.kind, entry);
-    pushInto6(byModule, entry.module, entry);
+    pushInto7(bySlug, entry.slug, entry);
+    pushInto7(byCategory, entry.category, entry);
+    pushInto7(byKind, entry.kind, entry);
+    pushInto7(byModule, entry.module, entry);
     byClassName.set(entry.className.toLowerCase(), entry);
     for (const token of splitSelectorTokens(entry.selector)) {
       if (!bySelectorToken.has(token)) {
@@ -4214,7 +4450,7 @@ ${entry.description}`.toLowerCase();
   return registry;
 }
 var EMPTY_UI_COMPONENT_REGISTRY = createUiComponentRegistryFromEntries({ entries: [], loadedSources: [] });
-function pushInto6(map, key, entry) {
+function pushInto7(map, key, entry) {
   const existing = map.get(key);
   if (existing === void 0) {
     map.set(key, [entry]);
@@ -4248,16 +4484,16 @@ async function loadUiComponentManifests(input) {
 }
 
 // packages/dbx-components-mcp/src/manifest/load-ui-components-registry.ts
-var DEFAULT_BUNDLED_FILENAMES6 = ["dereekb-dbx-web.ui-components.mcp.generated.json"];
-function findPackageRoot6(startUrl) {
-  const startPath = fileURLToPath6(startUrl);
-  let dir = dirname6(startPath);
+var DEFAULT_BUNDLED_FILENAMES7 = ["dereekb-dbx-web.ui-components.mcp.generated.json"];
+function findPackageRoot7(startUrl) {
+  const startPath = fileURLToPath7(startUrl);
+  let dir = dirname7(startPath);
   let result;
   while (result === void 0) {
-    if (existsSync6(resolve12(dir, "package.json"))) {
+    if (existsSync7(resolve13(dir, "package.json"))) {
       result = dir;
     } else {
-      const parent = dirname6(dir);
+      const parent = dirname7(dir);
       if (parent === dir) {
         throw new Error(`findPackageRoot: no package.json found above ${startPath}`);
       }
@@ -4266,20 +4502,20 @@ function findPackageRoot6(startUrl) {
   }
   return result;
 }
-var DEFAULT_BUNDLED_PATHS6 = () => {
-  const packageRoot = findPackageRoot6(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES6.map((name) => resolve12(packageRoot, "generated", name));
+var DEFAULT_BUNDLED_PATHS7 = () => {
+  const packageRoot = findPackageRoot7(import.meta.url);
+  return DEFAULT_BUNDLED_FILENAMES7.map((name) => resolve13(packageRoot, "generated", name));
 };
 async function loadUiComponentRegistry(input) {
-  const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS6, readFile: readFile20 } = input;
+  const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS7, readFile: readFile20 } = input;
   const bundledSources = bundledManifestPaths().map((path) => ({ origin: "bundled", path }));
   const configResult = await findAndLoadConfig({ cwd, readFile: readFile20 });
   const externalSources = [];
   if (configResult.config !== null && configResult.configPath !== null) {
-    const baseDir = dirname6(configResult.configPath);
+    const baseDir = dirname7(configResult.configPath);
     const declared = configResult.config.uiComponents?.sources ?? [];
     for (const source of declared) {
-      const absolute = isAbsolute6(source) ? source : resolve12(baseDir, source);
+      const absolute = isAbsolute7(source) ? source : resolve13(baseDir, source);
       externalSources.push({ origin: "external", path: absolute });
     }
   }
@@ -5294,11 +5530,11 @@ import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 var FORM_TIER_ORDER = ["field-factory", "field-derivative", "composite-builder", "template-builder", "primitive"];
 
 // packages/dbx-components-mcp/src/registry/downstream-models-runtime.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 
 // packages/dbx-components-mcp/src/scan/discover-firebase-packages.ts
 import { glob as fsGlob2, readFile, stat } from "node:fs/promises";
-import { basename, join, resolve as resolve13, sep } from "node:path";
+import { basename, join, resolve as resolve14, sep } from "node:path";
 var COMPONENTS_GLOB = "components/*-firebase";
 var MODEL_SUBPATH = "src/lib/model";
 var PACKAGE_JSON = "package.json";
@@ -5309,7 +5545,7 @@ async function discoverDownstreamFirebasePackages(workspaceRoot) {
     const componentDir = match.split(sep).join("/");
     if (seen.has(componentDir)) continue;
     seen.add(componentDir);
-    const componentAbs = resolve13(workspaceRoot, componentDir);
+    const componentAbs = resolve14(workspaceRoot, componentDir);
     const pkg = await inspectPackage(componentAbs, componentDir);
     if (pkg) out.push(pkg);
   }
@@ -5323,7 +5559,7 @@ async function resolveExplicitFirebasePackages(workspaceRoot, componentDirs) {
     const componentDir = raw.split(sep).join("/").replace(/\/+$/, "");
     if (seen.has(componentDir) || componentDir.length === 0) continue;
     seen.add(componentDir);
-    const componentAbs = resolve13(workspaceRoot, componentDir);
+    const componentAbs = resolve14(workspaceRoot, componentDir);
     const pkg = await inspectPackage(componentAbs, componentDir);
     if (pkg) out.push(pkg);
   }
@@ -5956,13 +6192,13 @@ function getDownstreamCatalog(input) {
   return pending;
 }
 function cacheKey(input) {
-  const root = resolve14(input.workspaceRoot);
+  const root = resolve15(input.workspaceRoot);
   const dirs = input.componentDirs;
   const dirKey = dirs ? [...dirs].slice().sort((a, b) => a.localeCompare(b)).join(",") : "*";
   return `${root}|${dirKey}`;
 }
 async function buildCatalog(input) {
-  const workspaceRoot = resolve14(input.workspaceRoot);
+  const workspaceRoot = resolve15(input.workspaceRoot);
   const discoveryUsed = input.componentDirs === void 0;
   const packages = discoveryUsed ? await discoverDownstreamFirebasePackages(workspaceRoot) : await resolveExplicitFirebasePackages(workspaceRoot, input.componentDirs ?? []);
   const errors = [];
@@ -5972,7 +6208,7 @@ async function buildCatalog(input) {
     packages.map(async (pkg) => {
       try {
         const result = await extractModels({
-          rootDir: resolve14(workspaceRoot, pkg.modelDir),
+          rootDir: resolve15(workspaceRoot, pkg.modelDir),
           sourcePackage: pkg.packageName,
           workspaceRoot,
           skipReservedFolders: RESERVED_FOLDER_NAMES
@@ -6942,6 +7178,141 @@ function registerSemanticTypesResource(server, config) {
   );
 }
 
+// packages/dbx-components-mcp/src/resources/tokens.resource.ts
+import { ResourceTemplate as ResourceTemplate8 } from "@modelcontextprotocol/sdk/server/mcp.js";
+var TOKENS_URI = "dbx://token/entries";
+var TOKENS_BY_SOURCE_TEMPLATE = "dbx://token/source/{source}";
+var TOKENS_BY_ROLE_TEMPLATE = "dbx://token/role/{role}";
+var TOKENS_BY_VAR_TEMPLATE = "dbx://token/css-var/{cssVariable}";
+function registerTokensResource(server, options) {
+  const { registry } = options;
+  server.registerResource(
+    "dbx-components Tokens",
+    TOKENS_URI,
+    {
+      title: "Design Tokens",
+      description: "Catalog of dbx-web + Angular Material design tokens (system, MDC, dbx-web aliases).",
+      mimeType: "application/json"
+    },
+    async () => {
+      const payload = {
+        description: "Every registered design token.",
+        sourceOrder: TOKEN_SOURCES,
+        roleOrder: TOKEN_ROLES,
+        tokens: registry.all.map((t) => ({
+          cssVariable: t.cssVariable,
+          source: t.source,
+          role: t.role,
+          description: t.description
+        }))
+      };
+      return {
+        contents: [
+          {
+            uri: TOKENS_URI,
+            mimeType: "application/json",
+            text: JSON.stringify(payload, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "dbx-components Tokens by Source",
+    new ResourceTemplate8(TOKENS_BY_SOURCE_TEMPLATE, { list: void 0 }),
+    {
+      title: "Tokens by Source",
+      description: "Tokens filtered by origin: dbx-web, mat-sys, mdc, app.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const rawSource = variables.source;
+      const source = Array.isArray(rawSource) ? rawSource[0] : rawSource;
+      const valid = source !== void 0 && TOKEN_SOURCES.includes(source);
+      let text;
+      if (valid && source !== void 0) {
+        const tokens = registry.bySource.get(source) ?? [];
+        text = JSON.stringify({ source, tokens }, null, 2);
+      } else {
+        text = `Invalid source. Valid values: ${TOKEN_SOURCES.join(", ")}`;
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: valid ? "application/json" : "text/plain",
+            text
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "dbx-components Tokens by Role",
+    new ResourceTemplate8(TOKENS_BY_ROLE_TEMPLATE, { list: void 0 }),
+    {
+      title: "Tokens by Role",
+      description: "Tokens filtered by role (color, surface, spacing, radius, ...).",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const rawRole = variables.role;
+      const role = Array.isArray(rawRole) ? rawRole[0] : rawRole;
+      const valid = role !== void 0 && TOKEN_ROLES.includes(role);
+      let text;
+      if (valid && role !== void 0) {
+        const tokens = registry.byRole.get(role) ?? [];
+        text = JSON.stringify({ role, tokens }, null, 2);
+      } else {
+        text = `Invalid role. Valid values: ${TOKEN_ROLES.join(", ")}`;
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: valid ? "application/json" : "text/plain",
+            text
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "dbx-components Token Details",
+    new ResourceTemplate8(TOKENS_BY_VAR_TEMPLATE, { list: void 0 }),
+    {
+      title: "Token Details",
+      description: "Full metadata for a single token by CSS variable name.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const rawVar = variables.cssVariable;
+      const cssVariable = Array.isArray(rawVar) ? rawVar[0] : rawVar;
+      let text;
+      let entry;
+      if (cssVariable !== void 0) {
+        entry = registry.findByCssVariable(cssVariable) ?? registry.findByScssVariable(cssVariable);
+      }
+      if (entry !== void 0) {
+        text = JSON.stringify(entry, null, 2);
+      } else if (cssVariable !== void 0) {
+        text = `Token '${cssVariable}' not found.`;
+      } else {
+        text = "No cssVariable provided.";
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: entry !== void 0 ? "application/json" : "text/plain",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
 // packages/dbx-components-mcp/src/resources/index.ts
 function registerResources(server, options = {}) {
   if (options.forgeFieldRegistry !== void 0) {
@@ -6963,13 +7334,16 @@ function registerResources(server, options = {}) {
   if (options.semanticTypeRegistry !== void 0) {
     registerSemanticTypesResource(server, { registry: options.semanticTypeRegistry });
   }
+  if (options.tokenRegistry !== void 0) {
+    registerTokensResource(server, { registry: options.tokenRegistry });
+  }
 }
 
 // packages/dbx-components-mcp/src/tools/index.ts
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // packages/dbx-components-mcp/src/tools/lookup-form.tool.ts
-import { type as type20 } from "arktype";
+import { type as type21 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/form-alias-resolver.ts
 var ALIASES = {
@@ -7206,13 +7580,13 @@ var DBX_FORM_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupFormArgsType = type20({
+var LookupFormArgsType = type21({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupFormArgs(raw) {
   const parsed = LookupFormArgsType(raw);
-  if (parsed instanceof type20.errors) {
+  if (parsed instanceof type21.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -7334,14 +7708,14 @@ function createLookupFormTool(config) {
 }
 
 // packages/dbx-components-mcp/src/tools/_search/score.ts
-import { type as type21 } from "arktype";
-var SEARCH_ARGS_TYPE = type21({
+import { type as type22 } from "arktype";
+var SEARCH_ARGS_TYPE = type22({
   query: "string",
   "limit?": "number"
 });
 function parseSearchArgs(raw, config) {
   const parsed = SEARCH_ARGS_TYPE(raw);
-  if (parsed instanceof type21.errors) {
+  if (parsed instanceof type22.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawLimit = parsed.limit ?? config.defaultLimit;
@@ -7539,7 +7913,7 @@ function createSearchFormTool(config) {
 }
 
 // packages/dbx-components-mcp/src/tools/form-examples.tool.ts
-import { type as type22 } from "arktype";
+import { type as type23 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/data/patterns/forms/form.address-form.pattern.ts
 var FORM_PATTERN_ADDRESS_FORM = {
@@ -7828,13 +8202,13 @@ var DBX_FORM_EXAMPLES_TOOL = {
     required: ["pattern"]
   }
 };
-var ExamplesArgsType = type22({
+var ExamplesArgsType = type23({
   pattern: "string",
   "depth?": "'minimal' | 'brief' | 'full'"
 });
 function parseExamplesArgs(raw) {
   const parsed = ExamplesArgsType(raw);
-  if (parsed instanceof type22.errors) {
+  if (parsed instanceof type23.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -7895,7 +8269,7 @@ var formExamplesTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/form-scaffold.tool.ts
-import { type as type23 } from "arktype";
+import { type as type24 } from "arktype";
 var DEFAULT_VALUE_TYPE_NAME = "ScaffoldedFormValue";
 var DBX_FORM_SCAFFOLD_TOOL = {
   name: "dbx_form_scaffold",
@@ -7933,14 +8307,14 @@ var DBX_FORM_SCAFFOLD_TOOL = {
     required: ["fields"]
   }
 };
-var ScaffoldArgsType = type23({
+var ScaffoldArgsType = type24({
   fields: "string[]>0",
   "valueTypeName?": "string",
   "wrapInSection?": "boolean"
 });
 function parseScaffoldArgs(raw) {
   const parsed = ScaffoldArgsType(raw);
-  if (parsed instanceof type23.errors) {
+  if (parsed instanceof type24.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -8096,7 +8470,7 @@ ${code11}
 }
 
 // packages/dbx-components-mcp/src/tools/lookup-ui.tool.ts
-import { type as type24 } from "arktype";
+import { type as type25 } from "arktype";
 var DBX_UI_LOOKUP_TOOL = {
   name: "dbx_ui_lookup",
   description: [
@@ -8126,13 +8500,13 @@ var DBX_UI_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupUiArgsType = type24({
+var LookupUiArgsType = type25({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupUiArgs(raw) {
   const parsed = LookupUiArgsType(raw);
-  if (parsed instanceof type24.errors) {
+  if (parsed instanceof type25.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -8382,7 +8756,7 @@ function createLookupUiTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/search-ui.tool.ts
-import { type as type25 } from "arktype";
+import { type as type26 } from "arktype";
 var DEFAULT_LIMIT2 = 10;
 var MAX_LIMIT2 = 25;
 var DBX_UI_SEARCH_TOOL = {
@@ -8419,14 +8793,14 @@ var DBX_UI_SEARCH_TOOL = {
     required: ["query"]
   }
 };
-var SearchUiArgsType = type25({
+var SearchUiArgsType = type26({
   query: "string",
   "category?": "'layout' | 'list' | 'button' | 'card' | 'feedback' | 'overlay' | 'navigation' | 'text' | 'screen' | 'action' | 'router' | 'misc'",
   "limit?": "number"
 });
 function parseSearchUiArgs(raw) {
   const parsed = SearchUiArgsType(raw);
-  if (parsed instanceof type25.errors) {
+  if (parsed instanceof type26.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawLimit = parsed.limit ?? DEFAULT_LIMIT2;
@@ -8579,7 +8953,7 @@ function createSearchUiTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/ui-examples.tool.ts
-import { type as type26 } from "arktype";
+import { type as type27 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/data/patterns/ui/ui.card-with-action.pattern.ts
 var UI_PATTERN_CARD_WITH_ACTION = {
@@ -8985,13 +9359,13 @@ var DBX_UI_EXAMPLES_TOOL = {
     required: ["pattern"]
   }
 };
-var UiExamplesArgsType = type26({
+var UiExamplesArgsType = type27({
   pattern: "string",
   "depth?": "'minimal' | 'brief' | 'full'"
 });
 function parseUiExamplesArgs(raw) {
   const parsed = UiExamplesArgsType(raw);
-  if (parsed instanceof type26.errors) {
+  if (parsed instanceof type27.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -9052,7 +9426,7 @@ var uiExamplesTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/lookup-model.tool.ts
-import { type as type27 } from "arktype";
+import { type as type28 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/firebase-lookup.formatter.ts
 function applyFieldsFilter(model, filter) {
@@ -9266,10 +9640,10 @@ function formatFirebaseStoreShapeTaxonomy() {
 
 // packages/dbx-components-mcp/src/tools/validate-input.ts
 import { glob as fsGlob3, readFile as readFile3, stat as stat3 } from "node:fs/promises";
-import { resolve as resolve15, sep as sep3 } from "node:path";
+import { resolve as resolve16, sep as sep3 } from "node:path";
 function ensurePathInsideCwd(relative17, cwd) {
   const cwdPrefix = cwd.endsWith(sep3) ? cwd : cwd + sep3;
-  const absolute = resolve15(cwd, relative17);
+  const absolute = resolve16(cwd, relative17);
   if (!absolute.startsWith(cwdPrefix) && absolute !== cwd) {
     throw new Error(`Path \`${relative17}\` resolves outside the server cwd and is not allowed.`);
   }
@@ -9291,7 +9665,7 @@ async function resolveFolderPaths(config) {
   }
   if (glob) {
     for await (const match of fsGlob3(glob, { cwd })) {
-      const absolute = resolve15(cwd, match);
+      const absolute = resolve16(cwd, match);
       try {
         const stats = await stat3(absolute);
         if (!stats.isDirectory()) continue;
@@ -9328,7 +9702,7 @@ async function resolveValidatorSources(config) {
   for (const relative17 of pathList) {
     if (seenNames.has(relative17)) continue;
     ensurePathInsideCwd(relative17, cwd);
-    const absolute = resolve15(cwd, relative17);
+    const absolute = resolve16(cwd, relative17);
     const text = await readFile3(absolute, "utf8");
     seenNames.add(relative17);
     collected.push({ name: relative17, text });
@@ -9388,7 +9762,7 @@ var DBX_MODEL_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupModelArgsType = type27({
+var LookupModelArgsType = type28({
   topic: "string",
   "depth?": "'brief' | 'full'",
   "scope?": "'all' | 'upstream' | 'downstream'",
@@ -9415,7 +9789,7 @@ function normalizeFieldsFilter(raw) {
 }
 function parseLookupModelArgs(raw) {
   const parsed = LookupModelArgsType(raw);
-  if (parsed instanceof type27.errors) {
+  if (parsed instanceof type28.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -9532,10 +9906,10 @@ var lookupModelTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/search-model.tool.ts
-import { type as type28 } from "arktype";
+import { type as type29 } from "arktype";
 var DEFAULT_LIMIT3 = 10;
 var MAX_LIMIT3 = 25;
-var SearchArgsType = type28({
+var SearchArgsType = type29({
   query: "string",
   "limit?": "number",
   "scope?": "'all' | 'upstream' | 'downstream'",
@@ -9679,7 +10053,7 @@ function formatSourceLine(scope, upstreamCount, downstreamPackages) {
 }
 function parseArgs2(rawArgs) {
   const parsed = SearchArgsType(rawArgs);
-  if (parsed instanceof type28.errors) {
+  if (parsed instanceof type29.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -9740,7 +10114,7 @@ var searchModelTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/model-decode.tool.ts
-import { type as type29 } from "arktype";
+import { type as type30 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/decode.formatter.ts
 function formatDecode(context) {
@@ -9900,13 +10274,13 @@ var DBX_MODEL_DECODE_TOOL = {
     required: ["data"]
   }
 };
-var DecodeArgsType = type29({
+var DecodeArgsType = type30({
   data: "string | object",
   "model?": "string"
 });
 function parseDecodeArgs(raw) {
   const parsed = DecodeArgsType(raw);
-  if (parsed instanceof type29.errors) {
+  if (parsed instanceof type30.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -10046,9 +10420,9 @@ var modelDecodeTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/validate-tool.ts
-import { resolve as resolve16 } from "node:path";
-import { type as type30 } from "arktype";
-var FolderValidateArgsType = type30({
+import { resolve as resolve17 } from "node:path";
+import { type as type31 } from "arktype";
+var FolderValidateArgsType = type31({
   "paths?": "string[]",
   "glob?": "string"
 });
@@ -10056,7 +10430,7 @@ function createFolderValidateTool(config) {
   const { definition, inspectFolder: inspectFolder3, validate, format } = config;
   async function run15(rawArgs) {
     const parsed = FolderValidateArgsType(rawArgs);
-    if (parsed instanceof type30.errors) {
+    if (parsed instanceof type31.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const hasAny = parsed.paths && parsed.paths.length > 0 || parsed.glob;
@@ -10077,7 +10451,7 @@ function createFolderValidateTool(config) {
     const inspections = [];
     try {
       for (const relative17 of paths) {
-        const absolute = resolve16(cwd, relative17);
+        const absolute = resolve17(cwd, relative17);
         const inspection = await inspectFolder3(absolute);
         const relativized = { ...inspection, path: relative17 };
         inspections.push(relativized);
@@ -10097,8 +10471,8 @@ function createFolderValidateTool(config) {
   const tool = { definition, run: run15 };
   return tool;
 }
-var SourceValidateArgsType = type30({
-  "sources?": type30({ name: "string", text: "string" }).array(),
+var SourceValidateArgsType = type31({
+  "sources?": type31({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string"
 });
@@ -10106,7 +10480,7 @@ function createSourceValidateTool(config) {
   const { definition, validate, format } = config;
   async function run15(rawArgs) {
     const parsed = SourceValidateArgsType(rawArgs);
-    if (parsed instanceof type30.errors) {
+    if (parsed instanceof type31.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const hasAny = parsed.sources && parsed.sources.length > 0 || parsed.paths && parsed.paths.length > 0 || parsed.glob;
@@ -10134,7 +10508,7 @@ function createSourceValidateTool(config) {
   const tool = { definition, run: run15 };
   return tool;
 }
-var TwoSideValidateArgsType = type30({
+var TwoSideValidateArgsType = type31({
   componentDir: "string",
   apiDir: "string"
 });
@@ -10150,9 +10524,9 @@ function resolveTwoSideInput(parsed) {
     return toolError(message);
   }
   return {
-    componentAbs: resolve16(cwd, componentRel),
+    componentAbs: resolve17(cwd, componentRel),
     componentRel,
-    apiAbs: resolve16(cwd, apiRel),
+    apiAbs: resolve17(cwd, apiRel),
     apiRel
   };
 }
@@ -10160,7 +10534,7 @@ function createTwoSideValidateTool(config) {
   const { definition, inspectAndValidate, format } = config;
   async function run15(rawArgs) {
     const parsed = TwoSideValidateArgsType(rawArgs);
-    if (parsed instanceof type30.errors) {
+    if (parsed instanceof type31.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const resolved = resolveTwoSideInput(parsed);
@@ -10178,7 +10552,7 @@ function createTwoSideValidateTool(config) {
   const tool = { definition, run: run15 };
   return tool;
 }
-var ListAppArgsType = type30({
+var ListAppArgsType = type31({
   componentDir: "string",
   apiDir: "string",
   "format?": "'markdown' | 'json'"
@@ -10187,7 +10561,7 @@ function createListAppTool(config) {
   const { definition, inspectAndList, formatMarkdown: formatMarkdown2, formatJson: formatJson2 } = config;
   async function run15(rawArgs) {
     const parsed = ListAppArgsType(rawArgs);
-    if (parsed instanceof type30.errors) {
+    if (parsed instanceof type31.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const resolved = resolveTwoSideInput(parsed);
@@ -10684,9 +11058,9 @@ var RULE_CATALOG = [
     severity: "error",
     title: "A model is missing one of Fixture / Instance / Params / factory",
     whatItFlags: "A model is missing one of Fixture / Instance / Params / factory\ncall / singleton \u2014 the five-anchor triplet definition is incomplete.",
-    whenItApplies: "Every model that has at least one of the anchors.",
-    whenItDoesNotApply: "Models intentionally not yet wired (uncommon \u2014 usually a forgotten scaffold step).",
-    canonicalFix: "Run `dbx_model_fixture_scaffold apiDir=<apiDir> model=<Model>` to generate the missing pieces.",
+    whenItApplies: "Every Firestore-model fixture (`kind === 'firestore-model'`) that has at least one of the anchors.",
+    whenItDoesNotApply: "Skipped for non-Firestore-model fixture pairs: AuthorizedUser-style fixtures (extending `AuthorizedUserTestContextFixture`/`Instance` or registered via `authorizedUserContextFactory`) and pairs tagged with `@dbxFixtureNotModel`.",
+    canonicalFix: "Run `dbx_model_fixture_scaffold apiDir=<apiDir> model=<Model>` to generate the missing pieces; or, if the pair is intentionally not a Firestore model, ensure it extends a recognized framework base or carries `@dbxFixtureNotModel`.",
     seeAlso: [
       {
         kind: "tool",
@@ -14722,8 +15096,8 @@ var modelValidateApiTool = createSourceValidateTool({
 });
 
 // packages/dbx-components-mcp/src/tools/model-api-list-app.tool.ts
-import { resolve as resolve17 } from "node:path";
-import { type as type31 } from "arktype";
+import { resolve as resolve18 } from "node:path";
+import { type as type32 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-api-list-app/extract.ts
 import { readdir as readdir2, readFile as readFile4, stat as stat4 } from "node:fs/promises";
@@ -15065,7 +15439,7 @@ async function listAppModelApi(componentAbs, options) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-api-list-app.tool.ts
-var ListArgsType = type31({
+var ListArgsType = type32({
   componentDir: "string",
   "model?": "string",
   "identity?": "string",
@@ -15103,7 +15477,7 @@ var TOOL = {
 };
 async function run(rawArgs) {
   const parsed = ListArgsType(rawArgs);
-  if (parsed instanceof type31.errors) {
+  if (parsed instanceof type32.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -15112,7 +15486,7 @@ async function run(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const componentAbs = resolve17(cwd, parsed.componentDir);
+  const componentAbs = resolve18(cwd, parsed.componentDir);
   const modelFilter = parsed.model ?? (parsed.identity ? identityToModel(parsed.identity) : void 0);
   let report;
   try {
@@ -15132,8 +15506,8 @@ function identityToModel(identity) {
 var modelApiListAppTool = { definition: TOOL, run };
 
 // packages/dbx-components-mcp/src/tools/model-api-lookup.tool.ts
-import { resolve as resolve18 } from "node:path";
-import { type as type32 } from "arktype";
+import { resolve as resolve19 } from "node:path";
+import { type as type33 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-api-lookup/extract.ts
 import { readdir as readdir4, readFile as readFile6, stat as stat6 } from "node:fs/promises";
@@ -15555,7 +15929,7 @@ async function lookupModelApi(options) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-api-lookup.tool.ts
-var LookupArgsType = type32({
+var LookupArgsType = type33({
   componentDir: "string",
   "apiDir?": "string",
   "model?": "string",
@@ -15593,7 +15967,7 @@ var TOOL2 = {
 };
 async function run2(rawArgs) {
   const parsed = LookupArgsType(rawArgs);
-  if (parsed instanceof type32.errors) {
+  if (parsed instanceof type33.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   if (!parsed.model && !parsed.identity) {
@@ -15608,8 +15982,8 @@ async function run2(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const componentAbs = resolve18(cwd, parsed.componentDir);
-  const apiAbs = parsed.apiDir ? resolve18(cwd, parsed.apiDir) : void 0;
+  const componentAbs = resolve19(cwd, parsed.componentDir);
+  const apiAbs = parsed.apiDir ? resolve19(cwd, parsed.apiDir) : void 0;
   const modelFilter = parsed.model ?? identityToModel2(parsed.identity);
   let report;
   try {
@@ -15638,8 +16012,8 @@ function identityToModel2(identity) {
 var modelApiLookupTool = { definition: TOOL2, run: run2 };
 
 // packages/dbx-components-mcp/src/tools/model-api-validate-app.tool.ts
-import { resolve as resolve19 } from "node:path";
-import { type as type33 } from "arktype";
+import { resolve as resolve20 } from "node:path";
+import { type as type34 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-api-validate-app/extract-declarations.ts
 import { readdir as readdir5, readFile as readFile7, stat as stat7 } from "node:fs/promises";
@@ -15937,7 +16311,7 @@ async function validateAppModelApi(options) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-api-validate-app.tool.ts
-var ValidateArgsType = type33({
+var ValidateArgsType = type34({
   componentDir: "string",
   apiDir: "string",
   "model?": "string",
@@ -15978,7 +16352,7 @@ var TOOL3 = {
 };
 async function run3(rawArgs) {
   const parsed = ValidateArgsType(rawArgs);
-  if (parsed instanceof type33.errors) {
+  if (parsed instanceof type34.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -15988,8 +16362,8 @@ async function run3(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const componentAbs = resolve19(cwd, parsed.componentDir);
-  const apiAbs = resolve19(cwd, parsed.apiDir);
+  const componentAbs = resolve20(cwd, parsed.componentDir);
+  const apiAbs = resolve20(cwd, parsed.apiDir);
   const modelFilter = parsed.model ?? (parsed.identity ? identityToModel3(parsed.identity) : void 0);
   let report;
   try {
@@ -16207,7 +16581,7 @@ var modelValidateFolderTool = createFolderValidateTool({
 });
 
 // packages/dbx-components-mcp/src/tools/model-store-scaffold.tool.ts
-import { type as type34 } from "arktype";
+import { type as type35 } from "arktype";
 var STORE_SHAPES = ["root", "root-singleton", "sub-collection", "singleton-sub", "system-state"];
 var SHAPE_PROFILES = {
   root: { defaultSurfaces: ["document", "collection"], allowedSurfaces: ["document", "collection"], hasParent: false, emitsDirectives: true, requiresCollectionsClass: true, requiresSystemStateTypeConst: false },
@@ -16303,7 +16677,7 @@ var DBX_MODEL_STORE_SCAFFOLD_TOOL = {
     required: ["model_name", "app_prefix", "firebase_package"]
   }
 };
-var ScaffoldArgsType2 = type34({
+var ScaffoldArgsType2 = type35({
   model_name: "string",
   app_prefix: "string",
   firebase_package: "string",
@@ -16323,7 +16697,7 @@ var ScaffoldArgsType2 = type34({
     name: "string",
     functions_path: "string"
   },
-  "crud_functions?": type34({
+  "crud_functions?": type35({
     name: "string",
     kind: "'create' | 'update' | 'crud'",
     functions_path: "string"
@@ -16343,7 +16717,7 @@ function requireString(value, label) {
 }
 function parseArgs3(raw) {
   const parsed = ScaffoldArgsType2(raw);
-  if (parsed instanceof type34.errors) {
+  if (parsed instanceof type35.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const modelName = requireString(parsed.model_name, "model_name");
@@ -16735,8 +17109,8 @@ var modelStoreScaffoldTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-list-app.tool.ts
-import { resolve as resolve20 } from "node:path";
-import { type as type35 } from "arktype";
+import { resolve as resolve21 } from "node:path";
+import { type as type36 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-fixture-shared/archetype.ts
 function classifyFixtureArchetype(input) {
@@ -16766,6 +17140,27 @@ function paramsHasFixtureDependencies(params) {
 
 // packages/dbx-components-mcp/src/tools/model-fixture-shared/extract.ts
 import { Node as Node13, Project as Project11, SyntaxKind as SyntaxKind7 } from "ts-morph";
+
+// packages/dbx-components-mcp/src/tools/model-fixture-shared/framework-fixtures.ts
+var KNOWN_NON_MODEL_FIXTURE_FAMILIES = [
+  {
+    kind: "authorized-user",
+    factoryName: "authorizedUserContextFactory",
+    baseFixtureClass: "AuthorizedUserTestContextFixture",
+    baseInstanceClass: "AuthorizedUserTestContextInstance",
+    module: "@dereekb/firebase-server/test",
+    description: "Authorized Firebase auth user (with custom claims). Not backed by a Firestore document."
+  }
+];
+var NON_MODEL_JSDOC_TAG = "dbxFixtureNotModel";
+function findFamilyByFactoryName(factoryCallName) {
+  return KNOWN_NON_MODEL_FIXTURE_FAMILIES.find((f) => f.factoryName === factoryCallName);
+}
+function findFamilyByBaseClass(baseClassName) {
+  return KNOWN_NON_MODEL_FIXTURE_FAMILIES.find((f) => f.baseFixtureClass === baseClassName || f.baseInstanceClass === baseClassName);
+}
+
+// packages/dbx-components-mcp/src/tools/model-fixture-shared/extract.ts
 var FIXTURE_SUFFIX = "TestContextFixture";
 var INSTANCE_SUFFIX = "TestContextInstance";
 var PARAMS_SUFFIX = "TestContextParams";
@@ -16782,7 +17177,7 @@ function extractAppFixturesFromText(input) {
   const unrecognized = [];
   collectClasses(sourceFile, prefix, { fixtures: fixtureClasses, instances: instanceClasses, unrecognized });
   const paramsTypes = collectParamsTypes(sourceFile, prefix);
-  const factoriesByModel = collectFactories(sourceFile, prefix);
+  const { factoriesByModel, nonModelFamiliesByModel } = collectFactories(sourceFile, prefix);
   const singletonsByFactory = collectSingletonsByFactory(sourceFile);
   const entries = [];
   const seenModels = /* @__PURE__ */ new Set();
@@ -16806,10 +17201,13 @@ function extractAppFixturesFromText(input) {
     const archetype = classifyFixtureArchetype({ factory, params });
     const fixtureMethods = readClassMethods(fixtureClass);
     const instanceMethods = readClassMethods(instanceClass);
+    const { kind, nonModelFamily } = classifyFixtureKind({ fixtureClass, instanceClass, nonModelFamily: nonModelFamiliesByModel.get(model) });
     const entry = {
       model,
       prefix: prefix ?? "",
       archetype,
+      kind,
+      nonModelFamily,
       fixtureClassName: fixtureClass.getName() ?? "",
       instanceClassName: instanceClass.getName() ?? "",
       paramsTypeName: params?.name ?? `${prefix ?? ""}${model}${PARAMS_SUFFIX}`,
@@ -16961,19 +17359,23 @@ function resolveFixtureFieldModel(typeText, prefix) {
   return model.length > 0 ? model : void 0;
 }
 function collectFactories(sourceFile, prefix) {
-  const out = /* @__PURE__ */ new Map();
+  const factoriesByModel = /* @__PURE__ */ new Map();
+  const nonModelFamiliesByModel = /* @__PURE__ */ new Map();
   for (const stmt of sourceFile.getVariableStatements()) {
     for (const decl of stmt.getDeclarations()) {
-      const factory = readModelTestContextFactory(decl, prefix);
-      if (!factory) continue;
-      const model = factoryNameToModel(factory.factoryName, prefix);
+      const parsed = readContextFactory(decl);
+      if (!parsed) continue;
+      const model = factoryNameToModel(parsed.factory.factoryName, prefix);
       if (model === void 0) continue;
-      out.set(model, factory);
+      factoriesByModel.set(model, parsed.factory);
+      if (parsed.family !== void 0) {
+        nonModelFamiliesByModel.set(model, parsed.family);
+      }
     }
   }
-  return out;
+  return { factoriesByModel, nonModelFamiliesByModel };
 }
-function readModelTestContextFactory(decl, _prefix) {
+function readContextFactory(decl) {
   const initializer = decl.getInitializer();
   if (!initializer) return void 0;
   let bodyExpr;
@@ -16984,7 +17386,13 @@ function readModelTestContextFactory(decl, _prefix) {
   }
   if (!bodyExpr || !Node13.isCallExpression(bodyExpr)) return void 0;
   const callee = bodyExpr.getExpression();
-  if (!Node13.isIdentifier(callee) || callee.getText() !== MODEL_FACTORY_NAME) return void 0;
+  if (!Node13.isIdentifier(callee)) return void 0;
+  const calleeName = callee.getText();
+  let family;
+  if (calleeName !== MODEL_FACTORY_NAME) {
+    family = findFamilyByFactoryName(calleeName);
+    if (family === void 0) return void 0;
+  }
   const generics = bodyExpr.getTypeArguments().map((t) => t.getText());
   const args = bodyExpr.getArguments();
   let hasParamsGetCollection = false;
@@ -17011,7 +17419,7 @@ function readModelTestContextFactory(decl, _prefix) {
       }
     }
   }
-  const result = {
+  const factory = {
     factoryName: decl.getName(),
     genericArgs: generics,
     hasParamsGetCollection,
@@ -17020,7 +17428,41 @@ function readModelTestContextFactory(decl, _prefix) {
     parentFixtureFieldFromGetCollection,
     line: decl.getStartLineNumber()
   };
-  return result;
+  return { factory, family };
+}
+function classifyFixtureKind(input) {
+  if (hasNonModelJsDoc(input.fixtureClass) || hasNonModelJsDoc(input.instanceClass)) {
+    return { kind: "non-model", nonModelFamily: "jsdoc-tag" };
+  }
+  const familyFromInheritance = familyFromExtends(input.fixtureClass) ?? familyFromExtends(input.instanceClass);
+  const family = familyFromInheritance ?? input.nonModelFamily;
+  if (family !== void 0) {
+    return { kind: family.kind, nonModelFamily: family.kind };
+  }
+  return { kind: "firestore-model" };
+}
+function hasNonModelJsDoc(cls) {
+  for (const doc of cls.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === NON_MODEL_JSDOC_TAG) return true;
+    }
+  }
+  return false;
+}
+function familyFromExtends(cls) {
+  const ext = cls.getExtends();
+  if (!ext) return void 0;
+  const expr = ext.getExpression();
+  let baseName;
+  if (Node13.isIdentifier(expr)) {
+    baseName = expr.getText();
+  } else {
+    const text = ext.getText();
+    const match = /^([A-Za-z_$][\w$]*)/.exec(text);
+    baseName = match ? match[1] : void 0;
+  }
+  if (baseName === void 0) return void 0;
+  return findFamilyByBaseClass(baseName);
 }
 function readSingleReturnExpression(fn) {
   const body = fn.getBody();
@@ -17176,12 +17618,15 @@ async function inspectAppFixtures(apiAbs, apiRel) {
 function validateAppFixtures(extraction, options = {}) {
   const diagnostics = [];
   for (const entry of extraction.entries) {
-    pushTripletCompletenessDiagnostics(entry, diagnostics);
+    const isFirestoreModel = entry.kind === "firestore-model";
+    if (isFirestoreModel) {
+      pushTripletCompletenessDiagnostics(entry, diagnostics);
+      pushArchetypeConsistencyDiagnostics(entry, diagnostics);
+      pushParentFieldNamingDiagnostics(entry, options.registry, diagnostics);
+      pushRegistryDiagnostics(entry, options.registry, diagnostics);
+    }
     pushForwardingDiagnostics(entry, diagnostics);
-    pushGenericAlignmentDiagnostics(entry, diagnostics);
-    pushArchetypeConsistencyDiagnostics(entry, diagnostics);
-    pushParentFieldNamingDiagnostics(entry, options.registry, diagnostics);
-    pushRegistryDiagnostics(entry, options.registry, diagnostics);
+    pushGenericAlignmentDiagnostics(entry, diagnostics, { skipFactoryComparison: !isFirestoreModel });
   }
   pushOrphanFixtureDiagnostics(extraction, diagnostics);
   pushModelsWithoutFixtureDiagnostics(extraction, options.registry, diagnostics);
@@ -17257,7 +17702,7 @@ function pushForwardingDiagnostics(entry, out) {
     }
   }
 }
-function pushGenericAlignmentDiagnostics(entry, out) {
+function pushGenericAlignmentDiagnostics(entry, out, options = { skipFactoryComparison: false }) {
   const fixGenerics = entry.fixtureExtendsGenerics;
   const instGenerics = entry.instanceExtendsGenerics;
   const factoryGenerics = entry.factory?.genericArgs ?? [];
@@ -17285,6 +17730,7 @@ function pushGenericAlignmentDiagnostics(entry, out) {
       line: entry.fixtureLine
     });
   }
+  if (options.skipFactoryComparison) return;
   if (factoryModel !== void 0 && fixModel !== void 0 && factoryModel !== fixModel) {
     out.push({
       code: "generics-misaligned",
@@ -17419,6 +17865,8 @@ function summarizeEntry(entry, full = false) {
   const summary = {
     model: entry.model,
     prefix: entry.prefix,
+    kind: entry.kind,
+    nonModelFamily: entry.nonModelFamily,
     archetype: entry.archetype,
     fixtureClassName: entry.fixtureClassName,
     instanceClassName: entry.instanceClassName,
@@ -17452,9 +17900,16 @@ function formatListAsMarkdown(extraction) {
   if (extraction.entries.length === 0) {
     lines.push("", "_No model fixtures found._");
   } else {
-    lines.push("", "| Model | Archetype | Fixture | Instance | Params | Factory | Singleton | Methods (F/I) | Lines |", "|---|---|---|---|---|---|---|---|---|");
+    lines.push("", "| Model | Kind | Archetype | Fixture | Instance | Params | Factory | Singleton | Methods (F/I) | Lines |", "|---|---|---|---|---|---|---|---|---|---|");
     for (const e of extraction.entries) {
-      lines.push("| " + [e.model, e.archetype, code3(e.fixtureClassName), code3(e.instanceClassName), code3(e.paramsTypeName), code3(e.factoryName ?? "\u2014"), code3(e.singletonName ?? "\u2014"), `${e.fixtureMethods.length}/${e.instanceMethods.length}`, `${e.fixtureLine}-${e.instanceEndLine}`].join(" | ") + " |");
+      lines.push("| " + [e.model, e.kind, e.archetype, code3(e.fixtureClassName), code3(e.instanceClassName), code3(e.paramsTypeName), code3(e.factoryName ?? "\u2014"), code3(e.singletonName ?? "\u2014"), `${e.fixtureMethods.length}/${e.instanceMethods.length}`, `${e.fixtureLine}-${e.instanceEndLine}`].join(" | ") + " |");
+    }
+    const nonModelEntries = extraction.entries.filter((e) => e.kind !== "firestore-model");
+    if (nonModelEntries.length > 0) {
+      lines.push("", "### Non-model fixtures");
+      for (const e of nonModelEntries) {
+        lines.push("", `- **${e.model}** \u2014 ${nonModelDescription(e)}`);
+      }
     }
   }
   if (extraction.unrecognizedClassNames.length > 0) {
@@ -17481,7 +17936,21 @@ function formatLookupAsMarkdown2(extraction, entry) {
   return lines.join("\n");
 }
 function appendLookupHeader(lines, extraction, entry) {
-  lines.push(`# Fixture: \`${entry.prefix}${entry.model}\``, "", `Source: \`${extraction.fixturePath}\``, `Archetype: \`${entry.archetype}\``, "");
+  lines.push(`# Fixture: \`${entry.prefix}${entry.model}\``, "", `Source: \`${extraction.fixturePath}\``, `Kind: \`${entry.kind}\``, `Archetype: \`${entry.archetype}\``);
+  if (entry.kind !== "firestore-model") {
+    lines.push("", `> ${nonModelDescription(entry)}`);
+  }
+  lines.push("");
+}
+function nonModelDescription(entry) {
+  if (entry.nonModelFamily === "jsdoc-tag") {
+    return "Tagged `@dbxFixtureNotModel` \u2014 explicitly opted out of model validation.";
+  }
+  const family = KNOWN_NON_MODEL_FIXTURE_FAMILIES.find((f) => f.kind === entry.kind);
+  if (family) {
+    return `${family.description} Registered via \`${family.factoryName}\` (\`${family.module}\`).`;
+  }
+  return "Non-Firestore-model fixture.";
 }
 function appendLookupTriplet(lines, entry) {
   lines.push("## Triplet", "", `- Fixture: \`${entry.fixtureClassName}\` (lines ${entry.fixtureLine}-${entry.fixtureEndLine})`, `- Instance: \`${entry.instanceClassName}\` (lines ${entry.instanceLine}-${entry.instanceEndLine})`, `- Params: \`${entry.paramsTypeName}\``, `- Factory: \`${entry.factoryName ?? "\u2014"}\``, `- Singleton: \`${entry.singletonName ?? "\u2014"}\``);
@@ -17845,7 +18314,7 @@ function topLevelColonIndex(text) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-fixture-list-app.tool.ts
-var ListArgsType2 = type35({
+var ListArgsType2 = type36({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -17873,7 +18342,7 @@ var TOOL4 = {
 };
 async function run4(rawArgs) {
   const parsed = ListArgsType2(rawArgs);
-  if (parsed instanceof type35.errors) {
+  if (parsed instanceof type36.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -17882,7 +18351,7 @@ async function run4(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const apiAbs = resolve20(cwd, parsed.apiDir);
+  const apiAbs = resolve21(cwd, parsed.apiDir);
   let extraction;
   try {
     extraction = await inspectAppFixtures(apiAbs, parsed.apiDir);
@@ -17896,9 +18365,9 @@ async function run4(rawArgs) {
 var modelFixtureListAppTool = { definition: TOOL4, run: run4 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-lookup.tool.ts
-import { resolve as resolve21 } from "node:path";
-import { type as type36 } from "arktype";
-var LookupArgsType2 = type36({
+import { resolve as resolve22 } from "node:path";
+import { type as type37 } from "arktype";
+var LookupArgsType2 = type37({
   apiDir: "string",
   "model?": "string",
   "identity?": "string",
@@ -17930,7 +18399,7 @@ var TOOL5 = {
 };
 async function run5(rawArgs) {
   const parsed = LookupArgsType2(rawArgs);
-  if (parsed instanceof type36.errors) {
+  if (parsed instanceof type37.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   if (!parsed.model && !parsed.identity) {
@@ -17942,7 +18411,7 @@ async function run5(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const apiAbs = resolve21(cwd, parsed.apiDir);
+  const apiAbs = resolve22(cwd, parsed.apiDir);
   let extraction;
   try {
     extraction = await inspectAppFixtures(apiAbs, parsed.apiDir);
@@ -17968,9 +18437,9 @@ function identityToModel4(identity) {
 var modelFixtureLookupTool = { definition: TOOL5, run: run5 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-validate-app.tool.ts
-import { resolve as resolve22 } from "node:path";
-import { type as type37 } from "arktype";
-var ValidateArgsType2 = type37({
+import { resolve as resolve23 } from "node:path";
+import { type as type38 } from "arktype";
+var ValidateArgsType2 = type38({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -18003,7 +18472,7 @@ var TOOL6 = {
 function createModelFixtureValidateAppTool(config = {}) {
   async function run15(rawArgs) {
     const parsed = ValidateArgsType2(rawArgs);
-    if (parsed instanceof type37.errors) {
+    if (parsed instanceof type38.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const cwd = process.cwd();
@@ -18012,7 +18481,7 @@ function createModelFixtureValidateAppTool(config = {}) {
     } catch (err) {
       return toolError(err instanceof Error ? err.message : String(err));
     }
-    const apiAbs = resolve22(cwd, parsed.apiDir);
+    const apiAbs = resolve23(cwd, parsed.apiDir);
     let extraction;
     try {
       extraction = await inspectAppFixtures(apiAbs, parsed.apiDir);
@@ -18033,16 +18502,16 @@ function createModelFixtureValidateAppTool(config = {}) {
 
 // packages/dbx-components-mcp/src/tools/model-fixture-scaffold.tool.ts
 import { readFile as readFile11, writeFile } from "node:fs/promises";
-import { join as join10, resolve as resolve23 } from "node:path";
-import { type as type38 } from "arktype";
-var ScaffoldArgsType3 = type38({
+import { join as join10, resolve as resolve24 } from "node:path";
+import { type as type39 } from "arktype";
+var ScaffoldArgsType3 = type39({
   apiDir: "string",
   model: "string",
   archetype: "'top-level-simple' | 'top-level-with-deps' | 'sub-collection' | 'sub-collection-traversal'",
   "prefix?": "string",
   "parentFixture?": "string",
   "parentFixtureField?": "string",
-  "paramsDependsOn?": type38({
+  "paramsDependsOn?": type39({
     field: "string",
     fixtureModel: "string",
     "optional?": "boolean",
@@ -18103,7 +18572,7 @@ var TOOL7 = {
 };
 async function run6(rawArgs) {
   const parsed = ScaffoldArgsType3(rawArgs);
-  if (parsed instanceof type38.errors) {
+  if (parsed instanceof type39.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -18112,7 +18581,7 @@ async function run6(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const apiAbs = resolve23(cwd, parsed.apiDir);
+  const apiAbs = resolve24(cwd, parsed.apiDir);
   let extraction;
   try {
     extraction = await inspectAppFixtures(apiAbs, parsed.apiDir);
@@ -18203,10 +18672,10 @@ function collectConflicts(extraction, rendered) {
 var modelFixtureScaffoldTool = { definition: TOOL7, run: run6 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-forward.tool.ts
-import { join as join11, resolve as resolve24 } from "node:path";
-import { type as type39 } from "arktype";
+import { join as join11, resolve as resolve25 } from "node:path";
+import { type as type40 } from "arktype";
 import { Project as Project12 } from "ts-morph";
-var ForwardArgsType = type39({
+var ForwardArgsType = type40({
   apiDir: "string",
   model: "string",
   "methods?": "string[]"
@@ -18230,7 +18699,7 @@ var TOOL8 = {
 };
 async function run7(rawArgs) {
   const parsed = ForwardArgsType(rawArgs);
-  if (parsed instanceof type39.errors) {
+  if (parsed instanceof type40.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -18239,7 +18708,7 @@ async function run7(rawArgs) {
   } catch (err) {
     return toolError(toErrorMessage(err));
   }
-  const apiAbs = resolve24(cwd, parsed.apiDir);
+  const apiAbs = resolve25(cwd, parsed.apiDir);
   let extraction;
   try {
     extraction = await inspectAppFixtures(apiAbs, parsed.apiDir);
@@ -18313,8 +18782,8 @@ function appendListSection(lines, heading, names) {
 var modelFixtureForwardTool = { definition: TOOL8, run: run7 };
 
 // packages/dbx-components-mcp/src/tools/model-test-tree.tool.ts
-import { resolve as resolve25 } from "node:path";
-import { type as type40 } from "arktype";
+import { resolve as resolve26 } from "node:path";
+import { type as type41 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-test-shared/extract.ts
 import { Node as Node14, Project as Project13, SyntaxKind as SyntaxKind8 } from "ts-morph";
@@ -19059,7 +19528,7 @@ function parseDescribePath2(value) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-test-tree.tool.ts
-var TreeArgsType = type40({
+var TreeArgsType = type41({
   specFile: "string",
   "apiDir?": "string",
   "view?": "'all' | 'describes' | 'fixtures' | 'its' | 'helpers'",
@@ -19097,7 +19566,7 @@ var TOOL9 = {
 };
 async function run8(rawArgs) {
   const parsed = TreeArgsType(rawArgs);
-  if (parsed instanceof type40.errors) {
+  if (parsed instanceof type41.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -19107,8 +19576,8 @@ async function run8(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const specAbs = resolve25(cwd, parsed.specFile);
-  const apiAbs = parsed.apiDir !== void 0 ? resolve25(cwd, parsed.apiDir) : void 0;
+  const specAbs = resolve26(cwd, parsed.specFile);
+  const apiAbs = parsed.apiDir !== void 0 ? resolve26(cwd, parsed.apiDir) : void 0;
   let tree;
   try {
     tree = await inspectSpecFile({ specAbs, specRel: parsed.specFile, apiAbs, apiRel: parsed.apiDir });
@@ -19124,9 +19593,9 @@ async function run8(rawArgs) {
 var modelTestTreeTool = { definition: TOOL9, run: run8 };
 
 // packages/dbx-components-mcp/src/tools/model-test-search.tool.ts
-import { resolve as resolve26 } from "node:path";
-import { type as type41 } from "arktype";
-var SearchArgsType2 = type41({
+import { resolve as resolve27 } from "node:path";
+import { type as type42 } from "arktype";
+var SearchArgsType2 = type42({
   specFile: "string",
   "apiDir?": "string",
   "model?": "string",
@@ -19167,7 +19636,7 @@ var TOOL10 = {
 };
 async function run9(rawArgs) {
   const parsed = SearchArgsType2(rawArgs);
-  if (parsed instanceof type41.errors) {
+  if (parsed instanceof type42.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const queryFields = [
@@ -19190,8 +19659,8 @@ async function run9(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const specAbs = resolve26(cwd, parsed.specFile);
-  const apiAbs = parsed.apiDir !== void 0 ? resolve26(cwd, parsed.apiDir) : void 0;
+  const specAbs = resolve27(cwd, parsed.specFile);
+  const apiAbs = parsed.apiDir !== void 0 ? resolve27(cwd, parsed.apiDir) : void 0;
   let tree;
   try {
     tree = await inspectSpecFile({ specAbs, specRel: parsed.specFile, apiAbs, apiRel: parsed.apiDir });
@@ -19618,8 +20087,8 @@ function getFunctionType(x) {
   return typeof x === "function" ? x.prototype ? Object.getOwnPropertyDescriptor(x, "prototype")?.writable ? "function" : "class" : x.constructor.name === "AsyncFunction" ? "function" : "arrow" : null;
 }
 function isNonClassFunction(x) {
-  const type65 = getFunctionType(x);
-  return type65 != null && type65 !== "class";
+  const type68 = getFunctionType(x);
+  return type68 != null && type68 !== "class";
 }
 
 // packages/util/src/lib/getter/getter.ts
@@ -19696,9 +20165,9 @@ function asNumber(input) {
 }
 
 // packages/util/src/lib/number/round.ts
-function roundingFunction(type65) {
+function roundingFunction(type68) {
   let fn;
-  switch (type65) {
+  switch (type68) {
     case "floor":
       fn = Math.floor;
       break;
@@ -19951,9 +20420,9 @@ function filterKeyValueTuplesInputToFilter(input) {
 }
 function filterKeyValueTupleFunction(inputFilter) {
   const filter = filterKeyValueTuplesInputToFilter(inputFilter);
-  const { valueFilter: type65 = 1 /* UNDEFINED */, invertFilter: inverseFilter = false, keysFilter } = filter;
+  const { valueFilter: type68 = 1 /* UNDEFINED */, invertFilter: inverseFilter = false, keysFilter } = filter;
   let filterFn;
-  switch (type65) {
+  switch (type68) {
     case 1 /* UNDEFINED */:
       filterFn = ([, x]) => x !== void 0;
       break;
@@ -20212,7 +20681,7 @@ var NUMBER_STRING_DENCODER_64_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd
 var NUMBER_STRING_DENCODER_64_DEFAULT_NEGATIVE_PREFIX = "!";
 function numberStringDencoder(config) {
   const { negativePrefix, digits } = config;
-  const type65 = negativePrefix ? "integer" : "positive_integer";
+  const type68 = negativePrefix ? "integer" : "positive_integer";
   const log2OfDigits = Math.min(6, Math.floor(Math.log2(digits.length)));
   const bitDepth = Math.pow(2, log2OfDigits);
   const bitMask = bitDepth - 1;
@@ -20249,7 +20718,7 @@ function numberStringDencoder(config) {
     return result;
   }
   return {
-    type: type65,
+    type: type68,
     digits,
     bitDepth,
     negativePrefix,
@@ -20320,9 +20789,9 @@ function readableStreamToStringFunction(encoding) {
 var readableStreamToBase64 = readableStreamToStringFunction("base64");
 function readableStreamToBuffer(stream) {
   const chunks = [];
-  return new Promise((resolve39, reject) => {
+  return new Promise((resolve41, reject) => {
     stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    stream.on("end", () => resolve39(Buffer.concat(chunks)));
+    stream.on("end", () => resolve41(Buffer.concat(chunks)));
     stream.on("error", reject);
   });
 }
@@ -24106,7 +24575,7 @@ var systemMValidateFolderTool = createFolderValidateTool({
 });
 
 // packages/dbx-components-mcp/src/tools/lookup-action.tool.ts
-import { type as type42 } from "arktype";
+import { type as type43 } from "arktype";
 var DBX_ACTION_LOOKUP_TOOL = {
   name: "dbx_action_lookup",
   description: [
@@ -24139,13 +24608,13 @@ var DBX_ACTION_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupActionArgsType = type42({
+var LookupActionArgsType = type43({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupActionArgs(raw) {
   const parsed = LookupActionArgsType(raw);
-  if (parsed instanceof type42.errors) {
+  if (parsed instanceof type43.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -24443,7 +24912,7 @@ function createLookupActionTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/action-examples.tool.ts
-import { type as type43 } from "arktype";
+import { type as type44 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/data/patterns/actions/action.auto-trigger-on-modify.pattern.ts
 var ACTION_PATTERN_AUTO_TRIGGER_ON_MODIFY = {
@@ -24803,13 +25272,13 @@ var DBX_ACTION_EXAMPLES_TOOL = {
     required: ["pattern"]
   }
 };
-var ActionExamplesArgsType = type43({
+var ActionExamplesArgsType = type44({
   pattern: "string",
   "depth?": "'minimal' | 'brief' | 'full'"
 });
 function parseActionExamplesArgs(raw) {
   const parsed = ActionExamplesArgsType(raw);
-  if (parsed instanceof type43.errors) {
+  if (parsed instanceof type44.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -24871,7 +25340,7 @@ var actionExamplesTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/action-scaffold.tool.ts
-import { type as type44 } from "arktype";
+import { type as type45 } from "arktype";
 var TRIGGER_VALUES = ["button", "form", "auto-modify"];
 var SUCCESS_FEEDBACK_VALUES = ["snackbar", "redirect", "none"];
 var CONTEXT_PROVIDER_VALUES = ["inline", "parent", "host-component"];
@@ -24905,7 +25374,7 @@ var DBX_ACTION_SCAFFOLD_TOOL = {
     required: ["use_case", "trigger", "value_type"]
   }
 };
-var ScaffoldArgsType4 = type44({
+var ScaffoldArgsType4 = type45({
   use_case: "string",
   trigger: "'button' | 'form' | 'auto-modify'",
   "confirm?": "boolean",
@@ -24916,7 +25385,7 @@ var ScaffoldArgsType4 = type44({
 });
 function parseScaffoldArgs2(raw) {
   const parsed = ScaffoldArgsType4(raw);
-  if (parsed instanceof type44.errors) {
+  if (parsed instanceof type45.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const useCase = parsed.use_case.trim();
@@ -25122,11 +25591,11 @@ var actionScaffoldTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-tree.tool.ts
-import { type as type45 } from "arktype";
+import { type as type46 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/route/load-sources.ts
 import { glob as fsGlob4, readFile as readFile16, stat as stat12 } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute7, resolve as resolve27, sep as sep9 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute8, resolve as resolve28, sep as sep9 } from "node:path";
 
 // packages/dbx-components-mcp/src/tools/route/extract.ts
 import { Node as Node19, Project as Project16, SyntaxKind as SyntaxKind12 } from "ts-morph";
@@ -25441,7 +25910,7 @@ function computeRelativeSpecifiers(source) {
 // packages/dbx-components-mcp/src/tools/route/load-sources.ts
 var TRY_EXTENSIONS = [".ts", ".tsx", "/index.ts", "/index.tsx"];
 async function loadRouteSources(args) {
-  const cwdResolved = args.cwd ? resolve27(process.cwd(), args.cwd) : process.cwd();
+  const cwdResolved = args.cwd ? resolve28(process.cwd(), args.cwd) : process.cwd();
   guardCwdInsideServer(args.cwd, cwdResolved);
   const collected = /* @__PURE__ */ new Map();
   if (args.sources) {
@@ -25513,7 +25982,7 @@ async function loadOne(relative17, cwd, into) {
   if (into.has(relative17)) {
     return;
   }
-  const absolute = resolve27(cwd, relative17);
+  const absolute = resolve28(cwd, relative17);
   const cwdPrefix = cwd.endsWith(sep9) ? cwd : cwd + sep9;
   if (!absolute.startsWith(cwdPrefix) && absolute !== cwd) {
     throw new Error(`Path \`${relative17}\` resolves outside the server cwd and is not allowed.`);
@@ -25525,9 +25994,9 @@ async function resolveRelativeImport(fromFile, specifier, cwd) {
   if (!specifier.startsWith(".")) {
     return void 0;
   }
-  const fromAbsolute = isAbsolute7(fromFile) ? fromFile : resolve27(cwd, fromFile);
-  const fromDir = dirname7(fromAbsolute);
-  const baseAbsolute = resolve27(fromDir, specifier);
+  const fromAbsolute = isAbsolute8(fromFile) ? fromFile : resolve28(cwd, fromFile);
+  const fromDir = dirname8(fromAbsolute);
+  const baseAbsolute = resolve28(fromDir, specifier);
   const cwdPrefix = cwd.endsWith(sep9) ? cwd : cwd + sep9;
   for (const ext of TRY_EXTENSIONS) {
     const candidateAbsolute = baseAbsolute + ext;
@@ -25906,8 +26375,8 @@ var DBX_ROUTE_TREE_TOOL = {
     }
   }
 };
-var TreeArgsType2 = type45({
-  "sources?": type45({ name: "string", text: "string" }).array(),
+var TreeArgsType2 = type46({
+  "sources?": type46({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string",
   "format?": "'markdown' | 'json' | 'flat'",
@@ -25916,7 +26385,7 @@ var TreeArgsType2 = type45({
 });
 function parseArgs4(raw) {
   const parsed = TreeArgsType2(raw);
-  if (parsed instanceof type45.errors) {
+  if (parsed instanceof type46.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -25966,7 +26435,7 @@ var routeTreeTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-lookup.tool.ts
-import { type as type46 } from "arktype";
+import { type as type47 } from "arktype";
 var DBX_ROUTE_LOOKUP_TOOL = {
   name: "dbx_route_lookup",
   description: ["Look up a single UIRouter state by name, full URL, or component class name. Returns the state's URL, component, parent chain, params, resolves, siblings, and children.", "", "Provide at least one of `sources` / `paths` / `glob` to point the tool at the source set, plus a `topic`.", "", "Resolution order: exact state name \u2192 URL path \u2192 component class name \u2192 fuzzy substring (returns up to 5 candidates)."].join("\n"),
@@ -25991,9 +26460,9 @@ var DBX_ROUTE_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupArgsType3 = type46({
+var LookupArgsType3 = type47({
   topic: "string",
-  "sources?": type46({ name: "string", text: "string" }).array(),
+  "sources?": type47({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string",
   "depth?": "'brief' | 'full'",
@@ -26001,7 +26470,7 @@ var LookupArgsType3 = type46({
 });
 function parseArgs5(raw) {
   const parsed = LookupArgsType3(raw);
-  if (parsed instanceof type46.errors) {
+  if (parsed instanceof type47.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -26194,7 +26663,7 @@ var routeLookupTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-search.tool.ts
-import { type as type47 } from "arktype";
+import { type as type48 } from "arktype";
 var DBX_ROUTE_SEARCH_TOOL = {
   name: "dbx_route_search",
   description: ["Search the UIRouter state tree of a dbx-components app. Matches against state names, full URLs, component class names, resolve keys, and source-file paths. Returns the top 10 results with state name, URL, component, and source location.", "", "Provide at least one of `sources` / `paths` / `glob` plus a `query`. `scope` narrows to a single axis (`name`, `url`, `component`, `resolve`)."].join("\n"),
@@ -26218,9 +26687,9 @@ var DBX_ROUTE_SEARCH_TOOL = {
     required: ["query"]
   }
 };
-var SearchArgsType3 = type47({
+var SearchArgsType3 = type48({
   query: "string",
-  "sources?": type47({ name: "string", text: "string" }).array(),
+  "sources?": type48({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string",
   "scope?": "'name' | 'url' | 'component' | 'resolve' | 'all'",
@@ -26228,7 +26697,7 @@ var SearchArgsType3 = type47({
 });
 function parseArgs6(raw) {
   const parsed = SearchArgsType3(raw);
-  if (parsed instanceof type47.errors) {
+  if (parsed instanceof type48.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -26321,14 +26790,14 @@ var routeSearchTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/_lookup.factory.ts
-import { type as type48 } from "arktype";
-var LOOKUP_ARGS_TYPE = type48({
+import { type as type49 } from "arktype";
+var LOOKUP_ARGS_TYPE = type49({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupArgs(raw) {
   const parsed = LOOKUP_ARGS_TYPE(raw);
-  if (parsed instanceof type48.errors) {
+  if (parsed instanceof type49.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -26530,7 +26999,7 @@ function createLookupFilterTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/filter-scaffold.tool.ts
-import { type as type49 } from "arktype";
+import { type as type50 } from "arktype";
 var DBX_FILTER_SCAFFOLD_TOOL = {
   name: "dbx_filter_scaffold",
   description: [
@@ -26555,7 +27024,7 @@ var DBX_FILTER_SCAFFOLD_TOOL = {
     required: ["model_name", "filter_type"]
   }
 };
-var ScaffoldArgsType5 = type49({
+var ScaffoldArgsType5 = type50({
   model_name: "string",
   filter_type: "string",
   "preset_keys?": "string[]",
@@ -26563,7 +27032,7 @@ var ScaffoldArgsType5 = type49({
 });
 function parseArgs7(raw) {
   const parsed = ScaffoldArgsType5(raw);
-  if (parsed instanceof type49.errors) {
+  if (parsed instanceof type50.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const modelName = parsed.model_name.trim();
@@ -26803,8 +27272,8 @@ function createLookupPipeTool(input) {
 
 // packages/dbx-components-mcp/src/tools/artifact-scaffold.tool.ts
 import { access } from "node:fs/promises";
-import { resolve as resolve28, sep as sep10 } from "node:path";
-import { type as type50 } from "arktype";
+import { resolve as resolve29, sep as sep10 } from "node:path";
+import { type as type51 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/artifact-scaffold/templates.ts
 function splitWords(input) {
@@ -27352,7 +27821,7 @@ var DBX_ARTIFACT_SCAFFOLD_TOOL = {
     required: ["artifact", "name", "componentDir", "apiDir"]
   }
 };
-var ScaffoldArtifactArgsType = type50({
+var ScaffoldArtifactArgsType = type51({
   artifact: ARTIFACT_KIND_LITERAL_UNION,
   name: "string",
   componentDir: "string",
@@ -27365,7 +27834,7 @@ var ScaffoldArtifactArgsType = type50({
 });
 function parseArgs8(raw) {
   const parsed = ScaffoldArtifactArgsType(raw);
-  if (parsed instanceof type50.errors) {
+  if (parsed instanceof type51.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -27378,7 +27847,7 @@ function parseArgs8(raw) {
   return result;
 }
 function ensureInsideCwd(relativePath, cwd) {
-  const absolute = resolve28(cwd, relativePath);
+  const absolute = resolve29(cwd, relativePath);
   const cwdPrefix = cwd.endsWith(sep10) ? cwd : cwd + sep10;
   if (!absolute.startsWith(cwdPrefix) && absolute !== cwd) {
     throw new Error(`Path \`${relativePath}\` resolves outside the server cwd and is not allowed.`);
@@ -27418,7 +27887,7 @@ async function runArtifactScaffold(rawArgs) {
     const message = err instanceof Error ? err.message : String(err);
     return toolError(`Scaffold failed: ${message}`);
   }
-  const checked = await applyIdempotency(raw, (relativePath) => fileExists2(resolve28(cwd, relativePath)));
+  const checked = await applyIdempotency(raw, (relativePath) => fileExists2(resolve29(cwd, relativePath)));
   const text = formatResult9(checked);
   const result = {
     content: [{ type: "text", text }]
@@ -27431,7 +27900,7 @@ var artifactScaffoldTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/artifact-file-convention.tool.ts
-import { type as type51 } from "arktype";
+import { type as type52 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/artifact-file-convention/spec.ts
 var FIRESTORE_MODEL = {
@@ -27867,7 +28336,7 @@ var DBX_ARTIFACT_FILE_CONVENTION_TOOL = {
     required: ["artifact"]
   }
 };
-var FileConventionArgsType = type51({
+var FileConventionArgsType = type52({
   artifact: ARTIFACT_KIND_LITERAL_UNION2,
   "componentDir?": "string",
   "apiDir?": "string",
@@ -27875,7 +28344,7 @@ var FileConventionArgsType = type51({
 });
 function parseArgs9(raw) {
   const parsed = FileConventionArgsType(raw);
-  if (parsed instanceof type51.errors) {
+  if (parsed instanceof type52.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -27908,8 +28377,8 @@ var artifactFileConventionTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/explain-rule.tool.ts
-import { type as type52 } from "arktype";
-var ExplainRuleArgsType = type52({
+import { type as type53 } from "arktype";
+var ExplainRuleArgsType = type53({
   code: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -27938,7 +28407,7 @@ var TOOL11 = {
 };
 async function run10(rawArgs) {
   const parsed = ExplainRuleArgsType(rawArgs);
-  if (parsed instanceof type52.errors) {
+  if (parsed instanceof type53.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const exact = findRule(parsed.code);
@@ -27963,11 +28432,11 @@ async function run10(rawArgs) {
 var explainRuleTool = { definition: TOOL11, run: run10 };
 
 // packages/dbx-components-mcp/src/tools/app-validate.tool.ts
-import { resolve as resolve29, join as join15 } from "node:path";
+import { resolve as resolve30, join as join15 } from "node:path";
 import { readdir as readdir10, stat as stat13 } from "node:fs/promises";
-import { type as type53 } from "arktype";
+import { type as type54 } from "arktype";
 var Cluster = "'storagefile_m' | 'notification_m' | 'model_folder' | 'system_m' | 'fixture'";
-var AppValidateArgsType = type53({
+var AppValidateArgsType = type54({
   componentDir: "string",
   apiDir: "string",
   "format?": "'markdown' | 'json'",
@@ -28007,7 +28476,7 @@ var TOOL12 = {
 };
 async function run11(rawArgs) {
   const parsed = AppValidateArgsType(rawArgs);
-  if (parsed instanceof type53.errors) {
+  if (parsed instanceof type54.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -28017,8 +28486,8 @@ async function run11(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const componentAbs = resolve29(cwd, parsed.componentDir);
-  const apiAbs = resolve29(cwd, parsed.apiDir);
+  const componentAbs = resolve30(cwd, parsed.componentDir);
+  const apiAbs = resolve30(cwd, parsed.apiDir);
   const skip = new Set(parsed.skip ?? []);
   const findings = [];
   const skipped = [];
@@ -28216,8 +28685,8 @@ function formatJson(report) {
 var appValidateTool = { definition: TOOL12, run: run11 };
 
 // packages/dbx-components-mcp/src/tools/model-list-component.tool.ts
-import { resolve as resolve30 } from "node:path";
-import { type as type54 } from "arktype";
+import { resolve as resolve31 } from "node:path";
+import { type as type55 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-list-component/extract.ts
 import { readdir as readdir11, readFile as readFile17, stat as stat14 } from "node:fs/promises";
@@ -28485,7 +28954,7 @@ function stripCoverage(model) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-list-component.tool.ts
-var ListArgsType3 = type54({
+var ListArgsType3 = type55({
   componentDir: "string",
   "apiDir?": "string",
   "format?": "'markdown' | 'json'"
@@ -28516,7 +28985,7 @@ var TOOL13 = {
 };
 async function run12(rawArgs) {
   const parsed = ListArgsType3(rawArgs);
-  if (parsed instanceof type54.errors) {
+  if (parsed instanceof type55.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -28526,8 +28995,8 @@ async function run12(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const componentAbs = resolve30(cwd, parsed.componentDir);
-  const apiAbs = parsed.apiDir ? resolve30(cwd, parsed.apiDir) : void 0;
+  const componentAbs = resolve31(cwd, parsed.componentDir);
+  const apiAbs = parsed.apiDir ? resolve31(cwd, parsed.apiDir) : void 0;
   let report;
   try {
     report = await listComponentModels(componentAbs, { componentDir: parsed.componentDir, apiDir: parsed.apiDir, apiAbs });
@@ -28541,12 +29010,12 @@ async function run12(rawArgs) {
 var modelListComponentTool = { definition: TOOL13, run: run12 };
 
 // packages/dbx-components-mcp/src/tools/server-actions-list-app.tool.ts
-import { resolve as resolve31 } from "node:path";
-import { type as type55 } from "arktype";
+import { resolve as resolve32 } from "node:path";
+import { type as type56 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/server-actions-list-app/extract.ts
 import { readdir as readdir12, readFile as readFile18, stat as stat15 } from "node:fs/promises";
-import { dirname as dirname8, join as join17, relative as relative11, sep as sep12 } from "node:path";
+import { dirname as dirname9, join as join17, relative as relative11, sep as sep12 } from "node:path";
 import { Node as Node21, Project as Project18 } from "ts-morph";
 var ACTION_SERVER_SUFFIX2 = ".action.server.ts";
 var COMMON_MODEL_SUBPATH2 = "src/app/common/model";
@@ -28654,7 +29123,7 @@ async function inspectSiblingModule(actionFilePath, className) {
   return { modulePath: moduleCandidates[0], providedByModule: false, exportedByModule: false };
 }
 async function findModuleCandidates(actionFilePath) {
-  const dir = dirname8(actionFilePath);
+  const dir = dirname9(actionFilePath);
   const out = [];
   try {
     const entries = await readdir12(dir, { withFileTypes: true });
@@ -28841,7 +29310,7 @@ async function listAppServerActions(apiAbs, options) {
 }
 
 // packages/dbx-components-mcp/src/tools/server-actions-list-app.tool.ts
-var ListArgsType4 = type55({
+var ListArgsType4 = type56({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -28870,7 +29339,7 @@ var TOOL14 = {
 };
 async function run13(rawArgs) {
   const parsed = ListArgsType4(rawArgs);
-  if (parsed instanceof type55.errors) {
+  if (parsed instanceof type56.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -28879,7 +29348,7 @@ async function run13(rawArgs) {
   } catch (err) {
     return toolError(err instanceof Error ? err.message : String(err));
   }
-  const apiAbs = resolve31(cwd, parsed.apiDir);
+  const apiAbs = resolve32(cwd, parsed.apiDir);
   let report;
   try {
     report = await listAppServerActions(apiAbs, { apiDir: parsed.apiDir });
@@ -28893,16 +29362,16 @@ async function run13(rawArgs) {
 var serverActionsListAppTool = { definition: TOOL14, run: run13 };
 
 // packages/dbx-components-mcp/src/tools/mcp-config.tool.ts
-import { type as type62 } from "arktype";
-import { resolve as resolve38 } from "node:path";
+import { type as type63 } from "arktype";
+import { resolve as resolve39 } from "node:path";
 
 // packages/dbx-components-mcp/src/tools/mcp-config/snapshot.ts
-import { dirname as dirname9, isAbsolute as isAbsolute8, relative as relative12, resolve as resolve33 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute9, relative as relative12, resolve as resolve34 } from "node:path";
 import { stat as stat17 } from "node:fs/promises";
 
 // packages/dbx-components-mcp/src/scan/discover-downstream-packages.ts
 import { glob as fsGlob5, readFile as readFile19, stat as stat16 } from "node:fs/promises";
-import { basename as basename7, join as join18, resolve as resolve32, sep as sep13 } from "node:path";
+import { basename as basename7, join as join18, resolve as resolve33, sep as sep13 } from "node:path";
 var COMPONENT_GLOBS = ["components/*-firebase", "components/*-shared", "components/*-web", "components/*-core"];
 var APPS_GLOB = "apps/*";
 var SCAN_CONFIG_FILENAME2 = "dbx-mcp.scan.json";
@@ -28947,7 +29416,7 @@ function normaliseExplicitDirs(dirs) {
   return result;
 }
 async function inspectPackage2(workspaceRoot, relDir) {
-  const absDir = resolve32(workspaceRoot, relDir);
+  const absDir = resolve33(workspaceRoot, relDir);
   const isDir = await isDirectory2(absDir);
   if (!isDir) return void 0;
   const packageName = await readPackageName2(absDir, relDir);
@@ -29053,7 +29522,7 @@ function mergeClusters(...lists) {
 async function buildSnapshot(input) {
   const { workspaceRoot, explicitDirs } = input;
   const configResult = await findAndLoadConfig({ cwd: workspaceRoot });
-  const configBaseDir = configResult.configPath !== null ? dirname9(configResult.configPath) : workspaceRoot;
+  const configBaseDir = configResult.configPath !== null ? dirname10(configResult.configPath) : workspaceRoot;
   const registeredSources = await collectRegisteredSources(configResult.config, configBaseDir, workspaceRoot);
   const packages = await discoverDownstreamPackages({ workspaceRoot, explicitDirs });
   const packageSnapshots = packages.map((pkg) => ({
@@ -29075,7 +29544,7 @@ async function collectRegisteredSources(config, configBaseDir, workspaceRoot) {
   for (const cluster of DOWNSTREAM_CLUSTERS) {
     const declared = config[cluster]?.sources ?? [];
     for (const declaredPath of declared) {
-      const absolutePath = isAbsolute8(declaredPath) ? declaredPath : resolve33(configBaseDir, declaredPath);
+      const absolutePath = isAbsolute9(declaredPath) ? declaredPath : resolve34(configBaseDir, declaredPath);
       const exists = await fileExists4(absolutePath);
       const relativePath = relativeOrAbsolute(workspaceRoot, absolutePath);
       out.push({ cluster, declaredPath, absolutePath, relativePath, exists });
@@ -29113,8 +29582,19 @@ function relativeOrAbsolute(from, target) {
 
 // packages/dbx-components-mcp/src/tools/mcp-config/init.ts
 import { writeFile as nodeWriteFile3, mkdir as nodeMkdir, readFile as nodeReadFile7 } from "node:fs/promises";
-import { dirname as dirname10, relative as relative13, resolve as resolve34 } from "node:path";
+import { dirname as dirname11, relative as relative13, resolve as resolve35 } from "node:path";
 var HEURISTIC_CLUSTERS = ["uiComponents", "forgeFields", "pipes", "actions", "filters"];
+var CLUSTER_FILENAME_SEGMENT = {
+  semanticTypes: "semantic",
+  uiComponents: "ui",
+  forgeFields: "forge",
+  pipes: "pipes",
+  actions: "actions",
+  filters: "filters"
+};
+function clusterFilenameSegment(cluster) {
+  return CLUSTER_FILENAME_SEGMENT[cluster];
+}
 var DEFAULT_INCLUDE = ["src/**/*.ts"];
 var DEFAULT_EXCLUDE = ["**/*.spec.ts", "**/*.test.ts", "**/*.stories.ts"];
 async function buildInitPlan(input) {
@@ -29136,14 +29616,14 @@ async function applyInitPlan(plan, opts) {
   const mkdir = opts?.mkdir ?? defaultMkdir;
   for (const change of plan.changes) {
     if (change.reason === "unchanged") continue;
-    await mkdir(dirname10(change.absolutePath));
+    await mkdir(dirname11(change.absolutePath));
     await writeFile2(change.absolutePath, change.after);
   }
 }
 async function planPackageScanConfig(input) {
   const { snapshot, packageSnapshot, readFile: readFile20 } = input;
   const { pkg } = packageSnapshot;
-  const scanConfigPath = resolve34(pkg.absDir, "dbx-mcp.scan.json");
+  const scanConfigPath = resolve35(pkg.absDir, "dbx-mcp.scan.json");
   const before = await tryRead(scanConfigPath, readFile20);
   const parsed = parseExisting(before);
   const targetClusters = HEURISTIC_CLUSTERS.filter((c) => pkg.candidateClusters.includes(c));
@@ -29154,7 +29634,7 @@ async function planPackageScanConfig(input) {
   if (next.version !== 1) next.version = 1;
   const sourcesToRegister = [];
   if (typeof next.topicNamespace === "string" && Array.isArray(next.include)) {
-    const outValue = typeof next.out === "string" && next.out.length > 0 ? next.out : `${pkg.slug}.semantic-types.json`;
+    const outValue = typeof next.out === "string" && next.out.length > 0 ? next.out : `${pkg.slug}.${clusterFilenameSegment("semanticTypes")}.json`;
     const declaredOut = resolveScanOut(scanConfigPath, outValue);
     sourcesToRegister.push({ cluster: "semanticTypes", relPath: relativeFromConfig(snapshot, declaredOut) });
   }
@@ -29187,7 +29667,7 @@ async function planPackageScanConfig(input) {
 }
 async function planRootConfig(input) {
   const { snapshot, sourcesToRegister, readFile: readFile20 } = input;
-  const configPath = snapshot.configPath ?? resolve34(snapshot.workspaceRoot, "dbx-mcp.config.json");
+  const configPath = snapshot.configPath ?? resolve35(snapshot.workspaceRoot, "dbx-mcp.config.json");
   const before = snapshot.configPath !== null ? await tryRead(configPath, readFile20) : null;
   const baseConfig = snapshot.config !== null ? cloneConfig(snapshot.config) : { version: 1 };
   if (baseConfig.version !== 1) baseConfig.version = 1;
@@ -29216,14 +29696,14 @@ async function planRootConfig(input) {
   };
 }
 function defaultOutFor(input) {
-  const targetAbs = resolve34(input.snapshot.workspaceRoot, ".tmp/dbx-mcp", `${input.slug}.${input.cluster}.json`);
-  return relative13(dirname10(input.scanConfigPath), targetAbs).split("\\").join("/");
+  const targetAbs = resolve35(input.snapshot.workspaceRoot, ".tmp/dbx-mcp", `${input.slug}.${clusterFilenameSegment(input.cluster)}.json`);
+  return relative13(dirname11(input.scanConfigPath), targetAbs).split("\\").join("/");
 }
 function resolveScanOut(scanConfigPath, out) {
-  return resolve34(dirname10(scanConfigPath), out);
+  return resolve35(dirname11(scanConfigPath), out);
 }
 function relativeFromConfig(snapshot, absolute) {
-  const configDir = snapshot.configPath !== null ? dirname10(snapshot.configPath) : snapshot.workspaceRoot;
+  const configDir = snapshot.configPath !== null ? dirname11(snapshot.configPath) : snapshot.workspaceRoot;
   return relative13(configDir, absolute).split("\\").join("/");
 }
 function workspaceRel(workspaceRoot, absolute) {
@@ -29267,8 +29747,8 @@ var defaultMkdir = async (dir) => {
 };
 
 // packages/dbx-components-mcp/src/scan/actions-build-manifest.ts
-import { relative as relative14, resolve as resolve35 } from "node:path";
-import { type as type57 } from "arktype";
+import { relative as relative14, resolve as resolve36 } from "node:path";
+import { type as type58 } from "arktype";
 import { Project as Project19 } from "ts-morph";
 
 // packages/dbx-components-mcp/src/scan/actions-extract.ts
@@ -29571,15 +30051,15 @@ function readMethodDescription(method) {
 }
 
 // packages/dbx-components-mcp/src/scan/actions-scan-config-schema.ts
-import { type as type56 } from "arktype";
-var ActionsScanSection = type56({
+import { type as type57 } from "arktype";
+var ActionsScanSection = type57({
   "source?": "string",
   "module?": "string",
   include: "string[] >= 1",
   "exclude?": "string[]",
   "out?": "string"
 });
-var ActionsScanConfig = type56({
+var ActionsScanConfig = type57({
   version: "1",
   actions: ActionsScanSection
 });
@@ -29591,8 +30071,8 @@ var DEFAULT_READ_FILE9 = defaultReadFile;
 var DEFAULT_GLOBBER4 = defaultGlobber;
 async function buildActionsManifest(input) {
   const { projectRoot, generator, readFile: readFile20 = DEFAULT_READ_FILE9, globber = DEFAULT_GLOBBER4, now = () => /* @__PURE__ */ new Date() } = input;
-  const configPath = resolve35(projectRoot, ACTIONS_SCAN_CONFIG_FILENAME);
-  const packagePath = resolve35(projectRoot, "package.json");
+  const configPath = resolve36(projectRoot, ACTIONS_SCAN_CONFIG_FILENAME);
+  const packagePath = resolve36(projectRoot, "package.json");
   const configOutcome = await loadScanConfig4(configPath, readFile20);
   if (configOutcome.kind !== "ok") return configOutcome.outcome;
   const scanSection = configOutcome.section;
@@ -29602,7 +30082,7 @@ async function buildActionsManifest(input) {
   const filePaths = await globber({ projectRoot, include: scanSection.include, exclude: scanSection.exclude ?? [] });
   const project = new Project19({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
   for (const relPath of filePaths) {
-    const absolute = resolve35(projectRoot, relPath);
+    const absolute = resolve36(projectRoot, relPath);
     const text = await readFile20(absolute);
     project.createSourceFile(absolute, text, { overwrite: true });
   }
@@ -29620,10 +30100,10 @@ async function buildActionsManifest(input) {
   };
   const validated = ActionManifest(manifest);
   let outcome;
-  if (validated instanceof type57.errors) {
+  if (validated instanceof type58.errors) {
     outcome = { kind: "invalid-manifest", error: validated.summary };
   } else {
-    const outPath = resolve35(projectRoot, scanSection.out ?? DEFAULT_ACTIONS_SCAN_OUT_PATH);
+    const outPath = resolve36(projectRoot, scanSection.out ?? DEFAULT_ACTIONS_SCAN_OUT_PATH);
     outcome = {
       kind: "success",
       manifest: validated,
@@ -29654,7 +30134,7 @@ async function loadScanConfig4(configPath, readFile20) {
     }
     if (parseError === null) {
       const validated = ActionsScanConfig(parsed);
-      if (validated instanceof type57.errors) {
+      if (validated instanceof type58.errors) {
         result = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: validated.summary } };
       } else {
         result = { kind: "ok", section: validated.actions };
@@ -29785,8 +30265,8 @@ function formatExtractWarning3(warning) {
 }
 
 // packages/dbx-components-mcp/src/scan/filters-build-manifest.ts
-import { relative as relative15, resolve as resolve36 } from "node:path";
-import { type as type59 } from "arktype";
+import { relative as relative15, resolve as resolve37 } from "node:path";
+import { type as type60 } from "arktype";
 import { Project as Project20 } from "ts-morph";
 
 // packages/dbx-components-mcp/src/scan/filters-extract.ts
@@ -29979,15 +30459,15 @@ function extractOutputs3(decl) {
 }
 
 // packages/dbx-components-mcp/src/scan/filters-scan-config-schema.ts
-import { type as type58 } from "arktype";
-var FiltersScanSection = type58({
+import { type as type59 } from "arktype";
+var FiltersScanSection = type59({
   "source?": "string",
   "module?": "string",
   include: "string[] >= 1",
   "exclude?": "string[]",
   "out?": "string"
 });
-var FiltersScanConfig = type58({
+var FiltersScanConfig = type59({
   version: "1",
   filters: FiltersScanSection
 });
@@ -29999,8 +30479,8 @@ var DEFAULT_READ_FILE10 = defaultReadFile;
 var DEFAULT_GLOBBER5 = defaultGlobber;
 async function buildFiltersManifest(input) {
   const { projectRoot, generator, readFile: readFile20 = DEFAULT_READ_FILE10, globber = DEFAULT_GLOBBER5, now = () => /* @__PURE__ */ new Date() } = input;
-  const configPath = resolve36(projectRoot, FILTERS_SCAN_CONFIG_FILENAME);
-  const packagePath = resolve36(projectRoot, "package.json");
+  const configPath = resolve37(projectRoot, FILTERS_SCAN_CONFIG_FILENAME);
+  const packagePath = resolve37(projectRoot, "package.json");
   const configOutcome = await loadScanConfig5(configPath, readFile20);
   if (configOutcome.kind !== "ok") {
     return configOutcome.outcome;
@@ -30018,7 +30498,7 @@ async function buildFiltersManifest(input) {
   });
   const project = new Project20({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
   for (const relPath of filePaths) {
-    const absolute = resolve36(projectRoot, relPath);
+    const absolute = resolve37(projectRoot, relPath);
     const text = await readFile20(absolute);
     project.createSourceFile(absolute, text, { overwrite: true });
   }
@@ -30036,10 +30516,10 @@ async function buildFiltersManifest(input) {
   };
   const validated = FilterManifest(manifest);
   let outcome;
-  if (validated instanceof type59.errors) {
+  if (validated instanceof type60.errors) {
     outcome = { kind: "invalid-manifest", error: validated.summary };
   } else {
-    const outPath = resolve36(projectRoot, scanSection.out ?? DEFAULT_FILTERS_SCAN_OUT_PATH);
+    const outPath = resolve37(projectRoot, scanSection.out ?? DEFAULT_FILTERS_SCAN_OUT_PATH);
     outcome = {
       kind: "success",
       manifest: validated,
@@ -30070,7 +30550,7 @@ async function loadScanConfig5(configPath, readFile20) {
     }
     if (parseError === null) {
       const validated = FiltersScanConfig(parsed);
-      if (validated instanceof type59.errors) {
+      if (validated instanceof type60.errors) {
         result = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: validated.summary } };
       } else {
         result = { kind: "ok", section: validated.filters };
@@ -30163,8 +30643,8 @@ function formatExtractWarning4(warning) {
 }
 
 // packages/dbx-components-mcp/src/scan/pipes-build-manifest.ts
-import { relative as relative16, resolve as resolve37 } from "node:path";
-import { type as type61 } from "arktype";
+import { relative as relative16, resolve as resolve38 } from "node:path";
+import { type as type62 } from "arktype";
 import { Project as Project21 } from "ts-morph";
 
 // packages/dbx-components-mcp/src/scan/pipes-extract.ts
@@ -30400,10 +30880,10 @@ function readTransformSignature(method, fallbackParamDescriptions) {
   for (let i = 1; i < params.length; i += 1) {
     const param = params[i];
     const name = param.getName();
-    const type65 = readParamType(param);
+    const type68 = readParamType(param);
     const description = methodParamDescriptions.get(name) ?? fallbackParamDescriptions.get(name) ?? "";
     const required = !param.isOptional() && !param.hasInitializer();
-    args.push({ name, type: type65, description, required });
+    args.push({ name, type: type68, description, required });
   }
   return { inputType, outputType, args };
 }
@@ -30440,15 +30920,15 @@ function extractParamName(rawTag) {
 }
 
 // packages/dbx-components-mcp/src/scan/pipes-scan-config-schema.ts
-import { type as type60 } from "arktype";
-var PipesScanSection = type60({
+import { type as type61 } from "arktype";
+var PipesScanSection = type61({
   "source?": "string",
   "module?": "string",
   include: "string[] >= 1",
   "exclude?": "string[]",
   "out?": "string"
 });
-var PipesScanConfig = type60({
+var PipesScanConfig = type61({
   version: "1",
   pipes: PipesScanSection
 });
@@ -30460,8 +30940,8 @@ var DEFAULT_READ_FILE11 = defaultReadFile;
 var DEFAULT_GLOBBER6 = defaultGlobber;
 async function buildPipesManifest(input) {
   const { projectRoot, generator, readFile: readFile20 = DEFAULT_READ_FILE11, globber = DEFAULT_GLOBBER6, now = () => /* @__PURE__ */ new Date() } = input;
-  const configPath = resolve37(projectRoot, PIPES_SCAN_CONFIG_FILENAME);
-  const packagePath = resolve37(projectRoot, "package.json");
+  const configPath = resolve38(projectRoot, PIPES_SCAN_CONFIG_FILENAME);
+  const packagePath = resolve38(projectRoot, "package.json");
   const configOutcome = await loadScanConfig6(configPath, readFile20);
   if (configOutcome.kind !== "ok") {
     return configOutcome.outcome;
@@ -30479,7 +30959,7 @@ async function buildPipesManifest(input) {
   });
   const project = new Project21({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
   for (const relPath of filePaths) {
-    const absolute = resolve37(projectRoot, relPath);
+    const absolute = resolve38(projectRoot, relPath);
     const text = await readFile20(absolute);
     project.createSourceFile(absolute, text, { overwrite: true });
   }
@@ -30497,10 +30977,10 @@ async function buildPipesManifest(input) {
   };
   const validated = PipeManifest(manifest);
   let outcome;
-  if (validated instanceof type61.errors) {
+  if (validated instanceof type62.errors) {
     outcome = { kind: "invalid-manifest", error: validated.summary };
   } else {
-    const outPath = resolve37(projectRoot, scanSection.out ?? DEFAULT_PIPES_SCAN_OUT_PATH);
+    const outPath = resolve38(projectRoot, scanSection.out ?? DEFAULT_PIPES_SCAN_OUT_PATH);
     outcome = {
       kind: "success",
       manifest: validated,
@@ -30531,7 +31011,7 @@ async function loadScanConfig6(configPath, readFile20) {
     }
     if (parseError === null) {
       const validated = PipesScanConfig(parsed);
-      if (validated instanceof type61.errors) {
+      if (validated instanceof type62.errors) {
         result = { kind: "fail", outcome: { kind: "invalid-scan-config", configPath, error: validated.summary } };
       } else {
         result = { kind: "ok", section: validated.pipes };
@@ -30880,7 +31360,7 @@ var TOOL15 = {
     required: ["op"]
   }
 };
-var McpConfigArgsType = type62({
+var McpConfigArgsType = type63({
   op: "'status' | 'validate' | 'init' | 'refresh'",
   "cwd?": "string",
   "dryRun?": "boolean",
@@ -30888,12 +31368,12 @@ var McpConfigArgsType = type62({
 });
 function parseArgs10(rawArgs, defaultCwd) {
   const parsed = McpConfigArgsType(rawArgs);
-  if (parsed instanceof type62.errors) {
+  if (parsed instanceof type63.errors) {
     return `Invalid arguments: ${parsed.summary}`;
   }
   let workspaceRoot = defaultCwd;
   if (parsed.cwd !== void 0 && parsed.cwd.length > 0) {
-    workspaceRoot = resolve38(defaultCwd, parsed.cwd);
+    workspaceRoot = resolve39(defaultCwd, parsed.cwd);
   }
   if (parsed.explicitDirs !== void 0) {
     for (const dir of parsed.explicitDirs) {
@@ -30945,7 +31425,7 @@ var mcpConfigTool = {
 };
 
 // packages/dbx-components-mcp/src/tools/lookup-semantic-type.tool.ts
-import { type as type63 } from "arktype";
+import { type as type64 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/semantic-type-lookup.formatter.ts
 function formatSemanticTypeEntry(entry, depth) {
@@ -31126,13 +31606,13 @@ var DBX_SEMANTIC_TYPE_LOOKUP_TOOL = {
     required: ["name"]
   }
 };
-var LookupSemanticTypeArgsType = type63({
+var LookupSemanticTypeArgsType = type64({
   name: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupArgs2(raw) {
   const parsed = LookupSemanticTypeArgsType(raw);
-  if (parsed instanceof type63.errors) {
+  if (parsed instanceof type64.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -31194,7 +31674,7 @@ function formatNotFound11(name, registry) {
 }
 
 // packages/dbx-components-mcp/src/tools/search-semantic-type.tool.ts
-import { type as type64 } from "arktype";
+import { type as type65 } from "arktype";
 var DEFAULT_LIMIT4 = 25;
 var MAX_LIMIT4 = 100;
 var DBX_SEMANTIC_TYPE_SEARCH_TOOL = {
@@ -31227,7 +31707,7 @@ var DBX_SEMANTIC_TYPE_SEARCH_TOOL = {
     }
   }
 };
-var SearchSemanticTypeArgsType = type64({
+var SearchSemanticTypeArgsType = type65({
   "topic?": "string",
   "baseType?": "string",
   "package?": "string",
@@ -31236,7 +31716,7 @@ var SearchSemanticTypeArgsType = type64({
 });
 function parseSearchArgs2(raw) {
   const parsed = SearchSemanticTypeArgsType(raw);
-  if (parsed instanceof type64.errors) {
+  if (parsed instanceof type65.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawLimit = parsed.limit ?? DEFAULT_LIMIT4;
@@ -31347,56 +31827,1273 @@ function describeFilters(args) {
   return parts.join(" \xB7 ");
 }
 
-// packages/dbx-components-mcp/src/tools/index.ts
-var DBX_TOOLS = [
-  // form
-  formExamplesTool,
-  // ui
-  uiExamplesTool,
-  // model
-  lookupModelTool,
-  searchModelTool,
-  modelDecodeTool,
-  modelValidateApiTool,
-  modelApiListAppTool,
-  modelApiLookupTool,
-  modelApiValidateAppTool,
-  modelValidateFolderTool,
-  modelStoreScaffoldTool,
-  modelFixtureListAppTool,
-  modelFixtureLookupTool,
-  modelFixtureScaffoldTool,
-  modelFixtureForwardTool,
-  modelTestTreeTool,
-  modelTestSearchTool,
-  // storagefile_m (model extension)
-  storageFileMValidateAppTool,
-  storageFileMListAppTool,
-  storageFileMValidateFolderTool,
-  // notification_m (model extension)
-  notificationMValidateAppTool,
-  notificationMListAppTool,
-  notificationMValidateFolderTool,
-  // system_m (model extension)
-  systemMValidateFolderTool,
-  // action
-  actionExamplesTool,
-  actionScaffoldTool,
-  // route
-  routeTreeTool,
-  routeLookupTool,
-  routeSearchTool,
-  // filter
-  filterScaffoldTool,
-  // artifact (cross-domain dispatchers)
-  artifactScaffoldTool,
-  artifactFileConventionTool,
-  // rule catalog (cross-domain reference)
-  explainRuleTool,
-  // aggregate orchestrator
-  appValidateTool,
-  // downstream component introspection
-  modelListComponentTool,
+// packages/dbx-components-mcp/src/tools/css-token-lookup.tool.ts
+import { type as type66 } from "arktype";
+
+// packages/dbx-components-mcp/src/tools/css-token-lookup/synonyms.ts
+var INTENT_SYNONYMS = /* @__PURE__ */ new Map([
+  ["subtitle", ["hint", "secondary text", "caption", "muted text"]],
+  ["hint", ["secondary text", "subtitle", "caption", "muted text"]],
+  ["caption", ["hint", "subtitle", "supporting text"]],
+  ["muted", ["hint", "secondary", "subtitle"]],
+  ["card", ["surface", "container", "content-box"]],
+  ["card surface", ["surface", "container", "card background"]],
+  ["card background", ["surface", "container"]],
+  ["section gap", ["default padding", "12px", "padding 3", "card padding"]],
+  ["gap", ["padding", "spacing"]],
+  ["margin", ["spacing"]],
+  ["radius", ["corner", "rounding"]],
+  ["corner", ["radius", "rounding"]],
+  ["shadow", ["elevation"]],
+  ["error", ["warn", "destructive", "danger"]],
+  ["warn", ["error", "destructive"]],
+  ["accent", ["tertiary", "highlight"]],
+  ["outline", ["border", "divider", "stroke"]],
+  ["border", ["outline", "divider"]],
+  ["divider", ["outline", "border"]]
+]);
+function expandIntentQuery(query) {
+  const trimmed = query.trim().toLowerCase();
+  let result;
+  if (trimmed.length === 0) {
+    result = [];
+  } else {
+    const set = /* @__PURE__ */ new Set([trimmed]);
+    const direct = INTENT_SYNONYMS.get(trimmed);
+    if (direct !== void 0) {
+      for (const value of direct) {
+        set.add(value.toLowerCase());
+      }
+    }
+    for (const [key, synonyms] of INTENT_SYNONYMS) {
+      if (trimmed.includes(key)) {
+        for (const value of synonyms) {
+          set.add(value.toLowerCase());
+        }
+      }
+    }
+    result = [...set];
+  }
+  return result;
+}
+
+// packages/dbx-components-mcp/src/tools/css-token-lookup/resolve.ts
+var CONFIDENT_THRESHOLD = 7;
+var MAX_MATCHES = 3;
+var SOURCE_RANK = { "mat-sys": 4, mdc: 3, "dbx-web": 2, app: 1 };
+function resolveToken(registry, input) {
+  let candidates = registry.all;
+  if (input.category !== void 0 && input.category !== "list") {
+    candidates = candidates.filter((c) => c.source === input.category);
+  }
+  if (input.role !== void 0) {
+    candidates = candidates.filter((c) => c.role === input.role);
+  }
+  if (input.component !== void 0) {
+    candidates = candidates.filter((c) => c.componentScope === input.component);
+  }
+  const scored = /* @__PURE__ */ new Map();
+  function add(entry, score) {
+    if (score <= 0) return;
+    const key = `${entry.source}::${entry.cssVariable}`;
+    const previous = scored.get(key);
+    if (previous === void 0 || previous < score) {
+      scored.set(key, score);
+    }
+  }
+  if (input.intent !== void 0 && input.intent.trim().length > 0) {
+    const expanded = expandIntentQuery(input.intent);
+    for (const entry of candidates) {
+      const score = scoreIntent(entry, expanded);
+      if (score > 0) add(entry, score);
+    }
+  }
+  if (input.value !== void 0 && input.value.trim().length > 0) {
+    const trimmed = input.value.trim();
+    const parsedColor = parseColor(trimmed);
+    const parsedLength = parseLength(trimmed);
+    const parsedShadow = parseShadow(trimmed);
+    const legacyHint = isLegacyHintColor(parsedColor);
+    for (const entry of candidates) {
+      let score = 0;
+      if (parsedColor !== null && (entry.role === "color" || entry.role === "text-color" || entry.role === "surface" || entry.role === "shadow")) {
+        score = Math.max(score, scoreColor(entry, parsedColor));
+      }
+      if (parsedLength !== null && (entry.role === "spacing" || entry.role === "radius" || entry.role === "size")) {
+        score = Math.max(score, scoreLength(entry, parsedLength));
+      }
+      if (parsedShadow !== null && (entry.role === "elevation" || entry.role === "shadow")) {
+        score = Math.max(score, scoreShadow(entry, trimmed, parsedShadow));
+      }
+      if (legacyHint && entry.cssVariable === "--mat-sys-on-surface-variant") {
+        score = Math.max(score, 9);
+      }
+      if (score === 0) {
+        score = scoreValueLiteral(entry, trimmed);
+      }
+      if (score > 0) add(entry, score);
+    }
+  }
+  if (input.component !== void 0 && input.intent === void 0 && input.value === void 0) {
+    for (const entry of candidates) {
+      add(entry, 5);
+    }
+  }
+  if (input.category !== void 0 && scored.size === 0 && input.intent === void 0 && input.value === void 0) {
+    for (const entry of candidates) {
+      add(entry, 1);
+    }
+  }
+  const matches = [];
+  for (const [key, score] of scored) {
+    const [source, cssVariable] = splitKey(key);
+    const entry = registry.all.find((e) => e.source === source && e.cssVariable === cssVariable);
+    if (entry !== void 0) {
+      matches.push({ entry, score });
+    }
+  }
+  matches.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    const rankDiff = (SOURCE_RANK[b.entry.source] ?? 0) - (SOURCE_RANK[a.entry.source] ?? 0);
+    if (rankDiff !== 0) return rankDiff;
+    return a.entry.cssVariable.localeCompare(b.entry.cssVariable);
+  });
+  const truncated = matches.slice(0, MAX_MATCHES);
+  const confident = truncated.length > 0 && truncated[0].score >= CONFIDENT_THRESHOLD;
+  return { matches: truncated, confident, category: input.category };
+}
+function scoreIntent(entry, expanded) {
+  let best = 0;
+  for (const intent of entry.intents) {
+    const lower = intent.toLowerCase();
+    for (const term of expanded) {
+      let score = 0;
+      if (lower === term) {
+        score = 12;
+      } else if (lower.includes(term)) {
+        score = 7;
+      } else if (term.length >= 3 && term.includes(lower)) {
+        score = 4;
+      }
+      if (score > best) best = score;
+    }
+  }
+  return best;
+}
+var RGB_RE = /rgba?\(\s*([0-9.]+)\s*,?\s*([0-9.]+)\s*,?\s*([0-9.]+)(?:[\s,/]+([0-9.]+%?))?\s*\)/i;
+var RGB_NEW_RE = /rgba?\(\s*([0-9.]+)\s+([0-9.]+)\s+([0-9.]+)(?:\s*\/\s*([0-9.]+%?))?\s*\)/i;
+var HEX_RE = /^#([0-9a-f]{3,8})$/i;
+function parseColor(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "transparent") return { r: 0, g: 0, b: 0, a: 0 };
+  if (trimmed.toLowerCase() === "white") return { r: 255, g: 255, b: 255, a: 1 };
+  if (trimmed.toLowerCase() === "black") return { r: 0, g: 0, b: 0, a: 1 };
+  let match = RGB_RE.exec(trimmed);
+  let result = null;
+  if (match !== null) {
+    result = {
+      r: clamp(parseFloat(match[1]), 0, 255),
+      g: clamp(parseFloat(match[2]), 0, 255),
+      b: clamp(parseFloat(match[3]), 0, 255),
+      a: parseAlpha(match[4])
+    };
+  }
+  if (result === null) {
+    match = RGB_NEW_RE.exec(trimmed);
+    if (match !== null) {
+      result = {
+        r: clamp(parseFloat(match[1]), 0, 255),
+        g: clamp(parseFloat(match[2]), 0, 255),
+        b: clamp(parseFloat(match[3]), 0, 255),
+        a: parseAlpha(match[4])
+      };
+    }
+  }
+  if (result === null) {
+    const hexMatch = HEX_RE.exec(trimmed);
+    if (hexMatch !== null) {
+      result = parseHex(hexMatch[1]);
+    }
+  }
+  return result;
+}
+function parseAlpha(value) {
+  let alpha = 1;
+  if (value !== void 0) {
+    if (value.endsWith("%")) {
+      alpha = clamp(parseFloat(value.slice(0, -1)) / 100, 0, 1);
+    } else {
+      alpha = clamp(parseFloat(value), 0, 1);
+    }
+  }
+  return alpha;
+}
+function parseHex(hex) {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 1;
+  if (hex.length === 3) {
+    r = parseInt(hex[0] + hex[0], 16);
+    g = parseInt(hex[1] + hex[1], 16);
+    b = parseInt(hex[2] + hex[2], 16);
+  } else if (hex.length === 4) {
+    r = parseInt(hex[0] + hex[0], 16);
+    g = parseInt(hex[1] + hex[1], 16);
+    b = parseInt(hex[2] + hex[2], 16);
+    a = parseInt(hex[3] + hex[3], 16) / 255;
+  } else if (hex.length === 6) {
+    r = parseInt(hex.slice(0, 2), 16);
+    g = parseInt(hex.slice(2, 4), 16);
+    b = parseInt(hex.slice(4, 6), 16);
+  } else if (hex.length === 8) {
+    r = parseInt(hex.slice(0, 2), 16);
+    g = parseInt(hex.slice(2, 4), 16);
+    b = parseInt(hex.slice(4, 6), 16);
+    a = parseInt(hex.slice(6, 8), 16) / 255;
+  }
+  return { r, g, b, a };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function srgbToLinear(channel) {
+  const v = channel / 255;
+  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+}
+function rgbToOkLab(rgb) {
+  const r = srgbToLinear(rgb.r);
+  const g = srgbToLinear(rgb.g);
+  const b = srgbToLinear(rgb.b);
+  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  const lCbrt = Math.cbrt(l);
+  const mCbrt = Math.cbrt(m);
+  const sCbrt = Math.cbrt(s);
+  return {
+    L: 0.2104542553 * lCbrt + 0.793617785 * mCbrt - 0.0040720468 * sCbrt,
+    a: 1.9779984951 * lCbrt - 2.428592205 * mCbrt + 0.4505937099 * sCbrt,
+    b: 0.0259040371 * lCbrt + 0.7827717662 * mCbrt - 0.808675766 * sCbrt,
+    alpha: rgb.a
+  };
+}
+function colorDistance(a, b) {
+  const lab1 = rgbToOkLab(a);
+  const lab2 = rgbToOkLab(b);
+  const dL = lab1.L - lab2.L;
+  const dA = lab1.a - lab2.a;
+  const dB = lab1.b - lab2.b;
+  const dAlpha = (lab1.alpha - lab2.alpha) * 0.5;
+  return Math.sqrt(dL * dL + dA * dA + dB * dB + dAlpha * dAlpha);
+}
+function scoreColor(entry, target) {
+  let best = 0;
+  const candidates = [entry.defaults.light, entry.defaults.dark].filter((v) => v !== void 0);
+  for (const value of candidates) {
+    const parsed = parseColor(value);
+    if (parsed !== null) {
+      const distance = colorDistance(target, parsed);
+      let score = 0;
+      if (distance <= 5e-3) score = 11;
+      else if (distance <= 0.02) score = 9;
+      else if (distance <= 0.04) score = 5;
+      else if (distance <= 0.08) score = 3;
+      if (score > best) best = score;
+    }
+  }
+  return best;
+}
+function isLegacyHintColor(parsed) {
+  let result = false;
+  if (parsed !== null) {
+    const isBlack = parsed.r < 5 && parsed.g < 5 && parsed.b < 5;
+    const isWhite = parsed.r > 250 && parsed.g > 250 && parsed.b > 250;
+    if (isBlack && parsed.a >= 0.5 && parsed.a <= 0.74 || isWhite && parsed.a >= 0.6 && parsed.a <= 0.85) {
+      result = true;
+    }
+  }
+  return result;
+}
+var LENGTH_RE = /^([0-9.]+)\s*(px|rem|em|%|vh|vw)?$/i;
+function parseLength(raw) {
+  const match = LENGTH_RE.exec(raw.trim());
+  let result = null;
+  if (match !== null) {
+    result = {
+      value: parseFloat(match[1]),
+      unit: (match[2] ?? "").toLowerCase()
+    };
+  }
+  return result;
+}
+function scoreLength(entry, target) {
+  let best = 0;
+  const candidates = [entry.defaults.light, entry.defaults.dark].filter((v) => v !== void 0);
+  for (const value of candidates) {
+    const parsed = parseLength(value);
+    if (parsed !== null && parsed.unit === target.unit) {
+      const diff = Math.abs(parsed.value - target.value);
+      let score = 0;
+      if (diff < 0.01) score = 11;
+      else if (diff <= 1 && (entry.role === "spacing" || entry.role === "radius")) score = 7;
+      else if (diff <= 2 && entry.role === "spacing") score = 4;
+      if (score > best) best = score;
+    }
+  }
+  return best;
+}
+function parseShadow(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.includes("px") && !trimmed.startsWith("rgba(") && !trimmed.includes(" ")) return null;
+  const layers = [];
+  for (const layerRaw of splitShadowLayers(trimmed)) {
+    const parsed = parseShadowLayer(layerRaw);
+    if (parsed !== null) layers.push(parsed);
+  }
+  return layers.length > 0 ? layers : null;
+}
+function splitShadowLayers(raw) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  for (const ch of raw) {
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth -= 1;
+    if (ch === "," && depth === 0) {
+      if (buf.trim().length > 0) out.push(buf.trim());
+      buf = "";
+    } else {
+      buf += ch;
+    }
+  }
+  if (buf.trim().length > 0) out.push(buf.trim());
+  return out;
+}
+function parseShadowLayer(raw) {
+  const colorMatch = /(rgba?\([^)]*\)|#[0-9a-f]+)/i.exec(raw);
+  let color = null;
+  let withoutColor = raw;
+  if (colorMatch !== null) {
+    color = parseColor(colorMatch[1]);
+    withoutColor = (raw.slice(0, colorMatch.index) + raw.slice(colorMatch.index + colorMatch[0].length)).trim();
+  }
+  const parts = withoutColor.split(/\s+/).filter((p) => p.length > 0);
+  let result = null;
+  if (parts.length >= 2) {
+    const ox = parseLength(parts[0]);
+    const oy = parseLength(parts[1]);
+    const blur = parts.length >= 3 ? parseLength(parts[2]) : { value: 0, unit: "px" };
+    const spread = parts.length >= 4 ? parseLength(parts[3]) : { value: 0, unit: "px" };
+    if (ox !== null && oy !== null && blur !== null && spread !== null) {
+      result = {
+        offsetX: ox.value,
+        offsetY: oy.value,
+        blur: blur.value,
+        spread: spread.value,
+        color
+      };
+    }
+  }
+  return result;
+}
+function scoreShadow(entry, raw, target) {
+  let best = 0;
+  for (const value of [entry.defaults.light, entry.defaults.dark].filter((v) => v !== void 0)) {
+    const parsed = parseShadow(value);
+    if (parsed !== null) {
+      let layerHits = 0;
+      for (const t of target) {
+        const found = parsed.find((p) => Math.abs(p.offsetX - t.offsetX) <= 1 && Math.abs(p.offsetY - t.offsetY) <= 1 && Math.abs(p.blur - t.blur) <= 2);
+        if (found !== void 0) layerHits += 1;
+      }
+      let score = 0;
+      if (layerHits === target.length) score = 9;
+      else if (layerHits > 0) score = 5;
+      if (score > best) best = score;
+    }
+    if (value === raw) best = Math.max(best, 11);
+  }
+  return best;
+}
+function scoreValueLiteral(entry, raw) {
+  let best = 0;
+  for (const value of [entry.defaults.light, entry.defaults.dark].filter((v) => v !== void 0)) {
+    if (value === raw) best = Math.max(best, 11);
+    else if (value.includes(raw)) best = Math.max(best, 4);
+  }
+  return best;
+}
+function splitKey(key) {
+  const idx = key.indexOf("::");
+  let result;
+  if (idx < 0) {
+    result = ["", key];
+  } else {
+    result = [key.slice(0, idx), key.slice(idx + 2)];
+  }
+  return result;
+}
+
+// packages/dbx-components-mcp/src/tools/css-token-lookup/format.ts
+function formatCssTokenLookup(registry, input, result) {
+  let text;
+  if (input.category !== void 0 && input.category !== "list" || input.intent === void 0 && input.value === void 0 && input.component === void 0 && input.role === void 0) {
+    if (input.category !== void 0) {
+      text = formatBrowse(registry, input.category, result.matches);
+    } else if (input.role !== void 0) {
+      text = formatBrowse(registry, void 0, result.matches);
+    } else {
+      text = formatNoQuery();
+    }
+  } else if (result.matches.length === 0) {
+    text = formatNoMatch(input);
+  } else if (!result.confident && result.matches.length > 1) {
+    text = formatAmbiguous(input, result.matches);
+  } else {
+    text = formatSingle2(result.matches[0], input, result.matches.slice(1));
+  }
+  return text;
+}
+function formatSingle2(match, input, otherMatches) {
+  const entry = match.entry;
+  const lines = [`# \`${entry.cssVariable}\``, "", formatHeaderLine(entry), "", `**Use:** \`var(${entry.cssVariable})\``];
+  if (entry.scssVariable !== void 0) {
+    lines.push(`**SCSS:** \`${entry.scssVariable}\``);
+  }
+  lines.push("");
+  lines.push(entry.description);
+  if (entry.defaults.light !== void 0 || entry.defaults.dark !== void 0) {
+    lines.push("", "## Default value");
+    if (entry.defaults.light !== void 0) {
+      lines.push(`- light: \`${entry.defaults.light}\``);
+    }
+    if (entry.defaults.dark !== void 0) {
+      lines.push(`- dark: \`${entry.defaults.dark}\``);
+    }
+  }
+  if (entry.antiUseNotes !== void 0 && entry.antiUseNotes.length > 0) {
+    lines.push("", "## Don't use this when", "", entry.antiUseNotes);
+  }
+  if (entry.utilityClasses !== void 0 && entry.utilityClasses.length > 0) {
+    const classes = entry.utilityClasses.map((c) => `\`${c}\``).join(", ");
+    lines.push("", `## Utility classes`, "", classes);
+  }
+  if (entry.recommendedPrimitive !== void 0) {
+    lines.push("", "## Recommended primitive", "", `Reach for \`${entry.recommendedPrimitive}\` when you'd otherwise hand-roll this token. See \`dbx_ui_lookup topic="${entry.recommendedPrimitive}"\`.`);
+  }
+  if (entry.seeAlso !== void 0 && entry.seeAlso.length > 0) {
+    const seeAlso = entry.seeAlso.map((s) => `\`${s}\``).join(", ");
+    lines.push("", "## See also", "", seeAlso);
+  }
+  if (otherMatches.length > 0) {
+    lines.push("", "## Other candidates", "");
+    for (const candidate of otherMatches) {
+      lines.push(`- \`${candidate.entry.cssVariable}\` \xB7 ${candidate.entry.role} \xB7 score ${candidate.score}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatHeaderLine(entry) {
+  const parts = [`**source:** \`${entry.source}\``, `**role:** \`${entry.role}\``];
+  if (entry.componentScope !== void 0) parts.push(`**component:** \`${entry.componentScope}\``);
+  return parts.join(" \xB7 ");
+}
+function formatAmbiguous(input, matches) {
+  const lines = [`# Top candidates`, "", `Multiple tokens look relevant for the supplied query (${describeQuery(input)}). The candidates are sorted by confidence:`, ""];
+  for (const match of matches) {
+    lines.push(`## \`${match.entry.cssVariable}\` \xB7 score ${match.score}`);
+    lines.push("", `${match.entry.description}`, "");
+    if (match.entry.defaults.light !== void 0) {
+      lines.push(`- light default: \`${match.entry.defaults.light}\``);
+    }
+    if (match.entry.defaults.dark !== void 0) {
+      lines.push(`- dark default: \`${match.entry.defaults.dark}\``);
+    }
+    if (match.entry.antiUseNotes !== void 0 && match.entry.antiUseNotes.length > 0) {
+      lines.push("", match.entry.antiUseNotes);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function formatBrowse(registry, category, matches) {
+  const list = matches.length > 0 ? matches.map((m) => m.entry) : registry.all;
+  const title = category !== void 0 ? `# Tokens \xB7 category \`${category}\`` : `# Tokens`;
+  const lines = [title, ""];
+  if (list.length === 0) {
+    lines.push("_No tokens matched._");
+  } else {
+    lines.push("| CSS variable | Role | Source | Description |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const entry of list) {
+      const desc = entry.description.replaceAll("|", String.raw`\|`).split("\n")[0];
+      lines.push(`| \`${entry.cssVariable}\` | ${entry.role} | ${entry.source} | ${desc} |`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatNoQuery() {
+  return ["# `dbx_css_token_lookup`", "", 'Provide at least one of `intent`, `value`, `role`, `component`, or `category` (use `category="list"` to browse the full catalog).'].join("\n");
+}
+function formatNoMatch(input) {
+  const lines = ["# No confident match", "", `No token confidently matched the query (${describeQuery(input)}).`, "", "If this looks like a project-specific brand chrome value, define a project-local SCSS variable in your app's `styles.scss` instead of reaching for a system token."];
+  return lines.join("\n");
+}
+function describeQuery(input) {
+  const parts = [];
+  if (input.intent !== void 0) parts.push(`intent="${input.intent}"`);
+  if (input.value !== void 0) parts.push(`value="${input.value}"`);
+  if (input.role !== void 0) parts.push(`role="${input.role}"`);
+  if (input.component !== void 0) parts.push(`component="${input.component}"`);
+  if (input.category !== void 0) parts.push(`category="${input.category}"`);
+  return parts.join(", ") || "(none)";
+}
+
+// packages/dbx-components-mcp/src/tools/css-token-lookup.tool.ts
+var DBX_CSS_TOKEN_LOOKUP_TOOL = {
+  name: "dbx_css_token_lookup",
+  description: [
+    "Forward-lookup over the dbx-web + Angular Material design-token catalog.",
+    "",
+    "Pass any combination of:",
+    '  \u2022 `intent` \u2014 plain English ("hint text color", "card radius", "section gap", "primary button color");',
+    "  \u2022 `value` \u2014 raw CSS value to reverse-lookup (`rgba(0,0,0,0.6)`, `12px`, `#26353f`, `0 1px 2px rgba(0,0,0,.06)`);",
+    "  \u2022 `role` \u2014 narrow the candidate pool (color, text-color, surface, spacing, radius, elevation, shadow, typography, motion, state-layer, size, breakpoint);",
+    '  \u2022 `component` \u2014 Angular Material component slug ("mat-progress-bar", "mat-button", ...) to surface the relevant MDC tokens;',
+    '  \u2022 `category` \u2014 `"list"` for the full catalog, or `"dbx-web"|"mat-sys"|"mdc"|"app"` to browse one source.',
+    "",
+    "Returns the recommended `var(--\u2026)` plus light/dark defaults, anti-use notes, the dbx-web utility class or primitive that wraps the underlying token, and any see-also references."
+  ].join("\n"),
+  inputSchema: {
+    type: "object",
+    properties: {
+      intent: { type: "string", description: "Plain-English intent \u2014 what the value is for." },
+      value: { type: "string", description: "Raw CSS value to reverse-lookup." },
+      role: { type: "string", enum: [...TOKEN_ROLES], description: "Token-role filter." },
+      component: { type: "string", description: "Angular Material component slug \u2014 narrows the lookup to MDC tokens scoped to that component." },
+      category: { type: "string", description: '"list" for the full catalog, or "dbx-web"|"mat-sys"|"mdc"|"app" to browse one source.' }
+    }
+  }
+};
+var CssTokenLookupArgs = type66({
+  "intent?": "string",
+  "value?": "string",
+  "role?": "string",
+  "component?": "string",
+  "category?": "string"
+});
+function parseArgs11(raw) {
+  const parsed = CssTokenLookupArgs(raw);
+  if (parsed instanceof type66.errors) {
+    throw new TypeError(`Invalid arguments: ${parsed.summary}`);
+  }
+  const result = {
+    intent: parsed.intent,
+    value: parsed.value,
+    role: parsed.role,
+    component: parsed.component,
+    category: parsed.category
+  };
+  return result;
+}
+function createCssTokenLookupTool(input) {
+  const { registry } = input;
+  const run15 = (rawArgs) => {
+    let args;
+    try {
+      args = parseArgs11(rawArgs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return toolError(message);
+    }
+    const result = resolveToken(registry, args);
+    const text = formatCssTokenLookup(registry, args, result);
+    const tool = { content: [{ type: "text", text }] };
+    return tool;
+  };
+  return { definition: DBX_CSS_TOKEN_LOOKUP_TOOL, run: run15 };
+}
+
+// packages/dbx-components-mcp/src/tools/ui-smell-check.tool.ts
+import { readFile as nodeReadFile8 } from "node:fs/promises";
+import { isAbsolute as isAbsolute10, resolve as resolve40 } from "node:path";
+import { type as type67 } from "arktype";
+
+// packages/dbx-components-mcp/src/tools/ui-smell-check/smells.ts
+function captureSnippet(haystack, index, length) {
+  const start = Math.max(0, haystack.lastIndexOf("\n", index) + 1);
+  const end = haystack.indexOf("\n", index + length);
+  let stop;
+  if (end < 0) {
+    stop = Math.min(haystack.length, index + length + 80);
+  } else {
+    stop = end;
+  }
+  return haystack.slice(start, stop).trimEnd();
+}
+function isInsideScssVarDeclaration(scss, colonIndex) {
+  const lineStart = scss.lastIndexOf("\n", colonIndex - 1) + 1;
+  const prefix = scss.slice(lineStart, colonIndex);
+  return /^\s*\$[\w-]+\s*$/.test(prefix);
+}
+function findCardSurface(scss) {
+  let result = null;
+  let depth = 0;
+  let blockStart = -1;
+  for (let i = 0; i < scss.length; i += 1) {
+    const ch = scss[i];
+    if (ch === "{") {
+      if (depth === 0) blockStart = i + 1;
+      depth += 1;
+    } else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0 && blockStart >= 0) {
+        const block = scss.slice(blockStart, i);
+        if (looksLikeCardSurface(block)) {
+          result = { index: blockStart, length: block.length, snippet: block.trim() };
+          break;
+        }
+        blockStart = -1;
+      }
+    }
+  }
+  return result;
+}
+function looksLikeCardSurface(block) {
+  const hasPadding = /\bpadding\s*:\s*[0-9]/i.test(block);
+  const hasWhiteBg = /background\s*:\s*(#fff|#ffffff|white|rgb\(\s*255\s*,\s*255\s*,\s*255\s*\))/i.test(block);
+  const hasRadius = /\bborder-radius\s*:\s*[0-9]/i.test(block);
+  return hasPadding && hasWhiteBg && hasRadius;
+}
+var cardSurfaceHandrolled = (input) => {
+  const matches = [];
+  const hit = findCardSurface(input.scss);
+  if (hit !== null) {
+    const wrapperHint = input.conventions.cardWrapperClasses && input.conventions.cardWrapperClasses.length > 0 ? ` Or wrap the projection in your project-local class: \`${input.conventions.cardWrapperClasses.join("`, `")}\`.` : "";
+    matches.push({
+      id: "card-surface-handrolled",
+      severity: "warn",
+      title: "Hand-rolled card surface",
+      snippet: hit.snippet,
+      fix: ['This block re-implements `<dbx-content-box>`. Replace the wrapper element with `<dbx-content-box>` (it provides padding, surface color, and corner radius automatically) and project the section content via `<dbx-section header="..." hint="...">` for the title/subtitle stack.' + wrapperHint, "", "Replacement HTML:", "```html", "<dbx-content-box>", '  <dbx-section header="\u2026" hint="\u2026">', "    <!-- projected content -->", "  </dbx-section>", "</dbx-content-box>", "```"].join("\n"),
+      seeAlsoSlugs: ["content-box", "section"],
+      seeAlsoTokens: ["--mat-sys-surface-container", "--dbx-padding-3"]
+    });
+  }
+  return matches;
+};
+var HARDCODED_RADIUS_RE = /border-radius\s*:\s*([0-9]+(?:\.[0-9]+)?(?:px|rem|em))(?!\s*\))/gi;
+var hardcodedRadius = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(HARDCODED_RADIUS_RE)) {
+    if (match.index === void 0) continue;
+    const colonIndex = input.scss.indexOf(":", match.index);
+    if (colonIndex !== -1 && isInsideScssVarDeclaration(input.scss, colonIndex)) continue;
+    const raw = match[1];
+    const candidates = input.tokenRegistry.findByValue(raw, "radius");
+    const top = candidates[0];
+    const fix = top !== void 0 ? `Replace \`border-radius: ${raw}\` with \`border-radius: var(${top.entry.cssVariable})\` (matches the design-system corner token).` : `Hardcoded radius \`${raw}\` doesn't match any known design-system token. Either wrap it in a project-local SCSS variable or align it with one of \`--mat-sys-corner-extra-small/-small/-medium/-large/-extra-large/-full\`.`;
+    matches.push({
+      id: "hardcoded-radius",
+      severity: "warn",
+      title: "Hardcoded border-radius",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix,
+      seeAlsoSlugs: top?.entry.recommendedPrimitive !== void 0 ? [top.entry.recommendedPrimitive] : [],
+      seeAlsoTokens: top !== void 0 ? [top.entry.cssVariable] : []
+    });
+  }
+  return matches;
+};
+var HARDCODED_SHADOW_RE = /box-shadow\s*:\s*([^;]+);/gi;
+var hardcodedShadow = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(HARDCODED_SHADOW_RE)) {
+    if (match.index === void 0) continue;
+    const raw = match[1].trim();
+    if (raw.startsWith("var(") || raw === "none") continue;
+    const candidates = input.tokenRegistry.findByValue(raw, "elevation");
+    const top = candidates[0];
+    const fix = top !== void 0 ? `Replace this hardcoded shadow with \`box-shadow: var(${top.entry.cssVariable})\` or use \`<dbx-content-box [elevate]="true">\` to apply the elevation through the wrapper component.` : 'Hardcoded `box-shadow:` declarations should map to one of the `--mat-sys-level0..5` elevation tokens, or wrap the surface in `<dbx-content-box [elevate]="true">` so the shadow comes from the design system.';
+    matches.push({
+      id: "hardcoded-shadow",
+      severity: "warn",
+      title: "Hardcoded box-shadow",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix,
+      seeAlsoSlugs: ["content-box", "content-elevate"],
+      seeAlsoTokens: top !== void 0 ? [top.entry.cssVariable] : ["--mat-sys-level1"]
+    });
+  }
+  return matches;
+};
+var HARDCODED_HINT_COLOR_RE = /color\s*:\s*(rgba?\(\s*0\s*,\s*0\s*,\s*0\s*[,/\s]\s*0\.[5-7][0-9]?\s*\)|rgba?\(\s*255\s*,\s*255\s*,\s*255\s*[,/\s]\s*0\.[6-8][0-9]?\s*\))/gi;
+var hardcodedHintColor = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(HARDCODED_HINT_COLOR_RE)) {
+    if (match.index === void 0) continue;
+    matches.push({
+      id: "hardcoded-hint-color",
+      severity: "warn",
+      title: "Hardcoded hint text color",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix: ["Replace this hardcoded hint color with `color: var(--mat-sys-on-surface-variant)` so it adapts to dark mode and matches Material guidance.", "", 'If this `color:` is on text inside a card, prefer `<dbx-section [header]="\u2026" [hint]="\u2026">`, which already styles the hint slot with the right token.'].join("\n"),
+      seeAlsoSlugs: ["section"],
+      seeAlsoTokens: ["--mat-sys-on-surface-variant"]
+    });
+  }
+  return matches;
+};
+var HARDCODED_PADDING_RE = /(?:padding|margin)\s*(?:-(?:top|right|bottom|left))?\s*:\s*([0-9]+(?:\.[0-9]+)?px)(?!\s*\))/gi;
+var hardcodedPadding = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(HARDCODED_PADDING_RE)) {
+    if (match.index === void 0) continue;
+    const raw = match[1];
+    const candidates = input.tokenRegistry.findByValue(raw, "spacing");
+    const top = candidates[0];
+    if (top !== void 0) {
+      const utility = top.entry.utilityClasses?.[0];
+      const fix = ["Replace `" + match[0].trim() + "` with `var(" + top.entry.cssVariable + ")`" + (utility !== void 0 ? ` (or use the \`${utility}\` utility class on the host element)` : "") + "."].join("\n");
+      matches.push({
+        id: "hardcoded-padding",
+        severity: "warn",
+        title: "Hardcoded padding/margin",
+        snippet: captureSnippet(input.scss, match.index, match[0].length),
+        fix,
+        seeAlsoSlugs: [],
+        seeAlsoTokens: [top.entry.cssVariable]
+      });
+    }
+  }
+  return matches;
+};
+var HARDCODED_TYPOGRAPHY_RE = /font-size\s*:\s*([0-9]+(?:\.[0-9]+)?)(rem|px)/gi;
+var hardcodedTypography = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(HARDCODED_TYPOGRAPHY_RE)) {
+    if (match.index === void 0) continue;
+    const value = parseFloat(match[1]);
+    const unit = match[2];
+    const tooBig = unit === "rem" && value > 1 || unit === "px" && value >= 18;
+    if (tooBig) {
+      matches.push({
+        id: "hardcoded-typography",
+        severity: "info",
+        title: "Hardcoded large font-size",
+        snippet: captureSnippet(input.scss, match.index, match[0].length),
+        fix: "Use the `<dbx-section [header]>` (or `<dbx-section-page>` for page-level headers) primitive \u2014 it carries Material `headline` typography automatically. If you must inline a font-size, reach for one of `--mat-sys-headline-{small|medium|large}` or `--mat-sys-title-large`.",
+        seeAlsoSlugs: ["section", "section-page"],
+        seeAlsoTokens: ["--mat-sys-headline-medium", "--mat-sys-title-large"]
+      });
+    }
+  }
+  return matches;
+};
+var PIT_BACKGROUND_RE = /background\s*:\s*(rgba?\(\s*0\s*,\s*0\s*,\s*0\s*[,/\s]\s*0\.0[2-8]\s*\))/gi;
+var pitInsteadOfTintedBg = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(PIT_BACKGROUND_RE)) {
+    if (match.index === void 0) continue;
+    matches.push({
+      id: "pit-instead-of-tinted-bg",
+      severity: "warn",
+      title: 'Hand-rolled tinted "pit" background',
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix: "Apply `[dbxContentPit]` to the host element. The directive paints the right tinted surface color and supports the rounded variant via `[dbxContentPitRounded]`.",
+      seeAlsoSlugs: ["content-pit"],
+      seeAlsoTokens: ["--mat-sys-surface-container-low"]
+    });
+  }
+  return matches;
+};
+var FLEX_COLUMN_GAP_RE = /display\s*:\s*flex\s*;\s*flex-direction\s*:\s*column\s*;\s*gap\s*:\s*[0-9]+(?:\.[0-9]+)?px\s*;/gi;
+var flexColumnWithGap = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(FLEX_COLUMN_GAP_RE)) {
+    if (match.index === void 0) continue;
+    matches.push({
+      id: "flex-column-with-gap-as-card-stack",
+      severity: "info",
+      title: "Flex column + gap on a card stack",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix: "For stacking dbx-web cards/content-boxes, prefer `[dbxFlexGroup]` with `[breakToColumn]` (it handles wrapping, gaps, and responsive flow) or rely on the default sibling margins emitted by `<dbx-content-box>` siblings.",
+      seeAlsoSlugs: ["flex-group"],
+      seeAlsoTokens: ["--dbx-padding-3"]
+    });
+  }
+  return matches;
+};
+var MDC_OVERRIDE_RE = /(--mdc-[a-z0-9-]+)\s*:/gi;
+var mdcTokenOverride = (input) => {
+  const matches = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of input.scss.matchAll(MDC_OVERRIDE_RE)) {
+    if (match.index === void 0) continue;
+    const tokenName = match[1];
+    if (seen.has(tokenName)) continue;
+    seen.add(tokenName);
+    const tokenEntry = input.tokenRegistry.findByCssVariable(tokenName);
+    const componentScope = tokenEntry?.componentScope;
+    const fix = componentScope !== void 0 ? `Don't override \`${tokenName}\` directly. Set \`color="primary|accent|warn"\` on the host \`<${componentScope}>\` (or wrap in a thin styled component) so the token resolution flows through Material's theme.` : `Don't override \`${tokenName}\` directly. Material component tokens should be set via the host component's \`color\` attribute or by a parent theme \u2014 direct overrides break dark mode and theme switching.`;
+    matches.push({
+      id: "mdc-token-override-instead-of-wrapper",
+      severity: "warn",
+      title: "Direct MDC token override",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix,
+      seeAlsoSlugs: componentScope === "mat-button" ? ["button"] : [],
+      seeAlsoTokens: [tokenName]
+    });
+  }
+  return matches;
+};
+var HARDCODED_HEX_RE = /:\s*(#[0-9a-fA-F]{3,8})\b(?!\s*(?:px|rem|em))/g;
+var hardcodedHexBrand = (input) => {
+  const matches = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of input.scss.matchAll(HARDCODED_HEX_RE)) {
+    if (match.index === void 0) continue;
+    if (isInsideScssVarDeclaration(input.scss, match.index)) continue;
+    const hex = match[1];
+    if (seen.has(hex)) continue;
+    seen.add(hex);
+    const candidates = input.tokenRegistry.findByValue(hex);
+    if (candidates.length === 0 || candidates[0].score < 6) {
+      matches.push({
+        id: "hardcoded-hex-brand-color",
+        severity: "info",
+        title: "Hardcoded hex with no matching token",
+        snippet: captureSnippet(input.scss, match.index, match[0].length),
+        fix: `\`${hex}\` doesn't map to a known design-system token. If this is project-local brand chrome, define a project-local SCSS variable in your app's \`styles.scss\` (e.g. \`$myapp-onboarding-bg: ${hex};\`) so the value has one source of truth.`,
+        seeAlsoSlugs: [],
+        seeAlsoTokens: []
+      });
+    }
+  }
+  return matches;
+};
+var EMPTY_RULESET_RE = /([^{}\n;]+?)\s*\{\s*\}/g;
+var emptyRuleset = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(EMPTY_RULESET_RE)) {
+    if (match.index === void 0) continue;
+    const selector = match[1].trim();
+    if (selector.length === 0) continue;
+    if (!/^[.#&*:@\w]/.test(selector)) continue;
+    matches.push({
+      id: "empty-ruleset",
+      severity: "info",
+      title: "Empty rule block",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix: "Empty rule blocks add noise. Either add styles, remove the block, or replace it with a `// TODO:` comment if you want to mark a placeholder.",
+      seeAlsoSlugs: [],
+      seeAlsoTokens: []
+    });
+  }
+  return matches;
+};
+var SCSS_USE_AS_RE = /@use\s+['"][^'"]+['"]\s+as\s+([\w-]+)\s*;/g;
+var unusedScssUse = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(SCSS_USE_AS_RE)) {
+    if (match.index === void 0) continue;
+    const ns = match[1];
+    const usagePattern = new RegExp(`(?:^|[^\\w-])${ns}\\.`, "g");
+    let used = false;
+    for (const usageMatch of input.scss.matchAll(usagePattern)) {
+      if (usageMatch.index === void 0) continue;
+      const lineStart = input.scss.lastIndexOf("\n", usageMatch.index) + 1;
+      const lineEndRaw = input.scss.indexOf("\n", usageMatch.index);
+      const lineEnd = lineEndRaw === -1 ? input.scss.length : lineEndRaw;
+      const line = input.scss.slice(lineStart, lineEnd);
+      if (/^\s*@use\b/.test(line)) continue;
+      used = true;
+      break;
+    }
+    if (!used) {
+      matches.push({
+        id: "unused-scss-use",
+        severity: "info",
+        title: `Unused @use namespace \`${ns}\``,
+        snippet: captureSnippet(input.scss, match.index, match[0].length),
+        fix: `\`@use\` declares namespace \`${ns}\` but no \`${ns}.\` reference appears in this file. Remove the import to keep the file lean, or use it.`,
+        seeAlsoSlugs: [],
+        seeAlsoTokens: []
+      });
+    }
+  }
+  return matches;
+};
+var RAW_MAT_BUTTON_RE = /<button\b([^>]*?)\b(mat-stroked-button|mat-flat-button|mat-raised-button|mat-button)\b/gi;
+var rawMatButton = (input) => {
+  const matches = [];
+  for (const match of input.html.matchAll(RAW_MAT_BUTTON_RE)) {
+    if (match.index === void 0) continue;
+    const variant = match[2];
+    const variantAttr = variant === "mat-stroked-button" ? "stroked" : variant === "mat-flat-button" ? "flat" : variant === "mat-raised-button" ? "raised" : "basic";
+    matches.push({
+      id: "raw-mat-button",
+      severity: "warn",
+      title: `Raw ${variant}`,
+      snippet: captureSnippet(input.html, match.index, match[0].length),
+      fix: `Use \`<dbx-button ${variantAttr}>\` instead of raw \`${variant}\`. \`<dbx-button>\` plugs into the action stack, accepts \`text\` / \`icon\` inputs, and inherits dbx-web theming.`,
+      seeAlsoSlugs: ["button"],
+      seeAlsoTokens: []
+    });
+  }
+  return matches;
+};
+var HEADER_THEN_HINT_RE = /<(h[1-3])\b[^>]*>([\s\S]*?)<\/\1>\s*<(?:p|span)\b[^>]*>([\s\S]{1,200}?)<\/(?:p|span)>/gi;
+var customSectionHeader = (input) => {
+  const matches = [];
+  for (const match of input.html.matchAll(HEADER_THEN_HINT_RE)) {
+    if (match.index === void 0) continue;
+    const headerTag = match[1].toLowerCase();
+    const isPageLevel = headerTag === "h1";
+    matches.push({
+      id: "custom-section-header",
+      severity: "info",
+      title: `Custom ${headerTag} + sibling hint text`,
+      snippet: captureSnippet(input.html, match.index, match[0].length),
+      fix: `Replace this header+hint pair with \`<${isPageLevel ? "dbx-section-page" : "dbx-section"} header="\u2026" hint="\u2026">\` \u2014 projected content lives inside, the typography and hint color come from dbx-web.`,
+      seeAlsoSlugs: [isPageLevel ? "section-page" : "section"],
+      seeAlsoTokens: ["--mat-sys-on-surface-variant"]
+    });
+  }
+  return matches;
+};
+var TWO_COLUMN_GRID_RE = /grid-template-columns\s*:\s*(?:1fr\s+1fr|repeat\(\s*2\s*,)/gi;
+var customGridLayout = (input) => {
+  const matches = [];
+  for (const match of input.scss.matchAll(TWO_COLUMN_GRID_RE)) {
+    if (match.index === void 0) continue;
+    matches.push({
+      id: "custom-grid-layout",
+      severity: "info",
+      title: "Custom two-column grid",
+      snippet: captureSnippet(input.scss, match.index, match[0].length),
+      fix: "For two-column layouts that should collapse on narrow viewports, prefer `[dbxFlexGroup] [breakToColumn]` on the parent and `[dbxFlexSize]` on each child. The directives handle responsive wrapping consistently across the app.",
+      seeAlsoSlugs: ["flex-group", "flex-size"],
+      seeAlsoTokens: []
+    });
+  }
+  return matches;
+};
+var EYEBROW_TEXT_RE = /<span\b[^>]*?(?:class|style)=[^>]*?(?:text-transform\s*:\s*uppercase|uppercase)/gi;
+var eyebrowText = (input) => {
+  const matches = [];
+  for (const match of input.html.matchAll(EYEBROW_TEXT_RE)) {
+    if (match.index === void 0) continue;
+    matches.push({
+      id: "eyebrow-text",
+      severity: "info",
+      title: "Eyebrow text (uppercase span above a heading)",
+      snippet: captureSnippet(input.html, match.index, match[0].length),
+      fix: 'No current dbx-web primitive wraps the "eyebrow" pattern (small uppercase label above a heading). Either keep it inline with `<dbx-label-block>` for now, or propose a `dbx-eyebrow` primitive in dbx-web.',
+      seeAlsoSlugs: ["label-block"],
+      seeAlsoTokens: ["--mat-sys-label-medium"]
+    });
+  }
+  return matches;
+};
+var UI_SMELLS = [
+  { id: "card-surface-handrolled", detect: cardSurfaceHandrolled },
+  { id: "hardcoded-radius", detect: hardcodedRadius },
+  { id: "hardcoded-shadow", detect: hardcodedShadow },
+  { id: "hardcoded-hint-color", detect: hardcodedHintColor },
+  { id: "hardcoded-padding", detect: hardcodedPadding },
+  { id: "hardcoded-typography", detect: hardcodedTypography },
+  { id: "pit-instead-of-tinted-bg", detect: pitInsteadOfTintedBg },
+  { id: "flex-column-with-gap-as-card-stack", detect: flexColumnWithGap },
+  { id: "mdc-token-override-instead-of-wrapper", detect: mdcTokenOverride },
+  { id: "hardcoded-hex-brand-color", detect: hardcodedHexBrand },
+  { id: "empty-ruleset", detect: emptyRuleset },
+  { id: "unused-scss-use", detect: unusedScssUse },
+  { id: "raw-mat-button", detect: rawMatButton },
+  { id: "custom-section-header", detect: customSectionHeader },
+  { id: "custom-grid-layout", detect: customGridLayout },
+  { id: "eyebrow-text", detect: eyebrowText }
+];
+function detectSmells(input) {
+  const matches = [];
+  for (const smell of UI_SMELLS) {
+    const found = smell.detect(input);
+    for (const match of found) matches.push(match);
+  }
+  return matches;
+}
+
+// packages/dbx-components-mcp/src/tools/ui-smell-check/format.ts
+function formatSmellResult(input, matches, tokenRegistry) {
+  const sections = [];
+  const title = "# UI smell check";
+  sections.push(title);
+  if (input.context !== void 0 && input.context.length > 0) {
+    sections.push(`_Context:_ ${input.context}`);
+  }
+  if (matches.length === 0) {
+    const goodSignals = formatGoodSignals(input.html, input.scss);
+    if (goodSignals !== null) {
+      sections.push("", "No smells detected.", "", goodSignals, "", "For a token recommendation, call `dbx_css_token_lookup` with an `intent` or `value`.");
+    } else {
+      sections.push("", "No smells detected against the v1 catalog. If you still want a token recommendation, call `dbx_css_token_lookup` with an `intent` or `value`.");
+    }
+  } else {
+    sections.push("", "## Detected smells", "");
+    for (const match of matches) {
+      sections.push(formatMatch(match));
+    }
+    const tokenTable = formatTokenTable(matches, tokenRegistry);
+    if (tokenTable !== null) {
+      sections.push("", "## Tokens to use", "", tokenTable);
+    }
+    const infoOnly = matches.filter((m) => m.severity === "info");
+    if (infoOnly.length > 0) {
+      sections.push("", "## No-match notes", "");
+      for (const match of infoOnly) {
+        sections.push(`- **${match.id}** \u2014 ${match.title}`);
+      }
+    }
+  }
+  return sections.join("\n");
+}
+function formatMatch(match) {
+  const lines = [`### ${match.id} \xB7 ${match.severity}`, "", match.title, "", "```", match.snippet, "```", "", match.fix];
+  if (match.seeAlsoSlugs.length > 0 || match.seeAlsoTokens.length > 0) {
+    const refs = [];
+    for (const slug of match.seeAlsoSlugs) {
+      refs.push(`\`dbx_ui_lookup topic="${slug}"\``);
+    }
+    for (const token of match.seeAlsoTokens) {
+      refs.push(`\`dbx_css_token_lookup value="${token}"\``);
+    }
+    lines.push("", `See also: ${refs.join(", ")}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatGoodSignals(html, scss) {
+  let result = null;
+  if (html.length > 0 || scss.length > 0) {
+    const lines = [];
+    if (html.length > 0) {
+      const elements = /* @__PURE__ */ new Map();
+      for (const match of html.matchAll(/<(dbx-[\w-]+)\b/g)) {
+        const tag = match[1].toLowerCase();
+        elements.set(tag, (elements.get(tag) ?? 0) + 1);
+      }
+      if (elements.size > 0) {
+        const summary = Array.from(elements.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([tag, n]) => `${tag} \xD7${n}`).join(", ");
+        lines.push(`- HTML uses: ${summary}`);
+      } else {
+        lines.push("- HTML uses: no `dbx-*` elements");
+      }
+    }
+    if (scss.length > 0) {
+      let dbx = 0;
+      let matSys = 0;
+      for (const match of scss.matchAll(/var\(\s*(--[\w-]+)/g)) {
+        const name = match[1];
+        if (name.startsWith("--dbx-")) dbx += 1;
+        else if (name.startsWith("--mat-sys-")) matSys += 1;
+      }
+      lines.push(`- SCSS uses: ${dbx} \`--dbx-*\` reference${dbx === 1 ? "" : "s"}, ${matSys} \`--mat-sys-*\` reference${matSys === 1 ? "" : "s"}`);
+    }
+    if (lines.length > 0) {
+      result = `Good signals:
+${lines.join("\n")}`;
+    }
+  }
+  return result;
+}
+function formatTokenTable(matches, _tokenRegistry) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    for (const token of match.seeAlsoTokens) {
+      if (seen.has(token)) continue;
+      seen.add(token);
+      rows.push(`| ${match.id} | \`var(${token})\` |`);
+    }
+  }
+  let result;
+  if (rows.length === 0) {
+    result = null;
+  } else {
+    result = ["| Smell | Recommended var |", "| --- | --- |", ...rows].join("\n");
+  }
+  return result;
+}
+
+// packages/dbx-components-mcp/src/tools/ui-smell-check.tool.ts
+var DBX_UI_SMELL_CHECK_TOOL = {
+  name: "dbx_ui_smell_check",
+  description: [
+    "Reverse-lookup: paste component HTML and/or SCSS and get back the dbx-web smells you triggered, plus the canonical fix.",
+    "",
+    "Run this after writing component SCSS \u2014 it flags hand-rolled card surfaces, raw `mat-button` usages, hardcoded paddings/radii/shadows/colors that map to existing tokens, MDC token overrides that should be a host attribute or wrapper, and other patterns that already have a dbx-web primitive.",
+    "",
+    "Pass either `html` / `scss` (inline strings) or `htmlPath` / `scssPath` (read from disk, relative to cwd or absolute). Prefer paths for files larger than ~1KB to keep the tool input small. Optional `context` is a one-liner about what the component is for (informational \u2014 does not change detection).",
+    "",
+    "Project-local conventions (e.g. wrapper class names) can be supplied via `projectConventions` or read from `dbx-mcp.config.json` `uiSmellCheck.projectConventions`."
+  ].join("\n"),
+  inputSchema: {
+    type: "object",
+    properties: {
+      html: { type: "string", description: "Component HTML (optional). Mutually exclusive with `htmlPath`." },
+      scss: { type: "string", description: "Component SCSS (optional). Mutually exclusive with `scssPath`." },
+      htmlPath: { type: "string", description: "Path to a component HTML file. Resolved relative to the MCP cwd, or used as-is when absolute. Mutually exclusive with `html`." },
+      scssPath: { type: "string", description: "Path to a component SCSS/CSS file. Resolved relative to the MCP cwd, or used as-is when absolute. Mutually exclusive with `scss`." },
+      context: { type: "string", description: "Optional one-liner about what the component is for." },
+      projectConventions: {
+        type: "object",
+        description: "Optional project-local convention overrides \u2014 wins over the config-file defaults.",
+        properties: {
+          cardWrapperClasses: { type: "array", items: { type: "string" } }
+        }
+      }
+    }
+  }
+};
+var SmellCheckArgs = type67({
+  "html?": "string",
+  "scss?": "string",
+  "htmlPath?": "string",
+  "scssPath?": "string",
+  "context?": "string",
+  "projectConventions?": type67({ "cardWrapperClasses?": "string[]" })
+});
+function parseArgs12(raw, defaults) {
+  const parsed = SmellCheckArgs(raw);
+  if (parsed instanceof type67.errors) {
+    throw new TypeError(`Invalid arguments: ${parsed.summary}`);
+  }
+  const html = parsed.html ?? "";
+  const scss = parsed.scss ?? "";
+  const merged = {
+    cardWrapperClasses: parsed.projectConventions?.cardWrapperClasses ?? defaults.cardWrapperClasses
+  };
+  return { html, scss, htmlPath: parsed.htmlPath, scssPath: parsed.scssPath, context: parsed.context, conventions: merged };
+}
+var DEFAULT_READ_FILE12 = (path) => nodeReadFile8(path, "utf-8");
+async function readPathInput(path, cwd, readFile20) {
+  const absolute = isAbsolute10(path) ? path : resolve40(cwd, path);
+  return readFile20(absolute);
+}
+function createUiSmellCheckTool(input) {
+  const { tokenRegistry, uiComponentRegistry, cwd, readFile: readFile20 } = input;
+  const run15 = async (rawArgs) => {
+    let conventionsFromConfig = {};
+    try {
+      const configResult = await findAndLoadConfig({ cwd: cwd ?? process.cwd(), readFile: readFile20 });
+      const block = configResult.config?.uiSmellCheck?.projectConventions;
+      if (block !== void 0) {
+        conventionsFromConfig = block;
+      }
+    } catch {
+      conventionsFromConfig = {};
+    }
+    let args;
+    try {
+      args = parseArgs12(rawArgs, conventionsFromConfig);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return toolError(message);
+    }
+    if (args.html.length > 0 && args.htmlPath !== void 0) {
+      return toolError("dbx_ui_smell_check: provide either `html` or `htmlPath`, not both.");
+    }
+    if (args.scss.length > 0 && args.scssPath !== void 0) {
+      return toolError("dbx_ui_smell_check: provide either `scss` or `scssPath`, not both.");
+    }
+    const resolvedCwd = cwd ?? process.cwd();
+    const reader = readFile20 ?? DEFAULT_READ_FILE12;
+    let html = args.html;
+    let scss = args.scss;
+    if (args.htmlPath !== void 0) {
+      try {
+        html = await readPathInput(args.htmlPath, resolvedCwd, reader);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return toolError(`dbx_ui_smell_check: failed to read htmlPath \`${args.htmlPath}\`: ${message}`);
+      }
+    }
+    if (args.scssPath !== void 0) {
+      try {
+        scss = await readPathInput(args.scssPath, resolvedCwd, reader);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return toolError(`dbx_ui_smell_check: failed to read scssPath \`${args.scssPath}\`: ${message}`);
+      }
+    }
+    if (html.length === 0 && scss.length === 0) {
+      return toolError("dbx_ui_smell_check: provide at least one of `html`, `scss`, `htmlPath`, or `scssPath`.");
+    }
+    const matches = detectSmells({
+      html,
+      scss,
+      conventions: args.conventions,
+      tokenRegistry,
+      uiComponentRegistry
+    });
+    const text = formatSmellResult({ html, scss, context: args.context }, matches, tokenRegistry);
+    return { content: [{ type: "text", text }] };
+  };
+  return { definition: DBX_UI_SMELL_CHECK_TOOL, run: run15 };
+}
+
+// packages/dbx-components-mcp/src/tools/index.ts
+var DBX_TOOLS = [
+  // form
+  formExamplesTool,
+  // ui
+  uiExamplesTool,
+  // model
+  lookupModelTool,
+  searchModelTool,
+  modelDecodeTool,
+  modelValidateApiTool,
+  modelApiListAppTool,
+  modelApiLookupTool,
+  modelApiValidateAppTool,
+  modelValidateFolderTool,
+  modelStoreScaffoldTool,
+  modelFixtureListAppTool,
+  modelFixtureLookupTool,
+  modelFixtureScaffoldTool,
+  modelFixtureForwardTool,
+  modelTestTreeTool,
+  modelTestSearchTool,
+  // storagefile_m (model extension)
+  storageFileMValidateAppTool,
+  storageFileMListAppTool,
+  storageFileMValidateFolderTool,
+  // notification_m (model extension)
+  notificationMValidateAppTool,
+  notificationMListAppTool,
+  notificationMValidateFolderTool,
+  // system_m (model extension)
+  systemMValidateFolderTool,
+  // action
+  actionExamplesTool,
+  actionScaffoldTool,
+  // route
+  routeTreeTool,
+  routeLookupTool,
+  routeSearchTool,
+  // filter
+  filterScaffoldTool,
+  // artifact (cross-domain dispatchers)
+  artifactScaffoldTool,
+  artifactFileConventionTool,
+  // rule catalog (cross-domain reference)
+  explainRuleTool,
+  // aggregate orchestrator
+  appValidateTool,
+  // downstream component introspection
+  modelListComponentTool,
   serverActionsListAppTool,
   // workspace config audit / setup
   mcpConfigTool
@@ -31424,6 +33121,12 @@ function registerTools(server, options = {}) {
   if (options.filterRegistry !== void 0) {
     tools.push(createLookupFilterTool({ registry: options.filterRegistry }));
   }
+  if (options.tokenRegistry !== void 0) {
+    tools.push(createCssTokenLookupTool({ registry: options.tokenRegistry }));
+    if (options.uiComponentRegistry !== void 0) {
+      tools.push(createUiSmellCheckTool({ tokenRegistry: options.tokenRegistry, uiComponentRegistry: options.uiComponentRegistry, cwd: options.cwd }));
+    }
+  }
   underlyingServer.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: tools.map((t) => t.definition) };
   });
@@ -31464,6 +33167,11 @@ Resource URIs are namespaced by domain:
 - dbx://ui/components[/{slug}|/category/{category}|/kind/{kind}]
 - dbx://pipe/entries[/{slug}|/category/{category}]
 - dbx://filter/entries[/{slug}|/kind/{kind}]
+- dbx://token/entries[/{cssVariable}|/source/{source}|/role/{role}]
+
+UI styling reverse/forward lookup:
+- dbx_css_token_lookup \u2014 forward: intent/value/role/component \u2192 recommended \`var(--\u2026)\` + utility class + dbx-web primitive.
+- dbx_ui_smell_check   \u2014 reverse: paste component HTML/SCSS, get smells + canonical fix. **Run this after writing component SCSS** so hardcoded paddings/radii/shadows/colors get caught before they ship.
 
 Fall back to dbx-components prose skills only for content this server doesn't carry: Firestore security rules, multi-file orchestration walkthroughs, model design phase, naming/tier checklists, and decision/why content beyond catalog lookup.`;
 async function createServer(options = {}) {
@@ -31592,12 +33300,30 @@ async function createServer(options = {}) {
       filterRegistry = void 0;
     }
   }
+  let tokenRegistry = options.tokenRegistry;
+  if (tokenRegistry === void 0) {
+    const cwd = options.cwd ?? process.cwd();
+    try {
+      const tokenLoaderResult = await loadTokenRegistry({ cwd });
+      if (options.onTokenLoaderResult === void 0) {
+        reportTokenLoaderResult(tokenLoaderResult);
+      } else {
+        options.onTokenLoaderResult(tokenLoaderResult);
+      }
+      tokenRegistry = tokenLoaderResult.registry;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[dbx-components-mcp] tokens registry unavailable: ${message}
+`);
+      tokenRegistry = void 0;
+    }
+  }
   const fixtureModelRegistry = {
     entries: FIREBASE_MODELS.map((m) => ({ name: m.name, modelType: m.modelType, collectionPrefix: m.collectionPrefix }))
   };
   await emitDownstreamHints({ cwd: options.cwd ?? process.cwd(), externalCounts, onDownstreamHints: options.onDownstreamHints });
-  registerResources(server, { semanticTypeRegistry: registry, forgeFieldRegistry: forgeRegistry, pipeRegistry, uiComponentRegistry: uiRegistry, actionRegistry, filterRegistry });
-  registerTools(server, { semanticTypeRegistry: registry, forgeFieldRegistry: forgeRegistry, pipeRegistry, uiComponentRegistry: uiRegistry, actionRegistry, filterRegistry, fixtureModelRegistry, modelValidateRuleOptions });
+  registerResources(server, { semanticTypeRegistry: registry, forgeFieldRegistry: forgeRegistry, pipeRegistry, uiComponentRegistry: uiRegistry, actionRegistry, filterRegistry, tokenRegistry });
+  registerTools(server, { semanticTypeRegistry: registry, forgeFieldRegistry: forgeRegistry, pipeRegistry, uiComponentRegistry: uiRegistry, actionRegistry, filterRegistry, tokenRegistry, fixtureModelRegistry, modelValidateRuleOptions, cwd: options.cwd ?? process.cwd() });
   return server;
 }
 function resolveModelValidateRuleOptions(config) {
@@ -31701,6 +33427,20 @@ function reportFilterLoaderResult(result) {
 `);
   }
 }
+function reportTokenLoaderResult(result) {
+  const { registry, configPath, configWarnings, loaderWarnings, externalSourceCount } = result;
+  const summary = [`[dbx-components-mcp] tokens registry loaded`, `  sources: ${registry.loadedSources.join(", ") || "(none)"}`, `  external: ${externalSourceCount}`, `  config: ${configPath ?? "(none)"}`, `  entries: ${registry.all.length}`, `  warnings: ${configWarnings.length + loaderWarnings.length}`].join("\n");
+  process.stderr.write(`${summary}
+`);
+  for (const warning of configWarnings) {
+    process.stderr.write(`[dbx-components-mcp] tokens-config-warning: ${warning.kind} ${warning.path}
+`);
+  }
+  for (const warning of loaderWarnings) {
+    process.stderr.write(`[dbx-components-mcp] tokens-loader-warning: ${warning.kind}
+`);
+  }
+}
 var HINT_CLUSTER_LABEL = {
   semanticTypes: "semantic-types",
   uiComponents: "ui-components",