@akanjs/cli 3.0.0-alpha.10 → 3.0.0-alpha.11

package/{quality.command-0cs2z92d.js → quality.command-ec8r1dn3.js}

@@ -7,11 +7,11 @@ import {
   command,
   runner,
   script
-} from "./index-kdh76j26.js";
+} from "./index-etwh7sd3.js";
 import {
   appRootAllowedFiles,
   libFacetRootAllowedFiles
-} from "./index-z8ptfkzv.js";
+} from "./index-yzsxc30b.js";
 import"./index-mxvakhsm.js";
 import"./index-1577bej2.js";
 import"./index-67546d0j.js";
@@ -20,13 +20,163 @@ import"./index-r24hmh0q.js";
 // pkgs/@akanjs/devkit/qualityScanner.ts
 import { createHash } from "crypto";
 import { readdir, readFile, stat } from "fs/promises";
-import path from "path";
+import path3 from "path";
 import { RESERVED_ROUTE_CONFIG_EXPORTS } from "akanjs/common";
 import ignore from "ignore";
-import ts2 from "typescript";
+import ts4 from "typescript";
 
-// pkgs/@akanjs/devkit/ssrScanner.ts
+// pkgs/@akanjs/devkit/mcpScanner.ts
+import path from "path";
 import ts from "typescript";
+
+class McpScanner {
+  scan(sourceFiles) {
+    const dictionaries = new Map(sourceFiles.filter((sourceFile) => sourceFile.file.endsWith(".dictionary.ts")).map((sourceFile) => [path.dirname(sourceFile.file), sourceFile]));
+    return sourceFiles.filter((sourceFile) => sourceFile.file.endsWith(".signal.ts")).flatMap((sourceFile) => this.#scanSignal(sourceFile, dictionaries.get(path.dirname(sourceFile.file))));
+  }
+  #scanSignal(signal, dictionary) {
+    const exposed = McpScanner.#exposedDeclarations(signal);
+    if (!exposed.length)
+      return [];
+    const refName = path.basename(signal.file, ".signal.ts").replace(/^_+/, "");
+    const described = dictionary ? McpScanner.#describedEntries(dictionary) : new Map;
+    return [
+      ...exposed.filter(({ name, kind }) => !McpScanner.#isDescribed(described, refName, name, kind)).map(({ name, kind, line }) => ({
+        rule: "akan.mcp.missing-description",
+        scope: "mcp",
+        severity: "warning",
+        file: signal.file,
+        line,
+        message: `MCP-exposed ${kind} "${name}" has no dictionary .desc(); an agent sees its name and nothing else.`
+      })),
+      ...exposed.filter(({ guards }) => guards === "missing").map(({ name, kind, line }) => ({
+        rule: "akan.mcp.unguarded-exposure",
+        scope: "mcp",
+        severity: "warning",
+        file: signal.file,
+        line,
+        message: `MCP-exposed ${kind} "${name}" declares no guards; a slice's guards map never reaches a named slice.`
+      }))
+    ];
+  }
+  static #isDescribed(described, refName, name, kind) {
+    if (described.get(kind)?.has(name))
+      return true;
+    return kind === "slice" && !!described.get("endpoint")?.has(`${refName}List${McpScanner.#capitalize(name)}`);
+  }
+  static #exposedDeclarations(signal) {
+    const found = [];
+    const visit = (node) => {
+      if (McpScanner.#isExposeOption(node)) {
+        const declaration = McpScanner.#enclosingDeclaration(node, signal.sourceFile);
+        if (declaration)
+          found.push(declaration);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(signal.sourceFile);
+    return found;
+  }
+  static #isExposeOption(node) {
+    if (!ts.isPropertyAssignment(node) || McpScanner.#propertyName(node) !== "mcp")
+      return false;
+    if (!ts.isObjectLiteralExpression(node.initializer))
+      return false;
+    return node.initializer.properties.some((property) => ts.isPropertyAssignment(property) && McpScanner.#propertyName(property) === "expose" && property.initializer.kind === ts.SyntaxKind.TrueKeyword);
+  }
+  static #enclosingDeclaration(option, sourceFile) {
+    let declaration = null;
+    for (let node = option.parent;node; node = node.parent) {
+      if (!declaration && ts.isPropertyAssignment(node)) {
+        declaration = node;
+        continue;
+      }
+      const kind = McpScanner.#factoryKind(node);
+      if (!kind || !declaration)
+        continue;
+      const name = McpScanner.#propertyName(declaration);
+      if (!name)
+        return null;
+      const line = sourceFile.getLineAndCharacterOfPosition(declaration.getStart(sourceFile)).line + 1;
+      return { name, kind, line, guards: McpScanner.#guardState(option) };
+    }
+    return null;
+  }
+  static #guardState(option) {
+    const options = option.parent;
+    if (!ts.isObjectLiteralExpression(options))
+      return "unknown";
+    if (options.properties.some((property) => ts.isSpreadAssignment(property)))
+      return "unknown";
+    return options.properties.some((property) => ts.isPropertyAssignment(property) && McpScanner.#propertyName(property) === "guards") ? "declared" : "missing";
+  }
+  static #factoryKind(node) {
+    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
+      return null;
+    const factory = node.expression.text;
+    return factory === "slice" || factory === "endpoint" ? factory : null;
+  }
+  static #describedEntries(dictionary) {
+    const described = new Map;
+    const visit = (node) => {
+      const stage = McpScanner.#dictionaryStage(node);
+      if (stage) {
+        for (const [name, chain] of McpScanner.#stageEntries(node)) {
+          if (!chain.has("desc"))
+            continue;
+          const names = described.get(stage) ?? new Set;
+          names.add(name);
+          described.set(stage, names);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(dictionary.sourceFile);
+    return described;
+  }
+  static #dictionaryStage(node) {
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression))
+      return null;
+    const stage = node.expression.name.text;
+    return stage === "endpoint" || stage === "slice" ? stage : null;
+  }
+  static #stageEntries(stage) {
+    const callback = stage.arguments[0];
+    if (!callback || !ts.isArrowFunction(callback))
+      return [];
+    const body = ts.isParenthesizedExpression(callback.body) ? callback.body.expression : callback.body;
+    if (!ts.isObjectLiteralExpression(body))
+      return [];
+    return body.properties.flatMap((property) => {
+      if (!ts.isPropertyAssignment(property))
+        return [];
+      const name = McpScanner.#propertyName(property);
+      return name ? [[name, McpScanner.#chainCalls(property.initializer)]] : [];
+    });
+  }
+  static #chainCalls(expression) {
+    const calls = new Set;
+    let current = expression;
+    while (ts.isCallExpression(current) || ts.isPropertyAccessExpression(current)) {
+      if (ts.isPropertyAccessExpression(current))
+        calls.add(current.name.text);
+      current = current.expression;
+    }
+    return calls;
+  }
+  static #propertyName(property) {
+    const { name } = property;
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+      return name.text;
+    return null;
+  }
+  static #capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+  }
+}
+
+// pkgs/@akanjs/devkit/ssrScanner.ts
+import ts2 from "typescript";
 var STATIC_COMPONENT_MIN_MASS = 4;
 var MIXED_COMPONENT_MIN_MASS = 10;
 var MIXED_COMPONENT_MAX_TOUCHES = 2;
