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

package/incrementalBuilder.proc.js

@@ -3396,28 +3396,28 @@ class SysExecutor extends Executor {
     return scalarModules;
   }
   async getViewComponents() {
-    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.View.tsx`).exists());
+    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.View.tsx`).exists());
     return viewComponents;
   }
   async getUnitComponents() {
-    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`).exists());
+    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Unit.tsx`).exists());
     return unitComponents;
   }
   async getTemplateComponents() {
-    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`).exists());
+    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Template.tsx`).exists());
     return templateComponents;
   }
   async getViewsSourceCode() {
     const viewComponents = await this.getViewComponents();
-    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${viewComponent}.View.tsx`)));
+    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`)));
   }
   async getUnitsSourceCode() {
     const unitComponents = await this.getUnitComponents();
-    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${unitComponent}.Unit.tsx`)));
+    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`)));
   }
   async getTemplatesSourceCode() {
     const templateComponents = await this.getTemplateComponents();
-    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${templateComponent}.Template.tsx`)));
+    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`)));
   }
   async getScalarConstantFiles() {
     const scalarModules = await this.getScalarModules();
@@ -4807,11 +4807,17 @@ var createWorkflowApplyReport = ({
   recommendedValidationCommands,
   commands = [],
   diagnostics = [],
+  postApplyChecks = [],
   recommendations = [],
   nextActions = [],
   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;
+  });
   return {
     schemaVersion: 1,
     workflow,
@@ -4823,8 +4829,9 @@ var createWorkflowApplyReport = ({
     recommendedValidationCommands: uniqueBy(validationCommands, (command) => command.command),
     commands: uniqueBy(validationCommands, (command) => command.command),
     diagnostics,
+    postApplyChecks,
     recommendations: uniqueBy(recommendations, (recommendation) => `${recommendation.kind}:${recommendation.code}`),
-    nextActions: uniqueBy(nextActions, (action) => action.command),
+    nextActions: orderedNextActions.slice(0, 3),
     plan
   };
 };
@@ -4889,6 +4896,12 @@ var statusForScope = (commands, diagnostics, scopes, expectedScope) => {
     return "unknown";
   return hasScopeFailure(scopes, expectedScope, diagnostics) ? "failed" : "passed";
 };
+var statusForValidationKind = (commands, kind) => {
+  const matching = commands.filter((command) => command.kind === kind);
+  if (matching.length === 0)
+    return "unknown";
+  return matching.some((command) => command.status === "failed") ? "failed" : "passed";
+};
 var createKnownBlockers = (commands, diagnostics) => {
   const commandBlockers = commands.filter((command) => command.status === "failed" && (command.failureScope === "workspace-config" || command.failureScope === "environment")).map((command) => ({
     code: `workflow-validation-${command.failureScope}`,
@@ -4922,7 +4935,17 @@ var createValidationStatuses = (commands, diagnostics) => {
   const sourceStatus = statusForScope(commands, diagnostics, scopes, "source-change");
   const workspaceStatus = hasScopeFailure(scopes, "workspace-config", diagnostics) || hasScopeFailure(scopes, "environment", diagnostics) ? "failed" : commands.length || diagnostics.length ? "passed" : "unknown";
   const overallStatus = hasScopeFailure(scopes, "source-change", diagnostics) ? "failed" : hasScopeFailure(scopes, "workspace-config", diagnostics) ? "blocked-by-workspace-config" : hasScopeFailure(scopes, "environment", diagnostics) ? "blocked-by-environment" : workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed";
-  return { sourceStatus, workspaceStatus, overallStatus };
+  return {
+    sourceStatus,
+    workspaceStatus,
+    overallStatus,
+    summary: {
+      sourceChange: sourceStatus,
+      generatedSync: statusForValidationKind(commands, "sync"),
+      workspaceConfig: statusForScope(commands, diagnostics, scopes, "workspace-config"),
+      environment: statusForScope(commands, diagnostics, scopes, "environment")
+    }
+  };
 };
 var createWorkflowValidationRunReport = async ({
   runId = createWorkflowRunId("validation"),
@@ -5032,221 +5055,7 @@ var createRepairReport = ({
 });
 // pkgs/@akanjs/devkit/workflow/executor.ts
 import { capitalize as capitalize2 } from "akanjs/common";
-var workflowStepKey = (workflow, stepId) => `${workflow}:${stepId}`;
-var primitiveReportToWorkflowStepResult = (report) => ({
-  changedFiles: report.changedFiles,
-  generatedFiles: report.generatedFiles,
-  commands: report.validationCommands,
-  diagnostics: report.diagnostics,
-  recommendations: [],
-  nextActions: report.nextActions
-});
-var workflowStringInput = (value) => typeof value === "string" ? value : null;
-var workflowStringListInput = (value) => Array.isArray(value) ? value.join(",") : null;
-var resolveWorkflowSys = async (workspace, target) => {
-  if (!target)
-    return null;
-  const [apps, libs] = await workspace.getSyss();
-  if (apps.includes(target))
-    return AppExecutor.from(workspace, target);
-  if (libs.includes(target))
-    return LibExecutor.from(workspace, target);
-  return null;
-};
-var targetMissing = (input2 = "app") => ({
-  severity: "error",
-  code: "workflow-target-missing",
-  input: input2,
-  message: "Workflow target app or library was not found."
-});
-var inputMissing = (input2) => ({
-  severity: "error",
-  code: "workflow-input-missing",
-  input: input2,
-  message: `Workflow input "${input2}" is required for apply.`
-});
-var unsupportedInput = (input2, message) => ({
-  severity: "error",
-  code: "workflow-input-unsupported",
-  input: input2,
-  message
-});
-var addFieldUiSurfaceInspection = (plan) => {
-  const app = workflowStringInput(plan.inputs.app);
-  const module = workflowStringInput(plan.inputs.module) ?? "<module>";
-  const field = workflowStringInput(plan.inputs.field) ?? "<field>";
-  const typeName = workflowStringInput(plan.inputs.type);
-  const isNumeric = typeName === "Int" || typeName === "Float" || typeName === "integer" || typeName === "float";
-  const moduleClassName = capitalize2(module);
-  const target = `${app ? `apps/${app}` : "*"}/lib/${module}/${moduleClassName}.Template.tsx`;
-  return {
-    recommendations: [
-      {
-        code: "add-field-ui-surface-review",
-        kind: "manual-action",
-        target,
-        action: isNumeric ? `Review ${moduleClassName} Template/Unit/View/Store surfaces before adding ${field}; confirm the local Field.Text numeric parser/formatter, validation rule, and dictionary label pattern.` : `Add ${field} to ${moduleClassName} UI surfaces only when the local Field.* pattern is clear.`,
-        confidence: "medium",
-        message: isNumeric ? `No UI file was modified automatically because a safe numeric input component pattern is not yet detected for ${module}.${field}.` : `Review Template/Unit/View/Store surfaces for ${module}.${field}; no UI file was modified automatically.`
-      }
-    ],
-    nextActions: [
-      {
-        command: `akan workflow explain ${plan.workflow}`,
-        reason: "Review UI surface guidance before manually editing ambiguous UI files."
-      }
-    ]
-  };
-};
-var createWorkflowStepRegistry = ({
-  workspace,
-  createModule,
-  createScalar,
-  createUi,
-  addField,
-  addEnumField
-}) => {
-  const inspect = async () => {
-    return;
-  };
-  const commandOnly = async () => {
-    return;
-  };
-  return {
-    inspectSystem: inspect,
-    inspectModule: inspect,
-    syncTarget: commandOnly,
-    lintTarget: commandOnly,
-    [workflowStepKey("create-module", "create-module")]: async (_step, plan) => {
-      const app = workflowStringInput(plan.inputs.app);
-      const module = workflowStringInput(plan.inputs.module);
-      const sys2 = await resolveWorkflowSys(workspace, app);
-      if (!sys2 || !module)
-        return { diagnostics: [!sys2 ? targetMissing() : inputMissing("module")] };
-      return primitiveReportToWorkflowStepResult(await createModule(sys2, module));
-    },
-    [workflowStepKey("create-scalar", "create-scalar")]: async (_step, plan) => {
-      const app = workflowStringInput(plan.inputs.app);
-      const scalar = workflowStringInput(plan.inputs.scalar);
-      const sys2 = await resolveWorkflowSys(workspace, app);
-      if (!sys2 || !scalar)
-        return { diagnostics: [!sys2 ? targetMissing() : inputMissing("scalar")] };
-      return primitiveReportToWorkflowStepResult(await createScalar(sys2, scalar));
-    },
-    [workflowStepKey("create-ui", "create-ui")]: async (_step, plan) => {
-      const surface = workflowStringInput(plan.inputs.surface);
-      if (surface !== "view" && surface !== "unit" && surface !== "template") {
-        return {
-          diagnostics: [
-            unsupportedInput("surface", "Workflow apply currently supports create-ui surfaces: view, unit, template.")
-          ]
-        };
-      }
-      return primitiveReportToWorkflowStepResult(await createUi({
-        app: workflowStringInput(plan.inputs.app),
-        module: workflowStringInput(plan.inputs.module),
-        surface
-      }));
-    },
-    [workflowStepKey("add-field", "update-constant")]: async (_step, plan) => {
-      if (workflowStringInput(plan.inputs.type)?.toLowerCase() === "enum") {
-        return primitiveReportToWorkflowStepResult(await addEnumField({
-          app: workflowStringInput(plan.inputs.app),
-          module: workflowStringInput(plan.inputs.module),
-          field: workflowStringInput(plan.inputs.field),
-          values: workflowStringListInput(plan.inputs.values),
-          defaultValue: workflowStringInput(plan.inputs.default)
-        }));
-      }
-      return primitiveReportToWorkflowStepResult(await addField({
-        app: workflowStringInput(plan.inputs.app),
-        module: workflowStringInput(plan.inputs.module),
-        field: workflowStringInput(plan.inputs.field),
-        type: workflowStringInput(plan.inputs.type),
-        defaultValue: workflowStringInput(plan.inputs.default)
-      }));
-    },
-    [workflowStepKey("add-field", "update-dictionary")]: inspect,
-    [workflowStepKey("add-field", "update-ui-surfaces")]: async (_step, plan) => addFieldUiSurfaceInspection(plan),
-    [workflowStepKey("add-enum-field", "update-constant")]: async (_step, plan) => primitiveReportToWorkflowStepResult(await addEnumField({
-      app: workflowStringInput(plan.inputs.app),
-      module: workflowStringInput(plan.inputs.module),
-      field: workflowStringInput(plan.inputs.field),
-      values: workflowStringListInput(plan.inputs.values),
-      defaultValue: workflowStringInput(plan.inputs.default)
-    })),
-    [workflowStepKey("add-enum-field", "update-dictionary")]: inspect,
-    [workflowStepKey("add-enum-field", "update-option")]: inspect
-  };
-};
-class WorkflowExecutor {
-  registry;
-  constructor(registry) {
-    this.registry = registry;
-  }
-  async apply(plan) {
-    const changedFiles = [];
-    const generatedFiles = [];
-    const recommendedValidationCommands = [];
-    const diagnostics = [...plan.diagnostics];
-    const recommendations = [...plan.recommendations];
-    const nextActions = [];
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createWorkflowApplyReport({
-        workflow: plan.workflow,
-        mode: "apply",
-        changedFiles,
-        generatedFiles,
-        recommendedValidationCommands,
-        diagnostics,
-        recommendations,
-        nextActions,
-        plan
-      });
-    }
-    recommendedValidationCommands.push(...workflowCommandsForPlan(plan));
-    nextActions.push(...workflowCommandsForPlan(plan));
-    for (const step of plan.steps) {
-      const runner = this.registry[workflowStepKey(plan.workflow, step.id)] ?? this.registry[step.tool] ?? this.registry[step.id];
-      if (!runner) {
-        diagnostics.push({
-          severity: "error",
-          code: "workflow-step-unsupported",
-          message: `Workflow ${plan.workflow} step "${step.id}" is not supported by workflow apply yet.`
-        });
-        nextActions.push({
-          command: `akan workflow explain ${plan.workflow}`,
-          reason: "Review the unsupported workflow step before retrying apply."
-        });
-        break;
-      }
-      const result = await runner(step, plan);
-      if (!result)
-        continue;
-      changedFiles.push(...result.changedFiles ?? []);
-      generatedFiles.push(...result.generatedFiles ?? []);
-      recommendedValidationCommands.push(...result.commands ?? []);
-      diagnostics.push(...result.diagnostics ?? []);
-      recommendations.push(...result.recommendations ?? []);
-      nextActions.push(...result.nextActions ?? []);
-      if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
-        break;
-    }
-    return createWorkflowApplyReport({
-      workflow: plan.workflow,
-      mode: "apply",
-      changedFiles,
-      generatedFiles,
-      recommendedValidationCommands,
-      diagnostics,
-      recommendations,
-      nextActions,
-      plan
-    });
-  }
-}
-// pkgs/@akanjs/devkit/workflow/plan.ts
-import { capitalize as capitalize3 } from "akanjs/common";
+import ts4 from "typescript";
 
 // pkgs/@akanjs/devkit/workflow/primitive.ts
 var createPrimitiveWriteReport = ({
@@ -5298,6 +5107,23 @@ var sourceFile = (sys2, path10, action, reason) => ({
   action,
   reason
 });
+var moduleComponentName = (moduleName) => `${moduleName.slice(0, 1).toUpperCase()}${moduleName.slice(1)}`;
+var moduleSourcePaths = (moduleName) => {
+  const componentName = moduleComponentName(moduleName);
+  return {
+    abstract: `lib/${moduleName}/${moduleName}.abstract.md`,
+    constant: `lib/${moduleName}/${moduleName}.constant.ts`,
+    dictionary: `lib/${moduleName}/${moduleName}.dictionary.ts`,
+    service: `lib/${moduleName}/${moduleName}.service.ts`,
+    signal: `lib/${moduleName}/${moduleName}.signal.ts`,
+    store: `lib/${moduleName}/${moduleName}.store.ts`,
+    template: `lib/${moduleName}/${componentName}.Template.tsx`,
+    unit: `lib/${moduleName}/${componentName}.Unit.tsx`,
+    util: `lib/${moduleName}/${componentName}.Util.tsx`,
+    view: `lib/${moduleName}/${componentName}.View.tsx`,
+    zone: `lib/${moduleName}/${componentName}.Zone.tsx`
+  };
+};
 var generatedFilesForSync = (sys2, reason = "Generated files may change after sync.") => generatedFilePathsForTarget(getSysRoot(sys2), reason);
 var validationCommandsForTarget = (target) => [
   { command: `akan sync ${target}`, reason: "Refresh generated Akan files from source conventions." },
@@ -5324,6 +5150,50 @@ var createPassedPrimitiveReport = ({
 var scalarChangedFiles = (sys2, scalarName, files) => Object.values(files).map((file) => sourceFile(sys2, `lib/__scalar/${scalarName}/${file.filename}`, "create", "Scalar source file was created."));
 var titleize = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 var lowerlize = (value) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
+var koLabels = {
+  amount: "\uAE08\uC561",
+  budget: "\uC608\uC0B0",
+  category: "\uCE74\uD14C\uACE0\uB9AC",
+  content: "\uB0B4\uC6A9",
+  count: "\uAC1C\uC218",
+  createdAt: "\uC0DD\uC131\uC77C",
+  date: "\uB0A0\uC9DC",
+  description: "\uC124\uBA85",
+  due: "\uB9C8\uAC10\uC77C",
+  dueAt: "\uB9C8\uAC10\uC77C",
+  email: "\uC774\uBA54\uC77C",
+  enabled: "\uD65C\uC131\uD654",
+  endAt: "\uC885\uB8CC\uC77C",
+  id: "ID",
+  name: "\uC774\uB984",
+  owner: "\uB2F4\uB2F9\uC790",
+  priority: "\uC6B0\uC120\uC21C\uC704",
+  project: "\uD504\uB85C\uC81D\uD2B8",
+  rating: "\uD3C9\uC810",
+  startAt: "\uC2DC\uC791\uC77C",
+  status: "\uC0C1\uD0DC",
+  title: "\uC81C\uBAA9",
+  updatedAt: "\uC218\uC815\uC77C"
+};
+var splitFieldWords = (fieldName) => fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").split(/\s+/).map((word) => word.trim()).filter(Boolean);
+var koLabelForField = (fieldName) => {
+  if (koLabels[fieldName])
+    return koLabels[fieldName];
+  const words = splitFieldWords(fieldName);
+  const translated = words.map((word) => koLabels[word] ?? koLabels[lowerlize(word)] ?? null);
+  return translated.every(Boolean) ? translated.join(" ") : null;
+};
+var bilingualLabelForField = (fieldName) => {
+  const en = titleize(fieldName);
+  return { en, ko: koLabelForField(fieldName) ?? en };
+};
+var bilingualDescriptionForField = (fieldName) => {
+  const label = bilingualLabelForField(fieldName);
+  return {
+    en: `Enter ${label.en.toLowerCase()}.`,
+    ko: `${label.ko} \uAC12\uC744 \uC785\uB825\uD569\uB2C8\uB2E4.`
+  };
+};
 var normalizeFieldType = (typeName) => {
   const normalizedTypes = {
     string: "String",
@@ -5351,6 +5221,15 @@ var ensureBaseTypeImport = (content, typeName) => {
 ${content}`;
 };
 var numericDefault = (typeName, rawDefault) => {
+  if (typeof rawDefault === "number") {
+    if (!Number.isFinite(rawDefault))
+      return null;
+    if (typeName === "Int" && !Number.isInteger(rawDefault))
+      return null;
+    return String(rawDefault);
+  }
+  if (typeof rawDefault !== "string")
+    return null;
   const trimmed = rawDefault.trim();
   if (!trimmed || !Number.isFinite(Number(trimmed)))
     return null;
@@ -5358,16 +5237,41 @@ var numericDefault = (typeName, rawDefault) => {
     return null;
   return trimmed;
 };
-var coerceFieldDefault = (typeName, defaultValue) => {
-  if (defaultValue === undefined || defaultValue === null || defaultValue === "")
-    return { expression: null };
-  const normalizedType = normalizeFieldType(typeName);
+var booleanDefault = (rawDefault) => {
+  if (typeof rawDefault === "boolean")
+    return String(rawDefault);
+  if (typeof rawDefault !== "string")
+    return null;
+  const lowered = rawDefault.trim().toLowerCase();
+  return lowered === "true" || lowered === "false" ? lowered : null;
+};
+var dateDefault = (rawDefault) => {
+  if (typeof rawDefault === "number" && Number.isFinite(rawDefault))
+    return `new Date(${rawDefault})`;
+  if (typeof rawDefault !== "string")
+    return null;
+  const trimmed = rawDefault.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "now")
+    return "new Date()";
+  if (!Number.isNaN(Date.parse(trimmed)))
+    return `new Date(${JSON.stringify(trimmed)})`;
+  return null;
+};
+var coerceFieldDefault = (typeName, defaultValue, options = {}) => {
+  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
+  if (defaultValue === undefined || defaultValue === null || defaultValue === "") {
+    return { expression: null, normalized: false, normalizedType };
+  }
   if (normalizedType === "Int" || normalizedType === "Float") {
     const expression = numericDefault(normalizedType, defaultValue);
     if (expression !== null)
-      return { expression };
+      return { expression, normalized: typeof defaultValue === "string", normalizedType };
     return {
       expression: null,
+      normalized: false,
+      normalizedType,
       diagnostic: {
         severity: "error",
         code: "primitive-default-value-invalid",
@@ -5378,11 +5282,13 @@ var coerceFieldDefault = (typeName, defaultValue) => {
     };
   }
   if (normalizedType === "Boolean") {
-    const lowered = defaultValue.trim().toLowerCase();
-    if (lowered === "true" || lowered === "false")
-      return { expression: lowered };
+    const expression = booleanDefault(defaultValue);
+    if (expression !== null)
+      return { expression, normalized: typeof defaultValue === "string", normalizedType };
     return {
       expression: null,
+      normalized: false,
+      normalizedType,
       diagnostic: {
         severity: "error",
         code: "primitive-default-value-invalid",
@@ -5392,13 +5298,58 @@ var coerceFieldDefault = (typeName, defaultValue) => {
       }
     };
   }
-  return { expression: JSON.stringify(defaultValue) };
+  if (normalizedType === "Date") {
+    const expression = dateDefault(defaultValue);
+    if (expression !== null)
+      return { expression, normalized: true, normalizedType };
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for Date must be "now", a timestamp, or a parseable date string. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  if (normalizedType === "enum") {
+    if (typeof defaultValue === "string" && options.enumValues?.includes(defaultValue)) {
+      return { expression: JSON.stringify(defaultValue), normalized: false, normalizedType };
+    }
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for enum must be one of: ${(options.enumValues ?? []).join(", ")}. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  return {
+    expression: JSON.stringify(String(defaultValue)),
+    normalized: typeof defaultValue !== "string",
+    normalizedType
+  };
 };
-var fieldExpression = (typeName, defaultValue) => {
+var fieldExpression = (typeName, defaultValue, options = {}) => {
   const typeExpression = normalizeFieldType(typeName);
-  const defaultExpression = coerceFieldDefault(typeExpression, defaultValue).expression;
+  const defaultExpression = coerceFieldDefault(options.enumValues ? "enum" : typeExpression, defaultValue, options).expression;
   const defaultOption = defaultExpression ? `, { default: ${defaultExpression} }` : "";
-  return `field(${typeExpression}${defaultOption})`;
+  return `${options.builderName ?? "field"}(${typeExpression}${defaultOption})`;
+};
+var viaBuilderParameterName = (content, className) => {
+  const classIndex = content.indexOf(`export class ${className} extends via`);
+  if (classIndex < 0)
+    return null;
+  const signature = content.slice(classIndex, content.indexOf("=>", classIndex));
+  return /via\(\(\s*([A-Za-z_$][\w$]*)\s*\)/.exec(signature)?.[1] ?? null;
 };
 var insertIntoObject = (content, className, line) => {
   const classIndex = content.indexOf(`export class ${className} extends via`);
@@ -5416,74 +5367,538 @@ var insertIntoObject = (content, className, line) => {
 `;
   return `${prefix}${insertion}${suffix}`;
 };
-var ensureEnumImport = (content) => {
-  if (content.includes("enumOf"))
-    return content;
-  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
-  if (baseImport) {
-    const names = baseImport[1]?.split(",").map((name) => name.trim()) ?? [];
-    return content.replace(baseImport[0], `import { ${[...names, "enumOf"].sort().join(", ")} } from "akanjs/base";`);
+var insertLightProjectionField = (content, moduleClassName, fieldName) => {
+  const classIndex = content.indexOf(`export class Light${moduleClassName} extends via`);
+  if (classIndex < 0)
+    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))
+    return content;
+  const nextFields = [...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)}`;
+};
+var insertTemplateField = ({
+  content,
+  moduleName,
+  moduleClassName,
+  fieldName,
+  component
+}) => {
+  if (content.includes(`l("${moduleName}.${fieldName}")`) || content.includes(`.${fieldName}`))
+    return content;
+  const layoutEndIndex = content.indexOf("    </Layout.Template>");
+  if (layoutEndIndex < 0)
+    return null;
+  const formName = `${moduleName}Form`;
+  if (!content.includes(`const ${formName} = st.use.${moduleName}Form();`))
+    return null;
+  const fieldSetter = `st.do.set${moduleComponentName(fieldName)}On${moduleClassName}`;
+  const fieldBlock = `      <${component}
+        label={l("${moduleName}.${fieldName}")}
+        desc={l("${moduleName}.${fieldName}.desc")}
+        value={${formName}.${fieldName}}
+        onChange={${fieldSetter}}
+      />
+`;
+  return `${content.slice(0, layoutEndIndex)}${fieldBlock}${content.slice(layoutEndIndex)}`;
+};
+var ensureEnumImport = (content) => {
+  if (content.includes("enumOf"))
+    return content;
+  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
+  if (baseImport) {
+    const names = baseImport[1]?.split(",").map((name) => name.trim()) ?? [];
+    return content.replace(baseImport[0], `import { ${[...names, "enumOf"].sort().join(", ")} } from "akanjs/base";`);
+  }
+  return `import { enumOf } from "akanjs/base";
+${content}`;
+};
+var insertEnumClass = (content, enumClassName, enumName, values) => {
+  if (content.includes(`export class ${enumClassName} extends enumOf`))
+    return content;
+  const enumClass = `export class ${enumClassName} extends enumOf("${enumName}", [
+${values.map((value) => `  ${JSON.stringify(value)},`).join(`
+`)}
+] as const) {}
+
+`;
+  const firstClassIndex = content.indexOf("export class ");
+  if (firstClassIndex < 0)
+    return `${content}
+${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)
+    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)}`;
+};
+var ensureConstantTypeImport = (content, constantPath, typeName) => {
+  if (new RegExp(`import type \\{[^}]*\\b${typeName}\\b[^}]*\\} from "${constantPath}";`).test(content))
+    return content;
+  const importPattern = new RegExp(`import type \\{ ([^}]+) \\} from "${constantPath}";`);
+  const existingImport = content.match(importPattern);
+  if (existingImport !== null) {
+    const names = existingImport[1]?.split(",").map((name) => name.trim()) ?? [];
+    return content.replace(existingImport[0], `import type { ${[...names, typeName].sort().join(", ")} } from "${constantPath}";`);
+  }
+  return `import type { ${typeName} } from "${constantPath}";
+${content}`;
+};
+var insertDictionaryEnum = (content, enumClassName, enumName, values) => {
+  if (content.includes(`.enum<${enumClassName}>("${enumName}"`))
+    return content;
+  const enumBlock = `  .enum<${enumClassName}>("${enumName}", (t) => ({
+${values.map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${JSON.stringify(titleize(value))}]),`).join(`
+`)}
+  }))
+`;
+  const chainEndIndex = content.lastIndexOf(";");
+  const insertBeforeIndex = [content.indexOf(".error("), content.indexOf(".translate("), chainEndIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+  if (insertBeforeIndex === undefined)
+    return null;
+  return `${content.slice(0, insertBeforeIndex)}${enumBlock}${content.slice(insertBeforeIndex)}`;
+};
+var parseValues = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+
+// pkgs/@akanjs/devkit/workflow/uiPolicy.ts
+var addFieldUiPolicyForType = (typeName) => {
+  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
+  if (normalizedType === "Int" || normalizedType === "Float") {
+    return {
+      normalizedType,
+      component: "Field.Number",
+      confidence: "high",
+      autoTemplateSupported: true
+    };
+  }
+  if (normalizedType === "Date") {
+    return {
+      normalizedType,
+      component: "Field.Date",
+      confidence: "high",
+      autoTemplateSupported: true
+    };
+  }
+  if (normalizedType === "Boolean" || normalizedType === "enum") {
+    return {
+      normalizedType,
+      component: "Field.ToggleSelect",
+      confidence: "medium",
+      autoTemplateSupported: false
+    };
+  }
+  if (normalizedType === "String") {
+    return {
+      normalizedType,
+      component: "Field.Text",
+      confidence: "high",
+      autoTemplateSupported: true
+    };
+  }
+  return {
+    normalizedType,
+    component: "Field.Text",
+    confidence: "low",
+    autoTemplateSupported: false
+  };
+};
+
+// pkgs/@akanjs/devkit/workflow/executor.ts
+var workflowStepKey = (workflow, stepId) => `${workflow}:${stepId}`;
+var primitiveReportToWorkflowStepResult = (report) => ({
+  changedFiles: report.changedFiles,
+  generatedFiles: report.generatedFiles,
+  commands: report.validationCommands,
+  diagnostics: report.diagnostics,
+  recommendations: [],
+  nextActions: report.nextActions
+});
+var workflowStringInput = (value) => typeof value === "string" ? value : null;
+var workflowStringListInput = (value) => Array.isArray(value) ? value.join(",") : null;
+var workflowStringArrayInput = (value) => Array.isArray(value) ? value : null;
+var workflowBooleanInput = (value) => typeof value === "boolean" ? value : null;
+var postApplyDiagnostic = (code, message, target) => ({
+  severity: "error",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target }
+});
+var sourceKindForPath = (filePath) => {
+  if (filePath.endsWith(".tsx"))
+    return ts4.ScriptKind.TSX;
+  if (filePath.endsWith(".ts"))
+    return ts4.ScriptKind.TS;
+  return null;
+};
+var checkPathCasing = async (workspace, filePath) => {
+  const segments = filePath.split("/").filter(Boolean);
+  let current = ".";
+  for (const segment of segments) {
+    const entries = await workspace.readdir(current);
+    if (entries.includes(segment)) {
+      current = current === "." ? segment : `${current}/${segment}`;
+      continue;
+    }
+    const caseInsensitiveMatch = entries.find((entry) => entry.toLowerCase() === segment.toLowerCase());
+    return caseInsensitiveMatch ? {
+      code: "workflow-path-casing-mismatch",
+      message: `Reported path segment "${segment}" does not match actual casing "${caseInsensitiveMatch}" in ${filePath}.`
+    } : {
+      code: "workflow-path-missing",
+      message: `Reported path does not exist: ${filePath}.`
+    };
+  }
+  return null;
+};
+var checkTypeScriptSyntax = async (workspace, filePath) => {
+  const scriptKind = sourceKindForPath(filePath);
+  if (!scriptKind)
+    return null;
+  const content = await workspace.readFile(filePath);
+  const source = ts4.createSourceFile(filePath, content, ts4.ScriptTarget.Latest, true, scriptKind);
+  const diagnostic = source.parseDiagnostics[0];
+  if (!diagnostic)
+    return null;
+  const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+  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, " ")}`
+  };
+};
+var checkChangedFile = async (workspace, file) => {
+  if (file.action === "remove")
+    return { postApplyChecks: [] };
+  const diagnostics = [];
+  const checks = [];
+  const pathIssue = await checkPathCasing(workspace, file.path);
+  if (pathIssue) {
+    diagnostics.push(postApplyDiagnostic(pathIssue.code, pathIssue.message, file.path));
+    checks.push({ ...pathIssue, target: file.path, status: "failed" });
+    return { diagnostics, postApplyChecks: checks };
+  }
+  const syntaxIssue = await checkTypeScriptSyntax(workspace, file.path);
+  if (syntaxIssue) {
+    diagnostics.push(postApplyDiagnostic(syntaxIssue.code, syntaxIssue.message, file.path));
+    checks.push({ ...syntaxIssue, target: file.path, status: "failed" });
+    return { diagnostics, postApplyChecks: checks };
+  }
+  checks.push({
+    code: "workflow-post-apply-file-valid",
+    target: file.path,
+    status: "passed",
+    message: "Changed file exists with exact casing and parses as source when applicable."
+  });
+  return { postApplyChecks: checks };
+};
+var checkRecommendationPath = async (workspace, recommendation) => {
+  if (!recommendation.target || recommendation.target.includes("*") || recommendation.target.startsWith("<"))
+    return null;
+  const pathIssue = await checkPathCasing(workspace, recommendation.target);
+  if (!pathIssue)
+    return null;
+  return {
+    severity: "warning",
+    code: "workflow-recommendation-path-unverified",
+    message: `${pathIssue.message} Recommendation "${recommendation.code}" should not be treated as an exact file target until the path is corrected.`,
+    failureScope: "source-change",
+    context: { target: recommendation.target }
+  };
+};
+var resolveWorkflowSys = async (workspace, target) => {
+  if (!target)
+    return null;
+  const [apps, libs] = await workspace.getSyss();
+  if (apps.includes(target))
+    return AppExecutor.from(workspace, target);
+  if (libs.includes(target))
+    return LibExecutor.from(workspace, target);
+  return null;
+};
+var targetMissing = (input2 = "app") => ({
+  severity: "error",
+  code: "workflow-target-missing",
+  input: input2,
+  message: "Workflow target app or library was not found."
+});
+var inputMissing = (input2) => ({
+  severity: "error",
+  code: "workflow-input-missing",
+  input: input2,
+  message: `Workflow input "${input2}" is required for apply.`
+});
+var unsupportedInput = (input2, message) => ({
+  severity: "error",
+  code: "workflow-input-unsupported",
+  input: input2,
+  message
+});
+var addFieldUiSurfaceInspection = (plan) => {
+  const app = workflowStringInput(plan.inputs.app);
+  const module = workflowStringInput(plan.inputs.module) ?? "<module>";
+  const field = workflowStringInput(plan.inputs.field) ?? "<field>";
+  const typeName = workflowStringInput(plan.inputs.type);
+  const policy = addFieldUiPolicyForType(typeName ?? "String");
+  const surfaces = workflowStringArrayInput(plan.inputs.surfaces);
+  const templateRequested = surfaces?.includes("template") ?? false;
+  const moduleClassName = capitalize2(module);
+  const target = `${app ? `apps/${app}` : "*"}/${moduleSourcePaths(module).template}`;
+  return {
+    recommendations: [
+      {
+        code: "add-field-ui-surface-review",
+        kind: "manual-action",
+        target,
+        action: templateRequested ? `Template was requested for ${field}. If no Template file changed, auto-edit was skipped because the file was missing, the generated ${module}Form/Layout.Template pattern was not found, or ${policy.component} needs option binding. Candidate position: inside Layout.Template near the existing Field components.` : `Template was not selected, so UI files are intentionally left unchanged. Candidate positions if you expose it later: Layout.Template field list for editing, Light${moduleClassName} projection for list/card data, and Unit/View card sections for display.`,
+        confidence: "medium",
+        message: `Review UI surfaces for ${module}.${field}; recommended component is ${policy.component}, with manual reasons and candidate positions in action.`
+      }
+    ],
+    nextActions: [
+      {
+        command: `akan workflow explain ${plan.workflow}`,
+        reason: "Review UI surface guidance before manually editing ambiguous UI files."
+      }
+    ]
+  };
+};
+var createWorkflowStepRegistry = ({
+  workspace,
+  createModule,
+  createScalar,
+  createUi,
+  addField,
+  addEnumField
+}) => {
+  const inspect = async () => {
+    return;
+  };
+  const commandOnly = async () => {
+    return;
+  };
+  return {
+    inspectSystem: inspect,
+    inspectModule: inspect,
+    syncTarget: commandOnly,
+    lintTarget: commandOnly,
+    [workflowStepKey("create-module", "create-module")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const module = workflowStringInput(plan.inputs.module);
+      const sys2 = await resolveWorkflowSys(workspace, app);
+      if (!sys2 || !module)
+        return { diagnostics: [!sys2 ? targetMissing() : inputMissing("module")] };
+      return primitiveReportToWorkflowStepResult(await createModule(sys2, module));
+    },
+    [workflowStepKey("create-scalar", "create-scalar")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const scalar = workflowStringInput(plan.inputs.scalar);
+      const sys2 = await resolveWorkflowSys(workspace, app);
+      if (!sys2 || !scalar)
+        return { diagnostics: [!sys2 ? targetMissing() : inputMissing("scalar")] };
+      return primitiveReportToWorkflowStepResult(await createScalar(sys2, scalar));
+    },
+    [workflowStepKey("create-ui", "create-ui")]: async (_step, plan) => {
+      const surface = workflowStringInput(plan.inputs.surface);
+      if (surface !== "view" && surface !== "unit" && surface !== "template") {
+        return {
+          diagnostics: [
+            unsupportedInput("surface", "Workflow apply currently supports create-ui surfaces: view, unit, template.")
+          ]
+        };
+      }
+      return primitiveReportToWorkflowStepResult(await createUi({
+        app: workflowStringInput(plan.inputs.app),
+        module: workflowStringInput(plan.inputs.module),
+        surface
+      }));
+    },
+    [workflowStepKey("add-field", "update-constant")]: async (_step, plan) => {
+      if (workflowStringInput(plan.inputs.type)?.toLowerCase() === "enum") {
+        return primitiveReportToWorkflowStepResult(await addEnumField({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          field: workflowStringInput(plan.inputs.field),
+          values: workflowStringListInput(plan.inputs.values),
+          defaultValue: workflowStringInput(plan.inputs.default),
+          surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+          includeInLight: workflowBooleanInput(plan.inputs.includeInLight)
+        }));
+      }
+      return primitiveReportToWorkflowStepResult(await addField({
+        app: workflowStringInput(plan.inputs.app),
+        module: workflowStringInput(plan.inputs.module),
+        field: workflowStringInput(plan.inputs.field),
+        type: workflowStringInput(plan.inputs.type),
+        defaultValue: workflowStringInput(plan.inputs.default),
+        surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+        includeInLight: workflowBooleanInput(plan.inputs.includeInLight)
+      }));
+    },
+    [workflowStepKey("add-field", "update-dictionary")]: inspect,
+    [workflowStepKey("add-field", "update-ui-surfaces")]: async (_step, plan) => addFieldUiSurfaceInspection(plan),
+    [workflowStepKey("add-enum-field", "update-constant")]: async (_step, plan) => primitiveReportToWorkflowStepResult(await addEnumField({
+      app: workflowStringInput(plan.inputs.app),
+      module: workflowStringInput(plan.inputs.module),
+      field: workflowStringInput(plan.inputs.field),
+      values: workflowStringListInput(plan.inputs.values),
+      defaultValue: workflowStringInput(plan.inputs.default)
+    })),
+    [workflowStepKey("add-enum-field", "update-dictionary")]: inspect,
+    [workflowStepKey("add-enum-field", "update-option")]: inspect
+  };
+};
+class WorkflowExecutor {
+  registry;
+  workspace;
+  constructor(registry, workspace) {
+    this.registry = registry;
+    this.workspace = workspace;
   }
-  return `import { enumOf } from "akanjs/base";
-${content}`;
-};
-var insertEnumClass = (content, enumClassName, enumName, values) => {
-  if (content.includes(`export class ${enumClassName} extends enumOf`))
-    return content;
-  const enumClass = `export class ${enumClassName} extends enumOf("${enumName}", [
-${values.map((value) => `  ${JSON.stringify(value)},`).join(`
-`)}
-] as const) {}
-
-`;
-  const firstClassIndex = content.indexOf("export class ");
-  if (firstClassIndex < 0)
-    return `${content}
-${enumClass}`;
-  return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
-};
-var insertDictionaryModelField = (content, moduleClassName, fieldName) => {
-  if (new RegExp(`\\b${fieldName}\\s*:`).test(content))
-    return content;
-  const label = titleize(fieldName);
-  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => ({`);
-  if (modelIndex < 0)
-    return null;
-  const objectEndIndex = content.indexOf("  }))", modelIndex);
-  if (objectEndIndex < 0)
-    return null;
-  return `${content.slice(0, objectEndIndex)}    ${fieldName}: t([${JSON.stringify(label)}, ${JSON.stringify(label)}]).desc([${JSON.stringify(label)}, ${JSON.stringify(label)}]),
-${content.slice(objectEndIndex)}`;
-};
-var ensureConstantTypeImport = (content, constantPath, typeName) => {
-  if (new RegExp(`import type \\{[^}]*\\b${typeName}\\b[^}]*\\} from "${constantPath}";`).test(content))
-    return content;
-  const importPattern = new RegExp(`import type \\{ ([^}]+) \\} from "${constantPath}";`);
-  const existingImport = content.match(importPattern);
-  if (existingImport !== null) {
-    const names = existingImport[1]?.split(",").map((name) => name.trim()) ?? [];
-    return content.replace(existingImport[0], `import type { ${[...names, typeName].sort().join(", ")} } from "${constantPath}";`);
+  async apply(plan) {
+    const changedFiles = [];
+    const generatedFiles = [];
+    const recommendedValidationCommands = [];
+    const diagnostics = [...plan.diagnostics];
+    const postApplyChecks = [];
+    const recommendations = [...plan.recommendations];
+    const nextActions = [];
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      return createWorkflowApplyReport({
+        workflow: plan.workflow,
+        mode: "apply",
+        changedFiles,
+        generatedFiles,
+        recommendedValidationCommands,
+        diagnostics,
+        postApplyChecks,
+        recommendations,
+        nextActions,
+        plan
+      });
+    }
+    recommendedValidationCommands.push(...workflowCommandsForPlan(plan));
+    nextActions.push(...workflowCommandsForPlan(plan));
+    for (const step of plan.steps) {
+      const runner = this.registry[workflowStepKey(plan.workflow, step.id)] ?? this.registry[step.tool] ?? this.registry[step.id];
+      if (!runner) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-step-unsupported",
+          message: `Workflow ${plan.workflow} step "${step.id}" is not supported by workflow apply yet.`
+        });
+        nextActions.push({
+          command: `akan workflow explain ${plan.workflow}`,
+          reason: "Review the unsupported workflow step before retrying apply."
+        });
+        break;
+      }
+      const result = await runner(step, plan);
+      if (!result)
+        continue;
+      changedFiles.push(...result.changedFiles ?? []);
+      generatedFiles.push(...result.generatedFiles ?? []);
+      recommendedValidationCommands.push(...result.commands ?? []);
+      diagnostics.push(...result.diagnostics ?? []);
+      recommendations.push(...result.recommendations ?? []);
+      nextActions.push(...result.nextActions ?? []);
+      if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+        break;
+    }
+    if (this.workspace && !diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      for (const file of changedFiles) {
+        const result = await checkChangedFile(this.workspace, file);
+        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));
+    }
+    return createWorkflowApplyReport({
+      workflow: plan.workflow,
+      mode: "apply",
+      changedFiles,
+      generatedFiles,
+      recommendedValidationCommands,
+      diagnostics,
+      postApplyChecks,
+      recommendations,
+      nextActions,
+      plan
+    });
   }
-  return `import type { ${typeName} } from "${constantPath}";
-${content}`;
-};
-var insertDictionaryEnum = (content, enumClassName, enumName, values) => {
-  if (content.includes(`.enum<${enumClassName}>("${enumName}"`))
-    return content;
-  const enumBlock = `  .enum<${enumClassName}>("${enumName}", (t) => ({
-${values.map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${JSON.stringify(titleize(value))}]),`).join(`
-`)}
-  }))
-`;
-  const chainEndIndex = content.lastIndexOf(";");
-  const insertBeforeIndex = [content.indexOf(".error("), content.indexOf(".translate("), chainEndIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
-  if (insertBeforeIndex === undefined)
-    return null;
-  return `${content.slice(0, insertBeforeIndex)}${enumBlock}${content.slice(insertBeforeIndex)}`;
-};
-var parseValues = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
-
+}
 // pkgs/@akanjs/devkit/workflow/plan.ts
+import { capitalize as capitalize3 } from "akanjs/common";
 var surfaceModes = new Set(["infer", "include", "skip"]);
 var parseStringList = (value) => {
   if (Array.isArray(value)) {
@@ -5501,6 +5916,18 @@ var normalizeInputValue = (name, spec, value) => {
     const values = parseStringList(value);
     return values && values.length > 0 ? values : null;
   }
+  if (spec.type === "boolean") {
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value !== "string")
+      return null;
+    const lowered = value.trim().toLowerCase();
+    if (lowered === "true")
+      return true;
+    if (lowered === "false")
+      return false;
+    return null;
+  }
   if (typeof value === "string" && surfaceModes.has(value))
     return value;
   throw new Error(`Unsupported workflow input value for ${name}`);
@@ -5508,17 +5935,45 @@ var normalizeInputValue = (name, spec, value) => {
 var listWorkflowSpecs = (specs) => [...specs].sort((a, b) => a.name.localeCompare(b.name));
 var getWorkflowSpec = (specs, name) => specs.find((spec) => spec.name === name) ?? null;
 var compactWorkflowInputs = (inputs) => Object.fromEntries(Object.entries(inputs).filter(([, value]) => value !== null && value !== ""));
-var addFieldComponentForType = (typeName) => {
-  const normalizedType = normalizeFieldType(typeName);
-  if (normalizedType === "Boolean")
-    return "Field.ToggleSelect";
-  if (normalizedType === "Date")
-    return "Field.Date";
-  if (normalizedType === "Int" || normalizedType === "Float")
-    return "manual numeric input review";
-  if (typeName.toLowerCase() === "enum")
-    return "Field.ToggleSelect";
-  return "Field.Text";
+var addFieldTargetRoot = (app) => app ? `apps/${app}` : "*";
+var addFieldPaths = (inputs) => {
+  const app = typeof inputs.app === "string" ? inputs.app : null;
+  const module = typeof inputs.module === "string" ? inputs.module : "<module>";
+  const paths = moduleSourcePaths(module);
+  const root = addFieldTargetRoot(app);
+  return {
+    constant: `${root}/${paths.constant}`,
+    dictionary: `${root}/${paths.dictionary}`,
+    template: `${root}/${paths.template}`,
+    unit: `${root}/${paths.unit}`,
+    view: `${root}/${paths.view}`
+  };
+};
+var selectedAddFieldSurfaces = (inputs) => Array.isArray(inputs.surfaces) ? new Set(inputs.surfaces) : null;
+var addFieldDefaultCoercion = (inputs) => {
+  const typeName = typeof inputs.type === "string" ? inputs.type : null;
+  const defaultValue = typeof inputs.default === "string" ? inputs.default : null;
+  if (!typeName || defaultValue === null)
+    return null;
+  if (typeName.toLowerCase() === "number" || typeName.toLowerCase() === "numeric")
+    return null;
+  const enumValues = Array.isArray(inputs.values) ? inputs.values : null;
+  return coerceFieldDefault(typeName.toLowerCase() === "enum" ? "enum" : typeName, defaultValue, { enumValues });
+};
+var createAddFieldDefaultRecommendations = (inputs) => {
+  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
+  const coercion = addFieldDefaultCoercion(inputs);
+  if (!coercion?.normalized || !coercion.expression)
+    return [];
+  return [
+    {
+      code: "add-field-default-normalized",
+      kind: "manual-action",
+      confidence: "high",
+      message: `Default for ${field} will be normalized to ${coercion.normalizedType} literal ${coercion.expression}.`,
+      action: "Review the normalized default in the apply report if this value should stay unset."
+    }
+  ];
 };
 var createAddFieldRecommendations = (inputs) => {
   const app = typeof inputs.app === "string" ? inputs.app : "<app-or-lib>";
@@ -5527,16 +5982,18 @@ var createAddFieldRecommendations = (inputs) => {
   const typeName = typeof inputs.type === "string" ? inputs.type : null;
   if (!typeName)
     return [];
-  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
-  const constantPath = `*/lib/${module}/${module}.constant.ts`;
-  const dictionaryPath = `*/lib/${module}/${module}.dictionary.ts`;
-  const templatePath = `*/lib/${module}/${capitalize3(module)}.Template.tsx`;
+  const policy = addFieldUiPolicyForType(typeName);
+  const normalizedType = policy.normalizedType;
+  const paths = addFieldPaths(inputs);
+  const surfaces = selectedAddFieldSurfaces(inputs);
+  const templateRequested = surfaces?.has("template") ?? false;
+  const includeInLight = inputs.includeInLight === true;
   return [
     ...normalizedType === "Int" || normalizedType === "Float" ? [
       {
         code: "add-field-import",
         kind: "import",
-        target: constantPath,
+        target: paths.constant,
         confidence: "high",
         message: `Import ${normalizedType} from "akanjs/base" before writing field(${normalizedType}).`
       }
@@ -5544,35 +6001,122 @@ var createAddFieldRecommendations = (inputs) => {
     {
       code: "add-field-placement-constant",
       kind: "placement",
-      target: constantPath,
+      target: paths.constant,
       confidence: "high",
       message: `Insert ${field}: field(${normalizedType}) in ${capitalize3(module)}Input.`
     },
     {
       code: "add-field-placement-dictionary",
       kind: "placement",
-      target: dictionaryPath,
+      target: paths.dictionary,
       confidence: "high",
       message: `Add dictionary labels for ${module}.${field}.`
     },
     {
       code: "add-field-component",
       kind: "ui-component",
-      target: templatePath,
-      confidence: normalizedType === "Int" || normalizedType === "Float" ? "low" : "high",
-      action: normalizedType === "Int" || normalizedType === "Float" ? "Do not auto-edit UI. Check local Template/Unit/View patterns for Field.Text parsing, formatting, validation rules, and dictionary labels before adding a numeric input." : undefined,
-      message: normalizedType === "Int" || normalizedType === "Float" ? `Numeric UI for ${field} (${normalizedType}) requires manual review; a safe numeric input component pattern is not yet detected.` : `Recommended UI component for ${field} (${normalizedType}): ${addFieldComponentForType(typeName)}.`
+      target: paths.template,
+      confidence: policy.confidence,
+      action: templateRequested ? `apply_workflow will try to add ${policy.component} to Template when the existing Template has a safe generated field-list pattern.` : `Recommended component is ${policy.component}. Pass surfaces=["template"] when this field should be rendered in the Template form.`,
+      message: `Recommended UI component for ${field} (${normalizedType}): ${policy.component}.`
     },
+    ...!surfaces ? [
+      {
+        code: "add-field-template-surface-choice",
+        kind: "manual-action",
+        target: paths.template,
+        action: `Choose whether to expose ${field} in Template by passing surfaces=["template"].`,
+        confidence: "medium",
+        message: `Template exposure for ${module}.${field} is not selected yet.`
+      }
+    ] : [],
+    ...!includeInLight ? [
+      {
+        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.`,
+        confidence: "medium",
+        message: `Light projection exposure for ${module}.${field} is not selected yet.`
+      }
+    ] : [],
+    ...includeInLight ? [
+      {
+        code: "add-field-light-projection",
+        kind: "placement",
+        target: paths.constant,
+        confidence: "high",
+        message: `Add ${field} to Light${capitalize3(module)} projection fields.`
+      }
+    ] : [],
+    ...surfaces && !templateRequested ? [
+      {
+        code: "add-field-ui-surface-skip",
+        kind: "manual-action",
+        target: paths.template,
+        confidence: "medium",
+        message: `Template is not included in surfaces, so ${module}.${field} will not be auto-rendered there.`
+      }
+    ] : [],
     {
       code: "add-field-ui-manual-review",
       kind: "manual-action",
-      target: templatePath,
-      action: `Review ${app}:${module} Template/Unit/View/Store surfaces and add ${field} only where the existing pattern is clear. For numeric fields, confirm parser/formatter behavior and validation before using Field.Text.`,
+      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.`,
       confidence: "medium",
-      message: normalizedType === "Int" || normalizedType === "Float" ? "UI surface edits stay manual because a safe numeric input component pattern is not yet detected." : "UI surface edits are planned as manual-review unless a safe existing field-list pattern is detected."
+      message: "UI manual review includes the reason auto-edit may be skipped and candidate insertion positions."
+    },
+    ...createAddFieldDefaultRecommendations(inputs)
+  ];
+};
+var createWorkflowPlanPredictedChanges = (spec, inputs) => {
+  if (spec.name !== "add-field")
+    return spec.predictedChanges;
+  const paths = addFieldPaths(inputs);
+  const surfaces = selectedAddFieldSurfaces(inputs);
+  const includeInLight = inputs.includeInLight === true;
+  return [
+    {
+      target: paths.constant,
+      action: "modify",
+      applyScope: "auto",
+      reason: includeInLight ? "Field shape and Light projection are added." : "Field shape is added."
+    },
+    {
+      target: paths.dictionary,
+      action: "modify",
+      applyScope: "auto",
+      reason: "Field label is added."
+    },
+    ...!surfaces || surfaces.has("template") ? [
+      {
+        target: paths.template,
+        action: "modify",
+        applyScope: surfaces?.has("template") ? "auto" : "manual-review",
+        reason: surfaces?.has("template") ? "Template form is selected for safe-pattern auto insertion." : "Form surface may include the field."
+      }
+    ] : [],
+    {
+      target: `${addFieldTargetRoot(typeof inputs.app === "string" ? inputs.app : null)}/lib/cnst.ts`,
+      action: "sync",
+      applyScope: "generated-sync",
+      reason: "Generated constants may change after sync."
+    },
+    {
+      target: `${addFieldTargetRoot(typeof inputs.app === "string" ? inputs.app : null)}/lib/dict.ts`,
+      action: "sync",
+      applyScope: "generated-sync",
+      reason: "Generated dictionary barrel may change after sync."
     }
   ];
 };
+var createWorkflowPlanOptionalSurfaces = (spec, inputs) => {
+  const optionalSurfaces = spec.optionalSurfaces ?? {};
+  const surfaces = selectedAddFieldSurfaces(inputs);
+  if (spec.name !== "add-field" || !surfaces)
+    return optionalSurfaces;
+  return Object.fromEntries(Object.entries(optionalSurfaces).map(([surface, mode]) => [surface, surfaces.has(surface) ? "include" : mode]));
+};
 var createWorkflowPlanRecommendations = (spec, inputs) => [
   {
     code: "workflow-apply-first",
@@ -5636,14 +6180,32 @@ var createWorkflowPlan = (spec, rawInputs) => {
       message: `Field type "${fieldType}" is ambiguous in Akan. Use Int for integer fields or Float for decimal fields.`
     });
   }
+  if (spec.name === "add-field") {
+    const defaultCoercion = addFieldDefaultCoercion(inputs);
+    if (defaultCoercion?.diagnostic) {
+      diagnostics.push({
+        ...defaultCoercion.diagnostic,
+        code: "workflow-default-value-invalid",
+        message: `Plan input default is not valid for ${defaultCoercion.normalizedType}: ${defaultCoercion.diagnostic.message}`
+      });
+    } else if (defaultCoercion?.normalized && defaultCoercion.expression) {
+      diagnostics.push({
+        severity: "warning",
+        code: "workflow-default-value-normalized",
+        input: "default",
+        failureScope: "source-change",
+        message: `Plan input default will be written as ${defaultCoercion.normalizedType} literal ${defaultCoercion.expression}.`
+      });
+    }
+  }
   return {
     schemaVersion: 1,
     workflow: spec.name,
     mode: "plan",
     inputs,
-    optionalSurfaces: spec.optionalSurfaces ?? {},
+    optionalSurfaces: createWorkflowPlanOptionalSurfaces(spec, inputs),
     steps: spec.steps,
-    predictedChanges: spec.predictedChanges,
+    predictedChanges: createWorkflowPlanPredictedChanges(spec, inputs),
     validation: spec.validation,
     diagnostics,
     recommendations: createWorkflowPlanRecommendations(spec, inputs),
@@ -5712,35 +6274,65 @@ var renderWorkflowPlan = (plan) => [
   ""
 ].join(`
 `);
-var renderWorkflowApplyReport = (report) => [
-  `# Workflow Apply: ${report.workflow}`,
-  "",
-  `- Mode: ${report.mode}`,
-  `- Status: ${report.status}`,
-  "",
-  "## Changed Files",
-  ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
-  "",
-  "## Generated Files",
-  ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
-  "",
-  "## Applied Commands",
-  ...report.appliedCommands.length ? report.appliedCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
-  "",
-  "## Recommended Validation Commands",
-  ...report.recommendedValidationCommands.length ? report.recommendedValidationCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
-  "",
-  "## Diagnostics",
-  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
-  "",
-  "## Recommendations",
-  ...report.recommendations.length ? report.recommendations.map((recommendation) => `- [${recommendation.kind}] ${recommendation.message}`) : ["- none"],
-  "",
-  "## Next Actions",
-  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
-  ""
-].join(`
+var renderRecommendation = (recommendation) => {
+  const target = recommendation.target ? ` ${recommendation.target}` : "";
+  const action = recommendation.action ? ` Action: ${recommendation.action}` : "";
+  return `- [${recommendation.kind}]${target} ${recommendation.message}${action}`;
+};
+var renderDiagnostic = (diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`;
+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 = [
+    ...report.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map(renderDiagnostic),
+    ...report.recommendations.filter((recommendation) => recommendation.kind === "manual-action").map(renderRecommendation)
+  ];
+  const validationBlockers = report.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "workspace-config" || diagnostic.failureScope === "environment")).map(renderDiagnostic);
+  const sourceBlockers = report.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "source-change" || !diagnostic.failureScope || diagnostic.failureScope === "unknown")).map(renderDiagnostic);
+  return [
+    `# Workflow Apply: ${report.workflow}`,
+    "",
+    `- Mode: ${report.mode}`,
+    `- Status: ${report.status}`,
+    `- Source-change status: ${applySourceStatus(report)}`,
+    `- Workspace status: ${validationBlockers.length ? "blocked" : "not blocked during apply"}`,
+    ...report.validationTarget ? [`- Validation target: ${report.validationTarget}`] : [],
+    "",
+    "## Apply Checks",
+    ...report.postApplyChecks?.length ? report.postApplyChecks.map((check) => `- [${check.status}] ${check.code} ${check.target}: ${check.message}`) : ["- not run"],
+    "",
+    "## Source Change Blockers",
+    ...sourceBlockers.length ? sourceBlockers : ["- none"],
+    "",
+    "## Automatically Modified",
+    ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+    "",
+    "## Generated Sync",
+    ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+    "",
+    "## Applied Commands",
+    ...report.appliedCommands.length ? report.appliedCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
+    "",
+    "## Recommended Validation Commands",
+    ...report.recommendedValidationCommands.length ? report.recommendedValidationCommands.map((command) => `- \`${command.command}\`: ${command.reason}`) : ["- none"],
+    "",
+    "## User Review Required",
+    ...manualReviewItems.length ? manualReviewItems : ["- none"],
+    "",
+    "## Validation Blockers",
+    ...validationBlockers.length ? validationBlockers : report.recommendedValidationCommands.length ? ["- none detected during apply; run validation with the validation target for command-level blockers."] : ["- none"],
+    "",
+    "## Diagnostics",
+    ...report.diagnostics.length ? report.diagnostics.map(renderDiagnostic) : ["- none"],
+    "",
+    "## Recommendations",
+    ...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"],
+    ""
+  ].join(`
 `);
