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

package/index.ts

@@ -2,6 +2,7 @@ export * from "./aiEditor";
 export * from "./akanApp";
 export * from "./akanConfig";
 export * from "./akanContext";
+export * from "./akanMcpContract";
 export * from "./applicationBuildReporter";
 export * from "./applicationBuildRunner";
 export * from "./applicationReleasePackager";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.3.9-rc.6",
+  "version": "2.3.9-rc.8",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -32,7 +32,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.3.9-rc.6",
+    "akanjs": "2.3.9-rc.8",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "5.5.23",

package/workflow/artifacts.ts

@@ -10,6 +10,8 @@ import type {
   WorkflowDiagnostic,
   WorkflowFailureScope,
   WorkflowKnownBlocker,
+  WorkflowNextActionCode,
+  WorkflowOverallStatus,
   WorkflowPlan,
   WorkflowRunArtifact,
   WorkflowRunSource,
@@ -19,6 +21,37 @@ import type {
 } from "./types";
 import { commandStatus, jsonText, uniqueBy, workflowStatus } from "./utils";
 
+const sourceChangeBlocked = (diagnostics: readonly WorkflowDiagnostic[]) =>
+  diagnostics.some(
+    (diagnostic) =>
+      diagnostic.severity === "error" &&
+      (diagnostic.failureScope === "source-change" ||
+        !diagnostic.failureScope ||
+        diagnostic.failureScope === "unknown"),
+  );
+
+const inferNextActionCode = (
+  action: { action?: WorkflowNextActionCode; command: string },
+  diagnostics: readonly WorkflowDiagnostic[],
+): WorkflowNextActionCode => {
+  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";
+};
+
+const nextActionPriority = (
+  action: { action?: WorkflowNextActionCode },
+  diagnostics: readonly WorkflowDiagnostic[],
+) => {
+  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"];
+};
+
 export const createWorkflowApplyReport = ({
   workflow,
   mode,
@@ -52,11 +85,20 @@ export const createWorkflowApplyReport = ({
   recommendations?: WorkflowApplyReport["recommendations"];
 }): WorkflowApplyReport => {
   const validationCommands = recommendedValidationCommands ?? commands;
-  const orderedNextActions = uniqueBy(nextActions, (action) => action.command).sort((left, right) => {
-    const leftRepair = left.command.startsWith("akan workflow explain") ? 0 : 1;
-    const rightRepair = right.command.startsWith("akan workflow explain") ? 0 : 1;
-    return leftRepair - rightRepair;
-  });
+  const nextActionsWithIntent = nextActions.map((action) => ({
+    ...action,
+    action: inferNextActionCode(action, diagnostics),
+  }));
+  if (sourceChangeBlocked(diagnostics) && !nextActionsWithIntent.some((action) => action.action === "blocked")) {
+    nextActionsWithIntent.unshift({
+      command: `akan workflow explain ${workflow}`,
+      reason: "Review source-change blockers before running validation.",
+      action: "blocked",
+    });
+  }
+  const orderedNextActions = uniqueBy(nextActionsWithIntent, (action) => action.command).sort(
+    (left, right) => nextActionPriority(left, diagnostics) - nextActionPriority(right, diagnostics),
+  );
   return {
     schemaVersion: 1,
     workflow,
@@ -251,7 +293,17 @@ const createKnownBlockers = (
 const createValidationStatuses = (
   commands: readonly WorkflowValidationCommandResult[],
   diagnostics: readonly WorkflowDiagnostic[],
-) => {
+): {
+  sourceStatus: WorkflowValidationStatus;
+  workspaceStatus: WorkflowValidationStatus;
+  overallStatus: WorkflowOverallStatus;
+  summary: {
+    sourceChange: WorkflowValidationStatus;
+    generatedSync: WorkflowValidationStatus;
+    workspaceConfig: WorkflowValidationStatus;
+    environment: WorkflowValidationStatus;
+  };
+} => {
   const scopes = [...failedCommandScopes(commands), ...errorDiagnosticScopes(diagnostics)];
   const sourceStatus = statusForScope(commands, diagnostics, scopes, "source-change");
   const workspaceStatus =

package/workflow/executor.ts

@@ -1,9 +1,17 @@
-import { capitalize } from "akanjs/common";
 import ts from "typescript";
+import type { AkanModuleContext } from "../akanContext";
 import type { Sys, Workspace } from "../commandDecorators";
 import { AppExecutor, LibExecutor } from "../executors";
 import { createWorkflowApplyReport, workflowCommandsForPlan } from "./artifacts";
-import { moduleSourcePaths } from "./source";
+import { buildAkanModuleContextIndex } from "./moduleIndex";
+import {
+  insertionIndexForFieldOrder,
+  inspectConstantStructure,
+  inspectDictionaryStructure,
+  moduleComponentName,
+  moduleSourcePaths,
+  normalizeFieldType,
+} from "./source";
 import type {
   PrimitiveChangedFile,
   PrimitiveGeneratedFile,
@@ -47,6 +55,14 @@ const postApplyDiagnostic = (code: string, message: string, target: string): Wor
   context: { target },
 });
 
+const postApplyWarning = (code: string, message: string, target: string): WorkflowDiagnostic => ({
+  severity: "warning",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target },
+});
+
 const sourceKindForPath = (filePath: string) => {
   if (filePath.endsWith(".tsx")) return ts.ScriptKind.TSX;
   if (filePath.endsWith(".ts")) return ts.ScriptKind.TS;
@@ -81,7 +97,8 @@ const checkTypeScriptSyntax = async (workspace: Workspace, filePath: string) =>
   if (!scriptKind) return null;
   const content = await workspace.readFile(filePath);
   const source = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKind);
-  const diagnostic = source.parseDiagnostics[0];
+  const diagnostic =
+    ((source as ts.SourceFile & { parseDiagnostics?: readonly ts.DiagnosticWithLocation[] }).parseDiagnostics ?? [])[0];
   if (!diagnostic) return null;
   const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
   const location = position ? `:${position.line + 1}:${position.character + 1}` : "";
@@ -136,6 +153,188 @@ const checkRecommendationPath = async (
   };
 };
 
+const sourceChangeError = (diagnostics: readonly WorkflowDiagnostic[]) =>
+  diagnostics.some(
+    (diagnostic) =>
+      diagnostic.severity === "error" &&
+      (diagnostic.failureScope === "source-change" ||
+        !diagnostic.failureScope ||
+        diagnostic.failureScope === "unknown"),
+  );
+
+const fieldCount = (fields: readonly string[], fieldName: string) =>
+  fields.filter((field) => field === fieldName).length;
+
+const fieldOrderValid = (fields: readonly string[], fieldName: string) => {
+  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;
+};
+
+const workflowModuleContext = async (workspace: Workspace, plan: WorkflowPlan): Promise<AkanModuleContext | null> => {
+  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,
+  };
+};
+
+const structureCheck = (
+  code: string,
+  target: string,
+  status: WorkflowPostApplyCheck["status"],
+  message: string,
+): WorkflowPostApplyCheck => ({
+  code,
+  target,
+  status,
+  message,
+});
+
+const checkAddFieldStructure = async (workspace: Workspace, plan: WorkflowPlan): Promise<WorkflowStepResult> => {
+  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: WorkflowDiagnostic[] = [];
+  const postApplyChecks: WorkflowPostApplyCheck[] = [];
+
+  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 is string => 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 is string => 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 };
+};
+
 const resolveWorkflowSys = async (workspace: Workspace, target: string | null): Promise<Sys | null> => {
   if (!target) return null;
   const [apps, libs] = await workspace.getSyss();
@@ -173,7 +372,7 @@ const addFieldUiSurfaceInspection = (plan: WorkflowPlan): WorkflowStepResult =>
   const policy = addFieldUiPolicyForType(typeName ?? "String");
   const surfaces = workflowStringArrayInput(plan.inputs.surfaces);
   const templateRequested = surfaces?.includes("template") ?? false;
-  const moduleClassName = capitalize(module);
+  const moduleClassName = moduleComponentName(module);
   const target = `${app ? `apps/${app}` : "*"}/${moduleSourcePaths(module).template}`;
   return {
     recommendations: [
@@ -362,6 +561,11 @@ export class WorkflowExecutor {
         postApplyChecks.push(...(result.postApplyChecks ?? []));
         diagnostics.push(...(result.diagnostics ?? []));
       }
+      if (!sourceChangeError(diagnostics)) {
+        const result = await checkAddFieldStructure(this.workspace, plan);
+        postApplyChecks.push(...(result.postApplyChecks ?? []));
+        diagnostics.push(...(result.diagnostics ?? []));
+      }
       const recommendationDiagnostics = await Promise.all(
         recommendations.map((recommendation) => checkRecommendationPath(this.workspace as Workspace, recommendation)),
       );

package/workflow/index.ts

@@ -1,8 +1,10 @@
 export * from "./artifacts";
 export * from "./executor";
+export * from "./moduleIndex";
 export * from "./plan";
 export * from "./primitive";
 export * from "./render";
+export * from "./rolloutGate";
 export * from "./source";
 export * from "./types";
 export * from "./uiPolicy";

package/workflow/moduleIndex.test.ts

@@ -0,0 +1,296 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { AkanModuleContext } from "../akanContext";
+import type { Workspace } from "../commandDecorators";
+import { buildAkanModuleContextIndex } from "./moduleIndex";
+
+const tempRoots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+const makeWorkspace = async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-module-index-"));
+  tempRoots.push(root);
+  return {
+    root,
+    workspace: { workspaceRoot: root } as Workspace,
+  };
+};
+
+const writeText = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+const moduleContext = (files: string[], name = "post"): AkanModuleContext => ({
+  kind: "domain",
+  name,
+  folderName: name,
+  sysName: "demo",
+  sysType: "app",
+  path: `apps/demo/lib/${name}`,
+  abstract: { path: `apps/demo/lib/${name}/${name}.abstract.md`, exists: true, headings: [] },
+  files,
+});
+
+describe("buildAkanModuleContextIndex", () => {
+  test("indexes constant, dictionary model, projection, spans, and partial presence without source bodies", async () => {
+    const { root, workspace } = await makeWorkspace();
+    const modulePath = path.join(root, "apps/demo/lib/post");
+    await writeText(
+      path.join(modulePath, "post.constant.ts"),
+      `
+import { Int } from "akanjs/base";
+import { via } from "akanjs/constant";
+
+export class PostInput extends via((_field) => ({
+  title: _field(String),
+  count: _field(Int, { default: 0 }),
+  metadata: _field({ nested: ["secret"] }),
+})) {}
+
+export class PostObject extends via(PostInput, (field) => ({})) {}
+export class LightPost extends via(PostObject, ["title"] as const, (resolve) => ({})) {}
+export class Post extends via(PostObject, LightPost, (resolve) => ({})) {}
+`,
+    );
+    await writeText(
+      path.join(modulePath, "post.dictionary.ts"),
+      `
+import { modelDictionary } from "akanjs/dictionary";
+import type { Post } from "./post.constant";
+
+export const dictionary = modelDictionary(["en", "ko"])
+  .model<Post>((t) => ({
+    title: t(["Title", "제목"]),
+  }))
+  .slice<PostSlice>((fn) => ({
+    inPublic: fn(["Post In Public", "Post 공개"]).arg((t) => ({
+      ignored: t(["Ignored", "Ignored"]),
+    })),
+  }))
+  .translate({});
+`,
+    );
+
+    const index = await buildAkanModuleContextIndex(
+      workspace,
+      moduleContext(["post.abstract.md", "post.constant.ts", "post.dictionary.ts"]),
+      { field: "count" },
+    );
+
+    expect(index).toMatchObject({
+      schemaVersion: 1,
+      app: "demo",
+      module: "post",
+      moduleClassName: "Post",
+      constant: { inputClassName: "PostInput", builderName: "_field" },
+      dictionary: { modelClassName: "Post", translatorName: "t" },
+    });
+    expect(index.constant?.fields.map((field) => [field.name, field.order, field.typeSummary])).toEqual([
+      ["title", 0, "_field(String)"],
+      ["count", 1, "_field(Int)"],
+      ["metadata", 2, "_field(object-literal)"],
+    ]);
+    expect(index.dictionary?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.dictionary?.fields.map((field) => field.name)).not.toContain("ignored");
+    expect(index.constant?.lightProjection?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.constant?.fields[0]?.sourceSpan).toMatchObject({
+      file: "apps/demo/lib/post/post.constant.ts",
+      startLine: expect.any(Number),
+      endLine: expect.any(Number),
+      startOffset: expect.any(Number),
+      endOffset: expect.any(Number),
+    });
+    expect(index.fieldPresence.find((field) => field.name === "count")).toMatchObject({
+      requested: true,
+      constant: true,
+      dictionary: false,
+      lightProjection: false,
+    });
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).toContain("module-index-field-presence-partial");
+    expect(JSON.stringify(index)).not.toContain("export class");
+    expect(JSON.stringify(index)).not.toContain("modelDictionary");
+    expect(JSON.stringify(index)).not.toContain("secret");
+    expect(JSON.stringify(index)).not.toContain("제목");
+  });
+
+  test("reports missing and casing mismatch diagnostics with expected and actual paths", async () => {
+    const { root, workspace } = await makeWorkspace();
+    const modulePath = path.join(root, "apps/demo/lib/post");
+    await writeText(path.join(modulePath, "Post.Constant.ts"), "export class PostInput {}\n");
+
+    const index = await buildAkanModuleContextIndex(workspace, moduleContext(["Post.Constant.ts"]));
+
+    expect(index.files.find((file) => file.kind === "constant")).toMatchObject({
+      path: "apps/demo/lib/post/Post.Constant.ts",
+      expectedPath: "apps/demo/lib/post/post.constant.ts",
+      casing: "mismatch",
+      present: true,
+    });
+    expect(index.files.find((file) => file.kind === "dictionary")).toMatchObject({
+      expectedPath: "apps/demo/lib/post/post.dictionary.ts",
+      casing: "missing",
+      present: false,
+    });
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).toContain("module-index-file-casing-mismatch");
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).toContain("module-index-file-missing");
+    expect(index.diagnostics.flatMap((diagnostic) => diagnostic.context?.paths ?? [])).not.toContain(
+      "apps/demo/lib/post/Post.Template.tsx",
+    );
+    expect(index.diagnostics.flatMap((diagnostic) => diagnostic.context?.paths ?? [])).not.toContain(
+      "apps/demo/lib/post/post.service.ts",
+    );
+  });
+
+  test("indexes field builder callbacks, dictionary block returns, and pascal module names", async () => {
+    const { root, workspace } = await makeWorkspace();
+    const modulePath = path.join(root, "apps/demo/lib/blog-post");
+    await writeText(
+      path.join(modulePath, "blog-post.constant.ts"),
+      `
+import { via } from "akanjs/constant";
+
+export class BlogPostInput extends via((field) => ({
+  title: field(String),
+})) {}
+
+export class BlogPostObject extends via(BlogPostInput, (field) => ({})) {}
+export class LightBlogPost extends via(BlogPostObject, ["title"] as const, (resolve) => ({})) {}
+export class BlogPost extends via(BlogPostObject, LightBlogPost, (resolve) => ({})) {}
+`,
+    );
+    await writeText(
+      path.join(modulePath, "blog-post.dictionary.ts"),
+      `
+import { modelDictionary } from "akanjs/dictionary";
+import type { BlogPost } from "./blog-post.constant";
+
+export const dictionary = modelDictionary(["en"]).model<BlogPost>((t) => {
+  return {
+    title: t(["Title"]),
+  };
+});
+`,
+    );
+
+    const index = await buildAkanModuleContextIndex(
+      workspace,
+      moduleContext(["blog-post.abstract.md", "blog-post.constant.ts", "blog-post.dictionary.ts"], "blog-post"),
+      { field: "title" },
+    );
+
+    expect(index.moduleClassName).toBe("BlogPost");
+    expect(index.constant).toMatchObject({ inputClassName: "BlogPostInput", builderName: "field" });
+    expect(index.constant?.fields.map((field) => [field.name, field.typeSummary])).toEqual([
+      ["title", "field(String)"],
+    ]);
+    expect(index.dictionary).toMatchObject({ modelClassName: "BlogPost", translatorName: "t" });
+    expect(index.dictionary?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.constant?.lightProjection?.fields.map((field) => field.name)).toEqual(["title"]);
+    expect(index.diagnostics.map((diagnostic) => diagnostic.code)).not.toContain(
+      "module-index-dictionary-model-missing",
+    );
+    expect(JSON.stringify(index)).not.toContain("return {");
+  });
+
+  test("reports parse and unsupported constant shape diagnostics", async () => {
+    const validDictionary = `
+import { modelDictionary } from "akanjs/dictionary";
+import type { Post } from "./post.constant";
+
+export const dictionary = modelDictionary(["en"]).model<Post>((t) => ({}));
+`;
+    const cases = [
+      {
+        name: "invalid-typescript",
+        constant: "export class PostInput extends via((field) => ({ title: field(String), })) {\n",
+        expectedCode: "module-index-typescript-parse-error",
+      },
+      {
+        name: "missing-input",
+        constant: "export class Post extends via(() => ({})) {}\n",
+        expectedCode: "module-index-constant-input-missing",
+      },
+      {
+        name: "missing-via",
+        constant: "export class PostInput {}\n",
+        expectedCode: "module-index-constant-via-missing",
+      },
+      {
+        name: "malformed-via",
+        constant: "export class PostInput extends via(PostObject) {}\n",
+        expectedCode: "module-index-constant-builder-missing",
+      },
+      {
+        name: "missing-builder-object",
+        constant: "export class PostInput extends via((field) => field(String)) {}\n",
+        expectedCode: "module-index-constant-builder-object-missing",
+      },
+    ];
+
+    for (const item of cases) {
+      const { root, workspace } = await makeWorkspace();
+      const modulePath = path.join(root, "apps/demo/lib/post");
+      await writeText(path.join(modulePath, "post.constant.ts"), item.constant);
+      await writeText(path.join(modulePath, "post.dictionary.ts"), validDictionary);
+
+      const index = await buildAkanModuleContextIndex(
+        workspace,
+        moduleContext(["post.abstract.md", "post.constant.ts", "post.dictionary.ts"]),
+      );
+
+      expect(
+        index.diagnostics.map((diagnostic) => diagnostic.code),
+        item.name,
+      ).toContain(item.expectedCode);
+      expect(JSON.stringify(index), item.name).not.toContain(item.constant.trim());
+    }
+  });
+
+  test("reports unsupported dictionary model callback shapes", async () => {
+    const validConstant = `
+import { via } from "akanjs/constant";
+
+export class PostInput extends via((field) => ({})) {}
+`;
+    const cases = [
+      {
+        name: "missing-callback",
+        dictionary: 'export const dictionary = modelDictionary(["en"]).model<Post>();\n',
+        expectedCode: "module-index-dictionary-builder-missing",
+      },
+      {
+        name: "missing-object-return",
+        dictionary: 'export const dictionary = modelDictionary(["en"]).model<Post>((t) => t(["Title"]));\n',
+        expectedCode: "module-index-dictionary-builder-object-missing",
+      },
+    ];
+
+    for (const item of cases) {
+      const { root, workspace } = await makeWorkspace();
+      const modulePath = path.join(root, "apps/demo/lib/post");
+      await writeText(path.join(modulePath, "post.constant.ts"), validConstant);
+      await writeText(path.join(modulePath, "post.dictionary.ts"), item.dictionary);
+
+      const index = await buildAkanModuleContextIndex(
+        workspace,
+        moduleContext(["post.abstract.md", "post.constant.ts", "post.dictionary.ts"]),
+      );
+
+      expect(
+        index.diagnostics.map((diagnostic) => diagnostic.code),
+        item.name,
+      ).toContain(item.expectedCode);
+      expect(
+        index.diagnostics.map((diagnostic) => diagnostic.code),
+        item.name,
+      ).not.toContain("module-index-dictionary-model-missing");
+      expect(JSON.stringify(index), item.name).not.toContain(item.dictionary.trim());
+    }
+  });
+});