@@ -144,31 +294,31 @@ class SsrScanner {
           });
         }
       }
-      ts.forEachChild(node, visit);
+      ts2.forEachChild(node, visit);
     };
-    ts.forEachChild(sourceFile.sourceFile, visit);
+    ts2.forEachChild(sourceFile.sourceFile, visit);
     return warnings;
   }
   #isMountEffect(sourceFile, node) {
-    if (!ts.isCallExpression(node))
+    if (!ts2.isCallExpression(node))
       return false;
     const callee = node.expression.getText(sourceFile);
     if (callee !== "useEffect" && callee !== "useLayoutEffect")
       return false;
     const deps = node.arguments[1];
-    return !!deps && ts.isArrayLiteralExpression(deps) && deps.elements.length === 0;
+    return !!deps && ts2.isArrayLiteralExpression(deps) && deps.elements.length === 0;
   }
   #getLoadCalls(sourceFile, node) {
     const calls = [];
     const visit = (child) => {
-      if (ts.isCallExpression(child)) {
+      if (ts2.isCallExpression(child)) {
         const callee = child.expression.getText(sourceFile);
         if (/^fetch\.[a-z]/.test(callee) || /^st\.do\.(init|get|view|load|list|count|insight)[A-Z]/.test(callee))
           calls.push({ callee, node: child });
       }
-      ts.forEachChild(child, visit);
+      ts2.forEachChild(child, visit);
     };
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
     return calls;
   }
   #getTemplateStateWarnings(sourceFile) {
