@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/jobs/__tests__/{jobs.integration.ts → jobs.integration.test.ts}

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { requestContext } from "../../api/request-context";
 import { createRegistry, defineFeature } from "../../engine";
 import type { AppContext, Registry } from "../../engine/types";
@@ -192,7 +192,7 @@ describe("scenario 2: scheduled job", () => {
 
   // BullMQ's repeatable scheduler needs a second or two to register its
   // first tick — a generous delay schedule covers the startup window.
-  test("cron job fires via BullMQ scheduler", { timeout: 15_000 }, async () => {
+  test("cron job fires via BullMQ scheduler", async () => {
     clearLog();
     await withRunner(async () => {
       await waitFor(
@@ -278,7 +278,7 @@ describe("concurrency: skip", () => {
 });
 
 describe("concurrency: sequential", () => {
-  test("same-name dispatches run strictly one after the other", { timeout: 15_000 }, async () => {
+  test("same-name dispatches run strictly one after the other", async () => {
     clearLog();
     await withRunner(async (runner) => {
       // Three rapid dispatches. Parallel mode would land all entries
@@ -318,7 +318,7 @@ describe("concurrency: sequential", () => {
     });
   });
 
-  test("lock is released even when the handler throws", { timeout: 10_000 }, async () => {
+  test("lock is released even when the handler throws", async () => {
     clearLog();
     await withRunner(async (runner) => {
       // First dispatch fails. If the finally-path didn't release the lock,
@@ -355,9 +355,7 @@ describe("concurrency: sequential", () => {
     });
   });
 
-  test("lock release is value-matched: foreign tokens survive expiration races", {
-    timeout: 5_000,
-  }, async () => {
+  test("lock release is value-matched: foreign tokens survive expiration races", async () => {
     // Pin the contract that distributed-lock's release script enforces:
     // a release call from a worker whose token has already expired and
     // been claimed by someone else must NOT delete the new owner's lock.

package/src/lifecycle/__tests__/{lifecycle-server.integration.ts → lifecycle-server.integration.test.ts}

@@ -1,7 +1,7 @@
 // Full-stack proof for lifecycle ↔ buildServer wiring.
 // Drives drain() directly — SIGTERM plumbing has its own unit test.
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { defineFeature } from "../../engine";
 import { setupTestStack, type TestStack } from "../../stack";
 import { sharedWidgetEntity } from "../../testing";

package/src/lifecycle/__tests__/lifecycle.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { createLifecycle } from "../lifecycle";
 
 describe("lifecycle — state machine", () => {
@@ -20,7 +20,7 @@ describe("lifecycle — state machine", () => {
 
   test("markReady from 'ready' is a no-op", () => {
     const lc = createLifecycle({ startReady: true });
-    const listener = vi.fn();
+    const listener = mock();
     lc.onStateChange(listener);
     lc.markReady();
     expect(listener).not.toHaveBeenCalled();
@@ -70,7 +70,7 @@ describe("lifecycle — shutdown hooks", () => {
   });
 
   test("one failing hook does not block the others, and the error is logged", async () => {
-    const logger = { error: vi.fn() };
+    const logger = { error: mock() };
     const lc = createLifecycle({ startReady: true, logger });
     const calls: string[] = [];
     lc.registerShutdownHook("healthy-a", async () => {
@@ -171,7 +171,7 @@ describe("lifecycle — onStateChange", () => {
 
   test("unsubscribe stops further callbacks", () => {
     const lc = createLifecycle();
-    const cb = vi.fn();
+    const cb = mock();
     const unsubscribe = lc.onStateChange(cb);
     lc.markReady();
     expect(cb).toHaveBeenCalledTimes(1);
@@ -184,9 +184,9 @@ describe("lifecycle — onStateChange", () => {
   });
 
   test("broken listener does not break others, and the error is logged", () => {
-    const logger = { error: vi.fn() };
+    const logger = { error: mock() };
     const lc = createLifecycle({ logger });
-    const healthy = vi.fn();
+    const healthy = mock();
     lc.onStateChange(() => {
       throw new Error("subscriber exploded");
     });

package/src/lifecycle/__tests__/signal-handlers.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { createLifecycle } from "../lifecycle";
 import { attachSignalHandlers } from "../signal-handlers";
 import { createTestLifecycle } from "./create-test-lifecycle";
@@ -6,7 +6,7 @@ import { createTestLifecycle } from "./create-test-lifecycle";
 describe("attachSignalHandlers", () => {
   test("SIGTERM triggers drain and calls exit(0)", async () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     const hookCalls: string[] = [];
     lc.registerShutdownHook("spy", async (signal) => {
       hookCalls.push(signal);
@@ -25,7 +25,7 @@ describe("attachSignalHandlers", () => {
 
   test("SIGINT path drains with the right signal label", async () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     const seen: string[] = [];
     lc.registerShutdownHook("spy", async (signal) => {
       seen.push(signal);
@@ -44,7 +44,7 @@ describe("attachSignalHandlers", () => {
 
   test("multiple SIGTERMs still call exit exactly once", async () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     // Slow hook so we can fire additional signals while drain is in-flight.
     lc.registerShutdownHook("slow", async () => {
       await new Promise((r) => setTimeout(r, 30));
@@ -74,7 +74,7 @@ describe("attachSignalHandlers", () => {
         throw new Error("drain itself exploded");
       },
     });
-    const exit = vi.fn();
+    const exit = mock();
     const handle = attachSignalHandlers(brokenLifecycle, { exit, signals: ["SIGTERM"] });
     try {
       process.emit("SIGTERM");
@@ -87,7 +87,7 @@ describe("attachSignalHandlers", () => {
 
   test("detach() removes the process listeners", () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     const before = process.listenerCount("SIGTERM");
     const handle = attachSignalHandlers(lc, { exit, signals: ["SIGTERM"] });
     expect(process.listenerCount("SIGTERM")).toBe(before + 1);

package/src/logging/__tests__/pino-trace-bridge.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { createConsoleProvider } from "../../observability";
 import { mergeTraceFields } from "../pino-logger";
 

package/src/migrations/__tests__/compare-snapshots.test.ts

@@ -3,7 +3,7 @@
 // Projection-Tabelle muss der Detector die richtigen Tabellen-Namen
 // melden, damit migrate apply den richtigen Rebuild triggert.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { compareSnapshots } from "../projection-detection";
 import type { Snapshot, SnapshotTable } from "../schema-drift";
 

package/src/migrations/__tests__/{detect-drift.integration.ts → detect-drift.integration.test.ts}

@@ -4,18 +4,20 @@
 // hier blockiert Container-Starts; jeder False-Negative lässt
 // Schema-Drift unentdeckt durch.
 
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { sql } from "drizzle-orm";
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { createTestDb, type TestDb } from "../../stack";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { detectDrift } from "../schema-drift";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let migrationsDir: string;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
 });
 
@@ -82,8 +84,8 @@ function writeSnapshotSimple(idx: number, tableNames: string[]): void {
 }
 
 async function ensureDrizzleMigrationsTable(): Promise<void> {
-  await testDb.db.execute(sql`CREATE SCHEMA IF NOT EXISTS drizzle`);
-  await testDb.db.execute(sql`
+  await asRawClient(testDb.db).unsafe(`CREATE SCHEMA IF NOT EXISTS drizzle`);
+  await asRawClient(testDb.db).unsafe(`
     CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
       id serial PRIMARY KEY,
       hash text NOT NULL,
@@ -93,12 +95,13 @@ async function ensureDrizzleMigrationsTable(): Promise<void> {
 }
 
 async function dropDrizzleMigrationsTable(): Promise<void> {
-  await testDb.db.execute(sql`DROP TABLE IF EXISTS drizzle.__drizzle_migrations`);
+  await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drizzle.__drizzle_migrations`);
 }
 
 async function insertAppliedMigration(hash: string): Promise<void> {
-  await testDb.db.execute(
-    sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES (${hash}, ${Date.now()})`,
+  await asRawClient(testDb.db).unsafe(
+    `INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES ($1, $2)`,
+    [hash, Date.now()],
   );
 }
 
@@ -106,8 +109,8 @@ describe("detectDrift", () => {
   beforeEach(async () => {
     await dropDrizzleMigrationsTable();
     // Cleanup test tables that might still exist from earlier runs
-    await testDb.db.execute(sql`DROP TABLE IF EXISTS drift_test_users`);
-    await testDb.db.execute(sql`DROP TABLE IF EXISTS drift_test_orders`);
+    await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drift_test_users`);
+    await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drift_test_orders`);
   });
 
   test("frische DB ohne __drizzle_migrations + 1 Migration im Journal → 1 pending + table missing", async () => {
@@ -124,7 +127,7 @@ describe("detectDrift", () => {
   test("alle Migrations applied + alle Tabellen existieren → ok", async () => {
     writeJournal([{ idx: 0, tag: "0000_init" }]);
     writeSnapshotSimple(0, ["drift_test_users"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
     await ensureDrizzleMigrationsTable();
     await insertAppliedMigration("hash-0000");
 
@@ -140,8 +143,8 @@ describe("detectDrift", () => {
       { idx: 1, tag: "0001_add_orders" },
     ]);
     writeSnapshotSimple(1, ["drift_test_users", "drift_test_orders"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_orders (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_orders (id uuid PRIMARY KEY)`);
     await ensureDrizzleMigrationsTable();
     await insertAppliedMigration("hash-0000"); // nur eine applied
 
@@ -155,7 +158,7 @@ describe("detectDrift", () => {
   test("alle Migrations applied aber Tabelle fehlt manuell → drift", async () => {
     writeJournal([{ idx: 0, tag: "0000_init" }]);
     writeSnapshotSimple(0, ["drift_test_users", "drift_test_orders"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
     // drift_test_orders bewusst NICHT angelegt (simuliert manuellen DROP)
     await ensureDrizzleMigrationsTable();
     await insertAppliedMigration("hash-0000");
@@ -179,7 +182,9 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat email NULLABLE — drift.
-      await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY, email text)`);
+      await asRawClient(testDb.db).unsafe(
+        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, email text)`,
+      );
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
 
@@ -204,7 +209,7 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat KEINE email-Spalte.
-      await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+      await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
 
@@ -226,8 +231,8 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat zusätzliche Spalte (z.B. manueller ALTER TABLE in Prod).
-      await testDb.db.execute(
-        sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY, secret_legacy text)`,
+      await asRawClient(testDb.db).unsafe(
+        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, secret_legacy text)`,
       );
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
@@ -251,7 +256,9 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat age als TEXT statt INTEGER.
-      await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY, age text)`);
+      await asRawClient(testDb.db).unsafe(
+        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, age text)`,
+      );
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
 
@@ -278,7 +285,7 @@ describe("detectDrift", () => {
           },
         },
       ]);
-      await testDb.db.execute(sql`
+      await asRawClient(testDb.db).unsafe(`
         CREATE TABLE drift_test_users (
           id uuid PRIMARY KEY,
           email text NOT NULL,
@@ -297,10 +304,10 @@ describe("detectDrift", () => {
   test("public.__drizzle_migrations Fallback (Pre-0.20-Drizzle)", async () => {
     writeJournal([{ idx: 0, tag: "0000_init" }]);
     writeSnapshotSimple(0, ["drift_test_users"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
     // Legacy: Tabelle in public-Schema statt drizzle-Schema
     await dropDrizzleMigrationsTable();
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(`
       CREATE TABLE public.__drizzle_migrations (
         id serial PRIMARY KEY,
         hash text NOT NULL,
@@ -308,13 +315,14 @@ describe("detectDrift", () => {
       )
     `);
     try {
-      await testDb.db.execute(
-        sql`INSERT INTO public.__drizzle_migrations (hash, created_at) VALUES ('hash-0000', ${Date.now()})`,
+      await asRawClient(testDb.db).unsafe(
+        `INSERT INTO public.__drizzle_migrations (hash, created_at) VALUES ('hash-0000', $1)`,
+        [Date.now()],
       );
       const report = await detectDrift(testDb.db, migrationsDir);
       expect(report.ok).toBe(true);
     } finally {
-      await testDb.db.execute(sql`DROP TABLE public.__drizzle_migrations`);
+      await asRawClient(testDb.db).unsafe(`DROP TABLE public.__drizzle_migrations`);
     }
   });
 });

package/src/migrations/__tests__/{detect-projections-to-rebuild.integration.ts → detect-projections-to-rebuild.integration.test.ts}

@@ -8,10 +8,10 @@
 // Sprint-G-Pieces nebeneinander leben aber sich nicht treffen — Marker
 // wäre leer, kein Rebuild würde ausgelöst.
 
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { createBooleanField, createEntity, createTextField, defineFeature } from "../../engine";
 import { createRegistry } from "../../engine/registry";
 import { detectProjectionsToRebuild } from "../projection-detection";

package/src/migrations/__tests__/rebuild-marker.test.ts

@@ -4,10 +4,10 @@
 //   - schemaVersion-Mismatch wirft (verhindert dass alte Markers gegen
 //     neue Lese-Logik fahren)
 
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { readRebuildMarker, writeRebuildMarker } from "../rebuild-marker";
 
 let tmpDir: string;

package/src/migrations/projection-detection.ts

@@ -11,7 +11,6 @@
 // Damit muss niemand Tabellen-Namen doppelt pflegen (Truth liegt in der
 // Projection-Definition).
 
-import { getTableName } from "drizzle-orm";
 import type { Registry } from "../engine/types/feature";
 import {
   type ColumnSpec,
@@ -90,6 +89,18 @@ function sameColumns(
   return true;
 }
 
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+function getTableName(table: unknown): string {
+  if (typeof table !== "object" || table === null) {
+    throw new Error("projection-detection: table is not a pgTable object");
+  }
+  const name = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  if (typeof name !== "string") {
+    throw new Error("projection-detection: table missing drizzle name symbol");
+  }
+  return name;
+}
+
 /** Index `tableName → projection-name` aus der Registry. Nur Projections
  *  mit table-Definition (single-stream + multi-stream-with-table) zählen.
  *  Side-effect-only MSPs (table omitted) haben keinen Rebuild-Sinn. */

package/src/migrations/schema-drift.ts

@@ -9,7 +9,7 @@
 //   3. Column-Diff: information_schema-Vergleich gegen Snapshot —
 //      missing-/extra-column, type-mismatch, nullability-mismatch. Fängt
 //      manuelle ALTER TABLEs in Prod sowie doppelte pgTable-Definitionen
-//      pro Tabelle (eine hand-written, eine via buildDrizzleTable), die
+//      pro Tabelle (eine hand-written, eine via buildEntityTable), die
 //      stillschweigend gegen den Snapshot driften.
 //
 // Drizzle-kit's eigene Garantie: nach `migrate apply` ist der DB-Stand
@@ -19,8 +19,8 @@
 
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { sql } from "drizzle-orm";
 import type { DbConnection } from "../db/connection";
+import { selectAppliedMigrations, selectPublicTableColumns } from "../db/queries/schema-drift";
 import { tableExists } from "../db/schema-inspection";
 import { parseJsonOrThrow } from "../utils/safe-json";
 
@@ -125,16 +125,10 @@ export async function loadAppliedMigrations(db: DbConnection): Promise<AppliedMi
     ? false
     : await tableExists(db, "public.__drizzle_migrations");
   if (!drizzleSchemaExists && !publicSchemaExists) return [];
-  // sql.identifier mit qualifiziertem Namen: erstes Argument = Schema,
-  // zweites = Tabellenname. Drizzle quotet beides defensiv.
-  const tableRef = drizzleSchemaExists
-    ? sql`drizzle.__drizzle_migrations`
-    : sql`public.__drizzle_migrations`;
-  const rows = await db.execute<{ hash: string; created_at: bigint | number | null }>(sql`
-    SELECT hash, created_at
-    FROM ${tableRef}
-    ORDER BY id
-  `);
+  const rows = await selectAppliedMigrations(
+    db,
+    drizzleSchemaExists ? "drizzle.__drizzle_migrations" : "public.__drizzle_migrations",
+  );
   return rows.map((r) => ({
     hash: r.hash,
     createdAt: typeof r.created_at === "bigint" ? Number(r.created_at) : (r.created_at ?? 0),
@@ -143,12 +137,6 @@ export async function loadAppliedMigrations(db: DbConnection): Promise<AppliedMi
 
 // --- Column-Diff (Welle 2 Boot-Gate Layer 3) ---
 
-type DbColumnRow = {
-  readonly column_name: string;
-  readonly data_type: string;
-  readonly is_nullable: "YES" | "NO";
-};
-
 /** Liest information_schema.columns für eine Tabelle im public-Schema.
  *  Map by column_name. Default-Werte werden bewusst ausgelassen — die
  *  drift'en über drizzle-Versionen / PG-Reformulierungen hinweg ohne dass
@@ -158,11 +146,7 @@ async function loadDbColumns(
   db: DbConnection,
   tableName: string,
 ): Promise<ReadonlyMap<string, { type: string; notNull: boolean }>> {
-  const rows = await db.execute<DbColumnRow>(sql`
-    SELECT column_name, data_type, is_nullable
-    FROM information_schema.columns
-    WHERE table_schema = 'public' AND table_name = ${tableName}
-  `);
+  const rows = await selectPublicTableColumns(db, tableName);
   const map = new Map<string, { type: string; notNull: boolean }>();
   for (const r of rows) {
     map.set(r.column_name, {

package/src/observability/__tests__/console-provider.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { createConsoleProvider } from "../console-provider";
 
 function makeProvider() {

package/src/observability/__tests__/metric-validator.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { buildMetricName, validateLabelKey, validateMetricName } from "../metric-validator";
 
 describe("validateMetricName", () => {

package/src/observability/__tests__/noop-provider.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { createNoopProvider } from "../noop-provider";
 
 describe("NoopProvider", () => {

package/src/observability/__tests__/{observability.integration.ts → observability.integration.test.ts}

@@ -1,6 +1,6 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
 import { z } from "zod";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { buildEntityTable } from "../../db/table-builder";
 import { createRegistry, defineFeature } from "../../engine";
 import type { AppContext, SaveContext } from "../../engine/types";
 import { createJobRunner } from "../../jobs";
@@ -65,18 +65,15 @@ const todoEntity = {
 
 let postSaveInvocations = 0;
 const todoFeature = defineFeature("todo", (r) => {
-  const todoTable = buildDrizzleTable("todo", todoEntity);
+  const todoTable = buildEntityTable("todo", todoEntity);
   r.entity("todo", todoEntity);
 
   r.writeHandler(
     "create",
     z.object({ title: z.string() }),
     async (event, ctx) => {
-      const rows = await ctx.db
-        .insert(todoTable)
-        .values({ title: event.payload.title })
-        .returning();
-      const row = rows[0] as { id: number; title: string };
+      const rows = await ctx.db.insertOne(todoTable, { title: event.payload.title });
+      const row = rows as { id: number; title: string };
       return {
         isSuccess: true,
         data: {

package/src/observability/__tests__/prometheus-meter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createPrometheusMeter, serializeOpenMetrics } from "../prometheus-meter";
 
 describe("PrometheusMeter — accumulation", () => {

package/src/observability/__tests__/recording-meter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { type MetricEvent, RecordingMeter } from "../recording-meter";
 
 function makeMeter() {

package/src/observability/__tests__/recording-tracer.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { type RecordedSpan, RecordingTracer } from "../recording-tracer";
 import { DEFAULT_SENSITIVE_CONFIG } from "../sensitive-filter";
 

package/src/observability/__tests__/sensitive-filter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import {
   DEFAULT_SENSITIVE_CONFIG,
   mergeSensitiveConfig,

package/src/pipeline/__tests__/{archive-stream.integration.ts → archive-stream.integration.test.ts}

@@ -5,10 +5,10 @@
 // Kumiko carries this as a sparse kumiko_archived_streams table so active
 // streams never pay for extra metadata writes.
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import {
   ArchivedStreamError,
@@ -27,7 +27,7 @@ const itemEntity = createEntity({
   table: "read_arch_items",
   fields: { label: createTextField({ required: true }) },
 });
-const itemTable = buildDrizzleTable("arch-item", itemEntity);
+const itemTable = buildEntityTable("arch-item", itemEntity);
 
 const archFeature = defineFeature("archtest", (r) => {
   r.entity("arch-item", itemEntity);

package/src/pipeline/__tests__/auth-claims-resolver.test.ts

@@ -1,18 +1,18 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import type { AuthClaimsContext, AuthClaimsHookDef, SessionUser } from "../../engine/types";
 import type { Logger } from "../../logging/types";
 import { resolveAuthClaims } from "../auth-claims-resolver";
 
 type TestLogger = {
   readonly log: Logger;
-  readonly warn: ReturnType<typeof vi.fn>;
+  readonly warn: ReturnType<typeof mock>;
 };
 
 function makeTestLogger(): TestLogger {
-  const warn = vi.fn();
-  const info = vi.fn();
-  const error = vi.fn();
-  const debug = vi.fn();
+  const warn = mock();
+  const info = mock();
+  const error = mock();
+  const debug = mock();
   const logger: Logger = {
     warn,
     info,
@@ -45,7 +45,7 @@ function hooks(...entries: AuthClaimsHookDef[]): readonly AuthClaimsHookDef[] {
 
 describe("resolveAuthClaims — empty", () => {
   test("zero hooks registered → empty record, contextFactory not called", async () => {
-    const factory = vi.fn();
+    const factory = mock();
     const result = await resolveAuthClaims({
       user: testUser,
       hooks: [],
@@ -73,8 +73,8 @@ describe("resolveAuthClaims — single hook", () => {
   });
 
   test("receives the user and context handed in", async () => {
-    const fn = vi.fn(async () => ({}));
-    const factory = vi.fn(() => stubContext);
+    const fn = mock(async () => ({}));
+    const factory = mock(() => stubContext);
     await resolveAuthClaims({
       user: testUser,
       hooks: hooks({ featureName: "any", fn }),