@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/pipeline/__tests__/event-dispatcher-strict.test.ts

@@ -8,7 +8,7 @@
 // Unit-level because the check happens before any DB call — no pgClient,
 // no event-store schema, no setupTestStack needed.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import type { AppContext, Registry } from "../../engine/types";
 import { createEventDispatcher, type EventConsumer } from "../event-dispatcher";
 
@@ -35,18 +35,20 @@ describe("event-dispatcher — strict runOnce precondition", () => {
   test("ensureRegistered() is a valid alternative to start() — runOnce no longer throws", async () => {
     const consumers: EventConsumer[] = [{ name: "noop", handler: async () => {} }];
     let insertCalls = 0;
+    // bun-db path: dispatcher uses db/queries/ for transition guard + transaction().
+    // INSERT/SELECT/UPDATE. Match by SQL substring so we count INSERTs and
+    // hand back empty rows for SELECT.
+    const unsafe = async (sqlText: string): Promise<unknown[]> => {
+      if (/INSERT INTO "kumiko_event_consumers"/.test(sqlText)) {
+        insertCalls += 1;
+        return [];
+      }
+      return [];
+    };
     const stubDb = {
-      insert: () => ({
-        values: () => ({ onConflictDoNothing: async () => ++insertCalls }),
-      }),
-      transaction: async (fn: (tx: unknown) => Promise<unknown>) =>
-        fn({
-          select: () => ({
-            from: () => ({ where: () => ({ for: () => [] }) }),
-          }),
-          execute: async () => [],
-          update: () => ({ set: () => ({ where: () => Promise.resolve() }) }),
-        }),
+      unsafe,
+      begin: async (fn: (tx: unknown) => Promise<unknown>) => fn(stubDb),
+      transaction: async (fn: (tx: unknown) => Promise<unknown>) => fn(stubDb),
     };
     const dispatcher = createEventDispatcher({
       db: stubDb as never,

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

@@ -13,14 +13,10 @@
 // production would take once ops wires CreateApp. No createEventDispatcher
 // calls in the test — only the registry round-trip.
 
-import { sql } from "drizzle-orm";
-import { afterEach, beforeAll, describe, expect, test } from "vitest";
-import {
-  integer as drizzleInteger,
-  table as drizzlePgTable,
-  uuid as drizzleUuid,
-} from "../../db/dialect";
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { integer, table as pgTable, uuid } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
+import { selectMany } from "../../db/query";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { defineFeature, type FeatureDefinition } from "../../engine";
 import type { StoredEvent } from "../../event-store";
@@ -40,10 +36,10 @@ import { sharedWidgetEntity, sharedWidgetTable } from "../../testing";
 // A tiny state table a subscriber mutates so we can observe "the handler was
 // called with this event" without relying on in-memory arrays — the state row
 // survives even if the test framework resets process state.
-const subscriberLogTable = drizzlePgTable("read_dispatcher_subscriber_log", {
-  id: drizzleUuid("id").primaryKey().defaultRandom(),
-  eventId: drizzleInteger("event_id").notNull(),
-  eventType: drizzleUuid("event_type"), // unused, kept to avoid another drizzle type import
+const subscriberLogTable = pgTable("read_dispatcher_subscriber_log", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  eventId: integer("event_id").notNull(),
+  eventType: uuid("event_type"), // unused, kept to avoid another drizzle type import
 });
 
 // Per-test capture. The subscriber handlers push here; beforeEach resets.
@@ -195,10 +191,7 @@ describe("event-dispatcher — isolation between consumers", () => {
     // the per-consumer transaction boundary holds.
     // Pre-registered state rows exist from boot (strict Sprint-E mode) — at
     // this point they're at cursor=0 / status=idle for both observers.
-    const state = await stack.db
-      .select()
-      .from(eventConsumerStateTable)
-      .where(sql`${eventConsumerStateTable.name} = ${qnA}`);
+    const state = await selectMany(stack.db, eventConsumerStateTable, { name: qnA });
     expect(state).toHaveLength(1);
     expect(state[0]?.lastProcessedEventId).toBe(0n);
 

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

@@ -10,9 +10,9 @@
 //   4. olderThanDays / olderThan convenience: both resolve to the same
 //      cutoff semantics (createdAt < cutoff).
 
-import { eq, sql } from "drizzle-orm";
-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 { asRawClient, insertOne, selectMany, updateMany } from "../../db/query";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { defineFeature } from "../../engine";
 import { eventsTable } from "../../event-store";
@@ -77,20 +77,17 @@ async function seedOldAggregateEvent(
   type: string,
   aggregateType = "widget",
 ): Promise<bigint> {
-  const [row] = await stack.db
-    .insert(eventsTable)
-    .values({
-      aggregateId: generateId(),
-      aggregateType,
-      tenantId: admin.tenantId,
-      version: 1,
-      type,
-      payload: {},
-      metadata: { userId: admin.id },
-      createdAt,
-      createdBy: admin.id,
-    })
-    .returning({ id: eventsTable.id });
+  const row = await insertOne<{ id: bigint }>(stack.db, eventsTable, {
+    aggregateId: generateId(),
+    aggregateType,
+    tenantId: admin.tenantId,
+    version: 1,
+    type,
+    payload: {},
+    metadata: { userId: admin.id },
+    createdAt,
+    createdBy: admin.id,
+  });
   if (!row) throw new Error("seed failed");
   return row.id;
 }
@@ -121,7 +118,7 @@ describe("E.2 — explicit-aggregateTypes pruning", () => {
     expect(result.deletedCount).toBe(1);
     expect(result.aggregateTypes).toEqual(["obsolete"]);
 
-    const remaining = await stack.db.select().from(eventsTable);
+    const remaining = await selectMany(stack.db, eventsTable);
     const ids = remaining.map((r) => r.id);
     expect(ids).toContain(widgetId);
     expect(ids).not.toContain(obsoleteId);
@@ -146,7 +143,7 @@ describe("E.2 — explicit-aggregateTypes pruning", () => {
     });
     expect(result.deletedCount).toBe(1);
 
-    const remaining = await stack.db.select().from(eventsTable);
+    const remaining = await selectMany(stack.db, eventsTable);
     const ids = remaining.map((r) => r.id).sort();
     expect(ids).toEqual([freshId]);
     expect(ids.includes(staleId)).toBe(false);
@@ -165,7 +162,7 @@ describe("E.2 — explicit-aggregateTypes pruning", () => {
     expect(result.deletedCount).toBe(1);
     expect(result.dryRun).toBe(true);
 
-    const remaining = await stack.db.select().from(eventsTable);
+    const remaining = await selectMany(stack.db, eventsTable);
     expect(remaining).toHaveLength(1);
   });
 });
@@ -182,13 +179,17 @@ describe("E.2 — consumer-lag guard", () => {
     // Only let the first one through.
     await stack.eventDispatcher?.runOnce();
     // Force cursor to 1 so the guard sees "consumer at 1, max candidate 3".
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ lastProcessedEventId: 1n, status: "idle" })
-      .where(eq(eventConsumerStateTable.name, observerQn));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { lastProcessedEventId: 1n, status: "idle" },
+      { name: observerQn },
+    );
 
     // Age all three events past the cutoff.
-    await stack.db.execute(sql`UPDATE kumiko_events SET created_at = now() - interval '30 days'`);
+    await asRawClient(stack.db).unsafe(
+      `UPDATE kumiko_events SET created_at = now() - interval '30 days'`,
+    );
 
     await expect(
       pruneEvents(stack.db, {
@@ -204,7 +205,9 @@ describe("E.2 — consumer-lag guard", () => {
     await disableConsumer(stack.db, observerQn);
 
     // Cursor is at 1 but consumer is disabled — should be skipped.
-    await stack.db.execute(sql`UPDATE kumiko_events SET created_at = now() - interval '30 days'`);
+    await asRawClient(stack.db).unsafe(
+      `UPDATE kumiko_events SET created_at = now() - interval '30 days'`,
+    );
 
     const result = await pruneEvents(stack.db, {
       olderThanDays: 7,

package/src/pipeline/__tests__/{fetch-for-writing.integration.ts → fetch-for-writing.integration.test.ts}

@@ -7,11 +7,11 @@
 //      the stream version internally — a sequence of appendOne calls writes
 //      consecutive versions without re-reading the DB.
 
-import { sql } 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 { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { asRawClient } from "../../db/query-api";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import { UnprocessableError, writeFailure } from "../../errors";
 import { loadAggregate } from "../../event-store";
@@ -26,7 +26,7 @@ const cartEntity = createEntity({
   },
 });
 
-const cartTable = buildDrizzleTable("f4wCart", cartEntity);
+const cartTable = buildEntityTable("f4wCart", cartEntity);
 
 const cartFeature = defineFeature("f4w", (r) => {
   r.entity("f4wCart", cartEntity);
@@ -144,8 +144,8 @@ afterAll(async () => {
 });
 
 afterEach(async () => {
-  await stack.db.execute(
-    sql`TRUNCATE kumiko_events, read_f4w_carts, kumiko_event_consumers RESTART IDENTITY CASCADE`,
+  await asRawClient(stack.db).unsafe(
+    `TRUNCATE kumiko_events, read_f4w_carts, kumiko_event_consumers RESTART IDENTITY CASCADE`,
   );
   await stack.eventDispatcher?.ensureRegistered();
 });

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

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, spyOn, test } from "bun:test";
 import { z } from "zod";
 import {
   createEntity,
@@ -200,7 +200,7 @@ describe("runPostSave", () => {
 
   test("postSave errors don't throw — logged and continued", async () => {
     const calls: string[] = [];
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
 
     const registry = makeRegistry({
       postSave: [
@@ -234,7 +234,7 @@ describe("runPostSave", () => {
 
   test("system hook failure doesn't block other system hooks", async () => {
     const calls: string[] = [];
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
 
     const registry = makeRegistry();
 
@@ -334,7 +334,7 @@ describe("runPostSave phase routing", () => {
   });
 
   test("afterCommit phase: hook errors are logged, never thrown", async () => {
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const consoleSpy = spyOn(console, "error").mockImplementation(() => {});
     const afterRan: string[] = [];
     const feature = defineFeature("phases", (r) => {
       r.entity("user", createEntity({ table: "Users", fields: {} }));

package/src/pipeline/__tests__/{load-aggregate-query.integration.ts → load-aggregate-query.integration.test.ts}

@@ -5,11 +5,15 @@
 // returned events into whatever domain-state shape the feature wants.
 // Events are upcasted by the dispatcher, so the reducer sees the current
 // payload shape even for old v1 events.
+//
+// Bun.SQL-only setup. KEIN postgres-js, KEIN setupTestStack.
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
+import type { DbConnection, DbTx } from "../../db/connection";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { insertOne } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import { append, loadAggregate as loadAggregateRaw } from "../../event-store";
 import {
@@ -29,7 +33,7 @@ const invoiceEntity = createEntity({
     status: createTextField({ required: true }),
   },
 });
-const invoiceTable = buildDrizzleTable("asof-invoice", invoiceEntity);
+const invoiceTable = buildEntityTable("asof-invoice", invoiceEntity);
 
 // --- Feature ---
 
@@ -214,8 +218,8 @@ describe("ctx.loadAggregate via queryHandler — Marten AggregateStreamAsync equ
     // against v2 (integer cents) — without upcasting it would blow up or
     // produce garbage.
     const invoiceId = "00000000-0000-4000-8000-000000000042";
-    await stack.db.transaction(async (tx) => {
-      await tx.insert(invoiceTable).values({
+    await (stack.db as DbConnection).begin(async (tx: DbTx) => {
+      await insertOne(tx, invoiceTable, {
         id: invoiceId,
         tenantId: admin.tenantId,
         customer: "LegacyCo",

package/src/pipeline/__tests__/{msp-error-mode.integration.ts → msp-error-mode.integration.test.ts}

@@ -9,7 +9,7 @@
 // error on the skip counter, advances the cursor, and keeps delivering. The
 // consumer stays "idle".
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, 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__/{msp-multi-hop.integration.ts → msp-multi-hop.integration.test.ts}

@@ -10,10 +10,11 @@
 //      a three-hop causal chain (order.placed → order.confirmed → order.shipped).
 //   5. ctx.loadAggregate reads the triggering stream's full history.
 
-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 { selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import { eventsTable } from "../../event-store";
 import {
@@ -33,7 +34,7 @@ const orderEntity = createEntity({
   },
 });
 
-const orderTable = buildDrizzleTable("mmh-order", orderEntity);
+const orderTable = buildEntityTable("mmh-order", orderEntity);
 
 // Snapshot what each MSP-apply observed via ctx.loadAggregate.
 const confirmLoadCounts: number[] = [];
@@ -132,7 +133,7 @@ async function postWrite(correlationId: string, item: string) {
 async function drainUntilShipped(aggregateId: string, maxPasses = 10): Promise<void> {
   for (let i = 0; i < maxPasses; i++) {
     await stack.eventDispatcher?.runOnce();
-    const rows = await stack.db.select().from(eventsTable);
+    const rows = await selectMany(stack.db, eventsTable);
     if (rows.some((r) => r.aggregateId === aggregateId && r.type === "mmh:event:shipped")) return;
   }
   throw new Error(`drainUntilShipped: never saw shipped event for ${aggregateId}`);
@@ -147,7 +148,7 @@ describe("Runde 3 / C.2b — MSP-apply ctx cascades", () => {
 
     await stack.eventDispatcher?.runOnce();
 
-    const rows = await stack.db.select().from(eventsTable);
+    const rows = await selectMany(stack.db, eventsTable);
     const types = rows.map((r) => r.type).sort();
     // Order: CRUD create, placed, confirmed (hop 1 fired).
     expect(types).toContain("mmh-order.created");
@@ -160,7 +161,7 @@ describe("Runde 3 / C.2b — MSP-apply ctx cascades", () => {
 
     // Find the aggregateId from the first placed event.
     await stack.eventDispatcher?.runOnce();
-    const placedRow = (await stack.db.select().from(eventsTable)).find(
+    const placedRow = (await selectMany(stack.db, eventsTable)).find(
       (r) => r.type === "mmh:event:placed",
     );
     expect(placedRow).toBeDefined();
@@ -168,7 +169,7 @@ describe("Runde 3 / C.2b — MSP-apply ctx cascades", () => {
 
     await drainUntilShipped(aggregateId);
 
-    const rows = (await stack.db.select().from(eventsTable))
+    const rows = (await selectMany(stack.db, eventsTable))
       .filter((r) => r.aggregateId === aggregateId)
       .sort((a, b) => Number(a.id - b.id));
 
@@ -220,7 +221,7 @@ describe("Runde 3 / C.2b — MSP-apply ctx cascades", () => {
     await stack.eventDispatcher?.runOnce();
 
     // Every event written on this chain belongs to the admin's tenant.
-    const rows = await stack.db.select().from(eventsTable);
+    const rows = await selectMany(stack.db, eventsTable);
     for (const row of rows) {
       expect(row.tenantId).toBe(admin.tenantId);
     }

package/src/pipeline/__tests__/{msp-rebuild.integration.ts → msp-rebuild.integration.test.ts}

@@ -15,12 +15,13 @@
 // carry a different state row (kumiko_event_consumers, not kumiko_projections)
 // and a different apply signature (3rd ctx arg).
 
-import { eq, sql } from "drizzle-orm";
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { sql } from "@cosmicdrift/kumiko-framework/db";
 import { z } from "zod";
 import { integer as pgInteger, table as pgTable, uuid as pgUuid } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { asRawClient, selectMany, updateMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import {
   eventConsumerStateTable,
@@ -41,13 +42,13 @@ const invoiceEntity = createEntity({
   table: "read_mspreb_invoices",
   fields: { customer: createTextField({ required: true }) },
 });
-const invoiceTable = buildDrizzleTable("msp-reb-invoice", invoiceEntity);
+const invoiceTable = buildEntityTable("msp-reb-invoice", invoiceEntity);
 
 const paymentEntity = createEntity({
   table: "read_mspreb_payments",
   fields: { customer: createTextField({ required: true }) },
 });
-const paymentTable = buildDrizzleTable("msp-reb-payment", paymentEntity);
+const paymentTable = buildEntityTable("msp-reb-payment", paymentEntity);
 
 // Main read-model: running balance per customer.
 const balanceTable = pgTable("read_mspreb_balance", {
@@ -88,33 +89,17 @@ const feature = defineFeature("mspreb", (r) => {
     apply: {
       [invoiceBilled.name]: async (event, tx) => {
         const p = event.payload as { customer: string; cents: number };
-        await tx
-          .insert(balanceTable)
-          .values({
-            customer: p.customer,
-            tenantId: event.tenantId,
-            invoicesCents: p.cents,
-            paymentsCents: 0,
-          })
-          .onConflictDoUpdate({
-            target: balanceTable.customer,
-            set: { invoicesCents: sql`${balanceTable.invoicesCents} + ${p.cents}` },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_mspreb_balance" (customer, tenant_id, invoices_cents, payments_cents) VALUES ($1::uuid, $2::uuid, $3, 0) ON CONFLICT (customer) DO UPDATE SET invoices_cents = read_mspreb_balance.invoices_cents + $3`,
+          [p.customer, event.tenantId, p.cents],
+        );
       },
       [paymentReceived.name]: async (event, tx) => {
         const p = event.payload as { customer: string; cents: number };
-        await tx
-          .insert(balanceTable)
-          .values({
-            customer: p.customer,
-            tenantId: event.tenantId,
-            invoicesCents: 0,
-            paymentsCents: p.cents,
-          })
-          .onConflictDoUpdate({
-            target: balanceTable.customer,
-            set: { paymentsCents: sql`${balanceTable.paymentsCents} + ${p.cents}` },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_mspreb_balance" (customer, tenant_id, invoices_cents, payments_cents) VALUES ($1::uuid, $2::uuid, 0, $3) ON CONFLICT (customer) DO UPDATE SET payments_cents = read_mspreb_balance.payments_cents + $3`,
+          [p.customer, event.tenantId, p.cents],
+        );
       },
     },
   });
@@ -248,10 +233,12 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
     // Disable the saga MSP for this test — it runs on the same event types
     // and would trip its own ctx.appendEvent path during live delivery
     // (which is fine in production, but noise here).
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "disabled", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "disabled", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
 
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: alice, cents: 10_00 }, admin);
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: alice, cents: 5_00 }, admin);
@@ -263,7 +250,7 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: bob, cents: 7_50 }, admin);
     await runFullDispatcher();
 
-    const liveRows = await stack.db.select().from(balanceTable).orderBy(balanceTable.customer);
+    const liveRows = await selectMany(stack.db, balanceTable);
     const aliceLive = liveRows.find((r) => r.customer === alice);
     const bobLive = liveRows.find((r) => r.customer === bob);
     expect(aliceLive).toMatchObject({ invoicesCents: 15_00, paymentsCents: 3_00 });
@@ -279,7 +266,7 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
     expect(result.eventsProcessed).toBe(4); // 2 invoices + 1 payment + 1 invoice
     expect(result.lastProcessedEventId).toBeGreaterThan(0n);
 
-    const rebuiltRows = await stack.db.select().from(balanceTable).orderBy(balanceTable.customer);
+    const rebuiltRows = await selectMany(stack.db, balanceTable);
     expect(rebuiltRows).toEqual(liveRows);
 
     // Consumer cursor is at head after rebuild — the live dispatcher should
@@ -291,28 +278,29 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
 
   test("rebuild after table corruption restores the correct state", async () => {
     const carol = "00000000-0000-4000-8000-000000000c03";
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "disabled", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "disabled", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: carol, cents: 42_00 }, admin);
     await runFullDispatcher();
 
     // Corrupt the read-model — simulate a buggy apply() landing bad numbers.
-    await stack.db
-      .update(balanceTable)
-      .set({ invoicesCents: -999, paymentsCents: 999 })
-      .where(eq(balanceTable.customer, carol));
+    await updateMany(
+      stack.db,
+      balanceTable,
+      { invoicesCents: -999, paymentsCents: 999 },
+      { customer: carol },
+    );
 
     await rebuildMultiStreamProjection(BALANCE_MSP, {
       db: stack.db,
       registry: stack.registry,
     });
 
-    const [row] = await stack.db
-      .select()
-      .from(balanceTable)
-      .where(eq(balanceTable.customer, carol));
+    const [row] = await selectMany(stack.db, balanceTable, { customer: carol });
     expect(row).toMatchObject({ invoicesCents: 42_00, paymentsCents: 0 });
   });
 });
@@ -339,18 +327,22 @@ describe("rebuildMultiStreamProjection — guard rails", () => {
   test("saga MSP using ctx.appendEvent fails rebuild at the first appendEvent call", async () => {
     const dave = "00000000-0000-4000-8000-000000000d04";
     // Disable the saga in live passes so we control when the apply runs.
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "disabled", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "disabled", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: dave, cents: 1_00 }, admin);
     // Put the consumer back to idle so rebuild doesn't treat it as "just
     // disabled on purpose" — rebuild is opinionated about WHEN it refuses,
     // not about the consumer's live-status.
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "idle", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "idle", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
 
     await expect(
       rebuildMultiStreamProjection(SAGA_MSP, {