@cosmicdrift/kumiko-framework 0.153.0 → 0.154.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.153.0",
+  "version": "0.154.1",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -193,7 +193,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.153.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.154.1",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/__tests__/anonymous-access.integration.test.ts

@@ -361,6 +361,31 @@ describe("anonymous access — resolverTrust: authoritative", () => {
     const body = (await res.json()) as { error: { code: string } };
     expect(body.error.code).toBe("tenant_mismatch");
   });
+
+  // pr-review kumiko-framework #1052/3 — resolveTenant treats header and
+  // cookie identically, but every case above only exercised the header.
+  // These two lock in that the cookie path behaves the same way.
+  test("kumiko_tenant cookie agreeing with the resolver → accepted", async () => {
+    const res = await stack.http.raw(
+      "POST",
+      "/api/query",
+      { type: "anonshop:query:product:list", payload: {} },
+      { Cookie: `kumiko_tenant=${TENANT_ID}` },
+    );
+    expect(res.status).toBe(200);
+  });
+
+  test("kumiko_tenant cookie disagreeing with the resolver → 400 tenant_mismatch, same as a disagreeing header", async () => {
+    const res = await stack.http.raw(
+      "POST",
+      "/api/query",
+      { type: "anonshop:query:product:list", payload: {} },
+      { Cookie: `kumiko_tenant=${OTHER_TENANT_ID}` },
+    );
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as { error: { code: string } };
+    expect(body.error.code).toBe("tenant_mismatch");
+  });
 });
 
 describe("anonymous access — resolverTrust: authoritative, resolver returns null", () => {

package/src/engine/__tests__/boot-validator-action-wiring.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, test } from "bun:test";
+import { z } from "zod";
+import { validateBoot } from "../boot-validator";
+import { defineFeature } from "../define-feature";
+import { createEntity, createTextField } from "../factories";
+
+describe("validateBoot — action wiring (no function values)", () => {
+  test("rowAction writeHandler payload as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-list",
+        type: "entityList",
+        entity: "product",
+        columns: ["name"],
+        rowActions: [
+          {
+            kind: "writeHandler",
+            id: "sync",
+            label: "actions.sync",
+            handler: "shop:write:sync",
+            // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+            payload: ((row: unknown) => ({ id: row })) as any,
+          },
+        ],
+      });
+      r.writeHandler("sync", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { roles: ["Admin"] },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/rowAction "sync" payload is a function/);
+  });
+
+  test("rowAction writeHandler payload as declarative pick → kein Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField({ sortable: true }) } }));
+      r.screen({
+        id: "product-list",
+        type: "entityList",
+        entity: "product",
+        columns: ["name"],
+        defaultSort: { field: "name", dir: "asc" },
+        rowActions: [
+          {
+            kind: "writeHandler",
+            id: "sync",
+            label: "actions.sync",
+            handler: "shop:write:sync",
+            payload: { pick: ["name"] },
+          },
+        ],
+      });
+      r.writeHandler("sync", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { roles: ["Admin"] },
+      });
+      r.translations({
+        keys: {
+          "screen:product-list.title": { de: "Liste", en: "List" },
+          "shop:entity:product:field:name": { de: "Name", en: "Name" },
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("rowAction navigate visible as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-list",
+        type: "entityList",
+        entity: "product",
+        columns: ["name"],
+        rowActions: [
+          {
+            kind: "navigate",
+            id: "edit",
+            label: "actions.edit",
+            screen: "product-list",
+            // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+            visible: (() => true) as any,
+          },
+        ],
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/rowAction "edit" visible is a function/);
+  });
+
+  test("toolbarAction writeHandler payload as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-list",
+        type: "entityList",
+        entity: "product",
+        columns: ["name"],
+        toolbarActions: [
+          {
+            kind: "writeHandler",
+            id: "sync",
+            label: "actions.sync",
+            handler: "shop:write:sync",
+            // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+            payload: (() => ({})) as any,
+          },
+        ],
+      });
+      r.writeHandler("sync", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
+        access: { roles: ["Admin"] },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/toolbarAction "sync" payload is a function/);
+  });
+
+  test("entityList column renderer as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-list",
+        type: "entityList",
+        entity: "product",
+        columns: [
+          // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+          { field: "name", renderer: ((v: unknown) => String(v)) as any },
+        ],
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/column "name" renderer is a function/);
+  });
+
+  test("entityEdit field visible as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-edit",
+        type: "entityEdit",
+        entity: "product",
+        layout: {
+          sections: [
+            {
+              columns: 1,
+              // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+              fields: [{ field: "name", visible: (() => true) as any }],
+            },
+          ],
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/field "name" visible is a function/);
+  });
+
+  test("entityEdit field renderer as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-edit",
+        type: "entityEdit",
+        entity: "product",
+        layout: {
+          sections: [
+            {
+              columns: 1,
+              // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+              fields: [{ field: "name", renderer: ((v: unknown) => String(v)) as any }],
+            },
+          ],
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/field "name" renderer is a function/);
+  });
+
+  test("entityEdit field with declarative visible/readOnly/required → kein Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-edit",
+        type: "entityEdit",
+        entity: "product",
+        layout: {
+          sections: [
+            {
+              columns: 1,
+              fields: [
+                {
+                  field: "name",
+                  visible: { field: "name", ne: "" },
+                  readOnly: false,
+                  required: true,
+                },
+              ],
+            },
+          ],
+        },
+      });
+      r.translations({
+        keys: {
+          "screen:product-edit.title": { de: "Bearbeiten", en: "Edit" },
+          "shop:entity:product:field:name": { de: "Name", en: "Name" },
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("projectionList column renderer as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.screen({
+        id: "sales-list",
+        type: "projectionList",
+        query: "shop:query:sales",
+        columns: [
+          // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+          { field: "amount", renderer: ((v: unknown) => String(v)) as any },
+        ],
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/column "amount" renderer is a function/);
+  });
+
+  test("projectionList rowAction payload as function → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.screen({
+        id: "sales-list",
+        type: "projectionList",
+        query: "shop:query:sales",
+        columns: ["amount"],
+        rowActions: [
+          {
+            kind: "writeHandler",
+            id: "sync",
+            label: "actions.sync",
+            handler: "shop:write:sync",
+            // biome-ignore lint/suspicious/noExplicitAny: intentional type violation under test
+            payload: (() => ({})) as any,
+          },
+        ],
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(/rowAction "sync" payload is a function/);
+  });
+});

