@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

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

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

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

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

package/src/migrations/projection-detection.ts

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

package/src/migrations/schema-drift.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.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";