@akanjs/cli 2.4.0 → 2.4.1-rc.0

package/index-h6ca6qg0.js

@@ -0,0 +1,2777 @@
+// @bun
+import {
+  AppExecutor,
+  LibExecutor
+} from "./index-a6sbyy0b.js";
+
+// pkgs/@akanjs/devkit/workflow/utils.ts
+var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `
+` : ""}`;
+var workflowStatus = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed";
+var commandStatus = (commands) => commands.some((command) => command.status === "failed") ? "failed" : "passed";
+var uniqueBy = (values, key) => {
+  const seen = new Set;
+  return values.filter((value) => {
+    const itemKey = key(value);
+    if (seen.has(itemKey))
+      return false;
+    seen.add(itemKey);
+    return true;
+  });
+};
+var compactDiagnostics = (diagnostics) => diagnostics.filter((diagnostic) => !!diagnostic);
+
+// pkgs/@akanjs/devkit/workflow/primitive.ts
+var createPrimitiveWriteReport = ({
+  command,
+  status,
+  changedFiles = [],
+  generatedFiles = [],
+  validationCommands = [],
+  diagnostics = [],
+  nextActions = []
+}) => ({
+  schemaVersion: 1,
+  command,
+  status: status ?? (diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed"),
+  changedFiles,
+  generatedFiles,
+  validationCommands,
+  diagnostics,
+  nextActions
+});
+var renderPrimitiveWriteReport = (report) => [
+  `# Primitive Write: ${report.command}`,
+  "",
+  `- 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"],
+  "",
+  "## Validation Commands",
+  ...report.validationCommands.length ? report.validationCommands.map((validation) => `- \`${validation.command}\`: ${validation.reason}`) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderPrimitiveReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderPrimitiveWriteReport(report);
+
+// 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 workflowPlanApproval = {
+  required: true,
+  meaning: "Review this read-only plan before apply_workflow mutates files.",
+  applyTool: "apply_workflow"
+};
+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,
+  changedFiles = [],
+  generatedFiles = [],
+  appliedCommands = [],
+  recommendedValidationCommands,
+  commands = [],
+  diagnostics = [],
+  postApplyChecks = [],
+  recommendations = [],
+  nextActions = [],
+  plan
+}) => {
+  const validationCommands = recommendedValidationCommands ?? commands;
+  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));
+  const sourceFilesChanged = uniqueBy(changedFiles, (file) => `${file.action}:${file.path}:${file.reason}`);
+  const generatedFilesSynced = uniqueBy(generatedFiles, (file) => `${file.action}:${file.path}:${file.reason}`);
+  return {
+    schemaVersion: 1,
+    workflow,
+    mode,
+    status: workflowStatus(diagnostics),
+    summary: {
+      sourceFilesChanged,
+      generatedFilesSynced
+    },
+    changedFiles: sourceFilesChanged,
+    generatedFiles: generatedFilesSynced,
+    appliedCommands: uniqueBy(appliedCommands, (command) => command.command),
+    recommendedValidationCommands: uniqueBy(validationCommands, (command) => command.command),
+    commands: uniqueBy(validationCommands, (command) => command.command),
+    diagnostics,
+    postApplyChecks,
+    recommendations: uniqueBy(recommendations, (recommendation) => `${recommendation.kind}:${recommendation.code}`),
+    nextActions: orderedNextActions.slice(0, 3),
+    plan
+  };
+};
+var resolveWorkflowCommand = (command, plan) => {
+  const target = typeof plan.inputs.app === "string" ? plan.inputs.app : "<app-or-lib>";
+  return command.replaceAll("<app-or-lib-or-pkg>", target).replaceAll("<app-or-lib>", target).replaceAll("<app-name>", target);
+};
+var workflowCommandsForPlan = (plan) => plan.validation.map((validation) => ({
+  command: resolveWorkflowCommand(validation.command, plan),
+  reason: validation.reason,
+  kind: validation.kind
+}));
+var workflowRunsDir = ".akan/workflows/runs";
+var createWorkflowRunId = (prefix = "run") => `${prefix}-${new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${Math.random().toString(36).slice(2, 8)}`;
+var getRunId = (artifact) => {
+  if ("runId" in artifact && artifact.runId)
+    return artifact.runId;
+  return createWorkflowRunId("mode" in artifact ? artifact.mode : artifact.kind);
+};
+var workflowRunArtifactPath = (runId) => `${workflowRunsDir}/${runId}.json`;
+var withWorkflowRunMetadata = (artifact, runId, artifactPath) => {
+  if ("mode" in artifact && (artifact.mode === "apply" || artifact.mode === "dry-run")) {
+    return { ...artifact, runId, applyReportPath: artifactPath, validationTarget: artifactPath };
+  }
+  if ("kind" in artifact)
+    return { ...artifact, runId, repairReportPath: artifactPath };
+  return artifact;
+};
+var writeWorkflowRunArtifact = async (workspace, artifact) => {
+  const runId = getRunId(artifact);
+  const artifactPath = workflowRunArtifactPath(runId);
+  const artifactWithMetadata = withWorkflowRunMetadata(artifact, runId, artifactPath);
+  await workspace.writeFile(artifactPath, jsonText(artifactWithMetadata), { silent: true });
+  return { runId, path: artifactPath, artifact: artifactWithMetadata };
+};
+var workflowSyncDir = ".akan/workflows/sync";
+var syncStateSlug = (target) => target.trim().replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+var workflowSyncStatePath = (target) => `${workflowSyncDir}/${syncStateSlug(target) || "target"}.json`;
+var generatedFilePathsForTarget = (targetRoot, reason = "Generated files were refreshed by sync.") => [
+  { path: `${targetRoot}/lib/cnst.ts`, action: "sync", reason },
+  { path: `${targetRoot}/lib/dict.ts`, action: "sync", reason },
+  { path: `${targetRoot}/lib/index.ts`, action: "sync", reason }
+];
+var writeGeneratedSyncState = async (workspace, state) => {
+  const statePath = workflowSyncStatePath(state.target);
+  await workspace.writeFile(statePath, jsonText(state), { silent: true });
+  return statePath;
+};
+var readWorkflowRunArtifact = async (workspace, runId) => {
+  const artifactPath = workflowRunArtifactPath(runId);
+  if (!await workspace.exists(artifactPath))
+    throw new Error(`Workflow run artifact does not exist: ${artifactPath}`);
+  return await workspace.readJson(artifactPath);
+};
+var failedCommandScopes = (commands) => commands.filter((command) => command.status === "failed").map((command) => command.failureScope ?? "unknown");
+var errorDiagnosticScopes = (diagnostics) => diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.failureScope ?? (diagnostic.scope === "baseline" ? "workspace-config" : diagnostic.scope === "workflow" ? "source-change" : "unknown"));
+var hasScopeFailure = (scopes, scope, diagnostics = []) => scopes.includes(scope) || diagnostics.some((diagnostic) => diagnostic.severity === "error" && diagnostic.failureScope === scope);
+var statusForScope = (commands, diagnostics, scopes, expectedScope) => {
+  const hasCommands = commands.length > 0 || diagnostics.length > 0;
+  if (!hasCommands)
+    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 statusForCommands = (commands) => {
+  if (commands.length === 0)
+    return "unknown";
+  return commandStatus(commands) === "failed" ? "failed" : "passed";
+};
+var statusForDiagnostics = (diagnostics) => {
+  if (diagnostics.length === 0)
+    return "unknown";
+  return workflowStatus(diagnostics) === "failed" ? "failed" : "passed";
+};
+var workflowDiagnosticContextPaths = (diagnostics) => uniqueBy(diagnostics.flatMap((diagnostic) => diagnostic.context?.paths ?? []), (filePath) => filePath);
+var createWorkflowBaselineSummary = (diagnostics, { detailsIncluded = true, knownBlockerCount = 0 } = {}) => {
+  const grouped = new Map;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity === "error")
+      totalErrors += 1;
+    else
+      totalWarnings += 1;
+    const existing = grouped.get(diagnostic.code);
+    if (existing) {
+      existing.count += 1;
+      if (existing.severity !== diagnostic.severity)
+        existing.severity = "mixed";
+    } else {
+      grouped.set(diagnostic.code, {
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        count: 1,
+        sampleMessage: diagnostic.message
+      });
+    }
+  }
+  const contextPaths = workflowDiagnosticContextPaths(diagnostics);
+  return {
+    status: totalErrors > 0 ? "failed" : diagnostics.length > 0 ? "passed" : "unknown",
+    total: diagnostics.length,
+    totalErrors,
+    totalWarnings,
+    detailsIncluded,
+    knownBlockerCount,
+    byCode: [...grouped.values()],
+    ...contextPaths.length ? { contextPaths } : {}
+  };
+};
+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}`,
+    message: `${command.failureScope === "environment" ? "Environment" : "Workspace configuration"} blocker: ${command.command}`,
+    failureScope: command.failureScope ?? "unknown",
+    command: command.command,
+    kind: command.kind,
+    count: 1
+  }));
+  const diagnosticBlockers = diagnostics.filter((diagnostic) => diagnostic.severity === "error" && (diagnostic.failureScope === "workspace-config" || diagnostic.failureScope === "environment" || diagnostic.scope === "baseline")).map((diagnostic) => ({
+    code: diagnostic.code,
+    message: diagnostic.message,
+    failureScope: diagnostic.failureScope ?? "workspace-config",
+    command: diagnostic.command,
+    kind: diagnostic.kind,
+    count: 1
+  }));
+  const grouped = new Map;
+  for (const blocker of [...commandBlockers, ...diagnosticBlockers]) {
+    const key = `${blocker.failureScope}:${blocker.code}:${blocker.command ?? ""}:${blocker.message}`;
+    const existing = grouped.get(key);
+    if (existing)
+      existing.count += blocker.count;
+    else
+      grouped.set(key, blocker);
+  }
+  return [...grouped.values()];
+};
+var createValidationStatuses = (commands, reportDiagnostics, baselineDiagnostics, workflowDiagnostics) => {
+  const diagnostics = [...reportDiagnostics, ...baselineDiagnostics, ...workflowDiagnostics];
+  const scopes = [...failedCommandScopes(commands), ...errorDiagnosticScopes(diagnostics)];
+  const sourceDiagnostics = [...reportDiagnostics, ...workflowDiagnostics].filter((diagnostic) => diagnostic.failureScope === "source-change" || diagnostic.scope === "workflow" || !diagnostic.failureScope && diagnostic.scope !== "baseline");
+  const sourceScopes = [...failedCommandScopes(commands), ...errorDiagnosticScopes(sourceDiagnostics)];
+  const sourceStatus = statusForScope(commands, sourceDiagnostics, sourceScopes, "source-change");
+  const validationCommandsStatus = statusForCommands(commands);
+  const baselineStatus = statusForDiagnostics(baselineDiagnostics);
+  const nonBaselineDiagnostics = [...reportDiagnostics, ...workflowDiagnostics];
+  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" : validationCommandsStatus === "passed" && baselineStatus === "failed" && workflowStatus(nonBaselineDiagnostics) !== "failed" ? "passed-with-baseline-blockers" : 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,
+    validationCommandsStatus,
+    baselineStatus,
+    overallStatus,
+    summary: {
+      sourceChange: sourceStatus,
+      generatedSync: statusForValidationKind(commands, "sync"),
+      validationCommands: validationCommandsStatus,
+      baseline: baselineStatus,
+      workspaceConfig: statusForScope(commands, diagnostics, scopes, "workspace-config"),
+      environment: statusForScope(commands, diagnostics, scopes, "environment")
+    }
+  };
+};
+var createWorkflowValidationRunReport = async ({
+  runId = createWorkflowRunId("validation"),
+  workflow,
+  source,
+  plan,
+  commands,
+  execute,
+  diagnostics = [],
+  baselineDiagnostics = [],
+  workflowDiagnostics = [],
+  repairActions = []
+}) => {
+  const results = [];
+  for (const command of commands) {
+    results.push(await execute(command));
+  }
+  const commandDiagnostics = results.flatMap((result) => result.status === "failed" ? [
+    {
+      severity: "error",
+      code: "workflow-validation-command-failed",
+      message: `Validation command failed: ${result.command}`,
+      command: result.command,
+      kind: result.kind,
+      failureScope: result.failureScope
+    }
+  ] : []);
+  const reportDiagnostics = [...diagnostics, ...commandDiagnostics];
+  const scopedDiagnostics = [...reportDiagnostics, ...baselineDiagnostics, ...workflowDiagnostics];
+  const knownBlockers = createKnownBlockers(results, scopedDiagnostics);
+  const statuses = createValidationStatuses(results, reportDiagnostics, baselineDiagnostics, workflowDiagnostics);
+  return {
+    schemaVersion: 1,
+    runId,
+    workflow,
+    mode: "validate",
+    source,
+    status: statuses.overallStatus === "passed" ? "passed" : "failed",
+    ...statuses,
+    knownBlockers,
+    commands: results,
+    diagnostics: reportDiagnostics,
+    baselineSummary: createWorkflowBaselineSummary(baselineDiagnostics, {
+      knownBlockerCount: knownBlockers.filter((blocker) => blocker.failureScope === "workspace-config").length
+    }),
+    baselineDiagnostics,
+    workflowDiagnostics,
+    repairActions: uniqueBy(repairActions, (action) => action.command),
+    nextActions: results.filter((result) => result.status === "failed").map((result) => ({ command: result.command, reason: "Re-run this validation command after repair." })),
+    plan
+  };
+};
+var createDryRunWorkflowApplyReport = (plan) => {
+  const changedFiles = plan.predictedChanges.flatMap((change) => {
+    if (change.action !== "create" && change.action !== "modify")
+      return [];
+    return [
+      {
+        path: change.target,
+        action: change.action,
+        reason: change.reason
+      }
+    ];
+  });
+  const generatedFiles = plan.predictedChanges.flatMap((change) => {
+    if (change.action !== "sync")
+      return [];
+    return [
+      {
+        path: change.target,
+        action: "sync",
+        reason: change.reason
+      }
+    ];
+  });
+  const diagnostics = [...plan.diagnostics];
+  return createWorkflowApplyReport({
+    workflow: plan.workflow,
+    mode: "dry-run",
+    changedFiles,
+    generatedFiles,
+    commands: workflowCommandsForPlan(plan),
+    diagnostics,
+    recommendations: plan.recommendations,
+    nextActions: workflowCommandsForPlan(plan),
+    plan
+  });
+};
+var createRepairReport = ({
+  command,
+  kind,
+  target = null,
+  diagnostics = [],
+  repairActions = [],
+  nextActions = [],
+  commands = [],
+  generatedFiles = [],
+  syncedAt
+}) => ({
+  schemaVersion: 1,
+  command,
+  kind,
+  target,
+  status: workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed",
+  diagnostics,
+  repairActions: uniqueBy(repairActions, (action) => action.command),
+  nextActions: uniqueBy(nextActions, (action) => action.command),
+  commands,
+  generatedFiles,
+  ...syncedAt ? { syncedAt } : {}
+});
+// pkgs/@akanjs/devkit/workflow/executor.ts
+import ts3 from "typescript";
+
+// pkgs/@akanjs/devkit/workflow/moduleIndex.ts
+import { access } from "fs/promises";
+import path from "path";
+import ts2 from "typescript";
+
+// pkgs/@akanjs/devkit/workflow/source.ts
+import ts from "typescript";
+var getSysRoot = (sys) => `${sys.type}s/${sys.name}`;
+var sourceFile = (sys, path, action, reason) => ({
+  path: `${getSysRoot(sys)}/${path}`,
+  action,
+  reason
+});
+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 {
+    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 = (sys, reason = "Generated files may change after sync.") => generatedFilePathsForTarget(getSysRoot(sys), reason);
+var validationCommandsForTarget = (target) => [
+  { command: `akan sync ${target}`, reason: "Refresh generated Akan files from source conventions." },
+  { command: `akan lint ${target}`, reason: "Validate formatting, imports, and static lint rules." }
+];
+var nextActionsForTarget = (target) => [
+  { command: `akan sync ${target}`, reason: "Refresh generated Akan files after source changes." },
+  { command: `akan lint ${target}`, reason: "Validate the target after generated files are refreshed." }
+];
+var createPassedPrimitiveReport = ({
+  command,
+  changedFiles,
+  generatedFiles,
+  target,
+  nextActions
+}) => createPrimitiveWriteReport({
+  command,
+  changedFiles,
+  generatedFiles: generatedFiles ?? [],
+  validationCommands: validationCommandsForTarget(target),
+  diagnostics: [],
+  nextActions: nextActions ?? nextActionsForTarget(target)
+});
+var scalarChangedFiles = (sys, scalarName, files) => Object.values(files).map((file) => sourceFile(sys, `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",
+    boolean: "Boolean",
+    date: "Date",
+    int: "Int",
+    integer: "Int",
+    float: "Float",
+    double: "Float",
+    decimal: "Float"
+  };
+  return normalizedTypes[typeName.toLowerCase()] ?? typeName;
+};
+var ensureBaseTypeImport = (content, typeName) => {
+  if (typeName !== "Int" && typeName !== "Float")
+    return content;
+  const source = sourceFileFor("constant.ts", content);
+  const baseImport = findNamedImport(source, "akanjs/base");
+  if (baseImport) {
+    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}`;
+};
+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;
+  if (typeName === "Int" && !/^-?\d+$/.test(trimmed))
+    return null;
+  return trimmed;
+};
+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, normalized: typeof defaultValue === "string", normalizedType };
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for ${normalizedType} must be a numeric literal. Received: ${JSON.stringify(defaultValue)}.`
+      }
+    };
+  }
+  if (normalizedType === "Boolean") {
+    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",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for Boolean must be true or false. Received: ${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, options = {}) => {
+  const typeExpression = normalizeFieldType(typeName);
+  const defaultExpression = coerceFieldDefault(options.enumValues ? "enum" : typeExpression, defaultValue, options).expression;
+  const defaultOption = defaultExpression ? `, { default: ${defaultExpression} }` : "";
+  return `${options.builderName ?? "field"}(${typeExpression}${defaultOption})`;
+};
+var fieldOrderingPriority = [
+  "id",
+  "name",
+  "title",
+  "status",
+  "category",
+  "description",
+  "content",
+  "startAt",
+  "dueAt",
+  "endAt",
+  "createdAt",
+  "updatedAt"
+];
+var sourceFileFor = (fileName, content, scriptKind = ts.ScriptKind.TS) => ts.createSourceFile(fileName, content, ts.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 (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node))
+    return node.text;
+  return null;
+};
+var propertyName = (node) => ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || ts.isMethodDeclaration(node) ? nodeName(node.name) : null;
+var expressionName = (expression) => {
+  if (ts.isIdentifier(expression))
+    return expression.text;
+  if (ts.isPropertyAccessExpression(expression))
+    return expression.name.text;
+  if (ts.isCallExpression(expression))
+    return expressionName(expression.expression);
+  if (ts.isAsExpression(expression))
+    return expressionName(expression.expression);
+  return null;
+};
+var firstObjectReturnedByArrow = (node) => {
+  if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node))
+    return null;
+  if (ts.isObjectLiteralExpression(node.body))
+    return node.body;
+  if (ts.isParenthesizedExpression(node.body) && ts.isObjectLiteralExpression(node.body.expression)) {
+    return node.body.expression;
+  }
+  if (!ts.isBlock(node.body))
+    return null;
+  for (const statement of node.body.statements) {
+    if (ts.isReturnStatement(statement) && statement.expression && ts.isObjectLiteralExpression(statement.expression)) {
+      return statement.expression;
+    }
+  }
+  return null;
+};
+var isViaCall = (expression) => ts.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 && ts.isCallExpression(expression) ? expression : null;
+};
+var callExpressionName = (node) => ts.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 (!ts.isClassDeclaration(node) || node.name?.text !== className) {
+      ts.forEachChild(node, visit);
+      return;
+    }
+    const viaCall = heritageCall(node);
+    const callback = viaCall?.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+    const objectLiteral = callback ? firstObjectReturnedByArrow(callback) : null;
+    if (objectLiteral)
+      locator = locatedObject(source, objectLiteral);
+  };
+  ts.forEachChild(source, visit);
+  return locator;
+};
+var chainMethodsForCall = (node) => {
+  if (ts.isAsExpression(node) || ts.isParenthesizedExpression(node))
+    return chainMethodsForCall(node.expression);
+  if (!ts.isCallExpression(node))
+    return [];
+  if (ts.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 (ts.isPropertyAccessExpression(current.parent) && current.parent.expression === current && ts.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 (!ts.isCallExpression(node) || callExpressionName(node) !== "model") {
+      ts.forEachChild(node, visit);
+      return;
+    }
+    const typeArgument = node.typeArguments?.[0];
+    if (!typeArgument || typeArgument.getText(source) !== moduleClassName) {
+      ts.forEachChild(node, visit);
+      return;
+    }
+    const callback = node.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+    const objectLiteral = callback ? firstObjectReturnedByArrow(callback) : null;
+    if (objectLiteral) {
+      locator = {
+        ...locatedObject(source, objectLiteral),
+        chainMethods: chainMethodsForCall(outermostFluentCall(node))
+      };
+    }
+  };
+  ts.forEachChild(source, visit);
+  return locator;
+};
+var findLightProjectionArray = (source, moduleClassName) => {
+  let locator = null;
+  const visit = (node) => {
+    if (locator)
+      return;
+    if (!ts.isClassDeclaration(node) || node.name?.text !== `Light${moduleClassName}`) {
+      ts.forEachChild(node, visit);
+      return;
+    }
+    const viaCall = heritageCall(node);
+    const projectionArg = viaCall?.arguments.find((arg) => {
+      const expression = ts.isAsExpression(arg) ? arg.expression : arg;
+      return ts.isArrayLiteralExpression(expression);
+    });
+    const arrayLiteral = projectionArg ? ts.isAsExpression(projectionArg) ? projectionArg.expression : projectionArg : null;
+    if (!projectionArg || !arrayLiteral || !ts.isArrayLiteralExpression(arrayLiteral))
+      return;
+    locator = {
+      projectionStart: projectionArg.getStart(source),
+      projectionEnd: projectionArg.getEnd(),
+      fields: arrayLiteral.elements.map((element) => ts.isStringLiteralLike(element) ? element.text : null).filter((field) => field !== null)
+    };
+  };
+  ts.forEachChild(source, visit);
+  return locator;
+};
+var findNamedImport = (source, moduleSpecifier) => {
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (statement.moduleSpecifier.text !== moduleSpecifier)
+      continue;
+    const namedBindings = statement.importClause?.namedBindings;
+    if (!namedBindings || !ts.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 (!ts.isPropertyAssignment(property))
+    return null;
+  const initializer = ts.isAsExpression(property.initializer) ? property.initializer.expression : property.initializer;
+  if (!ts.isCallExpression(initializer))
+    return 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 = ts.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 (!ts.isClassDeclaration(node) || node.name?.text !== className) {
+      ts.forEachChild(node, visit);
+      return;
+    }
+    const viaCall = heritageCall(node);
+    const callback = viaCall?.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+    if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+      builderName = nodeName(callback.parameters[0]?.name);
+    }
+  };
+  ts.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 (!ts.isClassDeclaration(node) || node.name?.text !== className) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      const viaCall = heritageCall(node);
+      const callback = viaCall?.arguments.find((arg) => ts.isArrowFunction(arg) || ts.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));
+    };
+    ts.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 fieldName = /^([A-Za-z_$][\w$]*)\s*:/.exec(line.trim())?.[1];
+  if (!fieldName)
+    return null;
+  const source = sourceFileFor("constant.ts", content);
+  const locator = findConstantInputObject(source, className);
+  if (!locator)
+    return null;
+  return insertOrderedFieldLine(content, locator, fieldName, line, { fieldIndent: "  ", closingIndent: "" });
+};
+var insertLightProjectionField = (content, moduleClassName, fieldName) => {
+  const source = sourceFileFor("constant.ts", content);
+  const locator = findLightProjectionArray(source, moduleClassName);
+  if (!locator)
+    return null;
+  if (locator.fields.includes(fieldName))
+    return content;
+  const nextFields = [...locator.fields, fieldName];
+  const nextArray = nextFields.length === 0 ? "[] as const" : `[
+${nextFields.map((field) => `  ${JSON.stringify(field)},`).join(`
+`)}
+] as const`;
+  return spliceText(content, locator.projectionStart, locator.projectionEnd, nextArray);
+};
+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 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) => {
+  const source = sourceFileFor("dictionary.ts", content);
+  const locator = findDictionaryModelObject(source, moduleClassName);
+  if (!locator)
+    return null;
+  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))
+    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) ?? [];
+var hasSourceParseErrors = (content, fileName = "source.ts") => hasParseDiagnostics(sourceFileFor(fileName, content));
+var findClassDeclaration = (source, className) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts.isClassDeclaration(node) && node.name?.text === className) {
+      found = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(source, visit);
+  return found;
+};
+var firstHeritageCall = (node) => {
+  const expression = (node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [])[0]?.expression;
+  return expression && ts.isCallExpression(expression) ? expression : null;
+};
+var factoryArrowOf = (call) => {
+  const arg = call.arguments.find((argument) => ts.isArrowFunction(argument) || ts.isFunctionExpression(argument));
+  return arg && (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) ? arg : null;
+};
+var hasClassMethod = (content, className, methodName) => {
+  const node = findClassDeclaration(sourceFileFor("service.ts", content), className);
+  return Boolean(node?.members.some((member) => ts.isMethodDeclaration(member) && nodeName(member.name) === methodName));
+};
+var insertClassMethod = (content, className, methodBlock) => {
+  const source = sourceFileFor("service.ts", content);
+  const node = findClassDeclaration(source, className);
+  if (!node)
+    return null;
+  const closeBrace = node.getEnd() - 1;
+  if (content[closeBrace] !== "}")
+    return null;
+  const lead = content.slice(0, closeBrace).endsWith(`
+`) ? "" : `
+`;
+  return spliceText(content, closeBrace, closeBrace, `${lead}${methodBlock}
+`);
+};
+var arrowParamInnerRegion = (content, source, arrow) => {
+  if (arrow.parameters.length > 0) {
+    return {
+      start: arrow.parameters[0].getStart(source),
+      end: arrow.parameters[arrow.parameters.length - 1].getEnd()
+    };
+  }
+  const open = content.indexOf("(", arrow.getStart(source));
+  if (open < 0)
+    return null;
+  const close = content.indexOf(")", open);
+  if (close < 0)
+    return null;
+  return { start: open + 1, end: close };
+};
+var factoryParamEdit = (content, source, arrow, plan) => {
+  if (arrow.parameters.length > 1)
+    return null;
+  const region = arrowParamInnerRegion(content, source, arrow);
+  if (!region)
+    return null;
+  if (arrow.parameters.length === 0) {
+    return { ...region, text: plan.mode === "destructure" ? `{ ${plan.name} }` : plan.name };
+  }
+  const param = arrow.parameters[0];
+  if (plan.mode === "positional")
+    return nodeName(param.name) === plan.name ? "unchanged" : null;
+  if (!ts.isObjectBindingPattern(param.name))
+    return null;
+  const names = param.name.elements.map((element) => ts.isIdentifier(element.name) ? element.name.text : null);
+  if (names.some((name) => name === null))
+    return null;
+  if (names.includes(plan.name))
+    return "unchanged";
+  return {
+    start: param.getStart(source),
+    end: param.getEnd(),
+    text: `{ ${[...names, plan.name].join(", ")} }`
+  };
+};
+var factoryObjectOf = (source, className) => {
+  const node = findClassDeclaration(source, className);
+  const call = node ? firstHeritageCall(node) : null;
+  const arrow = call ? factoryArrowOf(call) : null;
+  const object = arrow ? firstObjectReturnedByArrow(arrow) : null;
+  return arrow && object ? { arrow, object } : null;
+};
+var hasSignalFactoryEntry = (content, className, entryName) => {
+  const located = factoryObjectOf(sourceFileFor("signal.ts", content), className);
+  return Boolean(located?.object.properties.some((property) => propertyName(property) === entryName));
+};
+var insertSignalFactoryEntry = (content, className, entryName, entryLine, param) => {
+  const source = sourceFileFor("signal.ts", content);
+  const located = factoryObjectOf(source, className);
+  if (!located)
+    return null;
+  const locator = locatedObject(source, located.object);
+  if (locator.fields.some((field) => field.name === entryName))
+    return content;
+  const paramEdit = factoryParamEdit(content, source, located.arrow, param);
+  if (paramEdit === null)
+    return null;
+  const withEntry = insertOrderedFieldLine(content, locator, entryName, entryLine, {
+    fieldIndent: "  ",
+    closingIndent: ""
+  });
+  if (withEntry === content)
+    return null;
+  return paramEdit === "unchanged" ? withEntry : spliceText(withEntry, paramEdit.start, paramEdit.end, paramEdit.text);
+};
+
+// 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) => ts2.createSourceFile(filePath, content, ts2.ScriptTarget.Latest, true, ts2.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}: ${ts2.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 (ts2.isIdentifier(node) || ts2.isStringLiteral(node) || ts2.isNumericLiteral(node))
+    return node.text;
+  return null;
+};
+var propertyName2 = (node) => ts2.isPropertyAssignment(node) || ts2.isShorthandPropertyAssignment(node) || ts2.isMethodDeclaration(node) ? nodeName2(node.name) : null;
+var expressionName2 = (expression) => {
+  if (ts2.isIdentifier(expression))
+    return expression.text;
+  if (ts2.isPropertyAccessExpression(expression))
+    return expression.name.text;
+  if (ts2.isCallExpression(expression))
+    return expressionName2(expression.expression);
+  if (ts2.isAsExpression(expression))
+    return expressionName2(expression.expression);
+  return null;
+};
+var expressionSummary = (expression) => {
+  if (ts2.isAsExpression(expression))
+    return expressionSummary(expression.expression);
+  if (ts2.isIdentifier(expression) || ts2.isPropertyAccessExpression(expression))
+    return expressionName2(expression) ?? "expression";
+  if (ts2.isArrayLiteralExpression(expression))
+    return "array-literal";
+  if (ts2.isObjectLiteralExpression(expression))
+    return "object-literal";
+  if (ts2.isStringLiteralLike(expression))
+    return "string-literal";
+  if (ts2.isNumericLiteral(expression))
+    return "numeric-literal";
+  if (expression.kind === ts2.SyntaxKind.TrueKeyword || expression.kind === ts2.SyntaxKind.FalseKeyword) {
+    return "boolean-literal";
+  }
+  if (ts2.isCallExpression(expression)) {
+    const callee = expressionName2(expression.expression);
+    return callee ? `${callee}(...)` : "call-expression";
+  }
+  return ts2.SyntaxKind[expression.kind] ?? "expression";
+};
+var typeSummaryForInitializer = (initializer) => {
+  if (!initializer)
+    return;
+  const expression = ts2.isAsExpression(initializer) ? initializer.expression : initializer;
+  if (!ts2.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 = ts2.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 (!ts2.isArrowFunction(node) && !ts2.isFunctionExpression(node))
+    return null;
+  if (ts2.isObjectLiteralExpression(node.body))
+    return node.body;
+  if (ts2.isParenthesizedExpression(node.body) && ts2.isObjectLiteralExpression(node.body.expression)) {
+    return node.body.expression;
+  }
+  if (!ts2.isBlock(node.body))
+    return null;
+  for (const statement of node.body.statements) {
+    if (ts2.isReturnStatement(statement) && statement.expression && ts2.isObjectLiteralExpression(statement.expression)) {
+      return statement.expression;
+    }
+  }
+  return null;
+};
+var isViaCall2 = (expression) => ts2.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 && ts2.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 (!ts2.isClassDeclaration(node) || !node.name) {
+      ts2.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) => ts2.isArrowFunction(arg) || ts2.isFunctionExpression(arg));
+      if (callback && (ts2.isArrowFunction(callback) || ts2.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 = ts2.isAsExpression(arg) ? arg.expression : arg;
+        return ts2.isArrayLiteralExpression(expression);
+      });
+      const arrayLiteral = projectionArg ? ts2.isAsExpression(projectionArg) ? projectionArg.expression : projectionArg : null;
+      if (arrayLiteral && ts2.isArrayLiteralExpression(arrayLiteral)) {
+        lightProjection = {
+          className,
+          sourceSpan: spanFor(source, filePath, arrayLiteral),
+          fields: arrayLiteral.elements.map((element, order) => ts2.isStringLiteralLike(element) ? {
+            name: element.text,
+            kind: "lightProjection",
+            order,
+            typeSummary: "string-literal",
+            sourceSpan: spanFor(source, filePath, element)
+          } : null).filter((field) => field !== null)
+        };
+      }
+    }
+  };
+  ts2.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) => ts2.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 || !ts2.isCallExpression(node)) {
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    if (callExpressionName2(node) !== "model") {
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    const typeArgument = node.typeArguments?.[0];
+    if (!typeArgument || typeArgument.getText(source) !== moduleClassName) {
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    modelFound = true;
+    const callback = node.arguments.find((arg) => ts2.isArrowFunction(arg) || ts2.isFunctionExpression(arg));
+    if (!callback || !ts2.isArrowFunction(callback) && !ts2.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)
+    };
+  };
+  ts2.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 = path.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(path.join(workspace.workspaceRoot, constantFile.path)) : null;
+  const dictionaryContent = dictionaryFile?.present && dictionaryFile.casing === "match" ? await sourceText(path.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(path.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);
+  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 postApplyWarning = (code, message, target) => ({
+  severity: "warning",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target }
+});
+var sourceKindForPath = (filePath) => {
+  if (filePath.endsWith(".tsx"))
+    return ts3.ScriptKind.TSX;
+  if (filePath.endsWith(".ts"))
+    return ts3.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 = ts3.createSourceFile(filePath, content, ts3.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}: ${ts3.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 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;
+  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 = (input = "app") => ({
+  severity: "error",
+  code: "workflow-target-missing",
+  input,
+  message: "Workflow target app or library was not found."
+});
+var inputMissing = (input) => ({
+  severity: "error",
+  code: "workflow-input-missing",
+  input,
+  message: `Workflow input "${input}" is required for apply.`
+});
+var unsupportedInput = (input, message) => ({
+  severity: "error",
+  code: "workflow-input-unsupported",
+  input,
+  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 = moduleComponentName(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, users will not see the field in the form yet because the file was missing, the generated ${module}Form/Layout.Template pattern was not found, or ${policy.component} needs option binding. Add it inside Layout.Template near existing Field components.` : `Template was not selected, so users will not see ${field} in the form from this apply. If list/card display is needed, include ${field} in Light${moduleClassName} projection data and place it in the local Unit/View card layout.`,
+        confidence: "medium",
+        message: `Review user-visible UI for ${module}.${field}; recommended component is ${policy.component}.`
+      }
+    ],
+    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,
+  addMutation,
+  addSlice
+}) => {
+  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 sys = await resolveWorkflowSys(workspace, app);
+      if (!sys || !module)
+        return { diagnostics: [!sys ? targetMissing() : inputMissing("module")] };
+      return primitiveReportToWorkflowStepResult(await createModule(sys, module));
+    },
+    [workflowStepKey("create-scalar", "create-scalar")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const scalar = workflowStringInput(plan.inputs.scalar);
+      const sys = await resolveWorkflowSys(workspace, app);
+      if (!sys || !scalar)
+        return { diagnostics: [!sys ? targetMissing() : inputMissing("scalar")] };
+      return primitiveReportToWorkflowStepResult(await createScalar(sys, 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,
+    [workflowStepKey("add-mutation", "update-service")]: async (_step, plan) => primitiveReportToWorkflowStepResult(await addMutation({
+      app: workflowStringInput(plan.inputs.app),
+      module: workflowStringInput(plan.inputs.module),
+      mutation: workflowStringInput(plan.inputs.mutation)
+    })),
+    [workflowStepKey("add-mutation", "update-signal")]: inspect,
+    [workflowStepKey("add-slice", "update-service-query")]: async (_step, plan) => primitiveReportToWorkflowStepResult(await addSlice({
+      app: workflowStringInput(plan.inputs.app),
+      module: workflowStringInput(plan.inputs.module),
+      slice: workflowStringInput(plan.inputs.slice)
+    })),
+    [workflowStepKey("add-slice", "update-signal-slice")]: inspect
+  };
+};
+class WorkflowExecutor {
+  registry;
+  workspace;
+  constructor(registry, workspace) {
+    this.registry = registry;
+    this.workspace = workspace;
+  }
+  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 ?? []);
+      }
+      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));
+    }
+    return createWorkflowApplyReport({
+      workflow: plan.workflow,
+      mode: "apply",
+      changedFiles,
+      generatedFiles,
+      recommendedValidationCommands,
+      diagnostics,
+      postApplyChecks,
+      recommendations,
+      nextActions,
+      plan
+    });
+  }
+}
+// pkgs/@akanjs/devkit/workflow/plan.ts
+import { capitalize } from "akanjs/common";
+var surfaceModes = new Set(["infer", "include", "skip"]);
+var parseStringList = (value) => {
+  if (Array.isArray(value)) {
+    const values = value.filter((item) => typeof item === "string" && item.trim().length > 0);
+    return values.length === value.length ? values : null;
+  }
+  if (typeof value !== "string")
+    return null;
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+};
+var normalizeInputValue = (name, spec, value) => {
+  if (spec.type === "string")
+    return typeof value === "string" && value.length > 0 ? value : null;
+  if (spec.type === "string-list") {
+    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}`);
+};
+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 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. To leave the field without a default, omit the default input."
+    }
+  ];
+};
+var moneyLikeFieldPattern = /(budget|price|amount|cost|rate|fee|salary|balance)/i;
+var wholeNumberFieldPattern = /(count|quantity|total|number|index|rank|order|age)/i;
+var createAddFieldInputRecommendations = (inputs) => {
+  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
+  const typeName = typeof inputs.type === "string" ? inputs.type : null;
+  const recommendations = [];
+  if (!typeName)
+    return recommendations;
+  if (typeName.toLowerCase() === "number" || typeName.toLowerCase() === "numeric") {
+    const recommendedType = moneyLikeFieldPattern.test(field) ? "Float" : wholeNumberFieldPattern.test(field) ? "Int" : null;
+    recommendations.push({
+      code: "add-field-type-choice",
+      kind: "input-guidance",
+      confidence: recommendedType ? "high" : "medium",
+      message: recommendedType ? `Use ${recommendedType} for ${field}; Float is recommended for money-like decimal values and Int for whole-number values.` : `Choose Int for whole-number ${field} values or Float for decimal ${field} values.`,
+      action: recommendedType ? `Re-run plan_workflow with type="${recommendedType}".` : 'Re-run plan_workflow with type="Int" or type="Float".'
+    });
+  }
+  if (typeName.toLowerCase() === "enum" && !Array.isArray(inputs.values)) {
+    recommendations.push({
+      code: "add-field-enum-values",
+      kind: "input-guidance",
+      confidence: "high",
+      message: `Enum field ${field} needs values before apply can choose valid dictionary and default behavior.`,
+      action: 'Pass values as an array or comma-separated string, for example values=["draft","done"].'
+    });
+  }
+  if (inputs.default === undefined) {
+    recommendations.push({
+      code: "add-field-default-optional",
+      kind: "input-guidance",
+      confidence: "medium",
+      message: `No default will be written for ${field} because default is omitted.`,
+      action: "Keep default omitted when the field should have no default value."
+    });
+  }
+  return recommendations;
+};
+var createAddFieldRecommendations = (inputs) => {
+  const app = typeof inputs.app === "string" ? inputs.app : "<app-or-lib>";
+  const module = typeof inputs.module === "string" ? inputs.module : "<module>";
+  const field = typeof inputs.field === "string" ? inputs.field : "<field>";
+  const typeName = typeof inputs.type === "string" ? inputs.type : null;
+  if (!typeName)
+    return [];
+  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: paths.constant,
+        confidence: "high",
+        message: `Import ${normalizedType} from "akanjs/base" before writing field(${normalizedType}).`
+      }
+    ] : [],
+    {
+      code: "add-field-placement-constant",
+      kind: "placement",
+      target: paths.constant,
+      confidence: "high",
+      message: `Insert ${field}: field(${normalizedType}) in ${capitalize(module)}Input.`
+    },
+    {
+      code: "add-field-placement-dictionary",
+      kind: "placement",
+      target: paths.dictionary,
+      confidence: "high",
+      message: `Add dictionary labels for ${module}.${field}.`
+    },
+    {
+      code: "add-field-component",
+      kind: "ui-component",
+      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 users should see ${field} in list/card data. Without it, the field can exist on ${capitalize(module)}Input but stay absent from Light${capitalize(module)} projections.`,
+        confidence: "medium",
+        message: `${module}.${field} is not selected for list/card projection data.`
+      }
+    ] : [],
+    ...includeInLight ? [
+      {
+        code: "add-field-light-projection",
+        kind: "placement",
+        target: paths.constant,
+        confidence: "high",
+        message: `Add ${field} to Light${capitalize(module)} projection fields.`
+      }
+    ] : [],
+    ...surfaces && !templateRequested ? [
+      {
+        code: "add-field-ui-surface-skip",
+        kind: "manual-action",
+        target: paths.template,
+        confidence: "medium",
+        message: `Template form auto-edit is skipped for ${module}.${field} because surfaces does not include "template".`,
+        action: `Pass surfaces=["template"] when users should enter ${field} in the Template form.`
+      }
+    ] : [],
+    {
+      code: "add-field-ui-manual-review",
+      kind: "manual-action",
+      target: paths.template,
+      action: `After apply, verify what users can see: Template form auto-edit only runs when a generated ${module}Form hook and Layout.Template field list are present. Unit/View cards are not auto-edited, so ${field} may be stored on ${capitalize(module)} but not shown in list/card UI until you place it in the local card layout.`,
+      confidence: "medium",
+      message: `${app}:${module}.${field} may need UI review for user-visible Template, Unit, and View behavior.`
+    },
+    ...createAddFieldDefaultRecommendations(inputs),
+    ...createAddFieldInputRecommendations(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",
+    kind: "auto-apply",
+    confidence: "high",
+    action: "Call apply_workflow with the MCP planPath before editing source files directly.",
+    message: `Apply the ${spec.name} plan through apply_workflow when MCP returns planPath or next.tool=apply_workflow.`
+  },
+  {
+    code: "workflow-validate-apply-report",
+    kind: "validation",
+    confidence: "high",
+    action: "After apply_workflow, call run_validation with validationTarget when present; otherwise use applyReportPath.",
+    message: "Validate the apply report artifact so diagnostics and recommendations follow the actual apply result."
+  },
+  ...spec.name === "add-field" ? createAddFieldRecommendations(inputs) : []
+];
+var createWorkflowPlan = (spec, rawInputs) => {
+  const inputs = {};
+  const diagnostics = [];
+  for (const [name, inputSpec] of Object.entries(spec.inputs)) {
+    const rawValue = rawInputs[name];
+    if (rawValue === undefined || rawValue === null || rawValue === "") {
+      if (inputSpec.required) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-input-missing",
+          input: name,
+          message: `Workflow ${spec.name} requires input "${name}".`
+        });
+      }
+      continue;
+    }
+    const value = normalizeInputValue(name, inputSpec, rawValue);
+    if (value === null) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-invalid",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be ${inputSpec.type}.`
+      });
+      continue;
+    }
+    if (inputSpec.allowedValues && typeof value === "string" && !inputSpec.allowedValues.includes(value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-not-allowed",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be one of: ${inputSpec.allowedValues.join(", ")}.`
+      });
+      continue;
+    }
+    inputs[name] = value;
+  }
+  const fieldType = inputs.type;
+  if (spec.name === "add-field" && typeof fieldType === "string" && (fieldType.toLowerCase() === "number" || fieldType.toLowerCase() === "numeric")) {
+    diagnostics.push({
+      severity: "error",
+      code: "primitive-field-type-unsupported",
+      input: "type",
+      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: createWorkflowPlanOptionalSurfaces(spec, inputs),
+    steps: spec.steps,
+    predictedChanges: createWorkflowPlanPredictedChanges(spec, inputs),
+    validation: spec.validation,
+    diagnostics,
+    recommendations: createWorkflowPlanRecommendations(spec, inputs),
+    requiresApproval: true,
+    approval: workflowPlanApproval
+  };
+};
+// pkgs/@akanjs/devkit/workflow/render.ts
+var renderWorkflowList = (specs) => [
+  "# Akan Workflows",
+  "",
+  ...specs.flatMap((spec) => [`- \`${spec.name}\`: ${spec.description}`, `  - When: ${spec.whenToUse}`]),
+  ""
+].join(`
+`);
+var renderWorkflowExplain = (spec) => [
+  `# Workflow: ${spec.name}`,
+  "",
+  spec.description,
+  "",
+  "## When To Use",
+  spec.whenToUse,
+  "",
+  "## Inputs",
+  ...Object.entries(spec.inputs).map(([name, input]) => `- \`${name}\`${input.required ? " (required)" : ""}: ${input.description}${input.allowedValues ? ` Allowed: ${input.allowedValues.join(", ")}.` : ""}`),
+  "",
+  "## Optional Surfaces",
+  ...Object.entries(spec.optionalSurfaces ?? {}).map(([name, mode]) => `- \`${name}\`: ${mode}`),
+  "",
+  "## Steps",
+  ...spec.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
+  "",
+  "## Validation",
+  ...spec.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
+  ""
+].join(`
+`);
+var renderWorkflowPlan = (plan) => [
+  `# Workflow Plan: ${plan.workflow}`,
+  "",
+  `- Mode: ${plan.mode}`,
+  `- Requires approval: ${plan.requiresApproval}`,
+  `- Approval: ${plan.approval?.meaning ?? "Review this read-only plan before applying workflow mutations."}`,
+  "",
+  "## Inputs",
+  ...Object.entries(plan.inputs).map(([name, value]) => `- \`${name}\`: ${Array.isArray(value) ? value.join(", ") : value}`),
+  "",
+  "## Optional Surfaces",
+  ...Object.entries(plan.optionalSurfaces).map(([name, mode]) => `- \`${name}\`: ${mode}`),
+  "",
+  "## Steps",
+  ...plan.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
+  "",
+  "## Predicted Changes",
+  ...plan.predictedChanges.map((change) => {
+    const scope = change.applyScope ? ` (${change.applyScope})` : "";
+    return `- \`${change.action}\`${scope} ${change.target}: ${change.reason}`;
+  }),
+  "",
+  "## Validation",
+  ...plan.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
+  "",
+  "## Diagnostics",
+  ...plan.diagnostics.length ? plan.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Recommendations",
+  ...plan.recommendations.length ? plan.recommendations.map((recommendation) => `- [${recommendation.kind}] ${recommendation.message}`) : ["- 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 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 applySummary = {
+    sourceFilesChanged: report.summary?.sourceFilesChanged ?? report.changedFiles,
+    generatedFilesSynced: report.summary?.generatedFilesSynced ?? report.generatedFiles
+  };
+  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"}`,
+    `- Source files changed: ${applySummary.sourceFilesChanged.length}`,
+    `- Generated files queued for sync: ${applySummary.generatedFilesSynced.length}`,
+    ...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",
+    ...applySummary.sourceFilesChanged.length ? applySummary.sourceFilesChanged.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+    "",
+    "## Generated Sync",
+    ...applySummary.generatedFilesSynced.length ? applySummary.generatedFilesSynced.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.slice(0, 3).map(renderNextAction) : ["- none"],
+    ""
+  ].join(`
+`);
+};
+var renderWorkflowApply = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowApplyReport(report);
+var renderWorkflowValidationRunReport = (report) => {
+  const baselineSummary = report.baselineSummary ?? {
+    status: report.baselineDiagnostics?.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "unknown",
+    total: report.baselineDiagnostics?.length ?? 0,
+    totalErrors: report.baselineDiagnostics?.filter((diagnostic) => diagnostic.severity === "error").length ?? 0,
+    totalWarnings: report.baselineDiagnostics?.filter((diagnostic) => diagnostic.severity === "warning").length ?? 0,
+    detailsIncluded: true,
+    knownBlockerCount: report.knownBlockers.filter((blocker) => blocker.known).length,
+    byCode: []
+  };
+  return [
+    `# Workflow Validation: ${report.workflow}`,
+    "",
+    `- Run: ${report.runId}`,
+    `- Status: ${report.status}`,
+    `- Source status: ${report.sourceStatus}`,
+    `- Workspace status: ${report.workspaceStatus}`,
+    `- Validation commands status: ${report.validationCommandsStatus ?? "unknown"}`,
+    `- Baseline status: ${report.baselineStatus ?? baselineSummary.status}`,
+    `- Overall status: ${report.overallStatus}`,
+    "",
+    "## Status Summary",
+    `- Source-change: ${report.summary.sourceChange}`,
+    `- Generated sync: ${report.summary.generatedSync}`,
+    `- Validation commands: ${report.summary.validationCommands ?? "unknown"}`,
+    `- Baseline: ${report.summary.baseline ?? baselineSummary.status}`,
+    `- 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",
+    `- Status: ${baselineSummary.status}`,
+    `- Errors: ${baselineSummary.totalErrors}`,
+    `- Warnings: ${baselineSummary.totalWarnings}`,
+    ...baselineSummary.byCode.length ? baselineSummary.byCode.map((item) => `- [${item.severity}] ${item.code} (${item.count}x): ${item.sampleMessage}`) : ["- none"],
+    ...baselineSummary.detailsIncluded ? [] : [
+      "- Baseline details are summarized by default. Re-run validation with includeBaselineDetails=true for full baselineDiagnostics."
+    ],
+    "",
+    "## Existing Workspace Blocker Details",
+    ...report.baselineDiagnostics?.length ? report.baselineDiagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : baselineSummary.detailsIncluded ? ["- none"] : ["- omitted"],
+    "",
+    "## Known Blockers",
+    ...report.knownBlockers.length ? report.knownBlockers.map((blocker) => {
+      const command = blocker.command ? ` \`${blocker.command}\`` : "";
+      const count = blocker.count > 1 ? ` (${blocker.count}x)` : "";
+      const known = blocker.known ? " known" : "";
+      return `- [${blocker.failureScope}${known}]${command}${count}: ${blocker.message}`;
+    }) : ["- none"],
+    "",
+    "## Commands",
+    ...report.commands.length ? report.commands.map((command) => {
+      const scope = command.failureScope ? ` (${command.failureScope})` : "";
+      return `- [${command.status}] \`${command.command}\`${scope}: ${command.reason}`;
+    }) : ["- none"],
+    "",
+    "## Diagnostics",
+    ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+    "",
+    "## Repair Actions",
+    ...report.repairActions.length ? report.repairActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+    "",
+    "## Next Actions",
+    ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+    ""
+  ].join(`
+`);
+};
+var renderWorkflowValidation = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowValidationRunReport(report);
+var renderRepairReportMarkdown = (report) => [
+  `# Akan Repair: ${report.kind}`,
+  "",
+  `- Status: ${report.status}`,
+  `- Target: ${report.target ?? "none"}`,
+  "",
+  "## Commands",
+  ...report.commands.length ? report.commands.map((command) => `- [${command.status}] \`${command.command}\`: ${command.reason}`) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderRepairReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderRepairReportMarkdown(report);
+var renderWorkflowRunArtifact = (artifact, format = "markdown") => {
+  if ("kind" in artifact)
+    return renderRepairReport(artifact, format);
+  if ("mode" in artifact && artifact.mode === "validate")
+    return renderWorkflowValidation(artifact, format);
+  if ("mode" in artifact && (artifact.mode === "apply" || artifact.mode === "dry-run")) {
+    return renderWorkflowApply(artifact, format);
+  }
+  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;
+for (const candidate of toolingRolloutCandidates) {
+  if (isRestrictedCandidate(candidate))
+    restrictedCandidates.set(candidate.packageName, candidate);
+}
+export { jsonText, compactDiagnostics, workflowPlanApproval, createWorkflowApplyReport, workflowCommandsForPlan, workflowRunArtifactPath, writeWorkflowRunArtifact, workflowSyncDir, generatedFilePathsForTarget, writeGeneratedSyncState, readWorkflowRunArtifact, createWorkflowBaselineSummary, createWorkflowValidationRunReport, createDryRunWorkflowApplyReport, createRepairReport, createPrimitiveWriteReport, renderPrimitiveReport, sourceFile, moduleComponentName, moduleSourcePaths, generatedFilesForSync, validationCommandsForTarget, nextActionsForTarget, createPassedPrimitiveReport, scalarChangedFiles, lowerlize, bilingualLabelForField, bilingualDescriptionForField, normalizeFieldType, ensureBaseTypeImport, coerceFieldDefault, fieldExpression, viaBuilderParameterName, insertIntoObject, insertLightProjectionField, insertTemplateField, ensureEnumImport, insertEnumClass, insertDictionaryModelField, hasConstantInputField, hasDictionaryModelField, ensureConstantTypeImport, insertDictionaryEnum, parseValues, hasSourceParseErrors, hasClassMethod, insertClassMethod, hasSignalFactoryEntry, insertSignalFactoryEntry, buildAkanModuleContextIndex, addFieldUiPolicyForType, createWorkflowStepRegistry, WorkflowExecutor, listWorkflowSpecs, getWorkflowSpec, compactWorkflowInputs, createWorkflowPlan, renderWorkflowList, renderWorkflowExplain, renderWorkflowPlan, renderWorkflowApply, renderWorkflowValidation, renderRepairReport, renderWorkflowRunArtifact, toolingRolloutGate };