@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

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.

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);
     }