@@ -176,7 +326,7 @@ class SsrScanner {
       return [];
     const warnings = [];
     const visit = (node) => {
-      if (ts.isCallExpression(node) && node.expression.getText(sourceFile.sourceFile) === "useState") {
+      if (ts2.isCallExpression(node) && node.expression.getText(sourceFile.sourceFile) === "useState") {
         warnings.push({
           rule: "akan.ssr.template-client-state",
           scope: "ssr",
@@ -186,9 +336,9 @@ class SsrScanner {
           message: "Template holds form state in useState. Templates are store-driven and carry no local state."
         });
       }
-      ts.forEachChild(node, visit);
+      ts2.forEachChild(node, visit);
     };
-    ts.forEachChild(sourceFile.sourceFile, visit);
+    ts2.forEachChild(sourceFile.sourceFile, visit);
     return warnings;
   }
   #measureBalance(sourceFiles) {
@@ -229,14 +379,14 @@ class SsrScanner {
     return components;
   }
   #getComponentNodes(statement) {
-    if (ts.isFunctionDeclaration(statement) && statement.body)
+    if (ts2.isFunctionDeclaration(statement) && statement.body)
       return [{ name: statement.name?.text ?? "default", node: statement.body }];
-    if (!ts.isVariableStatement(statement))
+    if (!ts2.isVariableStatement(statement))
       return [];
     return statement.declarationList.declarations.flatMap((declaration) => {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+      if (!ts2.isIdentifier(declaration.name) || !declaration.initializer)
         return [];
-      if (!ts.isArrowFunction(declaration.initializer) && !ts.isFunctionExpression(declaration.initializer))
+      if (!ts2.isArrowFunction(declaration.initializer) && !ts2.isFunctionExpression(declaration.initializer))
         return [];
       return [{ name: declaration.name.text, node: declaration.initializer }];
     });
@@ -244,7 +394,7 @@ class SsrScanner {
   #getTouches(sourceFile, node) {
     const touches = [];
     const visit = (child) => {
-      if (ts.isCallExpression(child)) {
+      if (ts2.isCallExpression(child)) {
         const callee = child.expression.getText(sourceFile);
         const bareName = callee.split(".").pop() ?? callee;
         if (callee === "createContext" || callee === "lazy")
@@ -252,60 +402,60 @@ class SsrScanner {
         else if (/^use[A-Z]/.test(bareName) && !SsrScanner.#serverSafeCalls.has(bareName))
           touches.push(bareName);
       }
-      if (ts.isJsxAttribute(child) && /^on[A-Z]/.test(child.name.getText(sourceFile)))
+      if (ts2.isJsxAttribute(child) && /^on[A-Z]/.test(child.name.getText(sourceFile)))
         touches.push(child.name.getText(sourceFile));
-      if (ts.isPropertyAccessExpression(child)) {
+      if (ts2.isPropertyAccessExpression(child)) {
         const root = getAccessRoot(child);
         if (root === "st")
           touches.push("st");
         else if (SsrScanner.#clientGlobals.has(root))
           touches.push(root);
       }
-      ts.forEachChild(child, visit);
+      ts2.forEachChild(child, visit);
     };
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
     return touches;
   }
   #getTagNames(sourceFile, node) {
     const tags = new Set;
     const visit = (child) => {
-      if (ts.isJsxOpeningElement(child) || ts.isJsxSelfClosingElement(child))
+      if (ts2.isJsxOpeningElement(child) || ts2.isJsxSelfClosingElement(child))
         tags.add(child.tagName.getText(sourceFile).split(".")[0]);
-      ts.forEachChild(child, visit);
+      ts2.forEachChild(child, visit);
     };
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
     return tags;
   }
   #getMass(node) {
     let mass = 0;
     const visit = (child) => {
-      if (ts.isJsxOpeningElement(child) || ts.isJsxSelfClosingElement(child))
+      if (ts2.isJsxOpeningElement(child) || ts2.isJsxSelfClosingElement(child))
         mass += 1;
-      ts.forEachChild(child, visit);
+      ts2.forEachChild(child, visit);
     };
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
     return mass;
   }
   #hasUseClient(sourceFile) {
     const first = sourceFile.statements[0];
-    if (!first || !ts.isExpressionStatement(first) || !ts.isStringLiteral(first.expression))
+    if (!first || !ts2.isExpressionStatement(first) || !ts2.isStringLiteral(first.expression))
       return false;
     return first.expression.text === "use client";
   }
   #hasVendorImport(sourceFile) {
-    return sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) && isVendorSpecifier(getSpecifier(statement)));
+    return sourceFile.statements.some((statement) => ts2.isImportDeclaration(statement) && isVendorSpecifier(getSpecifier(statement)));
   }
   #getVendorNames(sourceFile) {
     const names = new Set;
     for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement) || !isVendorSpecifier(getSpecifier(statement)))
+      if (!ts2.isImportDeclaration(statement) || !isVendorSpecifier(getSpecifier(statement)))
         continue;
       const clause = statement.importClause;
       if (clause?.name)
         names.add(clause.name.text);
-      if (clause?.namedBindings && ts.isNamespaceImport(clause.namedBindings))
+      if (clause?.namedBindings && ts2.isNamespaceImport(clause.namedBindings))
         names.add(clause.namedBindings.name.text);
-      if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings))
+      if (clause?.namedBindings && ts2.isNamedImports(clause.namedBindings))
         for (const element of clause.namedBindings.elements)
           names.add(element.name.text);
     }
@@ -313,10 +463,10 @@ class SsrScanner {
   }
   #importsClientRuntime(sourceFile) {
     for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement))
+      if (!ts2.isImportDeclaration(statement))
         continue;
       const bindings = statement.importClause?.namedBindings;
