@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/es-ops/runner.ts

@@ -22,20 +22,13 @@
 
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
-import { eq, sql } from "drizzle-orm";
 import type { DbConnection, DbRunner } from "../db";
+import { acquireEsOpsAdvisoryLock, esOperationExists } from "../db/queries/es-ops";
+import { insertOne, selectMany } from "../db/query";
 import type { Registry } from "../engine";
 import { esOperationsTable } from "./operations-schema";
 import type { EsOperationAppliedBy, SeedMigration, SeedMigrationContext } from "./types";
 
-// Stabiler 32-bit-Integer-Lock-Key für pg_advisory_xact_lock. Multi-Replica-
-// Boots gegen den selben Stack greifen denselben Lock — sequentialisiert
-// die Migration ohne dass jedes Pod alle pending Files parallel anwendet.
-// Ohne Lock: Pod A + Pod B sehen beide dieselbe pending-Liste → beide
-// laufen migration.run() → events DOUBLED, marker-unique-constraint
-// catched zu spät (nur den Marker, nicht die schon-committed Events).
-const ES_OPS_LOCK_KEY = 0x65_73_6f_70; // 'esop' als hex
-
 export type RunPendingSeedMigrationsArgs = {
   readonly db: DbConnection;
   /** Absoluter Pfad zum seeds-Directory (typically <appRoot>/seeds). */
@@ -130,30 +123,24 @@ export async function runPendingSeedMigrations(
 
     const start = Date.now();
     try {
-      await args.db.transaction(async (tx) => {
+      await args.db.begin(async (tx: DbRunner) => {
         // Advisory-Lock: sequentialisiert Multi-Replica-Boots. Zweiter
         // Pod blockt bis erster fertig ist, dann re-checked sein
         // applied-set (außerhalb dieser Funktion in nächster Iteration)
         // und findet den Marker → skip. Lock wird beim Tx-Commit
         // automatisch released (xact-scope).
-        await tx.execute(sql`SELECT pg_advisory_xact_lock(${ES_OPS_LOCK_KEY})`);
+        await acquireEsOpsAdvisoryLock(tx);
 
-        // Re-check applied-set INSIDE Tx + Lock — verhindert Race
-        // wo Pod-A schon committed hat während Pod-B vor dem Lock
-        // war. Sonst würde Pod-B die Migration nochmal ausführen.
-        const reCheck = (await tx.execute(
-          sql`SELECT 1 FROM kumiko_es_operations WHERE id = ${entry.id} LIMIT 1`,
-        )) as unknown as readonly unknown[];
-        if (reCheck.length > 0) {
+        if (await esOperationExists(tx, entry.id)) {
           log(`${LOG_PREFIX} race-skip "${entry.id}" — applied by parallel boot`);
-          // skip: race-detected — other replica committed marker between
-          // loadAppliedIds() and this tx; their run already covered the work.
+          // skip: parallel boot won the advisory-lock and already applied
+          // this migration. Nothing more to do in this tx.
           return;
         }
 
         const ctx = args.createContext(tx);
         await migration.run(ctx);
-        await tx.insert(esOperationsTable).values({
+        await insertOne(tx, esOperationsTable, {
           id: entry.id,
           operationType: "seed-migration",
           durationMs: Date.now() - start,
@@ -204,11 +191,10 @@ async function listSeedFiles(seedsDir: string): Promise<readonly SeedFileEntry[]
 }
 
 async function loadAppliedIds(db: DbConnection): Promise<Set<string>> {
-  const rows = await db
-    .select({ id: esOperationsTable.id })
-    .from(esOperationsTable)
-    .where(eq(esOperationsTable.operationType, "seed-migration"));
-  return new Set(rows.map((r: { id: string }) => r.id));
+  const rows = await selectMany<{ id: string }>(db, esOperationsTable, {
+    operationType: "seed-migration",
+  });
+  return new Set(rows.map((r) => r.id));
 }
 
 async function loadSeedModule(filePath: string): Promise<SeedMigration> {

package/src/event-store/__tests__/{admin-api.integration.ts → admin-api.integration.test.ts}

@@ -9,15 +9,35 @@
 //   - Batch: single INSERT with multi-VALUES; atomic rollback on any
 //     failure; predecessor pre-flight per aggregate in the batch.
 
-import { sql } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/postgres-js";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import type { DbConnection, PgClient } from "../../db/connection";
+import { asRawClient, selectMany } from "../../db/query";
 import { createTestDb, type TestDb } from "../../stack";
 import { generateId as uuid } from "../../utils";
 import { appendRaw, appendRawBatch, type RawEventToAppend } from "../admin-api";
 import { VersionConflictError } from "../errors";
 import { append, loadAggregate } from "../event-store";
-import { createEventsTable } from "../events-schema";
+import { createEventsTable, eventsTable } from "../events-schema";
+
+// Test-only spy: wrap a DbConnection's `.unsafe()` to capture the SQL
+// string of every query the framework runs. Used to assert batching
+// behaviour (single multi-VALUES INSERT vs N statements).
+function spyQueries(db: DbConnection): { db: DbConnection; queries: string[] } {
+  const queries: string[] = [];
+  const wrapped = new Proxy(db, {
+    get(target, prop, receiver) {
+      if (prop === "unsafe") {
+        return (sql: string, params?: readonly unknown[]) => {
+          queries.push(sql);
+          // biome-ignore lint/suspicious/noExplicitAny: postgres-js .unsafe signature variance
+          return (target as any).unsafe(sql, params);
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+  return { db: wrapped, queries };
+}
 
 let testDb: TestDb;
 
@@ -35,7 +55,7 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events RESTART IDENTITY`);
+  await asRawClient(testDb.db).unsafe(`TRUNCATE kumiko_events RESTART IDENTITY`);
 });
 
 function makeEvent(partial: Partial<RawEventToAppend> = {}): RawEventToAppend {
@@ -86,9 +106,12 @@ describe("appendRaw — single event", () => {
       }),
     );
 
-    const rows = await testDb.db.execute<{ created_by: string }>(sql`
-      SELECT created_by FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid
-    `);
+    const rows = await asRawClient(testDb.db).unsafe<{ created_by: string }>(
+      `
+      SELECT created_by FROM kumiko_events WHERE aggregate_id = $1::uuid
+    `,
+      [aggregateId],
+    );
     expect(rows[0]?.created_by).toBe(legacyUser);
     expect(rows[0]?.created_by).not.toBe(userMigration);
   });
@@ -113,12 +136,7 @@ describe("appendRaw — single event", () => {
       }),
     );
 
-    const rows = await testDb.db.execute<{
-      payload: Record<string, unknown>;
-      metadata: Record<string, unknown>;
-    }>(sql`
-      SELECT payload, metadata FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid
-    `);
+    const rows = await selectMany(testDb.db, eventsTable, { aggregateId });
     expect(rows[0]?.payload).toEqual(payload);
     expect(rows[0]?.metadata).toEqual(metadata);
   });
@@ -128,9 +146,12 @@ describe("appendRaw — single event", () => {
     // client; the callback is invoked per NOTIFY payload. The resolved value
     // is a meta-object with an `unlisten` method, not a plain function.
     const notifications: string[] = [];
-    const subscription = await testDb.client.listen("kumiko_events_new", (payload) => {
-      notifications.push(payload);
-    });
+    const subscription = await (testDb.client as PgClient).listen(
+      "kumiko_events_new",
+      (payload: string) => {
+        notifications.push(payload);
+      },
+    );
 
     try {
       // appendRaw path — MUST NOT fire.
@@ -176,9 +197,12 @@ describe("appendRaw — single event", () => {
     ).rejects.toBeInstanceOf(VersionConflictError);
 
     // Sanity: no row landed.
-    const rows = await testDb.db.execute<{ c: number }>(sql`
-      SELECT count(*)::int as c FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid
-    `);
+    const rows = await asRawClient(testDb.db).unsafe<{ c: number }>(
+      `
+      SELECT count(*)::int as c FROM kumiko_events WHERE aggregate_id = $1::uuid
+    `,
+      [aggregateId],
+    );
     expect(rows[0]?.c).toBe(0);
   });
 
@@ -188,21 +212,19 @@ describe("appendRaw — single event", () => {
     await appendRaw(testDb.db, makeEvent({ aggregateId, expectedVersion: 1 }));
     await appendRaw(testDb.db, makeEvent({ aggregateId, expectedVersion: 2 }));
 
-    const rows = await testDb.db.execute<{ version: number }>(sql`
-      SELECT version FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid ORDER BY version
-    `);
+    const rows = await asRawClient(testDb.db).unsafe<{ version: number }>(
+      `
+      SELECT version FROM kumiko_events WHERE aggregate_id = $1::uuid ORDER BY version
+    `,
+      [aggregateId],
+    );
     expect(rows.map((r) => r.version)).toEqual([1, 2, 3]);
   });
 });
 
 describe("appendRawBatch — multi-event", () => {
   test("writes all events in a single INSERT statement (query-log spy)", async () => {
-    const queries: string[] = [];
-    const loggedDb = drizzle(testDb.client, {
-      logger: {
-        logQuery: (q) => queries.push(q),
-      },
-    });
+    const { db: loggedDb, queries } = spyQueries(testDb.db);
 
     const aggregateId = uuid();
     const events: readonly RawEventToAppend[] = [
@@ -217,9 +239,12 @@ describe("appendRawBatch — multi-event", () => {
     expect(inserts).toHaveLength(1);
 
     // All three events persisted with ascending versions.
-    const rows = await testDb.db.execute<{ version: number; type: string }>(sql`
-      SELECT version, type FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid ORDER BY version
-    `);
+    const rows = await asRawClient(testDb.db).unsafe<{ version: number; type: string }>(
+      `
+      SELECT version, type FROM kumiko_events WHERE aggregate_id = $1::uuid ORDER BY version
+    `,
+      [aggregateId],
+    );
     expect(rows.map((r) => ({ v: r.version, t: r.type }))).toEqual([
       { v: 1, t: "legacy.order.created" },
       { v: 2, t: "legacy.order.accepted" },
@@ -263,7 +288,7 @@ describe("appendRawBatch — multi-event", () => {
     await expect(appendRawBatch(testDb.db, batch)).rejects.toBeInstanceOf(VersionConflictError);
 
     // Only the seed event survived — multi-VALUES INSERT is atomic.
-    const rows = await testDb.db.execute<{ c: number }>(sql`
+    const rows = await asRawClient(testDb.db).unsafe<{ c: number }>(`
       SELECT count(*)::int as c FROM kumiko_events
     `);
     expect(rows[0]?.c).toBe(1);
@@ -280,9 +305,12 @@ describe("appendRawBatch — multi-event", () => {
       ]),
     ).rejects.toBeInstanceOf(VersionConflictError);
 
-    const rows = await testDb.db.execute<{ c: number }>(sql`
-      SELECT count(*)::int as c FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid
-    `);
+    const rows = await asRawClient(testDb.db).unsafe<{ c: number }>(
+      `
+      SELECT count(*)::int as c FROM kumiko_events WHERE aggregate_id = $1::uuid
+    `,
+      [aggregateId],
+    );
     expect(rows[0]?.c).toBe(0);
   });
 
@@ -301,9 +329,12 @@ describe("appendRawBatch — multi-event", () => {
     ).rejects.toBeInstanceOf(VersionConflictError);
 
     // Zero events persisted — the whole batch is rejected before the INSERT.
-    const rows = await testDb.db.execute<{ c: number }>(sql`
-      SELECT count(*)::int as c FROM kumiko_events WHERE aggregate_id = ${aggregateId}::uuid
-    `);
+    const rows = await asRawClient(testDb.db).unsafe<{ c: number }>(
+      `
+      SELECT count(*)::int as c FROM kumiko_events WHERE aggregate_id = $1::uuid
+    `,
+      [aggregateId],
+    );
     expect(rows[0]?.c).toBe(0);
   });
 
@@ -326,12 +357,7 @@ describe("appendRawBatch — multi-event", () => {
   });
 
   test("empty array is a no-op — no query, no throw", async () => {
-    const queries: string[] = [];
-    const loggedDb = drizzle(testDb.client, {
-      logger: {
-        logQuery: (q) => queries.push(q),
-      },
-    });
+    const { db: loggedDb, queries } = spyQueries(testDb.db);
 
     await appendRawBatch(loggedDb, []);
     expect(queries).toHaveLength(0);

package/src/event-store/__tests__/{event-store.integration.ts → event-store.integration.test.ts}

@@ -1,6 +1,7 @@
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { createTestDb, type TestDb } from "../../stack";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { generateId as uuid } from "../../utils";
 import {
   append,
@@ -14,13 +15,14 @@ import {
   VersionConflictError,
 } from "../index";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 
 const tenantA = uuid();
 const tenantB = uuid();
 const userA = uuid();
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
 });
@@ -30,7 +32,7 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events RESTART IDENTITY`);
+  await asRawClient(testDb.db).unsafe(`TRUNCATE kumiko_events RESTART IDENTITY`);
 });
 
 describe("event-store: append + load", () => {

package/src/event-store/__tests__/{get-stream-version-perf.integration.ts → get-stream-version-perf.integration.test.ts}

@@ -9,17 +9,19 @@
 // Not a strict SLA test — the threshold is generous enough to survive CI
 // noise but tight enough that an index-miss regression would fail loudly.
 
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
 import type { TenantId } from "../../engine/types";
-import { createTestDb, type TestDb } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { generateId as uuid } from "../../utils";
 import { append, createEventsTable, getStreamVersion } from "../index";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 const tenantId: TenantId = uuid();
 const userId = uuid();
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
 });

package/src/event-store/__tests__/{perf.integration.ts → perf.integration.test.ts}

@@ -12,10 +12,11 @@
 // latency, single-node PG. Production deploys are slower; these numbers
 // are the ceiling. Red test = framework regression, no slack tolerated.
 
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
 import type { TenantId } from "../../engine/types";
-import { createTestDb, type TestDb } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { generateId as uuid } from "../../utils";
 import {
   append,
@@ -25,11 +26,12 @@ import {
   saveSnapshot,
 } from "../index";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 const tenantId = uuid() as TenantId;
 const userId = uuid();
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
 });
@@ -39,8 +41,8 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, kumiko_snapshots, kumiko_archived_streams RESTART IDENTITY CASCADE`,
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, kumiko_snapshots, kumiko_archived_streams RESTART IDENTITY CASCADE`,
   );
 });
 
@@ -196,21 +198,27 @@ describe("event-store performance — Gate A", () => {
     // loadAggregateWithSnapshot performance on a finished stream, not
     // the seed phase.
     const aggregateId = uuid();
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(
+      `
       INSERT INTO kumiko_events (aggregate_id, aggregate_type, tenant_id, version, type, payload, metadata, created_by)
-      SELECT ${aggregateId}::uuid, 'task', ${tenantId}::uuid, 1, 'task.created',
+      SELECT $1::uuid, 'task', $2::uuid, 1, 'task.created',
              jsonb_build_object('title', 'v1'),
-             jsonb_build_object('userId', ${userId}::text),
-             ${userId}::text;
-    `);
-    await testDb.db.execute(sql`
+             jsonb_build_object('userId', $3::text),
+             $4::text;
+    `,
+      [aggregateId, tenantId, userId, userId],
+    );
+    await asRawClient(testDb.db).unsafe(
+      `
       INSERT INTO kumiko_events (aggregate_id, aggregate_type, tenant_id, version, type, payload, metadata, created_by)
-      SELECT ${aggregateId}::uuid, 'task', ${tenantId}::uuid, gs.v, 'task.updated',
+      SELECT $1::uuid, 'task', $2::uuid, gs.v, 'task.updated',
              jsonb_build_object('title', 'v' || gs.v),
-             jsonb_build_object('userId', ${userId}::text),
-             ${userId}::text
+             jsonb_build_object('userId', $3::text),
+             $4::text
         FROM generate_series(2, 1000) gs(v);
-    `);
+    `,
+      [aggregateId, tenantId, userId, userId],
+    );
 
     // Snapshot @ version 900 — typische Policy: snapshot every N events
     await saveSnapshot(testDb.db, {

package/src/event-store/__tests__/{snapshot.integration.ts → snapshot.integration.test.ts}

@@ -9,10 +9,15 @@
 //      in < 50ms (typical asOf/reducer rehydrate budget). Same gate the
 //      spike proved on raw SQL, now enforced on the framework path.
 
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+// Bun.SQL-only setup. KEIN postgres-js, KEIN createTestDb.
+// Event-store functions expect DbRunner (= postgres-js) but Bun.SQL
+// ist strukturell kompatibel (beide haben .unsafe()/.begin()) — kein Cast nötig.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
 import type { TenantId } from "../../engine/types";
-import { createTestDb, type TestDb } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { generateId as uuid } from "../../utils";
 import {
   append,
@@ -25,7 +30,7 @@ import {
   saveSnapshot,
 } from "../index";
 
-let testDb: TestDb;
+let bun: BunTestDb;
 const tenant = uuid() as TenantId;
 const userId = uuid();
 
@@ -49,17 +54,18 @@ const reducer: SnapshotReducer<CounterState> = (state, event) => {
 };
 
 beforeAll(async () => {
-  testDb = await createTestDb();
-  await createEventsTable(testDb.db);
+  await ensureTemporalPolyfill();
+  bun = await createTestDb();
+  await createEventsTable(bun.db);
 });
 
 afterAll(async () => {
-  await testDb.cleanup();
+  await bun.cleanup();
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, kumiko_snapshots, kumiko_archived_streams RESTART IDENTITY`,
+  await asRawClient(bun.db).unsafe(
+    `TRUNCATE kumiko_events, kumiko_snapshots, kumiko_archived_streams RESTART IDENTITY`,
   );
 });
 
@@ -67,7 +73,7 @@ beforeEach(async () => {
 async function seedAggregate(eventCount: number): Promise<string> {
   const aggId = uuid();
   for (let i = 0; i < eventCount; i++) {
-    await append(testDb.db, {
+    await append(bun.db, {
       aggregateId: aggId,
       aggregateType: "counter",
       tenantId: tenant,
@@ -85,7 +91,7 @@ async function seedAggregate(eventCount: number): Promise<string> {
 // raw SQL) keeps the invariant honest: if loadAggregate semantics drift,
 // this helper shifts with them.
 async function loadFullState(aggregateId: string): Promise<CounterState> {
-  const events = await loadAggregate(testDb.db, aggregateId, tenant);
+  const events = await loadAggregate(bun.db, aggregateId, tenant);
   let state: CounterState = initial;
   for (const event of events) {
     state = reducer(state, event);
@@ -96,7 +102,7 @@ async function loadFullState(aggregateId: string): Promise<CounterState> {
 describe("snapshot-store — round-trip", () => {
   test("saveSnapshot + loadLatestSnapshot roundtrip the state", async () => {
     const aggId = uuid();
-    await saveSnapshot(testDb.db, {
+    await saveSnapshot(bun.db, {
       aggregateId: aggId,
       tenantId: tenant,
       aggregateType: "counter",
@@ -104,7 +110,7 @@ describe("snapshot-store — round-trip", () => {
       state: { count: 100, label: "checkpoint" },
     });
 
-    const loaded = await loadLatestSnapshot<CounterState>(testDb.db, aggId, tenant);
+    const loaded = await loadLatestSnapshot<CounterState>(bun.db, aggId, tenant);
     expect(loaded).not.toBeNull();
     expect(loaded?.version).toBe(42);
     expect(loaded?.state).toEqual({ count: 100, label: "checkpoint" });
@@ -113,28 +119,28 @@ describe("snapshot-store — round-trip", () => {
 
   test("saveSnapshot is idempotent — re-snapshotting the same version upserts", async () => {
     const aggId = uuid();
-    await saveSnapshot(testDb.db, {
+    await saveSnapshot(bun.db, {
       aggregateId: aggId,
       tenantId: tenant,
       aggregateType: "counter",
       version: 10,
       state: { count: 10, label: "v1" },
     });
-    await saveSnapshot(testDb.db, {
+    await saveSnapshot(bun.db, {
       aggregateId: aggId,
       tenantId: tenant,
       aggregateType: "counter",
       version: 10,
       state: { count: 10, label: "v2-updated" },
     });
-    const loaded = await loadLatestSnapshot<CounterState>(testDb.db, aggId, tenant);
+    const loaded = await loadLatestSnapshot<CounterState>(bun.db, aggId, tenant);
     expect(loaded?.state.label).toBe("v2-updated");
   });
 
   test("loadLatestSnapshot picks the highest version when multiple exist", async () => {
     const aggId = uuid();
     for (const v of [5, 50, 20, 100, 75]) {
-      await saveSnapshot(testDb.db, {
+      await saveSnapshot(bun.db, {
         aggregateId: aggId,
         tenantId: tenant,
         aggregateType: "counter",
@@ -142,7 +148,7 @@ describe("snapshot-store — round-trip", () => {
         state: { count: v * 2, label: `at-${v}` },
       });
     }
-    const loaded = await loadLatestSnapshot<CounterState>(testDb.db, aggId, tenant);
+    const loaded = await loadLatestSnapshot<CounterState>(bun.db, aggId, tenant);
     expect(loaded?.version).toBe(100);
     expect(loaded?.state.label).toBe("at-100");
   });
@@ -155,7 +161,7 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
     // Snapshot MUST reflect that truth; otherwise the "snapshot + deltas =
     // full replay" invariant is meaningless.
     const partial = { count: 40, label: "snap-at-40" };
-    await saveSnapshot(testDb.db, {
+    await saveSnapshot(bun.db, {
       aggregateId: aggId,
       tenantId: tenant,
       aggregateType: "counter",
@@ -165,7 +171,7 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
 
     const full = await loadFullState(aggId);
     const snapBased = await loadAggregateWithSnapshot<CounterState>(
-      testDb.db,
+      bun.db,
       aggId,
       tenant,
       reducer,
@@ -181,7 +187,7 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
     const aggId = await seedAggregate(20);
     const full = await loadFullState(aggId);
     const snapBased = await loadAggregateWithSnapshot<CounterState>(
-      testDb.db,
+      bun.db,
       aggId,
       tenant,
       reducer,
@@ -198,14 +204,14 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
     // presence. Otherwise a snapshot would silently survive a GDPR-style
     // archival and leak state that the event log hid.
     const aggId = await seedAggregate(10);
-    await saveSnapshot(testDb.db, {
+    await saveSnapshot(bun.db, {
       aggregateId: aggId,
       tenantId: tenant,
       aggregateType: "counter",
       version: 10,
       state: { count: 10, label: "pre-archive" },
     });
-    await archiveStream(testDb.db, {
+    await archiveStream(bun.db, {
       tenantId: tenant,
       aggregateId: aggId,
       aggregateType: "counter",
@@ -213,7 +219,7 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
     });
 
     const snapBased = await loadAggregateWithSnapshot<CounterState>(
-      testDb.db,
+      bun.db,
       aggId,
       tenant,
       reducer,
@@ -225,7 +231,7 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
 
     // includeArchived opt-in surfaces the snapshot + deltas for ops tooling.
     const archived = await loadAggregateWithSnapshot<CounterState>(
-      testDb.db,
+      bun.db,
       aggId,
       tenant,
       reducer,
@@ -238,7 +244,7 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
 
   test("1000-event aggregate with snapshot at v900 loads in under 50ms", async () => {
     const aggId = await seedAggregate(1000);
-    await saveSnapshot(testDb.db, {
+    await saveSnapshot(bun.db, {
       aggregateId: aggId,
       tenantId: tenant,
       aggregateType: "counter",
@@ -247,11 +253,11 @@ describe("snapshot-store — loadAggregateWithSnapshot", () => {
     });
 
     // Warm cache
-    await loadAggregateWithSnapshot<CounterState>(testDb.db, aggId, tenant, reducer, initial);
+    await loadAggregateWithSnapshot<CounterState>(bun.db, aggId, tenant, reducer, initial);
 
     const start = performance.now();
     const snapBased = await loadAggregateWithSnapshot<CounterState>(
-      testDb.db,
+      bun.db,
       aggId,
       tenant,
       reducer,