@cosmicdrift/kumiko-dev-server 0.2.3 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # @cosmicdrift/kumiko-dev-server
 
+## 0.3.0
+
+### Minor Changes
+
+- 0.3.0 bringt zwei neue Subsysteme (Step-Engine Tier-3 + Visual-Tree) plus
+  eine AST-Codemod-Pipeline als Vorarbeit für den L2-AI-Layer.
+
+  ### Breaking Changes
+
+  - `skipTransitionGuard` → `unsafeSkipTransitionGuard` (Rename in
+    feature-ast + engine). Der `unsafe`-Prefix macht die Tragweite des
+    Casts sichtbar und ist konsistent zur `unsafeProjectionUpsert`- und
+    `r.rawTable`-Konvention. Migration: 1:1-Ersetzung, keine Verhaltens-Änderung.
+
+  ### Features
+
+  - **Step-Engine M.4 — Tier-3 Workflow-Engine.** Neue Step-Vocabulary
+    `wait`, `waitForEvent`, `retry` ermöglicht persistierte Long-Running-Flows
+    über Job-Boundaries hinweg. Q7 Snapshot-at-Start hängt jedem Step-Run
+    einen SHA-256-Fingerprint des Aggregat-Zustands an, sodass Replays
+    deterministisch gegen den ursprünglichen Eingangszustand laufen.
+  - **Visual-Tree V.1.x — Tree-API + Editor-Panel.** Neue `VisualTree`-
+    Component plus TreeProvider-Pattern; erste TreeProviders für
+    `text-content` und `legal-pages` (CMS-light + Impressum/Privacy).
+    Fundament für den späteren No-Code-Designer (~3000 LOC, 98 Tests).
+  - **Codemod-Pipeline.** AST-basierte Patcher-Module für strukturelle
+    Feature-Edits — wird vom kommenden L2-AI-Layer als Tool-Surface
+    verwendet, ist aber eigenständig nutzbar für ts-morph-style Migrationen.
+  - **user-data-rights Sample-Recipe.** DSGVO Art. 15/17/18/20 vollständig
+    als Sample-Recipe (`samples/recipes/`) inklusive README — zeigt die
+    Export- und Forget-Pipeline gegen den `compliance-profiles`-Default
+    (`eu-dsgvo`).
+
+  ### Fixes
+
+  - `tier-engine`: auto-default-tier-Hook benutzt jetzt `ctx.db.raw` für
+    Event-Store-Operationen (#37, vorher: stiller Bug, 22 Tage live).
+  - `engine`: unsafe-projection-upsert nutzt `as never` statt `as any` —
+    schmaler Cast-Surface, weniger Compiler-Knebel.
+  - `visual-tree`: runtime-isolation marker für client-konsumierte Files,
+    damit der Multi-Entry-Build den richtigen Bundle-Split bekommt.
+  - `feature-ast`: vollständiger `unsafeSkipTransitionGuard`-Rename (war
+    in zwei Modulen noch der alte Name).
+  - `framework`: Error-Reasons + `noConsole`-Lint + No-Date-API-Guard
+    wieder push-ready.
+
+  ### Library-Updates
+
+  hono 4.12, jose 6.2, stripe 22.1, meilisearch 0.58, marked 18,
+  bun-types 1.3.13, lucide-react 1.14, bullmq 5.76, ioredis 5.10,
+  i18next 26.0, react + radix-ui-primitives auf aktuelle Minors.
+
+### Patch Changes
+
+- Updated dependencies
+  - @cosmicdrift/kumiko-framework@0.3.0
+  - @cosmicdrift/kumiko-bundled-features@0.3.0
+
 ## 0.2.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Development server bootstrap for Kumiko apps. Bundles the client, mints dev-JWTs, injects the resolved AppSchema, and seeds an admin. Not for production.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -18,20 +18,38 @@
     "runtime": "dev"
   },
   "exports": {
-    ".": "./src/index.ts",
-    "./build": "./src/build.ts",
-    "./compose-features": "./src/compose-features.ts",
-    "./drizzle-config": "./src/drizzle-config.ts",
-    "./drizzle-tables-auth-mode": "./src/drizzle-tables-auth-mode.ts",
-    "./drizzle-tables-minimal": "./src/drizzle-tables-minimal.ts"
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./build": {
+      "types": "./src/build.ts",
+      "default": "./src/build.ts"
+    },
+    "./compose-features": {
+      "types": "./src/compose-features.ts",
+      "default": "./src/compose-features.ts"
+    },
+    "./drizzle-config": {
+      "types": "./src/drizzle-config.ts",
+      "default": "./src/drizzle-config.ts"
+    },
+    "./drizzle-tables-auth-mode": {
+      "types": "./src/drizzle-tables-auth-mode.ts",
+      "default": "./src/drizzle-tables-auth-mode.ts"
+    },
+    "./drizzle-tables-minimal": {
+      "types": "./src/drizzle-tables-minimal.ts",
+      "default": "./src/drizzle-tables-minimal.ts"
+    }
   },
   "bin": {
     "kumiko-build": "./bin/kumiko-build.ts",
     "kumiko-dev": "./bin/kumiko-dev.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.2.3",
-    "@cosmicdrift/kumiko-framework": "0.2.3"
+    "@cosmicdrift/kumiko-bundled-features": "0.3.0",
+    "@cosmicdrift/kumiko-framework": "0.3.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/codegen/__tests__/strict-mode-diagnostics.test.ts

@@ -1,39 +1,12 @@
-// Regression-Guard für die EIGENTLICHE Behauptung der Codegen-Pipeline:
-// `ctx.appendEvent` wird via Lokal-Wrapper STRICT typgeprüft.
-//
-// Ohne diesen Test verifizieren die anderen 12 Codegen-Tests nur, dass
-// die richtigen Strings ins File geschrieben werden. Wenn jemand später
-// das `export *`-Shadowing kaputt macht, den `KumikoEventTypeMap`-
-// Re-Export aus `engine/index.ts` entfernt, oder TS-Verhalten in einer
-// neuen Version subtil bricht — die anderen Tests bleiben grün und der
-// strict-mode stirbt schweigend. Genau das wäre der Fall den dieser
-// Test fängt.
-//
-// Ablauf pro Test-Case:
-//   1. tmp-App mit feature.ts + events.ts + bin/main.ts erzeugen.
-//   2. `runCodegen` auf die tmp-App fahren — schreibt
-//      `.kumiko/types.generated.d.ts` + `define.ts`.
-//   3. Eine synthetische Test-Datei mit den gewünschten Aufrufen schreiben.
-//   4. ts.createProgram über die App + paths-alias zur framework-source.
-//   5. Diagnostics auswerten — auf konkrete TS-Codes prüfen.
-//
-// `paths` zeigt direkt auf die framework-source (`packages/framework/src`),
-// damit der TS-Type-Checker die Augmentation als Teil DESSELBEN Compiles
-// sieht (Use-Site-Substitution funktioniert nur so — siehe
-// project_x1_typemap_findings memory).
-
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import * as ts from "typescript";
-import { afterAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { runCodegen } from "../run-codegen";
 
 const REPO_ROOT = join(__dirname, "../../../../..");
 const FRAMEWORK_SRC = join(REPO_ROOT, "packages/framework/src");
 
-// Test-Apps werden IM Repo-Tree angelegt (gitignored), damit Node's
-// natürliches `node_modules`-Hochsuchen 'zod' & Co finden kann. tmpdir
-// liegt außerhalb des Repo-Trees → keine node_modules-Sicht.
 const TEST_FIXTURE_DIR = join(__dirname, ".tmp-fixtures");
 const createdDirs: string[] = [];
 
@@ -48,15 +21,11 @@ afterAll(() => {
   for (const d of createdDirs) {
     try {
       rmSync(d, { recursive: true, force: true });
-    } catch {
-      // best-effort cleanup
-    }
+    } catch {}
   }
   try {
     rmSync(TEST_FIXTURE_DIR, { recursive: true, force: true });
-  } catch {
-    // ditto
-  }
+  } catch {}
 });
 
 function write(dir: string, relPath: string, content: string): string {
@@ -66,16 +35,7 @@ function write(dir: string, relPath: string, content: string): string {
   return full;
 }
 
-/**
- * Baut ein TS-Program über die App + framework-source, gibt die
- * semantischen Diagnostics zurück. Lib-files werden vom installierten
- * typescript-Package geholt; sonst meckert TS über fehlende DOM-types.
- */
 function compileApp(appRoot: string): readonly ts.Diagnostic[] {
-  // Wir lassen ts node_modules vom REPO_ROOT auflösen (tmp-Dir hat kein
-  // eigenes node_modules). `baseUrl` zeigt auf repo, `paths` mappt
-  // framework + tmp-app explizit; rest fällt auf node_modules-Lookup
-  // im repo-Tree zurück.
   const compilerOptions: ts.CompilerOptions = {
     target: ts.ScriptTarget.ESNext,
     module: ts.ModuleKind.ESNext,
@@ -91,8 +51,6 @@ function compileApp(appRoot: string): readonly ts.Diagnostic[] {
     types: [],
   };
 
-  // Sammle alle .ts-Files unter src/ + .kumiko/, plus die framework-
-  // source-tree die wir via paths erreichen wollen.
   const program = ts.createProgram({
     rootNames: collectFiles(appRoot),
     options: compilerOptions,
@@ -125,140 +83,214 @@ function collectFiles(dir: string): string[] {
   return out;
 }
 
-// Default-shape feature: setup callback registers `placed` and returns
-// nothing. Used by tests that exercise the standard `ctx.appendEvent({
-// type: "orders:event:placed", ... })` literal-string path.
-function setupApp(): string {
-  const appRoot = makeAppDir();
-  writeOrderPlacedSchema(appRoot);
-  write(
-    appRoot,
-    "src/feature/feature.ts",
-    `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { orderPlacedSchema } from "./events";
-
-export const ordersFeature = defineFeature("orders", (r) => {
-  r.defineEvent("placed", orderPlacedSchema);
-});
-`,
-  );
-  return appRoot;
-}
-
-// Exports-shape feature: setup callback returns `{ placed }` so handler
-// modules can do `ordersFeature.exports.placed.name` and pick up the
-// literal type. Used by the eventDef.name pattern test.
-function setupAppWithExports(): string {
-  const appRoot = makeAppDir();
-  writeOrderPlacedSchema(appRoot);
-  write(
-    appRoot,
-    "src/feature/feature.ts",
-    `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { orderPlacedSchema } from "./events";
-
-export const ordersFeature = defineFeature("orders", (r) => ({
-  placed: r.defineEvent("placed", orderPlacedSchema),
-}));
-`,
-  );
-  return appRoot;
-}
-
 function writeOrderPlacedSchema(appRoot: string): void {
   write(
     appRoot,
     "src/feature/events.ts",
-    `import { z } from "zod";
-export const orderPlacedSchema = z.object({
-  orderId: z.string(),
-  customerId: z.string(),
-  amount: z.number(),
-});
-`,
+    [
+      'import { z } from "zod";',
+      "export const orderPlacedSchema = z.object({",
+      "  orderId: z.string(),",
+      "  customerId: z.string(),",
+      "  amount: z.number(),",
+      "});",
+      "",
+    ].join("\n"),
   );
 }
 
-// Each test compiles a tmp-app via ts.createProgram, which traverses
-// the framework-source via paths-alias (~700 files). Lokal ~1.7s pro
-// test; CI auf cdgs-runner (Hetzner CAX21 ARM64) braucht teilweise
-// >60s — vermutlich kleinere Cores + weniger RAM-cache als M-Series-
-// Mac. 120s gibt genug Puffer für den langsamsten Run-Path
-// (eventDef.name pattern lädt full augmented map) ohne echte Hänger
-// zu maskieren.
-const STRICT_MODE_TIMEOUT_MS = 120_000;
+describe("strict-mode diagnostics -- the actual contract of the codegen", () => {
+  let appRoot: string;
+  let allDiagnostics: readonly ts.Diagnostic[];
 
-describe("strict-mode diagnostics — the actual contract of the codegen", () => {
-  test("good ctx.appendEvent compiles cleanly", { timeout: STRICT_MODE_TIMEOUT_MS }, () => {
-    const appRoot = setupApp();
+  beforeAll(() => {
+    appRoot = makeAppDir();
+    writeOrderPlacedSchema(appRoot);
+    write(
+      appRoot,
+      "src/feature/feature.ts",
+      [
+        'import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";',
+        'import { orderPlacedSchema } from "./events";',
+        "",
+        'export const ordersFeature = defineFeature("orders", (r) => ({',
+        '  placed: r.defineEvent("placed", orderPlacedSchema),',
+        "}));",
+        "",
+      ].join("\n"),
+    );
     runCodegen({ appRoot });
 
     write(
       appRoot,
-      "src/feature/handler.ts",
-      `import { defineWriteHandler } from "../../.kumiko/define";
-import { z } from "zod";
+      "src/feature/handler-good.ts",
+      [
+        'import { defineWriteHandler } from "../../.kumiko/define";',
+        'import { z } from "zod";',
+        "",
+        "export const placeOrder = defineWriteHandler({",
+        '  name: "orders.placeOrder",',
+        "  schema: z.object({}),",
+        '  access: { roles: ["Admin"] },',
+        "  handler: async (_event, ctx) => {",
+        "    await ctx.appendEvent({",
+        '      aggregateId: "x",',
+        '      aggregateType: "order",',
+        '      type: "orders:event:placed",',
+        '      payload: { orderId: "o1", customerId: "c1", amount: 99 },',
+        "    });",
+        '    return { isSuccess: true as const, data: { id: "o1" } };',
+        "  },",
+        "});",
+        "",
+      ].join("\n"),
+    );
 
-export const placeOrder = defineWriteHandler({
-  name: "orders.placeOrder",
-  schema: z.object({}),
-  access: { roles: ["Admin"] },
-  handler: async (_event, ctx) => {
-    await ctx.appendEvent({
-      aggregateId: "x",
-      aggregateType: "order",
-      type: "orders:event:placed",
-      payload: { orderId: "o1", customerId: "c1", amount: 99 },
-    });
-    return { isSuccess: true as const, data: { id: "o1" } };
-  },
-});
-`,
+    write(
+      appRoot,
+      "src/feature/handler-unknown-type.ts",
+      [
+        'import { defineWriteHandler } from "../../.kumiko/define";',
+        'import { z } from "zod";',
+        "",
+        "export const placeOrder = defineWriteHandler({",
+        '  name: "orders.placeOrder",',
+        "  schema: z.object({}),",
+        '  access: { roles: ["Admin"] },',
+        "  handler: async (_event, ctx) => {",
+        "    await ctx.appendEvent({",
+        '      aggregateId: "x",',
+        '      aggregateType: "order",',
+        '      type: "totally:made:up",',
+        "      payload: { whatever: 1 },",
+        "    });",
+        '    return { isSuccess: true as const, data: { id: "x" } };',
+        "  },",
+        "});",
+        "",
+      ].join("\n"),
     );
 
-    const diagnostics = compileApp(appRoot);
-    const handlerErrors = diagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler.ts"),
+    write(
+      appRoot,
+      "src/feature/handler-payload-mismatch.ts",
+      [
+        'import { defineWriteHandler } from "../../.kumiko/define";',
+        'import { z } from "zod";',
+        "",
+        "export const placeOrder = defineWriteHandler({",
+        '  name: "orders.placeOrder",',
+        "  schema: z.object({}),",
+        '  access: { roles: ["Admin"] },',
+        "  handler: async (_event, ctx) => {",
+        "    await ctx.appendEvent({",
+        '      aggregateId: "x",',
+        '      aggregateType: "order",',
+        '      type: "orders:event:placed",',
+        '      payload: { orderId: "o1", customerId: "c1", amount: 99, bogus: "extra" },',
+        "    });",
+        '    return { isSuccess: true as const, data: { id: "o1" } };',
+        "  },",
+        "});",
+        "",
+      ].join("\n"),
     );
-    expect(handlerErrors).toHaveLength(0);
-  });
 
-  test("unknown event-type triggers TS2322 with augmented map in error message", {
-    timeout: STRICT_MODE_TIMEOUT_MS,
-  }, () => {
-    const appRoot = setupApp();
-    runCodegen({ appRoot });
+    write(
+      appRoot,
+      "src/feature/handler-direct.ts",
+      [
+        'import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";',
+        'import { z } from "zod";',
+        "",
+        "export const placeOrder = defineWriteHandler({",
+        '  name: "orders.placeOrder",',
+        "  schema: z.object({}),",
+        '  access: { roles: ["Admin"] },',
+        "  handler: async (_event, ctx) => {",
+        "    await ctx.appendEvent({",
+        '      aggregateId: "x",',
+        '      aggregateType: "order",',
+        '      type: "orders:event:placed",',
+        '      payload: { orderId: "o1", customerId: "c1", amount: 99 },',
+        "    });",
+        '    return { isSuccess: true as const, data: { id: "o1" } };',
+        "  },",
+        "});",
+        "",
+      ].join("\n"),
+    );
 
     write(
       appRoot,
-      "src/feature/handler.ts",
-      `import { defineWriteHandler } from "../../.kumiko/define";
-import { z } from "zod";
+      "src/feature/handler-byname-good.ts",
+      [
+        'import { defineWriteHandler } from "../../.kumiko/define";',
+        'import { z } from "zod";',
+        'import { ordersFeature } from "./feature";',
+        "",
+        "const { placed } = ordersFeature.exports;",
+        "",
+        "export const placeOrder = defineWriteHandler({",
+        '  name: "orders.placeOrder",',
+        "  schema: z.object({}),",
+        '  access: { roles: ["Admin"] },',
+        "  handler: async (_event, ctx) => {",
+        "    await ctx.appendEvent({",
+        '      aggregateId: "x",',
+        '      aggregateType: "order",',
+        "      type: placed.name,",
+        '      payload: { orderId: "o1", customerId: "c1", amount: 99 },',
+        "    });",
+        '    return { isSuccess: true as const, data: { id: "o1" } };',
+        "  },",
+        "});",
+        "",
+      ].join("\n"),
+    );
 
-export const placeOrder = defineWriteHandler({
-  name: "orders.placeOrder",
-  schema: z.object({}),
-  access: { roles: ["Admin"] },
-  handler: async (_event, ctx) => {
-    await ctx.appendEvent({
-      aggregateId: "x",
-      aggregateType: "order",
-      type: "totally:made:up",
-      payload: { whatever: 1 },
-    });
-    return { isSuccess: true as const, data: { id: "x" } };
-  },
-});
-`,
+    write(
+      appRoot,
+      "src/feature/handler-byname-bad.ts",
+      [
+        'import { defineWriteHandler } from "../../.kumiko/define";',
+        'import { z } from "zod";',
+        'import { ordersFeature } from "./feature";',
+        "",
+        "const { placed } = ordersFeature.exports;",
+        "",
+        "export const placeOrder = defineWriteHandler({",
+        '  name: "orders.placeOrder",',
+        "  schema: z.object({}),",
+        '  access: { roles: ["Admin"] },',
+        "  handler: async (_event, ctx) => {",
+        "    await ctx.appendEvent({",
+        '      aggregateId: "x",',
+        '      aggregateType: "order",',
+        "      type: placed.name,",
+        '      payload: { orderId: "o1", customerId: "c1", amount: 99, bogus: "extra" },',
+        "    });",
+        '    return { isSuccess: true as const, data: { id: "o1" } };',
+        "  },",
+        "});",
+        "",
+      ].join("\n"),
     );
 
-    const diagnostics = compileApp(appRoot);
-    const handlerErrors = diagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler.ts"),
+    allDiagnostics = compileApp(appRoot);
+  }, 120_000);
+
+  test("good ctx.appendEvent compiles cleanly", () => {
+    const handlerErrors = allDiagnostics.filter((d) =>
+      d.file?.fileName.endsWith("/feature/handler-good.ts"),
+    );
+    expect(handlerErrors).toHaveLength(0);
+  });
+
+  test("unknown event-type triggers TS2322 with augmented map in error message", () => {
+    const handlerErrors = allDiagnostics.filter((d) =>
+      d.file?.fileName.endsWith("/feature/handler-unknown-type.ts"),
     );
-    // We expect at least one TS2322 ("not assignable") for the bogus
-    // type-string. The exact column may move with TS versions; the code
-    // + the type-name are the stable contract.
     const ts2322 = handlerErrors.filter((d) => d.code === 2322);
     expect(ts2322.length).toBeGreaterThan(0);
     const flattened = ts2322
@@ -267,42 +299,10 @@ export const placeOrder = defineWriteHandler({
     expect(flattened).toMatch(/keyof KumikoEventTypeMap|"orders:event:placed"/);
   });
 
-  test("payload-shape mismatch triggers a property-error", {
-    timeout: STRICT_MODE_TIMEOUT_MS,
-  }, () => {
-    const appRoot = setupApp();
-    runCodegen({ appRoot });
-
-    write(
-      appRoot,
-      "src/feature/handler.ts",
-      `import { defineWriteHandler } from "../../.kumiko/define";
-import { z } from "zod";
-
-export const placeOrder = defineWriteHandler({
-  name: "orders.placeOrder",
-  schema: z.object({}),
-  access: { roles: ["Admin"] },
-  handler: async (_event, ctx) => {
-    await ctx.appendEvent({
-      aggregateId: "x",
-      aggregateType: "order",
-      type: "orders:event:placed",
-      payload: { orderId: "o1", customerId: "c1", amount: 99, bogus: "extra" },
-    });
-    return { isSuccess: true as const, data: { id: "o1" } };
-  },
-});
-`,
-    );
-
-    const diagnostics = compileApp(appRoot);
-    const handlerErrors = diagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler.ts"),
+  test("payload-shape mismatch triggers a property-error", () => {
+    const handlerErrors = allDiagnostics.filter((d) =>
+      d.file?.fileName.endsWith("/feature/handler-payload-mismatch.ts"),
     );
-    // TS2353 = "Object literal may only specify known properties, and
-    // 'bogus' does not exist in type". This is the property-level
-    // strict-check we promised.
     const propErrors = handlerErrors.filter((d) => d.code === 2353);
     expect(propErrors.length).toBeGreaterThan(0);
     const flattened = propErrors
@@ -311,151 +311,26 @@ export const placeOrder = defineWriteHandler({
     expect(flattened).toMatch(/'bogus'/);
   });
 
-  test("direct framework-import + augmentation-included compiles strict too", {
-    timeout: STRICT_MODE_TIMEOUT_MS,
-  }, () => {
-    // Sanity-Check: in einem isolated app-tsc (tmp-fixture mit paths-
-    // mapping zur framework-source UND .kumiko/types.generated.d.ts im
-    // include-Glob) greift strict-mode auch beim direct framework-import.
-    // Generic-function-inference nimmt die augmentation am use-site wahr.
-    //
-    // Konsequenz: der Wrapper ist NICHT der einzige Weg zu strict —
-    // aber er ist DER ROBUSTE Weg. Er importiert `types.generated`
-    // explicit als side-effect, sodass die Augmentation auch in
-    // partial-builds / IDE-Sprachserver-stati garantiert visible ist.
-    // Direkter Import setzt voraus, dass das tsconfig-Setup stimmt.
-    //
-    // Die alte "K=never"-Beobachtung aus den 13 Probes war im
-    // bundled-features-Compile, wo das `.kumiko/`-Output nicht im
-    // include-Glob lag — die Augmentation aus inline `declare module`
-    // hatte einen anderen Resolution-Pfad. Der Wrapper bleibt der
-    // empfohlene Pfad für Apps, weil er diese Setup-Sensibilität wegabstrahiert.
-    const appRoot = setupApp();
-    runCodegen({ appRoot });
-
-    write(
-      appRoot,
-      "src/feature/handler-direct.ts",
-      `import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-
-export const placeOrder = defineWriteHandler({
-  name: "orders.placeOrder",
-  schema: z.object({}),
-  access: { roles: ["Admin"] },
-  handler: async (_event, ctx) => {
-    await ctx.appendEvent({
-      aggregateId: "x",
-      aggregateType: "order",
-      type: "orders:event:placed",
-      payload: { orderId: "o1", customerId: "c1", amount: 99 },
-    });
-    return { isSuccess: true as const, data: { id: "o1" } };
-  },
-});
-`,
-    );
-
-    const diagnostics = compileApp(appRoot);
-    const handlerErrors = diagnostics.filter((d) =>
+  test("direct framework-import + augmentation-included compiles strict too", () => {
+    const handlerErrors = allDiagnostics.filter((d) =>
       d.file?.fileName.endsWith("/feature/handler-direct.ts"),
     );
-    // Good call should compile — augmentation is visible via include of
-    // `.kumiko/types.generated.d.ts`.
     expect(handlerErrors).toHaveLength(0);
   });
 
-  test("eventDef.name pattern: literal-typed name resolves to correct payload-shape", {
-    timeout: STRICT_MODE_TIMEOUT_MS,
-  }, () => {
-    // Marten pattern: `const placed = r.defineEvent(...)`, then
-    // `type: placed.name` in appendEvent. This requires `EventDef.name`
-    // to be LITERAL-typed (`"orders:event:placed"`, NOT `string`) —
-    // otherwise the lookup collapses to `string` and the strict check
-    // silently disappears.
-    //
-    // This test catches regressions in `EventDef<TPayload, TName>` and
-    // the `<const TInner>` inference in `defineFeature`/`defineEvent`
-    // — both have to cooperate so that `placed.name` resolves as a
-    // literal into the `KumikoEventTypeMap` key.
-    //
-    // Setup: `setupAppWithExports` returns `{ placed }` from the
-    // defineFeature callback so handler modules can read it as
-    // `ordersFeature.exports.placed.name`.
-    const appRoot = setupAppWithExports();
-    runCodegen({ appRoot });
-
-    write(
-      appRoot,
-      "src/feature/handler-byname.ts",
-      `import { defineWriteHandler } from "../../.kumiko/define";
-import { z } from "zod";
-import { ordersFeature } from "./feature";
-
-const { placed } = ordersFeature.exports;
-
-export const placeOrder = defineWriteHandler({
-  name: "orders.placeOrder",
-  schema: z.object({}),
-  access: { roles: ["Admin"] },
-  handler: async (_event, ctx) => {
-    await ctx.appendEvent({
-      aggregateId: "x",
-      aggregateType: "order",
-      type: placed.name,
-      payload: { orderId: "o1", customerId: "c1", amount: 99 },
-    });
-    return { isSuccess: true as const, data: { id: "o1" } };
-  },
-});
-`,
-    );
-
-    const goodDiagnostics = compileApp(appRoot);
-    const goodErrors = goodDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-byname.ts"),
+  test("eventDef.name pattern: literal-typed name resolves to correct payload-shape", () => {
+    const goodErrors = allDiagnostics.filter((d) =>
+      d.file?.fileName.endsWith("/feature/handler-byname-good.ts"),
     );
     if (goodErrors.length > 0) {
       const msgs = goodErrors
         .map((d) => `  TS${d.code}: ${ts.flattenDiagnosticMessageText(d.messageText, "\n")}`)
         .join("\n");
-      throw new Error(`expected handler-byname.ts to compile cleanly, got:\n${msgs}`);
+      throw new Error(`expected handler-byname-good.ts to compile cleanly, got:\n${msgs}`);
     }
 
-    // Negative-Case: bad payload (extra property) → TS2353. Der
-    // entscheidende Punkt — wenn `placed.name` zu `string` kollabiert
-    // wäre, würde TS hier eine `Record<string, unknown>` annehmen und
-    // die extra property NICHT melden. TS2353 hier beweist die
-    // literal-typed Auflösung über `.name`.
-    write(
-      appRoot,
-      "src/feature/handler-byname.ts",
-      `import { defineWriteHandler } from "../../.kumiko/define";
-import { z } from "zod";
-import { ordersFeature } from "./feature";
-
-const { placed } = ordersFeature.exports;
-
-export const placeOrder = defineWriteHandler({
-  name: "orders.placeOrder",
-  schema: z.object({}),
-  access: { roles: ["Admin"] },
-  handler: async (_event, ctx) => {
-    await ctx.appendEvent({
-      aggregateId: "x",
-      aggregateType: "order",
-      type: placed.name,
-      payload: { orderId: "o1", customerId: "c1", amount: 99, bogus: "extra" },
-    });
-    return { isSuccess: true as const, data: { id: "o1" } };
-  },
-});
-`,
-    );
-
-    const badDiagnostics = compileApp(appRoot);
-    const badErrors = badDiagnostics.filter((d) =>
-      d.file?.fileName.endsWith("/feature/handler-byname.ts"),
+    const badErrors = allDiagnostics.filter((d) =>
+      d.file?.fileName.endsWith("/feature/handler-byname-bad.ts"),
     );
     const propErrors = badErrors.filter((d) => d.code === 2353);
     expect(propErrors.length).toBeGreaterThan(0);

package/src/codegen/render.ts

@@ -192,6 +192,7 @@ export function renderDefineFile(): string {
     `import type {`,
     `  KumikoEventTypeMap,`,
     `  WriteHandlerDefinition,`,
+    `  WriteHandlerInput,`,
     `  QueryHandlerDefinition,`,
     `} from "@cosmicdrift/kumiko-framework/engine";`,
     `import type { ZodType } from "zod";`,
@@ -204,7 +205,7 @@ export function renderDefineFile(): string {
     `  TSchema extends ZodType,`,
     `  TData = unknown,`,
     `>(`,
-    `  def: WriteHandlerDefinition<TName, TSchema, TData, KumikoEventTypeMap>,`,
+    `  def: WriteHandlerInput<TName, TSchema, TData, KumikoEventTypeMap>,`,
     `): WriteHandlerDefinition<TName, TSchema, TData, KumikoEventTypeMap> {`,
     `  return fwDefineWriteHandler<TName, TSchema, TData, KumikoEventTypeMap>(def);`,
     `}`,