-      if (!bindings || !ts.isNamedImports(bindings))
+      if (!bindings || !ts2.isNamedImports(bindings))
         continue;
       if (bindings.elements.some((element) => SsrScanner.#clientRuntimeImports.has(element.name.text)))
         return true;
@@ -367,7 +517,7 @@ function getShare(serverMass, clientMass) {
   return total === 0 ? 1 : serverMass / total;
 }
 function getSpecifier(statement) {
-  return ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : "";
+  return ts2.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : "";
 }
 function isVendorSpecifier(specifier) {
   if (specifier === "" || specifier.startsWith(".") || specifier.startsWith("/"))
@@ -380,9 +530,125 @@ function isVendorSpecifier(specifier) {
 }
 function getAccessRoot(node) {
   let current = node;
-  while (ts.isPropertyAccessExpression(current))
+  while (ts2.isPropertyAccessExpression(current))
     current = current.expression;
-  return ts.isIdentifier(current) ? current.text : "";
+  return ts2.isIdentifier(current) ? current.text : "";
+}
+
+// pkgs/@akanjs/devkit/storeScanner.ts
+import path2 from "path";
+import ts3 from "typescript";
+
+class StoreScanner {
+  scan(sourceFiles) {
+    const dictionaries = new Map(sourceFiles.filter((sourceFile) => sourceFile.file.endsWith(".dictionary.ts")).map((sourceFile) => [path2.dirname(sourceFile.file), sourceFile]));
+    return sourceFiles.filter((sourceFile) => sourceFile.file.endsWith(".store.ts")).flatMap((sourceFile) => this.#scanStore(sourceFile, dictionaries.get(path2.dirname(sourceFile.file))));
+  }
+  #scanStore(store, dictionary) {
+    const actions = StoreScanner.#customActions(store);
+    if (!actions.length)
+      return [];
+    const described = dictionary ? StoreScanner.#describedEntries(dictionary) : new Map;
+    return actions.filter(({ name, fetched }) => fetched.length && !fetched.includes(name)).filter(({ name }) => !described.get("store")?.has(name) && !described.get("endpoint")?.has(name)).map(({ name, line, fetched }) => ({
+      rule: "akan.agent.missing-store-description",
+      scope: "agent",
+      severity: "warning",
+      file: store.file,
+      line,
+      message: `Store action "${name}" calls ${fetched.map((key) => `${key}()`).join(", ")} under a different name and has no dictionary .store() entry, so an agent reading it has the name and nothing else.`
+    }));
+  }
+  static #customActions(store) {
+    const actions = [];
+    const visit = (node) => {
+      if (ts3.isClassDeclaration(node) && StoreScanner.#extendsStore(node)) {
+        for (const member of node.members) {
+          if (!ts3.isMethodDeclaration(member))
+            continue;
+          if (member.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.StaticKeyword))
+            continue;
+          const name = StoreScanner.#memberName(member);
+          if (!name)
+            continue;
+          const line = store.sourceFile.getLineAndCharacterOfPosition(member.getStart(store.sourceFile)).line + 1;
+          actions.push({ name, line, fetched: StoreScanner.#fetchedEndpoints(member) });
+        }
+      }
+      ts3.forEachChild(node, visit);
+    };
+    visit(store.sourceFile);
+    return actions;
+  }
+  static #extendsStore(node) {
+    return !!node.heritageClauses?.some((clause) => clause.types.some((type) => ts3.isCallExpression(type.expression) && StoreScanner.#isStoreCall(type.expression)));
+  }
+  static #isStoreCall(expression) {
+    return ts3.isIdentifier(expression.expression) && expression.expression.text === "store";
+  }
+  static #fetchedEndpoints(member) {
+    const fetched = new Set;
+    const visit = (node) => {
+      if (ts3.isCallExpression(node) && ts3.isPropertyAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "fetch")
+        fetched.add(node.expression.name.text);
+      ts3.forEachChild(node, visit);
+    };
+    visit(member);
+    return [...fetched];
+  }
+  static #describedEntries(dictionary) {
+    const described = new Map;
+    const visit = (node) => {
+      const stage = StoreScanner.#dictionaryStage(node);
+      if (stage) {
+        for (const [name, chain] of StoreScanner.#stageEntries(node)) {
+          if (!chain.has("desc"))
+            continue;
+          const names = described.get(stage) ?? new Set;
+          names.add(name);
+          described.set(stage, names);
+        }
+      }
+      ts3.forEachChild(node, visit);
+    };
+    visit(dictionary.sourceFile);
+    return described;
+  }
+  static #dictionaryStage(node) {
+    if (!ts3.isCallExpression(node) || !ts3.isPropertyAccessExpression(node.expression))
+      return null;
+    const stage = node.expression.name.text;
+    return stage === "store" || stage === "endpoint" ? stage : null;
+  }
+  static #stageEntries(stage) {
+    const callback = stage.arguments[0];
+    if (!callback || !ts3.isArrowFunction(callback))
+      return [];
+    const body = ts3.isParenthesizedExpression(callback.body) ? callback.body.expression : callback.body;
+    if (!ts3.isObjectLiteralExpression(body))
+      return [];
+    return body.properties.flatMap((property) => {
+      if (!ts3.isPropertyAssignment(property))
+        return [];
+      const name = StoreScanner.#memberName(property);
+      return name ? [[name, StoreScanner.#chainCalls(property.initializer)]] : [];
+    });
+  }
+  static #chainCalls(expression) {
+    const calls = new Set;
+    let current = expression;
+    while (ts3.isCallExpression(current) || ts3.isPropertyAccessExpression(current)) {
+      if (ts3.isPropertyAccessExpression(current))
+        calls.add(current.name.text);
+      current = current.expression;
+    }
+    return calls;
+  }
+  static #memberName(member) {
+    const { name } = member;
+    if (!name || !ts3.isIdentifier(name) && !ts3.isStringLiteral(name))
+      return null;
+    return name.text;
+  }
 }
 
 // pkgs/@akanjs/devkit/qualityScanner.ts
