@cosmicdrift/kumiko-framework 0.154.0 → 0.154.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.154.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.154.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.154.1",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

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/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() },
     });
   });
 });

package/src/engine/feature-ast/__tests__/render-roundtrip.test.ts

@@ -114,7 +114,7 @@ function stripLocations(value: unknown): unknown {
         out[k] = { raw: normalizeBodyRaw((v as { raw: string }).raw) };
         continue;
       }
-      if (k === "opaqueProps" && v && typeof v === "object") {
+      if ((k === "opaqueProps" || k === "migrations") && v && typeof v === "object") {
         const op: Record<string, unknown> = {};
         for (const [pk, pv] of Object.entries(v as Record<string, unknown>)) {
           if (pv && typeof pv === "object" && "raw" in pv) {
@@ -400,3 +400,39 @@ describe("render → parse roundtrip — r.screen({ nav }) inline sugar", () =>
     }
   });
 });
+
+const DEFINE_EVENT_WITH_MIGRATIONS_FEATURE = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("billing", (r) => {
+  r.defineEvent("invoicePaid", z.object({ totalCents: z.number() }), {
+    version: 2,
+    migrations: [
+      {
+        fromVersion: 1,
+        toVersion: 2,
+        transform: (payload) => ({ totalCents: Math.round(payload.total * 100) }),
+      },
+    ],
+  });
+});
+`;
+
+describe("render → parse roundtrip — r.defineEvent({ migrations }) fold", () => {
+  test("migrations array survives parse → render → parse unchanged", () => {
+    const initial = parse(DEFINE_EVENT_WITH_MIGRATIONS_FEATURE);
+    const rendered = renderFeatureFile({
+      featureName: initial.featureName ?? "",
+      patterns: initial.patterns,
+    });
+    const reparsed = parse(rendered);
+    expect(reparsed.patterns.map(stripLocations)).toEqual(initial.patterns.map(stripLocations));
+
+    const eventPattern = reparsed.patterns.find((p) => p.kind === "defineEvent");
+    expect(eventPattern?.kind).toBe("defineEvent");
+    if (eventPattern?.kind === "defineEvent") {
+      expect(eventPattern.version).toBe(2);
+      expect(Object.keys(eventPattern.migrations ?? {})).toEqual(["1"]);
+    }
+  });
+});

package/src/engine/feature-ast/extractors/index.ts

@@ -30,7 +30,6 @@ export {
   extractAuthClaims,
   extractDefineEvent,
   extractEntityHook,
-  extractEventMigration,
   extractHook,
   extractHttpRoute,
   extractJob,

package/src/engine/feature-ast/extractors/round4.ts

@@ -11,7 +11,6 @@ import type {
   AuthClaimsPattern,
   DefineEventPattern,
   EntityHookPattern,
-  EventMigrationPattern,
   HookPattern,
   HttpRoutePattern,
   JobPattern,
@@ -805,6 +804,74 @@ export function extractHttpRoute(
   });
 }
 
+// Reads defineEvent's `migrations` option — either the array-of-steps shape
+// used by hand-authored calls (`[{ fromVersion, toVersion, transform }]`,
+// toVersion is redundant on-disk since it is always fromVersion + 1) or the
+// keyed-object canonical shape the Designer renders (`{ "1": transform }`).
+// Keyed by fromVersion (as a string) → the transform closure's location.
+// Skips malformed entries rather than failing the whole defineEvent extract
+// — same "best-effort, degrade gracefully" posture as readDataLiteralNode.
+function extractEventMigrationsFromArray(
+  arr: Node,
+  sourceFile: SourceFile,
+): Record<string, SourceLocation> {
+  const result: Record<string, SourceLocation> = {};
+  const arrLit = arr.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+  for (const el of arrLit.getElements()) {
+    const obj = el.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!obj) continue;
+    const fromInit = obj
+      .getProperty("fromVersion")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const fromVersion = fromInit ? readDataLiteralNode(fromInit) : undefined;
+    if (typeof fromVersion !== "number") continue;
+    const transformInit = obj
+      .getProperty("transform")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const fn = transformInit ? findFunctionLiteral(transformInit) : undefined;
+    if (!fn) continue;
+    result[String(fromVersion)] = sourceLocationFromNode(fn, sourceFile);
+  }
+  return result;
+}
+
+function extractEventMigrationsFromKeyedObject(
+  objLit: Node,
+  sourceFile: SourceFile,
+): Record<string, SourceLocation> {
+  const result: Record<string, SourceLocation> = {};
+  const obj = objLit.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  for (const prop of obj.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
+    const initializer = propAssign?.getInitializer();
+    const fn = initializer ? findFunctionLiteral(initializer) : undefined;
+    if (!propAssign || !fn) continue;
+    result[readPropertyKey(propAssign)] = sourceLocationFromNode(fn, sourceFile);
+  }
+  return result;
+}
+
+// Reads defineEvent's `migrations` option — either the array-of-steps shape
+// used by hand-authored calls (`[{ fromVersion, toVersion, transform }]`,
+// toVersion is redundant on-disk since it is always fromVersion + 1) or the
+// keyed-object canonical shape the Designer renders (`{ "1": transform }`).
+// Keyed by fromVersion (as a string) → the transform closure's location.
+// Skips malformed entries rather than failing the whole defineEvent extract
+// — same "best-effort, degrade gracefully" posture as readDataLiteralNode.
+function extractEventMigrationsField(
+  node: Node,
+  sourceFile: SourceFile,
+): Readonly<Record<string, SourceLocation>> | undefined {
+  const result = node.asKind(SyntaxKind.ArrayLiteralExpression)
+    ? extractEventMigrationsFromArray(node, sourceFile)
+    : node.asKind(SyntaxKind.ObjectLiteralExpression)
+      ? extractEventMigrationsFromKeyedObject(node, sourceFile)
+      : undefined;
+  return result && Object.keys(result).length > 0 ? result : undefined;
+}
+
 export function extractDefineEvent(
   call: CallExpression,
   sourceFile: SourceFile,
@@ -853,12 +920,20 @@ export function extractDefineEvent(
       const v = readDataLiteralNode(versionInit);
       if (typeof v === "number") version = v;
     }
+    const migrationsInit = obj
+      .getProperty("migrations")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const migrations = migrationsInit
+      ? extractEventMigrationsField(migrationsInit, sourceFile)
+      : undefined;
     return ok({
       kind: "defineEvent",
       source: sourceLocationFromNode(call, sourceFile),
       eventName: nameInit.getLiteralValue(),
       schemaSource: sourceLocationFromNode(schemaInit, sourceFile),
       ...(version !== undefined && { version }),
+      ...(migrations !== undefined && { migrations }),
     });
   }
 
@@ -879,152 +954,33 @@ export function extractDefineEvent(
     );
   }
   let version: number | undefined;
+  let migrations: Readonly<Record<string, SourceLocation>> | undefined;
   const optionsArg = args[2];
-  if (optionsArg) {
-    const options = readDataLiteralNode(optionsArg);
-    if (isPlainObject(options) && typeof options["version"] === "number") {
-      version = options["version"];
-    }
-  }
-  return ok({
-    kind: "defineEvent",
-    source: sourceLocationFromNode(call, sourceFile),
-    eventName: nameArg.getLiteralValue(),
-    schemaSource: sourceLocationFromNode(schemaArg, sourceFile),
-    ...(version !== undefined && { version }),
-  });
-}
-
-export function extractEventMigration(
-  call: CallExpression,
-  sourceFile: SourceFile,
-): ExtractOutput<EventMigrationPattern> {
-  const args = call.getArguments();
-  const first = args[0];
-  if (!first) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "expected at least one argument",
-    );
-  }
-
-  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-  if (obj && args.length === 1) {
-    const eventInit = obj
-      .getProperty("event")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer()
-      ?.asKind(SyntaxKind.StringLiteral);
-    if (!eventInit) {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a string-literal `event` property",
-      );
-    }
-    const fromInit = obj
-      .getProperty("fromVersion")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer();
-    const fromVersion = fromInit ? readDataLiteralNode(fromInit) : undefined;
-    if (typeof fromVersion !== "number") {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "fromVersion must be a numeric literal",
-      );
-    }
-    const toInit = obj
-      .getProperty("toVersion")
+  const optionsObj = optionsArg?.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (optionsObj) {
+    const versionInit = optionsObj
+      .getProperty("version")
       ?.asKind(SyntaxKind.PropertyAssignment)
       ?.getInitializer();
-    const toVersion = toInit ? readDataLiteralNode(toInit) : undefined;
-    if (typeof toVersion !== "number") {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "toVersion must be a numeric literal",
-      );
+    if (versionInit) {
+      const v = readDataLiteralNode(versionInit);
+      if (typeof v === "number") version = v;
     }
-    const transformInit = obj
-      .getProperty("transform")
+    const migrationsInit = optionsObj
+      .getProperty("migrations")
       ?.asKind(SyntaxKind.PropertyAssignment)
       ?.getInitializer();
-    if (!transformInit) {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a `transform` property",
-      );
+    if (migrationsInit) {
+      migrations = extractEventMigrationsField(migrationsInit, sourceFile);
     }
-    const fn = findFunctionLiteral(transformInit);
-    if (!fn) {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "transform must be an inline arrow function or function expression",
-      );
-    }
-    return ok({
-      kind: "eventMigration",
-      source: sourceLocationFromNode(call, sourceFile),
-      eventName: eventInit.getLiteralValue(),
-      fromVersion,
-      toVersion,
-      transformBody: sourceLocationFromNode(fn, sourceFile),
-    });
-  }
-
-  const nameArg = first.asKind(SyntaxKind.StringLiteral);
-  if (!nameArg) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "first argument must be a string literal event name (or use the object form)",
-    );
-  }
-  const fromArg = args[1];
-  const fromVersion = fromArg ? readDataLiteralNode(fromArg) : undefined;
-  if (typeof fromVersion !== "number") {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "fromVersion must be a numeric literal",
-    );
-  }
-  const toArg = args[2];
-  const toVersion = toArg ? readDataLiteralNode(toArg) : undefined;
-  if (typeof toVersion !== "number") {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "toVersion must be a numeric literal",
-    );
-  }
-  const transformArg = args[3];
-  if (!transformArg) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "expected a transform function as fourth argument",
-    );
-  }
-  const fn = findFunctionLiteral(transformArg);
-  if (!fn) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "transform must be an inline arrow function or function expression",
-    );
   }
   return ok({
-    kind: "eventMigration",
+    kind: "defineEvent",
     source: sourceLocationFromNode(call, sourceFile),
     eventName: nameArg.getLiteralValue(),
-    fromVersion,
-    toVersion,
-    transformBody: sourceLocationFromNode(fn, sourceFile),
+    schemaSource: sourceLocationFromNode(schemaArg, sourceFile),
+    ...(version !== undefined && { version }),
+    ...(migrations !== undefined && { migrations }),
   });
 }
 

package/src/engine/feature-ast/index.ts

@@ -28,7 +28,6 @@ export type {
   AddDefineEventArgs,
   AddEntityArgs,
   AddEntityHookArgs,
-  AddEventMigrationArgs,
   AddHookArgs,
   AddHttpRouteArgs,
   AddJobArgs,
@@ -62,7 +61,6 @@ export type {
   EntityHookPattern,
   // Static patterns
   EntityPattern,
-  EventMigrationPattern,
   ExtendsRegistrarPattern,
   FeaturePattern,
   FeaturePatternKind,

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

@@ -40,7 +40,6 @@ import {
   extractEntity,
   extractEntityHook,
   extractEnvSchema,
-  extractEventMigration,
   extractExposesApi,
   extractExtendsRegistrar,
   extractHook,
@@ -457,8 +456,6 @@ function dispatchExtractor(
       return extractHttpRoute(call, sourceFile);
     case "defineEvent":
       return extractDefineEvent(call, sourceFile);
-    case "eventMigration":
-      return extractEventMigration(call, sourceFile);
     case "notification":
       return extractNotification(call, sourceFile);
     case "projection":

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

@@ -66,12 +66,6 @@ export type PatternId =
   | { readonly kind: "projection"; readonly name: string }
   | { readonly kind: "multiStreamProjection"; readonly name: string }
   | { readonly kind: "defineEvent"; readonly eventName: string }
-  | {
-      readonly kind: "eventMigration";
-      readonly eventName: string;
-      readonly fromVersion: number;
-      readonly toVersion: number;
-    }
   | { readonly kind: "extendsRegistrar"; readonly extensionName: string }
   // Singleton patterns — only one per feature, kind alone identifies them.
   | { readonly kind: "requires" }
@@ -419,20 +413,6 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
       return (
         matchFirstArgString(call, id.eventName) || matchObjectProperty(call, "name", id.eventName)
       );
-    case "eventMigration": {
-      // Positional: r.eventMigration(name, from, to, fn)
-      if (matchFirstArgString(call, id.eventName)) {
-        const from = numericArg(call, 1);
-        const to = numericArg(call, 2);
-        return from === id.fromVersion && to === id.toVersion;
-      }
-      // Object: { event, fromVersion, toVersion }
-      return (
-        matchObjectProperty(call, "event", id.eventName) &&
-        matchObjectNumericProperty(call, "fromVersion", id.fromVersion) &&
-        matchObjectNumericProperty(call, "toVersion", id.toVersion)
-      );
-    }
     case "extendsRegistrar":
       return matchFirstArgString(call, id.extensionName);
     default: {
@@ -459,27 +439,6 @@ function matchObjectProperty(call: CallExpression, propName: string, expected: s
   return init?.getLiteralValue() === expected;
 }
 
-function matchObjectNumericProperty(
-  call: CallExpression,
-  propName: string,
-  expected: number,
-): boolean {
-  const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
-  if (!obj) return false;
-  const init = obj
-    .getProperty(propName)
-    ?.asKind(SyntaxKind.PropertyAssignment)
-    ?.getInitializer()
-    ?.asKind(SyntaxKind.NumericLiteral);
-  return init !== undefined && Number(init.getText()) === expected;
-}
-
-function numericArg(call: CallExpression, idx: number): number | undefined {
-  const lit = call.getArguments()[idx]?.asKind(SyntaxKind.NumericLiteral);
-  if (!lit) return undefined;
-  return Number(lit.getText());
-}
-
 // =============================================================================
 // Format helpers — line boundaries / blank-line collapse
 // (indent / PATTERN_INDENT live in render.ts and are imported above.)