package/src/engine/__tests__/boot-validator.test.ts

@@ -1231,8 +1231,9 @@ describe("boot-validator", () => {
   // --- entityList column-renderer form-check ---
   // Validator akzeptiert die `{ react: { __component: "Name" } }`-Form
   // (PlatformComponent → client-side Registry-Lookup) und prüft sie
-  // strukturell. String-Funktionen, null/undefined, native-only und
-  // andere Formen bleiben opak.
+  // strukturell. null/undefined, native-only und andere Formen bleiben
+  // opak. Function-Renderer werfen (action-wiring.ts validateFieldWiring) —
+  // von JSON.stringify verworfen, sonst stiller No-op auf dem Client.
   describe("entityList column renderer form", () => {
     function shopFeature(renderer: unknown) {
       return defineFeature("shop", (r) => {
@@ -1250,8 +1251,10 @@ describe("boot-validator", () => {
       });
     }
 
-    test("function-renderer → kein Throw (Bestand)", () => {
-      expect(() => validateBoot([shopFeature((v: unknown) => String(v))])).not.toThrow();
+    test("function-renderer → Throw (Function wird von JSON.stringify verworfen)", () => {
+      expect(() => validateBoot([shopFeature((v: unknown) => String(v))])).toThrow(
+        /column "name" renderer is a function/,
+      );
     });
 
     test("undefined renderer → kein Throw (Spalte ohne Renderer)", () => {

package/src/engine/__tests__/event-migration-declarative.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { z } from "zod";
 import { defineFeature } from "../define-feature";
 import type { DeclarativeEventMigration, EventUpcastCtx } from "../types";
 
@@ -7,7 +8,10 @@ const upcastCtx = {} as EventUpcastCtx;
 
 function compile(spec: DeclarativeEventMigration) {
   const feature = defineFeature("billing", (r) => {
-    r.eventMigration("invoicePaid", 1, 2, spec);
+    r.defineEvent("invoicePaid", z.unknown(), {
+      version: 2,
+      migrations: [{ fromVersion: 1, toVersion: 2, transform: spec }],
+    });
   });
   const def = feature.eventMigrations["invoicePaid"]?.[0];
   if (!def) throw new Error("migration not registered");
@@ -51,7 +55,10 @@ describe("declarative eventMigration", () => {
   test("imperative function variant is stored untouched", () => {
     const fn = (payload: unknown) => payload;
     const feature = defineFeature("billing", (r) => {
-      r.eventMigration("invoicePaid", 1, 2, fn);
+      r.defineEvent("invoicePaid", z.unknown(), {
+        version: 2,
+        migrations: [{ fromVersion: 1, toVersion: 2, transform: fn }],
+      });
     });
     expect(feature.eventMigrations["invoicePaid"]?.[0]?.transform).toBe(fn);
   });

package/src/engine/boot-validator/action-wiring.ts

@@ -0,0 +1,99 @@
+import type { EditFieldSpec, FeatureDefinition, RowAction, ToolbarAction } from "../types";
+import { isExtensionEditSection, normalizeEditField, normalizeListColumn } from "../types/screen";
+
+const FUNCTION_DROPPED_HINT =
+  "functions are dropped by JSON.stringify when the screen config reaches the client " +
+  "bundle — the action/field silently no-ops at runtime instead of failing loudly.";
+
+function throwIfFunction(value: unknown, message: string): void {
+  if (typeof value === "function") {
+    throw new Error(message);
+  }
+}
+
+// rowActions/toolbarActions carry row-context extractors (payload/params),
+// static visibility conditions and navigate entityId — all declarative-DSL-
+// only fields (RowFieldExtractor's `{ pick }`/`{ map }`, FieldCondition's
+// `{ field, eq }`/`{ field, ne }`, plain strings). A function literal here
+// compiles fine (the DSL types are structural, not branded) but is silently
+// dropped once the feature config is serialized for the client.
+const ACTION_FUNCTION_FIELDS = ["payload", "params", "entityId", "visible"] as const;
+
+function validateActionNoFunctions(
+  featureName: string,
+  screenId: string,
+  actionKind: "rowAction" | "toolbarAction",
+  action: RowAction | ToolbarAction,
+): void {
+  const record = action as unknown as Record<string, unknown>;
+  for (const field of ACTION_FUNCTION_FIELDS) {
+    throwIfFunction(
+      record[field],
+      `[Feature ${featureName}] Screen "${screenId}" ${actionKind} "${action.id}" ${field} ` +
+        `is a function — ${FUNCTION_DROPPED_HINT} Use the declarative DSL ({ pick }, { map }, ` +
+        `"fieldName", { field, eq }) instead.`,
+    );
+  }
+}
+
+export function validateActionWiring(feature: FeatureDefinition): void {
+  for (const screen of Object.values(feature.screens)) {
+    if (screen.type !== "entityList" && screen.type !== "projectionList") continue;
+    for (const action of screen.rowActions ?? []) {
+      validateActionNoFunctions(feature.name, screen.id, "rowAction", action);
+    }
+    for (const action of screen.toolbarActions ?? []) {
+      validateActionNoFunctions(feature.name, screen.id, "toolbarAction", action);
+    }
+  }
+}
+
+// EditFieldSpec's visible/readOnly/required are the same FieldCondition DSL
+// as rowActions — same footgun, different screen type (entityEdit layouts).
+const EDIT_FIELD_FUNCTION_FIELDS = ["visible", "readOnly", "required"] as const;
+
+function validateEditFieldNoFunctions(
+  featureName: string,
+  screenId: string,
+  fieldSpec: EditFieldSpec,
+): void {
+  const normalized = normalizeEditField(fieldSpec);
+  const record = normalized as unknown as Record<string, unknown>;
+  for (const key of EDIT_FIELD_FUNCTION_FIELDS) {
+    throwIfFunction(
+      record[key],
+      `[Feature ${featureName}] Screen "${screenId}" (entityEdit) field "${normalized.field}" ` +
+        `${key} is a function — ${FUNCTION_DROPPED_HINT} Use a FieldCondition ` +
+        `(boolean or { field, eq }/{ field, ne }) instead.`,
+    );
+  }
+  throwIfFunction(
+    normalized.renderer,
+    `[Feature ${featureName}] Screen "${screenId}" (entityEdit) field "${normalized.field}" ` +
+      `renderer is a function — ${FUNCTION_DROPPED_HINT} Use a FormatSpec ({ format: "..." }) instead.`,
+  );
+}
+
+export function validateFieldWiring(feature: FeatureDefinition): void {
+  for (const screen of Object.values(feature.screens)) {
+    if (screen.type === "entityList" || screen.type === "projectionList") {
+      for (const col of screen.columns) {
+        const normalized = normalizeListColumn(col);
+        throwIfFunction(
+          normalized.renderer,
+          `[Feature ${feature.name}] Screen "${screen.id}" (${screen.type}) column ` +
+            `"${normalized.field}" renderer is a function — ${FUNCTION_DROPPED_HINT} ` +
+            `Use a FormatSpec ({ format: "..." }) instead.`,
+        );
+      }
+      continue;
+    }
+    if (screen.type !== "entityEdit") continue;
+    for (const section of screen.layout.sections) {
+      if (isExtensionEditSection(section)) continue;
+      for (const fieldSpec of section.fields) {
+        validateEditFieldNoFunctions(feature.name, screen.id, fieldSpec);
+      }
+    }
+  }
+}

package/src/engine/boot-validator/index.ts

@@ -1,6 +1,7 @@
 import { validateEntityFieldEncryptionAvailable } from "../../db/entity-field-encryption";
 import { QnTypes, qualifyEntityName } from "../qualified-name";
 import type { ClaimKeyDefinition, FeatureDefinition } from "../types";
+import { validateActionWiring, validateFieldWiring } from "./action-wiring";
 import { validateApiExposureMatching, validateExtensionUsages } from "./api-ext";
 import {
   validateCircularDeps,
@@ -171,6 +172,12 @@ export function validateBoot(features: readonly FeatureDefinition[]): void {
     validateConfigKeyBacking(feature);
     validateOwnershipRules(feature, allClaimKeys, knownRoles);
     validateMultiStreamProjections(feature);
+    // Vor validateScreens: dessen visible/entityId-Feldref-Checks werfen für
+    // einen Function-Wert bereits (mit verwirrender "unknown field undefined"-
+    // Message, weil `typeof fn !== "boolean"` true ist), bevor der klare
+    // Function-Check hier überhaupt liefe.
+    validateActionWiring(feature);
+    validateFieldWiring(feature);
     validateScreens(
       feature,
       featureMap,

package/src/engine/feature-ast/__tests__/canonical-form.test.ts

@@ -56,7 +56,10 @@ defineFeature("todoList", (r) => {
   r.defineEvent({
     name: "taskCompleted",
     schema: z.object({ id: z.string() }),
-    version: 1,
+    version: 2,
+    migrations: {
+      "1": (old) => ({ ...old, done: true }),
+    },
   });
 
   r.writeHandler({
@@ -127,13 +130,6 @@ defineFeature("todoList", (r) => {
 
   r.useExtension({ name: "auditLog", entity: "task" });
 
-  r.eventMigration({
-    event: "taskCompleted",
-    fromVersion: 1,
-    toVersion: 2,
-    transform: (old) => ({ ...old, done: true }),
-  });
-
   r.job({
     name: "cleanupExpired",
     schedule: { cron: "0 3 * * *" },
@@ -232,7 +228,6 @@ describe("Canonical Object-Form — parser akzeptiert + extrahiert", () => {
       "projection",
       "multiStreamProjection",
       "defineEvent",
-      "eventMigration",
     ];
     for (const e of expected) {
       expect(kinds.has(e), `expected kind "${e}"`).toBe(true);
@@ -283,12 +278,13 @@ describe("Canonical Object-Form — parser akzeptiert + extrahiert", () => {
     expect(claim).toMatchObject({ kind: "claimKey", shortName: "teamId" });
   });
 
-  test("defineEvent: name + version aus Object-Form", () => {
+  test("defineEvent: name + version + migrations aus Object-Form", () => {
     const ev = result.patterns.find((p) => p.kind === "defineEvent");
     expect(ev).toMatchObject({
       kind: "defineEvent",
       eventName: "taskCompleted",
-      version: 1,
+      version: 2,
+      migrations: { "1": expect.anything() },
     });
   });
 
@@ -334,16 +330,6 @@ describe("Canonical Object-Form — parser akzeptiert + extrahiert", () => {
     });
   });
 
-  test("eventMigration: event + fromVersion + toVersion aus Object-Form", () => {
-    const em = result.patterns.find((p) => p.kind === "eventMigration");
-    expect(em).toMatchObject({
-      kind: "eventMigration",
-      eventName: "taskCompleted",
-      fromVersion: 1,
-      toVersion: 2,
-    });
-  });
-
   test("job: name + handlerBody.raw enthält den Closure-Body", () => {
     const job = result.patterns.find((p) => p.kind === "job");
     expect(job).toMatchObject({ kind: "job", jobName: "cleanupExpired" });

package/src/engine/feature-ast/__tests__/parse.test.ts

@@ -961,19 +961,46 @@ defineFeature("f", (r) => {
   });
 });
 
-describe("extractEventMigration", () => {
-  test("captures fromVersion / toVersion / transform body", () => {
+describe("extractDefineEvent — migrations (formerly extractEventMigration)", () => {
+  test("positional-form migrations array captures the fromVersion→transform step", () => {
     const result = parseInline(`
 defineFeature("f", (r) => {
-  r.eventMigration("incidentOpened", 1, 2, (payload) => ({ ...payload, severity: "low" }));
+  r.defineEvent("incidentOpened", z.object({ id: z.string() }), {
+    version: 2,
+    migrations: [
+      { fromVersion: 1, toVersion: 2, transform: (payload) => ({ ...payload, severity: "low" }) },
+    ],
+  });
 });
 `);
 
     expect(result.patterns[0]).toMatchObject({
-      kind: "eventMigration",
+      kind: "defineEvent",
       eventName: "incidentOpened",
-      fromVersion: 1,
-      toVersion: 2,
+      version: 2,
+      migrations: { "1": expect.anything() },
+    });
+  });
+
+  test("object-form migrations map captures the fromVersion→transform step", () => {
+    const result = parseInline(`
+defineFeature("f", (r) => {
+  r.defineEvent({
+    name: "incidentOpened",
+    schema: z.object({ id: z.string() }),
+    version: 2,
+    migrations: {
+      "1": (payload) => ({ ...payload, severity: "low" }),
+    },
+  });
+});
+`);
+
+    expect(result.patterns[0]).toMatchObject({
+      kind: "defineEvent",
+      eventName: "incidentOpened",
+      version: 2,
+      migrations: { "1": expect.anything() },
     });
   });
 });

package/src/engine/feature-ast/__tests__/patch.test.ts

@@ -301,21 +301,16 @@ describe("patch coverage for the remaining pattern-kinds", () => {
     expect(parseSourceFile(sf).patterns.find((p) => p.kind === "authClaims")).toBeUndefined();
   });
 
-  test("add + remove via PatternId for eventMigration (event+versions key)", () => {
+  test("add + remove via PatternId for defineEvent with migrations", () => {
     const sf = makeSourceFile(STARTER);
-    createFeaturePatcher(sf).addEventMigration({
-      event: "itemCreated",
-      fromVersion: 1,
-      toVersion: 2,
-      transformSource: "(old) => old",
-    });
-    removePattern(sf, {
-      kind: "eventMigration",
-      eventName: "itemCreated",
-      fromVersion: 1,
-      toVersion: 2,
+    createFeaturePatcher(sf).addDefineEvent({
+      name: "itemCreated",
+      schemaSource: "z.object({ id: z.string() })",
+      version: 2,
+      migrations: { "1": "(old) => old" },
     });
-    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "eventMigration")).toBeUndefined();
+    removePattern(sf, { kind: "defineEvent", eventName: "itemCreated" });
+    expect(parseSourceFile(sf).patterns.find((p) => p.kind === "defineEvent")).toBeUndefined();
   });
 });
 

package/src/engine/feature-ast/__tests__/patcher.test.ts

@@ -172,33 +172,23 @@ describe("FeaturePatcher — typed add helpers for mixed (closure-bearing) patte
     });
   });
 
-  test("addDefineEvent + addEventMigration form a complete event-versioning chain", () => {
+  test("addDefineEvent with migrations forms a complete event-versioning chain", () => {
     const sf = makeSourceFile(STARTER);
     const p = createFeaturePatcher(sf);
     p.addDefineEvent({
       name: "stepCompleted",
       schemaSource: "z.object({ id: z.string() })",
       version: 2,
-    });
-    p.addEventMigration({
-      event: "stepCompleted",
-      fromVersion: 1,
-      toVersion: 2,
-      transformSource: '(old) => ({ id: old.id ?? "" })',
+      migrations: { "1": '(old) => ({ id: old.id ?? "" })' },
     });
     const result = parseSourceFile(sf);
     expect(result.errors).toEqual([]);
-    expect(result.patterns).toHaveLength(2);
+    expect(result.patterns).toHaveLength(1);
     expect(result.patterns[0]).toMatchObject({
       kind: "defineEvent",
       eventName: "stepCompleted",
       version: 2,
-    });
-    expect(result.patterns[1]).toMatchObject({
-      kind: "eventMigration",
-      eventName: "stepCompleted",
-      fromVersion: 1,
-      toVersion: 2,
+      migrations: { "1": expect.anything() },
     });
   });
 });