@cosmicdrift/kumiko-framework 0.14.0 → 0.15.0

package/src/db/tenant-db.ts

@@ -1,24 +1,29 @@
-import { and, type Column, eq, getTableName, or, type SQL } from "drizzle-orm";
+import {
+  asRawClient,
+  deleteMany as bunDeleteMany,
+  fetchOne as bunFetchOne,
+  insertOne as bunInsertOne,
+  selectMany as bunSelectMany,
+  updateMany as bunUpdateMany,
+  type SelectOptions,
+  type WhereObject,
+} from "../db/query";
 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";
 
-// biome-ignore lint/suspicious/noExplicitAny: Drizzle dynamic tables
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic tables — keys depend on user-defined schema.
 type Table = TableColumns<any>;
 
-// biome-ignore lint/suspicious/noExplicitAny: Drizzle column selection
-type ColumnSelection = Record<string, any>;
-
 /**
  * TenantDb scope modes:
  *
- * - "tenant" (default): SELECT/UPDATE/DELETE filtered by tenantId + reference data (tenantId=0).
+ * - "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 (e.g. write a
- *   cross-tenant row to a shared sentinel like SYSTEM_TENANT_ID).
+ *   INSERT uses tenantId as default but handler can override.
  *
  * Tables without a tenantId column are always unfiltered regardless of mode.
  */
@@ -29,143 +34,62 @@ export type TenantDb = {
   readonly mode: TenantDbMode;
   /**
    * Underlying DbRunner. Framework-internal use (event-store, migrations) —
-   * bypasses tenant-filter. Feature code should stick to the typed wrappers
-   * above so the automatic scoping stays intact.
+   * bypasses tenant-filter. Feature code uses the typed helpers above so the
+   * automatic scoping stays intact.
    */
   readonly raw: DbRunner;
-  select(): TenantSelect;
-  select(columns: ColumnSelection): TenantSelect;
-  insert(table: Table): TenantInsert;
-  update(table: Table): TenantUpdate;
-  delete(table: Table): TenantDelete;
-};
-
-type TenantSelect = {
-  from(table: Table): TenantSelectQuery;
-};
-
-type WhereCondition = SQL | undefined;
-
-type RowLockStrength = "update" | "no key update" | "share" | "key share";
-
-type TenantSelectQuery = PromiseLike<Record<string, unknown>[]> & {
-  where(condition: WhereCondition): TenantSelectQuery;
-  limit(n: number): TenantSelectQuery;
-  offset(n: number): TenantSelectQuery;
-  orderBy(...columns: (SQL | Column)[]): TenantSelectQuery;
-  /** Row-level locking (FOR UPDATE / FOR SHARE). Must be called inside a tx. */
-  for(strength: RowLockStrength): TenantSelectQuery;
-};
-
-type TenantInsert = {
-  values(data: Record<string, unknown>): TenantInsertValues;
-};
-
-type ConflictTarget = Column | readonly Column[];
-type ConflictUpdate = {
-  target: ConflictTarget;
-  set: Record<string, unknown>;
-};
-
-type TenantInsertValues = PromiseLike<void> & {
-  returning(): PromiseLike<Record<string, unknown>[]>;
-  onConflictDoUpdate(spec: ConflictUpdate): PromiseLike<void>;
-  onConflictDoNothing(spec?: { target: ConflictTarget }): PromiseLike<void>;
-};
-
-type TenantUpdate = {
-  set(data: Record<string, unknown>): TenantUpdateSet;
-};
-
-type TenantUpdateSet = PromiseLike<void> & {
-  where(condition: WhereCondition): TenantUpdateWhere;
-  returning(): PromiseLike<Record<string, unknown>[]>;
-};
-
-type TenantUpdateWhere = PromiseLike<void> & {
-  returning(): PromiseLike<Record<string, unknown>[]>;
-};
-
-type TenantDelete = {
-  where(condition: WhereCondition): PromiseLike<void>;
+  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: Table,
+    values: Record<string, unknown>,
+  ): Promise<T | undefined>;
+  updateMany<T = Record<string, unknown>>(
+    table: Table,
+    set: Record<string, unknown>,
+    where: WhereObject,
+  ): Promise<readonly T[]>;
+  deleteMany(table: Table, where: WhereObject): Promise<void>;
 };
 
