@akanjs/cli 2.3.9-rc.6 → 2.3.9-rc.8

package/incrementalBuilder.proc.js

@@ -2,7 +2,7 @@
 var __require = import.meta.require;
 
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
-import path40 from "path";
+import path42 from "path";
 
 // pkgs/@akanjs/devkit/aiEditor.ts
 import { input, select } from "@inquirer/prompts";
@@ -4777,8 +4777,8 @@ class AkanAppHost {
 }
 // pkgs/@akanjs/devkit/akanContext.ts
 import { readdir } from "fs/promises";
-import path10 from "path";
-import { capitalize as capitalize4 } from "akanjs/common";
+import path11 from "path";
+import { capitalize as capitalize3 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `
@@ -4798,6 +4798,24 @@ var uniqueBy = (values, key) => {
 var compactDiagnostics = (diagnostics) => diagnostics.filter((diagnostic) => !!diagnostic);
 
 // pkgs/@akanjs/devkit/workflow/artifacts.ts
+var sourceChangeBlocked = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "source-change" || !diagnostic.failureScope || diagnostic.failureScope === "unknown"));
+var inferNextActionCode = (action, diagnostics) => {
+  if (action.action)
+    return action.action;
+  if (sourceChangeBlocked(diagnostics) && action.command.startsWith("akan workflow explain"))
+    return "blocked";
+  if (action.command.startsWith("akan workflow repair"))
+    return "repair";
+  if (action.command.startsWith("akan workflow explain"))
+    return "manual-review";
+  if (action.command.startsWith("akan "))
+    return "validate";
+  return "answer";
+};
+var nextActionPriority = (action, diagnostics) => {
+  const priority = sourceChangeBlocked(diagnostics) ? { blocked: 0, repair: 1, "manual-review": 2, validate: 3, answer: 4 } : { "manual-review": 0, validate: 1, repair: 2, blocked: 3, answer: 4 };
+  return priority[action.action ?? "answer"];
+};
 var createWorkflowApplyReport = ({
   workflow,
   mode,
@@ -4813,11 +4831,18 @@ var createWorkflowApplyReport = ({
   plan
 }) => {
   const validationCommands = recommendedValidationCommands ?? commands;
-  const orderedNextActions = uniqueBy(nextActions, (action) => action.command).sort((left, right) => {
-    const leftRepair = left.command.startsWith("akan workflow explain") ? 0 : 1;
-    const rightRepair = right.command.startsWith("akan workflow explain") ? 0 : 1;
-    return leftRepair - rightRepair;
-  });
+  const nextActionsWithIntent = nextActions.map((action) => ({
+    ...action,
+    action: inferNextActionCode(action, diagnostics)
+  }));
+  if (sourceChangeBlocked(diagnostics) && !nextActionsWithIntent.some((action) => action.action === "blocked")) {
+    nextActionsWithIntent.unshift({
+      command: `akan workflow explain ${workflow}`,
+      reason: "Review source-change blockers before running validation.",
+      action: "blocked"
+    });
+  }
+  const orderedNextActions = uniqueBy(nextActionsWithIntent, (action) => action.command).sort((left, right) => nextActionPriority(left, diagnostics) - nextActionPriority(right, diagnostics));
   return {
     schemaVersion: 1,
     workflow,
@@ -5054,7 +5079,14 @@ var createRepairReport = ({
   ...syncedAt ? { syncedAt } : {}
 });
 // pkgs/@akanjs/devkit/workflow/executor.ts
-import { capitalize as capitalize2 } from "akanjs/common";
+import ts6 from "typescript";
+
+// pkgs/@akanjs/devkit/workflow/moduleIndex.ts
+import { access } from "fs/promises";
+import path10 from "path";
+import ts5 from "typescript";
+
+// pkgs/@akanjs/devkit/workflow/source.ts
 import ts4 from "typescript";
 
 // pkgs/@akanjs/devkit/workflow/primitive.ts
@@ -5107,7 +5139,7 @@ var sourceFile = (sys2, path10, action, reason) => ({
   action,
   reason
 });
-var moduleComponentName = (moduleName) => `${moduleName.slice(0, 1).toUpperCase()}${moduleName.slice(1)}`;
+var moduleComponentName = (moduleName) => moduleName.replace(/[-_]+/g, " ").replace(/(?:^|\s+)([a-zA-Z0-9])/g, (_, char) => char.toUpperCase()).replace(/\s+/g, "");
 var moduleSourcePaths = (moduleName) => {
   const componentName = moduleComponentName(moduleName);
   return {
@@ -5210,12 +5242,13 @@ var normalizeFieldType = (typeName) => {
 var ensureBaseTypeImport = (content, typeName) => {
   if (typeName !== "Int" && typeName !== "Float")
     return content;
-  if (new RegExp(`import \\{[^}]*\\b${typeName}\\b[^}]*\\} from "akanjs/base";`).test(content))
-    return content;
-  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
+  const source = sourceFileFor("constant.ts", content);
+  const baseImport = findNamedImport(source, "akanjs/base");
   if (baseImport) {
-    const names = baseImport[1].split(",").map((name) => name.trim()).filter(Boolean);
-    return content.replace(baseImport[0], `import { ${[...names, typeName].sort().join(", ")} } from "akanjs/base";`);
+    if (baseImport.names.includes(typeName))
+      return content;
+    const nextNames = [...baseImport.names, typeName].sort();
+    return spliceText(content, baseImport.namedBindingsStart, baseImport.namedBindingsEnd, `{ ${nextNames.join(", ")} }`);
   }
   return `import { ${typeName} } from "akanjs/base";
 ${content}`;
@@ -5344,47 +5377,350 @@ var fieldExpression = (typeName, defaultValue, options = {}) => {
   const defaultOption = defaultExpression ? `, { default: ${defaultExpression} }` : "";
   return `${options.builderName ?? "field"}(${typeExpression}${defaultOption})`;
 };
-var viaBuilderParameterName = (content, className) => {
-  const classIndex = content.indexOf(`export class ${className} extends via`);
-  if (classIndex < 0)
+var fieldOrderingPriority = [
+  "id",
+  "name",
+  "title",
+  "status",
+  "category",
+  "description",
+  "content",
+  "startAt",
+  "dueAt",
+  "endAt",
+  "createdAt",
+  "updatedAt"
+];
+var sourceFileFor = (fileName, content, scriptKind = ts4.ScriptKind.TS) => ts4.createSourceFile(fileName, content, ts4.ScriptTarget.Latest, true, scriptKind);
+var hasParseDiagnostics = (source) => (source.parseDiagnostics ?? []).length > 0;
+var spliceText = (content, start, end, replacement) => `${content.slice(0, start)}${replacement}${content.slice(end)}`;
+var lineStartAt = (content, position) => content.lastIndexOf(`
+`, Math.max(0, position - 1)) + 1;
+var lineEndAt = (content, position) => {
+  const end = content.indexOf(`
+`, position);
+  return end < 0 ? content.length : end + 1;
+};
+var lineIndentAt = (content, position) => /^[ \t]*/.exec(content.slice(lineStartAt(content, position)))?.[0] ?? "";
+var nodeName = (node) => {
+  if (!node)
+    return null;
+  if (ts4.isIdentifier(node) || ts4.isStringLiteral(node) || ts4.isNumericLiteral(node))
+    return node.text;
+  return null;
+};
+var propertyName = (node) => ts4.isPropertyAssignment(node) || ts4.isShorthandPropertyAssignment(node) || ts4.isMethodDeclaration(node) ? nodeName(node.name) : null;
+var expressionName = (expression) => {
+  if (ts4.isIdentifier(expression))
+    return expression.text;
+  if (ts4.isPropertyAccessExpression(expression))
+    return expression.name.text;
+  if (ts4.isCallExpression(expression))
+    return expressionName(expression.expression);
+  if (ts4.isAsExpression(expression))
+    return expressionName(expression.expression);
+  return null;
+};
+var firstObjectReturnedByArrow = (node) => {
+  if (!ts4.isArrowFunction(node) && !ts4.isFunctionExpression(node))
+    return null;
+  if (ts4.isObjectLiteralExpression(node.body))
+    return node.body;
+  if (ts4.isParenthesizedExpression(node.body) && ts4.isObjectLiteralExpression(node.body.expression)) {
+    return node.body.expression;
+  }
+  if (!ts4.isBlock(node.body))
+    return null;
+  for (const statement of node.body.statements) {
+    if (ts4.isReturnStatement(statement) && statement.expression && ts4.isObjectLiteralExpression(statement.expression)) {
+      return statement.expression;
+    }
+  }
+  return null;
+};
+var isViaCall = (expression) => ts4.isCallExpression(expression) && expressionName(expression.expression) === "via";
+var heritageCall = (node) => {
+  const heritage = node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [];
+  const expression = heritage.find((clause) => isViaCall(clause.expression))?.expression;
+  return expression && ts4.isCallExpression(expression) ? expression : null;
+};
+var callExpressionName = (node) => ts4.isPropertyAccessExpression(node.expression) ? node.expression.name.text : expressionName(node.expression);
+var locatedObject = (source, objectLiteral) => ({
+  objectStart: objectLiteral.getStart(source),
+  objectEnd: objectLiteral.getEnd(),
+  fields: objectLiteral.properties.map((property) => {
+    const name = propertyName(property);
+    if (!name)
+      return null;
+    return {
+      name,
+      start: property.getStart(source),
+      fullStart: property.getFullStart(),
+      end: property.getEnd()
+    };
+  }).filter((field) => field !== null)
+});
+var findConstantInputObject = (source, className) => {
+  let locator = null;
+  const visit = (node) => {
+    if (locator)
+      return;
+    if (!ts4.isClassDeclaration(node) || node.name?.text !== className) {
+      ts4.forEachChild(node, visit);
+      return;
+    }
+    const viaCall = heritageCall(node);
+    const callback = viaCall?.arguments.find((arg) => ts4.isArrowFunction(arg) || ts4.isFunctionExpression(arg));
+    const objectLiteral = callback ? firstObjectReturnedByArrow(callback) : null;
+    if (objectLiteral)
+      locator = locatedObject(source, objectLiteral);
+  };
+  ts4.forEachChild(source, visit);
+  return locator;
+};
+var chainMethodsForCall = (node) => {
+  if (ts4.isAsExpression(node) || ts4.isParenthesizedExpression(node))
+    return chainMethodsForCall(node.expression);
+  if (!ts4.isCallExpression(node))
+    return [];
+  if (ts4.isPropertyAccessExpression(node.expression)) {
+    return [...chainMethodsForCall(node.expression.expression), node.expression.name.text];
+  }
+  const name = expressionName(node.expression);
+  return name ? [name] : [];
+};
+var outermostFluentCall = (node) => {
+  let current = node;
+  while (ts4.isPropertyAccessExpression(current.parent) && current.parent.expression === current && ts4.isCallExpression(current.parent.parent) && current.parent.parent.expression === current.parent) {
+    current = current.parent.parent;
+  }
+  return current;
+};
+var protectedDictionaryChainOrder = ["model", "slice", "enum", "error", "translate"];
+var dictionaryChainOrderValid = (chainMethods) => {
+  const protectedOrder = new Map(protectedDictionaryChainOrder.map((method, index) => [method, index]));
+  let lastOrder = -1;
+  for (const method of chainMethods) {
+    const order = protectedOrder.get(method);
+    if (order === undefined)
+      continue;
+    if (order < lastOrder)
+      return false;
+    lastOrder = order;
+  }
+  return true;
+};
+var findDictionaryModelObject = (source, moduleClassName) => {
+  let locator = null;
+  const visit = (node) => {
+    if (locator)
+      return;
+    if (!ts4.isCallExpression(node) || callExpressionName(node) !== "model") {
+      ts4.forEachChild(node, visit);
+      return;
+    }
+    const typeArgument = node.typeArguments?.[0];
+    if (!typeArgument || typeArgument.getText(source) !== moduleClassName) {
+      ts4.forEachChild(node, visit);
+      return;
+    }
+    const callback = node.arguments.find((arg) => ts4.isArrowFunction(arg) || ts4.isFunctionExpression(arg));
+    const objectLiteral = callback ? firstObjectReturnedByArrow(callback) : null;
+    if (objectLiteral) {
+      locator = {
+        ...locatedObject(source, objectLiteral),
+        chainMethods: chainMethodsForCall(outermostFluentCall(node))
+      };
+    }
+  };
+  ts4.forEachChild(source, visit);
+  return locator;
+};
+var findLightProjectionArray = (source, moduleClassName) => {
+  let locator = null;
+  const visit = (node) => {
+    if (locator)
+      return;
+    if (!ts4.isClassDeclaration(node) || node.name?.text !== `Light${moduleClassName}`) {
+      ts4.forEachChild(node, visit);
+      return;
+    }
+    const viaCall = heritageCall(node);
+    const projectionArg = viaCall?.arguments.find((arg) => {
+      const expression = ts4.isAsExpression(arg) ? arg.expression : arg;
+      return ts4.isArrayLiteralExpression(expression);
+    });
+    const arrayLiteral = projectionArg ? ts4.isAsExpression(projectionArg) ? projectionArg.expression : projectionArg : null;
+    if (!projectionArg || !arrayLiteral || !ts4.isArrayLiteralExpression(arrayLiteral))
+      return;
+    locator = {
+      projectionStart: projectionArg.getStart(source),
+      projectionEnd: projectionArg.getEnd(),
+      fields: arrayLiteral.elements.map((element) => ts4.isStringLiteralLike(element) ? element.text : null).filter((field) => field !== null)
+    };
+  };
+  ts4.forEachChild(source, visit);
+  return locator;
+};
+var findNamedImport = (source, moduleSpecifier) => {
+  for (const statement of source.statements) {
+    if (!ts4.isImportDeclaration(statement) || !ts4.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (statement.moduleSpecifier.text !== moduleSpecifier)
+      continue;
+    const namedBindings = statement.importClause?.namedBindings;
+    if (!namedBindings || !ts4.isNamedImports(namedBindings))
+      continue;
+    return {
+      names: namedBindings.elements.map((element) => element.name.text),
+      namedBindingsStart: namedBindings.getStart(source),
+      namedBindingsEnd: namedBindings.getEnd()
+    };
+  }
+  return null;
+};
+var fieldExpressionBuilder = (property) => {
+  if (!ts4.isPropertyAssignment(property))
+    return null;
+  const initializer = ts4.isAsExpression(property.initializer) ? property.initializer.expression : property.initializer;
+  if (!ts4.isCallExpression(initializer))
     return null;
-  const signature = content.slice(classIndex, content.indexOf("=>", classIndex));
-  return /via\(\(\s*([A-Za-z_$][\w$]*)\s*\)/.exec(signature)?.[1] ?? null;
+  return expressionName(initializer.expression);
+};
+var priorityOf = (fieldName) => {
+  const priority = fieldOrderingPriority.indexOf(fieldName);
+  return priority < 0 ? null : priority;
+};
+var insertionIndexForFieldOrder = (fieldNames, newFieldName) => {
+  const newPriority = priorityOf(newFieldName);
+  if (newPriority !== null) {
+    const greaterPriorityIndex = fieldNames.findIndex((name) => {
+      const existingPriority = priorityOf(name);
+      return existingPriority !== null && existingPriority > newPriority;
+    });
+    if (greaterPriorityIndex >= 0)
+      return greaterPriorityIndex;
+    const lastPriorityIndex = fieldNames.reduce((lastIndex, name, index) => {
+      const existingPriority = priorityOf(name);
+      return existingPriority !== null ? index : lastIndex;
+    }, -1);
+    return lastPriorityIndex + 1;
+  }
+  const lastNonPriorityIndex = fieldNames.reduce((lastIndex, name, index) => priorityOf(name) === null ? index : lastIndex, -1);
+  return lastNonPriorityIndex >= 0 ? lastNonPriorityIndex + 1 : fieldNames.length;
+};
+var insertOrderedFieldLine = (content, locator, fieldName, line, options) => {
+  if (locator.fields.some((field) => field.name === fieldName))
+    return content;
+  const insertIndex = insertionIndexForFieldOrder(locator.fields.map((field) => field.name), fieldName);
+  const formattedLine = line.trim();
+  if (locator.fields.length === 0) {
+    return spliceText(content, locator.objectStart, locator.objectEnd, `{
+${options.fieldIndent}${formattedLine}
+${options.closingIndent}}`);
+  }
+  const beforeField = locator.fields[insertIndex];
+  if (beforeField) {
+    const leadingComments = ts4.getLeadingCommentRanges(content, beforeField.fullStart) ?? [];
+    const insertAt2 = lineStartAt(content, leadingComments[0]?.pos ?? beforeField.start);
+    const indent2 = lineIndentAt(content, beforeField.start) || options.fieldIndent;
+    return spliceText(content, insertAt2, insertAt2, `${indent2}${formattedLine}
+`);
+  }
+  const afterField = locator.fields[locator.fields.length - 1];
+  const insertAt = lineEndAt(content, afterField.end);
+  const indent = lineIndentAt(content, afterField.start) || options.fieldIndent;
+  return spliceText(content, insertAt, insertAt, `${indent}${formattedLine}
+`);
+};
+var viaBuilderParameterName = (content, className) => {
+  const source = sourceFileFor("constant.ts", content);
+  let builderName = null;
+  const visit = (node) => {
+    if (builderName !== null)
+      return;
+    if (!ts4.isClassDeclaration(node) || node.name?.text !== className) {
+      ts4.forEachChild(node, visit);
+      return;
+    }
+    const viaCall = heritageCall(node);
+    const callback = viaCall?.arguments.find((arg) => ts4.isArrowFunction(arg) || ts4.isFunctionExpression(arg));
+    if (callback && (ts4.isArrowFunction(callback) || ts4.isFunctionExpression(callback))) {
+      builderName = nodeName(callback.parameters[0]?.name);
+    }
+  };
+  ts4.forEachChild(source, visit);
+  return builderName;
+};
+var inspectConstantStructure = (content, className, moduleClassName) => {
+  const source = sourceFileFor("constant.ts", content);
+  const inputObject = findConstantInputObject(source, className);
+  const lightProjection = findLightProjectionArray(source, moduleClassName);
+  const baseImport = findNamedImport(source, "akanjs/base");
+  const fields = [];
+  if (inputObject) {
+    const visit = (node) => {
+      if (!ts4.isClassDeclaration(node) || node.name?.text !== className) {
+        ts4.forEachChild(node, visit);
+        return;
+      }
+      const viaCall = heritageCall(node);
+      const callback = viaCall?.arguments.find((arg) => ts4.isArrowFunction(arg) || ts4.isFunctionExpression(arg));
+      const objectLiteral = callback ? firstObjectReturnedByArrow(callback) : null;
+      if (!objectLiteral)
+        return;
+      fields.push(...objectLiteral.properties.map((property) => {
+        const name = propertyName(property);
+        if (!name)
+          return null;
+        return { name, expressionBuilder: fieldExpressionBuilder(property) };
+      }).filter((field) => field !== null));
+    };
+    ts4.forEachChild(source, visit);
+  }
+  return {
+    parseValid: !hasParseDiagnostics(source),
+    inputObjectFound: inputObject !== null,
+    builderName: viaBuilderParameterName(content, className),
+    fields,
+    lightProjectionFields: lightProjection?.fields ?? [],
+    baseImports: baseImport?.names ?? []
+  };
+};
+var inspectDictionaryStructure = (content, moduleClassName) => {
+  const source = sourceFileFor("dictionary.ts", content);
+  const modelObject = findDictionaryModelObject(source, moduleClassName);
+  return {
+    parseValid: !hasParseDiagnostics(source),
+    modelObjectFound: modelObject !== null,
+    chainOrderValid: modelObject ? dictionaryChainOrderValid(modelObject.chainMethods) : false,
+    chainMethods: modelObject?.chainMethods ?? [],
+    fields: modelObject?.fields.map((field) => field.name) ?? []
+  };
 };
 var insertIntoObject = (content, className, line) => {
-  const classIndex = content.indexOf(`export class ${className} extends via`);
-  if (classIndex < 0)
+  const fieldName = /^([A-Za-z_$][\w$]*)\s*:/.exec(line.trim())?.[1];
+  if (!fieldName)
     return null;
-  const objectEndIndex = content.indexOf("}))", classIndex);
-  if (objectEndIndex < 0)
+  const source = sourceFileFor("constant.ts", content);
+  const locator = findConstantInputObject(source, className);
+  if (!locator)
     return null;
-  const prefix = content.slice(0, objectEndIndex);
-  const suffix = content.slice(objectEndIndex);
-  const insertion = prefix.endsWith(`
-`) ? `  ${line}
-` : `
-  ${line}
-`;
-  return `${prefix}${insertion}${suffix}`;
+  return insertOrderedFieldLine(content, locator, fieldName, line, { fieldIndent: "  ", closingIndent: "" });
 };
 var insertLightProjectionField = (content, moduleClassName, fieldName) => {
-  const classIndex = content.indexOf(`export class Light${moduleClassName} extends via`);
-  if (classIndex < 0)
+  const source = sourceFileFor("constant.ts", content);
+  const locator = findLightProjectionArray(source, moduleClassName);
+  if (!locator)
     return null;
-  const arrayMatch = /\[([\s\S]*?)\]\s+as const/.exec(content.slice(classIndex));
-  if (!arrayMatch || arrayMatch.index === undefined)
-    return null;
-  const arrayStart = classIndex + arrayMatch.index;
-  const arrayEnd = arrayStart + arrayMatch[0].length;
-  const fields = [...arrayMatch[1].matchAll(/"([^"]+)"/g)].map((match) => match[1]).filter(Boolean);
-  if (fields.includes(fieldName))
+  if (locator.fields.includes(fieldName))
     return content;
-  const nextFields = [...fields, fieldName];
+  const nextFields = [...locator.fields, fieldName];
   const nextArray = nextFields.length === 0 ? "[] as const" : `[
 ${nextFields.map((field) => `  ${JSON.stringify(field)},`).join(`
 `)}
 ] as const`;
-  return `${content.slice(0, arrayStart)}${nextArray}${content.slice(arrayEnd)}`;
+  return spliceText(content, locator.projectionStart, locator.projectionEnd, nextArray);
 };
 var insertTemplateField = ({
   content,
@@ -5437,69 +5773,32 @@ ${values.map((value) => `  ${JSON.stringify(value)},`).join(`
 ${enumClass}`;
   return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
 };
-var findMatchingBrace = (content, openIndex) => {
-  let depth = 0;
-  let quote = null;
-  let escaped = false;
-  for (let index = openIndex;index < content.length; index++) {
-    const char = content[index];
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (char === "\\") {
-        escaped = true;
-        continue;
-      }
-      if (char === quote)
-        quote = null;
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "{")
-      depth += 1;
-    if (char === "}") {
-      depth -= 1;
-      if (depth === 0)
-        return index;
-    }
-  }
-  return -1;
-};
 var dictionaryModelFieldLine = (fieldName) => {
   const label = bilingualLabelForField(fieldName);
   const desc = bilingualDescriptionForField(fieldName);
   return `${fieldName}: t([${JSON.stringify(label.en)}, ${JSON.stringify(label.ko)}]).desc([${JSON.stringify(desc.en)}, ${JSON.stringify(desc.ko)}]),`;
 };
 var insertDictionaryModelField = (content, moduleClassName, fieldName) => {
-  if (new RegExp(`\\b${fieldName}\\s*:`).test(content))
-    return content;
-  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => (`);
-  if (modelIndex < 0)
-    return null;
-  const objectStartIndex = content.indexOf("{", modelIndex);
-  if (objectStartIndex < 0)
+  const source = sourceFileFor("dictionary.ts", content);
+  const locator = findDictionaryModelObject(source, moduleClassName);
+  if (!locator)
     return null;