+};
 var renderWorkflowApply = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowApplyReport(report);
 var renderWorkflowValidationRunReport = (report) => [
   `# Workflow Validation: ${report.workflow}`,
@@ -5751,11 +6343,24 @@ var renderWorkflowValidationRunReport = (report) => [
   `- Workspace status: ${report.workspaceStatus}`,
   `- Overall status: ${report.overallStatus}`,
   "",
+  "## Status Summary",
+  `- Source-change: ${report.summary.sourceChange}`,
+  `- Generated sync: ${report.summary.generatedSync}`,
+  `- Workspace config: ${report.summary.workspaceConfig}`,
+  `- Environment: ${report.summary.environment}`,
+  "",
+  "## Source Change Diagnostics",
+  ...report.workflowDiagnostics?.length ? report.workflowDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Existing Workspace Blockers",
+  ...report.baselineDiagnostics?.length ? report.baselineDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
   "## Known Blockers",
   ...report.knownBlockers.length ? report.knownBlockers.map((blocker) => {
     const command = blocker.command ? ` \`${blocker.command}\`` : "";
     const count = blocker.count > 1 ? ` (${blocker.count}x)` : "";
-    return `- [${blocker.failureScope}]${command}${count}: ${blocker.message}`;
+    const known = blocker.known ? " known" : "";
+    return `- [${blocker.failureScope}${known}]${command}${count}: ${blocker.message}`;
   }) : ["- none"],
   "",
   "## Commands",
@@ -6824,7 +7429,7 @@ var collapseIndex = (relPathNoExt) => {
 
 // pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
 import path14 from "path";
-import ts4 from "typescript";
+import ts5 from "typescript";
 var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAfter } = {}) => {
   const akanConfig2 = await app.getConfig();
   const barrels = [...new Set(akanConfig2.barrelImports)].filter(Boolean);
@@ -7065,11 +7670,11 @@ var rewriteBarrelImports = async (source2, barrels, analyzer) => {
 };
 var findImportStatements = (source2) => {
   const statements = [];
-  const sourceFile2 = ts4.createSourceFile("barrel-imports.tsx", source2, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX);
+  const sourceFile2 = ts5.createSourceFile("barrel-imports.tsx", source2, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TSX);
   for (const statement of sourceFile2.statements) {
-    if (!ts4.isImportDeclaration(statement))
+    if (!ts5.isImportDeclaration(statement))
       continue;
-    if (!ts4.isStringLiteral(statement.moduleSpecifier))
+    if (!ts5.isStringLiteral(statement.moduleSpecifier))
       continue;
     const importClause = statement.importClause;
     if (!importClause)
@@ -8064,7 +8669,7 @@ import path22 from "path";
 // pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
 import fs3 from "fs";
 import path21 from "path";
-import ts5 from "typescript";
+import ts6 from "typescript";
 
 class PagesEntrySourceGenerator {
   #pageEntries;
@@ -8108,7 +8713,7 @@ ${entries.join(`
   static #hasAsyncDefaultExport(moduleAbsPath) {
     try {
       const source2 = fs3.readFileSync(path21.resolve(moduleAbsPath), "utf8");
-      const sourceFile2 = ts5.createSourceFile(moduleAbsPath, source2, ts5.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
+      const sourceFile2 = ts6.createSourceFile(moduleAbsPath, source2, ts6.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
       return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile2);
     } catch {
       return false;
@@ -8118,31 +8723,31 @@ ${entries.join(`
     const asyncBindings = new Map;
     let defaultIdentifier = null;
     for (const statement of sourceFile2.statements) {
-      if (ts5.isFunctionDeclaration(statement)) {
-        if (PagesEntrySourceGenerator.#hasModifier(statement, ts5.SyntaxKind.DefaultKeyword)) {
-          return PagesEntrySourceGenerator.#hasModifier(statement, ts5.SyntaxKind.AsyncKeyword);
+      if (ts6.isFunctionDeclaration(statement)) {
+        if (PagesEntrySourceGenerator.#hasModifier(statement, ts6.SyntaxKind.DefaultKeyword)) {
+          return PagesEntrySourceGenerator.#hasModifier(statement, ts6.SyntaxKind.AsyncKeyword);
         }
         if (statement.name) {
-          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts5.SyntaxKind.AsyncKeyword));
+          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts6.SyntaxKind.AsyncKeyword));
         }
         continue;
       }
-      if (ts5.isVariableStatement(statement)) {
+      if (ts6.isVariableStatement(statement)) {
         for (const declaration of statement.declarationList.declarations) {
-          if (!ts5.isIdentifier(declaration.name))
+          if (!ts6.isIdentifier(declaration.name))
             continue;
           asyncBindings.set(declaration.name.text, PagesEntrySourceGenerator.#isAsyncFunctionExpression(declaration.initializer));
         }
         continue;
       }
-      if (ts5.isExportAssignment(statement)) {
+      if (ts6.isExportAssignment(statement)) {
         if (PagesEntrySourceGenerator.#isAsyncFunctionExpression(statement.expression))
           return true;
-        if (ts5.isIdentifier(statement.expression))
+        if (ts6.isIdentifier(statement.expression))
           defaultIdentifier = statement.expression.text;
         continue;
       }
-      if (ts5.isExportDeclaration(statement) && statement.exportClause && ts5.isNamedExports(statement.exportClause)) {
+      if (ts6.isExportDeclaration(statement) && statement.exportClause && ts6.isNamedExports(statement.exportClause)) {
         const exportClause = statement.exportClause;
         for (const specifier of exportClause.elements) {
           if (specifier.name.text !== "default")
@@ -8154,13 +8759,13 @@ ${entries.join(`
     return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
   }
   static #hasModifier(node, kind) {
-    return ts5.canHaveModifiers(node) && (ts5.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+    return ts6.canHaveModifiers(node) && (ts6.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
   }
   static #isAsyncFunctionExpression(node) {
-    return Boolean(node && (ts5.isArrowFunction(node) || ts5.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts5.SyntaxKind.AsyncKeyword));
+    return Boolean(node && (ts6.isArrowFunction(node) || ts6.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts6.SyntaxKind.AsyncKeyword));
   }
   static #scriptKind(moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts5.ScriptKind.TSX : ts5.ScriptKind.TS;
+    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts6.ScriptKind.TSX : ts6.ScriptKind.TS;
   }
 }
 
@@ -9079,7 +9684,7 @@ import {
 } from "fontaine";
 import { createFont, woff2 } from "fonteditor-core";
 import subsetFont from "subset-font";
-import ts6 from "typescript";
+import ts7 from "typescript";
 var FONT_URL_PREFIX = "/_akan/fonts";
 var DEFAULT_FONT_SUBSETS = ["latin"];
 
@@ -9144,17 +9749,17 @@ class FontOptimizer {
       this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
   }
   #extractFontsExport(source2, filePath) {
-    const sourceFile2 = ts6.createSourceFile(filePath, source2, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TSX);
+    const sourceFile2 = ts7.createSourceFile(filePath, source2, ts7.ScriptTarget.Latest, true, ts7.ScriptKind.TSX);
     const fonts = [];
     for (const statement of sourceFile2.statements) {
-      if (!ts6.isVariableStatement(statement))
+      if (!ts7.isVariableStatement(statement))
         continue;
-      const modifiers = ts6.canHaveModifiers(statement) ? ts6.getModifiers(statement) : undefined;
-      const isExported = modifiers?.some((modifier) => modifier.kind === ts6.SyntaxKind.ExportKeyword) ?? false;
+      const modifiers = ts7.canHaveModifiers(statement) ? ts7.getModifiers(statement) : undefined;
+      const isExported = modifiers?.some((modifier) => modifier.kind === ts7.SyntaxKind.ExportKeyword) ?? false;
       if (!isExported)
         continue;
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts6.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
+        if (!ts7.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
           continue;
         const value = declaration.initializer ? this.#literalToValue(declaration.initializer) : null;
         if (Array.isArray(value)) {
@@ -9165,20 +9770,20 @@ class FontOptimizer {
     return fonts;
   }
   #literalToValue(node) {
-    if (ts6.isStringLiteralLike(node))
+    if (ts7.isStringLiteralLike(node))
       return node.text;
-    if (ts6.isNumericLiteral(node))
+    if (ts7.isNumericLiteral(node))
       return Number(node.text);
-    if (node.kind === ts6.SyntaxKind.TrueKeyword)
+    if (node.kind === ts7.SyntaxKind.TrueKeyword)
       return true;
-    if (node.kind === ts6.SyntaxKind.FalseKeyword)
+    if (node.kind === ts7.SyntaxKind.FalseKeyword)
       return false;
-    if (ts6.isArrayLiteralExpression(node))
+    if (ts7.isArrayLiteralExpression(node))
       return node.elements.map((element) => this.#literalToValue(element));
-    if (ts6.isObjectLiteralExpression(node)) {
+    if (ts7.isObjectLiteralExpression(node)) {
       const obj = {};
       for (const prop of node.properties) {
-        if (!ts6.isPropertyAssignment(prop))
+        if (!ts7.isPropertyAssignment(prop))
           continue;
         const name = this.#getPropertyName(prop.name);
         if (!name)
@@ -9187,13 +9792,13 @@ class FontOptimizer {
       }
       return obj;
     }
-    if (ts6.isAsExpression(node) || ts6.isSatisfiesExpression(node) || ts6.isParenthesizedExpression(node)) {
+    if (ts7.isAsExpression(node) || ts7.isSatisfiesExpression(node) || ts7.isParenthesizedExpression(node)) {
       return this.#literalToValue(node.expression);
     }
     return;
   }
   #getPropertyName(name) {
-    if (ts6.isIdentifier(name) || ts6.isStringLiteral(name) || ts6.isNumericLiteral(name))
+    if (ts7.isIdentifier(name) || ts7.isStringLiteral(name) || ts7.isNumericLiteral(name))
       return name.text;
     return null;
   }
@@ -12663,10 +13268,12 @@ 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";
 // pkgs/@akanjs/devkit/getRelatedCnsts.ts
 import { readFileSync as readFileSync4, realpathSync } from "fs";
 import ora2 from "ora";
-import * as ts7 from "typescript";
+import * as ts8 from "typescript";
 var tsTranspiler = new Bun.Transpiler({ loader: "ts" });
 var tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
 var getTranspiler = (filePath) => filePath.endsWith(".tsx") ? tsxTranspiler : tsTranspiler;
@@ -12699,10 +13306,10 @@ var scanModuleSpecifiers = (source2, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts7.readConfigFile(tsConfigPath, (path40) => {
-    return ts7.sys.readFile(path40);
+  const configFile = ts8.readConfigFile(tsConfigPath, (path40) => {
+    return ts8.sys.readFile(path40);
   });
-  return ts7.parseJsonConfigFileContent(configFile.config, ts7.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
+  return ts8.parseJsonConfigFileContent(configFile.config, ts8.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
 var collectImportedFiles = (constantFilePath, parsedConfig) => {
   const allFilesToAnalyze = new Set([constantFilePath]);
@@ -12717,7 +13324,7 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
     for (const importPath of scanModuleSpecifiers(source2, filePath, false)) {
       if (!importPath.startsWith("."))
         continue;
-      const resolved = ts7.resolveModuleName(importPath, filePath, parsedConfig.options, ts7.sys).resolvedModule?.resolvedFileName;
+      const resolved = ts8.resolveModuleName(importPath, filePath, parsedConfig.options, ts8.sys).resolvedModule?.resolvedFileName;
       if (resolved && !allFilesToAnalyze.has(resolved)) {
         allFilesToAnalyze.add(resolved);
         collectImported(resolved);
@@ -12734,7 +13341,7 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
 var createTsProgram = (filePaths, options) => {
   const spinner = ora2("Creating TypeScript program for all files...");
   spinner.start();
-  const program2 = ts7.createProgram(Array.from(filePaths), options);
+  const program2 = ts8.createProgram(Array.from(filePaths), options);
   const checker = program2.getTypeChecker();
   spinner.succeed("TypeScript program created.");
   return {
@@ -12774,17 +13381,17 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
     function visit(node) {
       if (!source2)
         return;
-      if (ts7.isPropertyAccessExpression(node)) {
+      if (ts8.isPropertyAccessExpression(node)) {
         const left = node.expression;
         const right = node.name;
-        const { line } = ts7.getLineAndCharacterOfPosition(source2, node.getStart());
-        if (ts7.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 } = 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 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(`${ts7.sys.getCurrentDirectory()}/`, "");
+            const symbolFilePath = symbol.declarations[0]?.getSourceFile().fileName.replace(`${ts8.sys.getCurrentDirectory()}/`, "");
             if (!symbolFilePath)
               throw new Error(`No symbol file path found for ${left.text}.${right.text}`);
             if (property) {
@@ -12808,10 +13415,10 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
             }
           }
         }
-      } else if (ts7.isImportDeclaration(node) && ts7.isStringLiteral(node.moduleSpecifier)) {
+      } else if (ts8.isImportDeclaration(node) && ts8.isStringLiteral(node.moduleSpecifier)) {
         const importPath = node.moduleSpecifier.text;
         if (importPath.startsWith(".")) {
-          const resolved = ts7.resolveModuleName(importPath, filePath, program2.getCompilerOptions(), ts7.sys).resolvedModule?.resolvedFileName;
+          const resolved = ts8.resolveModuleName(importPath, filePath, program2.getCompilerOptions(), ts8.sys).resolvedModule?.resolvedFileName;
           const moduleName = importPath.split("/").pop()?.split(".")[0] ?? "";
           const property = propertyMap.get(moduleName);
           const isScalar = importPath.includes("_");
@@ -12826,7 +13433,7 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
           }
         }
       }
-      ts7.forEachChild(node, visit);
+      ts8.forEachChild(node, visit);
     }
     visit(source2);
   }