-/**
- * Cast helper for the `Record<string, unknown>[]` rows that
- * `TenantDb.select()` returns.
- *
- * Usage:
- *   const rows = castTenantRows<MyRow>(
- *     await ctx.db.select({...}).from(myTable),
- *   );
- *
- * Why this exists: drizzle's `.select({col1: t.col1, ...})` natively
- * returns `Array<{col1: T1, ...}>`, but our TenantDb wrapper erases
- * that shape to `Record<string, unknown>[]` so it can centralize tenant-
- * scoping. Until the wrapper preserves the typed-row shape (see memory:
- * project_tenant_db_typed_rows), call sites need to assert the column
- * shape they just selected. This helper:
- *   - centralises the cast (single grep target for the future refactor)
- *   - tags it with `@cast-boundary tenant-db-row` for the as-cast audit
- *   - documents the trade-off once instead of N times
- *
- * Removal plan: when TenantSelectQuery becomes generic over the
- * column-shape, every `castTenantRows<T>(...)` call is just `await ...`
- * and this helper goes away.
- */
 // @cast-boundary tenant-db-row
 export function castTenantRows<T>(rows: readonly Record<string, unknown>[]): readonly T[] {
   return rows as unknown as readonly T[];
 }
 
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+
+function tableNameOf(table: Table): string {
+  const sym = (table as unknown as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  return typeof sym === "string" ? sym : "<unknown>";
+}
+
+function hasTenantColumn(table: Table): boolean {
+  return (table as Record<string, unknown>)["tenantId"] !== undefined;
+}
+
 export function createTenantDb(
   db: DbRunner,
   tenantId: TenantId,
   mode: TenantDbMode = "tenant",
   tracer?: Tracer,
   meter?: Meter,
-  // Pre-flight cancellation: when set, every query check
-  // `signal.throwIfAborted()` BEFORE issuing the SQL. The currently
-  // running query is not actively cancelled (postgres-js connection
-  // cancel is a separate, riskier feature). This still saves the bulk
-  // of the wasted work in handlers that fire many sequential queries
-  // — once the client disconnects, the next query throws and the rest
-  // of the chain falls away.
   signal?: AbortSignal,
 ): TenantDb {
-  // If a meter was passed, make sure standard metrics are registered on it
-  // before we try to emit. Idempotent — buildServer typically registers them
-  // up front; this guards against test call-sites that wire up a TenantDb
-  // directly with a fresh meter.
   if (meter) registerStandardMetrics(meter);
 
-  function hasTenantColumn(table: Table): boolean {
-    return table["tenantId"] !== undefined;
-  }
-
-  // Drizzle's terminal builders (insert, update().where, delete().where) are
-  // thenable — `.then` is there so `await` works — but the declared return
-  // types don't include PromiseLike. Cast via this helper so the double-
-  // cast is named and lives in exactly one place per scope.
-  function asDrizzleThenable<T>(builder: unknown): PromiseLike<T> {
-    return builder as PromiseLike<T>; // @cast-boundary engine-bridge
-  }
-
-  // Wrap a DB query promise in a `db.query` span + emit the DB duration
-  // histogram. Row count is recorded when the result is an array (SELECTs
-  // + *.returning()). Metric is emitted both on success and on throw so
-  // slow failing queries show up too.
   function withDbSpan<T>(
     operation: "select" | "insert" | "update" | "delete",
     table: Table,
-    exec: () => PromiseLike<T>,
-  ): PromiseLike<T> {
-    // Pre-flight cancellation. Sits above the early-return so the check
-    // fires regardless of observability config — cancellation is a
-    // correctness feature, not an observability one.
+    runner: () => Promise<T>,
+  ): Promise<T> {
     signal?.throwIfAborted();
-    if (!tracer && !meter) return exec();
-    const tableName = getTableName(table);
+    if (!tracer && !meter) return runner();
+    const tableName = tableNameOf(table);
     const start = performance.now();
     const emitMetric = () => {
       if (meter) {
@@ -174,10 +98,9 @@ export function createTenantDb(
     };
 
     if (!tracer) {
-      // Tracer absent but meter present: just time + emit, no span.
       return (async () => {
         try {
-          return await exec();
+          return await runner();
         } finally {
           emitMetric();
         }
@@ -196,7 +119,7 @@ export function createTenantDb(
       },
       async (span) => {
         try {
-          const result = await exec();
+          const result = await runner();
           if (Array.isArray(result)) {
             span.setAttribute("db.row_count", result.length);
           }
@@ -208,227 +131,83 @@ export function createTenantDb(
     );
   }
 
-  // --- Read filter (SELECT WHERE clause) ---
-  //
-  // Reads in tenant mode see their own rows AND global reference data (rows
-  // with tenantId = SYSTEM_TENANT_ID). Writes explicitly do NOT — see writeFilter.
-
-  function readFilter(table: Table, ...extra: SQL[]): SQL | undefined {
-    if (!hasTenantColumn(table)) {
-      return extra.length > 0 ? and(...extra) : undefined;
-    }
-
-    if (mode === "system") {
-      // System mode: no tenant restriction, only pass through extra conditions
-      return extra.length > 0 ? and(...extra) : undefined;
-    }
-
-    // Tenant mode: own data + reference data (zero-UUID tenantId for global rows).
-    // Drizzle's `or()` is typed `SQL | undefined` (variadic-empty case); both
-    // `eq()` args always produce SQL, so the cast documents that assumption.
-    const ownOrGlobal = or(
-      eq(table["tenantId"], tenantId),
-      eq(table["tenantId"], SYSTEM_TENANT_ID),
-    ) as SQL; // @cast-boundary db-operator
-    return extra.length > 0 ? and(ownOrGlobal, ...extra) : ownOrGlobal;
+  // Reads see own-tenant rows + reference data (tenantId === SYSTEM_TENANT_ID).
+  // Writes never touch reference rows — those are system-mode only.
+  function readWhere(table: Table, where?: WhereObject): WhereObject | undefined {
+    if (!hasTenantColumn(table) || mode === "system") return where;
+    const tenantFilter: WhereObject = { tenantId: [tenantId, SYSTEM_TENANT_ID] };
+    return where ? { ...tenantFilter, ...where } : tenantFilter;
   }
 
-  // --- Write filter (UPDATE/DELETE WHERE clause) ---
-  //
-  // Writes in tenant mode must NEVER match reference rows — otherwise a tenant
-  // could mutate global data by coincidence of id/condition. Only system-scope
-  // (r.systemScope()) may modify reference data.
-
-  function writeFilter(table: Table, ...extra: SQL[]): SQL | undefined {
-    if (!hasTenantColumn(table)) {
-      return extra.length > 0 ? and(...extra) : undefined;
-    }
-
-    if (mode === "system") {
-      return extra.length > 0 ? and(...extra) : undefined;
-    }
-
-    const ownOnly = eq(table["tenantId"], tenantId);
-    return extra.length > 0 ? and(ownOnly, ...extra) : ownOnly;
+  function writeWhere(table: Table, where: WhereObject): WhereObject {
+    if (!hasTenantColumn(table) || mode === "system") return where;
+    return { tenantId, ...where };
   }
 
-  // --- Write values (INSERT tenantId handling) ---
-
   function insertValues(table: Table, data: Record<string, unknown>): Record<string, unknown> {
     if (!hasTenantColumn(table)) return data;
-
-    if (mode === "system") {
-      // System mode: tenantId is a default the handler can override —
-      // e.g. to write a cross-tenant row under SYSTEM_TENANT_ID, or to
-      // target a foreign tenant's projection from a SystemAdmin action.
-      return { tenantId, ...data };
-    }
-
-    // Tenant mode: tenantId is forced, handler cannot override
+    if (mode === "system") return { tenantId, ...data };
     return { ...data, tenantId };
   }
 
-  // --- Select wrapper (lazy filter + chainable) ---
-
-  function wrapSelect(
-    // biome-ignore lint/suspicious/noExplicitAny: Drizzle internal query type
-    query: any,
-    table: Table,
-    filtered: boolean,
-  ): TenantSelectQuery {
-    function ensureFiltered() {
-      if (filtered) return query;
-      const filter = readFilter(table);
-      return filter ? query.where(filter) : query;
-    }
-
-    return {
-      where(condition: SQL) {
-        const filter = readFilter(table, condition);
-        return wrapSelect(filter ? query.where(filter) : query.where(condition), table, true);
-      },
-      limit(n: number) {
-        return wrapSelect(ensureFiltered().limit(n), table, true);
-      },
-      offset(n: number) {
-        return wrapSelect(ensureFiltered().offset(n), table, true);
-      },
-      orderBy(...columns: SQL[]) {
-        return wrapSelect(ensureFiltered().orderBy(...columns), table, true);
-      },
-      for(strength: RowLockStrength) {
-        return wrapSelect(ensureFiltered().for(strength), table, true);
-      },
-      // biome-ignore lint/suspicious/noThenProperty: thenable for await
-      then(
-        resolve: ((value: Record<string, unknown>[]) => void) | null,
-        reject: ((reason: unknown) => void) | null,
-      ) {
-        return withDbSpan<Record<string, unknown>[]>("select", table, () => ensureFiltered()).then(
-          (rows) => resolve?.(rows),
-          reject ?? undefined,
-        );
-      },
-    } as TenantSelectQuery; // @cast-boundary drizzle-bridge
-  }
-
-  // --- Where helper for update/delete ---
-
-  function whereClause(table: Table, condition: SQL): SQL {
-    const filter = writeFilter(table, condition);
-    return filter ?? condition;
-  }
-
   return {
     tenantId,
     mode,
     raw: db,
 
-    select(columns?: ColumnSelection) {
-      return {
-        from(table: Table) {
-          const baseQuery = columns ? db.select(columns).from(table) : db.select().from(table);
-          return wrapSelect(baseQuery, table, false);
-        },
-      };
+    selectMany<T = Record<string, unknown>>(
+      table: Table,
+      where?: WhereObject,
+      options?: SelectOptions,
+    ): Promise<readonly T[]> {
+      const filter = readWhere(table, where);
+      return withDbSpan("select", table, async () => bunSelectMany<T>(db, table, filter, options));
     },
 
-    insert(table: Table) {
-      return {
-        values(data: Record<string, unknown>) {
-          const q = db.insert(table).values(insertValues(table, data));
-          return {
-            returning() {
-              return withDbSpan<Record<string, unknown>[]>(
-                "insert",
-                table,
-                () => q.returning() as PromiseLike<Record<string, unknown>[]>, // @cast-boundary db-runner
-              );
-            },
-            onConflictDoUpdate(spec: ConflictUpdate) {
-              return withDbSpan<void>("insert", table, () =>
-                (
-                  q as unknown as {
-                    onConflictDoUpdate: (s: ConflictUpdate) => PromiseLike<void>;
-                  }
-                ).onConflictDoUpdate(spec),
-              );
-            },
-            onConflictDoNothing(spec?: { target: ConflictTarget }) {
-              return withDbSpan<void>("insert", table, () =>
-                (
-                  q as unknown as {
-                    onConflictDoNothing: (s?: { target: ConflictTarget }) => PromiseLike<void>;
-                  }
-                ).onConflictDoNothing(spec),
-              );
-            },
-            // biome-ignore lint/suspicious/noThenProperty: thenable for await
-            then(resolve, reject) {
-              return withDbSpan<void>("insert", table, () => asDrizzleThenable<void>(q)).then(
-                resolve,
-                reject,
-              );
-            },
-          } as TenantInsertValues; // @cast-boundary drizzle-bridge
-        },
-      };
+    fetchOne<T = Record<string, unknown>>(
+      table: Table,
+      where: WhereObject,
+    ): Promise<T | undefined> {
+      const filter = readWhere(table, where) ?? {};
+      return withDbSpan("select", table, async () => bunFetchOne<T>(db, table, filter));
     },
 
-    update(table: Table) {
-      return {
-        set(data: Record<string, unknown>) {
-          const q = db.update(table).set(data);
-          return {
-            where(condition: SQL) {
-              const wq = q.where(whereClause(table, condition));
-              return {
-                returning() {
-                  return withDbSpan<Record<string, unknown>[]>(
-                    "update",
-                    table,
-                    () => wq.returning() as PromiseLike<Record<string, unknown>[]>, // @cast-boundary db-runner
-                  );
-                },
-                // biome-ignore lint/suspicious/noThenProperty: thenable for await
-                then(resolve, reject) {
-                  return withDbSpan<void>("update", table, () => asDrizzleThenable<void>(wq)).then(
-                    resolve,
-                    reject,
-                  );
-                },
-              } as TenantUpdateWhere; // @cast-boundary drizzle-bridge
-            },
-            returning(): PromiseLike<Record<string, unknown>[]> {
-              return Promise.reject(
-                new Error(
-                  "TenantDb.update().set().returning() without .where() would mass-update all tenant rows. " +
-                    "Add .where(...) first, or call .set(...).where(...).returning().",
-                ),
-              );
-            },
-            // biome-ignore lint/suspicious/noThenProperty: thenable for await
-            then(resolve, reject) {
-              return Promise.reject(
-                new Error(
-                  "TenantDb.update().set() awaited without .where() would mass-update all tenant rows. " +
-                    "Add .where(...) before awaiting.",
-                ),
-              ).then(resolve, reject);
-            },
-          } as TenantUpdateSet; // @cast-boundary drizzle-bridge
-        },
-      };
+    insertOne<T = Record<string, unknown>>(
+      table: Table,
+      values: Record<string, unknown>,
+    ): Promise<T | undefined> {
+      const data = insertValues(table, values);
+      return withDbSpan("insert", table, async () => bunInsertOne<T>(db, table, data));
     },
 
-    delete(table: Table) {
-      return {
-        where(condition: SQL) {
-          return withDbSpan<void>("delete", table, () =>
-            asDrizzleThenable<void>(db.delete(table).where(whereClause(table, condition))),
-          );
-        },
-      };
+    updateMany<T = Record<string, unknown>>(
+      table: Table,
+      set: Record<string, unknown>,
+      where: WhereObject,
+    ): Promise<readonly T[]> {
+      if (!where || Object.keys(where).length === 0) {
+        return Promise.reject(
+          new Error(
+            "TenantDb.updateMany without where would mass-update all tenant rows. Pass at least one where condition.",
+          ),
+        );
+      }
+      const filter = writeWhere(table, where);
+      return withDbSpan("update", table, async () => bunUpdateMany<T>(db, table, set, filter));
+    },
+
+    deleteMany(table: Table, where: WhereObject): Promise<void> {
+      if (!where || Object.keys(where).length === 0) {
+        return Promise.reject(
+          new Error(
+            "TenantDb.deleteMany without where would mass-delete all tenant rows. Pass at least one where condition.",
+          ),
+        );
+      }
+      const filter = writeWhere(table, where);
+      return withDbSpan("delete", table, async () => bunDeleteMany(db, table, filter));
     },
   };
 }
+
+export { asRawClient };

package/src/engine/__tests__/auth-claims-registrar.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createRegistry, defineFeature } from "../index";
 
 describe("r.authClaims() — registrar collection", () => {

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

@@ -9,15 +9,15 @@
 // Soft-Warning (console.warn):
 //   - Feature ruft eigene exposesApi via usesApi (Refactor-Leftover)
 
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
 
 describe("validateBoot — r.exposesApi / r.usesApi", () => {
-  let warnSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof spyOn>;
 
   beforeEach(() => {
-    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
   });
 
   afterEach(() => {

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

@@ -4,7 +4,7 @@
 // in derselben Entity referenzieren. Sonst silent data loss — wir wollen
 // fail-fast beim Boot.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
 import { createEntity, createTimestampField, createTzField, locatedTimestamp } from "../factories";

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

@@ -14,7 +14,7 @@
 //
 // allowPlaintext-Marker unterdrückt Heuristik-Warnings.
 
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { z } from "zod";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
@@ -48,10 +48,10 @@ function stubListHandler(r: any, entityName: string): void {
 }
 
 describe("validateBoot — PII annotations", () => {
-  let warnSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof spyOn>;
 
   beforeEach(() => {
-    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -428,10 +428,10 @@ describe("validateBoot — PII annotations", () => {
 });
 
 describe("validateBoot — retention", () => {
-  let warnSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof spyOn>;
 
   beforeEach(() => {
-    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
   });
 
   afterEach(() => {

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

@@ -13,7 +13,7 @@
 //                        + retention.blockDelete + anonymize-Funktion
 //                        + handler-access mit ROLES.TenantAdmin
 
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { z } from "zod";
 import { ROLES } from "../../auth";
 import { validateBoot } from "../boot-validator";
@@ -27,10 +27,10 @@ import {
 } from "../index";
 
 describe("S0 Integration — full surface stack", () => {
-  let warnSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof spyOn>;
 
   beforeEach(() => {
-    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
   });
 
   afterEach(() => {

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

@@ -1,6 +1,7 @@
-import { pgTable, text } from "drizzle-orm/pg-core";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { z } from "zod";
+import type { SchemaTable } from "../../db/dialect";
+import { table, text } from "../../db/dialect";
 import { validateBoot } from "../boot-validator";
 import { createSystemConfig, createTenantConfig } from "../config-helpers";
 import {
@@ -904,7 +905,7 @@ describe("boot-validator", () => {
   // --- MultiStreamProjection delivery invariant (Welle 2.7) ---
 
   describe("MultiStreamProjection delivery", () => {
-    const sinkTable = pgTable("sink", { id: text("id").primaryKey() });
+    const sinkTable = table("sink", { id: text("id").primaryKey() }) as unknown as SchemaTable;
 
     test("rejects delivery='per-instance' combined with a backing table", () => {
       const features = [

package/src/engine/__tests__/build-app-schema.test.ts

@@ -7,7 +7,7 @@
 //      projection-Schritt rausgefiltert — sonst landet Server-Runtime
 //      im Browser-Bundle.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { buildAppSchema } from "../build-app-schema";
 import { defineFeature } from "../define-feature";
 import { createRegistry } from "../registry";

package/src/engine/__tests__/build-target.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { buildTarget, type TreeActionDef } from "../index";
 
 // createTreeActionsStub — Test-Helper für Phase-0-Stub-Features. Das

package/src/engine/__tests__/claim-keys.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createRegistry, defineFeature, readClaim } from "../index";
 import type { ClaimKeyHandle, SessionUser } from "../types";