-  const objectEndIndex = findMatchingBrace(content, objectStartIndex);
-  if (objectEndIndex < 0)
-    return null;
-  const fieldLine = dictionaryModelFieldLine(fieldName);
-  const body = content.slice(objectStartIndex + 1, objectEndIndex);
-  if (body.trim().length === 0) {
-    return `${content.slice(0, objectStartIndex + 1)}
-    ${fieldLine}
-  ${content.slice(objectEndIndex)}`;
-  }
-  const insertion = body.endsWith(`
-`) ? `    ${fieldLine}
-` : `
-    ${fieldLine}
-`;
-  return `${content.slice(0, objectEndIndex)}${insertion}${content.slice(objectEndIndex)}`;
+  return insertOrderedFieldLine(content, locator, fieldName, dictionaryModelFieldLine(fieldName), {
+    fieldIndent: "    ",
+    closingIndent: "  "
+  });
+};
+var hasConstantInputField = (content, className, fieldName) => {
+  const source = sourceFileFor("constant.ts", content);
+  if (hasParseDiagnostics(source))
+    return false;
+  return findConstantInputObject(source, className)?.fields.some((field) => field.name === fieldName) ?? false;
+};
+var hasDictionaryModelField = (content, moduleClassName, fieldName) => {
+  const source = sourceFileFor("dictionary.ts", content);
+  if (hasParseDiagnostics(source))
+    return false;
+  return findDictionaryModelObject(source, moduleClassName)?.fields.some((field) => field.name === fieldName) ?? false;
 };
 var ensureConstantTypeImport = (content, constantPath, typeName) => {
   if (new RegExp(`import type \\{[^}]*\\b${typeName}\\b[^}]*\\} from "${constantPath}";`).test(content))
@@ -5529,6 +5828,401 @@ ${values.map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${
 };
 var parseValues = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
 
+// pkgs/@akanjs/devkit/workflow/moduleIndex.ts
+var indexFileKinds = [
+  "abstract",
+  "constant",
+  "dictionary",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+var sourceText = async (filePath) => {
+  try {
+    return await Bun.file(filePath).text();
+  } catch {
+    return null;
+  }
+};
+var fileExists = async (filePath) => {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var sourceFileFor2 = (filePath, content) => ts5.createSourceFile(filePath, content, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
+var parseDiagnosticsFor = (source, filePath) => {
+  const parseDiagnostics = source.parseDiagnostics ?? [];
+  return parseDiagnostics.map((diagnostic) => ({
+    severity: "error",
+    code: "module-index-typescript-parse-error",
+    message: `TypeScript parse diagnostic TS${diagnostic.code} in ${filePath}: ${ts5.flattenDiagnosticMessageText(diagnostic.messageText, `
+`)}`,
+    context: { target: filePath, paths: [filePath] }
+  }));
+};
+var spanFor = (source, file, node) => {
+  const startOffset = node.getStart(source);
+  const endOffset = node.getEnd();
+  const start = source.getLineAndCharacterOfPosition(startOffset);
+  const end = source.getLineAndCharacterOfPosition(endOffset);
+  return {
+    file,
+    startLine: start.line + 1,
+    endLine: end.line + 1,
+    startOffset,
+    endOffset
+  };
+};
+var nodeName2 = (node) => {
+  if (!node)
+    return null;
+  if (ts5.isIdentifier(node) || ts5.isStringLiteral(node) || ts5.isNumericLiteral(node))
+    return node.text;
+  return null;
+};
+var propertyName2 = (node) => ts5.isPropertyAssignment(node) || ts5.isShorthandPropertyAssignment(node) || ts5.isMethodDeclaration(node) ? nodeName2(node.name) : null;
+var expressionName2 = (expression) => {
+  if (ts5.isIdentifier(expression))
+    return expression.text;
+  if (ts5.isPropertyAccessExpression(expression))
+    return expression.name.text;
+  if (ts5.isCallExpression(expression))
+    return expressionName2(expression.expression);
+  if (ts5.isAsExpression(expression))
+    return expressionName2(expression.expression);
+  return null;
+};
+var expressionSummary = (expression) => {
+  if (ts5.isAsExpression(expression))
+    return expressionSummary(expression.expression);
+  if (ts5.isIdentifier(expression) || ts5.isPropertyAccessExpression(expression))
+    return expressionName2(expression) ?? "expression";
+  if (ts5.isArrayLiteralExpression(expression))
+    return "array-literal";
+  if (ts5.isObjectLiteralExpression(expression))
+    return "object-literal";
+  if (ts5.isStringLiteralLike(expression))
+    return "string-literal";
+  if (ts5.isNumericLiteral(expression))
+    return "numeric-literal";
+  if (expression.kind === ts5.SyntaxKind.TrueKeyword || expression.kind === ts5.SyntaxKind.FalseKeyword) {
+    return "boolean-literal";
+  }
+  if (ts5.isCallExpression(expression)) {
+    const callee = expressionName2(expression.expression);
+    return callee ? `${callee}(...)` : "call-expression";
+  }
+  return ts5.SyntaxKind[expression.kind] ?? "expression";
+};
+var typeSummaryForInitializer = (initializer) => {
+  if (!initializer)
+    return;
+  const expression = ts5.isAsExpression(initializer) ? initializer.expression : initializer;
+  if (!ts5.isCallExpression(expression))
+    return expressionSummary(expression);
+  const callee = expressionName2(expression.expression);
+  const firstArg = expression.arguments[0];
+  const argSummary = firstArg ? expressionSummary(firstArg) : "";
+  return [callee, argSummary ? `(${argSummary})` : ""].filter(Boolean).join("");
+};
+var fieldsFromObject = (source, file, objectLiteral, kind) => objectLiteral.properties.map((property, index) => {
+  const name = propertyName2(property);
+  if (!name)
+    return null;
+  const initializer = ts5.isPropertyAssignment(property) ? property.initializer : undefined;
+  return {
+    name,
+    kind,
+    order: index,
+    ...initializer ? { typeSummary: typeSummaryForInitializer(initializer) } : {},
+    sourceSpan: spanFor(source, file, property)
+  };
+}).filter((field) => field !== null);
+var firstObjectReturnedByArrow2 = (node) => {
+  if (!ts5.isArrowFunction(node) && !ts5.isFunctionExpression(node))
+    return null;
+  if (ts5.isObjectLiteralExpression(node.body))
+    return node.body;
+  if (ts5.isParenthesizedExpression(node.body) && ts5.isObjectLiteralExpression(node.body.expression)) {
+    return node.body.expression;
+  }
+  if (!ts5.isBlock(node.body))
+    return null;
+  for (const statement of node.body.statements) {
+    if (ts5.isReturnStatement(statement) && statement.expression && ts5.isObjectLiteralExpression(statement.expression)) {
+      return statement.expression;
+    }
+  }
+  return null;
+};
+var isViaCall2 = (expression) => ts5.isCallExpression(expression) && expressionName2(expression.expression) === "via";
+var heritageCall2 = (node) => {
+  const heritage = node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [];
+  const expression = heritage.find((clause) => isViaCall2(clause.expression))?.expression;
+  return expression && ts5.isCallExpression(expression) ? expression : null;
+};
+var parseConstantIndex = (filePath, content, moduleClassName) => {
+  const source = sourceFileFor2(filePath, content);
+  const diagnostics = parseDiagnosticsFor(source, filePath);
+  const inputClassName = `${moduleClassName}Input`;
+  let inputClass = null;
+  let inputViaFound = false;
+  let inputBuilderFound = false;
+  let inputBuilderObjectFound = false;
+  let builderName = null;
+  let fields = [];
+  let lightProjection;
+  const visit = (node) => {
+    if (!ts5.isClassDeclaration(node) || !node.name) {
+      ts5.forEachChild(node, visit);
+      return;
+    }
+    const className = node.name.text;
+    const viaCall = heritageCall2(node);
+    if (className === inputClassName) {
+      inputClass = node;
+      if (!viaCall)
+        return;
+      inputViaFound = true;
+      const callback = viaCall.arguments.find((arg) => ts5.isArrowFunction(arg) || ts5.isFunctionExpression(arg));
+      if (callback && (ts5.isArrowFunction(callback) || ts5.isFunctionExpression(callback))) {
+        inputBuilderFound = true;
+        builderName = nodeName2(callback.parameters[0]?.name) ?? null;
+        const objectLiteral = firstObjectReturnedByArrow2(callback);
+        if (objectLiteral) {
+          inputBuilderObjectFound = true;
+          fields = fieldsFromObject(source, filePath, objectLiteral, "constant");
+        }
+      }
+    }
+    if (!viaCall)
+      return;
+    if (className === `Light${moduleClassName}`) {
+      const projectionArg = viaCall.arguments.find((arg) => {
+        const expression = ts5.isAsExpression(arg) ? arg.expression : arg;
+        return ts5.isArrayLiteralExpression(expression);
+      });
+      const arrayLiteral = projectionArg ? ts5.isAsExpression(projectionArg) ? projectionArg.expression : projectionArg : null;
+      if (arrayLiteral && ts5.isArrayLiteralExpression(arrayLiteral)) {
+        lightProjection = {
+          className,
+          sourceSpan: spanFor(source, filePath, arrayLiteral),
+          fields: arrayLiteral.elements.map((element, order) => ts5.isStringLiteralLike(element) ? {
+            name: element.text,
+            kind: "lightProjection",
+            order,
+            typeSummary: "string-literal",
+            sourceSpan: spanFor(source, filePath, element)
+          } : null).filter((field) => field !== null)
+        };
+      }
+    }
+  };
+  ts5.forEachChild(source, visit);
+  if (!inputClass) {
+    diagnostics.push({
+      severity: "error",
+      code: "module-index-constant-input-missing",
+      message: `Constant input class ${inputClassName} was not found in ${filePath}.`,
+      context: { target: inputClassName, paths: [filePath] }
+    });
+  } else if (!inputViaFound) {
+    diagnostics.push({
+      severity: "error",
+      code: "module-index-constant-via-missing",
+      message: `Constant input class ${inputClassName} does not extend via(...) in ${filePath}.`,
+      context: { target: inputClassName, paths: [filePath] }
+    });
+  } else if (!inputBuilderFound) {
+    diagnostics.push({
+      severity: "error",
+      code: "module-index-constant-builder-missing",
+      message: `Constant input class ${inputClassName} does not provide a via(...) builder callback in ${filePath}.`,
+      context: { target: inputClassName, paths: [filePath] }
+    });
+  } else if (!inputBuilderObjectFound) {
+    diagnostics.push({
+      severity: "error",
+      code: "module-index-constant-builder-object-missing",
+      message: `Constant input class ${inputClassName} builder does not return an object literal in ${filePath}.`,
+      context: { target: inputClassName, paths: [filePath] }
+    });
+  }
+  return {
+    index: {
+      path: filePath,
+      inputClassName,
+      builderName,
+      fields,
+      ...lightProjection ? { lightProjection } : {},
+      ...inputClass ? { sourceSpan: spanFor(source, filePath, inputClass) } : {}
+    },
+    diagnostics
+  };
+};
+var callExpressionName2 = (node) => ts5.isPropertyAccessExpression(node.expression) ? node.expression.name.text : expressionName2(node.expression);
+var parseDictionaryIndex = (filePath, content, moduleClassName) => {
+  const source = sourceFileFor2(filePath, content);
+  const diagnostics = parseDiagnosticsFor(source, filePath);
+  let index;
+  let modelFound = false;
+  const visit = (node) => {
+    if (modelFound || !ts5.isCallExpression(node)) {
+      ts5.forEachChild(node, visit);
+      return;
+    }
+    if (callExpressionName2(node) !== "model") {
+      ts5.forEachChild(node, visit);
+      return;
+    }
+    const typeArgument = node.typeArguments?.[0];
+    if (!typeArgument || typeArgument.getText(source) !== moduleClassName) {
+      ts5.forEachChild(node, visit);
+      return;
+    }
+    modelFound = true;
+    const callback = node.arguments.find((arg) => ts5.isArrowFunction(arg) || ts5.isFunctionExpression(arg));
+    if (!callback || !ts5.isArrowFunction(callback) && !ts5.isFunctionExpression(callback)) {
+      diagnostics.push({
+        severity: "error",
+        code: "module-index-dictionary-builder-missing",
+        message: `Dictionary .model<${moduleClassName}> branch does not provide a builder callback in ${filePath}.`,
+        context: { target: moduleClassName, paths: [filePath] }
+      });
+      return;
+    }
+    const objectLiteral = firstObjectReturnedByArrow2(callback);
+    if (!objectLiteral) {
+      diagnostics.push({
+        severity: "error",
+        code: "module-index-dictionary-builder-object-missing",
+        message: `Dictionary .model<${moduleClassName}> builder does not return an object literal in ${filePath}.`,
+        context: { target: moduleClassName, paths: [filePath] }
+      });
+    }
+    index = {
+      path: filePath,
+      modelClassName: moduleClassName,
+      translatorName: nodeName2(callback.parameters[0]?.name),
+      fields: objectLiteral ? fieldsFromObject(source, filePath, objectLiteral, "dictionary") : [],
+      sourceSpan: spanFor(source, filePath, node)
+    };
+  };
+  ts5.forEachChild(source, visit);
+  return { index, diagnostics, modelFound };
+};
+var expectedFilesFor = (module) => {
+  const paths = moduleSourcePaths(module.name);
+  return indexFileKinds.map((kind) => {
+    const expectedModulePath = paths[kind];
+    const expectedFilename = path10.basename(expectedModulePath);
+    const actualFilename = module.files.find((file) => file === expectedFilename) ?? module.files.find((file) => file.toLowerCase() === expectedFilename.toLowerCase());
+    const present = actualFilename !== undefined;
+    const casing = !present ? "missing" : actualFilename === expectedFilename ? "match" : "mismatch";
+    return {
+      kind,
+      path: `${module.path}/${actualFilename ?? expectedFilename}`,
+      expectedPath: `${module.path}/${expectedFilename}`,
+      filename: actualFilename ?? expectedFilename,
+      expectedFilename,
+      present,
+      casing
+    };
+  });
+};
+var diagnosticsForFiles = (files) => files.flatMap((file) => {
+  if (file.kind !== "constant" && file.kind !== "dictionary")
+    return [];
+  if (file.casing === "match")
+    return [];
+  return [
+    {
+      severity: "error",
+      code: file.casing === "missing" ? "module-index-file-missing" : "module-index-file-casing-mismatch",
+      message: file.casing === "missing" ? `Expected ${file.kind} file is missing: ${file.expectedPath}.` : `Expected ${file.expectedPath}, but found ${file.path}.`,
+      context: { target: file.expectedPath, paths: [file.path, file.expectedPath] }
+    }
+  ];
+});
+var fieldPresence = (requestedField, constantFields, dictionaryFields, lightFields) => {
+  const names = new Set([
+    ...constantFields.map((field) => field.name),
+    ...dictionaryFields.map((field) => field.name),
+    ...lightFields.map((field) => field.name),
+    ...requestedField ? [requestedField] : []
+  ]);
+  return [...names].sort().map((name) => ({
+    name,
+    requested: requestedField === name,
+    constant: constantFields.some((field) => field.name === name),
+    dictionary: dictionaryFields.some((field) => field.name === name),
+    lightProjection: lightFields.some((field) => field.name === name)
+  }));
+};
+var partialPresenceDiagnostics = (presence, module) => presence.filter((field) => field.constant !== field.dictionary || field.lightProjection && (!field.constant || !field.dictionary)).map((field) => ({
+  severity: "warning",
+  code: "module-index-field-presence-partial",
+  message: `${module.sysName}:${module.name}.${field.name} presence differs across constant, dictionary, and lightProjection.`,
+  context: {
+    target: `${module.sysName}:${module.name}.${field.name}`,
+    paths: [`${module.path}/${module.name}.constant.ts`, `${module.path}/${module.name}.dictionary.ts`]
+  }
+}));
+var buildAkanModuleContextIndex = async (workspace, module, options = {}) => {
+  const files = expectedFilesFor(module);
+  const diagnostics = diagnosticsForFiles(files);
+  const moduleClassName = moduleComponentName(module.name);
+  const constantFile = files.find((file) => file.kind === "constant");
+  const dictionaryFile = files.find((file) => file.kind === "dictionary");
+  const constantContent = constantFile?.present && constantFile.casing === "match" ? await sourceText(path10.join(workspace.workspaceRoot, constantFile.path)) : null;
+  const dictionaryContent = dictionaryFile?.present && dictionaryFile.casing === "match" ? await sourceText(path10.join(workspace.workspaceRoot, dictionaryFile.path)) : null;
+  const parsedConstant = constantFile && constantContent ? parseConstantIndex(constantFile.path, constantContent, moduleClassName) : undefined;
+  const constant = parsedConstant?.index;
+  const parsedDictionary = dictionaryFile && dictionaryContent ? parseDictionaryIndex(dictionaryFile.path, dictionaryContent, moduleClassName) : undefined;
+  const dictionary = parsedDictionary?.index;
+  const presence = fieldPresence(options.field, constant?.fields ?? [], dictionary?.fields ?? [], constant?.lightProjection?.fields ?? []);
+  if (constantFile?.present && constantFile.casing === "match" && !await fileExists(path10.join(workspace.workspaceRoot, constantFile.path))) {
+    diagnostics.push({
+      severity: "error",
+      code: "module-index-file-unreadable",
+      message: `Expected constant file could not be read: ${constantFile.path}.`,
+      context: { paths: [constantFile.path] }
+    });
+  }
+  if (parsedConstant)
+    diagnostics.push(...parsedConstant.diagnostics);
+  if (parsedDictionary)
+    diagnostics.push(...parsedDictionary.diagnostics);
+  if (dictionaryFile?.present && dictionaryFile.casing === "match" && !parsedDictionary?.modelFound) {
+    diagnostics.push({
+      severity: "error",
+      code: "module-index-dictionary-model-missing",
+      message: `Dictionary .model<${moduleClassName}> branch was not found in ${dictionaryFile.path}.`,
+      context: { paths: [dictionaryFile.path] }
+    });
+  }
+  diagnostics.push(...partialPresenceDiagnostics(presence, module));
+  return {
+    schemaVersion: 1,
+    app: module.sysName,
+    module: module.name,
+    moduleClassName,
+    files,
+    fieldPresence: presence,
+    ...constant ? { constant } : {},
+    ...dictionary ? { dictionary } : {},
+    diagnostics
+  };
+};
+
 // pkgs/@akanjs/devkit/workflow/uiPolicy.ts
 var addFieldUiPolicyForType = (typeName) => {
   const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
@@ -5593,11 +6287,18 @@ var postApplyDiagnostic = (code, message, target) => ({
   failureScope: "source-change",
   context: { target }
 });
+var postApplyWarning = (code, message, target) => ({
+  severity: "warning",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target }
+});
 var sourceKindForPath = (filePath) => {
   if (filePath.endsWith(".tsx"))
-    return ts4.ScriptKind.TSX;
+    return ts6.ScriptKind.TSX;
   if (filePath.endsWith(".ts"))
-    return ts4.ScriptKind.TS;
+    return ts6.ScriptKind.TS;
   return null;
 };
 var checkPathCasing = async (workspace, filePath) => {
@@ -5625,7 +6326,7 @@ var checkTypeScriptSyntax = async (workspace, filePath) => {
   if (!scriptKind)
     return null;
   const content = await workspace.readFile(filePath);
-  const source = ts4.createSourceFile(filePath, content, ts4.ScriptTarget.Latest, true, scriptKind);
+  const source = ts6.createSourceFile(filePath, content, ts6.ScriptTarget.Latest, true, scriptKind);
   const diagnostic = source.parseDiagnostics[0];
   if (!diagnostic)
     return null;
@@ -5633,7 +6334,7 @@ var checkTypeScriptSyntax = async (workspace, filePath) => {
   const location = position ? `:${position.line + 1}:${position.character + 1}` : "";
   return {
     code: "workflow-post-apply-syntax-error",
-    message: `Generated source has a TypeScript syntax error at ${filePath}${location}: ${ts4.flattenDiagnosticMessageText(diagnostic.messageText, " ")}`
+    message: `Generated source has a TypeScript syntax error at ${filePath}${location}: ${ts6.flattenDiagnosticMessageText(diagnostic.messageText, " ")}`
   };
 };
 var checkChangedFile = async (workspace, file) => {
@@ -5675,6 +6376,111 @@ var checkRecommendationPath = async (workspace, recommendation) => {
     context: { target: recommendation.target }
   };
 };
+var sourceChangeError = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "source-change" || !diagnostic.failureScope || diagnostic.failureScope === "unknown"));
+var fieldCount = (fields, fieldName) => fields.filter((field) => field === fieldName).length;
+var fieldOrderValid = (fields, fieldName) => {
+  const actualIndex = fields.indexOf(fieldName);
+  if (actualIndex < 0 || fields.lastIndexOf(fieldName) !== actualIndex)
+    return false;
+  const fieldsWithoutRequested = fields.filter((_, index) => index !== actualIndex);
+  return insertionIndexForFieldOrder(fieldsWithoutRequested, fieldName) === actualIndex;
+};
+var workflowModuleContext = async (workspace, plan) => {
+  const app = workflowStringInput(plan.inputs.app);
+  const moduleName = workflowStringInput(plan.inputs.module);
+  if (!app || !moduleName)
+    return null;
+  const [apps, libs] = await workspace.getSyss();
+  const sysType = apps.includes(app) ? "app" : libs.includes(app) ? "lib" : null;
+  if (!sysType)
+    return null;
+  const modulePath = `${sysType}s/${app}/lib/${moduleName}`;
+  const files = await workspace.readdir(modulePath);
+  const abstractPath = `${modulePath}/${moduleName}.abstract.md`;
+  return {
+    kind: "domain",
+    name: moduleName,
+    folderName: moduleName,
+    sysName: app,
+    sysType,
+    path: modulePath,
+    abstract: {
+      path: abstractPath,
+      exists: files.includes(`${moduleName}.abstract.md`),
+      headings: []
+    },
+    files
+  };
+};
+var structureCheck = (code, target, status, message) => ({
+  code,
+  target,
+  status,
+  message
+});
+var checkAddFieldStructure = async (workspace, plan) => {
+  if (plan.workflow !== "add-field" && plan.workflow !== "add-enum-field")
+    return {};
+  const app = workflowStringInput(plan.inputs.app);
+  const moduleName = workflowStringInput(plan.inputs.module);
+  const fieldName = workflowStringInput(plan.inputs.field);
+  const typeName = workflowStringInput(plan.inputs.type);
+  if (!app || !moduleName || !fieldName || !typeName)
+    return {};
+  const moduleContext = await workflowModuleContext(workspace, plan);
+  if (!moduleContext)
+    return {};
+  const paths = moduleSourcePaths(moduleName);
+  const constantPath = `${moduleContext.path}/${paths.constant.replace(`lib/${moduleName}/`, "")}`;
+  const dictionaryPath = `${moduleContext.path}/${paths.dictionary.replace(`lib/${moduleName}/`, "")}`;
+  const moduleClassName = moduleComponentName(moduleName);
+  const inputClassName = `${moduleClassName}Input`;
+  const index = await buildAkanModuleContextIndex(workspace, moduleContext, { field: fieldName });
+  const diagnostics = [];
+  const postApplyChecks = [];
+  const constantContent = await workspace.readFile(constantPath);
+  const constantStructure = inspectConstantStructure(constantContent, inputClassName, moduleClassName);
+  const constantNames = constantStructure.fields.map((field) => field.name);
+  const requestedConstantFields = constantStructure.fields.filter((field) => field.name === fieldName);
+  const normalizedType = typeName.toLowerCase() === "enum" ? typeName : normalizeFieldType(typeName);
+  const constantFailures = [
+    !constantStructure.parseValid ? "constant file does not parse" : null,
+    !constantStructure.inputObjectFound ? `${inputClassName} via builder object was not found` : null,
+    requestedConstantFields.length !== 1 ? `field "${fieldName}" appears ${requestedConstantFields.length} time(s) in ${inputClassName}` : null,
+    constantStructure.builderName && requestedConstantFields[0]?.expressionBuilder && requestedConstantFields[0].expressionBuilder !== constantStructure.builderName ? `field "${fieldName}" uses builder "${requestedConstantFields[0].expressionBuilder}" instead of "${constantStructure.builderName}"` : null,
+    !constantStructure.builderName ? `${inputClassName} via builder parameter was not found` : null,
+    (normalizedType === "Int" || normalizedType === "Float") && !constantStructure.baseImports.includes(normalizedType) ? `missing ${normalizedType} import from "akanjs/base"` : null,
+    workflowBooleanInput(plan.inputs.includeInLight) === true && fieldCount(constantStructure.lightProjectionFields, fieldName) !== 1 ? `field "${fieldName}" is not present exactly once in Light${moduleClassName}` : null,
+    ...index.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && diagnostic.context?.paths?.includes(constantPath)).map((diagnostic) => diagnostic.message)
+  ].filter((failure) => failure !== null);
+  const constantValid = constantFailures.length === 0;
+  postApplyChecks.push(structureCheck(constantValid ? "workflow-post-apply-constant-shape-valid" : "workflow-post-apply-structure-invalid", constantPath, constantValid ? "passed" : "failed", constantValid ? `${inputClassName} keeps via structure, builder usage, imports, and requested field presence.` : constantFailures.join(" ")));
+  if (!constantValid) {
+    diagnostics.push(postApplyDiagnostic("workflow-post-apply-structure-invalid", constantFailures.join(" "), constantPath));
+  }
+  const dictionaryContent = await workspace.readFile(dictionaryPath);
+  const dictionaryStructure = inspectDictionaryStructure(dictionaryContent, moduleClassName);
+  const dictionaryFailures = [
+    !dictionaryStructure.parseValid ? "dictionary file does not parse" : null,
+    !dictionaryStructure.modelObjectFound ? `.model<${moduleClassName}> object was not found` : null,
+    dictionaryStructure.modelObjectFound && !dictionaryStructure.chainOrderValid ? `.model(), .slice(), .enum(), .error(), and .translate() chain order is broken: ${dictionaryStructure.chainMethods.join(" -> ")}` : null,
+    fieldCount(dictionaryStructure.fields, fieldName) !== 1 ? `field "${fieldName}" appears ${fieldCount(dictionaryStructure.fields, fieldName)} time(s) in .model<${moduleClassName}>` : null,
+    ...index.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && diagnostic.context?.paths?.includes(dictionaryPath)).map((diagnostic) => diagnostic.message)
+  ].filter((failure) => failure !== null);
+  const dictionaryValid = dictionaryFailures.length === 0;
+  postApplyChecks.push(structureCheck(dictionaryValid ? "workflow-post-apply-dictionary-shape-valid" : "workflow-post-apply-structure-invalid", dictionaryPath, dictionaryValid ? "passed" : "failed", dictionaryValid ? `.model<${moduleClassName}> keeps the requested field inside the model object and preserves dictionary chain order.` : dictionaryFailures.join(" ")));
+  if (!dictionaryValid) {
+    diagnostics.push(postApplyDiagnostic("workflow-post-apply-structure-invalid", dictionaryFailures.join(" "), dictionaryPath));
+  }
+  const constantOrderValid = fieldOrderValid(constantNames, fieldName);
+  const dictionaryOrderValid = fieldOrderValid(dictionaryStructure.fields, fieldName);
+  const orderValid = constantOrderValid && dictionaryOrderValid;
+  postApplyChecks.push(structureCheck("workflow-post-apply-field-order-valid", `${constantPath}, ${dictionaryPath}`, orderValid ? "passed" : "failed", orderValid ? `Field "${fieldName}" follows the shared priority ordering policy.` : `Field "${fieldName}" is present but does not match the shared priority ordering policy.`));
+  if (!orderValid) {
+    diagnostics.push(postApplyWarning("workflow-post-apply-field-order-mismatch", `Field "${fieldName}" is present but does not match the shared priority ordering policy.`, `${constantPath}, ${dictionaryPath}`));
+  }
+  return { diagnostics, postApplyChecks };
+};
 var resolveWorkflowSys = async (workspace, target) => {
   if (!target)
     return null;
@@ -5711,7 +6517,7 @@ var addFieldUiSurfaceInspection = (plan) => {
   const policy = addFieldUiPolicyForType(typeName ?? "String");
   const surfaces = workflowStringArrayInput(plan.inputs.surfaces);
   const templateRequested = surfaces?.includes("template") ?? false;
-  const moduleClassName = capitalize2(module);
+  const moduleClassName = moduleComponentName(module);
   const target = `${app ? `apps/${app}` : "*"}/${moduleSourcePaths(module).template}`;
   return {
     recommendations: [
@@ -5880,6 +6686,11 @@ class WorkflowExecutor {
         postApplyChecks.push(...result.postApplyChecks ?? []);
         diagnostics.push(...result.diagnostics ?? []);
       }
+      if (!sourceChangeError(diagnostics)) {
+        const result = await checkAddFieldStructure(this.workspace, plan);
+        postApplyChecks.push(...result.postApplyChecks ?? []);
+        diagnostics.push(...result.diagnostics ?? []);
+      }
       const recommendationDiagnostics = await Promise.all(recommendations.map((recommendation) => checkRecommendationPath(this.workspace, recommendation)));
       diagnostics.push(...recommendationDiagnostics.filter((diagnostic) => !!diagnostic));
     }
@@ -5898,7 +6709,7 @@ class WorkflowExecutor {
   }
 }
 // pkgs/@akanjs/devkit/workflow/plan.ts
-import { capitalize as capitalize3 } from "akanjs/common";
+import { capitalize as capitalize2 } from "akanjs/common";
 var surfaceModes = new Set(["infer", "include", "skip"]);
 var parseStringList = (value) => {
   if (Array.isArray(value)) {
@@ -6003,7 +6814,7 @@ var createAddFieldRecommendations = (inputs) => {
       kind: "placement",
       target: paths.constant,
       confidence: "high",
-      message: `Insert ${field}: field(${normalizedType}) in ${capitalize3(module)}Input.`
+      message: `Insert ${field}: field(${normalizedType}) in ${capitalize2(module)}Input.`
     },
     {
       code: "add-field-placement-dictionary",
@@ -6035,7 +6846,7 @@ var createAddFieldRecommendations = (inputs) => {
         code: "add-field-light-projection-choice",
         kind: "manual-action",
         target: paths.constant,
-        action: `Pass includeInLight=true when ${field} should appear in Light${capitalize3(module)} list/card projections.`,
+        action: `Pass includeInLight=true when ${field} should appear in Light${capitalize2(module)} list/card projections.`,
         confidence: "medium",
         message: `Light projection exposure for ${module}.${field} is not selected yet.`
       }
@@ -6046,7 +6857,7 @@ var createAddFieldRecommendations = (inputs) => {
         kind: "placement",
         target: paths.constant,
         confidence: "high",
-        message: `Add ${field} to Light${capitalize3(module)} projection fields.`
+        message: `Add ${field} to Light${capitalize2(module)} projection fields.`
       }
     ] : [],
     ...surfaces && !templateRequested ? [
@@ -6062,7 +6873,7 @@ var createAddFieldRecommendations = (inputs) => {
       code: "add-field-ui-manual-review",
       kind: "manual-action",
       target: paths.template,
-      action: `Review ${app}:${module} UI after apply. Template auto-edit requires a generated ${module}Form hook and Layout.Template field list; Unit/View are not auto-edited because list/card placement depends on local layout. Candidate positions: Layout.Template before the closing tag, Light${capitalize3(module)} projection array for list data, and Unit/View card sections for display.`,
+      action: `Review ${app}:${module} UI after apply. Template auto-edit requires a generated ${module}Form hook and Layout.Template field list; Unit/View are not auto-edited because list/card placement depends on local layout. Candidate positions: Layout.Template before the closing tag, Light${capitalize2(module)} projection array for list data, and Unit/View card sections for display.`,
       confidence: "medium",
       message: "UI manual review includes the reason auto-edit may be skipped and candidate insertion positions."
     },
@@ -6280,6 +7091,7 @@ var renderRecommendation = (recommendation) => {
   return `- [${recommendation.kind}]${target} ${recommendation.message}${action}`;
 };
 var renderDiagnostic = (diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`;
+var renderNextAction = (action) => `- \`${action.command}\`: ${action.reason}`;
 var applySourceStatus = (report) => report.diagnostics.some((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "source-change" || !diagnostic.failureScope || diagnostic.failureScope === "unknown")) ? "failed" : "passed";
 var renderWorkflowApplyReport = (report) => {
   const manualReviewItems = [
@@ -6328,7 +7140,7 @@ var renderWorkflowApplyReport = (report) => {
     ...report.recommendations.length ? report.recommendations.slice(0, 3).map(renderRecommendation) : ["- none"],
     "",
     "## Next Actions",
-    ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+    ...report.nextActions.length ? report.nextActions.slice(0, 3).map(renderNextAction) : ["- none"],
     ""
   ].join(`
 `);
@@ -6409,6 +7221,66 @@ var renderWorkflowRunArtifact = (artifact, format = "markdown") => {
   }
   return jsonText(artifact);
 };
+// pkgs/@akanjs/devkit/workflow/rolloutGate.ts
+var toolingRolloutCandidates = [
+  {
+    packageName: "typescript",
+    status: "allowed",
+    role: "Primary TypeScript Compiler API baseline for AST locator, text splice, and reparse checks.",
+    adoptionGate: "Already present; keep using stable Bun-compatible package builds."
+  },
+  {
+    packageName: "@ttsc/graph",
+    status: "reference-only",
+    role: "Source-free graph shape and lazy resident model reference.",
+    adoptionGate: "Do not add as an Akan runtime dependency without a separate proposal or milestone update."
+  },
+  {
+    packageName: "ts-morph",
+    status: "experiment-only",
+    role: "Prototype candidate for complex object literal insertion, import update, and class traversal.",
+    adoptionGate: "Use only in isolated prototypes until package size and formatting churn are measured."
+  },
+  {
+    packageName: "ast-grep",
+    status: "experiment-only",
+    role: "Prototype candidate for shape detection, CI rules, and migration rules.",
+    adoptionGate: "Use as a local rule/check experiment, not as the edit engine."
+  },
+  {
+    packageName: "recast",
+    status: "experiment-only",
+    role: "Prototype candidate for formatting preservation.",
+    adoptionGate: "Low priority; require proof that formatting churn is lower than the baseline."
+  },
+  {
+    packageName: "typescript-go",
+    status: "blocked",
+    role: "TypeScript-Go toolchain transition placeholder.",
+    adoptionGate: "Out of scope for Season 2 rollout."
+  },
+  {
+    packageName: "@typescript/native-preview",
+    status: "blocked",
+    role: "TypeScript-Go native preview package placeholder.",
+    adoptionGate: "Out of scope for Season 2 rollout."
+  }
+];
+var toolingRolloutGate = {
+  schemaVersion: 1,
+  strategy: "reference-first-dependency-later",
+  dependencyPolicy: "Season 2 keeps new AST and graph tooling as references or isolated experiments until a separate proposal or milestone update approves adoption.",
+  gateConditions: [
+    "Works in Bun runtime and published package artifacts.",
+    "Does not break dist/pkgs package verification.",
+    "Keeps generated source formatting churn limited.",
+    "Reduces add-field regression fixture failures compared with the current TypeScript API baseline.",
+    "Does not move MCP responses toward returning source bodies."
+  ],
+  candidates: toolingRolloutCandidates
+};
+var isRestrictedCandidate = (candidate) => candidate.status !== "allowed";
+var restrictedCandidates = new Map(toolingRolloutCandidates.filter(isRestrictedCandidate).map((candidate) => [candidate.packageName, candidate]));
 // pkgs/@akanjs/devkit/akanContext.ts
 var resourceList = [
   { uri: "akan://docs/framework", name: "Akan framework guide", mimeType: "text/markdown" },
@@ -6551,7 +7423,7 @@ var planInputString = (plan2, key) => {
 var expandWorkflowTarget = (target, plan2) => {
   const app = planInputString(plan2, "app");
   const module = planInputString(plan2, "module");
-  const moduleClass = module ? capitalize4(module) : "<Module>";
+  const moduleClass = module ? capitalize3(module) : "<Module>";
   return target.replace(/^\*\//, app ? `apps/${app}/` : "").replaceAll("<module>", module || "<module>").replaceAll("<Module>", moduleClass);
 };
 var workflowPathsForPlan = (plan2) => plan2.predictedChanges.map((change) => expandWorkflowTarget(change.target, plan2));
@@ -6573,8 +7445,8 @@ var loadWorkflowContextPaths = async (workspace, runIdOrPlan, changedFiles) => {
   const paths = [...changedFiles];
   if (!runIdOrPlan)
     return paths;
-  const inputPath = path10.isAbsolute(runIdOrPlan) ? runIdOrPlan : path10.join(workspace.workspaceRoot, runIdOrPlan);
-  const artifact = await safeReadJson(inputPath) ?? await safeReadJson(path10.join(workspace.workspaceRoot, workflowRunArtifactPath(runIdOrPlan)));
+  const inputPath = path11.isAbsolute(runIdOrPlan) ? runIdOrPlan : path11.join(workspace.workspaceRoot, runIdOrPlan);
+  const artifact = await safeReadJson(inputPath) ?? await safeReadJson(path11.join(workspace.workspaceRoot, workflowRunArtifactPath(runIdOrPlan)));
   if (artifact && isWorkflowRunArtifact(artifact))
     paths.push(...workflowPathsForArtifact(artifact));
   return [...new Set(paths.filter(Boolean))];
@@ -6592,9 +7464,9 @@ var isWorkflowRelatedDiagnostic = (diagnostic, workflowPaths) => {
   });
 };
 var readGeneratedSyncStates = async (workspace) => {
-  const syncDir = path10.join(workspace.workspaceRoot, workflowSyncDir);
+  const syncDir = path11.join(workspace.workspaceRoot, workflowSyncDir);
   const entries = await safeReadDir(syncDir);
-  const states = await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => safeReadJson(path10.join(syncDir, entry.name))));
+  const states = await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => safeReadJson(path11.join(syncDir, entry.name))));
   return states.filter((state) => !!state && state.schemaVersion === 1 && typeof state.target === "string" && typeof state.syncedAt === "string");
 };
 var generatedFreshnessFromStates = async (workspace) => {
@@ -6631,12 +7503,12 @@ var parseAbstractSummary = (relativePath, content, includeContent) => {
   };
 };
 var readFiles = async (dirPath) => (await safeReadDir(dirPath)).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
-var getRelative = (workspace, absolutePath) => path10.relative(workspace.workspaceRoot, absolutePath).replaceAll(path10.sep, "/");
+var getRelative = (workspace, absolutePath) => path11.relative(workspace.workspaceRoot, absolutePath).replaceAll(path11.sep, "/");
 var createModuleContext = async (workspace, sys2, kind, folderName, moduleName, includeAbstractContent) => {
-  const modulePath = kind === "scalar" ? path10.join(sys2.cwdPath, "lib", "__scalar", moduleName) : path10.join(sys2.cwdPath, "lib", folderName);
+  const modulePath = kind === "scalar" ? path11.join(sys2.cwdPath, "lib", "__scalar", moduleName) : path11.join(sys2.cwdPath, "lib", folderName);
   const relativePath = getRelative(workspace, modulePath);
   const abstractPath = `${relativePath}/${moduleName}.abstract.md`;
-  const abstractContent = await safeReadText(path10.join(workspace.workspaceRoot, abstractPath));
+  const abstractContent = await safeReadText(path11.join(workspace.workspaceRoot, abstractPath));
   return {
     kind,
     name: moduleName,
@@ -6652,7 +7524,7 @@ var getSysModules = async (workspace, sys2, {
   includeAbstractContent = false,
   module: moduleFilter
 } = {}) => {
-  const libPath = path10.join(sys2.cwdPath, "lib");
+  const libPath = path11.join(sys2.cwdPath, "lib");
   const entries = await safeReadDir(libPath);
   const modules = [];
   for (const entry of entries) {
@@ -6666,24 +7538,24 @@ var getSysModules = async (workspace, sys2, {
       const serviceName = entry.name.replace(/^_+/, "");
       if (moduleFilter && moduleFilter !== serviceName && moduleFilter !== entry.name)
         continue;
-      if (!await FileSys.fileExists(path10.join(libPath, entry.name, `${serviceName}.service.ts`)))
+      if (!await FileSys.fileExists(path11.join(libPath, entry.name, `${serviceName}.service.ts`)))
         continue;
       modules.push(await createModuleContext(workspace, sys2, "service", entry.name, serviceName, includeAbstractContent));
     } else {
       if (moduleFilter && moduleFilter !== entry.name)
         continue;
-      if (!await FileSys.fileExists(path10.join(libPath, entry.name, `${entry.name}.constant.ts`)))
+      if (!await FileSys.fileExists(path11.join(libPath, entry.name, `${entry.name}.constant.ts`)))
         continue;
       modules.push(await createModuleContext(workspace, sys2, "domain", entry.name, entry.name, includeAbstractContent));
     }
   }
-  const scalarRoot = path10.join(libPath, "__scalar");
+  const scalarRoot = path11.join(libPath, "__scalar");
   for (const entry of await safeReadDir(scalarRoot)) {
     if (!entry.isDirectory() || entry.name.startsWith("_"))
       continue;
     if (moduleFilter && moduleFilter !== entry.name)
       continue;
-    if (!await FileSys.fileExists(path10.join(scalarRoot, entry.name, `${entry.name}.constant.ts`)))
+    if (!await FileSys.fileExists(path11.join(scalarRoot, entry.name, `${entry.name}.constant.ts`)))
       continue;
     modules.push(await createModuleContext(workspace, sys2, "scalar", entry.name, entry.name, includeAbstractContent));
   }
@@ -6695,7 +7567,7 @@ var getSysContext = async (workspace, type, name, options) => {
     type,
     name,
     path: `${type}s/${name}`,
-    hasConfig: await FileSys.fileExists(path10.join(sys2.cwdPath, "akan.config.ts")),
+    hasConfig: await FileSys.fileExists(path11.join(sys2.cwdPath, "akan.config.ts")),
     modules: await getSysModules(workspace, sys2, {
       includeAbstractContent: options.includeAbstractContent,
       module: options.module
@@ -6706,13 +7578,13 @@ var getSysContext = async (workspace, type, name, options) => {
 class AkanContextAnalyzer {
   static async analyze(workspace, options = {}) {
     const [appNames, libNames, pkgNames] = await workspace.getExecs();
-    const rootPackageJson = await safeReadJson(path10.join(workspace.workspaceRoot, "package.json"));
+    const rootPackageJson = await safeReadJson(path11.join(workspace.workspaceRoot, "package.json"));
     const filteredApps = options.app ? appNames.filter((name) => name === options.app) : appNames;
     const [apps, libs, pkgs] = await Promise.all([
       Promise.all(filteredApps.map((name) => getSysContext(workspace, "app", name, options))),
       Promise.all(libNames.map((name) => getSysContext(workspace, "lib", name, options))),
       Promise.all(pkgNames.map(async (name) => {
-        const packageJson = await safeReadJson(path10.join(workspace.workspaceRoot, "pkgs", name, "package.json"));
+        const packageJson = await safeReadJson(path11.join(workspace.workspaceRoot, "pkgs", name, "package.json"));
         return {
           name,
           path: `pkgs/${name}`,
@@ -6745,7 +7617,7 @@ class AkanContextAnalyzer {
       repairAction("format", "akan repair format --target <app-or-lib-or-pkg>", "Run the formatter/linter repair path.", true)
     ];
     for (const app of context.apps) {
-      const appPath = path10.join(workspace.workspaceRoot, app.path);
+      const appPath = path11.join(workspace.workspaceRoot, app.path);
       for (const entry of await safeReadDir(appPath)) {
         const allowed = entry.isDirectory() ? appRootAllowDirs.has(entry.name) : appRootAllowFiles.has(entry.name);
         if (!allowed) {
@@ -6769,7 +7641,7 @@ class AkanContextAnalyzer {
             severity: strict ? "error" : "warning",
             code: "module-abstract-missing",
             path: module.abstract.path,
-            message: `${capitalize4(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`,
+            message: `${capitalize3(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`,
             repairActions: [action]
           });
           repairActions.push(action);
@@ -6781,14 +7653,14 @@ class AkanContextAnalyzer {
             severity: "error",
             code: "module-shape-invalid",
             path: module.path,
-            message: `${capitalize4(module.kind)} module ${sys2.name}:${module.name} is missing required files: ${missingFiles.join(", ")}`,
+            message: `${capitalize3(module.kind)} module ${sys2.name}:${module.name} is missing required files: ${missingFiles.join(", ")}`,
             repairActions: [action]
           });
           repairActions.push(action);
         }
         if (module.kind !== "service" && module.files.includes(`${module.name}.dictionary.ts`)) {
-          const constantPath = path10.join(workspace.workspaceRoot, module.path, `${module.name}.constant.ts`);
-          const dictionaryPath = path10.join(workspace.workspaceRoot, module.path, `${module.name}.dictionary.ts`);
+          const constantPath = path11.join(workspace.workspaceRoot, module.path, `${module.name}.constant.ts`);
+          const dictionaryPath = path11.join(workspace.workspaceRoot, module.path, `${module.name}.dictionary.ts`);
           const [constantContent, dictionaryContent] = await Promise.all([
             safeReadText(constantPath),
             safeReadText(dictionaryPath)
@@ -6860,6 +7732,519 @@ class AkanContextAnalyzer {
 `;
   }
 }
+// pkgs/@akanjs/devkit/akanMcpContract.ts
+import path12 from "path";
+var emptySchema = { type: "object", properties: {} };
+var stringProperty = { type: "string" };
+var booleanProperty = { type: "boolean" };
+var objectProperty = { type: "object", additionalProperties: true };
+var stringArrayProperty = { type: "array", items: stringProperty };
+var inspectAkanContextRequestTypes = [
+  "workspaceOverview",
+  "moduleContext",
+  "fieldInsertionContext",
+  "workflowDiagnostics",
+  "escape"
+];
+var inspectAkanContextRequestTypeProperty = { type: "string", enum: inspectAkanContextRequestTypes };
+var inspectAkanContextRequestBranches = [
+  {
+    type: "object",
+    properties: { type: { const: "workspaceOverview" } },
+    required: ["type"]
+  },
+  {
+    type: "object",
+    properties: { type: { const: "moduleContext" }, app: stringProperty, module: stringProperty },
+    required: ["type", "app", "module"]
+  },
+  {
+    type: "object",
+    properties: {
+      type: { const: "fieldInsertionContext" },
+      app: stringProperty,
+      module: stringProperty,
+      field: stringProperty,
+      fieldType: stringProperty
+    },
+    required: ["type", "app", "module", "field", "fieldType"]
+  },
+  {
+    type: "object",
+    properties: { type: { const: "workflowDiagnostics" }, runIdOrPlan: stringProperty },
+    required: ["type", "runIdOrPlan"]
+  },
+  {
+    type: "object",
+    properties: { type: { const: "escape" }, reason: stringProperty, nextStep: stringProperty },
+    required: ["type", "reason"]
+  }
+];
+var inspectAkanContextInputSchema = {
+  type: "object",
+  properties: {
+    question: {
+      ...stringProperty,
+      description: "The user-facing question the agent is trying to answer before reading source bodies."
+    },
+    draft: {
+      type: "object",
+      properties: {
+        reason: stringProperty,
+        type: inspectAkanContextRequestTypeProperty
+      },
+      required: ["reason", "type"]
+    },
+    review: {
+      ...stringProperty,
+      description: "A short self-review explaining why this minimal request is sufficient."
+    },
+    request: {
+      type: "object",
+      properties: {
+        type: inspectAkanContextRequestTypeProperty,
+        app: stringProperty,
+        module: stringProperty,
+        field: stringProperty,
+        fieldType: stringProperty,
+        runIdOrPlan: stringProperty,
+        reason: stringProperty,
+        nextStep: stringProperty
+      },
+      required: ["type"],
+      oneOf: inspectAkanContextRequestBranches
+    }
+  },
+  required: ["question", "draft", "review", "request"]
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var slugPart = (value) => typeof value === "string" ? value.trim().replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() : "";
+var optionalString = (args, key) => {
+  const value = args[key];
+  return typeof value === "string" && value ? value : undefined;
+};
+var nestedStringArg = (args, key) => {
+  const value = args[key];
+  if (typeof value !== "string" || !value)
+    throw new Error(`MCP tool argument "${key}" is required.`);
+  return value;
+};
+var isInspectAkanContextRequestType = (value) => typeof value === "string" && inspectAkanContextRequestTypes.includes(value);
+var parseJsonOutput = (output) => JSON.parse(output);
+var workspacePath = (workspace, filePath) => path12.isAbsolute(filePath) ? filePath : path12.join(workspace.workspaceRoot, filePath);
+var defaultWorkflowPlanPath = (workflow, inputs) => {
+  const slug = [
+    slugPart(workflow),
+    slugPart(inputs.app),
+    slugPart(inputs.module),
+    slugPart(inputs.field),
+    slugPart(inputs.scalar),
+    slugPart(inputs.surface),
+    slugPart(inputs.mutation),
+    slugPart(inputs.slice)
+  ].filter(Boolean).join("-");
+  return `.akan/workflows/plans/${slug || "workflow-plan"}.json`;
+};
+var applyFirstPolicy = {
+  mode: "apply-first",
+  directSourceEdits: "fallback-only",
+  applyRequiredWhen: ["plan_workflow returns planPath", "plan_workflow returns next.tool=apply_workflow"],
+  validationRequiredAfterApply: ["validationTarget", "applyReportPath"],
+  fallbackAllowedWhen: [
+    "list_workflows and explain_workflow show no matching workflow",
+    "apply_workflow reports unsupported/no-op/failed diagnostics that require manual action",
+    "recommendations include manual-action follow-up after workflow apply and repairs"
+  ],
+  baselineDiagnosticsPolicy: "Do not fix unrelated baselineDiagnostics unless the user asks."
+};
+var stringArg = (args, key) => {
+  const value = args[key];
+  if (typeof value !== "string" || !value)
+    throw new Error(`MCP tool argument "${key}" is required.`);
+  return value;
+};
+var workflowInputsArg = (args) => {
+  const value = args.inputs;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  return value;
+};
+var inspectAkanContextPropsArg = (args) => {
+  const question = stringArg(args, "question");
+  const review = stringArg(args, "review");
+  if (!isRecord(args.draft))
+    throw new Error('MCP tool argument "draft" is required.');
+  if (!isRecord(args.request))
+    throw new Error('MCP tool argument "request" is required.');
+  if (!isInspectAkanContextRequestType(args.draft.type)) {
+    throw new Error('MCP tool argument "draft.type" must be a supported inspect_akan_context request type.');
+  }
+  if (!isInspectAkanContextRequestType(args.request.type)) {
+    throw new Error('MCP tool argument "request.type" must be a supported inspect_akan_context request type.');
+  }
+  const draft = { reason: nestedStringArg(args.draft, "reason"), type: args.draft.type };
+  const request = args.request;
+  if (request.type === "workspaceOverview")
+    return { question, draft, review, request: { type: request.type } };
+  if (request.type === "moduleContext")
+    return {
+      question,
+      draft,
+      review,
+      request: {
+        type: request.type,
+        app: nestedStringArg(request, "app"),
+        module: nestedStringArg(request, "module")
+      }
+    };
+  if (request.type === "fieldInsertionContext")
+    return {
+      question,
+      draft,
+      review,
+      request: {
+        type: request.type,
+        app: nestedStringArg(request, "app"),
+        module: nestedStringArg(request, "module"),
+        field: nestedStringArg(request, "field"),
+        fieldType: nestedStringArg(request, "fieldType")
+      }
+    };
+  if (request.type === "workflowDiagnostics")
+    return {
+      question,
+      draft,
+      review,
+      request: { type: request.type, runIdOrPlan: nestedStringArg(request, "runIdOrPlan") }
+    };
+  return {
+    question,
+    draft,
+    review,
+    request: {
+      type: "escape",
+      reason: nestedStringArg(request, "reason"),
+      nextStep: optionalString(request, "nextStep")
+    }
+  };
+};
+var inspectDiagnostic = (severity, code, message) => ({ severity, code, message });
+var moduleEvidence = (module) => ({
+  kind: "module",
+  target: `${module.sysName}:${module.name}`,
+  path: module.path,
+  summary: `${module.kind} module at ${module.path} with ${module.files.length} source file(s).`
+});
+var moduleCandidate = (module) => ({
+  app: module.sysName,
+  sysType: module.sysType,
+  module: module.name,
+  kind: module.kind,
+  path: module.path,
+  files: module.files
+});
+var readonlyMcpTools = [
+  {
+    name: "inspect_akan_context",
+    description: "Read-only typed context inspection. Use question -> draft -> review -> request before source body reads; choose fieldInsertionContext for add-field evidence and escape when source body or outside evidence is required.",
+    inputSchema: inspectAkanContextInputSchema
+  },
+  {
+    name: "get_workspace_summary",
+    description: "Legacy broad workspace summary. Prefer inspect_akan_context.workspaceOverview for typed source-body-free evidence.",
+    inputSchema: emptySchema
+  },
+  {
+    name: "list_apps",
+    description: "List Akan apps from the workspace context without reading source bodies.",
+    inputSchema: emptySchema
+  },
+  {
+    name: "list_modules",
+    description: "List Akan modules across apps and libs; use inspect_akan_context.moduleContext for typed evidence.",
+    inputSchema: emptySchema
+  },
+  {
+    name: "get_module_context",
+    description: "Legacy broad module context. Pass app in monorepos; prefer inspect_akan_context.moduleContext or fieldInsertionContext for typed add-field evidence.",
+    inputSchema: { type: "object", properties: { app: stringProperty, module: stringProperty }, required: ["module"] }
+  },
+  {
+    name: "get_guideline",
+    description: "Return an Akan agent guideline resource by name.",
+    inputSchema: { type: "object", properties: { name: stringProperty }, required: ["name"] }
+  },
+  {
+    name: "explain_command",
+    description: "Explain one Akan CLI command and its agent-facing workflow policy.",
+    inputSchema: { type: "object", properties: { command: stringProperty }, required: ["command"] }
+  },
+  {
+    name: "doctor_workspace",
+    description: "Report workspace diagnostics, optionally split into baseline and workflow scopes.",
+    inputSchema: {
+      type: "object",
+      properties: { strict: booleanProperty, runIdOrPlan: stringProperty, changedFiles: stringArrayProperty }
+    }
+  },
+  {
+    name: "get_validation_contract",
+    description: "Return validation, artifact chain, and apply-first fallback policy.",
+    inputSchema: emptySchema
+  }
+];
+var planMcpTools = [
+  {
+    name: "list_workflows",
+    description: "List available read-only workflow specs before creating a plan.",
+    inputSchema: emptySchema
+  },
+  {
+    name: "explain_workflow",
+    description: "Explain one workflow's inputs, predicted changes, validation, and completion criteria.",
+    inputSchema: { type: "object", properties: { workflow: stringProperty }, required: ["workflow"] }
+  },
+  {
+    name: "plan_workflow",
+    description: "Create a read-only workflow plan after context inspection and return planPath plus next.tool=apply_workflow.",
+    inputSchema: {
+      type: "object",
+      properties: { workflow: stringProperty, inputs: objectProperty, out: stringProperty },
+      required: ["workflow"]
+    }
+  }
+];
+var applyMcpTools = [
+  {
+    name: "apply_workflow",
+    description: "Apply a stored workflow plan before direct edits and return validationTarget for run_validation.",
+    inputSchema: {
+      type: "object",
+      properties: { planPath: stringProperty, dryRun: booleanProperty },
+      required: ["planPath"]
+    }
+  },
+  {
+    name: "run_validation",
+    description: "Validate a plan, apply report, validationTarget, or run artifact.",
+    inputSchema: {
+      type: "object",
+      properties: { runIdOrPlan: stringProperty },
+      required: ["runIdOrPlan"]
+    }
+  },
+  {
+    name: "repair_generated",
+    description: "Refresh generated Akan files before direct generated-file edits.",
+    inputSchema: { type: "object", properties: { app: stringProperty }, required: ["app"] }
+  },
+  {
+    name: "repair_imports",
+    description: "Run the import repair path before manual import edits.",
+    inputSchema: { type: "object", properties: { target: stringProperty }, required: ["target"] }
+  },
+  {
+    name: "repair_module_shape",
+    description: "Report module-shape repair actions before direct module file fixes.",
+    inputSchema: {
+      type: "object",
+      properties: { app: stringProperty, module: stringProperty },
+      required: ["app", "module"]
+    }
+  }
+];
+var listAkanMcpTools = (mode = "readonly") => {
+  if (mode === "readonly")
+    return readonlyMcpTools;
+  if (mode === "plan")
+    return [...readonlyMcpTools, ...planMcpTools];
+  return [...readonlyMcpTools, ...planMcpTools, ...applyMcpTools];
+};
+var createAkanValidationContract = (listTools = listAkanMcpTools) => ({
+  schemaVersion: 1,
+  reports: ["WorkflowPlan", "WorkflowApplyReport", "WorkflowValidationRunReport", "RepairReport"],
+  modes: {
+    readonly: listTools("readonly").map((tool) => tool.name),
+    plan: listTools("plan").map((tool) => tool.name),
+    apply: listTools("apply").map((tool) => tool.name)
+  },
+  validationCommands: [
+    "akan workflow validate <run-id-or-plan> --format json",
+    "akan workflow report <run-id> --format json",
+    "akan doctor --strict --format json"
+  ],
+  validationFailureScopes: ["workspace-config", "environment", "source-change", "unknown"],
+  artifactChainFields: ["planPath", "applyReportPath", "repairReportPath", "runId", "validationTarget", "next"],
+  diagnosticScopes: ["baseline", "workflow", "unknown"],
+  validationStatuses: {
+    sourceStatus: ["passed", "failed", "unknown"],
+    workspaceStatus: ["passed", "failed", "unknown"],
+    overallStatus: ["passed", "failed", "blocked-by-workspace-config", "blocked-by-environment"],
+    knownBlockers: "Repeated workspace-config/environment failures are summarized before command output."
+  },
+  moduleContextInputs: {
+    module: "required",
+    app: "required"
+  },
+  generatedFreshnessStatuses: ["fresh", "stale", "missing", "unknown"],
+  toolingRolloutGate,
+  directEditFallbackPolicy: applyFirstPolicy,
+  applyReportFields: [
+    "appliedCommands",
+    "recommendedValidationCommands",
+    "commands",
+    "recommendations",
+    "validationTarget"
+  ],
+  repairCommands: [
+    "akan repair generated --app <app-or-lib> --format json",
+    "akan repair format --target <app-or-lib-or-pkg> --format json",
+    "akan repair imports --target <app-or-lib-or-pkg> --format json",
+    "akan repair dictionary --app <app-or-lib> --module <module> --format json",
+    "akan repair module-shape --app <app-or-lib> --module <module> --format json"
+  ]
+});
+var inspectAkanContext = async (workspace, args) => {
+  const props = inspectAkanContextPropsArg(args);
+  const diagnostics = [];
+  if (props.draft.type !== props.request.type) {
+    diagnostics.push(inspectDiagnostic("warning", "inspect-draft-request-mismatch", `Draft chose ${props.draft.type}, but request uses ${props.request.type}.`));
+  }
+  const baseResult = (type, evidence, next, data) => ({
+    schemaVersion: 1,
+    type,
+    question: props.question,
+    diagnostics,
+    evidence,
+    next,
+    ...data ? { data } : {}
+  });
+  if (props.request.type === "escape") {
+    return baseResult("escape", [{ kind: "escape", summary: props.request.reason }], {
+      action: "escape",
+      reason: props.request.reason,
+      ...props.request.nextStep ? { args: { nextStep: props.request.nextStep } } : {}
+    }, { reason: props.request.reason, nextStep: props.request.nextStep ?? null });
+  }
+  if (props.request.type === "workflowDiagnostics") {
+    const doctor = await AkanContextAnalyzer.doctor(workspace, {
+      strict: true,
+      runIdOrPlan: workspacePath(workspace, props.request.runIdOrPlan)
+    });
+    diagnostics.push(...doctor.diagnostics.map((diagnostic) => ({
+      severity: diagnostic.severity,
+      code: diagnostic.code,
+      message: diagnostic.message,
+      scope: diagnostic.scope,
+      context: {
+        ...diagnostic.context,
+        ...diagnostic.path ? { paths: [diagnostic.path] } : {}
+      }
+    })));
+    return baseResult("workflowDiagnostics", [
+      {
+        kind: "workflow",
+        target: props.request.runIdOrPlan,
+        summary: `Workflow diagnostics status is ${doctor.status}.`
+      }
+    ], {
+      action: doctor.status === "passed" ? "answer" : "validate",
+      reason: doctor.status === "passed" ? "No strict workspace diagnostics were found for the workflow context." : "Review diagnostics before applying or manually editing source files."
+    }, {
+      status: doctor.status,
+      baselineDiagnostics: doctor.baselineDiagnostics?.length ?? 0,
+      workflowDiagnostics: doctor.workflowDiagnostics?.length ?? 0
+    });
+  }
+  const context = await AkanContextAnalyzer.analyze(workspace, {
+    app: props.request.type === "moduleContext" || props.request.type === "fieldInsertionContext" ? props.request.app : null,
+    module: props.request.type === "moduleContext" || props.request.type === "fieldInsertionContext" ? props.request.module : null,
+    includeAbstractContent: false
+  });
+  if (props.request.type === "workspaceOverview") {
+    return baseResult("workspaceOverview", [
+      {
+        kind: "workspace",
+        summary: `${context.repoName} has ${context.apps.length} app(s), ${context.libs.length} lib(s), and ${context.pkgs.length} package(s).`
+      }
+    ], {
+      action: "inspect",
+      reason: "Choose moduleContext or fieldInsertionContext for module-scoped evidence before planning a workflow.",
+      tool: "inspect_akan_context"
+    }, {
+      repoName: context.repoName,
+      apps: context.apps.map((app) => ({ name: app.name, path: app.path, modules: app.modules.length })),
+      libs: context.libs.map((lib) => ({ name: lib.name, path: lib.path, modules: lib.modules.length })),
+      pkgs: context.pkgs.map((pkg) => ({ name: pkg.name, path: pkg.path, version: pkg.version ?? null })),
+      generatedFiles: context.generatedFiles,
+      validationCommands: context.validationCommands
+    });
+  }
+  const modules = AkanContextAnalyzer.findModules(context, props.request.module, {
+    app: props.request.app ?? null
+  });
+  if (modules.length === 0) {
+    diagnostics.push(inspectDiagnostic("error", "inspect-module-not-found", `No module matched ${props.request.app ? `${props.request.app}:` : ""}${props.request.module}.`));
+    return baseResult(props.request.type, [], {
+      action: "escape",
+      reason: "The requested module was not found in the workspace index; inspect workspace files or clarify the target."
+    }, { candidates: [] });
+  }
+  if (!props.request.app && modules.length > 1) {
+    diagnostics.push(inspectDiagnostic("error", "inspect-module-ambiguous", `Multiple modules match "${props.request.module}". Re-run with app to disambiguate.`));
+    return baseResult(props.request.type, modules.map(moduleEvidence), {
+      action: "clarify",
+      reason: "Multiple modules have the same name; choose an app before planning a workflow."
+    }, { candidates: modules.map(moduleCandidate) });
+  }
+  const module = modules[0];
+  if (props.request.type === "moduleContext") {
+    return baseResult("moduleContext", [moduleEvidence(module)], {
+      action: "inspect",
+      reason: "Use fieldInsertionContext when preparing add-field or escape when source body details are required.",
+      tool: "inspect_akan_context"
+    }, { module: moduleCandidate(module) });
+  }
+  if (module.kind !== "domain") {
+    diagnostics.push(inspectDiagnostic("error", "field-insertion-unsupported-module-kind", `fieldInsertionContext currently targets domain modules; ${module.sysName}:${module.name} is ${module.kind}.`));
+  }
+  const moduleIndex2 = await buildAkanModuleContextIndex(workspace, module, { field: props.request.field });
+  diagnostics.push(...moduleIndex2.diagnostics);
+  return baseResult("fieldInsertionContext", [
+    moduleEvidence(module),
+    {
+      kind: "field-insertion",
+      target: `${module.sysName}:${module.name}.${props.request.field}`,
+      path: module.path,
+      summary: "M2 returns source-body-free AST index evidence for constant fields, dictionary model labels, and light projection fields."
+    }
+  ], module.kind === "domain" ? {
+    action: "plan_workflow",
+    reason: "The module target is unambiguous; create an add-field workflow plan before source edits.",
+    tool: "plan_workflow",
+    args: {
+      workflow: "add-field",
+      inputs: {
+        app: module.sysName,
+        module: module.name,
+        field: props.request.field,
+        type: props.request.fieldType
+      }
+    }
+  } : {
+    action: "escape",
+    reason: "This module kind is not a supported add-field target in the P1 context contract."
+  }, {
+    target: {
+      app: module.sysName,
+      module: module.name,
+      field: props.request.field,
+      fieldType: props.request.fieldType
+    },
+    files: moduleIndex2.files,
+    moduleIndex: moduleIndex2
+  });
+};
 // pkgs/@akanjs/devkit/applicationBuildReporter.ts
 import { Logger as Logger6 } from "akanjs/common";
 
@@ -6906,20 +8291,20 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
 }
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
 import { mkdir as mkdir8, rm as rm3 } from "fs/promises";
-import path35 from "path";
+import path37 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
-import path20 from "path";
+import path22 from "path";
 
 // pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
 import { mkdir as mkdir3 } from "fs/promises";
-import path11 from "path";
+import path13 from "path";
 var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
 async function appHasStModule(appCwdPath) {
-  return Bun.file(path11.join(appCwdPath, "lib", "st.ts")).exists();
+  return Bun.file(path13.join(appCwdPath, "lib", "st.ts")).exists();
 }
-var IMPLICIT_LAYOUT_DIR = path11.join(".akan", "generated", "root-layouts");
-var IMPLICIT_DICT_DIR = path11.join(".akan", "generated", "dict");
+var IMPLICIT_LAYOUT_DIR = path13.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path13.join(".akan", "generated", "dict");
 function getRootBoundarySegments(key) {
   const match = LAYOUT_KEY_RE.exec(key);
   if (!match)
@@ -6934,10 +8319,10 @@ function implicitRootLayoutKey(segments) {
 }
 function implicitRootLayoutAbsPath(appCwdPath, segments) {
   const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
-  return path11.join(path11.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+  return path13.join(path13.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
 }
 function implicitDictionaryMacroAbsPath(appCwdPath) {
-  return path11.join(path11.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
+  return path13.join(path13.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
 }
 function isRootBoundarySegments(segments, basePaths) {
   const firstVisibleIndex = segments.findIndex((segment) => !/^\(.+\)$/.test(segment));
@@ -6960,7 +8345,7 @@ function findRootBoundaries(pageKeys, appCwdPath, basePaths) {
     const id = segments.join("/");
     boundaries.set(id, {
       sourceKey: key,
-      sourceAbsPath: path11.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
+      sourceAbsPath: path13.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
       segments
     });
   }
@@ -6978,21 +8363,21 @@ function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
     const segments = getRootBoundarySegments(key);
     return segments !== null && segments.length === 0;
   });
-  return rootLayoutKey ? path11.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
+  return rootLayoutKey ? path13.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
 }
 function routePrefixForSegments(segments) {
   const visible = segments.filter((segment) => !/^\(.+\)$/.test(segment));
   return visible[0] ?? null;
 }
 async function assertEnvClientConvention(appCwdPath, appName) {
-  const envPath = path11.join(appCwdPath, "env", "env.client.ts");
+  const envPath = path13.join(appCwdPath, "env", "env.client.ts");
   if (!await Bun.file(envPath).exists()) {
     throw new Error(`[route-convention] app "${appName}" must provide env/env.client.ts exporting "env" for generated System.Provider`);
   }
 }
 async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
   const absPath = implicitDictionaryMacroAbsPath(appCwdPath);
-  await mkdir3(path11.dirname(absPath), { recursive: true });
+  await mkdir3(path13.dirname(absPath), { recursive: true });
   await Bun.write(absPath, `import { getAllDictionary } from "@apps/${appName}/lib/dict" with { type: "macro" };
 
 export const allDictionary = getAllDictionary();
@@ -7003,13 +8388,13 @@ async function writeGeneratedRootLayoutFile(opts) {
   await assertEnvClientConvention(opts.appCwdPath, opts.appName);
   const dictMacroAbsPath = opts.includeSystemProvider ? await writeGeneratedDictionaryMacroFile(opts.appCwdPath, opts.appName) : null;
   const absPath = implicitRootLayoutAbsPath(opts.appCwdPath, opts.boundary.segments);
-  await mkdir3(path11.dirname(absPath), { recursive: true });
-  const dictMacroRel = dictMacroAbsPath ? path11.relative(path11.dirname(absPath), dictMacroAbsPath).split(path11.sep).join("/") : null;
+  await mkdir3(path13.dirname(absPath), { recursive: true });
+  const dictMacroRel = dictMacroAbsPath ? path13.relative(path13.dirname(absPath), dictMacroAbsPath).split(path13.sep).join("/") : null;
   const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
-  const sourceRel = opts.boundary.sourceAbsPath ? path11.relative(path11.dirname(absPath), opts.boundary.sourceAbsPath).split(path11.sep).join("/") : null;
+  const sourceRel = opts.boundary.sourceAbsPath ? path13.relative(path13.dirname(absPath), opts.boundary.sourceAbsPath).split(path13.sep).join("/") : null;
   const sourceSpecifier = sourceRel ? sourceRel.startsWith(".") ? sourceRel : `./${sourceRel}` : null;
   const inheritedSourceAbsPath = opts.rootSourceAbsPath && opts.rootSourceAbsPath !== opts.boundary.sourceAbsPath ? opts.rootSourceAbsPath : null;
-  const inheritedSourceRel = inheritedSourceAbsPath ? path11.relative(path11.dirname(absPath), inheritedSourceAbsPath).split(path11.sep).join("/") : null;
+  const inheritedSourceRel = inheritedSourceAbsPath ? path13.relative(path13.dirname(absPath), inheritedSourceAbsPath).split(path13.sep).join("/") : null;
   const inheritedSourceSpecifier = inheritedSourceRel ? inheritedSourceRel.startsWith(".") ? inheritedSourceRel : `./${inheritedSourceRel}` : null;
   const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
 void st;
@@ -7103,7 +8488,7 @@ export default function GeneratedLayout({ children, params, searchParams }: Layo
   return absPath;
 }
 async function resolveSsrPageEntries(opts) {
-  const absPageDir = path11.resolve(opts.appCwdPath, "page");
+  const absPageDir = path13.resolve(opts.appCwdPath, "page");
   const hasSt = await appHasStModule(opts.appCwdPath);
   const basePaths = opts.basePaths ?? [];
   const rootSourceAbsPath = findExplicitRootLayoutAbsPath(opts.pageKeys, opts.appCwdPath);
@@ -7114,7 +8499,7 @@ async function resolveSsrPageEntries(opts) {
   }));
   const base = opts.pageKeys.filter((key) => !rootLayoutKeys.has(key)).map((key) => ({
     key,
-    moduleAbsPath: path11.resolve(absPageDir, key)
+    moduleAbsPath: path13.resolve(absPageDir, key)
   }));
   const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
     key: implicitRootLayoutKey(boundary.segments),
@@ -7138,14 +8523,14 @@ async function resolveSsrPageEntriesForApp(app, pageKeys) {
 }
 
 // pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
-import path12 from "path";
+import path14 from "path";
 import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey as parseRouteModuleKey2 } from "akanjs/common";
 function computeRouteSeedIndex(pageEntries) {
   const layoutsByPrefix = new Map;
   const pagesBySegments = [];
   for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
     const parsed = parseRouteModuleKey2(key);
-    const files = [path12.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path12.resolve(seed))];
+    const files = [path14.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path14.resolve(seed))];
     if (parsed.kind === "layout") {
       const prefix = parsed.routeSegments.join("/");
       const prev = layoutsByPrefix.get(prefix) ?? [];
@@ -7182,7 +8567,7 @@ function computeRouteSeedIndex(pageEntries) {
 }
 var ROUTE_SEED_INDEX_JSON = "route-seed-index.json";
 function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
-  const normalizedArtifactDir = path12.resolve(artifactDir);
+  const normalizedArtifactDir = path14.resolve(artifactDir);
   if (options.production) {
     return {
       entries: index.entries.map((entry) => ({ routeId: entry.routeId }))
@@ -7197,22 +8582,22 @@ function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
   };
 }
 async function saveRouteSeedIndex(artifactDir, index, options = {}) {
-  const absPath = path12.join(path12.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
+  const absPath = path14.join(path14.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
   await Bun.write(absPath, `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}
 `);
   return absPath;
 }
 function serializeArtifactPath(artifactPath, artifactDir) {
-  if (!path12.isAbsolute(artifactPath))
+  if (!path14.isAbsolute(artifactPath))
     return artifactPath;
-  return path12.relative(artifactDir, artifactPath).split(path12.sep).join("/");
+  return path14.relative(artifactDir, artifactPath).split(path14.sep).join("/");
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
-import path15 from "path";
+import path17 from "path";
 
 // pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
-import path13 from "path";
+import path15 from "path";
 import { Logger as Logger7 } from "akanjs/common";
 var REEXPORT_RE = /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
 var LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
@@ -7335,7 +8720,7 @@ class BarrelAnalyzer {
   }
   #scanExports(source2, absFile) {
     try {
-      const transpiler = [".tsx", ".jsx"].includes(path13.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
+      const transpiler = [".tsx", ".jsx"].includes(path15.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
       const { exports } = transpiler.scan(source2);
       return new Set(exports);
     } catch (err) {
@@ -7344,16 +8729,16 @@ class BarrelAnalyzer {
     }
   }
   #subpathFor(pkg, absFile) {
-    const rel = path13.relative(pkg.pkgDir, absFile);
-    if (!rel || rel.startsWith("..") || path13.isAbsolute(rel))
+    const rel = path15.relative(pkg.pkgDir, absFile);
+    if (!rel || rel.startsWith("..") || path15.isAbsolute(rel))
       return null;
     if (pkg.preserveFilePath)
-      return `${pkg.pkgName}/${rel.split(path13.sep).join("/")}`;
+      return `${pkg.pkgName}/${rel.split(path15.sep).join("/")}`;
     const noExt = stripKnownExt(rel);
     const tail = collapseIndex(noExt);
     if (tail === "")
       return pkg.pkgName;
-    return `${pkg.pkgName}/${tail.split(path13.sep).join("/")}`;
+    return `${pkg.pkgName}/${tail.split(path15.sep).join("/")}`;
   }
   async#resolveRel(fromFile, relSpec) {
     if (this.#opts.resolveRelative)
@@ -7394,9 +8779,9 @@ var readIfExists = async (absFile) => {
   return file.text();
 };
 var defaultResolveRelative = async (fromFile, relSpec) => {
-  const baseDir = path13.dirname(fromFile);
-  const joined = path13.resolve(baseDir, relSpec);
-  if (path13.extname(joined)) {
+  const baseDir = path15.dirname(fromFile);
+  const joined = path15.resolve(baseDir, relSpec);
+  if (path15.extname(joined)) {
     if (await Bun.file(joined).exists())
       return joined;
     return null;
@@ -7407,7 +8792,7 @@ var defaultResolveRelative = async (fromFile, relSpec) => {
       return cand;
   }
   for (const ext of CANDIDATE_EXTS) {
-    const cand = path13.join(joined, `index${ext}`);
+    const cand = path15.join(joined, `index${ext}`);
     if (await Bun.file(cand).exists())
       return cand;
   }
@@ -7421,15 +8806,15 @@ var stripKnownExt = (relPath) => {
   return relPath;
 };
 var collapseIndex = (relPathNoExt) => {
-  const parts = relPathNoExt.split(path13.sep);
+  const parts = relPathNoExt.split(path15.sep);
   if (parts[parts.length - 1] === "index")
     parts.pop();
-  return parts.join(path13.sep);
+  return parts.join(path15.sep);
 };
 
 // pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
-import path14 from "path";
-import ts5 from "typescript";
+import path16 from "path";
+import ts7 from "typescript";
 var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAfter } = {}) => {
   const akanConfig2 = await app.getConfig();
   const barrels = [...new Set(akanConfig2.barrelImports)].filter(Boolean);
@@ -7487,10 +8872,10 @@ var createTsconfigPackageResolver = async (app) => {
       const raw = exact[0];
       if (!raw)
         return null;
-      const entryFile = path14.resolve(app.workspace.workspaceRoot, raw);
+      const entryFile = path16.resolve(app.workspace.workspaceRoot, raw);
       if (!await Bun.file(entryFile).exists())
         return null;
-      const parsed = path14.parse(entryFile);
+      const parsed = path16.parse(entryFile);
       const lastSlash = pkgName.lastIndexOf("/");
       if (parsed.name !== "index" && lastSlash !== -1) {
         const facet = pkgName.slice(lastSlash + 1);
@@ -7499,7 +8884,7 @@ var createTsconfigPackageResolver = async (app) => {
           return { pkgName: parentSpec, entryFile, pkgDir: parsed.dir };
         }
       }
-      return { pkgName, entryFile, pkgDir: path14.dirname(entryFile) };
+      return { pkgName, entryFile, pkgDir: path16.dirname(entryFile) };
     }
     for (const { prefix, replacements } of wildcardEntries) {
       if (!pkgName.startsWith(prefix))
@@ -7509,7 +8894,7 @@ var createTsconfigPackageResolver = async (app) => {
         if (!repl)
           continue;
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const candidate = path14.resolve(app.workspace.workspaceRoot, replPath + suffix);
+        const candidate = path16.resolve(app.workspace.workspaceRoot, replPath + suffix);
         for (const ext of CANDIDATE_EXTS2) {
           const file = `${candidate}${ext}`;
           if (await Bun.file(file).exists()) {
@@ -7517,14 +8902,14 @@ var createTsconfigPackageResolver = async (app) => {
             if (lastSlash !== -1) {
               const parentSpec = pkgName.slice(0, lastSlash);
               if (parentSpec.length > 0) {
-                return { pkgName: parentSpec, entryFile: file, pkgDir: path14.dirname(file) };
+                return { pkgName: parentSpec, entryFile: file, pkgDir: path16.dirname(file) };
               }
             }
-            return { pkgName, entryFile: file, pkgDir: path14.dirname(file) };
+            return { pkgName, entryFile: file, pkgDir: path16.dirname(file) };
           }
         }
         for (const ext of CANDIDATE_EXTS2) {
-          const file = path14.join(candidate, `index${ext}`);
+          const file = path16.join(candidate, `index${ext}`);
           if (await Bun.file(file).exists()) {
             return { pkgName, entryFile: file, pkgDir: candidate };
           }
@@ -7535,16 +8920,16 @@ var createTsconfigPackageResolver = async (app) => {
     const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
     if (exported)
       return exported;
-    const pkgJsonPath = path14.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
+    const pkgJsonPath = path16.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
     if (!await Bun.file(pkgJsonPath).exists())
       return null;
     try {
       const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
       const rel = pkgJson.module ?? pkgJson.main ?? "index.js";
-      const entryFile = path14.resolve(path14.dirname(pkgJsonPath), rel);
+      const entryFile = path16.resolve(path16.dirname(pkgJsonPath), rel);
       if (!await Bun.file(entryFile).exists())
         return null;
-      return { pkgName, entryFile, pkgDir: path14.dirname(pkgJsonPath) };
+      return { pkgName, entryFile, pkgDir: path16.dirname(pkgJsonPath) };
     } catch {
       return null;
     }
@@ -7558,22 +8943,22 @@ var resolveNodePackageExport = async (workspaceRoot, specifier) => {
   const packageName = getPackageName(specifier);
   if (!packageName)
     return null;
-  const pkgJsonPath = path14.join(workspaceRoot, "node_modules", packageName, "package.json");
+  const pkgJsonPath = path16.join(workspaceRoot, "node_modules", packageName, "package.json");
   if (!await Bun.file(pkgJsonPath).exists())
     return null;
   try {
-    const pkgDir = path14.dirname(pkgJsonPath);
+    const pkgDir = path16.dirname(pkgJsonPath);
     const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
     const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
     const exported = resolvePackageExport(pkgJson.exports, subpath);
     const rel = exported ?? (subpath === "." ? pkgJson.module ?? pkgJson.main ?? "index.js" : null);
     if (!rel || !rel.startsWith("."))
       return null;
-    const entryFile = await resolveFileCandidate(path14.resolve(pkgDir, rel));
+    const entryFile = await resolveFileCandidate(path16.resolve(pkgDir, rel));
     if (!entryFile)
       return null;
     const pkgEntryName = specifier;
-    return { pkgName: pkgEntryName, entryFile, pkgDir: path14.dirname(entryFile), preserveFilePath: true };
+    return { pkgName: pkgEntryName, entryFile, pkgDir: path16.dirname(entryFile), preserveFilePath: true };
   } catch {
     return null;
   }
@@ -7630,7 +9015,7 @@ var getPackageName = (specifier) => {
 var resolveFileCandidate = async (candidate) => {
   if (await Bun.file(candidate).exists())
     return candidate;
-  if (path14.extname(candidate))
+  if (path16.extname(candidate))
     return null;
   for (const ext of CANDIDATE_EXTS2) {
     const file = `${candidate}${ext}`;
@@ -7638,7 +9023,7 @@ var resolveFileCandidate = async (candidate) => {
       return file;
   }
   for (const ext of CANDIDATE_EXTS2) {
-    const file = path14.join(candidate, `index${ext}`);
+    const file = path16.join(candidate, `index${ext}`);
     if (await Bun.file(file).exists())
       return file;
   }
@@ -7670,11 +9055,11 @@ var rewriteBarrelImports = async (source2, barrels, analyzer) => {
 };
 var findImportStatements = (source2) => {
   const statements = [];
-  const sourceFile2 = ts5.createSourceFile("barrel-imports.tsx", source2, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TSX);
+  const sourceFile2 = ts7.createSourceFile("barrel-imports.tsx", source2, ts7.ScriptTarget.Latest, true, ts7.ScriptKind.TSX);
   for (const statement of sourceFile2.statements) {
-    if (!ts5.isImportDeclaration(statement))
+    if (!ts7.isImportDeclaration(statement))
       continue;
-    if (!ts5.isStringLiteral(statement.moduleSpecifier))
+    if (!ts7.isStringLiteral(statement.moduleSpecifier))
       continue;
     const importClause = statement.importClause;
     if (!importClause)
@@ -7852,7 +9237,7 @@ class GraphClientEntryDiscovery {
   }
   invalidate(files) {
     for (const file of files) {
-      const absPath = path15.resolve(file);
+      const absPath = path17.resolve(file);
       this.#readCache.delete(absPath);
       this.#rewriteCache.delete(absPath);
       this.#importCache.delete(absPath);
@@ -7862,7 +9247,7 @@ class GraphClientEntryDiscovery {
       this.#reachableEntriesCache.clear();
   }
   async#fileExists(p) {
-    const absPath = path15.resolve(p);
+    const absPath = path17.resolve(p);
     let cached = this.#fileExistsCache.get(absPath);
     if (!cached) {
       cached = Bun.file(absPath).exists();
@@ -7871,7 +9256,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   #readFile(file) {
-    const absPath = path15.resolve(file);
+    const absPath = path17.resolve(file);
     let cached = this.#readCache.get(absPath);
     if (!cached) {
       cached = Bun.file(absPath).text().catch(() => null);
@@ -7880,7 +9265,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#resolveFileCandidate(absPathNoExt) {
-    const cacheKey = path15.resolve(absPathNoExt);
+    const cacheKey = path17.resolve(absPathNoExt);
     let cached = this.#resolvedFileCache.get(cacheKey);
     if (cached)
       return cached;
@@ -7893,7 +9278,7 @@ class GraphClientEntryDiscovery {
           return f;
       }
       for (const ext of SOURCE_EXTS2) {
-        const f = path15.join(cacheKey, `index${ext}`);
+        const f = path17.join(cacheKey, `index${ext}`);
         if (await this.#fileExists(f))
           return f;
       }
@@ -7909,7 +9294,7 @@ class GraphClientEntryDiscovery {
       return cached;
     cached = (async () => {
       if (spec.startsWith(".") || spec.startsWith("/")) {
-        const abs = spec.startsWith("/") ? spec : path15.resolve(importerDir, spec);
+        const abs = spec.startsWith("/") ? spec : path17.resolve(importerDir, spec);
         return this.#resolveFileCandidate(abs);
       }
       const pkg = await this.#resolvePackage(spec);
@@ -7921,7 +9306,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#getRewrittenSource(file, content) {
-    const absPath = path15.resolve(file);
+    const absPath = path17.resolve(file);
     let cached = this.#rewriteCache.get(absPath);
     if (!cached) {
       cached = (async () => {
@@ -7938,7 +9323,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#getImports(file, source2) {
-    const absPath = path15.resolve(file);
+    const absPath = path17.resolve(file);
     let cached = this.#importCache.get(absPath);
     if (!cached) {
       cached = Promise.resolve().then(() => {
@@ -7953,7 +9338,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#discoverFromFile(file, visiting) {
-    const absPath = path15.resolve(file);
+    const absPath = path17.resolve(file);
     const cached = this.#reachableEntriesCache.get(absPath);
     if (cached)
       return new Set(cached);
@@ -7970,7 +9355,7 @@ class GraphClientEntryDiscovery {
     }
     const source2 = await this.#getRewrittenSource(absPath, content);
     const imports = await this.#getImports(absPath, source2);
-    const importerDir = path15.dirname(absPath);
+    const importerDir = path17.dirname(absPath);
     for (const imp of imports) {
       const spec = imp.path;
       if (!spec)
@@ -7996,14 +9381,14 @@ class GraphClientEntryDiscovery {
 
 // pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
 import { mkdir as mkdir4 } from "fs/promises";
-import path18 from "path";
+import path20 from "path";
 
 // pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
-import path16 from "path";
+import path18 from "path";
 var USE_CLIENT_RE2 = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
 var IMPLICIT_ROOT_LAYOUT_RE = /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-layout|root-layouts[/\\].*__root_layout)\.(tsx|ts|jsx|js)$/;
 function toClientReferencePath(absPath, workspaceRoot) {
-  return path16.relative(path16.resolve(workspaceRoot), path16.resolve(absPath)).split(path16.sep).join("/");
+  return path18.relative(path18.resolve(workspaceRoot), path18.resolve(absPath)).split(path18.sep).join("/");
 }
 function transformUseClient(source2, args) {
   if (!USE_CLIENT_RE2.test(source2))
@@ -8039,7 +9424,7 @@ function loaderFor2(absPath) {
 
 // pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
 import fs2 from "fs";
-import path17 from "path";
+import path19 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/clientBuildTypes.ts
 var CLIENT_BUNDLE_NAMING = {
@@ -8128,23 +9513,23 @@ class ClientEntriesBundler {
     };
   }
   async#createOpaqueEntryAliases() {
-    const aliasDir = path17.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
+    const aliasDir = path19.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
     fs2.mkdirSync(aliasDir, { recursive: true });
     const originalByAlias = new Map;
     const aliasedEntries = await Promise.all(this.#entries.map(async (entry) => {
-      const absEntry = path17.resolve(entry);
+      const absEntry = path19.resolve(entry);
       const hash = Bun.hash(`${this.#app.name}
 ${this.#outputSubdir}
 ${absEntry}`).toString(36);
-      const aliasPath = path17.join(aliasDir, `${hash}.tsx`);
+      const aliasPath = path19.join(aliasDir, `${hash}.tsx`);
       await Bun.write(aliasPath, this.#createOpaqueEntryAliasSource(absEntry, await this.#scanEntryExportNames(absEntry)));
-      originalByAlias.set(path17.resolve(aliasPath), absEntry);
+      originalByAlias.set(path19.resolve(aliasPath), absEntry);
       return aliasPath;
     }));
     return { entries: aliasedEntries, originalByAlias, aliasDir };
   }
   #createOpaqueEntryAliasSource(absEntry, exportNames) {
-    const entryLit = JSON.stringify(path17.resolve(absEntry));
+    const entryLit = JSON.stringify(path19.resolve(absEntry));
     if (exportNames.length === 0)
       return `export * from ${entryLit};
 `;
@@ -8227,16 +9612,16 @@ ${absEntry}`).toString(36);
     return rewritten;
   }
   #toServeUrl(absOutPath) {
-    const rel = path17.relative(this.#outdir, absOutPath).split(path17.sep).join("/");
+    const rel = path19.relative(this.#outdir, absOutPath).split(path19.sep).join("/");
     return `${this.#servePrefix}/${rel}`;
   }
   #absFromOutdir(p) {
-    return path17.isAbsolute(p) ? p : path17.resolve(this.#outdir, p);
+    return path19.isAbsolute(p) ? p : path19.resolve(this.#outdir, p);
   }
   #absFromEntryPoint(p) {
-    if (path17.isAbsolute(p))
-      return path17.resolve(p);
-    const candidates = [path17.resolve(process.cwd(), p), path17.resolve(this.#app.cwdPath, p)];
+    if (path19.isAbsolute(p))
+      return path19.resolve(p);
+    const candidates = [path19.resolve(process.cwd(), p), path19.resolve(this.#app.cwdPath, p)];
     return candidates.find((candidate) => fs2.existsSync(candidate)) ?? candidates[0];
   }
   #collectChunkUrls(absOutPath, visited = new Set) {
@@ -8386,13 +9771,13 @@ class RouteClientBuilder {
       ssrModuleMap[row.id][row.name] = { id: ssrOutput, chunks: [ssrOutput, ssrOutput], name: row.name, async: true };
     }
     for (const entry of bootstrapEntries.buildEntries) {
-      const buildEntry = path18.resolve(entry);
-      const originalEntry = path18.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
+      const buildEntry = path20.resolve(entry);
+      const originalEntry = path20.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
       if (!acceptedEntries.has(originalEntry))
         continue;
       const deps = new Set([originalEntry]);
       for (const dep of browserBundle.entryDepsByAbsPath.get(buildEntry) ?? [])
-        deps.add(path18.resolve(dep));
+        deps.add(path20.resolve(dep));
       const sortedDeps = [...deps].sort();
       clientDepsByEntry[originalEntry] = sortedDeps;
       for (const dep of sortedDeps)
@@ -8444,25 +9829,25 @@ class RouteClientBuilder {
     }).bundle();
   }
   async#createBootstrapEntries(entries) {
-    if (!await Bun.file(path18.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
+    if (!await Bun.file(path20.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
       return { buildEntries: entries, originalByBuildEntry: new Map };
     }
-    const outdir = path18.join(this.#app.cwdPath, ".akan", "generated", "client-entry-bootstrap");
+    const outdir = path20.join(this.#app.cwdPath, ".akan", "generated", "client-entry-bootstrap");
     await mkdir4(outdir, { recursive: true });
     const originalByBuildEntry = new Map;
     const buildEntries = await Promise.all(entries.map(async (entry) => {
-      const absEntry = path18.resolve(entry);
+      const absEntry = path20.resolve(entry);
       const hash = Bun.hash(`${this.#app.name}
 ${absEntry}`).toString(36);
-      const base = path18.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
-      const wrapperEntry = path18.join(outdir, `${base}-${hash}.tsx`);
+      const base = path20.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
+      const wrapperEntry = path20.join(outdir, `${base}-${hash}.tsx`);
       const exportNames = await this.#scanExportNames(absEntry);
       await Bun.write(wrapperEntry, RouteClientBuilder.createStoreBootstrapEntrySource({
         appName: this.#app.name,
         originalEntry: absEntry,
         exportNames
       }));
-      originalByBuildEntry.set(path18.resolve(wrapperEntry), absEntry);
+      originalByBuildEntry.set(path20.resolve(wrapperEntry), absEntry);
       return wrapperEntry;
     }));
     return { buildEntries, originalByBuildEntry };
@@ -8514,11 +9899,11 @@ ${defaultNames.map((name) => `export default ${name};`).join(`
     try {
       return Bun.resolveSync("akanjs/server", import.meta.dir);
     } catch {
-      return path18.resolve(import.meta.dir, "../../../server/index.ts");
+      return path20.resolve(import.meta.dir, "../../../server/index.ts");
     }
   }
   static createStoreBootstrapEntrySource(args) {
-    const originalEntry = JSON.stringify(path18.resolve(args.originalEntry));
+    const originalEntry = JSON.stringify(path20.resolve(args.originalEntry));
     const namedExports = args.exportNames.filter((name) => name !== "default");
     const lines = [
       `import ${JSON.stringify(`@apps/${args.appName}/client`)};`,
@@ -8544,7 +9929,7 @@ ${defaultNames.map((name) => `export default ${name};`).join(`
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/routesManifestArtifactSerializer.ts
-import path19 from "path";
+import path21 from "path";
 
 class RoutesManifestArtifactSerializer {
   #manifest;
@@ -8552,7 +9937,7 @@ class RoutesManifestArtifactSerializer {
   #production;
   constructor(manifest, artifactDir, options = {}) {
     this.#manifest = manifest;
-    this.#artifactDir = path19.resolve(artifactDir);
+    this.#artifactDir = path21.resolve(artifactDir);
     this.#production = options.production ?? false;
   }
   static serialize(manifest, artifactDir, options = {}) {
@@ -8585,9 +9970,9 @@ class RoutesManifestArtifactSerializer {
     };
   }
   #serializeArtifactPath(artifactPath) {
-    if (!path19.isAbsolute(artifactPath))
+    if (!path21.isAbsolute(artifactPath))
       return artifactPath;
-    return path19.relative(this.#artifactDir, artifactPath).split(path19.sep).join("/");
+    return path21.relative(this.#artifactDir, artifactPath).split(path21.sep).join("/");
   }
 }
 
@@ -8627,7 +10012,7 @@ class AllRoutesBuilder {
       routeIds: this.#routeIds,
       ...this.#merged
     };
-    const manifestPath = path20.join(path20.resolve(this.#artifactDir), "routes-manifest.json");
+    const manifestPath = path22.join(path22.resolve(this.#artifactDir), "routes-manifest.json");
     await Bun.write(manifestPath, `${JSON.stringify(RoutesManifestArtifactSerializer.serialize(manifest, this.#artifactDir, {
       production: this.#command === "build"
     }), null, 2)}
@@ -8664,12 +10049,12 @@ class AllRoutesBuilder {
 }
 // pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
 import { mkdir as mkdir5, rm, unlink } from "fs/promises";
-import path22 from "path";
+import path24 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
 import fs3 from "fs";
-import path21 from "path";
-import ts6 from "typescript";
+import path23 from "path";
+import ts8 from "typescript";
 
 class PagesEntrySourceGenerator {
   #pageEntries;
@@ -8681,7 +10066,7 @@ class PagesEntrySourceGenerator {
   }
   generate() {
     const lines = this.#pageEntries.map(({ key, moduleAbsPath }) => {
-      const absPath = path21.resolve(moduleAbsPath);
+      const absPath = path23.resolve(moduleAbsPath);
       return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(absPath)}),`;
     });
     return `export const pages = {
@@ -8695,7 +10080,7 @@ ${lines.join(`
   }
   generateStatic() {
     const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
-      const absPath = path21.resolve(moduleAbsPath);
+      const absPath = path23.resolve(moduleAbsPath);
       return `import * as page${index} from ${JSON.stringify(absPath)};`;
     });
     const entries = this.#pageEntries.map(({ key, moduleAbsPath }, index) => {
@@ -8712,8 +10097,8 @@ ${entries.join(`
   }
   static #hasAsyncDefaultExport(moduleAbsPath) {
     try {
-      const source2 = fs3.readFileSync(path21.resolve(moduleAbsPath), "utf8");
-      const sourceFile2 = ts6.createSourceFile(moduleAbsPath, source2, ts6.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
+      const source2 = fs3.readFileSync(path23.resolve(moduleAbsPath), "utf8");
+      const sourceFile2 = ts8.createSourceFile(moduleAbsPath, source2, ts8.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
       return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile2);
     } catch {
       return false;
@@ -8723,31 +10108,31 @@ ${entries.join(`
     const asyncBindings = new Map;
     let defaultIdentifier = null;
     for (const statement of sourceFile2.statements) {
-      if (ts6.isFunctionDeclaration(statement)) {
-        if (PagesEntrySourceGenerator.#hasModifier(statement, ts6.SyntaxKind.DefaultKeyword)) {
-          return PagesEntrySourceGenerator.#hasModifier(statement, ts6.SyntaxKind.AsyncKeyword);
+      if (ts8.isFunctionDeclaration(statement)) {
+        if (PagesEntrySourceGenerator.#hasModifier(statement, ts8.SyntaxKind.DefaultKeyword)) {
+          return PagesEntrySourceGenerator.#hasModifier(statement, ts8.SyntaxKind.AsyncKeyword);
         }
         if (statement.name) {
-          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts6.SyntaxKind.AsyncKeyword));
+          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts8.SyntaxKind.AsyncKeyword));
         }
         continue;
       }
-      if (ts6.isVariableStatement(statement)) {
+      if (ts8.isVariableStatement(statement)) {
         for (const declaration of statement.declarationList.declarations) {
-          if (!ts6.isIdentifier(declaration.name))
+          if (!ts8.isIdentifier(declaration.name))
             continue;
           asyncBindings.set(declaration.name.text, PagesEntrySourceGenerator.#isAsyncFunctionExpression(declaration.initializer));
         }
         continue;
       }
-      if (ts6.isExportAssignment(statement)) {
+      if (ts8.isExportAssignment(statement)) {
         if (PagesEntrySourceGenerator.#isAsyncFunctionExpression(statement.expression))
           return true;
-        if (ts6.isIdentifier(statement.expression))
+        if (ts8.isIdentifier(statement.expression))
           defaultIdentifier = statement.expression.text;
         continue;
       }
-      if (ts6.isExportDeclaration(statement) && statement.exportClause && ts6.isNamedExports(statement.exportClause)) {
+      if (ts8.isExportDeclaration(statement) && statement.exportClause && ts8.isNamedExports(statement.exportClause)) {
         const exportClause = statement.exportClause;
         for (const specifier of exportClause.elements) {
           if (specifier.name.text !== "default")
@@ -8759,13 +10144,13 @@ ${entries.join(`
     return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
   }
   static #hasModifier(node, kind) {
-    return ts6.canHaveModifiers(node) && (ts6.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+    return ts8.canHaveModifiers(node) && (ts8.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
   }
   static #isAsyncFunctionExpression(node) {
-    return Boolean(node && (ts6.isArrowFunction(node) || ts6.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts6.SyntaxKind.AsyncKeyword));
+    return Boolean(node && (ts8.isArrowFunction(node) || ts8.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts8.SyntaxKind.AsyncKeyword));
   }
   static #scriptKind(moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts6.ScriptKind.TSX : ts6.ScriptKind.TS;
+    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS;
   }
 }
 
@@ -8791,7 +10176,7 @@ class CsrArtifactBuilder {
     const csrBasePaths = [...akanConfig2.basePaths];
     const htmlEntries = csrBasePaths.length > 0 ? csrBasePaths : ["index"];
     await rm(this.#outputDir, { recursive: true, force: true });
-    await mkdir5(path22.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
+    await mkdir5(path24.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
     const generatedHtmlFiles = Object.fromEntries(htmlEntries.map((basePath2) => this.#createHtmlFile(basePath2)));
     const result = await Bun.build({
       target: "browser",
@@ -8823,7 +10208,7 @@ ${logs}` : ""}`);
     return { outputDir: this.#outputDir };
   }
   get #outputDir() {
-    return path22.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
+    return path24.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
   }
   #define() {
     const nodeEnv = this.#command === "build" ? "production" : "development";
@@ -8854,8 +10239,8 @@ ${logs}` : ""}`);
     ];
   }
   async#loadCsrArtifact() {
-    const artifactDir = path22.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
-    const artifactFile = Bun.file(path22.join(artifactDir, "base-artifact.json"));
+    const artifactDir = path24.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+    const artifactFile = Bun.file(path24.join(artifactDir, "base-artifact.json"));
     if (!await artifactFile.exists())
       return { cssAssets: {} };
     const artifact = await artifactFile.json();
@@ -8868,7 +10253,7 @@ ${logs}` : ""}`);
       const htmlFile = Bun.file(htmlPath);
       if (!await htmlFile.exists())
         continue;
-      const basePath2 = path22.basename(htmlPath, ".html") === "index" ? "" : path22.basename(htmlPath, ".html");
+      const basePath2 = path24.basename(htmlPath, ".html") === "index" ? "" : path24.basename(htmlPath, ".html");
       const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAssets[basePath2]);
       for (const filePath of inlined.jsFiles)
         jsFiles.add(filePath);
@@ -8910,7 +10295,7 @@ ${remainingAssets.join(`
         next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
     }
     if (cssAsset) {
-      const cssPath = path22.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
+      const cssPath = path24.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
       const css = await Bun.file(cssPath).text();
       const style = CsrArtifactBuilder.createInlineStyle(css);
       if (!next.includes(style))
@@ -8981,16 +10366,16 @@ ${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
       throw new Error(`[csr-build] cannot inline external script: ${src}`);
     }
     const normalized = src.startsWith("/") ? src.slice(1) : src;
-    return path22.resolve(path22.dirname(htmlPath), normalized);
+    return path24.resolve(path24.dirname(htmlPath), normalized);
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-import path24 from "path";
+import path26 from "path";
 import { Logger as Logger8 } from "akanjs/common";
 import { compile } from "tailwindcss";
 
 // pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
-import path23 from "path";
+import path25 from "path";
 var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
 
 class CssImportResolver {
@@ -9043,7 +10428,7 @@ class CssImportResolver {
     const exact = this.#paths[id];
     if (exact) {
       for (const repl of exact) {
-        const resolved = await this.#firstExisting(path23.resolve(this.#workspaceRoot, repl));
+        const resolved = await this.#firstExisting(path25.resolve(this.#workspaceRoot, repl));
         if (resolved)
           return resolved;
       }
@@ -9054,7 +10439,7 @@ class CssImportResolver {
       const suffix = id.slice(prefix.length);
       for (const repl of replacements) {
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const resolved = await this.#firstExisting(path23.resolve(this.#workspaceRoot, replPath + suffix));
+        const resolved = await this.#firstExisting(path25.resolve(this.#workspaceRoot, replPath + suffix));
         if (resolved)
           return resolved;
       }
@@ -9084,25 +10469,25 @@ class CssImportResolver {
     try {
       if (!await Bun.file(pkgPath).exists())
         return null;
-      const pkgDir = path23.dirname(pkgPath);
+      const pkgDir = path25.dirname(pkgPath);
       const pkg = await Bun.file(pkgPath).json();
       const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
       const exportValue = pkg.exports?.[subpath];
       const styleEntry = (typeof exportValue === "string" ? exportValue : exportValue?.style || exportValue?.import || exportValue?.default) || pkg.exports?.["."]?.style || pkg.style || "index.css";
-      return await this.#firstExisting(path23.resolve(pkgDir, styleEntry));
+      return await this.#firstExisting(path25.resolve(pkgDir, styleEntry));
     } catch {
       return null;
     }
   }
   #resolutionBases(fromBase) {
-    return [fromBase, this.#workspaceRoot, path23.dirname(Bun.main), path23.resolve(path23.dirname(Bun.main), "../..")];
+    return [fromBase, this.#workspaceRoot, path25.dirname(Bun.main), path25.resolve(path25.dirname(Bun.main), "../..")];
   }
   #packageJsonCandidates(pkgName) {
     return [
-      path23.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
-      path23.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
-      path23.join(path23.dirname(Bun.main), "node_modules", pkgName, "package.json"),
-      path23.join(path23.dirname(Bun.main), "../../", pkgName, "package.json")
+      path25.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
+      path25.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
+      path25.join(path25.dirname(Bun.main), "node_modules", pkgName, "package.json"),
+      path25.join(path25.dirname(Bun.main), "../../", pkgName, "package.json")
     ];
   }
   async#firstExisting(basePath2) {
@@ -9120,7 +10505,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path23.extname(filePath) === ".css";
+    return path25.extname(filePath) === ".css";
   }
 }
 
@@ -9187,7 +10572,7 @@ class CssCompiler {
     pageKeys
   } = {}) {
     pageKeys ??= await this.#app.getPageKeys({ refresh });
-    const seeds = pageKeys.map((key) => path24.resolve(this.#app.cwdPath, "page", key));
+    const seeds = pageKeys.map((key) => path26.resolve(this.#app.cwdPath, "page", key));
     const cssFiles = new Set;
     const sourceFiles = new Set;
     const queue = [...seeds];
@@ -9219,7 +10604,7 @@ class CssCompiler {
       } catch {
         continue;
       }
-      const importerDir = path24.dirname(filePath);
+      const importerDir = path26.dirname(filePath);
       for (const imp of imports) {
         const spec = imp.path;
         if (!spec)
@@ -9245,7 +10630,7 @@ class CssCompiler {
     const compileStarted = Date.now();
     const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
       const css = await Bun.file(cssPath).text();
-      const base = path24.dirname(cssPath);
+      const base = path26.dirname(cssPath);
       const compiler = await compile(css, {
         base,
         loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
@@ -9276,11 +10661,11 @@ class CssCompiler {
   async#loadStylesheet(id, fromBase) {
     const p = await this.#resolveCssImport(id, fromBase);
     const content = await Bun.file(p).text();
-    return { path: p, base: path24.dirname(p), content };
+    return { path: p, base: path26.dirname(p), content };
   }
   async#resolveCssImport(id, fromBase) {
     if (id.startsWith(".") || id.startsWith("/"))
-      return path24.resolve(fromBase, id);
+      return path26.resolve(fromBase, id);
     const resolver = await this.#getCssImportResolver();
     const resolved = await resolver.resolve(id, fromBase);
     if (resolved)
@@ -9296,11 +10681,11 @@ class CssCompiler {
   async#loadModule(id, fromBase) {
     const p = __require.resolve(id, { paths: [fromBase] });
     const mod = await import(p);
-    return { path: p, base: path24.dirname(p), module: mod.default ?? mod };
+    return { path: p, base: path26.dirname(p), module: mod.default ?? mod };
   }
   async#resolveSourceImport(id, fromBase, resolvePackage) {
     if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path24.resolve(fromBase, id);
+      const abs = id.startsWith("/") ? id : path26.resolve(fromBase, id);
       return resolveSourceFileCandidate(abs);
     }
     const pkg = await resolvePackage(id);
@@ -9342,7 +10727,7 @@ async function resolveSourceFileCandidate(absPathNoExt) {
       return filePath;
   }
   for (const ext of SOURCE_EXTS3) {
-    const filePath = path24.join(absPathNoExt, `index${ext}`);
+    const filePath = path26.join(absPathNoExt, `index${ext}`);
     if (await Bun.file(filePath).exists())
       return filePath;
   }
@@ -9365,19 +10750,19 @@ function resolveSourceWithRequire(id, fromBase) {
   }
 }
 function isSourceFile(filePath) {
-  return SOURCE_EXTS3.includes(path24.extname(filePath));
+  return SOURCE_EXTS3.includes(path26.extname(filePath));
 }
 function isIgnoredNodeModuleSource(filePath) {
   return NODE_MODULES_RE3.test(filePath) && !AKANJS_NODE_MODULE_RE3.test(filePath);
 }
 function getPageKeyBasePath(pageKey, basePaths) {
-  const normalized = pageKey.split(path24.sep).join("/").replace(/^\.\//, "");
+  const normalized = pageKey.split(path26.sep).join("/").replace(/^\.\//, "");
   const segments = normalized.split("/");
   const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
   return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
 }
 // pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
-import path25 from "path";
+import path27 from "path";
 var SOURCE_EXTS4 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
 var BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit"]);
@@ -9389,11 +10774,11 @@ var RUNTIME_METADATA_BASENAMES2 = new Set(["dict.ts", "sig.ts", "useClient.ts",
 class DevChangePlanner {
   #workspaceRoot;
   constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path25.resolve(workspaceRoot);
+    this.#workspaceRoot = path27.resolve(workspaceRoot);
   }
   plan({ generation, files, kinds, generatedFiles: generatedFiles2 = [] }) {
     const fileList = uniqueResolved([...files, ...generatedFiles2]);
-    const generatedSet = new Set(generatedFiles2.map((file) => path25.resolve(file)));
+    const generatedSet = new Set(generatedFiles2.map((file) => path27.resolve(file)));
     const kindSet = new Set(kinds);
     const roles = new Set;
     const actions = new Set;
@@ -9410,13 +10795,13 @@ class DevChangePlanner {
     }
     for (const file of fileList) {
       const reasons = new Set;
-      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path25.resolve(file)), reasons });
+      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path27.resolve(file)), reasons });
       for (const role of fileRoles)
         roles.add(role);
       if (reasons.has("runtime-metadata"))
         actions.add("restart-builder");
       if (reasons.size > 0)
-        reasonByFile[path25.resolve(file)] = [...reasons].sort();
+        reasonByFile[path27.resolve(file)] = [...reasons].sort();
     }
     if (roles.has("barrel"))
       actions.add("sync-generated");
@@ -9437,12 +10822,12 @@ class DevChangePlanner {
   }
   #rolesForFile(file, { isGenerated, reasons }) {
     const roles = new Set;
-    const abs = path25.resolve(file);
-    const base = path25.basename(abs);
-    const ext = path25.extname(abs).toLowerCase();
+    const abs = path27.resolve(file);
+    const base = path27.basename(abs);
+    const ext = path27.extname(abs).toLowerCase();
     const isSource = SOURCE_EXTS4.has(ext);
-    const rel = path25.relative(this.#workspaceRoot, abs);
-    const parts = rel.split(path25.sep).filter(Boolean);
+    const rel = path27.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path27.sep).filter(Boolean);
     if (CONFIG_BASENAMES.has(base)) {
       roles.add("config");
       reasons.add("config-file");
@@ -9483,15 +10868,15 @@ class DevChangePlanner {
     return roles;
   }
   #isServerBiased(abs, parts) {
-    const base = path25.basename(abs);
+    const base = path27.basename(abs);
     return parts.includes("srvkit") || SERVER_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
   }
   #isClientBiased(abs, parts) {
-    const base = path25.basename(abs);
+    const base = path27.basename(abs);
     return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
   }
   #isSharedBiased(abs, parts) {
-    const base = path25.basename(abs);
+    const base = path27.basename(abs);
     return parts.includes("common") || SHARED_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES2.has(base);
   }
   #isRuntimeMetadataFile(parts, base) {
@@ -9516,16 +10901,16 @@ class DevChangePlanner {
     return true;
   }
   #isWorkspaceSource(rel) {
-    if (!rel || rel.startsWith("..") || path25.isAbsolute(rel))
+    if (!rel || rel.startsWith("..") || path27.isAbsolute(rel))
       return false;
-    const [scope] = rel.split(path25.sep);
+    const [scope] = rel.split(path27.sep);
     return scope === "apps" || scope === "libs" || scope === "pkgs";
   }
 }
-var uniqueResolved = (files) => [...new Set(files.map((file) => path25.resolve(file)))].sort();
+var uniqueResolved = (files) => [...new Set(files.map((file) => path27.resolve(file)))].sort();
 // pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
 import { mkdir as mkdir6, readdir as readdir2, readFile, rm as rm2, stat as stat3, writeFile } from "fs/promises";
-import path26 from "path";
+import path28 from "path";
 var BARREL_FACETS2 = new Set(["common", "srvkit", "ui", "webkit"]);
 var FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
 var FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
@@ -9536,7 +10921,7 @@ var SCALAR_UI_TYPES = ["Template", "Unit"];
 class DevGeneratedIndexSync {
   #workspaceRoot;
   constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path26.resolve(workspaceRoot);
+    this.#workspaceRoot = path28.resolve(workspaceRoot);
   }
   async syncForBatch(files) {
     const indexPaths = new Set;
@@ -9545,12 +10930,12 @@ class DevGeneratedIndexSync {
       const facetIndex = this.#facetIndexFor(file);
       if (facetIndex)
         indexPaths.add(facetIndex);
-      const moduleIndex = await this.#moduleIndexForDirectoryEvent(file).catch((err) => {
+      const moduleIndex2 = await this.#moduleIndexForDirectoryEvent(file).catch((err) => {
         errors.push(`[generated-index] module detection failed for ${file}: ${formatError(err)}`);
         return null;
       });
-      if (moduleIndex)
-        indexPaths.add(moduleIndex);
+      if (moduleIndex2)
+        indexPaths.add(moduleIndex2);
     }
     const changedFiles = [];
     for (const indexPath of [...indexPaths].sort()) {
@@ -9565,11 +10950,11 @@ class DevGeneratedIndexSync {
     return { changedFiles, errors };
   }
   #facetIndexFor(file) {
-    const abs = path26.resolve(file);
-    const rel = path26.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path26.isAbsolute(rel))
+    const abs = path28.resolve(file);
+    const rel = path28.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path28.isAbsolute(rel))
       return null;
-    const parts = rel.split(path26.sep).filter(Boolean);
+    const parts = rel.split(path28.sep).filter(Boolean);
     if (parts.length < 4)
       return null;
     const [scope, project, facet, child] = parts;
@@ -9577,32 +10962,32 @@ class DevGeneratedIndexSync {
       return null;
     if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
       return null;
-    return path26.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+    return path28.join(this.#workspaceRoot, scope, project, facet, "index.ts");
   }
   async#moduleIndexForDirectoryEvent(file) {
-    const abs = path26.resolve(file);
-    const rel = path26.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path26.isAbsolute(rel))
+    const abs = path28.resolve(file);
+    const rel = path28.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path28.isAbsolute(rel))
       return null;
-    const parts = rel.split(path26.sep).filter(Boolean);
+    const parts = rel.split(path28.sep).filter(Boolean);
     if (parts.length !== 4 && parts.length !== 5)
       return null;
     const [scope, project, libSegment, moduleSegment, scalarSegment] = parts;
     if (scope !== "apps" && scope !== "libs" || !project || libSegment !== "lib")
       return null;
     const isExistingDirectory = await stat3(abs).then((s) => s.isDirectory()).catch(() => false);
-    const looksLikeDeletedDirectory = !path26.extname(abs);
+    const looksLikeDeletedDirectory = !path28.extname(abs);
     if (!isExistingDirectory && !looksLikeDeletedDirectory)
       return null;
     if (moduleSegment === "__scalar" && scalarSegment) {
-      return path26.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+      return path28.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
     }
     if (!moduleSegment || moduleSegment === "__scalar")
       return null;
-    return path26.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+    return path28.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
   }
   async#syncIndex(indexPath) {
-    const dir = path26.dirname(indexPath);
+    const dir = path28.dirname(indexPath);
     const content = await this.#contentForIndex(indexPath);
     if (content === null) {
       if (!await exists(indexPath))
@@ -9618,11 +11003,11 @@ class DevGeneratedIndexSync {
     return true;
   }
   async#contentForIndex(indexPath) {
-    const parts = path26.relative(this.#workspaceRoot, indexPath).split(path26.sep).filter(Boolean);
+    const parts = path28.relative(this.#workspaceRoot, indexPath).split(path28.sep).filter(Boolean);
     const facet = parts.at(-2);
     if (facet && BARREL_FACETS2.has(facet))
-      return this.#facetContent(path26.dirname(indexPath));
-    return this.#moduleContent(path26.dirname(indexPath));
+      return this.#facetContent(path28.dirname(indexPath));
+    return this.#moduleContent(path28.dirname(indexPath));
   }
   async#facetContent(dir) {
     const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
@@ -9645,8 +11030,8 @@ class DevGeneratedIndexSync {
 `;
   }
   async#moduleContent(dir) {
-    const rel = path26.relative(this.#workspaceRoot, dir);
-    const parts = rel.split(path26.sep).filter(Boolean);
+    const rel = path28.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path28.sep).filter(Boolean);
     const moduleSegment = parts.at(-1);
     if (!moduleSegment)
       return null;
@@ -9654,11 +11039,11 @@ class DevGeneratedIndexSync {
     const rawModel = moduleSegment.startsWith("_") ? moduleSegment.slice(1) : moduleSegment;
     if (!rawModel)
       return null;
-    const modelName = capitalize5(rawModel);
+    const modelName = capitalize4(rawModel);
     const allowedTypes = isScalar ? SCALAR_UI_TYPES : moduleSegment.startsWith("_") ? SERVICE_UI_TYPES : MODULE_UI_TYPES;
     const fileTypes = [];
     for (const type of allowedTypes) {
-      if (await exists(path26.join(dir, `${modelName}.${type}.tsx`)))
+      if (await exists(path28.join(dir, `${modelName}.${type}.tsx`)))
         fileTypes.push(type);
     }
     if (fileTypes.length === 0)
@@ -9671,11 +11056,11 @@ export const ${modelName} = { ${fileTypes.join(", ")} };`;
   }
 }
 var exists = async (file) => stat3(file).then(() => true).catch(() => false);
-var capitalize5 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+var capitalize4 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
 var formatError = (err) => err instanceof Error ? err.message : String(err);
 // pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
 import { mkdir as mkdir7 } from "fs/promises";
-import path27 from "path";
+import path29 from "path";
 import {
   generateFontFace,
   getMetricsForFamily,
@@ -9684,7 +11069,7 @@ import {
 } from "fontaine";
 import { createFont, woff2 } from "fonteditor-core";
 import subsetFont from "subset-font";
-import ts7 from "typescript";
+import ts9 from "typescript";
 var FONT_URL_PREFIX = "/_akan/fonts";
 var DEFAULT_FONT_SUBSETS = ["latin"];
 
@@ -9699,7 +11084,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path27.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path29.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -9718,7 +11103,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path27.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path29.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -9734,8 +11119,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path27.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir7(path27.dirname(outputPath), { recursive: true });
+      const outputPath = path29.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir7(path29.dirname(outputPath), { recursive: true });
       const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
       const outputBuffer = font.subset === false ? await this.#convertToWoff2(sourceBuffer, sourcePath) : await subsetFont(sourceBuffer, await this.#getSubsetText(font), { targetFormat: "woff2" });
       await Bun.write(outputPath, outputBuffer);
@@ -9749,17 +11134,17 @@ class FontOptimizer {
       this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
   }
   #extractFontsExport(source2, filePath) {
-    const sourceFile2 = ts7.createSourceFile(filePath, source2, ts7.ScriptTarget.Latest, true, ts7.ScriptKind.TSX);
+    const sourceFile2 = ts9.createSourceFile(filePath, source2, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TSX);
     const fonts = [];
     for (const statement of sourceFile2.statements) {
-      if (!ts7.isVariableStatement(statement))
+      if (!ts9.isVariableStatement(statement))
         continue;
-      const modifiers = ts7.canHaveModifiers(statement) ? ts7.getModifiers(statement) : undefined;
-      const isExported = modifiers?.some((modifier) => modifier.kind === ts7.SyntaxKind.ExportKeyword) ?? false;
+      const modifiers = ts9.canHaveModifiers(statement) ? ts9.getModifiers(statement) : undefined;
+      const isExported = modifiers?.some((modifier) => modifier.kind === ts9.SyntaxKind.ExportKeyword) ?? false;
       if (!isExported)
         continue;
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts7.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
+        if (!ts9.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
           continue;
         const value = declaration.initializer ? this.#literalToValue(declaration.initializer) : null;
         if (Array.isArray(value)) {
@@ -9770,20 +11155,20 @@ class FontOptimizer {
     return fonts;
   }
   #literalToValue(node) {
-    if (ts7.isStringLiteralLike(node))
+    if (ts9.isStringLiteralLike(node))
       return node.text;
-    if (ts7.isNumericLiteral(node))
+    if (ts9.isNumericLiteral(node))
       return Number(node.text);
-    if (node.kind === ts7.SyntaxKind.TrueKeyword)
+    if (node.kind === ts9.SyntaxKind.TrueKeyword)
       return true;
-    if (node.kind === ts7.SyntaxKind.FalseKeyword)
+    if (node.kind === ts9.SyntaxKind.FalseKeyword)
       return false;
-    if (ts7.isArrayLiteralExpression(node))
+    if (ts9.isArrayLiteralExpression(node))
       return node.elements.map((element) => this.#literalToValue(element));
-    if (ts7.isObjectLiteralExpression(node)) {
+    if (ts9.isObjectLiteralExpression(node)) {
       const obj = {};
       for (const prop of node.properties) {
-        if (!ts7.isPropertyAssignment(prop))
+        if (!ts9.isPropertyAssignment(prop))
           continue;
         const name = this.#getPropertyName(prop.name);
         if (!name)
@@ -9792,13 +11177,13 @@ class FontOptimizer {
       }
       return obj;
     }
-    if (ts7.isAsExpression(node) || ts7.isSatisfiesExpression(node) || ts7.isParenthesizedExpression(node)) {
+    if (ts9.isAsExpression(node) || ts9.isSatisfiesExpression(node) || ts9.isParenthesizedExpression(node)) {
       return this.#literalToValue(node.expression);
     }
     return;
   }
   #getPropertyName(name) {
-    if (ts7.isIdentifier(name) || ts7.isStringLiteral(name) || ts7.isNumericLiteral(name))
+    if (ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNumericLiteral(name))
       return name.text;
     return null;
   }
@@ -9882,8 +11267,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path27.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path27.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path29.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path29.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -9911,7 +11296,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path27.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path29.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -9920,7 +11305,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path27.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path29.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -9930,7 +11315,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path27.isAbsolute(filePath) ? filePath : path27.join(this.#app.cwdPath, filePath);
+      const abs = path29.isAbsolute(filePath) ? filePath : path29.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -9949,7 +11334,7 @@ class FontOptimizer {
     return "";
   }
   async#collectAutoSubsetText() {
-    const roots = ["page", "ui"].map((dir) => path27.join(this.#app.cwdPath, dir));
+    const roots = ["page", "ui"].map((dir) => path29.join(this.#app.cwdPath, dir));
     const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
     const parts = [];
     await Promise.all(roots.map(async (root) => {
@@ -10063,7 +11448,7 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
-import path28 from "path";
+import path30 from "path";
 var SOURCE_EXTS5 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var CSS_EXTS = new Set([".css"]);
 var CONFIG_BASENAMES2 = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
@@ -10072,10 +11457,10 @@ class HmrChangeClassifier {
   classify(abs) {
     if (this.#isUninteresting(abs))
       return "ignore";
-    const base = path28.basename(abs);
+    const base = path30.basename(abs);
     if (CONFIG_BASENAMES2.has(base))
       return "config";
-    const ext = path28.extname(abs).toLowerCase();
+    const ext = path30.extname(abs).toLowerCase();
     if (CSS_EXTS.has(ext))
       return "css";
     if (SOURCE_EXTS5.has(ext))
@@ -10083,23 +11468,23 @@ class HmrChangeClassifier {
     return "ignore";
   }
   #isUninteresting(abs) {
-    const base = path28.basename(abs);
+    const base = path30.basename(abs);
     if (!base)
       return true;
     if (base.startsWith("."))
       return true;
     if (base.endsWith("~") || base.endsWith(".swp") || base.endsWith(".swx") || base.endsWith(".tmp"))
       return true;
-    if (abs.includes(`${path28.sep}node_modules${path28.sep}`))
+    if (abs.includes(`${path30.sep}node_modules${path30.sep}`))
       return true;
-    if (abs.includes(`${path28.sep}.akan${path28.sep}`))
+    if (abs.includes(`${path30.sep}.akan${path30.sep}`))
       return true;
     return false;
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
 import fs4 from "fs";
-import path29 from "path";
+import path31 from "path";
 class HmrWatcher {
   #roots;
   #debounceMs;
@@ -10112,7 +11497,7 @@ class HmrWatcher {
   #stopped = false;
   #flushing = false;
   constructor(opts) {
-    this.#roots = [...new Set(opts.roots.map((r) => path29.resolve(r)))];
+    this.#roots = [...new Set(opts.roots.map((r) => path31.resolve(r)))];
     this.#debounceMs = opts.debounceMs ?? 80;
     this.#onBatch = opts.onBatch;
     this.#logger = opts.logger;
@@ -10123,7 +11508,7 @@ class HmrWatcher {
         const w = fs4.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
           if (!filename)
             return;
-          const abs = path29.resolve(root, filename.toString());
+          const abs = path31.resolve(root, filename.toString());
           this.#queue(abs);
         });
         this.#watchers.push(w);
@@ -10181,10 +11566,10 @@ class HmrWatcher {
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path31 from "path";
+import path33 from "path";
 
 // pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path30 from "path";
+import path32 from "path";
 var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
 var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "@akanjs/cli", "@akanjs/devkit"]);
 var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
@@ -10227,7 +11612,7 @@ async function createExternalizeFrameworkPlugin(options) {
         const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
         if (!replPath)
           continue;
-        const candidate = path30.resolve(workspaceRoot, replPath + suffix);
+        const candidate = path32.resolve(workspaceRoot, replPath + suffix);
         const hit = await firstExisting(candidate);
         if (hit)
           return hit;
@@ -10239,8 +11624,8 @@ async function createExternalizeFrameworkPlugin(options) {
       if (spec === pkg)
         continue;
       const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path30.dirname(path30.resolve(workspaceRoot, entryFile));
-      const candidate = path30.join(pkgDir, suffix);
+      const pkgDir = path32.dirname(path32.resolve(workspaceRoot, entryFile));
+      const candidate = path32.join(pkgDir, suffix);
       const hit = await firstExisting(candidate);
       if (hit)
         return hit;
@@ -10290,7 +11675,7 @@ async function firstExisting(basePath2) {
       return candidate;
   }
   for (const ext of CANDIDATE_EXTS3) {
-    const candidate = path30.join(basePath2, `index${ext}`);
+    const candidate = path32.join(basePath2, `index${ext}`);
     if (await Bun.file(candidate).exists())
       return candidate;
   }
@@ -10381,11 +11766,11 @@ class PagesBundleBuilder {
     const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
     if (!entryArtifact)
       throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
-    const bundlePath = path31.resolve(entryArtifact.path);
+    const bundlePath = path33.resolve(entryArtifact.path);
     const buildId = Date.now();
     const outputBytes = result.outputs.reduce((sum, output) => sum + output.size, 0);
     const chunkCount = result.outputs.filter((output) => output.kind === "chunk").length;
-    this.#app.verbose(`[PagesBundleBuilder] ${path31.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
+    this.#app.verbose(`[PagesBundleBuilder] ${path33.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
     return {
       bundlePath,
       buildId,
@@ -10467,11 +11852,11 @@ function loaderFor4(absPath) {
 }
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
 import fs5 from "fs";
-import path32 from "path";
+import path34 from "path";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
 async function precompressArtifacts(app) {
-  const roots = [path32.join(app.dist.cwdPath, ".akan/artifact/client")];
+  const roots = [path34.join(app.dist.cwdPath, ".akan/artifact/client")];
   const result = { files: 0, inputBytes: 0, outputBytes: 0 };
   await Promise.all(roots.map((root) => precompressRoot(root, result)));
   if (result.files > 0) {
@@ -10497,7 +11882,7 @@ async function precompressRoot(root, result) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path32.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path34.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -10515,7 +11900,7 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path33 from "path";
+import path35 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath2, cssText) {
   return optimize(cssText, { file: `${basePath2 || "root"}.css`, minify: command === "build" }).code;
@@ -10531,7 +11916,7 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path33.resolve(this.#artifactDir);
+    this.#absArtifactDir = path35.resolve(this.#artifactDir);
   }
   async build() {
     const akanConfig2 = await this.#app.getConfig();
@@ -10553,7 +11938,7 @@ class SsrBaseArtifactBuilder {
       rscRuntimeSsrManifest,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path33.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path35.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
       pagesBundleBuildId: pagesBundle.buildId,
       domains: [...akanConfig2.domains],
       subRoutes: Object.fromEntries(Array.from(akanConfig2.subRoutes.entries()).map(([basePath2, domains]) => [basePath2, [...domains]])),
@@ -10562,7 +11947,7 @@ class SsrBaseArtifactBuilder {
       i18n: akanConfig2.i18n,
       imageConfig: akanConfig2.images
     };
-    await Bun.write(path33.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path35.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
 `);
     this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
     return { artifact, seedIndex, cssCompiler, optimizedFonts };
@@ -10610,15 +11995,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path33.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path35.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path33.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path35.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path33.dirname(Bun.resolveSync("akanjs/server", path33.dirname(Bun.main))));
+      candidates.push(path35.dirname(Bun.resolveSync("akanjs/server", path35.dirname(Bun.main))));
     } catch {}
-    candidates.push(path33.join(path33.dirname(Bun.main), "node_modules/akanjs/server"), path33.join(path33.dirname(Bun.main), "../../akanjs/server"), path33.resolve(import.meta.dir, "../../server"), path33.resolve(import.meta.dir, "../server"));
+    candidates.push(path35.join(path35.dirname(Bun.main), "node_modules/akanjs/server"), path35.join(path35.dirname(Bun.main), "../../akanjs/server"), path35.resolve(import.meta.dir, "../../server"), path35.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path33.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path35.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -10647,14 +12032,14 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path33.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path35.join(this.#absArtifactDir, cssRelPath), preparedCssText);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath2} -> ${cssRelPath}`);
     return [basePath2, { cssUrl, cssRelPath }];
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/watchRootResolver.ts
 import fs6 from "fs";
-import path34 from "path";
+import path36 from "path";
 
 class WatchRootResolver {
   #app;
@@ -10664,15 +12049,15 @@ class WatchRootResolver {
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
     const set = new Set;
-    set.add(path34.resolve(`${this.#app.cwdPath}/page`));
+    set.add(path36.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
       for (const target of targets) {
         if (!target)
           continue;
-        if (path34.isAbsolute(target))
+        if (path36.isAbsolute(target))
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
-        const resolved = path34.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        const resolved = path36.resolve(this.#app.workspace.workspaceRoot, cleaned);
         if (fs6.existsSync(resolved))
           set.add(resolved);
       }
@@ -10739,7 +12124,7 @@ class ApplicationBuildRunner {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path35.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path37.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
@@ -10747,7 +12132,7 @@ class ApplicationBuildRunner {
     await this.#app.getPageKeys({ refresh: true });
     const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
     if (clean)
-      await rm3(path35.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm3(path37.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
   async#runPhase(id, label, task, summarize, options = {}) {
@@ -10819,7 +12204,7 @@ class ApplicationBuildRunner {
     };
   }
   async#writeConsoleShim() {
-    await Bun.write(path35.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
+    await Bun.write(path37.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
 import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
 
 const run = async () => {
@@ -10842,14 +12227,14 @@ void run().catch((error) => {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path37.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
     }
   }
   #resolveConsoleRuntimeBuildEntry() {
     try {
-      return path35.join(path35.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+      return path37.join(path37.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
     } catch {
-      return path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+      return path37.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
   async#buildCsr() {
@@ -10866,7 +12251,7 @@ void run().catch((error) => {
     return { base, allRoutes };
   }
   async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path35.join(this.#app.cwdPath, ".akan", "typecheck");
+    const typecheckDir = path37.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir8(typecheckDir, { recursive: true });
     const tsconfig = {
       extends: "../../tsconfig.json",
@@ -10885,7 +12270,7 @@ void run().catch((error) => {
       ],
       references: []
     };
-    const tsconfigPath = path35.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path37.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -10911,10 +12296,10 @@ void run().catch((error) => {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path35.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path35.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path35.join(import.meta.dir, "typecheck.proc.js"),
-      path35.join(import.meta.dir, "typecheck.proc.ts")
+      path37.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path37.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path37.join(import.meta.dir, "typecheck.proc.js"),
+      path37.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -11090,13 +12475,13 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path36) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path36}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path38) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path38}`;
       if (await FileSys.dirExists(targetPath))
         await rm4(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path36) => cp(`${this.#app.workspace.cwdPath}/${path36}`, `${sourceRoot}/${path36}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path38) => cp(`${this.#app.workspace.cwdPath}/${path38}`, `${sourceRoot}/${path38}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
     await this.#app.workspace.spawn("tar", [
@@ -11187,20 +12572,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path36 from "path";
+import path38 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path36.join(path36.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path38.join(path38.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path36.dirname(Bun.main));
+  addResolvedPackageCandidate(path38.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path36.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(path36.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path38.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.join(path38.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path38.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   for (const candidate of [...new Set(candidates)]) {
     if (await Bun.file(candidate).exists())
       return candidate;
@@ -11210,7 +12595,7 @@ async function resolveSignalTestPreloadPath(target) {
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
-import path37 from "path";
+import path39 from "path";
 var SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
 var assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
 var assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file"]));
@@ -11227,14 +12612,14 @@ class Builder {
   #globEntrypoints(cwd, pattern) {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path37.sep);
+      const segments = relativePath.split(path39.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path37.join(cwd, rel));
+    }).map((rel) => path39.join(cwd, rel));
   }
   #globFiles(cwd, pattern = "**/*.*") {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path37.sep);
+      const segments = relativePath.split(path39.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -11242,17 +12627,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path37.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path39.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path37.isAbsolute(p) ? p : path37.join(cwd, p));
+        out.push(path39.isAbsolute(p) ? p : path39.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path37.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path39.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -11273,9 +12658,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path37.join(cwd, relativePath);
-      const targetPath = path37.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir10(path37.dirname(targetPath), { recursive: true });
+      const sourcePath = path39.join(cwd, relativePath);
+      const targetPath = path39.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir10(path39.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -11286,13 +12671,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path37.posix.parse(withoutFormatDir);
+    const parsed = path39.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path37.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path39.posix.join(parsed.dir, parsed.name);
     const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
     const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path37.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path39.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -11343,10 +12728,10 @@ class Builder {
 // pkgs/@akanjs/devkit/capacitorApp.ts
 import { cp as cp2, mkdir as mkdir11, rm as rm5 } from "fs/promises";
 import os from "os";
-import path38 from "path";
+import path40 from "path";
 import { select as select2 } from "@inquirer/prompts";
 import { MobileProject } from "@trapezedev/project";
-import { capitalize as capitalize6 } from "akanjs/common";
+import { capitalize as capitalize5 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/fileEditor.ts
 class FileEditor {
@@ -11550,13 +12935,13 @@ var rootCapacitorConfigFilenames = [
   "capacitor.config.js",
   "capacitor.config.json"
 ];
-var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path38.join(appRoot, file));
+var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path40.join(appRoot, file));
 async function clearRootCapacitorConfigs(appRoot) {
   await Promise.all(rootCapacitorConfigPaths(appRoot).map((file) => rm5(file, { force: true })));
 }
 async function writeRootCapacitorConfig(appRoot, content) {
   await clearRootCapacitorConfigs(appRoot);
-  await Bun.write(path38.join(appRoot, "capacitor.config.json"), content);
+  await Bun.write(path40.join(appRoot, "capacitor.config.json"), content);
 }
 var getLocalIP = () => {
   const interfaces = os.networkInterfaces();
@@ -11570,7 +12955,7 @@ var getLocalIP = () => {
   }
   return "127.0.0.1";
 };
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var asString = (value) => typeof value === "string" ? value : undefined;
 var firstString = (...values) => values.find((value) => typeof value === "string");
 var scoreIosDeviceTarget = (target) => {
@@ -11594,7 +12979,7 @@ function walkRecords(value, visit) {
       walkRecords(item, visit);
     return;
   }
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return;
   visit(value);
   for (const item of Object.values(value))
@@ -11605,9 +12990,9 @@ function parseDevicectlDevices(output) {
     const json = JSON.parse(output);
     const targets = new Map;
     walkRecords(json, (record) => {
-      const deviceProperties = isRecord(record.deviceProperties) ? record.deviceProperties : {};
-      const hardwareProperties = isRecord(record.hardwareProperties) ? record.hardwareProperties : {};
-      const connectionProperties = isRecord(record.connectionProperties) ? record.connectionProperties : {};
+      const deviceProperties = isRecord2(record.deviceProperties) ? record.deviceProperties : {};
+      const hardwareProperties = isRecord2(record.hardwareProperties) ? record.hardwareProperties : {};
+      const connectionProperties = isRecord2(record.connectionProperties) ? record.connectionProperties : {};
       const devicectlId = firstString(record.identifier, record.deviceIdentifier);
       const potentialHostnames = Array.isArray(connectionProperties.potentialHostnames) ? connectionProperties.potentialHostnames.filter((value) => typeof value === "string") : [];
       const hostnameUdid = potentialHostnames.map((hostname) => hostname.match(/([0-9A-Fa-f]{8}-[0-9A-Fa-f]{16})\.coredevice\.local/)?.[1]).find((value) => Boolean(value));
@@ -11640,7 +13025,7 @@ function parseSimctlDevices(output) {
   try {
     const json = JSON.parse(output);
     const devices = json.devices ?? {};
-    return Object.values(devices).flatMap((runtimeDevices) => runtimeDevices).filter(isRecord).flatMap((device) => {
+    return Object.values(devices).flatMap((runtimeDevices) => runtimeDevices).filter(isRecord2).flatMap((device) => {
       const id = firstString(device.udid, device.UDID, device.identifier);
       const name = firstString(device.name, device.displayName);
       const isAvailable = device.isAvailable !== false && device.availabilityError === undefined;
@@ -11665,13 +13050,13 @@ function buildIosNativeRunCommand({
   scheme = "App",
   configuration = "Debug"
 }) {
-  const derivedDataPath = path38.join(appRoot, "ios/DerivedData", device.id);
+  const derivedDataPath = path40.join(appRoot, "ios/DerivedData", device.id);
   const productPlatform = device.kind === "device" ? "iphoneos" : "iphonesimulator";
   const destination = device.kind === "device" ? `id=${device.xcodebuildId ?? device.id}` : `platform=iOS Simulator,id=${device.id}`;
   return {
     configuration,
     derivedDataPath,
-    appPath: path38.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
+    appPath: path40.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
     xcodebuildArgs: [
       "-project",
       "App.xcodeproj",
@@ -11872,16 +13257,16 @@ function materializeCapacitorConfig(target, { operation, localServerUrl, localIp
     experimental,
     ...capacitorConfig
   } = target;
-  const serverConfig = isRecord(server) ? server : undefined;
-  const cordovaConfig = isRecord(cordova) ? cordova : undefined;
-  const experimentalConfig = isRecord(experimental) ? experimental : undefined;
-  const pluginsConfig = isRecord(plugins) ? plugins : {};
-  const keyboardPluginConfig = isRecord(pluginsConfig.Keyboard) ? pluginsConfig.Keyboard : {};
+  const serverConfig = isRecord2(server) ? server : undefined;
+  const cordovaConfig = isRecord2(cordova) ? cordova : undefined;
+  const experimentalConfig = isRecord2(experimental) ? experimental : undefined;
+  const pluginsConfig = isRecord2(plugins) ? plugins : {};
+  const keyboardPluginConfig = isRecord2(pluginsConfig.Keyboard) ? pluginsConfig.Keyboard : {};
   const config = {
     ...capacitorConfig,
     appId,
     appName,
-    webDir: path38.posix.join(".akan", "mobile", name, "www"),
+    webDir: path40.posix.join(".akan", "mobile", name, "www"),
     plugins: {
       CapacitorCookies: { enabled: true },
       ...pluginsConfig,
@@ -11891,11 +13276,11 @@ function materializeCapacitorConfig(target, { operation, localServerUrl, localIp
       }
     },
     android: {
-      ...isRecord(android) ? android : {},
+      ...isRecord2(android) ? android : {},
       path: "android"
     },
     ios: {
-      ...isRecord(ios) ? ios : {},
+      ...isRecord2(ios) ? ios : {},
       path: "ios"
     }
   };
@@ -11938,10 +13323,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path38.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path38.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path38.join(this.targetRoot, "www");
-    this.targetAssetRoot = path38.join(this.targetRoot, "assets");
+    this.targetRootPath = path40.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path40.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path40.join(this.targetRoot, "www");
+    this.targetAssetRoot = path40.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -11956,9 +13341,9 @@ class CapacitorApp {
     await mkdir11(this.targetRoot, { recursive: true });
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm5(path38.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm5(path40.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm5(path38.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm5(path40.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -12081,7 +13466,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     const xcodebuildArgs = noAllowProvisioningUpdates ? command.xcodebuildArgs : [...command.xcodebuildArgs.slice(0, -1), "-allowProvisioningUpdates", ...command.xcodebuildArgs.slice(-1)];
     try {
       await this.#spawn("xcodebuild", xcodebuildArgs, {
-        cwd: path38.join(this.app.cwdPath, this.iosProjectPath),
+        cwd: path40.join(this.app.cwdPath, this.iosProjectPath),
         env: mobileEnv
       });
       const devicectlId = runTarget.devicectlId ?? runTarget.id;
@@ -12103,10 +13488,10 @@ ${textError instanceof Error ? textError.message : ""}`);
     }
   }
   #iosScheme() {
-    return isRecord(this.target.ios) && typeof this.target.ios.scheme === "string" ? this.target.ios.scheme : "App";
+    return isRecord2(this.target.ios) && typeof this.target.ios.scheme === "string" ? this.target.ios.scheme : "App";
   }
   async#getIosDevelopmentTeam() {
-    const pbxprojPath = path38.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
+    const pbxprojPath = path40.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
     if (!await Bun.file(pbxprojPath).exists())
       return;
     return (await Bun.file(pbxprojPath).text()).match(/DEVELOPMENT_TEAM = ([^;]+);/)?.[1]?.trim();
@@ -12132,7 +13517,7 @@ ${error.message}`;
     await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path38.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path40.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -12176,7 +13561,7 @@ ${error.message}`;
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path38.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path40.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -12184,10 +13569,10 @@ ${error.message}`;
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir11(path38.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir11(path40.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path38.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path40.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -12226,7 +13611,7 @@ ${error.message}`;
     await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
   async#assertAndroidReleaseSigningConfig() {
-    const gradlePropertiesPath = path38.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
+    const gradlePropertiesPath = path40.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
     const gradleProperties = await Bun.file(gradlePropertiesPath).exists() ? await Bun.file(gradlePropertiesPath).text() : "";
     const missingKeys = getMissingAndroidReleaseSigningKeys({ gradleProperties });
     if (missingKeys.length > 0)
@@ -12253,12 +13638,12 @@ ${error.message}`;
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path38.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path40.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
     await rm5(this.targetWebRoot, { recursive: true, force: true });
     await mkdir11(this.targetWebRoot, { recursive: true });
-    await Bun.write(path38.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await Bun.write(path40.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -12278,7 +13663,7 @@ ${error.message}`;
     });
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    await Bun.write(path38.join(this.targetRoot, "capacitor.config.json"), content);
+    await Bun.write(path40.join(this.targetRoot, "capacitor.config.json"), content);
     return content;
   }
   async#prepareTargetAssets() {
@@ -12286,11 +13671,11 @@ ${error.message}`;
       return;
     await mkdir11(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path38.join(this.app.cwdPath, this.target.assets.icon), path38.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path40.join(this.app.cwdPath, this.target.assets.icon), path40.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path38.join(this.app.cwdPath, this.target.assets.splash), path38.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path40.join(this.app.cwdPath, this.target.assets.splash), path40.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -12298,11 +13683,11 @@ ${error.message}`;
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path38.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path40.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path38.join(platformRoot, to);
-      await mkdir11(path38.dirname(targetPath), { recursive: true });
-      await cp2(path38.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path40.join(platformRoot, to);
+      await mkdir11(path40.dirname(targetPath), { recursive: true });
+      await cp2(path40.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -12312,7 +13697,7 @@ ${error.message}`;
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path38.posix.join(this.targetRootPath, "assets"),
+      path40.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -12437,7 +13822,7 @@ ${error.message}`;
     this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
   }
   async#setPermissionInIos(permissions) {
-    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize6(key)}`, value]));
+    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize5(key)}`, value]));
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
@@ -12522,15 +13907,15 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path39 from "path";
+import path41 from "path";
 import { confirm, input as input2, select as select3 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
 import { program } from "commander";
 
 // pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
-var capitalize7 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
-var createDependencyKey = (refName, kind) => `${refName}${capitalize7(kind)}`;
+var capitalize6 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
+var createDependencyKey = (refName, kind) => `${refName}${capitalize6(kind)}`;
 
 class CommandContainer {
   static #instances = new Map;
@@ -13026,7 +14411,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path39.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path41.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -13269,11 +14654,11 @@ var NODE_NATIVE_MODULE_SET = new Set([
 // pkgs/@akanjs/devkit/getCredentials.ts
 import yaml from "js-yaml";
 // pkgs/@akanjs/devkit/getModelFileData.ts
-import { capitalize as capitalize8 } from "akanjs/common";
+import { capitalize as capitalize7 } from "akanjs/common";
 // pkgs/@akanjs/devkit/getRelatedCnsts.ts
 import { readFileSync as readFileSync4, realpathSync } from "fs";
 import ora2 from "ora";
-import * as ts8 from "typescript";
+import * as ts10 from "typescript";
 var tsTranspiler = new Bun.Transpiler({ loader: "ts" });
 var tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
 var getTranspiler = (filePath) => filePath.endsWith(".tsx") ? tsxTranspiler : tsTranspiler;
@@ -13306,10 +14691,10 @@ var scanModuleSpecifiers = (source2, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts8.readConfigFile(tsConfigPath, (path40) => {
-    return ts8.sys.readFile(path40);
+  const configFile = ts10.readConfigFile(tsConfigPath, (path42) => {
+    return ts10.sys.readFile(path42);
   });
-  return ts8.parseJsonConfigFileContent(configFile.config, ts8.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
+  return ts10.parseJsonConfigFileContent(configFile.config, ts10.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
 var collectImportedFiles = (constantFilePath, parsedConfig) => {
   const allFilesToAnalyze = new Set([constantFilePath]);
@@ -13324,7 +14709,7 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
     for (const importPath of scanModuleSpecifiers(source2, filePath, false)) {
       if (!importPath.startsWith("."))
         continue;
-      const resolved = ts8.resolveModuleName(importPath, filePath, parsedConfig.options, ts8.sys).resolvedModule?.resolvedFileName;
+      const resolved = ts10.resolveModuleName(importPath, filePath, parsedConfig.options, ts10.sys).resolvedModule?.resolvedFileName;
       if (resolved && !allFilesToAnalyze.has(resolved)) {
         allFilesToAnalyze.add(resolved);
         collectImported(resolved);
@@ -13341,7 +14726,7 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
 var createTsProgram = (filePaths, options) => {
   const spinner = ora2("Creating TypeScript program for all files...");
   spinner.start();
-  const program2 = ts8.createProgram(Array.from(filePaths), options);
+  const program2 = ts10.createProgram(Array.from(filePaths), options);
   const checker = program2.getTypeChecker();
   spinner.succeed("TypeScript program created.");
   return {
@@ -13381,17 +14766,17 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
     function visit(node) {
       if (!source2)
         return;
-      if (ts8.isPropertyAccessExpression(node)) {
+      if (ts10.isPropertyAccessExpression(node)) {
         const left = node.expression;
         const right = node.name;
-        const { line } = ts8.getLineAndCharacterOfPosition(source2, node.getStart());
-        if (ts8.isIdentifier(left) && sourceLines && sourceLines.length > line && sourceLines[line] && (sourceLines[line]?.includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
+        const { line } = ts10.getLineAndCharacterOfPosition(source2, node.getStart());
+        if (ts10.isIdentifier(left) && sourceLines && sourceLines.length > line && sourceLines[line] && (sourceLines[line]?.includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
           const symbol = getCachedSymbol(right);
           if (symbol?.declarations && symbol.declarations.length > 0) {
             const key = symbol.declarations[0]?.getSourceFile().fileName.split("/").pop()?.split(".")[0] ?? "";
             const property = propertyMap.get(key);
             const isScalar = symbol.declarations[0]?.getSourceFile().fileName.includes("_") ?? false;
-            const symbolFilePath = symbol.declarations[0]?.getSourceFile().fileName.replace(`${ts8.sys.getCurrentDirectory()}/`, "");
+            const symbolFilePath = symbol.declarations[0]?.getSourceFile().fileName.replace(`${ts10.sys.getCurrentDirectory()}/`, "");
             if (!symbolFilePath)
               throw new Error(`No symbol file path found for ${left.text}.${right.text}`);
             if (property) {
@@ -13415,10 +14800,10 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
             }
           }
         }
-      } else if (ts8.isImportDeclaration(node) && ts8.isStringLiteral(node.moduleSpecifier)) {
+      } else if (ts10.isImportDeclaration(node) && ts10.isStringLiteral(node.moduleSpecifier)) {
         const importPath = node.moduleSpecifier.text;
         if (importPath.startsWith(".")) {
-          const resolved = ts8.resolveModuleName(importPath, filePath, program2.getCompilerOptions(), ts8.sys).resolvedModule?.resolvedFileName;
+          const resolved = ts10.resolveModuleName(importPath, filePath, program2.getCompilerOptions(), ts10.sys).resolvedModule?.resolvedFileName;
           const moduleName = importPath.split("/").pop()?.split(".")[0] ?? "";
           const property = propertyMap.get(moduleName);
           const isScalar = importPath.includes("_");
@@ -13433,7 +14818,7 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
           }
         }
       }
-      ts8.forEachChild(node, visit);
+      ts10.forEachChild(node, visit);
     }
     visit(source2);
   }
@@ -13640,10 +15025,10 @@ class IncrementalBuilder {
     }
   }
   batchTouchesPagesTree(appDir, batch) {
-    const absAppDir = path40.resolve(appDir);
+    const absAppDir = path42.resolve(appDir);
     for (const f of batch.files) {
-      const abs = path40.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path40.sep}`) && abs !== absAppDir)
+      const abs = path42.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path42.sep}`) && abs !== absAppDir)
         continue;
       if (/\.(tsx|ts|jsx|js)$/.test(abs))
         return true;
@@ -13651,15 +15036,15 @@ class IncrementalBuilder {
     return false;
   }
   async batchMayChangePageKeys(appDir, batch) {
-    const absAppDir = path40.resolve(appDir);
-    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path40.normalize(key)));
+    const absAppDir = path42.resolve(appDir);
+    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path42.normalize(key)));
     for (const f of batch.files) {
-      const abs = path40.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path40.sep}`) && abs !== absAppDir)
+      const abs = path42.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path42.sep}`) && abs !== absAppDir)
         continue;
       if (!/\.(tsx|ts|jsx|js)$/.test(abs))
         continue;
-      const rel = path40.normalize(path40.relative(absAppDir, abs));
+      const rel = path42.normalize(path42.relative(absAppDir, abs));
       if (!await Bun.file(abs).exists() || !pageKeys.has(rel))
         return true;
     }
@@ -13687,7 +15072,7 @@ class IncrementalBuilder {
 ${cssText}`).toString(36);
           const cssRelPath = `styles/${cssAssetName}-${cssHash}.css`;
           const cssUrl = `/_akan/styles/${cssAssetName}-${cssHash}.css`;
-          await Bun.write(path40.join(artifactDir, cssRelPath), cssText);
+          await Bun.write(path42.join(artifactDir, cssRelPath), cssText);
           cssAssetEntries.push([basePath2, { cssUrl, cssRelPath }]);
           cssBase64ByUrl[cssUrl] = Buffer.from(new TextEncoder().encode(cssText)).toString("base64");
         })()
@@ -13755,10 +15140,10 @@ ${cssText}`).toString(36);
     if (changedFiles.length === 0)
       return false;
     return changedFiles.some((file) => {
-      const normalized = path40.resolve(file);
+      const normalized = path42.resolve(file);
       if (/\.(woff2?|ttf|otf)$/i.test(normalized))
         return true;
-      return this.#optimizedFonts.files.some((fontFile) => path40.resolve(fontFile) === normalized);
+      return this.#optimizedFonts.files.some((fontFile) => path42.resolve(fontFile) === normalized);
     });
   }
   async installWatcher() {