@cosmicdrift/kumiko-framework 0.159.1 → 0.161.0

package/src/db/event-store-executor.ts

@@ -1,19 +1,14 @@
+import type { EventStoreExecutor } from "@cosmicdrift/kumiko-types/event-store-executor-types";
 import type { LocalKeyKmsAdapter } from "../crypto";
-import type {
-  DeleteContext,
-  EntityDefinition,
-  EntityId,
-  SaveContext,
-  SessionUser,
-  WriteResult,
-} from "../engine/types";
+import type { EntityDefinition } from "../engine/types";
 import type { EntityCache } from "../pipeline/entity-cache";
 import type { SearchAdapter } from "../search/types";
 import type { EnvelopeCipher } from "../secrets/envelope-cipher";
 import { buildExecutorContext, type Table } from "./event-store-executor-context";
 import { createReadVerbs } from "./event-store-executor-read";
 import { createWriteVerbs } from "./event-store-executor-write";
-import type { CursorResult } from "./index";
+
+export type { EventStoreExecutor } from "@cosmicdrift/kumiko-types/event-store-executor-types";
 
 // The executor writes events + auto-projection (entity table) in one TX.
 // It no longer knows about user projections — those are driven by the
@@ -42,93 +37,6 @@ export type EventStoreExecutorOptions = {
   kms?: LocalKeyKmsAdapter;
 };
 
-export type EventStoreExecutor = {
-  create: (
-    payload: Record<string, unknown>,
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-  ) => Promise<WriteResult<SaveContext>>;
-
-  update: (
-    payload: { id: EntityId; version?: number | undefined; changes: Record<string, unknown> },
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-    options?: { skipOptimisticLock?: boolean; skipUnchanged?: boolean },
-  ) => Promise<WriteResult<SaveContext>>;
-
-  delete: (
-    payload: { id: EntityId },
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-  ) => Promise<WriteResult<DeleteContext>>;
-
-  // Hard-purge (Art. 17 erasure). Like delete, but emits `<entity>.forgotten`
-  // which hard-deletes the row even for softDelete entities — and, being an
-  // auto-verb replayed by the implicit projection, the erasure survives a
-  // rebuild (created → forgotten → row gone). Reaches soft-deleted rows too.
-  forget: (
-    payload: { id: EntityId },
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-  ) => Promise<WriteResult<DeleteContext>>;
-
-  restore: (
-    payload: { id: EntityId },
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-  ) => Promise<WriteResult<SaveContext>>;
-
-  list: (
-    payload: {
-      cursor?: string | undefined;
-      limit?: number | undefined;
-      search?: string | undefined;
-      sort?: string | undefined;
-      sortDirection?: "asc" | "desc" | undefined;
-      offset?: number | undefined;
-      totalCount?: boolean | undefined;
-      filter?:
-        | {
-            readonly field: string;
-            readonly op: "eq" | "ne" | "lt" | "gt" | "in";
-            readonly value: unknown;
-          }
-        | undefined;
-      // User-gewählte Faceted-Filter (dynamisch, additiv zum statischen
-      // `filter`). Alle werden mit AND verknüpft.
-      filters?:
-        | ReadonlyArray<{
-            readonly field: string;
-            readonly op: "eq" | "ne" | "lt" | "gt" | "in";
-            readonly value: unknown;
-          }>
-        | undefined;
-    },
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-    /** Tier 2.7e Audit-Fix: per-Call SearchAdapter Override. Wenn der
-     *  Executor beim Build keinen SearchAdapter via Options bekommen
-     *  hat (defaultEntityQueryHandler-Pfad), kann der Caller (Handler)
-     *  hier zur Runtime einen aus ctx.searchAdapter durchreichen.
-     *  options.searchAdapter (build-time) gewinnt — runtime-Override
-     *  ist Fallback für die default-Wrapper. */
-    runtimeOptions?: {
-      readonly searchAdapter?: SearchAdapter;
-      // Trash query: skip the implicit `isDeleted = FALSE` filter so soft-
-      // deleted rows are returned too. Tenant + ownership clauses still apply
-      // — includeDeleted only relaxes the soft-delete predicate, never the
-      // visibility ones, so it can ride untrusted query input safely.
-      readonly includeDeleted?: boolean;
-    },
-  ) => Promise<CursorResult<Record<string, unknown>>>;
-
-  detail: (
-    payload: { id: EntityId },
-    user: SessionUser,
-    db: import("./tenant-db").TenantDb,
-  ) => Promise<Record<string, unknown> | null>;
-};
-
 export function createEventStoreExecutor(
   table: Table,
   entity: EntityDefinition,

package/src/db/table-builder.ts

@@ -1,3 +1,4 @@
+import type { ExecutorOnly } from "@cosmicdrift/kumiko-types/executor-brand";
 import type {
   EntityDefinition,
   EntityRelations,
@@ -382,25 +383,7 @@ type SoftDeleteColumnsType = {
 };
 
 // ── ES-write brand ──────────────────────────────────────────────────────
-// A managed projection is only writable through the executor (event →
-// rebuild-safe). To make a direct write a *compile* error rather than a
-// convention, EntityTable carries a phantom `unique symbol` prop; the public
-// write helpers reject anything that has it (see NotExecutorOnly + query.ts).
-// The symbol key dodges SchemaTable's `[field: string]: unknown` index
-// signature (string index sigs don't cover symbol keys), so the brand
-// survives the type-erasure that would swallow a plain marker prop — and the
-// executor seam (applyEntityEvent) erases `table` to TableColumns<any>, which
-// carries no such prop, so the one legitimate writer stays green.
-declare const EXECUTOR_ONLY: unique symbol;
-export interface ExecutorOnly {
-  readonly [EXECUTOR_ONLY]: true;
-}
-// Negative brand for write-helper params: a branded EntityTable is NOT
-// assignable (its `true` clashes with `never`), while unmanaged EntityTableMeta
-// and erased SchemaTable pass (they lack the prop, so `?: never` is satisfied).
-export type NotExecutorOnly = {
-  readonly [EXECUTOR_ONLY]?: never;
-};
+export type { ExecutorOnly, NotExecutorOnly } from "@cosmicdrift/kumiko-types/executor-brand";
 
 export type EntityTable<E extends EntityDefinition = EntityDefinition> =
   TableColumns<// biome-ignore lint/suspicious/noExplicitAny: drizzle's internal table-config stays generic; we layer typed columns on top via the intersection below.

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);
+  });
+});