@@ -439,7 +705,10 @@ var RULE_FIXES = {
   "akan.ssr.client-static-markup": "Keep the interactive element in the client component and hoist the static subtree into a server component, then accept it as `children` or render it through a Unit/View reference.",
   "akan.ssr.client-mount-load": "Load the data in the route with `fetch.initX(...)` / `fetch.viewX(...)` and pass the init/view object down as a prop; the client store hydrates from it and the effect goes away.",
   "akan.ssr.module-missing-server-view": "Add a <Model>.Unit.tsx for list/card rendering and a <Model>.View.tsx for the detail surface, then have the Zone delegate to them.",
-  "akan.ssr.template-client-state": "Bind the field to the store instead: `value={xForm.field}` with `onChange={st.do.setFieldOnX}`."
+  "akan.ssr.template-client-state": "Bind the field to the store instead: `value={xForm.field}` with `onChange={st.do.setFieldOnX}`.",
+  "akan.mcp.missing-description": "Add `.desc([en, ko])` to this entry in the module's dictionary \u2014 for a slice, either on the slice entry or on the `<model>List<Slice>` endpoint it generates. Describe when to reach for it, not what it is named.",
+  "akan.agent.missing-store-description": "Add the action to the module dictionary's `.store()` stage with a `.desc([en, ko])` saying what it does for the user \u2014 not what the endpoint it calls does. That stage is optional everywhere else: an action named after its endpoint already reads as that endpoint's description.",
+  "akan.mcp.unguarded-exposure": "Name the guards in the same option object as `mcp`: `init({ guards: [SignedIn], mcp: { expose: true } })`. Write `guards: [Public]` if anonymous reads are the intent \u2014 the access is the same, but only one of the two is a decision. The `slice()` call's guards map reaches the root slice and base CRUD, never a named slice."
 };
 function getRuleFix(rule) {
   if (rule.startsWith("akan.convention"))
@@ -460,7 +729,9 @@ class AkanQualityScanner {
       ...sourceFiles.flatMap((sourceFile) => this.#scanConventionQuality(sourceFile)),
       ...sourceFiles.flatMap((sourceFile) => this.#scanLayoutQuality(sourceFile)),
       ...abstractFiles.flatMap((abstractFile) => this.#scanAbstractQuality(abstractFile)),
-      ...ssr.warnings
+      ...ssr.warnings,
+      ...new McpScanner().scan(sourceFiles),
+      ...new StoreScanner().scan(sourceFiles)
     ];
     return {
       workspaceRoot,
@@ -474,7 +745,7 @@ class AkanQualityScanner {
     const ignoreFilter = ignore().add(await this.#readGitIgnore(workspaceRoot));
     const files = [];
     for (const targetRoot of ["apps", "libs"]) {
-      const absoluteTargetRoot = path.join(workspaceRoot, targetRoot);
+      const absoluteTargetRoot = path3.join(workspaceRoot, targetRoot);
       if (!await isDirectory(absoluteTargetRoot))
         continue;
       await this.#walkTargetFiles(workspaceRoot, absoluteTargetRoot, ignoreFilter, files);
@@ -482,7 +753,7 @@ class AkanQualityScanner {
     return files.sort();
   }
   async#readGitIgnore(workspaceRoot) {
-    const gitIgnorePath = path.join(workspaceRoot, ".gitignore");
+    const gitIgnorePath = path3.join(workspaceRoot, ".gitignore");
     if (!await Bun.file(gitIgnorePath).exists())
       return [];
     return (await readFile(gitIgnorePath, "utf8")).split(/\r?\n/);
@@ -490,8 +761,8 @@ class AkanQualityScanner {
   async#walkTargetFiles(workspaceRoot, currentPath, ignoreFilter, files) {
     const entries = await readdir(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = path.join(currentPath, entry.name);
-      const relativePath = toPosix(path.relative(workspaceRoot, absolutePath));
+      const absolutePath = path3.join(currentPath, entry.name);
+      const relativePath = toPosix(path3.relative(workspaceRoot, absolutePath));
       if (shouldSkipPath(relativePath, entry.isDirectory(), ignoreFilter))
         continue;
       if (entry.isDirectory()) {
@@ -506,17 +777,17 @@ class AkanQualityScanner {
     }
   }
   async#readSourceFile(workspaceRoot, file) {
-    const absolutePath = path.join(workspaceRoot, file);
+    const absolutePath = path3.join(workspaceRoot, file);
     const content = await readFile(absolutePath, "utf8");
     return {
       file,
       absolutePath,
       content,
-      sourceFile: ts2.createSourceFile(file, content, ts2.ScriptTarget.Latest, true, getScriptKind(file))
+      sourceFile: ts4.createSourceFile(file, content, ts4.ScriptTarget.Latest, true, getScriptKind(file))
     };
   }
   async#readTextFile(workspaceRoot, file) {
-    return { file, content: await readFile(path.join(workspaceRoot, file), "utf8") };
+    return { file, content: await readFile(path3.join(workspaceRoot, file), "utf8") };
   }
   #scanGlobalQuality(sourceFiles) {
     const exportedFunctionLikes = sourceFiles.flatMap((sourceFile) => getExportedFunctionLikes(sourceFile));
@@ -640,7 +911,7 @@ class AkanQualityScanner {
     const suffix = CONVENTION_SUFFIXES.find((candidate) => sourceFile.file.endsWith(candidate));
     if (!suffix)
       return [];
-    const modelName = toPascalCase(path.basename(sourceFile.file, suffix));
+    const modelName = toPascalCase(path3.basename(sourceFile.file, suffix));
     const warnings = [];
     for (const declaration of getTopLevelDeclarations(sourceFile)) {
       if (isAllowedConventionDeclaration(suffix, modelName, declaration))
@@ -651,7 +922,7 @@ class AkanQualityScanner {
         severity: "warning",
         file: sourceFile.file,
         line: declaration.line,
-        message: `${path.basename(sourceFile.file)} should not declare top-level ${declaration.kind} "${declaration.name}". Allowed declarations: ${getConventionDescription(suffix, modelName)}.`
+        message: `${path3.basename(sourceFile.file)} should not declare top-level ${declaration.kind} "${declaration.name}". Allowed declarations: ${getConventionDescription(suffix, modelName)}.`
       });
     }
     return warnings;
@@ -759,7 +1030,7 @@ function getExportedFunctionLikes(sourceFile) {
   const declarations = [];
   const nameExempt = isPageRouteFile(sourceFile.file) || isUiComponentFile(sourceFile.file);
   for (const statement of sourceFile.sourceFile.statements) {
-    if (ts2.isFunctionDeclaration(statement) && statement.name && isExported(statement)) {
+    if (ts4.isFunctionDeclaration(statement) && statement.name && isExported(statement)) {
       declarations.push({
         name: statement.name.text,
         kind: "function",
@@ -769,7 +1040,7 @@ function getExportedFunctionLikes(sourceFile) {
         duplicateNameExempt: nameExempt || isConventionDuplicateNameExempt(sourceFile.file, false)
       });
     }
-    if (ts2.isClassDeclaration(statement) && statement.name && isExported(statement)) {
+    if (ts4.isClassDeclaration(statement) && statement.name && isExported(statement)) {
       declarations.push({
         name: statement.name.text,
         kind: "class",
@@ -779,9 +1050,9 @@ function getExportedFunctionLikes(sourceFile) {
         duplicateNameExempt: nameExempt || isConventionDuplicateNameExempt(sourceFile.file, isEnumClassStatement(sourceFile.sourceFile, statement))
       });
     }
-    if (ts2.isVariableStatement(statement) && isExported(statement)) {
+    if (ts4.isVariableStatement(statement) && isExported(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts2.isIdentifier(declaration.name) || !isFunctionLikeInitializer(declaration.initializer))
+        if (!ts4.isIdentifier(declaration.name) || !isFunctionLikeInitializer(declaration.initializer))
           continue;
         declarations.push({
           name: declaration.name.text,
@@ -820,14 +1091,14 @@ function isInLibModule(file) {
   return (segments[0] === "apps" || segments[0] === "libs") && segments.includes("lib");
 }
 function isEnumClassStatement(sourceFile, statement) {
-  if (!ts2.isClassDeclaration(statement))
+  if (!ts4.isClassDeclaration(statement))
     return false;
-  const heritageClause = statement.heritageClauses?.find((clause) => clause.token === ts2.SyntaxKind.ExtendsKeyword);
+  const heritageClause = statement.heritageClauses?.find((clause) => clause.token === ts4.SyntaxKind.ExtendsKeyword);
   const expression = heritageClause?.types[0]?.expression;
   return !!expression && expression.getText(sourceFile).startsWith("enumOf(");
 }
 function getExportedClassNames(sourceFile) {
-  return sourceFile.statements.filter((statement) => ts2.isClassDeclaration(statement) && !!statement.name).filter((statement) => isExported(statement)).map((statement) => statement.name.text);
+  return sourceFile.statements.filter((statement) => ts4.isClassDeclaration(statement) && !!statement.name).filter((statement) => isExported(statement)).map((statement) => statement.name.text);
 }
 function isComponentDeclarationFile(file) {
   if (!file.endsWith(".tsx"))
@@ -843,7 +1114,7 @@ function isComponentDeclarationFile(file) {
 function getComponentFileDeclarations(sourceFile) {
   const reExportedNames = new Set;
   for (const statement of sourceFile.statements) {
-    if (ts2.isExportDeclaration(statement) && statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+    if (ts4.isExportDeclaration(statement) && statement.exportClause && ts4.isNamedExports(statement.exportClause)) {
       for (const element of statement.exportClause.elements)
         reExportedNames.add((element.propertyName ?? element.name).text);
     }
@@ -853,19 +1124,19 @@ function getComponentFileDeclarations(sourceFile) {
     const isDefaultExport = isDefaultExportStatement(statement);
     const inlineExported = isExported(statement);
     const add = (name, kind, line) => declarations.push({ name, kind, line, exported: inlineExported || reExportedNames.has(name), isDefaultExport });
-    if (ts2.isInterfaceDeclaration(statement))
+    if (ts4.isInterfaceDeclaration(statement))
       add(statement.name.text, "interface", getLine(sourceFile, statement));
-    else if (ts2.isTypeAliasDeclaration(statement))
+    else if (ts4.isTypeAliasDeclaration(statement))
       add(statement.name.text, "type", getLine(sourceFile, statement));
-    else if (ts2.isEnumDeclaration(statement))
+    else if (ts4.isEnumDeclaration(statement))
       add(statement.name.text, "enum", getLine(sourceFile, statement));
-    else if (ts2.isFunctionDeclaration(statement) && statement.name)
+    else if (ts4.isFunctionDeclaration(statement) && statement.name)
       add(statement.name.text, "function", getLine(sourceFile, statement));
-    else if (ts2.isClassDeclaration(statement) && statement.name)
+    else if (ts4.isClassDeclaration(statement) && statement.name)
       add(statement.name.text, "class", getLine(sourceFile, statement));
-    else if (ts2.isVariableStatement(statement)) {
+    else if (ts4.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts2.isIdentifier(declaration.name))
+        if (!ts4.isIdentifier(declaration.name))
           continue;
         const kind = isFunctionLikeInitializer(declaration.initializer) ? "function" : "variable";
         add(declaration.name.text, kind, getLine(sourceFile, declaration));
@@ -877,15 +1148,15 @@ function getComponentFileDeclarations(sourceFile) {
 function getCompoundComponentNames(sourceFile) {
   const names = new Set;
   for (const statement of sourceFile.statements) {
-    if (!ts2.isExpressionStatement(statement))
+    if (!ts4.isExpressionStatement(statement))
       continue;
     const { expression } = statement;
-    if (!ts2.isBinaryExpression(expression) || expression.operatorToken.kind !== ts2.SyntaxKind.EqualsToken)
+    if (!ts4.isBinaryExpression(expression) || expression.operatorToken.kind !== ts4.SyntaxKind.EqualsToken)
       continue;
-    if (!ts2.isPropertyAccessExpression(expression.left) || !isPascalCaseName(expression.left.name.text))
+    if (!ts4.isPropertyAccessExpression(expression.left) || !isPascalCaseName(expression.left.name.text))
       continue;
     names.add(expression.left.name.text);
-    if (ts2.isIdentifier(expression.right) && isPascalCaseName(expression.right.text))
+    if (ts4.isIdentifier(expression.right) && isPascalCaseName(expression.right.text))
       names.add(expression.right.text);
   }
   return names;
@@ -905,9 +1176,9 @@ function isPascalCaseName(name) {
   return /^[A-Z]/.test(name) && !/^[A-Z0-9_]+$/.test(name);
 }
 function isDefaultExportStatement(statement) {
-  if (ts2.isExportAssignment(statement))
+  if (ts4.isExportAssignment(statement))
     return !statement.isExportEquals;
-  return !!(ts2.getCombinedModifierFlags(statement) & ts2.ModifierFlags.Default);
+  return !!(ts4.getCombinedModifierFlags(statement) & ts4.ModifierFlags.Default);
 }
 function getPlaceholderExportWarnings(sourceFile) {
   if (!sourceFile.file.endsWith("/index.ts") && !sourceFile.file.endsWith("/index.tsx"))
@@ -937,7 +1208,7 @@ function getDictionaryTextWarnings(sourceFile) {
 function getGlobalMutationWarnings(sourceFile) {
   const warnings = [];
   for (const statement of sourceFile.sourceFile.statements) {
-    if (ts2.isModuleDeclaration(statement) && statement.name.getText(sourceFile.sourceFile) === "global") {
+    if (ts4.isModuleDeclaration(statement) && statement.name.getText(sourceFile.sourceFile) === "global") {
       warnings.push({
         rule: "akan.file.global-declaration",
         scope: "file",
@@ -947,7 +1218,7 @@ function getGlobalMutationWarnings(sourceFile) {
         message: "Global declarations require an explicit low-level integration allowlist."
       });
     }
-    if (ts2.isInterfaceDeclaration(statement) && statement.name.text === "Window") {
+    if (ts4.isInterfaceDeclaration(statement) && statement.name.text === "Window") {
       warnings.push({
         rule: "akan.file.window-augmentation",
         scope: "file",
@@ -957,7 +1228,7 @@ function getGlobalMutationWarnings(sourceFile) {
         message: "Window augmentation should be isolated to approved browser integration files."
       });
     }
-    if (ts2.isExpressionStatement(statement) && statement.expression.getText(sourceFile.sourceFile).includes(".prototype.")) {
+    if (ts4.isExpressionStatement(statement) && statement.expression.getText(sourceFile.sourceFile).includes(".prototype.")) {
       warnings.push({
         rule: "akan.file.prototype-mutation",
         scope: "file",
@@ -975,23 +1246,23 @@ function getTopLevelDeclarations(sourceFile) {
 }
 function getTopLevelDeclaration(sourceFile, statement) {
   const line = getLine(sourceFile, statement);
-  if (ts2.isClassDeclaration(statement) && statement.name) {
+  if (ts4.isClassDeclaration(statement) && statement.name) {
     return [{ name: statement.name.text, kind: "class", line, exported: isExported(statement), node: statement }];
   }
-  if (ts2.isFunctionDeclaration(statement) && statement.name) {
+  if (ts4.isFunctionDeclaration(statement) && statement.name) {
     return [{ name: statement.name.text, kind: "function", line, exported: isExported(statement), node: statement }];
   }
-  if (ts2.isInterfaceDeclaration(statement)) {
+  if (ts4.isInterfaceDeclaration(statement)) {
     return [{ name: statement.name.text, kind: "interface", line, exported: isExported(statement), node: statement }];
   }
-  if (ts2.isTypeAliasDeclaration(statement)) {
+  if (ts4.isTypeAliasDeclaration(statement)) {
     return [{ name: statement.name.text, kind: "type", line, exported: isExported(statement), node: statement }];
   }
-  if (ts2.isEnumDeclaration(statement)) {
+  if (ts4.isEnumDeclaration(statement)) {
     return [{ name: statement.name.text, kind: "enum", line, exported: isExported(statement), node: statement }];
   }
-  if (ts2.isVariableStatement(statement)) {
-    return statement.declarationList.declarations.filter((declaration) => ts2.isIdentifier(declaration.name)).map((declaration) => ({
+  if (ts4.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.filter((declaration) => ts4.isIdentifier(declaration.name)).map((declaration) => ({
       name: declaration.name.text,
       kind: "variable",
       line: getLine(sourceFile, declaration),
@@ -999,7 +1270,7 @@ function getTopLevelDeclaration(sourceFile, statement) {
       node: statement
     }));
   }
-  if (ts2.isExportDeclaration(statement)) {
+  if (ts4.isExportDeclaration(statement)) {
     return [{ name: "export declaration", kind: "export", line, exported: true, node: statement }];
   }
   return [];
@@ -1024,9 +1295,9 @@ function isAllowedConstantDeclaration(modelName, declaration) {
     return false;
   if ([`${modelName}Input`, `${modelName}Object`, modelName, `Light${modelName}`, `${modelName}Insight`].includes(declaration.name))
     return true;
-  if (!ts2.isClassDeclaration(declaration.node))
+  if (!ts4.isClassDeclaration(declaration.node))
     return false;
-  const heritageClause = declaration.node.heritageClauses?.find((clause) => clause.token === ts2.SyntaxKind.ExtendsKeyword);
+  const heritageClause = declaration.node.heritageClauses?.find((clause) => clause.token === ts4.SyntaxKind.ExtendsKeyword);
   const expression = heritageClause?.types[0]?.expression;
   return !!expression && expression.getText().startsWith("enumOf(");
 }
@@ -1092,13 +1363,13 @@ function getModuleInfo(file) {
   return { moduleName, fileName, kind: "database" };
 }
 function isExportedConst(declaration) {
-  return declaration.exported && ts2.isVariableStatement(declaration.node) && (declaration.node.declarationList.flags & ts2.NodeFlags.Const) !== 0;
+  return declaration.exported && ts4.isVariableStatement(declaration.node) && (declaration.node.declarationList.flags & ts4.NodeFlags.Const) !== 0;
 }
 function isExported(node) {
-  return !!ts2.getCombinedModifierFlags(node) && !!(ts2.getCombinedModifierFlags(node) & ts2.ModifierFlags.Export);
+  return !!ts4.getCombinedModifierFlags(node) && !!(ts4.getCombinedModifierFlags(node) & ts4.ModifierFlags.Export);
 }
 function isFunctionLikeInitializer(node) {
-  return !!node && (ts2.isArrowFunction(node) || ts2.isFunctionExpression(node));
+  return !!node && (ts4.isArrowFunction(node) || ts4.isFunctionExpression(node));
 }
 function getBodyFingerprint(sourceFile, node) {
   if (!node)
@@ -1120,7 +1391,7 @@ async function isDirectory(absolutePath) {
   }
 }
 function getScriptKind(file) {
-  return file.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS;
+  return file.endsWith(".tsx") ? ts4.ScriptKind.TSX : ts4.ScriptKind.TS;
 }
 function getLine(sourceFile, node) {
   return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
@@ -1141,7 +1412,7 @@ function toPascalCase(value) {
   return value.replace(/(^|[-_./])([a-zA-Z0-9])/g, (_, __, char) => char.toUpperCase()).replace(/[-_./]/g, "");
 }
 function toPosix(value) {
-  return value.split(path.sep).join("/");
+  return value.split(path3.sep).join("/");
 }
 function groupBy(items, getKey) {
   const grouped = new Map;