@dereekb/dbx-components-mcp 14.5.0 → 14.5.1

package/dbx-components-mcp.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 // packages/dbx-components-mcp/package.json
 var package_default = {
   name: "@dereekb/dbx-components-mcp",
-  version: "14.5.0",
+  version: "14.5.1",
   sideEffects: false,
   type: "module",
   bin: {
@@ -22,8 +22,8 @@ var package_default = {
     "ts-morph": "^21.0.0"
   },
   peerDependencies: {
-    "@dereekb/dbx-cli": "14.5.0",
-    "@dereekb/util": "14.5.0"
+    "@dereekb/dbx-cli": "14.5.1",
+    "@dereekb/util": "14.5.1"
   }
 };
 
@@ -4925,10 +4925,10 @@ function extractCandidateParams(candidate, descriptions) {
   for (const param of params) {
     const name = param.getName();
     const typeNode = param.getTypeNode()?.getText();
-    const type109 = typeNode ?? param.getType().getText() ?? "unknown";
+    const type110 = typeNode ?? param.getType().getText() ?? "unknown";
     const description = descriptions.get(name) ?? "";
     const optional = param.isOptional() || param.hasInitializer();
-    out.push({ name, type: type109, description, optional });
+    out.push({ name, type: type110, description, optional });
   }
   return out;
 }
@@ -6411,13 +6411,13 @@ function parseDecoratorInput(property) {
   const decoratorArg = decorator.getCallExpression()?.getArguments()[0];
   const { alias, requiredFromDecorator } = readInputDecoratorArg(decoratorArg);
   const required = requiredFromDecorator ?? !property.hasQuestionToken();
-  const type109 = property.getTypeNode()?.getText() ?? "unknown";
+  const type110 = property.getTypeNode()?.getText() ?? "unknown";
   const initializer = property.getInitializer();
   const defaultValue = initializer === void 0 ? void 0 : initializer.getText();
   return {
     propertyName,
     alias: alias ?? propertyName,
-    type: type109,
+    type: type110,
     required,
     description: readPropertyDescription(property),
     ...defaultValue === void 0 ? {} : { defaultValue }
@@ -6510,22 +6510,22 @@ function parseDecoratorOutput(property) {
     alias = decoratorArg.getLiteralText();
   }
   const initializer = property.getInitializer();
-  let type109 = "unknown";
+  let type110 = "unknown";
   if (initializer !== void 0 && Node9.isNewExpression(initializer)) {
     const typeArgs = initializer.getTypeArguments();
     if (typeArgs.length > 0) {
-      type109 = typeArgs[0].getText();
+      type110 = typeArgs[0].getText();
     }
   } else {
     const explicit = property.getTypeNode()?.getText();
     if (explicit !== void 0) {
-      type109 = explicit;
+      type110 = explicit;
     }
   }
   return {
     propertyName,
     name: alias ?? propertyName,
-    type: type109,
+    type: type110,
     description: readPropertyDescription(property)
   };
 }
@@ -6540,7 +6540,7 @@ function parseSignalOutput(property) {
   }
   const propertyName = property.getName();
   const typeArgs = initializer.getTypeArguments();
-  const type109 = typeArgs.length > 0 ? typeArgs[0].getText() : "void";
+  const type110 = typeArgs.length > 0 ? typeArgs[0].getText() : "void";
   const args = initializer.getArguments();
   let alias;
   if (args.length > 0 && Node9.isObjectLiteralExpression(args[0])) {
@@ -6549,7 +6549,7 @@ function parseSignalOutput(property) {
   return {
     propertyName,
     name: alias ?? propertyName,
-    type: type109,
+    type: type110,
     description: readPropertyDescription(property)
   };
 }
@@ -11274,10 +11274,10 @@ function collectParams(decl, descriptions) {
   for (const param of params) {
     const name = param.getName();
     const typeNode = param.getTypeNode()?.getText();
-    const type109 = typeNode ?? param.getType().getText() ?? "unknown";
+    const type110 = typeNode ?? param.getType().getText() ?? "unknown";
     const description = descriptions.get(name) ?? "";
     const optional = param.isOptional() || param.hasInitializer();
-    out.push({ name, type: type109, description, optional });
+    out.push({ name, type: type110, description, optional });
   }
   return out;
 }
@@ -12957,10 +12957,10 @@ function readTransformSignature(method, fallbackParamDescriptions) {
   for (let i = 1; i < params.length; i += 1) {
     const param = params[i];
     const name = param.getName();
-    const type109 = readParamType(param);
+    const type110 = readParamType(param);
     const description = methodParamDescriptions.get(name) ?? fallbackParamDescriptions.get(name) ?? "";
     const required = !param.isOptional() && !param.hasInitializer();
-    args.push({ name, type: type109, description, required });
+    args.push({ name, type: type110, description, required });
   }
   return { inputType, outputType, args };
 }
@@ -14956,7 +14956,7 @@ async function loadForgeFieldRegistry(input) {
 }
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/load-model-firebase-index-registry.ts
-import { dirname as dirname9, isAbsolute as isAbsolute9, resolve as resolve27 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute9, resolve as resolve28 } from "node:path";
 
 // packages/dbx-cli/firestore-indexes/src/firestore-indexes-generate.ts
 function generateFirestoreIndexesJson(input) {
@@ -15186,7 +15186,7 @@ function computeDiff(input) {
 
 // packages/dbx-cli/firestore-indexes/src/generate-firestore-indexes-cli.ts
 import { readFile as nodeReadFile7, writeFile as nodeWriteFile3 } from "node:fs/promises";
-import { resolve as resolve26 } from "node:path";
+import { resolve as resolve27 } from "node:path";
 
 // packages/dbx-cli/firestore-indexes/src/model-firebase-index-runtime.ts
 // @__NO_SIDE_EFFECTS__
@@ -15288,17 +15288,128 @@ function pushInto13(map, key, entry) {
   }
 }
 
+// packages/dbx-cli/firestore-indexes/src/model-firebase-index-package-manifests.ts
+import { type as type42 } from "arktype";
+import { readdir as nodeReadDir } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname as dirname9, resolve as resolve26 } from "node:path";
+var MODEL_FIREBASE_INDEX_MANIFEST_FILENAME_SUFFIX = ".model-firebase-index.mcp.generated.json";
+var BUNDLED_MODEL_FIREBASE_INDEX_MANIFEST_PACKAGE = "@dereekb/dbx-components-mcp";
+var BUNDLED_MANIFEST_DIRECTORY_NAME = "generated";
+var defaultBundledManifestDirectoryResolver = (cwd) => {
+  let result;
+  try {
+    const requireFromCwd = createRequire(resolve26(cwd, "noop.js"));
+    const packageJsonPath = requireFromCwd.resolve(`${BUNDLED_MODEL_FIREBASE_INDEX_MANIFEST_PACKAGE}/package.json`);
+    result = resolve26(dirname9(packageJsonPath), BUNDLED_MANIFEST_DIRECTORY_NAME);
+  } catch {
+    result = null;
+  }
+  return result;
+};
+var defaultReadDir = (path) => nodeReadDir(path);
+async function loadModelFirebaseIndexPackageManifests(input) {
+  const { cwd, manifestPaths = [], discoverBundled = false, readFile: readFile33 = defaultReadFile, readDir = defaultReadDir, resolveBundledDirectory = defaultBundledManifestDirectoryResolver } = input;
+  const paths = manifestPaths.map((path) => resolve26(cwd, path));
+  let failure = null;
+  if (discoverBundled) {
+    const bundledDirectory = resolveBundledDirectory(cwd);
+    if (bundledDirectory == null) {
+      failure = { kind: "no-bundled-package", packageName: BUNDLED_MODEL_FIREBASE_INDEX_MANIFEST_PACKAGE };
+    } else {
+      paths.push(...await readBundledManifestPaths(bundledDirectory, readDir));
+    }
+  }
+  const loaded = [];
+  for (const path of paths) {
+    if (failure != null) {
+      break;
+    }
+    const readResult = await readManifestFile(path, readFile33);
+    if (readResult.kind === "ok") {
+      loaded.push({ path, manifest: readResult.manifest });
+    } else {
+      failure = readResult.outcome;
+    }
+  }
+  return failure ?? { kind: "success", loaded };
+}
+function formatModelFirebaseIndexPackageManifestFailure(outcome) {
+  let result;
+  switch (outcome.kind) {
+    case "unreadable-manifest":
+      result = `could not read manifest at ${outcome.path} \u2014 ${outcome.error}`;
+      break;
+    case "invalid-manifest":
+      result = `manifest at ${outcome.path} failed validation \u2014 ${outcome.error}`;
+      break;
+    default:
+      result = `${outcome.packageName} is not installed, so no bundled index manifests could be discovered. Install it, or pass --manifest <path> explicitly.`;
+      break;
+  }
+  return result;
+}
+async function readBundledManifestPaths(directory, readDir) {
+  let result;
+  try {
+    const names = await readDir(directory);
+    result = names.filter((name) => name.endsWith(MODEL_FIREBASE_INDEX_MANIFEST_FILENAME_SUFFIX)).toSorted().map((name) => resolve26(directory, name));
+  } catch {
+    result = [];
+  }
+  return result;
+}
+async function readManifestFile(path, readFile33) {
+  let raw = null;
+  let readError = null;
+  try {
+    raw = await readFile33(path);
+  } catch (err) {
+    readError = err instanceof Error ? err.message : String(err);
+  }
+  let result;
+  if (raw == null) {
+    result = { kind: "fail", outcome: { kind: "unreadable-manifest", path, error: readError ?? "unknown error" } };
+  } else {
+    let parsed;
+    let parseError = null;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      parseError = err instanceof Error ? err.message : String(err);
+    }
+    if (parseError == null) {
+      const validated = ModelFirebaseIndexManifest(parsed);
+      if (validated instanceof type42.errors) {
+        result = { kind: "fail", outcome: { kind: "invalid-manifest", path, error: validated.summary } };
+      } else {
+        result = { kind: "ok", manifest: validated };
+      }
+    } else {
+      result = { kind: "fail", outcome: { kind: "invalid-manifest", path, error: parseError } };
+    }
+  }
+  return result;
+}
+
 // packages/dbx-cli/firestore-indexes/src/generate-firestore-indexes-cli.ts
 var DEFAULT_BIN_NAME = "dbx-cli-generate-firestore-indexes";
 function buildUsage(binName) {
   return [
-    `Usage: ${binName} --component <dir> [--component <dir> ...] [--output <path>] [--check] [--json] [--help]`,
+    `Usage: ${binName} [--component <dir> ...] [--packages] [--manifest <path> ...] [--output <path>] [--check] [--json] [--help]`,
     "",
     "Generates `firestore.indexes.json` from `@dbxModelFirebaseIndex`-tagged factories.",
     "",
     "Options:",
-    "  --component <dir>  Required, repeatable. Relative path to a `-firebase` component or package.",
-    "                     Repeat to derive one indexes file from several packages at once.",
+    "  --component <dir>  Repeatable. Relative path to a `-firebase` component or package whose",
+    "                     source is scanned for tagged factories. Repeat to derive one indexes",
+    "                     file from several packages at once.",
+    "  --packages         Also merge the pre-built index manifests bundled in the installed",
+    "                     @dereekb/dbx-components-mcp. Lets an app derive the framework models\u2019",
+    "                     indexes without a scannable copy of their source.",
+    "  --manifest <path>  Repeatable. Merge a specific pre-built manifest JSON file.",
+    "",
+    "  At least one of --component / --packages / --manifest is required.",
     "  --output <path>    Output path. Defaults to `firestore.indexes.json` at the cwd.",
     "  --check            Compare against the on-disk file; exit 1 on drift, do not write.",
     "  --json             Print the diff summary as JSON instead of human-readable text.",
@@ -15318,18 +15429,18 @@ async function runGenerateFirestoreIndexesCli(input) {
     stderr(usage);
     return { exitCode: 2 };
   }
-  if (parsed.components.length === 0) {
-    stderr("generate-firestore-indexes: --component is required");
+  if (parsed.components.length === 0 && parsed.manifests.length === 0 && !parsed.packages) {
+    stderr("generate-firestore-indexes: at least one of --component / --packages / --manifest is required");
     stderr(usage);
     return { exitCode: 2 };
   }
-  const outputAbs = resolve26(cwd, parsed.output);
+  const outputAbs = resolve27(cwd, parsed.output);
   const entries = [];
   const loadedSources = [];
   let sawUnresolvedModel = false;
   for (const component of parsed.components) {
     const buildOutcome = await buildModelFirebaseIndexManifest({
-      projectRoot: resolve26(cwd, component),
+      projectRoot: resolve27(cwd, component),
       generator
     });
     if (buildOutcome.kind !== "success") {
@@ -15347,6 +15458,15 @@ async function runGenerateFirestoreIndexesCli(input) {
     }
     loadedSources.push(buildOutcome.manifest.source);
   }
+  if (parsed.packages || parsed.manifests.length > 0) {
+    const merged = await collectPackageManifestEntries({ cwd, manifestPaths: parsed.manifests, discoverBundled: parsed.packages, readFile: readFile33 });
+    if (merged.kind === "fail") {
+      stderr(merged.message);
+      return { exitCode: 1 };
+    }
+    entries.push(...merged.entries);
+    loadedSources.push(...merged.sources);
+  }
   if (sawUnresolvedModel) {
     stderr("generate-firestore-indexes: one or more @dbxModelFirebaseIndexModel tags could not be resolved, so their indexes were dropped. Add the missing identity file to the component\u2019s `dbx-mcp.scan.json` include globs.");
     return { exitCode: 1 };
@@ -15373,8 +15493,29 @@ async function runGenerateFirestoreIndexesCli(input) {
   }
   return { exitCode: 0 };
 }
+async function collectPackageManifestEntries(input) {
+  const { cwd, manifestPaths, discoverBundled, readFile: readFile33 } = input;
+  const outcome = await loadModelFirebaseIndexPackageManifests({ cwd, manifestPaths, discoverBundled, readFile: readFile33 });
+  let result;
+  if (outcome.kind === "success") {
+    const entries = [];
+    const sources = [];
+    for (const { manifest } of outcome.loaded) {
+      for (const entry of manifest.entries) {
+        entries.push(toModelFirebaseIndexEntryInfo(entry));
+      }
+      sources.push(manifest.source);
+    }
+    result = { kind: "ok", entries, sources };
+  } else {
+    result = { kind: "fail", message: `generate-firestore-indexes: ${formatModelFirebaseIndexPackageManifestFailure(outcome)}` };
+  }
+  return result;
+}
 function parseArgv(argv) {
   const components = [];
+  const manifests = [];
+  let packages = false;
   let output = "firestore.indexes.json";
   let check = false;
   let json = false;
@@ -15392,6 +15533,17 @@ function parseArgv(argv) {
           components.push(argv[i]);
         }
         break;
+      case "--manifest":
+        i += 1;
+        if (i >= argv.length) {
+          error = "generate-firestore-indexes: --manifest requires a value";
+        } else {
+          manifests.push(argv[i]);
+        }
+        break;
+      case "--packages":
+        packages = true;
+        break;
       case "--output":
         i += 1;
         if (i >= argv.length) {
@@ -15416,7 +15568,7 @@ function parseArgv(argv) {
     }
     i += 1;
   }
-  return { components, output, check, json, help, error };
+  return { components, manifests, packages, output, check, json, help, error };
 }
 async function readExistingIndexes(input) {
   const text = await readExistingIndexesText(input);
@@ -15542,7 +15694,7 @@ async function loadModelFirebaseIndexManifests(input) {
 var DEFAULT_BUNDLED_FILENAMES7 = ["dereekb-firebase.model-firebase-index.mcp.generated.json"];
 var DEFAULT_BUNDLED_PATHS7 = () => {
   const packageRoot = findPackageRoot(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES7.map((name) => resolve27(packageRoot, "generated", name));
+  return DEFAULT_BUNDLED_FILENAMES7.map((name) => resolve28(packageRoot, "generated", name));
 };
 async function loadModelFirebaseIndexRegistry(input) {
   const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS7, readFile: readFile33 } = input;
@@ -15550,10 +15702,10 @@ async function loadModelFirebaseIndexRegistry(input) {
   const configResult = await findAndLoadConfig({ cwd, readFile: readFile33 });
   const externalSources = [];
   if (configResult.config != null && configResult.configPath != null) {
-    const baseDir = dirname9(configResult.configPath);
+    const baseDir = dirname10(configResult.configPath);
     const declared = configResult.config.modelFirebaseIndex?.sources ?? [];
     for (const source of declared) {
-      const absolute = isAbsolute9(source) ? source : resolve27(baseDir, source);
+      const absolute = isAbsolute9(source) ? source : resolve28(baseDir, source);
       externalSources.push({ origin: "external", path: absolute });
     }
   }
@@ -15579,7 +15731,7 @@ async function loadModelFirebaseIndexRegistry(input) {
 }
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/load-model-snapshot-fields-registry.ts
-import { dirname as dirname10, isAbsolute as isAbsolute10, resolve as resolve28 } from "node:path";
+import { dirname as dirname11, isAbsolute as isAbsolute10, resolve as resolve29 } from "node:path";
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/model-snapshot-fields-loader.ts
 async function loadModelSnapshotFieldManifests(input) {
@@ -15596,7 +15748,7 @@ async function loadModelSnapshotFieldManifests(input) {
 var DEFAULT_BUNDLED_FILENAMES8 = ["dereekb-firebase.model-snapshot-fields.mcp.generated.json"];
 var DEFAULT_BUNDLED_PATHS8 = () => {
   const packageRoot = findPackageRoot(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES8.map((name) => resolve28(packageRoot, "generated", name));
+  return DEFAULT_BUNDLED_FILENAMES8.map((name) => resolve29(packageRoot, "generated", name));
 };
 async function loadModelSnapshotFieldRegistry(input) {
   const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS8, readFile: readFile33 } = input;
@@ -15604,10 +15756,10 @@ async function loadModelSnapshotFieldRegistry(input) {
   const configResult = await findAndLoadConfig({ cwd, readFile: readFile33 });
   const externalSources = [];
   if (configResult.config != null && configResult.configPath != null) {
-    const baseDir = dirname10(configResult.configPath);
+    const baseDir = dirname11(configResult.configPath);
     const declared = configResult.config.modelSnapshotFields?.sources ?? [];
     for (const source of declared) {
-      const absolute = isAbsolute10(source) ? source : resolve28(baseDir, source);
+      const absolute = isAbsolute10(source) ? source : resolve29(baseDir, source);
       externalSources.push({ origin: "external", path: absolute });
     }
   }
@@ -15634,7 +15786,7 @@ async function loadModelSnapshotFieldRegistry(input) {
 }
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/load-pipes-registry.ts
-import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve29 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute11, resolve as resolve30 } from "node:path";
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/pipes-loader.ts
 async function loadPipeManifests(input) {
@@ -15651,7 +15803,7 @@ async function loadPipeManifests(input) {
 var DEFAULT_BUNDLED_FILENAMES9 = ["dereekb-dbx-core.pipes.mcp.generated.json"];
 var DEFAULT_BUNDLED_PATHS9 = () => {
   const packageRoot = findPackageRoot(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES9.map((name) => resolve29(packageRoot, "generated", name));
+  return DEFAULT_BUNDLED_FILENAMES9.map((name) => resolve30(packageRoot, "generated", name));
 };
 async function loadPipeRegistry(input) {
   const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS9, readFile: readFile33 } = input;
@@ -15659,10 +15811,10 @@ async function loadPipeRegistry(input) {
   const configResult = await findAndLoadConfig({ cwd, readFile: readFile33 });
   const externalSources = [];
   if (configResult.config != null && configResult.configPath != null) {
-    const baseDir = dirname11(configResult.configPath);
+    const baseDir = dirname12(configResult.configPath);
     const declared = configResult.config.pipes?.sources ?? [];
     for (const source of declared) {
-      const absolute = isAbsolute11(source) ? source : resolve29(baseDir, source);
+      const absolute = isAbsolute11(source) ? source : resolve30(baseDir, source);
       externalSources.push({ origin: "external", path: absolute });
     }
   }
@@ -15685,17 +15837,17 @@ async function loadPipeRegistry(input) {
 }
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/load-tokens-registry.ts
-import { dirname as dirname12, isAbsolute as isAbsolute12, resolve as resolve30 } from "node:path";
+import { dirname as dirname13, isAbsolute as isAbsolute12, resolve as resolve31 } from "node:path";
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/tokens-schema.ts
-import { type as type42 } from "arktype";
+import { type as type43 } 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", "dbx-form", "mat-sys", "mdc", "app"];
-var TokenDefaults = type42({
+var TokenDefaults = type43({
   "light?": "string",
   "dark?": "string"
 });
-var TokenEntry = type42({
+var TokenEntry = type43({
   cssVariable: "string",
   "scssVariable?": "string",
   source: '"dbx-web" | "dbx-form" | "mat-sys" | "mdc" | "app"',
@@ -15709,7 +15861,7 @@ var TokenEntry = type42({
   "recommendedPrimitive?": "string",
   "seeAlso?": "string[]"
 });
-var TokenManifest = type42({
+var TokenManifest = type43({
   version: "1",
   source: "string",
   module: "string",
@@ -15733,7 +15885,7 @@ async function loadTokenManifests(input) {
 var DEFAULT_BUNDLED_FILENAMES10 = ["dereekb-dbx-web.tokens.mcp.generated.json", "dereekb-dbx-form.tokens.mcp.generated.json", "angular-material-m3.tokens.mcp.generated.json", "angular-material-mdc.tokens.mcp.generated.json"];
 var DEFAULT_BUNDLED_PATHS10 = () => {
   const packageRoot = findPackageRoot(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES10.map((name) => resolve30(packageRoot, "generated", name));
+  return DEFAULT_BUNDLED_FILENAMES10.map((name) => resolve31(packageRoot, "generated", name));
 };
 async function loadTokenRegistry(input) {
   const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS10, readFile: readFile33 } = input;
@@ -15760,7 +15912,7 @@ async function loadTokenRegistry(input) {
 function collectExternalTokenSources(configResult) {
   const externalSources = [];
   if (configResult.config != null && configResult.configPath != null) {
-    const baseDir = dirname12(configResult.configPath);
+    const baseDir = dirname13(configResult.configPath);
     const tokensCluster = configResult.config.tokens;
     for (const source of tokensCluster?.sources ?? []) {
       externalSources.push({ origin: "external", path: toAbsolutePath2(baseDir, source) });
@@ -15775,11 +15927,11 @@ function collectExternalTokenSources(configResult) {
   return externalSources;
 }
 function toAbsolutePath2(baseDir, value) {
-  return isAbsolute12(value) ? value : resolve30(baseDir, value);
+  return isAbsolute12(value) ? value : resolve31(baseDir, value);
 }
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/load-ui-components-registry.ts
-import { dirname as dirname13, isAbsolute as isAbsolute13, resolve as resolve31 } from "node:path";
+import { dirname as dirname14, isAbsolute as isAbsolute13, resolve as resolve32 } from "node:path";
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/ui-components-loader.ts
 async function loadUiComponentManifests(input) {
@@ -15796,7 +15948,7 @@ async function loadUiComponentManifests(input) {
 var DEFAULT_BUNDLED_FILENAMES11 = ["dereekb-dbx-web.ui-components.mcp.generated.json"];
 var DEFAULT_BUNDLED_PATHS11 = () => {
   const packageRoot = findPackageRoot(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES11.map((name) => resolve31(packageRoot, "generated", name));
+  return DEFAULT_BUNDLED_FILENAMES11.map((name) => resolve32(packageRoot, "generated", name));
 };
 async function loadUiComponentRegistry(input) {
   const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS11, readFile: readFile33 } = input;
@@ -15804,10 +15956,10 @@ async function loadUiComponentRegistry(input) {
   const configResult = await findAndLoadConfig({ cwd, readFile: readFile33 });
   const externalSources = [];
   if (configResult.config != null && configResult.configPath != null) {
-    const baseDir = dirname13(configResult.configPath);
+    const baseDir = dirname14(configResult.configPath);
     const declared = configResult.config.uiComponents?.sources ?? [];
     for (const source of declared) {
-      const absolute = isAbsolute13(source) ? source : resolve31(baseDir, source);
+      const absolute = isAbsolute13(source) ? source : resolve32(baseDir, source);
       externalSources.push({ origin: "external", path: absolute });
     }
   }
@@ -15830,7 +15982,7 @@ async function loadUiComponentRegistry(input) {
 }
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/load-utils-registry.ts
-import { dirname as dirname14, isAbsolute as isAbsolute14, resolve as resolve32 } from "node:path";
+import { dirname as dirname15, isAbsolute as isAbsolute14, resolve as resolve33 } from "node:path";
 
 // packages/dbx-cli/src/lib/mcp-scan/manifest/utils-loader.ts
 async function loadUtilManifests(input) {
@@ -15847,7 +15999,7 @@ async function loadUtilManifests(input) {
 var DEFAULT_BUNDLED_FILENAMES12 = ["dereekb-util.utils.mcp.generated.json", "dereekb-date.utils.mcp.generated.json", "dereekb-rxjs.utils.mcp.generated.json", "dereekb-model.utils.mcp.generated.json"];
 var DEFAULT_BUNDLED_PATHS12 = () => {
   const packageRoot = findPackageRoot(import.meta.url);
-  return DEFAULT_BUNDLED_FILENAMES12.map((name) => resolve32(packageRoot, "generated", name));
+  return DEFAULT_BUNDLED_FILENAMES12.map((name) => resolve33(packageRoot, "generated", name));
 };
 async function loadUtilRegistry(input) {
   const { cwd, bundledManifestPaths = DEFAULT_BUNDLED_PATHS12, readFile: readFile33 } = input;
@@ -15855,10 +16007,10 @@ async function loadUtilRegistry(input) {
   const configResult = await findAndLoadConfig({ cwd, readFile: readFile33 });
   const externalSources = [];
   if (configResult.config != null && configResult.configPath != null) {
-    const baseDir = dirname14(configResult.configPath);
+    const baseDir = dirname15(configResult.configPath);
     const declared = configResult.config.utils?.sources ?? [];
     for (const source of declared) {
-      const absolute = isAbsolute14(source) ? source : resolve32(baseDir, source);
+      const absolute = isAbsolute14(source) ? source : resolve33(baseDir, source);
       externalSources.push({ origin: "external", path: absolute });
     }
   }
@@ -16574,7 +16726,7 @@ function loadRouteTree(args) {
 }
 
 // packages/dbx-cli/src/lib/route/component-resolve.ts
-import { dirname as dirname15, join as join5, normalize } from "node:path/posix";
+import { dirname as dirname16, join as join5, normalize } from "node:path/posix";
 var TRY_EXTENSIONS = [".ts", ".tsx", "/index.ts", "/index.tsx"];
 function resolveComponentSourceFromSources(input) {
   const byName = /* @__PURE__ */ new Map();
@@ -16594,7 +16746,7 @@ function resolveComponentSourceFromSources(input) {
 function resolveSpecifier(specifier, routerFile, byName) {
   let result;
   if (specifier.startsWith(".")) {
-    const base = normalize(join5(dirname15(routerFile), specifier));
+    const base = normalize(join5(dirname16(routerFile), specifier));
     let resolved;
     for (const ext of TRY_EXTENSIONS) {
       const candidate = base + ext;
@@ -17006,7 +17158,7 @@ function detectMissingRouteModels(states, warnings) {
 // packages/dbx-components-mcp/src/server.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { McpServer } from "@modelcontextprotocol/server";
-import { dirname as dirname23, isAbsolute as isAbsolute20, resolve as resolvePath4 } from "node:path";
+import { dirname as dirname24, isAbsolute as isAbsolute20, resolve as resolvePath4 } from "node:path";
 
 // packages/dbx-components-mcp/src/resources/form-fields.resource.ts
 import { ResourceTemplate } from "@modelcontextprotocol/server";
@@ -19512,7 +19664,7 @@ function registerAuthResource(server, options) {
 
 // packages/dbx-components-mcp/src/resources/firestore-rules.resource.ts
 import { readFile as readFile4 } from "node:fs/promises";
-import { resolve as resolve33 } from "node:path";
+import { resolve as resolve34 } from "node:path";
 import { ResourceTemplate as ResourceTemplate15 } from "@modelcontextprotocol/server";
 
 // packages/dbx-cli/firestore-rules/src/firestore-rules-scan.ts
@@ -19739,7 +19891,7 @@ function registerFirestoreRulesResource(server, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     let result;
     try {
-      result = { scan: scanFirestoreRules(await readFile4(resolve33(cwd, rulesFile), "utf8")) };
+      result = { scan: scanFirestoreRules(await readFile4(resolve34(cwd, rulesFile), "utf8")) };
     } catch (e) {
       result = { error: `Failed to read ${rulesFile}: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -19862,7 +20014,7 @@ function registerResources(server, options = {}) {
 }
 
 // packages/dbx-components-mcp/src/tools/lookup-form.tool.ts
-import { type as type43 } from "arktype";
+import { type as type44 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/form-alias-resolver.ts
 var ALIASES = {
@@ -20087,7 +20239,7 @@ function toolError(message) {
   return result;
 }
 function toCallToolResult(result) {
-  const content = result.content.map(({ type: type109, text }) => ({ type: type109, text }));
+  const content = result.content.map(({ type: type110, text }) => ({ type: type110, text }));
   const callToolResult = result.isError === void 0 ? { content } : { content, isError: result.isError };
   return callToolResult;
 }
@@ -20124,13 +20276,13 @@ var DBX_FORM_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupFormArgsType = type43({
+var LookupFormArgsType = type44({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupFormArgs(raw) {
   const parsed = LookupFormArgsType(raw);
-  if (parsed instanceof type43.errors) {
+  if (parsed instanceof type44.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -20254,14 +20406,14 @@ function createLookupFormTool(config) {
 }
 
 // packages/dbx-components-mcp/src/tools/_search/score.ts
-import { type as type44 } from "arktype";
-var SEARCH_ARGS_TYPE = type44({
+import { type as type45 } from "arktype";
+var SEARCH_ARGS_TYPE = type45({
   query: "string",
   "limit?": "number"
 });
 function parseSearchArgs(raw, config) {
   const parsed = SEARCH_ARGS_TYPE(raw);
-  if (parsed instanceof type44.errors) {
+  if (parsed instanceof type45.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawLimit = parsed.limit ?? config.defaultLimit;
@@ -20506,7 +20658,7 @@ function createSearchFormTool(config) {
 }
 
 // packages/dbx-components-mcp/src/tools/form-examples.tool.ts
-import { type as type45 } from "arktype";
+import { type as type46 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/data/patterns/forms/form.address-form.pattern.ts
 var FORM_PATTERN_ADDRESS_FORM = {
@@ -20795,13 +20947,13 @@ var DBX_FORM_EXAMPLES_TOOL = {
     required: ["pattern"]
   }
 };
-var ExamplesArgsType = type45({
+var ExamplesArgsType = type46({
   pattern: "string",
   "depth?": "'minimal' | 'brief' | 'full'"
 });
 function parseExamplesArgs(raw) {
   const parsed = ExamplesArgsType(raw);
-  if (parsed instanceof type45.errors) {
+  if (parsed instanceof type46.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -20862,7 +21014,7 @@ var FORM_EXAMPLES_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/form-scaffold.tool.ts
-import { type as type46 } from "arktype";
+import { type as type47 } from "arktype";
 var DEFAULT_VALUE_TYPE_NAME = "ScaffoldedFormValue";
 var DBX_FORM_SCAFFOLD_TOOL = {
   name: "dbx_form_scaffold",
@@ -20900,14 +21052,14 @@ var DBX_FORM_SCAFFOLD_TOOL = {
     required: ["fields"]
   }
 };
-var ScaffoldArgsType = type46({
+var ScaffoldArgsType = type47({
   fields: "string[]>0",
   "valueTypeName?": "string",
   "wrapInSection?": "boolean"
 });
 function parseScaffoldArgs(raw) {
   const parsed = ScaffoldArgsType(raw);
-  if (parsed instanceof type46.errors) {
+  if (parsed instanceof type47.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -21065,7 +21217,7 @@ ${code17}
 }
 
 // packages/dbx-components-mcp/src/tools/lookup-ui.tool.ts
-import { type as type47 } from "arktype";
+import { type as type48 } from "arktype";
 var DBX_UI_LOOKUP_TOOL = {
   name: "dbx_ui_lookup",
   description: [
@@ -21095,13 +21247,13 @@ var DBX_UI_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupUiArgsType = type47({
+var LookupUiArgsType = type48({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupUiArgs(raw) {
   const parsed = LookupUiArgsType(raw);
-  if (parsed instanceof type47.errors) {
+  if (parsed instanceof type48.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -21359,7 +21511,7 @@ function createLookupUiTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/search-ui.tool.ts
-import { type as type48 } from "arktype";
+import { type as type49 } from "arktype";
 var DEFAULT_LIMIT2 = 10;
 var MAX_LIMIT2 = 25;
 var DBX_UI_SEARCH_TOOL = {
@@ -21396,14 +21548,14 @@ var DBX_UI_SEARCH_TOOL = {
     required: ["query"]
   }
 };
-var SearchUiArgsType = type48({
+var SearchUiArgsType = type49({
   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 type48.errors) {
+  if (parsed instanceof type49.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawLimit = parsed.limit ?? DEFAULT_LIMIT2;
@@ -21603,7 +21755,7 @@ function createSearchUiTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/ui-examples.tool.ts
-import { type as type49 } from "arktype";
+import { type as type50 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/data/patterns/ui/ui.card-with-action.pattern.ts
 var UI_PATTERN_CARD_WITH_ACTION = {
@@ -22001,13 +22153,13 @@ var DBX_UI_EXAMPLES_TOOL = {
     required: ["pattern"]
   }
 };
-var UiExamplesArgsType = type49({
+var UiExamplesArgsType = type50({
   pattern: "string",
   "depth?": "'minimal' | 'brief' | 'full'"
 });
 function parseUiExamplesArgs(raw) {
   const parsed = UiExamplesArgsType(raw);
-  if (parsed instanceof type49.errors) {
+  if (parsed instanceof type50.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -22176,7 +22328,7 @@ function createUiExamplesTool(input = {}) {
 }
 
 // packages/dbx-components-mcp/src/tools/lookup-model.tool.ts
-import { type as type50 } from "arktype";
+import { type as type51 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/firebase-lookup.formatter.ts
 function applyFieldsFilter(model, filter) {
@@ -25680,10 +25832,10 @@ function formatSeeAlso(ref) {
 
 // packages/dbx-cli/validate/src/lib/_core/validate-input.ts
 import { glob as fsGlob5, readFile as readFile5, stat as stat4 } from "node:fs/promises";
-import { resolve as resolve34, sep as sep5 } from "node:path";
+import { resolve as resolve35, sep as sep5 } from "node:path";
 function ensurePathInsideCwd(relative23, cwd) {
   const cwdPrefix = cwd.endsWith(sep5) ? cwd : cwd + sep5;
-  const absolute = resolve34(cwd, relative23);
+  const absolute = resolve35(cwd, relative23);
   if (!absolute.startsWith(cwdPrefix) && absolute !== cwd) {
     throw new Error(`Path \`${relative23}\` resolves outside the server cwd and is not allowed.`);
   }
@@ -25705,7 +25857,7 @@ async function resolveFolderPaths(config) {
   }
   if (glob2) {
     for await (const match of fsGlob5(glob2, { cwd })) {
-      const absolute = resolve34(cwd, match);
+      const absolute = resolve35(cwd, match);
       try {
         const stats = await stat4(absolute);
         if (!stats.isDirectory()) continue;
@@ -25742,7 +25894,7 @@ async function resolveValidatorSources(config) {
   for (const relative23 of pathList) {
     if (seenNames.has(relative23)) continue;
     ensurePathInsideCwd(relative23, cwd);
-    const absolute = resolve34(cwd, relative23);
+    const absolute = resolve35(cwd, relative23);
     const text = await readFile5(absolute, "utf8");
     seenNames.add(relative23);
     collected.push({ name: relative23, text });
@@ -30134,7 +30286,7 @@ function normalize2(value) {
 
 // packages/dbx-cli/validate/src/lib/model-api-validate-app/source-roots.ts
 import { readFile as readFile10, stat as stat8 } from "node:fs/promises";
-import { dirname as dirname16, isAbsolute as isAbsolute15, join as join10, relative as relative10, resolve as resolve35, sep as sep7 } from "node:path";
+import { dirname as dirname17, isAbsolute as isAbsolute15, join as join10, relative as relative10, resolve as resolve36, sep as sep7 } from "node:path";
 var TSCONFIG_BASE = "tsconfig.base.json";
 var COMPONENT_PACKAGE_JSON = "package.json";
 var SRC_LIB_SUBPATH = "src/lib";
@@ -30160,7 +30312,7 @@ async function resolveApiSourceRoots(input) {
   return { roots, workspaceRoot };
 }
 async function findWorkspaceRoot(startAbs) {
-  let current = resolve35(startAbs);
+  let current = resolve36(startAbs);
   for (; ; ) {
     const candidate = join10(current, TSCONFIG_BASE);
     try {
@@ -30168,7 +30320,7 @@ async function findWorkspaceRoot(startAbs) {
       if (s.isFile()) return current;
     } catch {
     }
-    const parent = dirname16(current);
+    const parent = dirname17(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -30244,8 +30396,8 @@ async function readTsconfigPaths(workspaceRoot) {
 function resolvePackageRoot(input) {
   const target = input.paths.entries.get(input.packageName);
   if (!target) return void 0;
-  const targetAbs = isAbsolute15(target) ? target : resolve35(input.workspaceRoot, target);
-  return dirname16(dirname16(targetAbs));
+  const targetAbs = isAbsolute15(target) ? target : resolve36(input.workspaceRoot, target);
+  return dirname17(dirname17(targetAbs));
 }
 async function isDirectory2(path) {
   let result = false;
@@ -37427,7 +37579,7 @@ __export(server_actions_list_app_exports, {
 
 // packages/dbx-cli/validate/src/lib/server-actions-list-app/extract.ts
 import { readdir as readdir10, readFile as readFile21 } from "node:fs/promises";
-import { dirname as dirname17, join as join21, relative as relative18, sep as sep15 } from "node:path";
+import { dirname as dirname18, join as join21, relative as relative18, sep as sep15 } from "node:path";
 import { Node as Node34, Project as Project18 } from "ts-morph";
 var ACTION_SERVER_SUFFIX2 = ".action.server.ts";
 var COMMON_MODEL_SUBPATH2 = "src/app/common/model";
@@ -37502,7 +37654,7 @@ async function inspectSiblingModule(actionFilePath, className) {
   return { modulePath: moduleCandidates[0], providedByModule: false, exportedByModule: false };
 }
 async function findModuleCandidates(actionFilePath) {
-  const dir = dirname17(actionFilePath);
+  const dir = dirname18(actionFilePath);
   const out = [];
   try {
     const entries = await readdir10(dir, { withFileTypes: true });
@@ -40088,7 +40240,7 @@ var DBX_MODEL_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupModelArgsType = type50({
+var LookupModelArgsType = type51({
   topic: "string",
   "depth?": "'brief' | 'full'",
   "scope?": "'all' | 'upstream' | 'downstream'",
@@ -40115,7 +40267,7 @@ function normalizeFieldsFilter(raw) {
 }
 function parseLookupModelArgs(raw) {
   const parsed = LookupModelArgsType(raw);
-  if (parsed instanceof type50.errors) {
+  if (parsed instanceof type51.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -40247,10 +40399,10 @@ var LOOKUP_MODEL_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/search-model.tool.ts
-import { type as type51 } from "arktype";
+import { type as type52 } from "arktype";
 var DEFAULT_LIMIT3 = 10;
 var MAX_LIMIT3 = 25;
-var SearchArgsType = type51({
+var SearchArgsType = type52({
   query: "string",
   "limit?": "number",
   "scope?": "'all' | 'upstream' | 'downstream'",
@@ -40407,7 +40559,7 @@ function formatSourceLine(scope, upstreamCount, downstreamPackages) {
 }
 function parseArgs2(rawArgs) {
   const parsed = SearchArgsType(rawArgs);
-  if (parsed instanceof type51.errors) {
+  if (parsed instanceof type52.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -40481,7 +40633,7 @@ var SEARCH_MODEL_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/model-decode.tool.ts
-import { type as type52 } from "arktype";
+import { type as type53 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/decode.formatter.ts
 function formatDecode(context) {
@@ -40651,14 +40803,14 @@ var DBX_MODEL_DECODE_TOOL = {
     }
   }
 };
-var DecodeArgsType = type52({
+var DecodeArgsType = type53({
   "data?": "string | object",
   "key?": "string",
   "model?": "string"
 });
 function parseDecodeArgs(raw) {
   const parsed = DecodeArgsType(raw);
-  if (parsed instanceof type52.errors) {
+  if (parsed instanceof type53.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -40914,9 +41066,9 @@ var MODEL_DECODE_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/validate-tool.ts
-import { resolve as resolve36 } from "node:path";
-import { type as type53 } from "arktype";
-var FolderValidateArgsType = type53({
+import { resolve as resolve37 } from "node:path";
+import { type as type54 } from "arktype";
+var FolderValidateArgsType = type54({
   "paths?": "string[]",
   "glob?": "string"
 });
@@ -40925,7 +41077,7 @@ function createFolderValidateTool(config) {
   const { definition, inspectFolder: inspectFolder5, validate, format } = config;
   async function run24(rawArgs) {
     const parsed = FolderValidateArgsType(rawArgs);
-    if (parsed instanceof type53.errors) {
+    if (parsed instanceof type54.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const hasAny = parsed.paths && parsed.paths.length > 0 || parsed.glob;
@@ -40951,7 +41103,7 @@ function createFolderValidateTool(config) {
       let readError;
       try {
         for (const relative23 of paths) {
-          const absolute = resolve36(cwd, relative23);
+          const absolute = resolve37(cwd, relative23);
           const inspection = await inspectFolder5(absolute);
           const relativized = { ...inspection, path: relative23 };
           inspections.push(relativized);
@@ -40976,8 +41128,8 @@ function createFolderValidateTool(config) {
   const tool = { definition, run: run24 };
   return tool;
 }
-var SourceValidateArgsType = type53({
-  "sources?": type53({ name: "string", text: "string" }).array(),
+var SourceValidateArgsType = type54({
+  "sources?": type54({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string"
 });
@@ -40986,7 +41138,7 @@ function createSourceValidateTool(config) {
   const { definition, validate, format } = config;
   async function run24(rawArgs) {
     const parsed = SourceValidateArgsType(rawArgs);
-    if (parsed instanceof type53.errors) {
+    if (parsed instanceof type54.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const hasAny = parsed.sources && parsed.sources.length > 0 || parsed.paths && parsed.paths.length > 0 || parsed.glob;
@@ -41019,7 +41171,7 @@ function createSourceValidateTool(config) {
   const tool = { definition, run: run24 };
   return tool;
 }
-var TwoSideValidateArgsType = type53({
+var TwoSideValidateArgsType = type54({
   componentDir: "string",
   apiDir: "string"
 });
@@ -41037,9 +41189,9 @@ function resolveTwoSideInput(parsed) {
   }
   if (ensureError === void 0) {
     result = {
-      componentAbs: resolve36(cwd, componentRel),
+      componentAbs: resolve37(cwd, componentRel),
       componentRel,
-      apiAbs: resolve36(cwd, apiRel),
+      apiAbs: resolve37(cwd, apiRel),
       apiRel
     };
   } else {
@@ -41052,7 +41204,7 @@ function createTwoSideValidateTool(config) {
   const { definition, inspectAndValidate, format } = config;
   async function run24(rawArgs) {
     const parsed = TwoSideValidateArgsType(rawArgs);
-    if (parsed instanceof type53.errors) {
+    if (parsed instanceof type54.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const resolved = resolveTwoSideInput(parsed);
@@ -41070,7 +41222,7 @@ function createTwoSideValidateTool(config) {
   const tool = { definition, run: run24 };
   return tool;
 }
-var ListAppArgsType = type53({
+var ListAppArgsType = type54({
   componentDir: "string",
   apiDir: "string",
   "format?": "'markdown' | 'json'"
@@ -41080,7 +41232,7 @@ function createListAppTool(config) {
   const { definition, inspectAndList, formatMarkdown: formatMarkdown3, formatJson: formatJson3 } = config;
   async function run24(rawArgs) {
     const parsed = ListAppArgsType(rawArgs);
-    if (parsed instanceof type53.errors) {
+    if (parsed instanceof type54.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const resolved = resolveTwoSideInput(parsed);
@@ -41201,10 +41353,10 @@ var modelValidateApiTool = createSourceValidateTool({
 });
 
 // packages/dbx-components-mcp/src/tools/model-api-list-app.tool.ts
-import { resolve as resolve37 } from "node:path";
-import { type as type54 } from "arktype";
+import { resolve as resolve38 } from "node:path";
+import { type as type55 } from "arktype";
 var { formatReportAsJson: formatReportAsJson9, formatReportAsMarkdown: formatReportAsMarkdown9, listAppModelApi: listAppModelApi2 } = model_api_list_app_exports;
-var ListArgsType = type54({
+var ListArgsType = type55({
   componentDir: "string",
   "model?": "string",
   "identity?": "string",
@@ -41244,7 +41396,7 @@ var TOOL = {
 };
 async function run(rawArgs) {
   const parsed = ListArgsType(rawArgs);
-  if (parsed instanceof type54.errors) {
+  if (parsed instanceof type55.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -41256,7 +41408,7 @@ async function run(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const componentAbs = resolve37(cwd, parsed.componentDir);
+    const componentAbs = resolve38(cwd, parsed.componentDir);
     const modelFilter = parsed.model ?? (parsed.identity ? identityToModel(parsed.identity) : void 0);
     let report;
     let listError;
@@ -41284,10 +41436,10 @@ function identityToModel(identity) {
 var MODEL_API_LIST_APP_TOOL = { definition: TOOL, run };
 
 // packages/dbx-components-mcp/src/tools/model-api-lookup.tool.ts
-import { resolve as resolve38 } from "node:path";
-import { type as type55 } from "arktype";
+import { resolve as resolve39 } from "node:path";
+import { type as type56 } from "arktype";
 var { formatLookupAsJson: formatLookupAsJson3, formatLookupAsMarkdown: formatLookupAsMarkdown3, lookupModelApi: lookupModelApi2 } = model_api_lookup_exports;
-var LookupArgsType = type55({
+var LookupArgsType = type56({
   componentDir: "string",
   "apiDir?": "string",
   "model?": "string",
@@ -41326,7 +41478,7 @@ var TOOL2 = {
 };
 async function run2(rawArgs) {
   const parsed = LookupArgsType(rawArgs);
-  if (parsed instanceof type55.errors) {
+  if (parsed instanceof type56.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   if (!parsed.model && !parsed.identity) {
@@ -41344,8 +41496,8 @@ async function run2(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const componentAbs = resolve38(cwd, parsed.componentDir);
-    const apiAbs = parsed.apiDir ? resolve38(cwd, parsed.apiDir) : void 0;
+    const componentAbs = resolve39(cwd, parsed.componentDir);
+    const apiAbs = parsed.apiDir ? resolve39(cwd, parsed.apiDir) : void 0;
     const modelFilter = parsed.model ?? identityToModel2(parsed.identity);
     let report;
     let lookupError;
@@ -41383,10 +41535,10 @@ function identityToModel2(identity) {
 var MODEL_API_LOOKUP_TOOL = { definition: TOOL2, run: run2 };
 
 // packages/dbx-components-mcp/src/tools/model-api-validate-app.tool.ts
-import { resolve as resolve39 } from "node:path";
-import { type as type56 } from "arktype";
+import { resolve as resolve40 } from "node:path";
+import { type as type57 } from "arktype";
 var { formatValidationAsJson: formatValidationAsJson3, formatValidationAsMarkdown: formatValidationAsMarkdown3, validateAppModelApi: validateAppModelApi2 } = model_api_validate_app_exports;
-var ValidateArgsType = type56({
+var ValidateArgsType = type57({
   componentDir: "string",
   apiDir: "string",
   "model?": "string",
@@ -41428,7 +41580,7 @@ var TOOL3 = {
 };
 async function run3(rawArgs) {
   const parsed = ValidateArgsType(rawArgs);
-  if (parsed instanceof type56.errors) {
+  if (parsed instanceof type57.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -41441,8 +41593,8 @@ async function run3(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const componentAbs = resolve39(cwd, parsed.componentDir);
-    const apiAbs = resolve39(cwd, parsed.apiDir);
+    const componentAbs = resolve40(cwd, parsed.componentDir);
+    const apiAbs = resolve40(cwd, parsed.apiDir);
     const modelFilter = parsed.model ?? (parsed.identity ? identityToModel3(parsed.identity) : void 0);
     let report;
     let validateError;
@@ -41513,7 +41665,7 @@ function createModelValidateFolderTool(options = {}) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-store-scaffold.tool.ts
-import { type as type57 } from "arktype";
+import { type as type58 } 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 },
@@ -41609,7 +41761,7 @@ var DBX_MODEL_STORE_SCAFFOLD_TOOL = {
     required: ["model_name", "app_prefix", "firebase_package"]
   }
 };
-var ScaffoldArgsType2 = type57({
+var ScaffoldArgsType2 = type58({
   model_name: "string",
   app_prefix: "string",
   firebase_package: "string",
@@ -41629,7 +41781,7 @@ var ScaffoldArgsType2 = type57({
     name: "string",
     functions_path: "string"
   },
-  "crud_functions?": type57({
+  "crud_functions?": type58({
     name: "string",
     kind: "'create' | 'update' | 'crud'",
     functions_path: "string"
@@ -41649,7 +41801,7 @@ function requireString(value, label) {
 }
 function parseArgs3(raw) {
   const parsed = ScaffoldArgsType2(raw);
-  if (parsed instanceof type57.errors) {
+  if (parsed instanceof type58.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const modelName = requireString(parsed.model_name, "model_name");
@@ -42094,9 +42246,9 @@ var MODEL_STORE_SCAFFOLD_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-list-app.tool.ts
-import { resolve as resolve40 } from "node:path";
-import { type as type58 } from "arktype";
-var ListArgsType2 = type58({
+import { resolve as resolve41 } from "node:path";
+import { type as type59 } from "arktype";
+var ListArgsType2 = type59({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -42124,7 +42276,7 @@ var TOOL4 = {
 };
 async function run4(rawArgs) {
   const parsed = ListArgsType2(rawArgs);
-  if (parsed instanceof type58.errors) {
+  if (parsed instanceof type59.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -42136,7 +42288,7 @@ async function run4(rawArgs) {
   }
   let result;
   if (ensureError === void 0) {
-    const apiAbs = resolve40(cwd, parsed.apiDir);
+    const apiAbs = resolve41(cwd, parsed.apiDir);
     let extraction;
     let inspectError;
     try {
@@ -42158,9 +42310,9 @@ async function run4(rawArgs) {
 var MODEL_FIXTURE_LIST_APP_TOOL = { definition: TOOL4, run: run4 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-lookup.tool.ts
-import { resolve as resolve41 } from "node:path";
-import { type as type59 } from "arktype";
-var LookupArgsType2 = type59({
+import { resolve as resolve42 } from "node:path";
+import { type as type60 } from "arktype";
+var LookupArgsType2 = type60({
   apiDir: "string",
   "model?": "string",
   "identity?": "string",
@@ -42192,7 +42344,7 @@ var TOOL5 = {
 };
 async function run5(rawArgs) {
   const parsed = LookupArgsType2(rawArgs);
-  if (parsed instanceof type59.errors) {
+  if (parsed instanceof type60.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   if (!parsed.model && !parsed.identity) {
@@ -42202,7 +42354,7 @@ async function run5(rawArgs) {
   const ensureError = runEnsurePathInsideCwd(parsed.apiDir, cwd);
   let result;
   if (ensureError === void 0) {
-    const apiAbs = resolve41(cwd, parsed.apiDir);
+    const apiAbs = resolve42(cwd, parsed.apiDir);
     const inspection = await inspectFixturesSafe(apiAbs, parsed.apiDir);
     if (inspection.kind === "error") {
       result = toolError(inspection.message);
@@ -42261,10 +42413,10 @@ function identityToModel4(identity) {
 var MODEL_FIXTURE_LOOKUP_TOOL = { definition: TOOL5, run: run5 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-validate-app.tool.ts
-import { resolve as resolve42 } from "node:path";
-import { type as type60 } from "arktype";
+import { resolve as resolve43 } from "node:path";
+import { type as type61 } from "arktype";
 var { formatValidationAsJson: formatValidationAsJson4, formatValidationAsMarkdown: formatValidationAsMarkdown4, validateAppFixtures: validateAppFixtures2 } = model_fixture_shared_exports;
-var ValidateArgsType2 = type60({
+var ValidateArgsType2 = type61({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -42298,7 +42450,7 @@ var TOOL6 = {
 function createModelFixtureValidateAppTool(config = {}) {
   async function run24(rawArgs) {
     const parsed = ValidateArgsType2(rawArgs);
-    if (parsed instanceof type60.errors) {
+    if (parsed instanceof type61.errors) {
       return toolError(`Invalid arguments: ${parsed.summary}`);
     }
     const cwd = process.cwd();
@@ -42310,7 +42462,7 @@ function createModelFixtureValidateAppTool(config = {}) {
       ensureError = err instanceof Error ? err.message : String(err);
     }
     if (ensureError === void 0) {
-      const apiAbs = resolve42(cwd, parsed.apiDir);
+      const apiAbs = resolve43(cwd, parsed.apiDir);
       let extraction;
       let inspectError;
       try {
@@ -42339,16 +42491,16 @@ function createModelFixtureValidateAppTool(config = {}) {
 
 // packages/dbx-components-mcp/src/tools/model-fixture-scaffold.tool.ts
 import { readFile as readFile23, writeFile } from "node:fs/promises";
-import { join as join23, resolve as resolve43 } from "node:path";
-import { type as type61 } from "arktype";
-var ScaffoldArgsType3 = type61({
+import { join as join23, resolve as resolve44 } from "node:path";
+import { type as type62 } from "arktype";
+var ScaffoldArgsType3 = type62({
   apiDir: "string",
   model: "string",
   archetype: "'top-level-simple' | 'top-level-with-deps' | 'sub-collection' | 'sub-collection-traversal'",
   "prefix?": "string",
   "parentFixture?": "string",
   "parentFixtureField?": "string",
-  "paramsDependsOn?": type61({
+  "paramsDependsOn?": type62({
     field: "string",
     fixtureModel: "string",
     "optional?": "boolean",
@@ -42409,7 +42561,7 @@ var TOOL7 = {
 };
 async function run6(rawArgs) {
   const parsed = ScaffoldArgsType3(rawArgs);
-  if (parsed instanceof type61.errors) {
+  if (parsed instanceof type62.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -42425,7 +42577,7 @@ async function run6(rawArgs) {
   return runScaffold(parsed, cwd);
 }
 async function runScaffold(parsed, cwd) {
-  const apiAbs = resolve43(cwd, parsed.apiDir);
+  const apiAbs = resolve44(cwd, parsed.apiDir);
   let extraction;
   let extractionError;
   try {
@@ -42535,10 +42687,10 @@ function collectConflicts(extraction, rendered) {
 var MODEL_FIXTURE_SCAFFOLD_TOOL = { definition: TOOL7, run: run6 };
 
 // packages/dbx-components-mcp/src/tools/model-fixture-forward.tool.ts
-import { join as join24, resolve as resolve44 } from "node:path";
-import { type as type62 } from "arktype";
+import { join as join24, resolve as resolve45 } from "node:path";
+import { type as type63 } from "arktype";
 import { Project as Project21 } from "ts-morph";
-var ForwardArgsType = type62({
+var ForwardArgsType = type63({
   apiDir: "string",
   model: "string",
   "methods?": "string[]"
@@ -42572,7 +42724,7 @@ var TOOL8 = {
 };
 async function run7(rawArgs) {
   const parsed = ForwardArgsType(rawArgs);
-  if (parsed instanceof type62.errors) {
+  if (parsed instanceof type63.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -42584,7 +42736,7 @@ async function run7(rawArgs) {
     ensureError = toErrorMessage(err);
   }
   if (ensureError === void 0) {
-    const apiAbs = resolve44(cwd, parsed.apiDir);
+    const apiAbs = resolve45(cwd, parsed.apiDir);
     let extraction;
     let inspectError;
     try {
@@ -42674,9 +42826,9 @@ function appendListSection(lines, heading, names) {
 var MODEL_FIXTURE_FORWARD_TOOL = { definition: TOOL8, run: run7 };
 
 // packages/dbx-components-mcp/src/tools/model-test-list-app.tool.ts
-import { resolve as resolve45 } from "node:path";
-import { type as type63 } from "arktype";
-var ListAppArgsType2 = type63({
+import { resolve as resolve46 } from "node:path";
+import { type as type64 } from "arktype";
+var ListAppArgsType2 = type64({
   apiDir: "string",
   "group?": "string",
   "format?": "'markdown' | 'json'"
@@ -42716,7 +42868,7 @@ var TOOL9 = {
 };
 async function run8(rawArgs) {
   const parsed = ListAppArgsType2(rawArgs);
-  if (parsed instanceof type63.errors) {
+  if (parsed instanceof type64.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -42728,7 +42880,7 @@ async function run8(rawArgs) {
   }
   let result;
   if (ensureError === void 0) {
-    const apiAbs = resolve45(cwd, parsed.apiDir);
+    const apiAbs = resolve46(cwd, parsed.apiDir);
     let catalog;
     let discoveryError;
     try {
@@ -42763,9 +42915,9 @@ function filterCatalogByGroup(catalog, group) {
 var MODEL_TEST_LIST_APP_TOOL = { definition: TOOL9, run: run8 };
 
 // packages/dbx-components-mcp/src/tools/model-test-tree.tool.ts
-import { resolve as resolve46 } from "node:path";
-import { type as type64 } from "arktype";
-var TreeArgsType = type64({
+import { resolve as resolve47 } from "node:path";
+import { type as type65 } from "arktype";
+var TreeArgsType = type65({
   specFile: "string",
   "apiDir?": "string",
   "view?": "'all' | 'describes' | 'fixtures' | 'its' | 'helpers'",
@@ -42805,7 +42957,7 @@ var TOOL10 = {
 };
 async function run9(rawArgs) {
   const parsed = TreeArgsType(rawArgs);
-  if (parsed instanceof type64.errors) {
+  if (parsed instanceof type65.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -42818,8 +42970,8 @@ async function run9(rawArgs) {
   }
   let result;
   if (ensureError === void 0) {
-    const specAbs = resolve46(cwd, parsed.specFile);
-    const apiAbs = parsed.apiDir === void 0 ? void 0 : resolve46(cwd, parsed.apiDir);
+    const specAbs = resolve47(cwd, parsed.specFile);
+    const apiAbs = parsed.apiDir === void 0 ? void 0 : resolve47(cwd, parsed.apiDir);
     let tree;
     let inspectError;
     try {
@@ -42843,9 +42995,9 @@ async function run9(rawArgs) {
 var MODEL_TEST_TREE_TOOL = { definition: TOOL10, run: run9 };
 
 // packages/dbx-components-mcp/src/tools/model-test-search.tool.ts
-import { resolve as resolve47 } from "node:path";
-import { type as type65 } from "arktype";
-var SearchArgsType2 = type65({
+import { resolve as resolve48 } from "node:path";
+import { type as type66 } from "arktype";
+var SearchArgsType2 = type66({
   specFile: "string",
   "apiDir?": "string",
   "model?": "string",
@@ -42888,7 +43040,7 @@ var TOOL11 = {
 };
 async function run10(rawArgs) {
   const parsed = SearchArgsType2(rawArgs);
-  if (parsed instanceof type65.errors) {
+  if (parsed instanceof type66.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const queryFields = [
@@ -42914,8 +43066,8 @@ async function run10(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const specAbs = resolve47(cwd, parsed.specFile);
-    const apiAbs = parsed.apiDir === void 0 ? void 0 : resolve47(cwd, parsed.apiDir);
+    const specAbs = resolve48(cwd, parsed.specFile);
+    const apiAbs = parsed.apiDir === void 0 ? void 0 : resolve48(cwd, parsed.apiDir);
     let tree;
     let inspectError;
     try {
@@ -42938,9 +43090,9 @@ async function run10(rawArgs) {
 var MODEL_TEST_SEARCH_TOOL = { definition: TOOL11, run: run10 };
 
 // packages/dbx-components-mcp/src/tools/model-test-convention.tool.ts
-import { type as type66 } from "arktype";
+import { type as type67 } from "arktype";
 var API_DIR_PLACEHOLDER = "<apiDir>";
-var ConventionArgsType = type66({
+var ConventionArgsType = type67({
   group: "string",
   "apiDir?": "string",
   "bucket?": "'crud' | 'scenario'",
@@ -42979,7 +43131,7 @@ var TOOL12 = {
 };
 function parseArgs4(rawArgs) {
   const parsed = ConventionArgsType(rawArgs);
-  if (parsed instanceof type66.errors) {
+  if (parsed instanceof type67.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   if (parsed.subgroups !== void 0 && parsed.bucket === void 0) {
@@ -43067,9 +43219,9 @@ async function run11(rawArgs) {
 var MODEL_TEST_CONVENTION_TOOL = { definition: TOOL12, run: run11 };
 
 // packages/dbx-components-mcp/src/tools/model-test-hotspots.tool.ts
-import { resolve as resolve48 } from "node:path";
-import { type as type67 } from "arktype";
-var HotspotsArgsType = type67({
+import { resolve as resolve49 } from "node:path";
+import { type as type68 } from "arktype";
+var HotspotsArgsType = type68({
   apiDir: "string",
   model: "string",
   "format?": "'markdown' | 'json'"
@@ -43102,7 +43254,7 @@ var TOOL13 = {
 };
 async function run12(rawArgs) {
   const parsed = HotspotsArgsType(rawArgs);
-  if (parsed instanceof type67.errors) {
+  if (parsed instanceof type68.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -43114,7 +43266,7 @@ async function run12(rawArgs) {
   }
   let result;
   if (ensureError === void 0) {
-    const apiAbs = resolve48(cwd, parsed.apiDir);
+    const apiAbs = resolve49(cwd, parsed.apiDir);
     let hotspots;
     let lookupError;
     try {
@@ -43136,11 +43288,11 @@ async function run12(rawArgs) {
 var MODEL_TEST_HOTSPOTS_TOOL = { definition: TOOL13, run: run12 };
 
 // packages/dbx-components-mcp/src/tools/model-test-validate-app.tool.ts
-import { resolve as resolve49 } from "node:path";
-import { type as type68 } from "arktype";
+import { resolve as resolve50 } from "node:path";
+import { type as type69 } from "arktype";
 var { extractComponentModels: extractComponentModels2 } = model_list_component_exports;
 var { formatModelTestValidateAppJson: formatModelTestValidateAppJson2, formatModelTestValidateAppMarkdown: formatModelTestValidateAppMarkdown2, validateModelTestApp: validateModelTestApp2 } = model_test_validate_app_exports;
-var ValidateAppArgsType = type68({
+var ValidateAppArgsType = type69({
   componentDir: "string",
   apiDir: "string",
   "strict?": "boolean",
@@ -43178,7 +43330,7 @@ var TOOL14 = {
 };
 async function run13(rawArgs) {
   const parsed = ValidateAppArgsType(rawArgs);
-  if (parsed instanceof type68.errors) {
+  if (parsed instanceof type69.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -43192,8 +43344,8 @@ async function run13(rawArgs) {
   if (ensureError !== void 0) {
     return toolError(ensureError);
   }
-  const componentAbs = resolve49(cwd, parsed.componentDir);
-  const apiAbs = resolve49(cwd, parsed.apiDir);
+  const componentAbs = resolve50(cwd, parsed.componentDir);
+  const apiAbs = resolve50(cwd, parsed.apiDir);
   let catalog;
   let extraction;
   let inspectionError;
@@ -43221,7 +43373,7 @@ async function run13(rawArgs) {
 var MODEL_TEST_VALIDATE_APP_TOOL = { definition: TOOL14, run: run13 };
 
 // packages/dbx-components-mcp/src/tools/archetype-recommend.tool.ts
-import { type as type69 } from "arktype";
+import { type as type70 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/archetype/score.ts
 var FRAMEWORK_SHORT_CIRCUITS = [
@@ -43613,7 +43765,7 @@ function formatArchetypeCatalog(archetypes) {
 // packages/dbx-components-mcp/src/tools/archetype-recommend.tool.ts
 var DEFAULT_PEER_COUNT = 5;
 var DEFAULT_MAX_RESULTS = 3;
-var QuestionnaireType = type69({
+var QuestionnaireType = type70({
   "candidateName?": "string",
   "candidateGroup?": "string",
   "domainDescription?": "string",
@@ -43651,7 +43803,7 @@ var QuestionnaireType = type69({
   "estimatedItemsPerParent?": "'0-50' | '50-500' | '500+' | 'unknown'",
   "alwaysReadWithParent?": "boolean"
 });
-var RecommendArgsType = type69({
+var RecommendArgsType = type70({
   questionnaire: QuestionnaireType,
   "archetypeHint?": "string",
   "scope?": "'all' | 'upstream' | 'downstream'",
@@ -43705,7 +43857,7 @@ var DBX_MODEL_ARCHETYPE_RECOMMEND_TOOL = {
 };
 function parseArgs5(raw) {
   const parsed = RecommendArgsType(raw);
-  if (parsed instanceof type69.errors) {
+  if (parsed instanceof type70.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -43815,7 +43967,7 @@ var ARCHETYPE_RECOMMEND_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/archetype-lookup.tool.ts
-import { type as type70 } from "arktype";
+import { type as type71 } from "arktype";
 var DBX_MODEL_ARCHETYPE_LOOKUP_TOOL = {
   name: "dbx_model_archetype_lookup",
   description: [
@@ -43839,14 +43991,14 @@ var DBX_MODEL_ARCHETYPE_LOOKUP_TOOL = {
     required: ["slug"]
   }
 };
-var LookupArgsType3 = type70({
+var LookupArgsType3 = type71({
   slug: "string",
   "axes?": { "[string]": "string" }
 });
 var CATALOG_KEYWORDS = /* @__PURE__ */ new Set(["list", "catalog", "all"]);
 function parseArgs6(raw) {
   const parsed = LookupArgsType3(raw);
-  if (parsed instanceof type70.errors) {
+  if (parsed instanceof type71.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return { slug: parsed.slug, axes: parsed.axes };
@@ -43894,9 +44046,9 @@ var ARCHETYPE_LOOKUP_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/archetype-search.tool.ts
-import { type as type71 } from "arktype";
+import { type as type72 } from "arktype";
 var DEFAULT_LIMIT4 = 25;
-var SearchArgsType3 = type71({
+var SearchArgsType3 = type72({
   archetype: "string",
   "axes?": { "[string]": "string" },
   "scope?": "'all' | 'upstream' | 'downstream'",
@@ -43932,7 +44084,7 @@ var DBX_MODEL_ARCHETYPE_SEARCH_TOOL = {
 };
 function parseArgs7(raw) {
   const parsed = SearchArgsType3(raw);
-  if (parsed instanceof type71.errors) {
+  if (parsed instanceof type72.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -44042,7 +44194,7 @@ var ARCHETYPE_SEARCH_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/model-hierarchy.tool.ts
-import { type as type72 } from "arktype";
+import { type as type73 } from "arktype";
 var DBX_MODEL_HIERARCHY_TOOL = {
   name: "dbx_model_hierarchy",
   description: [
@@ -44100,7 +44252,7 @@ var DBX_MODEL_HIERARCHY_TOOL = {
     }
   }
 };
-var HierarchyArgsType = type72({
+var HierarchyArgsType = type73({
   "rootModel?": "string",
   "maxDepth?": "number.integer >= 0",
   "format?": "'tree' | 'flat' | 'both'",
@@ -44110,7 +44262,7 @@ var HierarchyArgsType = type72({
 });
 function parseHierarchyArgs(raw) {
   const parsed = HierarchyArgsType(raw ?? {});
-  if (parsed instanceof type72.errors) {
+  if (parsed instanceof type73.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -44531,10 +44683,10 @@ var systemMValidateFolderTool = createFolderValidateTool({
 });
 
 // packages/dbx-components-mcp/src/tools/system-m-list-app.tool.ts
-import { resolve as resolve50 } from "node:path";
-import { type as type73 } from "arktype";
+import { resolve as resolve51 } from "node:path";
+import { type as type74 } from "arktype";
 var { formatReportAsJson: formatReportAsJson12, formatReportAsMarkdown: formatReportAsMarkdown12, listAppSystem: listAppSystem2 } = system_m_list_app_exports;
-var ListAppArgsType3 = type73({
+var ListAppArgsType3 = type74({
   componentDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -44562,7 +44714,7 @@ var TOOL15 = {
 };
 async function run14(rawArgs) {
   const parsed = ListAppArgsType3(rawArgs);
-  if (parsed instanceof type73.errors) {
+  if (parsed instanceof type74.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -44574,7 +44726,7 @@ async function run14(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const componentAbs = resolve50(cwd, parsed.componentDir);
+    const componentAbs = resolve51(cwd, parsed.componentDir);
     let report;
     let listError;
     try {
@@ -44711,7 +44863,7 @@ var dbxAssetValidateFolderTool = createTwoSideValidateTool({
 });
 
 // packages/dbx-components-mcp/src/tools/dbx-asset-scaffold.tool.ts
-import { type as type74 } from "arktype";
+import { type as type75 } from "arktype";
 var ASSET_BUILDERS = [
   { kind: "local", helper: "localAsset", signature: "(path: SlashPath)" },
   { kind: "remote", helper: "remoteAsset", signature: "(url: WebsiteUrlWithPrefix)" },
@@ -44747,7 +44899,7 @@ var DBX_ASSET_SCAFFOLD_TOOL_DEFINITION = {
     required: ["name", "kind"]
   }
 };
-var ScaffoldArgsType4 = type74({
+var ScaffoldArgsType4 = type75({
   name: "string",
   kind: "'local' | 'remote' | 'folder' | 'remote-base'",
   "path?": "string",
@@ -44757,7 +44909,7 @@ var ScaffoldArgsType4 = type74({
 });
 function parseScaffoldArgs2(raw) {
   const parsed = ScaffoldArgsType4(raw);
-  if (parsed instanceof type74.errors) {
+  if (parsed instanceof type75.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const name = parsed.name.trim();
@@ -44901,8 +45053,8 @@ var DBX_ASSET_SCAFFOLD_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/dbx-color-template-list-app.tool.ts
-import { resolve as resolve51 } from "node:path";
-import { type as type75 } from "arktype";
+import { resolve as resolve52 } from "node:path";
+import { type as type76 } from "arktype";
 var { formatReportAsJson: formatReportAsJson14, formatReportAsMarkdown: formatReportAsMarkdown14, inspectColorTemplates: inspectColorTemplates2, listAppColorTemplates: listAppColorTemplates2 } = dbx_color_template_list_app_exports;
 var DBX_COLOR_TEMPLATE_LIST_APP_TOOL_DEFINITION = {
   name: "dbx_color_template_list_app",
@@ -44928,14 +45080,14 @@ var DBX_COLOR_TEMPLATE_LIST_APP_TOOL_DEFINITION = {
     required: ["apiDir"]
   }
 };
-var ColorTemplateListAppArgs = type75({
+var ColorTemplateListAppArgs = type76({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
 async function run15(rawArgs) {
   const parsed = ColorTemplateListAppArgs(rawArgs);
   let result;
-  if (parsed instanceof type75.errors) {
+  if (parsed instanceof type76.errors) {
     result = toolError(`Invalid arguments: ${parsed.summary}`);
   } else {
     const cwd = process.cwd();
@@ -44947,7 +45099,7 @@ async function run15(rawArgs) {
       pathError = err instanceof Error ? err.message : String(err);
     }
     if (pathError === void 0) {
-      const apiAbs = resolve51(cwd, apiRel);
+      const apiAbs = resolve52(cwd, apiRel);
       const inspection = await inspectColorTemplates2(apiAbs, apiRel);
       if (inspection.appExists) {
         const report = listAppColorTemplates2(inspection);
@@ -44968,8 +45120,8 @@ var DBX_COLOR_TEMPLATE_LIST_APP_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/dbx-color-smell-check.tool.ts
-import { resolve as resolve52 } from "node:path";
-import { type as type76 } from "arktype";
+import { resolve as resolve53 } from "node:path";
+import { type as type77 } from "arktype";
 var { extractHtmlLiterals: extractHtmlLiterals2, extractTsLiterals: extractTsLiterals2, formatResultAsJson: formatResultAsJson2, formatResultAsMarkdown: formatResultAsMarkdown2, groupColorSmells: groupColorSmells2 } = dbx_color_smell_check_exports;
 var { extractColorTemplates: extractColorTemplates2, inspectColorTemplates: inspectColorTemplates3 } = dbx_color_template_list_app_exports;
 var DBX_COLOR_SMELL_CHECK_TOOL_DEFINITION = {
@@ -45002,7 +45154,7 @@ var DBX_COLOR_SMELL_CHECK_TOOL_DEFINITION = {
     }
   }
 };
-var ColorSmellCheckArgs = type76({
+var ColorSmellCheckArgs = type77({
   "paths?": "string[]",
   "glob?": "string",
   "equivalenceMode?": "'exact' | 'normalized'",
@@ -45012,7 +45164,7 @@ var ColorSmellCheckArgs = type76({
 });
 async function run16(rawArgs) {
   const parsed = ColorSmellCheckArgs(rawArgs);
-  if (parsed instanceof type76.errors) {
+  if (parsed instanceof type77.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const hasAny = parsed.paths && parsed.paths.length > 0 || parsed.glob;
@@ -45062,7 +45214,7 @@ async function resolveCrossReferenceTemplates(input) {
   let result;
   if (pathError === void 0) {
     try {
-      const inspection = await inspectColorTemplates3(resolve52(input.cwd, input.apiDir), input.apiDir);
+      const inspection = await inspectColorTemplates3(resolve53(input.cwd, input.apiDir), input.apiDir);
       if (inspection.appExists) {
         const extracted = extractColorTemplates2(inspection);
         result = { kind: "value", value: extracted.templates };
@@ -45084,7 +45236,7 @@ var DBX_COLOR_SMELL_CHECK_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/lookup-action.tool.ts
-import { type as type77 } from "arktype";
+import { type as type78 } from "arktype";
 var DBX_ACTION_LOOKUP_TOOL = {
   name: "dbx_action_lookup",
   description: [
@@ -45117,13 +45269,13 @@ var DBX_ACTION_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupActionArgsType = type77({
+var LookupActionArgsType = type78({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupActionArgs(raw) {
   const parsed = LookupActionArgsType(raw);
-  if (parsed instanceof type77.errors) {
+  if (parsed instanceof type78.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -45597,7 +45749,7 @@ function createSearchActionTool(config) {
 }
 
 // packages/dbx-components-mcp/src/tools/action-examples.tool.ts
-import { type as type78 } from "arktype";
+import { type as type79 } 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 = {
@@ -46034,13 +46186,13 @@ var DBX_ACTION_EXAMPLES_TOOL = {
     required: ["pattern"]
   }
 };
-var ActionExamplesArgsType = type78({
+var ActionExamplesArgsType = type79({
   pattern: "string",
   "depth?": "'minimal' | 'brief' | 'full'"
 });
 function parseActionExamplesArgs(raw) {
   const parsed = ActionExamplesArgsType(raw);
-  if (parsed instanceof type78.errors) {
+  if (parsed instanceof type79.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -46102,7 +46254,7 @@ var ACTION_EXAMPLES_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/action-scaffold.tool.ts
-import { type as type79 } from "arktype";
+import { type as type80 } from "arktype";
 var TRIGGER_VALUES = ["button", "form", "auto-modify"];
 var SUCCESS_FEEDBACK_VALUES = ["snackbar", "redirect", "none"];
 var CONTEXT_PROVIDER_VALUES = ["inline", "parent", "host-component"];
@@ -46136,7 +46288,7 @@ var DBX_ACTION_SCAFFOLD_TOOL = {
     required: ["use_case", "trigger", "value_type"]
   }
 };
-var ScaffoldArgsType5 = type79({
+var ScaffoldArgsType5 = type80({
   use_case: "string",
   trigger: "'button' | 'form' | 'auto-modify'",
   "confirm?": "boolean",
@@ -46147,7 +46299,7 @@ var ScaffoldArgsType5 = type79({
 });
 function parseScaffoldArgs3(raw) {
   const parsed = ScaffoldArgsType5(raw);
-  if (parsed instanceof type79.errors) {
+  if (parsed instanceof type80.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const useCase = parsed.use_case.trim();
@@ -46373,14 +46525,14 @@ var ACTION_SCAFFOLD_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-tree.tool.ts
-import { type as type80 } from "arktype";
+import { type as type81 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/route/load-sources.ts
 import { glob as fsGlob6, readFile as readFile24, stat as stat14 } from "node:fs/promises";
-import { dirname as dirname18, isAbsolute as isAbsolute16, resolve as resolve53, sep as sep17 } from "node:path";
+import { dirname as dirname19, isAbsolute as isAbsolute16, resolve as resolve54, sep as sep17 } from "node:path";
 var TRY_EXTENSIONS2 = [".ts", ".tsx", "/index.ts", "/index.tsx"];
 async function loadRouteSources(args) {
-  const cwdResolved = args.cwd ? resolve53(process.cwd(), args.cwd) : process.cwd();
+  const cwdResolved = args.cwd ? resolve54(process.cwd(), args.cwd) : process.cwd();
   guardCwdInsideServer(args.cwd, cwdResolved);
   const collected = /* @__PURE__ */ new Map();
   if (args.sources) {
@@ -46452,7 +46604,7 @@ async function loadOne(relative23, cwd, into) {
   if (into.has(relative23)) {
     return;
   }
-  const absolute = resolve53(cwd, relative23);
+  const absolute = resolve54(cwd, relative23);
   const cwdPrefix = cwd.endsWith(sep17) ? cwd : cwd + sep17;
   if (!absolute.startsWith(cwdPrefix) && absolute !== cwd) {
     throw new Error(`Path \`${relative23}\` resolves outside the server cwd and is not allowed.`);
@@ -46463,9 +46615,9 @@ async function loadOne(relative23, cwd, into) {
 async function resolveRelativeImport(fromFile, specifier, cwd) {
   let result;
   if (specifier.startsWith(".")) {
-    const fromAbsolute = isAbsolute16(fromFile) ? fromFile : resolve53(cwd, fromFile);
-    const fromDir = dirname18(fromAbsolute);
-    const baseAbsolute = resolve53(fromDir, specifier);
+    const fromAbsolute = isAbsolute16(fromFile) ? fromFile : resolve54(cwd, fromFile);
+    const fromDir = dirname19(fromAbsolute);
+    const baseAbsolute = resolve54(fromDir, specifier);
     const cwdPrefix = cwd.endsWith(sep17) ? cwd : cwd + sep17;
     for (const ext of TRY_EXTENSIONS2) {
       const candidateAbsolute = baseAbsolute + ext;
@@ -46690,8 +46842,8 @@ var DBX_ROUTE_TREE_TOOL = {
     }
   }
 };
-var TreeArgsType2 = type80({
-  "sources?": type80({ name: "string", text: "string" }).array(),
+var TreeArgsType2 = type81({
+  "sources?": type81({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string",
   "format?": "'markdown' | 'json' | 'flat'",
@@ -46700,7 +46852,7 @@ var TreeArgsType2 = type80({
 });
 function parseArgs8(raw) {
   const parsed = TreeArgsType2(raw);
-  if (parsed instanceof type80.errors) {
+  if (parsed instanceof type81.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -46756,7 +46908,7 @@ var ROUTE_TREE_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-lookup.tool.ts
-import { type as type81 } from "arktype";
+import { type as type82 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/route/page-models.ts
 function buildPageModelsIndex(sources) {
@@ -46816,9 +46968,9 @@ var DBX_ROUTE_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var LookupArgsType4 = type81({
+var LookupArgsType4 = type82({
   topic: "string",
-  "sources?": type81({ name: "string", text: "string" }).array(),
+  "sources?": type82({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string",
   "depth?": "'brief' | 'full'",
@@ -46826,7 +46978,7 @@ var LookupArgsType4 = type81({
 });
 function parseArgs9(raw) {
   const parsed = LookupArgsType4(raw);
-  if (parsed instanceof type81.errors) {
+  if (parsed instanceof type82.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -47051,7 +47203,7 @@ var ROUTE_LOOKUP_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-search.tool.ts
-import { type as type82 } from "arktype";
+import { type as type83 } from "arktype";
 var DBX_ROUTE_SEARCH_TOOL = {
   name: "dbx_route_search",
   description: [
@@ -47079,9 +47231,9 @@ var DBX_ROUTE_SEARCH_TOOL = {
     required: ["query"]
   }
 };
-var SearchArgsType4 = type82({
+var SearchArgsType4 = type83({
   query: "string",
-  "sources?": type82({ name: "string", text: "string" }).array(),
+  "sources?": type83({ name: "string", text: "string" }).array(),
   "paths?": "string[]",
   "glob?": "string",
   "scope?": "'name' | 'url' | 'component' | 'resolve' | 'all'",
@@ -47089,7 +47241,7 @@ var SearchArgsType4 = type82({
 });
 function parseArgs10(raw) {
   const parsed = SearchArgsType4(raw);
-  if (parsed instanceof type82.errors) {
+  if (parsed instanceof type83.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -47188,18 +47340,18 @@ var ROUTE_SEARCH_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/route-resolve-url.tool.ts
-import { type as type83 } from "arktype";
+import { type as type84 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/route/resolve-url.ts
 import { readFile as readFile26, stat as stat15 } from "node:fs/promises";
-import { dirname as dirname20, isAbsolute as isAbsolute17, resolve as resolve55, sep as sep19 } from "node:path";
+import { dirname as dirname21, isAbsolute as isAbsolute17, resolve as resolve56, sep as sep19 } from "node:path";
 
 // packages/dbx-components-mcp/src/tools/route/app-port-map.ts
 import { glob as fsGlob7, readFile as readFile25 } from "node:fs/promises";
-import { dirname as dirname19, resolve as resolve54, sep as sep18 } from "node:path";
+import { dirname as dirname20, resolve as resolve55, sep as sep18 } from "node:path";
 var CACHE = /* @__PURE__ */ new Map();
 async function loadAppPortMap(cwd) {
-  const resolved = cwd ? resolve54(process.cwd(), cwd) : process.cwd();
+  const resolved = cwd ? resolve55(process.cwd(), cwd) : process.cwd();
   let pending = CACHE.get(resolved);
   if (!pending) {
     pending = scanAppPortMap(resolved);
@@ -47210,8 +47362,8 @@ async function loadAppPortMap(cwd) {
 async function scanAppPortMap(cwdResolved) {
   const entries = [];
   for await (const match of fsGlob7("apps/*/project.json", { cwd: cwdResolved })) {
-    const projectRoot = dirname19(match);
-    const absolute = resolve54(cwdResolved, match);
+    const projectRoot = dirname20(match);
+    const absolute = resolve55(cwdResolved, match);
     const entry = await readEntry({ projectJsonAbsolute: absolute, projectRoot });
     if (entry) {
       entries.push(entry);
@@ -47439,8 +47591,8 @@ function collectSiblings(node) {
 }
 var TRY_EXTENSIONS3 = [".ts", ".tsx", "/index.ts", "/index.tsx"];
 async function resolveComponentFile(input) {
-  const cwdResolved = input.cwd ? resolve55(process.cwd(), input.cwd) : process.cwd();
-  const routerAbsolute = isAbsolute17(input.routerFile) ? input.routerFile : resolve55(cwdResolved, input.routerFile);
+  const cwdResolved = input.cwd ? resolve56(process.cwd(), input.cwd) : process.cwd();
+  const routerAbsolute = isAbsolute17(input.routerFile) ? input.routerFile : resolve56(cwdResolved, input.routerFile);
   let text;
   try {
     text = await readFile26(routerAbsolute, "utf8");
@@ -47461,8 +47613,8 @@ async function resolveSpecifierToFile(input) {
   if (!specifier.startsWith(".")) {
     return { path: specifier, moduleSpecifier: specifier };
   }
-  const fromDir = dirname20(routerAbsolute);
-  const baseAbsolute = resolve55(fromDir, specifier);
+  const fromDir = dirname21(routerAbsolute);
+  const baseAbsolute = resolve56(fromDir, specifier);
   const cwdPrefix = cwdResolved.endsWith(sep19) ? cwdResolved : cwdResolved + sep19;
   let resolved;
   for (const ext of TRY_EXTENSIONS3) {
@@ -47548,7 +47700,7 @@ var DBX_ROUTE_RESOLVE_URL_TOOL = {
     required: ["url"]
   }
 };
-var ResolveUrlArgsType = type83({
+var ResolveUrlArgsType = type84({
   url: "string",
   "app?": "string",
   "cwd?": "string",
@@ -47557,7 +47709,7 @@ var ResolveUrlArgsType = type83({
 });
 function parseArgs11(raw) {
   const parsed = ResolveUrlArgsType(raw);
-  if (parsed instanceof type83.errors) {
+  if (parsed instanceof type84.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -47797,14 +47949,14 @@ var ROUTE_RESOLVE_URL_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/_lookup.factory.ts
-import { type as type84 } from "arktype";
-var LOOKUP_ARGS_TYPE = type84({
+import { type as type85 } from "arktype";
+var LOOKUP_ARGS_TYPE = type85({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupArgs(raw) {
   const parsed = LOOKUP_ARGS_TYPE(raw);
-  if (parsed instanceof type84.errors) {
+  if (parsed instanceof type85.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -48008,7 +48160,7 @@ function createLookupFilterTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/filter-scaffold.tool.ts
-import { type as type85 } from "arktype";
+import { type as type86 } from "arktype";
 var DBX_FILTER_SCAFFOLD_TOOL = {
   name: "dbx_filter_scaffold",
   description: [
@@ -48033,7 +48185,7 @@ var DBX_FILTER_SCAFFOLD_TOOL = {
     required: ["model_name", "filter_type"]
   }
 };
-var ScaffoldArgsType6 = type85({
+var ScaffoldArgsType6 = type86({
   model_name: "string",
   filter_type: "string",
   "preset_keys?": "string[]",
@@ -48041,7 +48193,7 @@ var ScaffoldArgsType6 = type85({
 });
 function parseArgs12(raw) {
   const parsed = ScaffoldArgsType6(raw);
-  if (parsed instanceof type85.errors) {
+  if (parsed instanceof type86.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const modelName = parsed.model_name.trim();
@@ -49103,10 +49255,10 @@ function createSearchModelSnapshotFieldTool(config) {
 
 // packages/dbx-components-mcp/src/tools/list-app-model-snapshot-fields.tool.ts
 import { glob, readFile as readFile27 } from "node:fs/promises";
-import { resolve as resolve56 } from "node:path";
-import { type as type86 } from "arktype";
+import { resolve as resolve57 } from "node:path";
+import { type as type87 } from "arktype";
 import { Node as Node37, Project as Project22 } from "ts-morph";
-var ListAppArgsType4 = type86({
+var ListAppArgsType4 = type87({
   componentDir: "string",
   "apiDir?": "string",
   "format?": "'markdown' | 'json'"
@@ -49141,7 +49293,7 @@ function createListAppModelSnapshotFieldsTool(input) {
   async function run24(rawArgs) {
     const parsed = ListAppArgsType4(rawArgs);
     let result;
-    if (parsed instanceof type86.errors) {
+    if (parsed instanceof type87.errors) {
       result = toolError(`Invalid arguments: ${parsed.summary}`);
     } else {
       const cwd = process.cwd();
@@ -49155,8 +49307,8 @@ function createListAppModelSnapshotFieldsTool(input) {
         pathError = err instanceof Error ? err.message : String(err);
       }
       if (pathError === void 0) {
-        const componentAbs = resolve56(cwd, parsed.componentDir);
-        const apiAbs = parsed.apiDir === void 0 ? void 0 : resolve56(cwd, parsed.apiDir);
+        const componentAbs = resolve57(cwd, parsed.componentDir);
+        const apiAbs = parsed.apiDir === void 0 ? void 0 : resolve57(cwd, parsed.apiDir);
         let report;
         let buildError;
         try {
@@ -49205,14 +49357,14 @@ async function buildListAppReport(input) {
   const project = new Project22({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
   const componentFiles = await collectFiles(componentAbs, COMPONENT_MODEL_GLOBS);
   for (const rel of componentFiles) {
-    const abs = resolve56(componentAbs, rel);
+    const abs = resolve57(componentAbs, rel);
     const text = await readFile27(abs, "utf-8");
     project.createSourceFile(`/component/${rel}`, text, { overwrite: true });
   }
   if (apiAbs !== void 0) {
     const apiFiles = await collectFiles(apiAbs, API_MODEL_GLOBS);
     for (const rel of apiFiles) {
-      const abs = resolve56(apiAbs, rel);
+      const abs = resolve57(apiAbs, rel);
       const text = await readFile27(abs, "utf-8");
       project.createSourceFile(`/api/${rel}`, text, { overwrite: true });
     }
@@ -49818,9 +49970,9 @@ function createSearchModelFirebaseIndexTool(config) {
 }
 
 // packages/dbx-components-mcp/src/tools/list-app-model-firebase-index.tool.ts
-import { resolve as resolve57 } from "node:path";
-import { type as type87 } from "arktype";
-var ListAppArgsType5 = type87({
+import { resolve as resolve58 } from "node:path";
+import { type as type88 } from "arktype";
+var ListAppArgsType5 = type88({
   componentDir: "string",
   "format?": "'markdown' | 'json'",
   "model?": "string",
@@ -49869,7 +50021,7 @@ var DBX_MODEL_FIREBASE_INDEX_LIST_APP_TOOL = {
 async function runListAppModelFirebaseIndex(rawArgs) {
   const parsed = ListAppArgsType5(rawArgs);
   let result;
-  if (parsed instanceof type87.errors) {
+  if (parsed instanceof type88.errors) {
     result = toolError(`Invalid arguments: ${parsed.summary}`);
   } else {
     const cwd = process.cwd();
@@ -49880,7 +50032,7 @@ async function runListAppModelFirebaseIndex(rawArgs) {
       pathError = err instanceof Error ? err.message : String(err);
     }
     if (pathError === void 0) {
-      const componentAbs = resolve57(cwd, parsed.componentDir);
+      const componentAbs = resolve58(cwd, parsed.componentDir);
       const filters = {
         model: parsed.model,
         category: parsed.category,
@@ -50276,8 +50428,8 @@ function formatReportAsJson16(report) {
 
 // packages/dbx-components-mcp/src/tools/validate-app-model-firebase-index.tool.ts
 import { readFile as readFile28 } from "node:fs/promises";
-import { resolve as resolve58 } from "node:path";
-import { type as type88 } from "arktype";
+import { resolve as resolve59 } from "node:path";
+import { type as type89 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-firebase-index-validate-app/format-warnings.ts
 function mapModelFirebaseIndexBuildWarning(warning) {
@@ -50492,7 +50644,7 @@ function buildFirebaseIndexValidateAppViolation(mapped) {
 }
 
 // packages/dbx-components-mcp/src/tools/validate-app-model-firebase-index.tool.ts
-var ValidateAppArgsType2 = type88({
+var ValidateAppArgsType2 = type89({
   componentDir: "string",
   "indexesFile?": "string",
   "format?": "'markdown' | 'json'"
@@ -50614,7 +50766,7 @@ var DBX_MODEL_FIREBASE_INDEX_VALIDATE_APP_TOOL = {
 };
 async function runValidateAppModelFirebaseIndex(rawArgs) {
   const parsed = ValidateAppArgsType2(rawArgs);
-  if (parsed instanceof type88.errors) {
+  if (parsed instanceof type89.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -50630,8 +50782,8 @@ async function runValidateAppModelFirebaseIndex(rawArgs) {
   }
   if (ensureError === void 0) {
     const indexesRelative = parsed.indexesFile ?? "firestore.indexes.json";
-    const componentAbs = resolve58(cwd, parsed.componentDir);
-    const indexesAbs = resolve58(cwd, indexesRelative);
+    const componentAbs = resolve59(cwd, parsed.componentDir);
+    const indexesAbs = resolve59(cwd, indexesRelative);
     let report;
     let buildError;
     try {
@@ -50985,8 +51137,8 @@ function formatReportAsJson17(report) {
 
 // packages/dbx-components-mcp/src/tools/artifact-scaffold.tool.ts
 import { access } from "node:fs/promises";
-import { resolve as resolve59, sep as sep20 } from "node:path";
-import { type as type89 } from "arktype";
+import { resolve as resolve60, sep as sep20 } from "node:path";
+import { type as type90 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/artifact-scaffold/templates.ts
 function splitWords(input) {
@@ -51556,7 +51708,7 @@ var DBX_ARTIFACT_SCAFFOLD_TOOL = {
     required: ["artifact", "name", "componentDir", "apiDir"]
   }
 };
-var ScaffoldArtifactArgsType = type89({
+var ScaffoldArtifactArgsType = type90({
   artifact: ARTIFACT_KIND_LITERAL_UNION,
   name: "string",
   componentDir: "string",
@@ -51569,7 +51721,7 @@ var ScaffoldArtifactArgsType = type89({
 });
 function parseArgs13(raw) {
   const parsed = ScaffoldArtifactArgsType(raw);
-  if (parsed instanceof type89.errors) {
+  if (parsed instanceof type90.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -51582,7 +51734,7 @@ function parseArgs13(raw) {
   return result;
 }
 function ensureInsideCwd(relativePath, cwd) {
-  const absolute = resolve59(cwd, relativePath);
+  const absolute = resolve60(cwd, relativePath);
   const cwdPrefix = cwd.endsWith(sep20) ? cwd : cwd + sep20;
   if (!absolute.startsWith(cwdPrefix) && absolute !== cwd) {
     throw new Error(`Path \`${relativePath}\` resolves outside the server cwd and is not allowed.`);
@@ -51621,7 +51773,7 @@ async function runArtifactScaffold(rawArgs) {
         scaffoldError = `Scaffold failed: ${message}`;
       }
       if (scaffoldError === void 0) {
-        const checked = await applyIdempotency(raw, (relativePath) => fileExists4(resolve59(cwd, relativePath)));
+        const checked = await applyIdempotency(raw, (relativePath) => fileExists4(resolve60(cwd, relativePath)));
         const text = formatResult21(checked);
         result = { content: [{ type: "text", text }] };
       } else {
@@ -51642,7 +51794,7 @@ var ARTIFACT_SCAFFOLD_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/artifact-file-convention.tool.ts
-import { type as type90 } from "arktype";
+import { type as type91 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/artifact-file-convention/spec.ts
 var FIRESTORE_MODEL = {
@@ -52118,7 +52270,7 @@ var DBX_ARTIFACT_FILE_CONVENTION_TOOL = {
     required: ["artifact"]
   }
 };
-var FileConventionArgsType = type90({
+var FileConventionArgsType = type91({
   artifact: ARTIFACT_KIND_LITERAL_UNION2,
   "componentDir?": "string",
   "apiDir?": "string",
@@ -52126,7 +52278,7 @@ var FileConventionArgsType = type90({
 });
 function parseArgs14(raw) {
   const parsed = FileConventionArgsType(raw);
-  if (parsed instanceof type90.errors) {
+  if (parsed instanceof type91.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -52160,8 +52312,8 @@ var ARTIFACT_FILE_CONVENTION_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/explain-rule.tool.ts
-import { type as type91 } from "arktype";
-var ExplainRuleArgsType = type91({
+import { type as type92 } from "arktype";
+var ExplainRuleArgsType = type92({
   "code?": "string",
   "source?": "string",
   "severity?": "'error' | 'warning'",
@@ -52204,7 +52356,7 @@ var TOOL16 = {
 };
 async function run17(rawArgs) {
   const parsed = ExplainRuleArgsType(rawArgs);
-  if (parsed instanceof type91.errors) {
+  if (parsed instanceof type92.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   if (parsed.code !== void 0) {
@@ -52292,9 +52444,9 @@ function groupBySource(entries) {
 var EXPLAIN_RULE_TOOL = { definition: TOOL16, run: run17 };
 
 // packages/dbx-components-mcp/src/tools/app-validate.tool.ts
-import { resolve as resolve60, join as join25 } from "node:path";
+import { resolve as resolve61, join as join25 } from "node:path";
 import { readdir as readdir11, readFile as readFile29, stat as stat16 } from "node:fs/promises";
-import { type as type92 } from "arktype";
+import { type as type93 } from "arktype";
 var { inspectAppStorageFiles: inspectAppStorageFiles4, validateAppStorageFiles: validateAppStorageFiles3 } = storagefile_m_validate_app_exports;
 var { inspectAppNotifications: inspectAppNotifications4, validateAppNotifications: validateAppNotifications3 } = notification_m_validate_app_exports;
 var { validateAppFixtures: validateAppFixtures3 } = model_fixture_shared_exports;
@@ -52306,7 +52458,7 @@ var { validateAppModelApi: validateAppModelApi3 } = model_api_validate_app_expor
 var { validateModelTestApp: validateModelTestApp3 } = model_test_validate_app_exports;
 var { extractComponentModels: extractComponentModels3 } = model_list_component_exports;
 var Cluster = "'storagefile_m' | 'notification_m' | 'model_folder' | 'system_m' | 'fixture' | 'manifest' | 'model_api' | 'firebase_index' | 'asset' | 'model_test'";
-var AppValidateArgsType = type92({
+var AppValidateArgsType = type93({
   componentDir: "string",
   apiDir: "string",
   "webDir?": "string",
@@ -52362,17 +52514,17 @@ var TOOL17 = {
 };
 async function run18(rawArgs) {
   const parsed = AppValidateArgsType(rawArgs);
-  if (parsed instanceof type92.errors) {
+  if (parsed instanceof type93.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
   const pathCheck = ensureArgPaths(parsed, cwd);
   if (pathCheck !== void 0) return pathCheck;
-  const componentAbs = resolve60(cwd, parsed.componentDir);
-  const apiAbs = resolve60(cwd, parsed.apiDir);
-  const webAbs = parsed.webDir === void 0 ? void 0 : resolve60(cwd, parsed.webDir);
+  const componentAbs = resolve61(cwd, parsed.componentDir);
+  const apiAbs = resolve61(cwd, parsed.apiDir);
+  const webAbs = parsed.webDir === void 0 ? void 0 : resolve61(cwd, parsed.webDir);
   const indexesRel = parsed.indexesFile ?? "firestore.indexes.json";
-  const indexesAbs = resolve60(cwd, indexesRel);
+  const indexesAbs = resolve61(cwd, indexesRel);
   const skip = new Set(parsed.skip ?? []);
   const findings = [];
   const skipped = [];
@@ -52730,9 +52882,9 @@ var APP_VALIDATE_TOOL = { definition: TOOL17, run: run18 };
 
 // packages/dbx-components-mcp/src/tools/firestore-rules-scan.tool.ts
 import { readFile as readFile30 } from "node:fs/promises";
-import { resolve as resolve61 } from "node:path";
-import { type as type93 } from "arktype";
-var ScanArgsType = type93({
+import { resolve as resolve62 } from "node:path";
+import { type as type94 } from "arktype";
+var ScanArgsType = type94({
   "rulesFile?": "string",
   "collection?": "string",
   "serverOnly?": "boolean",
@@ -52838,7 +52990,7 @@ function formatFirestoreRulesScanReportAsMarkdown(report) {
 }
 async function run19(rawArgs) {
   const parsed = ScanArgsType(rawArgs ?? {});
-  if (parsed instanceof type93.errors) {
+  if (parsed instanceof type94.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -52853,7 +53005,7 @@ async function run19(rawArgs) {
   if (failure === void 0) {
     let source;
     try {
-      source = await readFile30(resolve61(cwd, rulesFile), "utf8");
+      source = await readFile30(resolve62(cwd, rulesFile), "utf8");
     } catch (err) {
       failure = `Failed to read ${rulesFile}: ${err instanceof Error ? err.message : String(err)}`;
     }
@@ -52875,8 +53027,8 @@ var FIRESTORE_RULES_SCAN_TOOL = { definition: TOOL18, run: run19 };
 
 // packages/dbx-components-mcp/src/tools/model-server-only-validate-app.tool.ts
 import { readdir as readdir12, readFile as readFile31, stat as stat17 } from "node:fs/promises";
-import { join as join26, relative as relative20, resolve as resolve62 } from "node:path";
-import { type as type94 } from "arktype";
+import { join as join26, relative as relative20, resolve as resolve63 } from "node:path";
+import { type as type95 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/model-server-only-validate-app/extract-service-flags.ts
 var SERVICE_FACTORY_TAG2 = /@dbxModelServiceFactory\s+([A-Za-z_$][\w$]*)/;
@@ -53197,7 +53349,7 @@ function buildViolation(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/model-server-only-validate-app.tool.ts
-var ValidateAppArgsType3 = type94({
+var ValidateAppArgsType3 = type95({
   componentDir: "string",
   "rulesFile?": "string",
   "serviceFile?": "string",
@@ -53251,7 +53403,7 @@ async function scanModelFacts(input) {
   const interfaces = /* @__PURE__ */ new Map();
   const identities = /* @__PURE__ */ new Map();
   for (const dir of input.dirs) {
-    for (const filePath of await walkTypeScriptFiles(resolve62(input.cwd, dir))) {
+    for (const filePath of await walkTypeScriptFiles(resolve63(input.cwd, dir))) {
       const text = await readFile31(filePath, "utf8");
       if (!text.includes("firestoreModelIdentity(") && !text.includes("@dbxModel")) continue;
       const relativePath = relative20(input.cwd, filePath);
@@ -53300,7 +53452,7 @@ async function isDirectory5(path) {
 }
 async function run20(rawArgs) {
   const parsed = ValidateAppArgsType3(rawArgs);
-  if (parsed instanceof type94.errors) {
+  if (parsed instanceof type95.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -53317,22 +53469,22 @@ async function run20(rawArgs) {
   if (failure !== void 0) {
     return toolError(failure);
   }
-  const rulesSource = await readOptionalFile(resolve62(cwd, rulesFile));
+  const rulesSource = await readOptionalFile(resolve63(cwd, rulesFile));
   if (rulesSource === void 0) {
     return toolError(`Failed to read rules file \`${rulesFile}\`.`);
   }
-  const serviceSource = await readOptionalFile(resolve62(cwd, serviceFile));
+  const serviceSource = await readOptionalFile(resolve63(cwd, serviceFile));
   if (serviceSource === void 0) {
     return toolError(`Failed to read service file \`${serviceFile}\`. Pass \`serviceFile\` when the component does not use the conventional \`src/lib/model/service.ts\` path.`);
   }
   const requestedDirs = [`${parsed.componentDir.replace(/[/\\]+$/, "")}/src/lib`, ...DEFAULT_UPSTREAM_MODEL_DIRS, ...parsed.modelDirs ?? []];
   const modelDirs = [];
   for (const dir of requestedDirs) {
-    if (!modelDirs.includes(dir) && await isDirectory5(resolve62(cwd, dir))) {
+    if (!modelDirs.includes(dir) && await isDirectory5(resolve63(cwd, dir))) {
       modelDirs.push(dir);
     }
   }
-  const manifestSource = parsed.manifestFile === void 0 ? void 0 : await readOptionalFile(resolve62(cwd, parsed.manifestFile));
+  const manifestSource = parsed.manifestFile === void 0 ? void 0 : await readOptionalFile(resolve63(cwd, parsed.manifestFile));
   if (parsed.manifestFile !== void 0 && manifestSource === void 0) {
     return toolError(`Failed to read model manifest \`${parsed.manifestFile}\`.`);
   }
@@ -53354,10 +53506,10 @@ async function run20(rawArgs) {
 var MODEL_SERVER_ONLY_VALIDATE_APP_TOOL = { definition: TOOL19, run: run20 };
 
 // packages/dbx-components-mcp/src/tools/model-list-component.tool.ts
-import { resolve as resolve63 } from "node:path";
-import { type as type95 } from "arktype";
+import { resolve as resolve64 } from "node:path";
+import { type as type96 } from "arktype";
 var { formatReportAsJson: formatReportAsJson18, formatReportAsMarkdown: formatReportAsMarkdown18, listComponentModels: listComponentModels2 } = model_list_component_exports;
-var ListArgsType3 = type95({
+var ListArgsType3 = type96({
   componentDir: "string",
   "apiDir?": "string",
   "format?": "'markdown' | 'json'"
@@ -53388,7 +53540,7 @@ var TOOL20 = {
 };
 async function run21(rawArgs) {
   const parsed = ListArgsType3(rawArgs);
-  if (parsed instanceof type95.errors) {
+  if (parsed instanceof type96.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -53401,8 +53553,8 @@ async function run21(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const componentAbs = resolve63(cwd, parsed.componentDir);
-    const apiAbs = parsed.apiDir ? resolve63(cwd, parsed.apiDir) : void 0;
+    const componentAbs = resolve64(cwd, parsed.componentDir);
+    const apiAbs = parsed.apiDir ? resolve64(cwd, parsed.apiDir) : void 0;
     let report;
     let listError;
     try {
@@ -53424,10 +53576,10 @@ async function run21(rawArgs) {
 var MODEL_LIST_COMPONENT_TOOL = { definition: TOOL20, run: run21 };
 
 // packages/dbx-components-mcp/src/tools/server-actions-list-app.tool.ts
-import { resolve as resolve64 } from "node:path";
-import { type as type96 } from "arktype";
+import { resolve as resolve65 } from "node:path";
+import { type as type97 } from "arktype";
 var { formatReportAsJson: formatReportAsJson19, formatReportAsMarkdown: formatReportAsMarkdown19, listAppServerActions: listAppServerActions2 } = server_actions_list_app_exports;
-var ListArgsType4 = type96({
+var ListArgsType4 = type97({
   apiDir: "string",
   "format?": "'markdown' | 'json'"
 });
@@ -53456,7 +53608,7 @@ var TOOL21 = {
 };
 async function run22(rawArgs) {
   const parsed = ListArgsType4(rawArgs);
-  if (parsed instanceof type96.errors) {
+  if (parsed instanceof type97.errors) {
     return toolError(`Invalid arguments: ${parsed.summary}`);
   }
   const cwd = process.cwd();
@@ -53468,7 +53620,7 @@ async function run22(rawArgs) {
     ensureError = err instanceof Error ? err.message : String(err);
   }
   if (ensureError === void 0) {
-    const apiAbs = resolve64(cwd, parsed.apiDir);
+    const apiAbs = resolve65(cwd, parsed.apiDir);
     let report;
     let listError;
     try {
@@ -53490,16 +53642,16 @@ async function run22(rawArgs) {
 var SERVER_ACTIONS_LIST_APP_TOOL = { definition: TOOL21, run: run22 };
 
 // packages/dbx-components-mcp/src/tools/mcp-config.tool.ts
-import { type as type97 } from "arktype";
-import { resolve as resolve67 } from "node:path";
+import { type as type98 } from "arktype";
+import { resolve as resolve68 } from "node:path";
 
 // packages/dbx-components-mcp/src/tools/mcp-config/snapshot.ts
-import { dirname as dirname21, isAbsolute as isAbsolute18, relative as relative21, resolve as resolve65 } from "node:path";
+import { dirname as dirname22, isAbsolute as isAbsolute18, relative as relative21, resolve as resolve66 } from "node:path";
 import { stat as stat18 } from "node:fs/promises";
 async function buildSnapshot(input) {
   const { workspaceRoot, explicitDirs } = input;
   const configResult = await findAndLoadConfig({ cwd: workspaceRoot });
-  const configBaseDir = configResult.configPath === null ? workspaceRoot : dirname21(configResult.configPath);
+  const configBaseDir = configResult.configPath === null ? workspaceRoot : dirname22(configResult.configPath);
   const registeredSources = await collectRegisteredSources(configResult.config, configBaseDir, workspaceRoot);
   const packages = await discoverDownstreamPackages({ workspaceRoot, explicitDirs });
   const packageSnapshots = packages.map((pkg) => ({
@@ -53521,7 +53673,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 = isAbsolute18(declaredPath) ? declaredPath : resolve65(configBaseDir, declaredPath);
+      const absolutePath = isAbsolute18(declaredPath) ? declaredPath : resolve66(configBaseDir, declaredPath);
       const exists = await fileExists5(absolutePath);
       const relativePath = relativeOrAbsolute(workspaceRoot, absolutePath);
       out.push({ cluster, declaredPath, absolutePath, relativePath, exists });
@@ -53561,7 +53713,7 @@ function relativeOrAbsolute(from, target) {
 
 // packages/dbx-components-mcp/src/tools/mcp-config/init.ts
 import { writeFile as nodeWriteFile4, mkdir as nodeMkdir, readFile as nodeReadFile8 } from "node:fs/promises";
-import { dirname as dirname22, relative as relative22, resolve as resolve66 } from "node:path";
+import { dirname as dirname23, relative as relative22, resolve as resolve67 } from "node:path";
 var HEURISTIC_CLUSTERS = ["uiComponents", "forgeFields", "pipes", "actions", "filters"];
 var CLUSTER_FILENAME_SEGMENT = {
   semanticTypes: "semantic",
@@ -53600,7 +53752,7 @@ async function applyInitPlan(plan, opts) {
   const mkdir = opts?.mkdir ?? defaultMkdir;
   for (const change of plan.changes) {
     if (change.reason === "unchanged") continue;
-    await mkdir(dirname22(change.absolutePath));
+    await mkdir(dirname23(change.absolutePath));
     await writeFile2(change.absolutePath, change.after);
   }
 }
@@ -53625,7 +53777,7 @@ function upsertClusterSection(input) {
 async function planPackageScanConfig(input) {
   const { snapshot, packageSnapshot, readFile: readFile33 } = input;
   const { pkg } = packageSnapshot;
-  const scanConfigPath = resolve66(pkg.absDir, "dbx-mcp.scan.json");
+  const scanConfigPath = resolve67(pkg.absDir, "dbx-mcp.scan.json");
   const before = await tryRead(scanConfigPath, readFile33);
   const parsed = parseExisting(before);
   const targetClusters = HEURISTIC_CLUSTERS.filter((c) => pkg.candidateClusters.includes(c));
@@ -53655,7 +53807,7 @@ async function planPackageScanConfig(input) {
 }
 async function planRootConfig(input) {
   const { snapshot, sourcesToRegister, readFile: readFile33 } = input;
-  const configPath = snapshot.configPath ?? resolve66(snapshot.workspaceRoot, "dbx-mcp.config.json");
+  const configPath = snapshot.configPath ?? resolve67(snapshot.workspaceRoot, "dbx-mcp.config.json");
   const before = snapshot.configPath === null ? null : await tryRead(configPath, readFile33);
   const baseConfig = snapshot.config === null ? { version: 1 } : cloneConfig(snapshot.config);
   if (baseConfig.version !== 1) baseConfig.version = 1;
@@ -53684,14 +53836,14 @@ async function planRootConfig(input) {
   };
 }
 function defaultOutFor(input) {
-  const targetAbs = resolve66(input.snapshot.workspaceRoot, ".tmp/dbx-mcp", `${input.slug}.${clusterFilenameSegment(input.cluster)}.json`);
-  return relative22(dirname22(input.scanConfigPath), targetAbs).replaceAll("\\", "/");
+  const targetAbs = resolve67(input.snapshot.workspaceRoot, ".tmp/dbx-mcp", `${input.slug}.${clusterFilenameSegment(input.cluster)}.json`);
+  return relative22(dirname23(input.scanConfigPath), targetAbs).replaceAll("\\", "/");
 }
 function resolveScanOut(scanConfigPath, out) {
-  return resolve66(dirname22(scanConfigPath), out);
+  return resolve67(dirname23(scanConfigPath), out);
 }
 function relativeFromConfig(snapshot, absolute) {
-  const configDir = snapshot.configPath === null ? snapshot.workspaceRoot : dirname22(snapshot.configPath);
+  const configDir = snapshot.configPath === null ? snapshot.workspaceRoot : dirname23(snapshot.configPath);
   return relative22(configDir, absolute).replaceAll("\\", "/");
 }
 function workspaceRel(workspaceRoot, absolute) {
@@ -54024,7 +54176,7 @@ var TOOL22 = {
     required: ["op"]
   }
 };
-var McpConfigArgsType = type97({
+var McpConfigArgsType = type98({
   op: "'status' | 'validate' | 'init' | 'refresh'",
   "cwd?": "string",
   "dryRun?": "boolean",
@@ -54032,10 +54184,10 @@ var McpConfigArgsType = type97({
 });
 function parseArgs15(rawArgs, defaultCwd) {
   const parsed = McpConfigArgsType(rawArgs);
-  if (parsed instanceof type97.errors) {
+  if (parsed instanceof type98.errors) {
     return `Invalid arguments: ${parsed.summary}`;
   }
-  const workspaceRoot = parsed.cwd !== void 0 && parsed.cwd.length > 0 ? resolve67(defaultCwd, parsed.cwd) : defaultCwd;
+  const workspaceRoot = parsed.cwd !== void 0 && parsed.cwd.length > 0 ? resolve68(defaultCwd, parsed.cwd) : defaultCwd;
   const invalidDirError = validateExplicitDirs(parsed.explicitDirs, workspaceRoot);
   let result;
   if (invalidDirError === void 0) {
@@ -54104,12 +54256,12 @@ var MCP_CONFIG_TOOL = {
 };
 
 // packages/dbx-components-mcp/src/tools/log-search.tool.ts
-import { type as type98 } from "arktype";
+import { type as type99 } from "arktype";
 import { basename as basename10 } from "node:path";
 
 // packages/dbx-components-mcp/src/tools/log-search/discover-logs.ts
 import { readdir as readdir13, stat as stat19 } from "node:fs/promises";
-import { basename as basename9, join as join27, resolve as resolve68 } from "node:path";
+import { basename as basename9, join as join27, resolve as resolve69 } from "node:path";
 var DBX_LOG_PATH_ENV_VAR = "DBX_LOG_PATH";
 function resolveLogBasePath(input) {
   let result;
@@ -54117,11 +54269,11 @@ function resolveLogBasePath(input) {
   const fromEnv = input.env[DBX_LOG_PATH_ENV_VAR]?.trim();
   const fromConfig = input.configBasePath?.trim();
   if (fromArg !== void 0 && fromArg.length > 0) {
-    result = { kind: "ok", absolutePath: resolve68(fromArg), source: "arg" };
+    result = { kind: "ok", absolutePath: resolve69(fromArg), source: "arg" };
   } else if (fromEnv !== void 0 && fromEnv.length > 0) {
-    result = { kind: "ok", absolutePath: resolve68(fromEnv), source: "env" };
+    result = { kind: "ok", absolutePath: resolve69(fromEnv), source: "env" };
   } else if (fromConfig !== void 0 && fromConfig.length > 0) {
-    result = { kind: "ok", absolutePath: resolve68(fromConfig), source: "config" };
+    result = { kind: "ok", absolutePath: resolve69(fromConfig), source: "config" };
   } else {
     result = { kind: "error", message: `No log path configured. Set ${DBX_LOG_PATH_ENV_VAR}, pass basePath, or add a logs.basePath block to dbx-mcp.config.json.` };
   }
@@ -54517,7 +54669,7 @@ var DBX_LOG_SEARCH_TOOL = {
     }
   }
 };
-var LogSearchArgsType = type98({
+var LogSearchArgsType = type99({
   "query?": "string",
   "mode?": "'fuzzy' | 'keyword' | 'list'",
   "basePath?": "string",
@@ -54530,7 +54682,7 @@ var LogSearchArgsType = type98({
 });
 function parseArgs16(input) {
   const parsed = LogSearchArgsType(input.raw ?? {});
-  if (parsed instanceof type98.errors) {
+  if (parsed instanceof type99.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawQuery = parsed.query?.trim();
@@ -54652,7 +54804,7 @@ function createLogSearchTool(config) {
 var LOG_SEARCH_TOOL = createLogSearchTool();
 
 // packages/dbx-components-mcp/src/tools/lookup-semantic-type.tool.ts
-import { type as type99 } from "arktype";
+import { type as type100 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/semantic-type-lookup.formatter.ts
 function formatSemanticTypeEntry(entry, depth) {
@@ -54828,13 +54980,13 @@ var DBX_SEMANTIC_TYPE_LOOKUP_TOOL = {
     required: ["name"]
   }
 };
-var LookupSemanticTypeArgsType = type99({
+var LookupSemanticTypeArgsType = type100({
   name: "string",
   "depth?": "'brief' | 'full'"
 });
 function parseLookupArgs2(raw) {
   const parsed = LookupSemanticTypeArgsType(raw);
-  if (parsed instanceof type99.errors) {
+  if (parsed instanceof type100.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -54896,7 +55048,7 @@ function formatNotFound16(name, registry) {
 }
 
 // packages/dbx-components-mcp/src/tools/search-semantic-type.tool.ts
-import { type as type100 } from "arktype";
+import { type as type101 } from "arktype";
 var DEFAULT_LIMIT9 = 25;
 var MAX_LIMIT8 = 100;
 var DBX_SEMANTIC_TYPE_SEARCH_TOOL = {
@@ -54929,7 +55081,7 @@ var DBX_SEMANTIC_TYPE_SEARCH_TOOL = {
     }
   }
 };
-var SearchSemanticTypeArgsType = type100({
+var SearchSemanticTypeArgsType = type101({
   "topic?": "string",
   "baseType?": "string",
   "package?": "string",
@@ -54938,7 +55090,7 @@ var SearchSemanticTypeArgsType = type100({
 });
 function parseSearchArgs2(raw) {
   const parsed = SearchSemanticTypeArgsType(raw);
-  if (parsed instanceof type100.errors) {
+  if (parsed instanceof type101.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const rawLimit = parsed.limit ?? DEFAULT_LIMIT9;
@@ -55055,7 +55207,7 @@ function describeFilters(args) {
 }
 
 // packages/dbx-components-mcp/src/tools/css-token-lookup.tool.ts
-import { type as type101 } from "arktype";
+import { type as type102 } from "arktype";
 
 // packages/dbx-components-mcp/src/tools/css-token-lookup/synonyms.ts
 var INTENT_SYNONYMS = /* @__PURE__ */ new Map([
@@ -55624,7 +55776,7 @@ var DBX_CSS_TOKEN_LOOKUP_TOOL = {
     }
   }
 };
-var CssTokenLookupArgs = type101({
+var CssTokenLookupArgs = type102({
   "intent?": "string",
   "value?": "string",
   "role?": "string",
@@ -55633,7 +55785,7 @@ var CssTokenLookupArgs = type101({
 });
 function parseArgs17(raw) {
   const parsed = CssTokenLookupArgs(raw);
-  if (parsed instanceof type101.errors) {
+  if (parsed instanceof type102.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const result = {
@@ -55665,7 +55817,7 @@ function createCssTokenLookupTool(input) {
 }
 
 // packages/dbx-components-mcp/src/tools/css-class-lookup.tool.ts
-import { type as type102 } from "arktype";
+import { type as type103 } from "arktype";
 var DBX_CSS_CLASS_LOOKUP_TOOL = {
   name: "dbx_css_class_lookup",
   description: [
@@ -55703,7 +55855,7 @@ var DBX_CSS_CLASS_LOOKUP_TOOL = {
     }
   }
 };
-var CssClassLookupArgs = type102({
+var CssClassLookupArgs = type103({
   "name?": "string",
   "declarations?": "string",
   "intent?": "string",
@@ -55714,7 +55866,7 @@ var CssClassLookupArgs = type102({
 });
 function parseArgs18(raw) {
   const parsed = CssClassLookupArgs(raw);
-  if (parsed instanceof type102.errors) {
+  if (parsed instanceof type103.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   return {
@@ -56022,8 +56174,8 @@ function renderAmbiguous(matches) {
 
 // packages/dbx-components-mcp/src/tools/ui-smell-check.tool.ts
 import { readFile as nodeReadFile9 } from "node:fs/promises";
-import { basename as basename11, extname, isAbsolute as isAbsolute19, resolve as resolve69 } from "node:path";
-import { type as type103 } from "arktype";
+import { basename as basename11, extname, isAbsolute as isAbsolute19, resolve as resolve70 } from "node:path";
+import { type as type104 } from "arktype";
 var { detectSmellsDetailed: detectSmellsDetailed2, formatBatchSmellResult: formatBatchSmellResult2, formatSmellResult: formatSmellResult2 } = ui_smell_check_exports;
 var DBX_UI_SMELL_CHECK_TOOL = {
   name: "dbx_ui_smell_check",
@@ -56057,18 +56209,18 @@ var DBX_UI_SMELL_CHECK_TOOL = {
     }
   }
 };
-var SmellCheckArgs = type103({
+var SmellCheckArgs = type104({
   "html?": "string",
   "scss?": "string",
   "htmlPath?": "string",
   "scssPath?": "string",
   "paths?": "string[]",
   "context?": "string",
-  "projectConventions?": type103({ "cardWrapperClasses?": "string[]" })
+  "projectConventions?": type104({ "cardWrapperClasses?": "string[]" })
 });
 function parseArgs19(raw, defaults) {
   const parsed = SmellCheckArgs(raw);
-  if (parsed instanceof type103.errors) {
+  if (parsed instanceof type104.errors) {
     throw new TypeError(`Invalid arguments: ${parsed.summary}`);
   }
   const html = parsed.html ?? "";
@@ -56080,7 +56232,7 @@ function parseArgs19(raw, defaults) {
 }
 var DEFAULT_READ_FILE17 = (path) => nodeReadFile9(path, "utf-8");
 async function readPathInput(path, cwd, readFile33) {
-  const absolute = isAbsolute19(path) ? path : resolve69(cwd, path);
+  const absolute = isAbsolute19(path) ? path : resolve70(cwd, path);
   return readFile33(absolute);
 }
 function pairBatchPaths(paths) {
@@ -56287,7 +56439,7 @@ async function tryReadBatchPath(path, cwd, reader) {
 }
 
 // packages/dbx-components-mcp/src/tools/auth-claim-lookup.tool.ts
-import { type as type104 } from "arktype";
+import { type as type105 } from "arktype";
 var DBX_AUTH_CLAIM_LOOKUP_TOOL = {
   name: "dbx_auth_claim_lookup",
   description: [
@@ -56307,7 +56459,7 @@ var DBX_AUTH_CLAIM_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var ClaimArgsType = type104({
+var ClaimArgsType = type105({
   topic: "string",
   "app?": "string",
   "depth?": "'brief' | 'full'"
@@ -56320,7 +56472,7 @@ function createAuthClaimLookupTool(input) {
     run(rawArgs) {
       const parsed = ClaimArgsType(rawArgs);
       let result;
-      if (parsed instanceof type104.errors) {
+      if (parsed instanceof type105.errors) {
         result = toolError(`Invalid arguments: ${parsed.summary}`);
       } else {
         const { topic, app, depth = "full" } = parsed;
@@ -56419,7 +56571,7 @@ function code16(value) {
 }
 
 // packages/dbx-components-mcp/src/tools/auth-scope-lookup.tool.ts
-import { type as type105 } from "arktype";
+import { type as type106 } from "arktype";
 var DBX_AUTH_SCOPE_LOOKUP_TOOL = {
   name: "dbx_auth_scope_lookup",
   description: ["Look up an OIDC scope (`model.read`, `model.write`, `demo`).", "", "Returns the prefix family, the CRUD verb (when a callModel scope), the source `path:line` declaration, every gate that enforces it, the error code thrown on rejection, and the apps that accept it."].join("\n"),
@@ -56432,7 +56584,7 @@ var DBX_AUTH_SCOPE_LOOKUP_TOOL = {
     required: ["topic"]
   }
 };
-var ScopeArgsType = type105({
+var ScopeArgsType = type106({
   topic: "string",
   "depth?": "'brief' | 'full'"
 });
@@ -56444,7 +56596,7 @@ function createAuthScopeLookupTool(input) {
     run(rawArgs) {
       const parsed = ScopeArgsType(rawArgs);
       let result;
-      if (parsed instanceof type105.errors) {
+      if (parsed instanceof type106.errors) {
         result = toolError(`Invalid arguments: ${parsed.summary}`);
       } else {
         const { topic, depth = "full" } = parsed;
@@ -56516,7 +56668,7 @@ function sourceLink2(path, line) {
 }
 
 // packages/dbx-components-mcp/src/tools/auth-role-lookup.tool.ts
-import { type as type106 } from "arktype";
+import { type as type107 } from "arktype";
 var DBX_AUTH_ROLE_LOOKUP_TOOL = {
   name: "dbx_auth_role_lookup",
   description: [
@@ -56538,7 +56690,7 @@ var DBX_AUTH_ROLE_LOOKUP_TOOL = {
     }
   }
 };
-var RoleArgsType = type106({
+var RoleArgsType = type107({
   "topic?": "string",
   "tag?": "string",
   "model?": "string",
@@ -56553,7 +56705,7 @@ function createAuthRoleLookupTool(input) {
     run(rawArgs) {
       const parsed = RoleArgsType(rawArgs);
       let result;
-      if (parsed instanceof type106.errors) {
+      if (parsed instanceof type107.errors) {
         result = toolError(`Invalid arguments: ${parsed.summary}`);
       } else {
         const text = dispatchRoleLookup(registry, parsed);
@@ -56706,7 +56858,7 @@ function sourceLink3(path, line) {
 }
 
 // packages/dbx-components-mcp/src/tools/auth-token-explain.tool.ts
-import { type as type107 } from "arktype";
+import { type as type108 } from "arktype";
 var DBX_AUTH_TOKEN_EXPLAIN_TOOL = {
   name: "dbx_auth_token_explain",
   description: [
@@ -56724,7 +56876,7 @@ var DBX_AUTH_TOKEN_EXPLAIN_TOOL = {
     }
   }
 };
-var TokenArgsType = type107({
+var TokenArgsType = type108({
   "token?": "string",
   "claims?": "object",
   "app?": "string",
@@ -56739,7 +56891,7 @@ function createAuthTokenExplainTool(input) {
     run(rawArgs) {
       const parsed = TokenArgsType(rawArgs);
       let result;
-      if (parsed instanceof type107.errors) {
+      if (parsed instanceof type108.errors) {
         result = toolError(`Invalid arguments: ${parsed.summary}`);
       } else {
         const { token, claims: claimsObj, app, expectedIssuer } = parsed;
@@ -56951,7 +57103,7 @@ function describeReserved(key) {
 }
 
 // packages/dbx-components-mcp/src/tools/auth-list-app.tool.ts
-import { type as type108 } from "arktype";
+import { type as type109 } from "arktype";
 var DBX_AUTH_LIST_APP_TOOL = {
   name: "dbx_auth_list_app",
   description: ["Enumerate the auth surface of one app: every custom claim on its `*ApiAuthClaims` interface, every OIDC scope it accepts, and every server-action gate wired up.", "", 'Pass `app="list"` to enumerate the apps catalogued by the registry.'].join("\n"),
@@ -56963,7 +57115,7 @@ var DBX_AUTH_LIST_APP_TOOL = {
     required: ["app"]
   }
 };
-var ListAppArgsType6 = type108({
+var ListAppArgsType6 = type109({
   app: "string"
 });
 // @__NO_SIDE_EFFECTS__
@@ -56974,7 +57126,7 @@ function createAuthListAppTool(input) {
     run(rawArgs) {
       const parsed = ListAppArgsType6(rawArgs);
       let result;
-      if (parsed instanceof type108.errors) {
+      if (parsed instanceof type109.errors) {
         result = toolError(`Invalid arguments: ${parsed.summary}`);
       } else {
         const { app } = parsed;
@@ -57285,7 +57437,7 @@ async function loadServerContext(options = {}) {
 `);
   }
   const modelValidateRuleOptions = resolveModelValidateRuleOptions(configResult.config);
-  const configBaseDir = configResult.configPath !== null && configResult.configPath !== void 0 ? dirname23(configResult.configPath) : cwd;
+  const configBaseDir = configResult.configPath !== null && configResult.configPath !== void 0 ? dirname24(configResult.configPath) : cwd;
   const logSearchConfig = resolveLogSearchConfig(configResult.config, configBaseDir);
   const registry = await resolveOptionalRegistry({
     injected: options.semanticTypeRegistry,