@cosmicdrift/kumiko-dev-server 0.328.1 → 0.330.0

package/src/codegen/__tests__/run-codegen.test.ts

@@ -1,665 +0,0 @@
-// Codegen — End-to-End-Test mit realistischen Feature-Files.
-//
-// Schreibt Features + events.ts in ein tmp-Verzeichnis, ruft runCodegen
-// auf, und prüft die generierten Files.
-//
-// Was hier verifiziert wird:
-//   - Position-Form `r.defineEvent("name", schema)` → "imported"
-//   - Object-Form `r.defineEvent({ name, schema })` → "imported"
-//   - Inline-Form `r.defineEvent("name", z.object({...}))`  → "inline"
-//   - Computed-Name `r.defineEvent(NAME_CONST.member, schema)` → "imported"
-//     mit string-resolved Name aus dem `as const`-Object
-//   - Mehrere Features in unterschiedlichen Files werden zusammengeführt
-//   - Doppelte qualifiedName erzeugen Warning + werden dedupliziert
-//   - Idempotent: 2× run schreibt beim 2. Mal nicht (didWrite=false)
-//   - Locally-declared schema (kein import, kein inline-z.*) → Warning, skip
-//   - skipped-Flag wenn 0 Events UND kein .kumiko/ schon existiert
-//   - schemas.generated.ts wird erzeugt wenn inline-Schemas, sonst nicht
-
-import { describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { runCodegen } from "../run-codegen";
-
-function makeAppDir(): string {
-  return mkdtempSync(join(tmpdir(), "kumiko-codegen-"));
-}
-
-function write(dir: string, relPath: string, content: string): string {
-  const full = join(dir, relPath);
-  const lastSep = full.lastIndexOf("/");
-  mkdirSync(full.substring(0, lastSep), { recursive: true });
-  writeFileSync(full, content, "utf-8");
-  return full;
-}
-
-describe("runCodegen", () => {
-  test("scans position-form r.defineEvent + writes augmentation", () => {
-    const appRoot = makeAppDir();
-
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";
-export const fooSchema = z.object({ id: z.string() });
-`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { fooSchema } from "./events";
-
-export const myFeature = defineFeature("myFeat", (r) => {
-  r.defineEvent("foo-happened", fooSchema);
-});
-`,
-    );
-
-    // handlerQns: [] opts out of the #2757 manifest-fallback warning — out of scope here.
-    const result = runCodegen({ appRoot, handlerQns: [] });
-
-    expect(result.eventCount).toBe(1);
-    expect(result.warnings).toEqual([]);
-    expect(result.didWriteTypes).toBe(true);
-    expect(result.didWriteDefine).toBe(true);
-    expect(result.didWriteSchemas).toBe(false);
-
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(`"my-feat:event:foo-happened": z.infer<typeof fooSchema>;`);
-    expect(types).toContain(`import type { fooSchema }`);
-    expect(types).toContain(`export {};`);
-
-    const define = readFileSync(join(appRoot, ".kumiko", "define.ts"), "utf-8");
-    expect(define).toContain(`/// <reference path="./types.generated.d.ts" />`);
-    expect(define).toContain(`export function defineWriteHandler<`);
-    expect(define).toContain(
-      `fwDefineWriteHandler<TName, TSchema, TData, KumikoEventTypeMap>(def)`,
-    );
-    expect(define).toContain(`export function defineQueryHandler<`);
-
-    expect(existsSync(join(appRoot, ".kumiko", "schemas.generated.ts"))).toBe(false);
-  });
-
-  test("scans object-form r.defineEvent", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";
-export const barSchema = z.object({ count: z.number() });
-`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { barSchema } from "./events";
-
-export const myFeature = defineFeature("objForm", (r) => {
-  r.defineEvent({ name: "bar-occurred", schema: barSchema });
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot });
-    expect(result.eventCount).toBe(1);
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(`"obj-form:event:bar-occurred": z.infer<typeof barSchema>;`);
-  });
-
-  test("inline-schema becomes a generated const in schemas.generated.ts", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-
-export const myFeature = defineFeature("inlineFeat", (r) => {
-  r.defineEvent("inline-evt", z.object({ id: z.string(), count: z.number() }));
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot, handlerQns: [] });
-    expect(result.eventCount).toBe(1);
-    expect(result.warnings).toEqual([]);
-    expect(result.didWriteSchemas).toBe(true);
-
-    const schemas = readFileSync(join(appRoot, ".kumiko", "schemas.generated.ts"), "utf-8");
-    expect(schemas).toContain(`import { z } from "zod";`);
-    // Generated const-name is stable + qualifiedName-derived; the exact
-    // string is part of the contract because types.generated.d.ts
-    // imports it under that name.
-    expect(schemas).toMatch(/export const _kg_inlineFeat__inlineEvt = z\.object/);
-    expect(schemas).toContain(`z.object({ id: z.string(), count: z.number() })`);
-
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(
-      `"inline-feat:event:inline-evt": z.infer<typeof _kg_inlineFeat__inlineEvt>;`,
-    );
-    expect(types).toContain(`from "./schemas.generated"`);
-  });
-
-  test("computed name via const-member resolves to string literal", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";
-export const EVT = {
-  sent: "invoice-sent",
-  paid: "invoice-paid",
-} as const;
-export const sentSchema = z.object({});
-export const paidSchema = z.object({ amount: z.number() });
-`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { EVT, sentSchema, paidSchema } from "./events";
-
-export const myFeature = defineFeature("billing", (r) => {
-  r.defineEvent(EVT.sent, sentSchema);
-  r.defineEvent(EVT.paid, paidSchema);
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot, handlerQns: [] });
-    expect(result.eventCount).toBe(2);
-    expect(result.warnings).toEqual([]);
-
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(`"billing:event:invoice-sent": z.infer<typeof sentSchema>;`);
-    expect(types).toContain(`"billing:event:invoice-paid": z.infer<typeof paidSchema>;`);
-  });
-
-  test("computed name + inline schema (recipes pattern)", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `export const EVT = {
-  forced: "force-applied",
-} as const;
-`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-import { EVT } from "./events";
-
-export const myFeature = defineFeature("billing", (r) => {
-  r.defineEvent(EVT.forced, z.object({ reason: z.string() }));
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot, handlerQns: [] });
-    expect(result.eventCount).toBe(1);
-    expect(result.warnings).toEqual([]);
-    expect(result.didWriteSchemas).toBe(true);
-
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(
-      `"billing:event:force-applied": z.infer<typeof _kg_billing__forceApplied>;`,
-    );
-  });
-
-  test("merges events from multiple feature files", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/a/events.ts",
-      `import { z } from "zod";\nexport const aSchema = z.object({ a: z.string() });\n`,
-    );
-    write(
-      appRoot,
-      "src/a/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { aSchema } from "./events";
-export default defineFeature("featA", (r) => {
-  r.defineEvent("evt", aSchema);
-});
-`,
-    );
-    write(
-      appRoot,
-      "src/b/events.ts",
-      `import { z } from "zod";\nexport const bSchema = z.object({ b: z.number() });\n`,
-    );
-    write(
-      appRoot,
-      "src/b/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { bSchema } from "./events";
-export default defineFeature("featB", (r) => {
-  r.defineEvent("evt", bSchema);
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot });
-    expect(result.eventCount).toBe(2);
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(`"feat-a:event:evt"`);
-    expect(types).toContain(`"feat-b:event:evt"`);
-  });
-
-  test("warns + dedupes on duplicate qualifiedName", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/x/events.ts",
-      `import { z } from "zod";\nexport const xSchema = z.object({ id: z.string() });\nexport const ySchema = z.object({ name: z.string() });\n`,
-    );
-    write(
-      appRoot,
-      "src/x/feature1.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { xSchema } from "./events";
-export default defineFeature("dup", (r) => {
-  r.defineEvent("collide", xSchema);
-});
-`,
-    );
-    write(
-      appRoot,
-      "src/x/feature2.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { ySchema } from "./events";
-export default defineFeature("dup", (r) => {
-  r.defineEvent("collide", ySchema);
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot });
-    expect(result.eventCount).toBe(1);
-    expect(result.warnings.length).toBeGreaterThanOrEqual(1);
-    const w = result.warnings.find((w) => w.message.includes("duplicate"));
-    expect(w).toBeDefined();
-  });
-
-  test("emits WriteHandlerQn union and TypedDispatcher when handlerQns passed", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";\nexport const sSchema = z.object({ id: z.string() });\n`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { sSchema } from "./events";
-export default defineFeature("typed", (r) => {
-  r.defineEvent("only", sSchema);
-});
-`,
-    );
-
-    const result = runCodegen({
-      appRoot,
-      handlerQns: ["typed:write:create"],
-    });
-    expect(result.skipped).toBe(false);
-
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain('| "typed:write:create"');
-
-    const define = readFileSync(join(appRoot, ".kumiko", "define.ts"), "utf-8");
-    expect(define).toContain("createTypedDispatcher");
-  });
-
-  test("idempotent — second run does not re-write files", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";\nexport const sSchema = z.object({ id: z.string() });\n`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { sSchema } from "./events";
-export default defineFeature("idem", (r) => {
-  r.defineEvent("only", sSchema);
-});
-`,
-    );
-
-    const first = runCodegen({ appRoot });
-    expect(first.didWriteTypes).toBe(true);
-    expect(first.didWriteDefine).toBe(true);
-
-    const second = runCodegen({ appRoot });
-    expect(second.didWriteTypes).toBe(false);
-    expect(second.didWriteDefine).toBe(false);
-  });
-
-  test("warns when schema is locally declared (not imported, not inline z.*)", () => {
-    const appRoot = makeAppDir();
-    // Schema is declared as a local const but referenced by a name that's
-    // neither an imported identifier nor an inline z.* call (it's an
-    // identifier-reference to the local const). Scanner can't reach it
-    // without a separate scan of the file's local symbols → warn + skip.
-    write(
-      appRoot,
-      "src/inline/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-
-const localSchema = z.object({ x: z.string() });
-
-export default defineFeature("inline", (r) => {
-  r.defineEvent("local", localSchema);
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot });
-    expect(result.eventCount).toBe(0);
-    expect(result.warnings.length).toBe(1);
-    expect(result.warnings[0]?.message).toMatch(/not a named import nor an inline z\.\* call/);
-  });
-
-  test("skips test files, node_modules, .kumiko, dist", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";\nexport const realSchema = z.object({});\n`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { realSchema } from "./events";
-export default defineFeature("real", (r) => {
-  r.defineEvent("ok", realSchema);
-});
-`,
-    );
-    // Should be ignored:
-    write(
-      appRoot,
-      "src/feature/__tests__/feature.test.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-const fakeSchema = z.object({});
-defineFeature("fake-from-test", (r) => {
-  r.defineEvent("nope", fakeSchema);
-});
-`,
-    );
-    write(
-      appRoot,
-      ".kumiko/old.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-const oldSchema = z.object({});
-defineFeature("old-codegen-output", (r) => {
-  r.defineEvent("nope", oldSchema);
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot });
-    expect(result.eventCount).toBe(1);
-    const types = readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8");
-    expect(types).toContain(`"real:event:ok"`);
-    expect(types).not.toContain(`"fake-from-test`);
-    expect(types).not.toContain(`"old-codegen-output`);
-  });
-
-  test("0 events + no existing .kumiko/ → bails with skipped=true", () => {
-    const appRoot = makeAppDir();
-    // App with NO r.defineEvent at all. Codegen should not create an
-    // empty `.kumiko/` directory.
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-export default defineFeature("nothing", (r) => {
-  r.requires("auth");
-});
-`,
-    );
-
-    const result = runCodegen({ appRoot });
-    expect(result.eventCount).toBe(0);
-    expect(result.skipped).toBe(true);
-    expect(result.didWriteTypes).toBe(false);
-    expect(result.didWriteDefine).toBe(false);
-    expect(existsSync(join(appRoot, ".kumiko"))).toBe(false);
-  });
-
-  test("schemas.generated.ts gets removed when last inline-schema disappears", () => {
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-export default defineFeature("evolve", (r) => {
-  r.defineEvent("inline-once", z.object({ x: z.string() }));
-});
-`,
-    );
-
-    const first = runCodegen({ appRoot });
-    expect(first.didWriteSchemas).toBe(true);
-    expect(existsSync(join(appRoot, ".kumiko", "schemas.generated.ts"))).toBe(true);
-
-    // Refactor: schema moves out of the call-site into a named export.
-    write(
-      appRoot,
-      "src/feature/events.ts",
-      `import { z } from "zod";\nexport const onceSchema = z.object({ x: z.string() });\n`,
-    );
-    write(
-      appRoot,
-      "src/feature/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { onceSchema } from "./events";
-export default defineFeature("evolve", (r) => {
-  r.defineEvent("inline-once", onceSchema);
-});
-`,
-    );
-
-    const second = runCodegen({ appRoot });
-    expect(second.didWriteSchemas).toBe(true); // means: removed
-    expect(existsSync(join(appRoot, ".kumiko", "schemas.generated.ts"))).toBe(false);
-  });
-
-  test(".kumiko/package.json has the shape that yarn 4 link: needs", () => {
-    // The generated package.json turns `.kumiko/` into an installable
-    // file-link package (`"@app/define": "link:./.kumiko"` in app's
-    // package.json). The shape here is load-bearing:
-    //   - name=@app/define matches what handlers import
-    //   - exports."."=./define.ts gives the wrapper as the default
-    //   - exports."./*"=./* lets apps reach types.generated etc.
-    //   - license=BUSL-1.1 keeps License-Check happy (UNLICENSED would deny)
-    //   - main+types pin TypeScript + Node resolution targets
-    // Regressions in any field break either runtime resolution or the
-    // kumiko-check License-Check gate — the test fails fast.
-    const appRoot = makeAppDir();
-    write(
-      appRoot,
-      "src/feature.ts",
-      `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { z } from "zod";
-export default defineFeature("pkgjson", (r) => {
-  r.defineEvent("evt", z.object({ id: z.string() }));
-});
-`,
-    );
-
-    runCodegen({ appRoot });
-
-    const pkgPath = join(appRoot, ".kumiko", "package.json");
-    expect(existsSync(pkgPath)).toBe(true);
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as Record<string, unknown>;
-    expect(pkg).toMatchObject({
-      name: "@app/define",
-      private: true,
-      license: "BUSL-1.1",
-      type: "module",
-      main: "./define.ts",
-      types: "./define.ts",
-      exports: {
-        ".": "./define.ts",
-        "./*": "./*",
-      },
-    });
-  });
-
-  // #2757 — `kumiko-build` runs `runCodegen({ appRoot })` with no
-  // `handlerQns`. Without a `feature-manifest.json` that falls back to
-  // an empty list, which used to mean "render types.generated.d.ts and
-  // define.ts as if there were no write handlers at all" — silently
-  // deleting an already-checked-in WriteHandlerQn union / TypedDispatcher
-  // that a previous dev-server run had generated from the real registry.
-  describe("preserving the handler-derived block when handlerQns is omitted (#2757)", () => {
-    function writeSingleEventFeature(appRoot: string): void {
-      write(
-        appRoot,
-        "src/feature/events.ts",
-        `import { z } from "zod";\nexport const sSchema = z.object({ id: z.string() });\n`,
-      );
-      write(
-        appRoot,
-        "src/feature/feature.ts",
-        `import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { sSchema } from "./events";
-export default defineFeature("app", (r) => {
-  r.defineEvent("only", sSchema);
-});
-`,
-      );
-    }
-
-    test("a block generated with handlerQns survives a later run without handlerQns", () => {
-      const appRoot = makeAppDir();
-      writeSingleEventFeature(appRoot);
-
-      runCodegen({ appRoot, handlerQns: ["app:write:create"] });
-      const typesPath = join(appRoot, ".kumiko", "types.generated.d.ts");
-      const definePath = join(appRoot, ".kumiko", "define.ts");
-      expect(readFileSync(typesPath, "utf-8")).toContain('| "app:write:create"');
-      expect(readFileSync(definePath, "utf-8")).toContain("createTypedDispatcher");
-
-      // No feature-manifest.json in appRoot — this is the kumiko-build path.
-      const result = runCodegen({ appRoot });
-
-      expect(readFileSync(typesPath, "utf-8")).toContain('| "app:write:create"');
-      expect(readFileSync(definePath, "utf-8")).toContain("createTypedDispatcher");
-      expect(result.warnings.some((w) => w.message.includes("feature-manifest.json"))).toBe(true);
-      // Round-trip is byte-identical, not just "still contains the QN" — writeIfChanged
-      // must see no diff once the preserved block is reattached.
-      expect(result.didWriteTypes).toBe(false);
-      expect(result.didWriteDefine).toBe(false);
-    });
-
-    test("a block from a pre-#2757 file (no marker) survives a run without handlerQns", () => {
-      const appRoot = makeAppDir();
-      writeSingleEventFeature(appRoot);
-      // Legacy shape: what the released renderer wrote before markers existed.
-      write(
-        appRoot,
-        ".kumiko/types.generated.d.ts",
-        `export {};\n\nexport type WriteHandlerQn =\n  | "app:write:legacy"\n;\n`,
-      );
-      write(
-        appRoot,
-        ".kumiko/define.ts",
-        `export function defineQueryHandler() {}\n\nimport type { Dispatcher, WriteOpts, WriteResult } from "@cosmicdrift/kumiko-headless";\nexport function createTypedDispatcher() {}\n`,
-      );
-
-      const result = runCodegen({ appRoot });
-
-      expect(readFileSync(join(appRoot, ".kumiko", "types.generated.d.ts"), "utf-8")).toContain(
-        '| "app:write:legacy"',
-      );
-      expect(readFileSync(join(appRoot, ".kumiko", "define.ts"), "utf-8")).toContain(
-        "createTypedDispatcher",
-      );
-      expect(result.warnings.some((w) => w.message.includes("feature-manifest.json"))).toBe(true);
-    });
-
-    test("no handlerQns and no prior generated file → no block, no crash", () => {
-      const appRoot = makeAppDir();
-      writeSingleEventFeature(appRoot);
-
-      const result = runCodegen({ appRoot });
-
-      const typesPath = join(appRoot, ".kumiko", "types.generated.d.ts");
-      const definePath = join(appRoot, ".kumiko", "define.ts");
-      expect(readFileSync(typesPath, "utf-8")).not.toContain("WriteHandlerQn");
-      expect(readFileSync(definePath, "utf-8")).not.toContain("TypedDispatcher");
-      expect(result.skipped).toBe(false);
-    });
-
-    test("a preserved block is not duplicated across repeated runs without handlerQns", () => {
-      const appRoot = makeAppDir();
-      writeSingleEventFeature(appRoot);
-
-      runCodegen({ appRoot, handlerQns: ["app:write:create"] });
-      runCodegen({ appRoot });
-      runCodegen({ appRoot });
-
-      const typesPath = join(appRoot, ".kumiko", "types.generated.d.ts");
-      const definePath = join(appRoot, ".kumiko", "define.ts");
-      const typesOccurrences =
-        readFileSync(typesPath, "utf-8").split("app:write:create").length - 1;
-      const defineOccurrences =
-        readFileSync(definePath, "utf-8").split("createTypedDispatcher").length - 1;
-      expect(typesOccurrences).toBe(1);
-      expect(defineOccurrences).toBe(1);
-    });
-
-    test("a later run with handlerQns overwrites a preserved stale block", () => {
-      const appRoot = makeAppDir();
-      writeSingleEventFeature(appRoot);
-
-      runCodegen({ appRoot, handlerQns: ["app:write:create"] });
-      runCodegen({ appRoot }); // preserves app:write:create
-      runCodegen({ appRoot, handlerQns: ["app:write:update"] });
-
-      const typesPath = join(appRoot, ".kumiko", "types.generated.d.ts");
-      const typesContent = readFileSync(typesPath, "utf-8");
-      expect(typesContent).toContain('| "app:write:update"');
-      expect(typesContent).not.toContain("app:write:create");
-    });
-
-    test("the missing-manifest warning appears only when handlerQns is omitted", () => {
-      const appRoot = makeAppDir();
-      writeSingleEventFeature(appRoot);
-
-      const withoutOption = runCodegen({ appRoot });
-      expect(withoutOption.warnings.some((w) => w.message.includes("feature-manifest.json"))).toBe(
-        true,
-      );
-
-      const explicitEmpty = runCodegen({ appRoot, handlerQns: [] });
-      expect(explicitEmpty.warnings.some((w) => w.message.includes("feature-manifest.json"))).toBe(
-        false,
-      );
-
-      const explicitList = runCodegen({ appRoot, handlerQns: ["app:write:create"] });
-      expect(explicitList.warnings.some((w) => w.message.includes("feature-manifest.json"))).toBe(
-        false,
-      );
-    });
-  });
-});