@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/pipeline/__tests__/{cascade-handler.integration.ts → cascade-handler.integration.test.ts}

@@ -1,7 +1,8 @@
-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 { TableColumns } from "../../db/dialect";
 import { createEventStoreExecutor, type EventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { buildEntityTable } from "../../db/table-builder";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import {
   createEntity,
@@ -11,13 +12,14 @@ import {
   type Registry,
 } from "../../engine";
 import { createEventsTable } from "../../event-store";
-import { createTestDb, type TestDb, TestUsers, unsafeCreateEntityTable } from "../../stack";
+import { TestUsers, unsafeCreateEntityTable } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { createCascadeDeleteHook } from "../cascade-handler";
 
 // biome-ignore lint/suspicious/noExplicitAny: Drizzle dynamic tables
 type Table = TableColumns<any>;
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let tdb: TenantDb;
 let registry: Registry;
 let departmentTable: Table;
@@ -77,6 +79,7 @@ const memberEntity = createEntity({
 });
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
   tdb = createTenantDb(testDb.db, admin.tenantId);
@@ -90,14 +93,14 @@ beforeAll(async () => {
   await unsafeCreateEntityTable(testDb.db, teamEntity);
   await unsafeCreateEntityTable(testDb.db, memberEntity);
 
-  departmentTable = buildDrizzleTable("department", departmentEntity);
-  userTable = buildDrizzleTable("user", userEntity);
-  sessionTable = buildDrizzleTable("session", sessionEntity);
-  groupTable = buildDrizzleTable("group", groupEntity);
-  userGroupRestrictTable = buildDrizzleTable("user-group-restrict", userGroupRestrictEntity);
-  userGroupCascadeTable = buildDrizzleTable("user-group-cascade", userGroupCascadeEntity);
-  teamTable = buildDrizzleTable("team", teamEntity);
-  memberTable = buildDrizzleTable("member", memberEntity);
+  departmentTable = buildEntityTable("department", departmentEntity);
+  userTable = buildEntityTable("user", userEntity);
+  sessionTable = buildEntityTable("session", sessionEntity);
+  groupTable = buildEntityTable("group", groupEntity);
+  userGroupRestrictTable = buildEntityTable("user-group-restrict", userGroupRestrictEntity);
+  userGroupCascadeTable = buildEntityTable("user-group-cascade", userGroupCascadeEntity);
+  teamTable = buildEntityTable("team", teamEntity);
+  memberTable = buildEntityTable("member", memberEntity);
 
   const feature = defineFeature("cascade", (r) => {
     r.entity("department", departmentEntity);
@@ -219,10 +222,10 @@ describe("cascade delete: cascade", () => {
     const user = await userExecutor.create({ name: "Cascade User" }, admin, tdb);
     if (!user.isSuccess) throw new Error("Setup failed");
 
-    await sessionExecutor.create({ userId: user.data.id, token: "abc" }, admin, tdb);
-    await sessionExecutor.create({ userId: user.data.id, token: "def" }, admin, tdb);
+    const s1 = await sessionExecutor.create({ userId: user.data.id, token: "abc" }, admin, tdb);
+    const s2 = await sessionExecutor.create({ userId: user.data.id, token: "def" }, admin, tdb);
+    if (!s1.isSuccess || !s2.isSuccess) throw new Error("Setup failed");
 
-    // Verify sessions exist
     const before = await sessionExecutor.list({}, admin, tdb);
     const sessionsBefore = before.rows.filter((r) => r["userId"] === user.data.id);
     expect(sessionsBefore.length).toBe(2);

package/src/pipeline/__tests__/cascade-handler.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
 
 describe("getIncomingRelations", () => {

package/src/pipeline/__tests__/{causation-chain.integration.ts → causation-chain.integration.test.ts}

@@ -15,11 +15,12 @@
 // The active propagation into cascaded writes is covered by
 // msp-multi-hop.integration.ts.
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { requestContext } from "../../api/request-context";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import { eventsTable } from "../../event-store";
 import {
@@ -39,7 +40,7 @@ const orderEntity = createEntity({
   },
 });
 
-const orderTable = buildDrizzleTable("causation-order", orderEntity);
+const orderTable = buildEntityTable("causation-order", orderEntity);
 
 // MSP-apply observation sink — every apply run pushes its reqCtx snapshot
 // here so the tests can assert what the event-dispatcher wrapped it with.
@@ -85,7 +86,7 @@ const causationFeature = defineFeature("causation", (r) => {
       [placed.name]: async (event) => {
         const ctx = requestContext.get();
         applyObservations.push({
-          forEventId: String(event.id),
+          forEventId: String(event["id"]),
           correlationId: ctx?.correlationId,
           causationId: ctx?.causationId,
         });
@@ -118,11 +119,9 @@ afterEach(async () => {
 
 // --- Helpers ---
 
-type EventRow = typeof eventsTable.$inferSelect;
-
-async function eventsByType(type: string): Promise<EventRow[]> {
-  const rows = await stack.db.select().from(eventsTable);
-  return rows.filter((r) => r.type === type);
+async function eventsByType(type: string) {
+  const rows = await selectMany(stack.db, eventsTable);
+  return rows.filter((r: Record<string, unknown>) => r["type"] === type);
 }
 
 // --- Tests ---
@@ -133,7 +132,7 @@ describe("Runde 2 — correlationId on root HTTP request", () => {
 
     const [placedEvent] = await eventsByType("causation:event:placed");
     expect(placedEvent).toBeDefined();
-    const meta = placedEvent?.metadata as {
+    const meta = placedEvent?.["metadata"] as {
       requestId?: string;
       correlationId?: string;
       causationId?: string;
@@ -159,10 +158,10 @@ describe("Runde 2 — correlationId on root HTTP request", () => {
     const crudEvent = (await eventsByType("causation-order.created"))[0];
     const placedEvent = (await eventsByType("causation:event:placed"))[0];
 
-    expect((crudEvent?.metadata as { correlationId?: string })?.correlationId).toBe(
+    expect((crudEvent?.["metadata"] as { correlationId?: string })?.correlationId).toBe(
       "test-chain-abc123",
     );
-    expect((placedEvent?.metadata as { correlationId?: string })?.correlationId).toBe(
+    expect((placedEvent?.["metadata"] as { correlationId?: string })?.correlationId).toBe(
       "test-chain-abc123",
     );
   });
@@ -192,7 +191,7 @@ describe("Runde 2 — event-dispatcher propagates correlation + causation to MSP
     // should have seen as causationId.
     const [placedEvent] = await eventsByType("causation:event:placed");
     expect(placedEvent).toBeDefined();
-    const placedId = String(placedEvent?.id);
+    const placedId = String(placedEvent?.["id"]);
 
     // Observation recorded inside the MSP apply.
     expect(applyObservations).toHaveLength(1);

package/src/pipeline/__tests__/{ctx-bridge.integration.ts → ctx-bridge.integration.test.ts}

@@ -1,7 +1,8 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { asRawClient, selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import {
   access,
   createEntity,
@@ -27,7 +28,7 @@ const bagEntity = createEntity({
     counter: createNumberField({ default: 0 }),
   },
 });
-const bagTable = buildDrizzleTable("bag", bagEntity);
+const bagTable = buildEntityTable("bag", bagEntity);
 
 // secret has a system-only read field — proves queryAs(system) reads it,
 // plain query doesn't.
@@ -41,7 +42,7 @@ const secretEntity = createEntity({
     }),
   },
 });
-const secretTable = buildDrizzleTable("secret", secretEntity);
+const secretTable = buildEntityTable("secret", secretEntity);
 
 let stack: TestStack;
 const admin = TestUsers.admin;
@@ -76,7 +77,7 @@ const bridgeFeature = defineFeature("ctxbridge", (r) => {
     "secret:by-owner",
     z.object({ owner: z.string() }),
     async (query, ctx) => {
-      const rows = await ctx.db.select().from(secretTable);
+      const rows = await selectMany(ctx.db, secretTable);
       return (
         (rows as Array<Record<string, unknown>>).find((r) => r["owner"] === query.payload.owner) ??
         null
@@ -154,8 +155,8 @@ afterAll(async () => {
 
 beforeEach(async () => {
   afterCommitLog.length = 0;
-  await stack.db.delete(bagTable);
-  await stack.db.delete(secretTable);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${bagTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${secretTable.tableName}"`);
   // Clear the event-dedup cache — tests re-use entity ids (Postgres sequences
   // reset, each test sees id=1). Without flushing Redis the second test hits
   // a dedup hit on the same handler:id:version:phase key and the hook is
@@ -195,8 +196,8 @@ describe("ctx.writeAs shares the outer transaction", () => {
     expect(body.isSuccess).toBe(false);
 
     // Both tables empty — outer bag + inner secret rolled back together
-    const bags = await stack.db.select().from(bagTable);
-    const secrets = await stack.db.select().from(secretTable);
+    const bags = await selectMany(stack.db, bagTable);
+    const secrets = await selectMany(stack.db, secretTable);
     expect(bags).toHaveLength(0);
     expect(secrets).toHaveLength(0);
   });
@@ -209,8 +210,8 @@ describe("ctx.writeAs shares the outer transaction", () => {
     );
     expect((await res.json()).isSuccess).toBe(true);
 
-    const bags = await stack.db.select().from(bagTable);
-    const secrets = await stack.db.select().from(secretTable);
+    const bags = await selectMany(stack.db, bagTable);
+    const secrets = await selectMany(stack.db, secretTable);
     expect(bags).toHaveLength(1);
     expect(secrets).toHaveLength(1);
 

package/src/pipeline/__tests__/dispatcher-utils.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import { createSystemUser } from "../../engine/system-user";
+import { InternalError } from "../../errors";
+import {
+  describeShape,
+  dispatcherSpanAttributes,
+  extractNestedSpecs,
+  isFailedWriteResult,
+  isLifecycleResult,
+  isWriteResultShape,
+  prefixValidationPath,
+  resolveType,
+  wrapToKumiko,
+} from "../dispatcher-utils";
+
+describe("isFailedWriteResult", () => {
+  test("narrows failed write results", () => {
+    const result = { isSuccess: false as const, error: { code: "validation_error" } };
+    expect(isFailedWriteResult(result)).toBe(true);
+    expect(isFailedWriteResult({ isSuccess: true, data: {} })).toBe(false);
+  });
+});
+
+describe("isWriteResultShape / isLifecycleResult", () => {
+  test("detects write-result envelope", () => {
+    expect(isWriteResultShape({ isSuccess: true, data: 1 })).toBe(true);
+    expect(isWriteResultShape({ kind: "created" })).toBe(false);
+  });
+
+  test("detects lifecycle results", () => {
+    expect(isLifecycleResult({ kind: "deleted" })).toBe(true);
+    expect(isLifecycleResult(null)).toBe(false);
+  });
+});
+
+describe("describeShape", () => {
+  test("summarizes unknown values", () => {
+    expect(describeShape(null)).toBe("null");
+    expect(describeShape("x")).toBe("string");
+    expect(describeShape({ a: 1, b: 2 })).toContain("object with keys");
+  });
+});
+
+describe("dispatcherSpanAttributes", () => {
+  test("includes handler, operation, user, tenant, optional feature", () => {
+    const user = createSystemUser("tenant-1");
+    const attrs = dispatcherSpanAttributes("feat:query:task:list", "query", user, "feat");
+    expect(attrs).toMatchObject({
+      "kumiko.handler": "feat:query:task:list",
+      "kumiko.operation": "query",
+      "kumiko.feature": "feat",
+    });
+  });
+});
+
+describe("prefixValidationPath", () => {
+  test("prefixes validation field paths", () => {
+    const info = {
+      code: "validation_error",
+      httpStatus: 400,
+      i18nKey: "errors.validation.failed",
+      message: "Validation failed",
+      details: {
+        fields: [{ path: "title", code: "too_small", i18nKey: "errors.validation.too_small" }],
+      },
+    };
+    const prefixed = prefixValidationPath(info, "tasks.0");
+    const fields = (prefixed.details as { fields: { path: string }[] }).fields;
+    expect(fields[0]?.path).toBe("tasks.0.title");
+  });
+
+  test("leaves non-validation errors unchanged", () => {
+    const info = {
+      code: "not_found",
+      httpStatus: 404,
+      i18nKey: "errors.notFound",
+      message: "missing",
+    };
+    expect(prefixValidationPath(info, "x")).toBe(info);
+  });
+});
+
+describe("resolveType", () => {
+  test("unwraps HandlerRef objects", () => {
+    expect(resolveType({ name: "feat:write:task:create" })).toBe("feat:write:task:create");
+    expect(resolveType("feat:query:task:list")).toBe("feat:query:task:list");
+  });
+});
+
+describe("wrapToKumiko", () => {
+  test("passes through KumikoError instances", () => {
+    const err = new InternalError();
+    expect(wrapToKumiko(err)).toBe(err);
+  });
+
+  test("wraps generic Error as InternalError", () => {
+    const wrapped = wrapToKumiko(new TypeError("boom"));
+    expect(wrapped.code).toBe("internal_error");
+    expect(wrapped.cause).toBeInstanceOf(TypeError);
+  });
+});
+
+describe("extractNestedSpecs", () => {
+  test("returns null for non-create handlers", () => {
+    expect(extractNestedSpecs("feat:write:task:update", { tasks: [] }, {} as never)).toBeNull();
+  });
+});

package/src/pipeline/__tests__/dispatcher.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
 import type { TenantId } from "../../engine/types/identifiers";
@@ -97,7 +97,7 @@ describe("dispatcher.write", () => {
     const res = await dispatcher.write("alias:write:item:create", { name: "x" }, user);
     expect(res.isSuccess).toBe(true);
     expect(captured.fromCtx).toBe(captured.fromEvent);
-    expect((captured.fromCtx as { id: number }).id).toBe(user.id);
+    expect((captured.fromCtx as { id: unknown }).id).toBe(user.id);
   });
 
   test("runs validation hooks", async () => {

package/src/pipeline/__tests__/{distributed-lock.integration.ts → distributed-lock.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 { createTestRedis, type TestRedis } from "../../stack";
 import { createDistributedLock } from "../distributed-lock";
 

package/src/pipeline/__tests__/{domain-events-projections.integration.ts → domain-events-projections.integration.test.ts}

@@ -9,9 +9,7 @@
 // Without all three pieces wired together (registry opens defineEvent names,
 // projections-runner fires on appendEvent, dispatcher routes appendEvent to
 // the aggregate stream), any of the assertions below go red.
-
-import { eq } from "drizzle-orm";
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import {
   integer as pgInteger,
@@ -20,7 +18,8 @@ import {
   uuid as pgUuid,
 } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { insertOne, selectMany, updateMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import { loadAggregate } from "../../event-store";
 import {
@@ -41,7 +40,7 @@ const shipmentEntity = createEntity({
   },
 });
 
-const shipmentTable = buildDrizzleTable("domain-shipment", shipmentEntity);
+const shipmentTable = buildEntityTable("domain-shipment", shipmentEntity);
 
 // --- Read-model table (fed by the projection below) ---
 
@@ -69,7 +68,7 @@ const shippingFeature = defineFeature("shipping", (r) => {
       // Auto CRUD event — fires on shipment create.
       "domain-shipment.created": async (event, tx) => {
         const payload = event.payload as { cargo?: string };
-        await tx.insert(billingTable).values({
+        await insertOne(tx, billingTable, {
           shipmentId: event.aggregateId,
           tenantId: event.tenantId,
           cargo: payload.cargo ?? "",
@@ -82,10 +81,12 @@ const shippingFeature = defineFeature("shipping", (r) => {
       // create-apply just inserted.
       [shipmentBilled.name]: async (event, tx) => {
         const payload = event.payload as { cost: number };
-        await tx
-          .update(billingTable)
-          .set({ totalCost: payload.cost, billedMarker: "billed" })
-          .where(eq(billingTable.shipmentId, event.aggregateId));
+        await updateMany(
+          tx,
+          billingTable,
+          { totalCost: payload.cost, billedMarker: "billed" },
+          { shipmentId: event.aggregateId },
+        );
       },
     },
   });
@@ -196,7 +197,7 @@ describe("Marten gold-standard: domain events → inline projections", () => {
       admin,
     );
 
-    const rows = await stack.db.select().from(billingTable);
+    const rows = await selectMany(stack.db, billingTable);
     expect(rows).toHaveLength(1);
     expect(rows[0]?.shipmentId).toBe(data.id);
     expect(rows[0]?.billedMarker).toBe("pending");
@@ -212,10 +213,7 @@ describe("Marten gold-standard: domain events → inline projections", () => {
 
     await stack.http.writeOk("shipping:write:shipment:bill", { id: created.id, cost: 1500 }, admin);
 
-    const [row] = await stack.db
-      .select()
-      .from(billingTable)
-      .where(eq(billingTable.shipmentId, created.id));
+    const [row] = await selectMany(stack.db, billingTable, { shipmentId: created.id });
     expect(row).toBeDefined();
     expect(row?.billedMarker).toBe("billed");
     expect(row?.totalCost).toBe(1500);

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

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { defineFeature, type SaveContext } from "../../engine";

package/src/pipeline/__tests__/{event-define-event-strict.integration.ts → event-define-event-strict.integration.test.ts}

@@ -10,10 +10,9 @@
 //      it hits the events-table. Mismatches throw ValidationError.
 //   3. r.defineEvent returns `{ name: qualifiedName, schema }` — callers
 //      pass `def.name` to ctx.appendEvent without building the qn manually.
-
-import { eq } from "drizzle-orm";
-import { afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
+import { selectMany } from "../../db/query";
 import { defineFeature } from "../../engine";
 import { eventsTable } from "../../event-store";
 import {
@@ -146,10 +145,7 @@ describe("E.3 — ctx.appendEvent strict validation", () => {
     );
     expect(res.status).toBe(200);
 
-    const stored = await stack.db
-      .select()
-      .from(eventsTable)
-      .where(eq(eventsTable.type, welcomeEventName));
+    const stored = await selectMany(stack.db, eventsTable, { type: welcomeEventName });
     expect(stored).toHaveLength(1);
     expect(stored[0]?.payload).toEqual({ userId, email: "welcome@test.de" });
     expect(stored[0]?.aggregateType).toBe("user");
@@ -164,7 +160,7 @@ describe("E.3 — ctx.appendEvent strict validation", () => {
     // Non-Kumiko throw inside a handler → wrapped as InternalError → 500.
     expect(res.status).toBe(500);
 
-    const stored = await stack.db.select().from(eventsTable);
+    const stored = await selectMany(stack.db, eventsTable);
     // TX rolled back: no event landed.
     expect(stored).toHaveLength(0);
   });
@@ -175,10 +171,7 @@ describe("E.3 — ctx.appendEvent strict validation", () => {
     // ValidationError is a first-class Kumiko error → 400.
     expect(res.status).toBe(400);
 
-    const stored = await stack.db
-      .select()
-      .from(eventsTable)
-      .where(eq(eventsTable.type, welcomeEventName));
+    const stored = await selectMany(stack.db, eventsTable, { type: welcomeEventName });
     expect(stored).toHaveLength(0);
   });
 });
@@ -193,10 +186,7 @@ describe("E.3 — cross-feature ownership guard", () => {
     const res = await stack.http.write("emitter:write:emit:foreign-event", { userId }, admin);
     expect(res.status).toBe(500);
 
-    const stored = await stack.db
-      .select()
-      .from(eventsTable)
-      .where(eq(eventsTable.type, foreignEventName));
+    const stored = await selectMany(stack.db, eventsTable, { type: foreignEventName });
     expect(stored).toHaveLength(0);
   });
 });

package/src/pipeline/__tests__/{event-dispatcher-lifecycle.integration.ts → event-dispatcher-lifecycle.integration.test.ts}

@@ -12,7 +12,7 @@
 // via payload, not via a wrapped DB handle. Tenant-isolation-via-MSP is
 // tested in multi-stream-projection.integration.ts.
 
-import { afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { defineFeature } from "../../engine";

package/src/pipeline/__tests__/{event-dispatcher-multi-instance.integration.ts → event-dispatcher-multi-instance.integration.test.ts}

@@ -18,8 +18,9 @@
 // single-instance runs. Any regression in the locking strategy shows up
 // here first.
 
-import { afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
+import { insertMany } from "../../db/query";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { defineFeature } from "../../engine";
 import { eventsTable, type StoredEvent } from "../../event-store";
@@ -91,7 +92,7 @@ async function bulkSeedWidgetCreated(count: number, namePrefix: string): Promise
     metadata: { userId: admin.id },
     createdBy: admin.id,
   }));
-  await stack.db.insert(eventsTable).values(rows);
+  await insertMany(stack.db, eventsTable, rows);
 }
 
 function buildDispatcherWith(consumers: readonly EventConsumer[]): EventDispatcher {

package/src/pipeline/__tests__/{event-dispatcher-pg-listen.integration.ts → event-dispatcher-pg-listen.integration.test.ts}

@@ -11,7 +11,7 @@
 //   2. The dispatcher starts cleanly when pgClient is wired and stops
 //      without leaking the LISTEN connection.
 
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { defineFeature } from "../../engine";

package/src/pipeline/__tests__/{event-dispatcher-recovery.integration.ts → event-dispatcher-recovery.integration.test.ts}

@@ -14,7 +14,7 @@
 //                    will never succeed (broken payload, removed code).
 //   (list/status are read-only; covered by event-dispatcher wiring tests.)
 
-import { afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { defineFeature } from "../../engine";
@@ -110,7 +110,7 @@ describe("E.9 — restartConsumer", () => {
     expect(after.attempts).toBe(0);
     expect(after.lastError).toBeNull();
     // Cursor unchanged — next pass retries the SAME failing event.
-    expect(after.lastProcessedEventId).toBe(cursorBefore);
+    expect(after.lastProcessedEventId).toBe(cursorBefore!);
 
     // Retry still poisoned (handler still throws) — attempts climbs again.
     await stack.eventDispatcher?.runOnce();

package/src/pipeline/__tests__/{event-dispatcher-second-audit.integration.ts → event-dispatcher-second-audit.integration.test.ts}

@@ -14,8 +14,8 @@
 //      moment delivery latency regresses from TCP-round-trip to
 //      pollIntervalMs.
 
-import { eq, sql } from "drizzle-orm";
-import { afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { asRawClient, insertOne, selectMany, updateMany } from "../../db/query";
 import { defineFeature } from "../../engine";
 import { eventsTable } from "../../event-store";
 import {
@@ -70,7 +70,7 @@ afterEach(async () => {
 });
 
 async function seedOldWidgetEvent(createdAt: Temporal.Instant): Promise<void> {
-  await stack.db.insert(eventsTable).values({
+  await insertOne(stack.db, eventsTable, {
     aggregateId: generateId(),
     aggregateType: "widget",
     tenantId: admin.tenantId,
@@ -94,7 +94,7 @@ describe("Second audit — consumer pre-registration on start()", () => {
     // every consumer at cursor=0, refuses to prune past them.
     await stack.eventDispatcher?.start();
     try {
-      const rows = await stack.db.select().from(eventConsumerStateTable);
+      const rows = await selectMany(stack.db, eventConsumerStateTable);
       const names = new Set(rows.map((r) => r.name));
 
       // The test-stack wires only feature MSP consumers (systemHooks: []),
@@ -138,17 +138,18 @@ describe("Second audit — consumer pre-registration on start()", () => {
 
     // Advance the cursor explicitly so we can prove the second start
     // doesn't clobber it back to 0.
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ lastProcessedEventId: 42n })
-      .where(eq(eventConsumerStateTable.name, "audit:projection:default-scope"));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { lastProcessedEventId: 42n },
+      { name: "audit:projection:default-scope" },
+    );
 
     await stack.eventDispatcher?.start();
     try {
-      const [row] = await stack.db
-        .select()
-        .from(eventConsumerStateTable)
-        .where(eq(eventConsumerStateTable.name, "audit:projection:default-scope"));
+      const [row] = await selectMany(stack.db, eventConsumerStateTable, {
+        name: "audit:projection:default-scope",
+      });
       expect(row?.lastProcessedEventId).toBe(42n);
     } finally {
       await stack.eventDispatcher?.stop();
@@ -255,13 +256,13 @@ describe("Second audit — LISTEN gauge", () => {
         // `LISTEN "kumiko_events_new"` and is now idle. pg_terminate_backend
         // on it closes the TCP; postgres.js's onclose handler re-subscribes
         // and fires onlisten again.
-        await recStack.db.execute(
-          sql`SELECT pg_terminate_backend(pid) FROM pg_stat_activity
+        await asRawClient(
+          recStack.db,
+        ).unsafe(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity
               WHERE datname = current_database()
                 AND query ILIKE 'listen%'
                 AND state = 'idle'
-                AND pid <> pg_backend_pid()`,
-        );
+                AND pid <> pg_backend_pid()`);
 
         // Wait for the SECOND gauge.set(1) — the reconnect. Generous timeout
         // because postgres.js's reconnect loop includes backoff.