@cosmicdrift/kumiko-framework 0.159.1 → 0.160.0

package/src/db/tenant-db.ts

@@ -1,3 +1,5 @@
+import type { SchemaTable } from "@cosmicdrift/kumiko-types/schema-table-types";
+import type { TenantDb, TenantDbMode } from "@cosmicdrift/kumiko-types/tenant-db-types";
 import {
   asEntityTableMeta,
   asRawClient,
@@ -12,61 +14,10 @@ import {
 import { SYSTEM_TENANT_ID, type TenantId } from "../engine/types/identifiers";
 import { emitDbQuery, type Meter, registerStandardMetrics, type Tracer } from "../observability";
 import type { DbRunner } from "./connection";
-import type { TableColumns } from "./dialect";
-import type { EntityTableMeta } from "./entity-table-meta";
-import type { NotExecutorOnly } from "./table-builder";
-
-// biome-ignore lint/suspicious/noExplicitAny: Dynamic tables — keys depend on user-defined schema.
-type Table = TableColumns<any>;
-
-// Method-form writes reject the executor-only brand exactly like the free-function
-// helpers (#742): a managed EntityTable is a rebuildable projection, so writing it
-// directly — free-function OR method-form — drifts the row past its event stream and
-// a rebuild wipes it. The permissive base stays (raw pgTables AND unmanaged entity
-// metas are not projections → writable); `& NotExecutorOnly` strips only branded
-// EntityTables (its `[EXECUTOR_ONLY]: true` violates the optional-never). Reads keep
-// the plain `Table` param.
-type WritableTable = (Table | EntityTableMeta) & NotExecutorOnly;
-
-/**
- * TenantDb scope modes:
- *
- * - "tenant" (default): SELECT/UPDATE/DELETE filtered by tenantId + reference data (tenantId=SYSTEM_TENANT_ID).
- *   INSERT forces tenantId — handler cannot override.
- *
- * - "system" (r.systemScope()): No tenant filter on reads/updates/deletes.
- *   INSERT uses tenantId as default but handler can override.
- *
- * Tables without a tenantId column are always unfiltered regardless of mode.
- */
-export type TenantDbMode = "tenant" | "system";
-
-export type TenantDb = {
-  readonly tenantId: TenantId;
-  readonly mode: TenantDbMode;
-  /**
-   * Underlying DbRunner. Framework-internal use (event-store, migrations) —
-   * bypasses tenant-filter. Feature code uses the typed helpers above so the
-   * automatic scoping stays intact.
-   */
-  readonly raw: DbRunner;
-  selectMany<T = Record<string, unknown>>(
-    table: Table,
-    where?: WhereObject,
-    options?: SelectOptions,
-  ): Promise<readonly T[]>;
-  fetchOne<T = Record<string, unknown>>(table: Table, where: WhereObject): Promise<T | undefined>;
-  insertOne<T = Record<string, unknown>>(
-    table: WritableTable,
-    values: Record<string, unknown>,
-  ): Promise<T | undefined>;
-  updateMany<T = Record<string, unknown>>(
-    table: WritableTable,
-    set: Record<string, unknown>,
-    where: WhereObject,
-  ): Promise<readonly T[]>;
-  deleteMany(table: WritableTable, where: WhereObject): Promise<void>;
-};
+
+type Table = SchemaTable;
+
+export type { TenantDb, TenantDbMode } from "@cosmicdrift/kumiko-types/tenant-db-types";
 
 // @cast-boundary tenant-db-row
 export function castTenantRows<T>(rows: readonly Record<string, unknown>[]): readonly T[] {

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

@@ -590,6 +590,52 @@ describe("boot-validator", () => {
     expect(() => validateBoot(features)).not.toThrow();
   });
 
+  test("throws when a stream handler has no access rule", () => {
+    const features = [
+      defineFeature("a", (r) => {
+        r.streamHandler("chat:complete", z.object({}), async function* () {});
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(/a:stream:chat:complete.*missing an access rule/i);
+  });
+
+  test("accepts openToAll access rule on a stream handler", () => {
+    const features = [
+      defineFeature("a", (r) => {
+        r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+          access: { openToAll: true },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).not.toThrow();
+  });
+
+  test("throws when an anonymous stream handler uses a user-bucketed rate limit", () => {
+    const features = [
+      defineFeature("a", (r) => {
+        r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+          access: { roles: ["anonymous"] },
+          rateLimit: { per: "user", limit: 10, windowSeconds: 60 },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).toThrow(
+      /stream handler "a:stream:chat:complete" allows anonymous callers/i,
+    );
+  });
+
+  test("accepts an anonymous stream handler with an ip-bucketed rate limit", () => {
+    const features = [
+      defineFeature("a", (r) => {
+        r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+          access: { roles: ["anonymous"] },
+          rateLimit: { per: "ip", limit: 10, windowSeconds: 60 },
+        });
+      }),
+    ];
+    expect(() => validateBoot(features)).not.toThrow();
+  });
+
   describe("config key bounds consistency", () => {
     test("accepts number key with consistent bounds + default", () => {
       const features = [

package/src/engine/__tests__/codemod-pipeline.test.ts

@@ -1,19 +1,32 @@
 import { afterAll, beforeAll, describe, expect, it, mock } from "bun:test";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-// Bun.Glob is only used by scanForCandidates / runCodemod, not by
-// analyzeFile or convertFile. Those higher-level functions are tested
-// in the integration suite; unit tests here focus on file-level
-// operations which don't need Glob. A stub class prevents import
-// errors in bun (which runs on Node, not Bun).
+// Bun.Glob is only used by scanForCandidates / runCodemod. Emulate
+// **/*.write.ts via node:fs so scan/convert paths stay testable.
+function collectWriteTsRelPaths(rootDir: string, dir = rootDir, prefix = ""): string[] {
+  const out: string[] = [];
+  for (const name of readdirSync(dir)) {
+    const rel = prefix ? `${prefix}/${name}` : name;
+    const full = join(dir, name);
+    if (statSync(full).isDirectory()) {
+      out.push(...collectWriteTsRelPaths(rootDir, full, rel));
+    } else if (name.endsWith(".write.ts")) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+
 mock.module("bun", () => {
-  class StubGlob {
-    scanSync(): never {
-      throw new Error("Bun.Glob is not available in unit-test mode");
+  class FsGlob {
+    constructor(private readonly pattern: string) {}
+    scanSync(rootDir: string): string[] {
+      if (this.pattern !== "**/*.write.ts") return [];
+      return collectWriteTsRelPaths(rootDir).sort();
     }
   }
-  return { Glob: StubGlob };
+  return { Glob: FsGlob };
 });
 
 import {
@@ -21,6 +34,8 @@ import {
   analyzeHandlerArrow,
   convertFile,
   generatePerformBlock,
+  runCodemod,
+  scanForCandidates,
 } from "../codemod/index";
 
 const tmpDir = join(__dirname, "__codemod_fixtures__");
@@ -31,6 +46,20 @@ function writeFixture(name: string, content: string): string {
   return p;
 }
 
+function writeFixtureIn(dir: string, name: string, content: string): string {
+  const p = join(dir, name);
+  mkdirSync(join(p, ".."), { recursive: true });
+  writeFileSync(p, content, "utf8");
+  return p;
+}
+
+function freshScanRoot(name: string): string {
+  const dir = join(tmpDir, name);
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
 beforeAll(() => {
   rmSync(tmpDir, { recursive: true, force: true });
   mkdirSync(tmpDir, { recursive: true });
@@ -399,6 +428,31 @@ export const h = defineWriteHandler({
       // ts-morph should handle this gracefully (parse error → no call found)
       expect(result.status).toBe("skipped");
     });
+
+    it("returns error when the path is not a readable file", async () => {
+      const dirPath = join(tmpDir, "dir-not-file.write.ts");
+      rmSync(dirPath, { recursive: true, force: true });
+      mkdirSync(dirPath, { recursive: true });
+      const result = await convertFile(dirPath);
+      expect(result.status).toBe("error");
+      expect(result.reason).toBeDefined();
+    });
+
+    it("verbose logs when skipping a non-trivial handler", async () => {
+      const p = writeFixture("verbose-skip-file.write.ts", complexContent);
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: unknown[]) => {
+        logs.push(args.map(String).join(" "));
+      };
+      try {
+        const result = await convertFile(p, undefined, { verbose: true });
+        expect(result.status).toBe("skipped");
+        expect(logs.some((l) => l.includes("non-trivial handler"))).toBe(true);
+      } finally {
+        console.log = origLog;
+      }
+    });
   });
 });
 
@@ -509,6 +563,81 @@ describe("analyzeHandlerArrow", () => {
     expect(result.isGuardedCreate).toBe(true);
     expect(result.isSimpleExecutorCreate).toBe(false);
   });
+
+  it("returns non-convertible defaults for async ( without =>", () => {
+    const result = analyzeHandlerArrow("async (event, ctx) { return { isSuccess: true } }");
+    expect(result.isStaticReturn).toBe(false);
+    expect(result.isSimpleExecutorCreate).toBe(false);
+    expect(result.isSimpleExecutorUpdate).toBe(false);
+    expect(result.hasConditionalLogic).toBe(false);
+    expect(result.isExpressionBodyCreate).toBe(false);
+    expect(result.isGuardedCreate).toBe(false);
+  });
+});
+
+describe("scanForCandidates", () => {
+  it("returns empty list when no *.write.ts files exist", () => {
+    const root = freshScanRoot("scan-empty");
+    expect(scanForCandidates(root)).toEqual([]);
+  });
+
+  it("finds and classifies *.write.ts fixtures under rootDir", () => {
+    const root = freshScanRoot("scan-mixed");
+    writeFixtureIn(root, "freeform.write.ts", staticReturnContent);
+    writeFixtureIn(root, "already-pipeline.write.ts", alreadyPipelineContent);
+    writeFixtureIn(root, "nested/deep.write.ts", queryHandlerContent);
+
+    const results = scanForCandidates(root);
+    expect(results.map((r) => r.filePath).sort()).toEqual(
+      [
+        join(root, "already-pipeline.write.ts"),
+        join(root, "freeform.write.ts"),
+        join(root, "nested/deep.write.ts"),
+      ].sort(),
+    );
+    expect(results.find((r) => r.pattern === "free-form-write")?.convertible).toBe(true);
+    expect(results.find((r) => r.pattern === "pipeline-write")?.convertible).toBe(false);
+    expect(results.find((r) => r.pattern === "query-handler")?.convertible).toBe(false);
+  });
+});
+
+describe("runCodemod", () => {
+  it("returns empty report when scan finds no convertible handlers", async () => {
+    const root = freshScanRoot("run-empty");
+    const report = await runCodemod(root);
+    expect(report).toEqual({ results: [], converted: 0, skipped: 0, errors: 0 });
+  });
+
+  it("converts free-form write handlers discovered by scan", async () => {
+    const root = freshScanRoot("run-convert");
+    const p = writeFixtureIn(root, "to-convert.write.ts", staticReturnContent);
+    const report = await runCodemod(root);
+    expect(report.converted).toBe(1);
+    expect(report.skipped).toBe(0);
+    expect(report.errors).toBe(0);
+    expect(readFileSync(p, "utf8")).toContain("perform: stepsPipeline");
+  });
+
+  it("verbose logs per-file outcomes", async () => {
+    const root = freshScanRoot("run-verbose");
+    writeFixtureIn(root, "verbose-convert.write.ts", staticReturnContent);
+    writeFixtureIn(root, "verbose-skip.write.ts", complexContent);
+
+    const logs: string[] = [];
+    const origLog = console.log;
+    console.log = (...args: unknown[]) => {
+      logs.push(args.map(String).join(" "));
+    };
+    try {
+      const report = await runCodemod(root, { verbose: true });
+      expect(report.converted).toBe(1);
+      expect(report.skipped).toBe(1);
+      expect(logs.some((l) => l.includes("verbose-convert.write.ts"))).toBe(true);
+      expect(logs.some((l) => l.includes("verbose-skip.write.ts"))).toBe(true);
+    } finally {
+      console.log = origLog;
+    }
+  });
 });
 
 describe("generatePerformBlock", () => {

package/src/engine/__tests__/engine.test.ts

@@ -14,6 +14,7 @@ import {
   createTextField,
 } from "../factories";
 import { createApp, createRegistry, defineFeature } from "../index";
+import { buildMinimalCtx } from "./_pipeline-test-utils";
 
 // --- defineFeature ---
 
@@ -118,6 +119,33 @@ describe("defineFeature", () => {
     expect(ref?.name).toBe("order:list");
   });
 
+  test("streamHandler registers on feature.streamHandlers with schema/access/handler intact", async () => {
+    let ref: { name: string } | undefined;
+    const feature = defineFeature("test", (r) => {
+      ref = r.streamHandler(
+        "chat:complete",
+        z.object({ prompt: z.string() }),
+        async function* (query) {
+          yield `echo:${query.payload.prompt}`;
+        },
+        { access: { openToAll: true } },
+      );
+    });
+    expect(ref?.name).toBe("chat:complete");
+
+    const stored = feature.streamHandlers["chat:complete"];
+    expect(stored?.access).toEqual({ openToAll: true });
+
+    const chunks: string[] = [];
+    for await (const chunk of stored!.handler(
+      { type: "chat:complete", payload: { prompt: "hi" }, user: createTestUser() },
+      buildMinimalCtx(),
+    )) {
+      chunks.push(chunk as string);
+    }
+    expect(chunks).toEqual(["echo:hi"]);
+  });
+
   test("r.defineEvent returns typed EventDef and registers on feature", () => {
     let eventRef: { name: string } | undefined;
     const feature = defineFeature("orders", (r) => {

package/src/engine/__tests__/registry-facade-sweep.test.ts

@@ -0,0 +1,80 @@
+// Dilution reclaim: integration lcov registers every facade getter as DA:N,0
+// when the file loads, but unit only instruments getters that a test touches.
+// Calling every getter once in unit raises LF+LH so the badge merge stops
+// counting those one-liners as uncovered.
+
+import { describe, expect, test } from "bun:test";
+import { createRegistry } from "../registry";
+
+describe("buildRegistryFacade — getter sweep", () => {
+  test("empty registry: every getter is callable without throw", () => {
+    const r = createRegistry([]);
+
+    expect(r.features.size).toBe(0);
+    expect(r.getFeature("x")).toBeUndefined();
+    expect(r.hasRateLimitedHandler()).toBe(false);
+    expect(r.getEntity("x")).toBeUndefined();
+    expect(r.getAllEntities().size).toBe(0);
+    expect(r.getWriteHandler("x")).toBeUndefined();
+    expect(r.getQueryHandler("x")).toBeUndefined();
+    expect(r.getAllQueryHandlers().size).toBe(0);
+    expect(r.getSearchableFields("x")).toEqual([]);
+    expect(r.getSortableFields("x")).toEqual([]);
+    expect(r.getRelations("x")).toEqual({});
+    expect(r.getSearchIncludes("x").size).toBe(0);
+    expect(r.getIncomingRelations("x")).toEqual([]);
+    expect(r.getPreSaveHooks("x")).toEqual([]);
+    expect(r.getPostSaveHooks("x")).toEqual([]);
+    expect(r.getPreDeleteHooks("x")).toEqual([]);
+    expect(r.getPostDeleteHooks("x")).toEqual([]);
+    expect(r.getPreQueryHooks("x")).toEqual([]);
+    expect(r.getPostQueryHooks("x")).toEqual([]);
+    expect(r.getEntityPostSaveHooks("x")).toEqual([]);
+    expect(r.getEntityPreDeleteHooks("x")).toEqual([]);
+    expect(r.getEntityPostDeleteHooks("x")).toEqual([]);
+    expect(r.getEntityPostQueryHooks("x")).toEqual([]);
+    expect(r.getSearchPayloadExtensions("x")).toEqual([]);
+    expect(r.getAllTranslations()).toBeDefined();
+    expect(r.getHandlerEntity("x")).toBeUndefined();
+    expect(r.isHandlerSystemScoped("x")).toBe(false);
+    expect(r.getHandlerFeature("x")).toBeUndefined();
+    expect(r.getAllMetrics().size).toBe(0);
+    expect(r.getAllSecretKeys().size).toBe(0);
+    expect(r.getSecretKey("x")).toBeUndefined();
+    expect(r.getConfigKey("x")).toBeUndefined();
+    expect(r.getAllConfigKeys().size).toBe(0);
+    expect(r.getJob("x")).toBeUndefined();
+    expect(r.getAllJobs().size).toBe(0);
+    expect(r.getEvent("x")).toBeUndefined();
+    expect(r.getEventUpcasters().size).toBe(0);
+    expect(r.getExtension("x")).toBeUndefined();
+    expect(r.getExtensionUsages("x")).toEqual([]);
+    expect(r.getAllExtensionSelectors().size).toBe(0);
+    expect(r.getAllNotifications().size).toBe(0);
+    expect(r.getAllReferenceData()).toEqual([]);
+    expect(r.getAllConfigSeeds()).toEqual([]);
+    expect(r.getProjectionsForSource("x")).toEqual([]);
+    expect(r.getAllProjections().size).toBe(0);
+    expect(r.getAllStoreTables().size).toBe(0);
+    expect(r.getAllMultiStreamProjections().size).toBe(0);
+    expect(r.getMultiStreamProjectionFeature("x")).toBeUndefined();
+    expect(r.getAuthClaimsHooks()).toEqual([]);
+    expect(r.getAllClaimKeys().size).toBe(0);
+    expect(r.getClaimKey("x")).toBeUndefined();
+    expect(r.getAllScreens().size).toBe(0);
+    expect(r.getScreen("x")).toBeUndefined();
+    expect(r.getScreenFeature("x")).toBeUndefined();
+    expect(r.getScreensByEntity("x")).toEqual([]);
+    expect(r.getAllNavs().size).toBe(0);
+    expect(r.getNav("x")).toBeUndefined();
+    expect(r.getNavFeature("x")).toBeUndefined();
+    expect(r.getNavsByParent("x")).toEqual([]);
+    expect(r.getTopLevelNavs()).toEqual([]);
+    expect(r.getAllWorkspaces().size).toBe(0);
+    expect(r.getWorkspace("x")).toBeUndefined();
+    expect(r.getWorkspaceFeature("x")).toBeUndefined();
+    expect(r.getWorkspaceNavs("x")).toEqual([]);
+    expect(r.getDefaultWorkspace()).toBeUndefined();
+    expect(r.getTreeActions("x")).toBeUndefined();
+  });
+});

package/src/engine/__tests__/registry.test.ts

@@ -101,6 +101,46 @@ describe("getAllQueryHandlers", () => {
   });
 });
 
+describe("getAllStreamHandlers", () => {
+  test("returns every registered stream handler, qualified, across multiple features", () => {
+    const aiFeature = defineFeature("registry-test-ai", (r) => {
+      r.streamHandler("chat:complete", z.object({ prompt: z.string() }), async function* () {}, {
+        access: { openToAll: true },
+      });
+    });
+    const otherFeature = defineFeature("registry-test-other", (r) => {
+      r.streamHandler("chat:complete", z.object({ prompt: z.string() }), async function* () {}, {
+        access: { openToAll: true },
+      });
+    });
+
+    const registry = createRegistry([aiFeature, otherFeature]);
+    const handlers = registry.getAllStreamHandlers();
+
+    expect(handlers.get("registry-test-ai:stream:chat:complete")).toBeDefined();
+    expect(handlers.get("registry-test-other:stream:chat:complete")).toBeDefined();
+    // Same Map instance getStreamHandler reads from, not a copy that can drift.
+    expect(handlers.get("registry-test-ai:stream:chat:complete")).toBe(
+      registry.getStreamHandler("registry-test-ai:stream:chat:complete"),
+    );
+  });
+
+  test("empty registry returns an empty map, not undefined", () => {
+    const registry = createRegistry([]);
+    expect(registry.getAllStreamHandlers().size).toBe(0);
+  });
+
+  test("duplicate stream-handler short-name across features qualifies independently, no collision", () => {
+    const aiFeature = defineFeature("registry-test-dup-a", (r) => {
+      r.streamHandler("chat:complete", z.object({}), async function* () {});
+    });
+    const otherFeature = defineFeature("registry-test-dup-b", (r) => {
+      r.streamHandler("chat:complete", z.object({}), async function* () {});
+    });
+    expect(() => createRegistry([aiFeature, otherFeature])).not.toThrow();
+  });
+});
+
 describe("extensionSelector boot-validation", () => {
   function foundationFeature() {
     return defineFeature("probe-foundation", (r) => {

package/src/engine/__tests__/tier-resolver-extension.test.ts

@@ -5,7 +5,11 @@
 
 import { describe, expect, test } from "bun:test";
 import { createEntity, defineFeature } from "../index";
-import { findTierResolverUsage, TENANT_TIER_RESOLVER_EXT } from "../tier-resolver-extension";
+import {
+  findTierResolverUsage,
+  isTierResolverPlugin,
+  TENANT_TIER_RESOLVER_EXT,
+} from "../tier-resolver-extension";
 
 function tierResolverFeature(name: string) {
   return defineFeature(name, (r) => {
@@ -49,3 +53,17 @@ describe("findTierResolverUsage", () => {
     expect(findTierResolverUsage([])).toBeUndefined();
   });
 });
+
+describe("isTierResolverPlugin", () => {
+  test("true when build is a function", () => {
+    expect(isTierResolverPlugin({ build: async () => new Set() })).toBe(true);
+  });
+
+  test("false for null, non-objects, and missing/non-fn build", () => {
+    expect(isTierResolverPlugin(null)).toBe(false);
+    expect(isTierResolverPlugin(undefined)).toBe(false);
+    expect(isTierResolverPlugin("x")).toBe(false);
+    expect(isTierResolverPlugin({})).toBe(false);
+    expect(isTierResolverPlugin({ build: 1 })).toBe(false);
+  });
+});

package/src/engine/boot-validator/entity-handler.ts

@@ -119,11 +119,20 @@ export function validateHandlerAccess(feature: FeatureDefinition): void {
     }
     validateAnonymousRateLimit(feature.name, "query", name, handler.access, handler.rateLimit);
   }
+  for (const [name, handler] of Object.entries(feature.streamHandlers)) {
+    if (!handler.access) {
+      throw new Error(
+        `Stream handler "${feature.name}:stream:${name}" is missing an access rule. ` +
+          `Set { roles: [...] } for role-based access, or { openToAll: true } for any authenticated user.`,
+      );
+    }
+    validateAnonymousRateLimit(feature.name, "stream", name, handler.access, handler.rateLimit);
+  }
 }
 
 export function validateAnonymousRateLimit(
   featureName: string,
-  kind: "write" | "query",
+  kind: "write" | "query" | "stream",
   handlerName: string,
   access: NonNullable<FeatureDefinition["writeHandlers"][string]["access"]>,
   rateLimit: FeatureDefinition["writeHandlers"][string]["rateLimit"],

package/src/engine/define-feature.ts

@@ -106,6 +106,7 @@ export function defineFeature<const TName extends string, TExports = undefined>(
     relations: state.relations,
     writeHandlers: state.writeHandlers,
     queryHandlers: state.queryHandlers,
+    streamHandlers: state.streamHandlers,
     translations: state.translations,
     hooks: {
       validation: state.validationHooks,

package/src/engine/define-handler.ts

@@ -10,6 +10,7 @@ import type {
 
 export type {
   QueryHandlerDefinition,
+  StreamHandlerDefinition,
   WriteHandlerDefinition,
   WriteHandlerInput,
 } from "./types/define-handler";

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

@@ -78,6 +78,15 @@ defineFeature("todoList", (r) => {
     access: { openToAll: true },
   });
 
+  r.streamHandler({
+    name: "task:stream",
+    schema: z.object({ prompt: z.string() }),
+    handler: async function* (input, ctx) {
+      yield "token";
+    },
+    access: { roles: ["user"] },
+  });
+
   r.hook({
     type: "postSave",
     target: "task",
@@ -195,7 +204,7 @@ describe("Canonical Object-Form — parser akzeptiert + extrahiert", () => {
     expect(unknowns).toEqual([]);
   });
 
-  test("alle 28 Pattern-Kinds sind erfasst", () => {
+  test("alle Pattern-Kinds sind erfasst", () => {
     const kinds: ReadonlySet<string> = new Set(result.patterns.map((p) => p.kind));
     const expected = [
       // Static
@@ -219,6 +228,7 @@ describe("Canonical Object-Form — parser akzeptiert + extrahiert", () => {
       "screen",
       "writeHandler",
       "queryHandler",
+      "streamHandler",
       "hook",
       "job",
       "notification",