@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/engine/__tests__/codemod-pipeline.test.ts

@@ -1,13 +1,13 @@
+import { afterAll, beforeAll, describe, expect, it, mock } from "bun:test";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 
 // Bun.Glob is only used by scanForCandidates / runCodemod, not by
 // analyzeFile or convertFile. Those higher-level functions are tested
 // in the integration suite; unit tests here focus on file-level
 // operations which don't need Glob. A stub class prevents import
-// errors in vitest (which runs on Node, not Bun).
-vi.mock("bun", () => {
+// errors in bun (which runs on Node, not Bun).
+mock.module("bun", () => {
   class StubGlob {
     scanSync(): never {
       throw new Error("Bun.Glob is not available in unit-test mode");

package/src/engine/__tests__/config-helpers.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "bun:test";
 import {
   access,
   createSystemConfig,

package/src/engine/__tests__/effective-features.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { computeEffectiveFeatures, type ToggleReader } from "../effective-features";
 import type { FeatureDefinition, Registry } from "../types";
 

package/src/engine/__tests__/engine.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { createTestUser } from "../../stack";
 import { rolesOf } from "../../testing/access-assertions";

package/src/engine/__tests__/entity-handlers.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import {
   createEntityExecutor,
   defineEntityCreateHandler,
@@ -170,7 +170,7 @@ describe("defineProjectionQueryHandler", () => {
     );
     const fakeRows = [{ customer: "a", totalCents: 100 }];
     const ctx = {
-      queryProjection: vi.fn().mockResolvedValue(fakeRows),
+      queryProjection: mock().mockResolvedValue(fakeRows),
     };
     const result = await def.handler(
       // biome-ignore lint/suspicious/noExplicitAny: test shim — handler only touches ctx.queryProjection here.
@@ -191,7 +191,7 @@ describe("defineProjectionQueryHandler", () => {
       "showcase:projection:customer-revenue",
       { unsafeAllTenants: true },
     );
-    const ctx = { queryProjection: vi.fn().mockResolvedValue([]) };
+    const ctx = { queryProjection: mock().mockResolvedValue([]) };
     await def.handler(
       // biome-ignore lint/suspicious/noExplicitAny: test shim.
       { type: "revenue:list", user: {} as any, payload: {} },

package/src/engine/__tests__/event-helpers.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { z } from "zod";
 import { emitEvent, typedPayload } from "../event-helpers";
 import type { EventDef } from "../types/handlers";
@@ -11,7 +11,7 @@ describe("emitEvent", () => {
   };
 
   test("delegates to ctx.appendEvent with eventDef.name as the type", async () => {
-    const ctx = { unsafeAppendEvent: vi.fn().mockResolvedValue(undefined) };
+    const ctx = { unsafeAppendEvent: mock().mockResolvedValue(undefined) };
     await emitEvent(ctx, orderPlaced, {
       aggregateId: "agg-1",
       aggregateType: "pubsub-order",
@@ -26,7 +26,7 @@ describe("emitEvent", () => {
   });
 
   test("payload type is inferred from the eventDef — wrong shape is a compile error", async () => {
-    const ctx = { unsafeAppendEvent: vi.fn().mockResolvedValue(undefined) };
+    const ctx = { unsafeAppendEvent: mock().mockResolvedValue(undefined) };
     // Runtime check: compile-time narrowing is the real win, but we also
     // make sure the value flows through unchanged.
     await emitEvent(ctx, orderPlaced, {

package/src/engine/__tests__/extends-registrar.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { z } from "zod";
 import { createEntity, createRegistry, createTextField, defineFeature } from "../index";
 
@@ -24,7 +24,7 @@ describe("extendsRegistrar", () => {
   });
 
   test("registry calls onRegister for each extension usage", () => {
-    const onRegister = vi.fn();
+    const onRegister = mock();
 
     const ext = defineFeature("tags", (r) => {
       r.extendsRegistrar("tags", { onRegister });
@@ -99,7 +99,7 @@ describe("extendsRegistrar", () => {
   });
 
   test("extension preSave hooks fire for entity-scoped handlers", () => {
-    const preSaveFn = vi.fn(async (changes: Record<string, unknown>) => changes);
+    const preSaveFn = mock(async (changes: Record<string, unknown>) => changes);
 
     const ext = defineFeature("audit", (r) => {
       r.extendsRegistrar("audited", {
@@ -137,7 +137,7 @@ describe("extendsRegistrar", () => {
   });
 
   test("extension postSave hooks are entity hooks", () => {
-    const postSaveFn = vi.fn(async () => {});
+    const postSaveFn = mock(async () => {});
 
     const ext = defineFeature("audit", (r) => {
       r.extendsRegistrar("audited", {

package/src/engine/__tests__/factories-long-text.test.ts

@@ -8,7 +8,7 @@
 // source-code / markdown / blog-posts — explicitly NOT sortable /
 // searchable / filterable. Type-level enforcement statt soft-defaults.
 
-import { describe, expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "bun:test";
 import { createLongTextField } from "../factories";
 import type { LongTextFieldDef } from "../types";
 

package/src/engine/__tests__/factories-time.test.ts

@@ -5,7 +5,7 @@
 // echte TZ-Konvertierung (Wall-Clock ↔ UTC) testen wir später beim
 // DB-Wrapper-Schritt.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   createLocatedTimestampField,
   createTimestampField,

package/src/engine/__tests__/field-predicates.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import type { AnyFileFieldDef, FieldDefinition } from "../types";
 import { isFileField } from "../types";
 

package/src/engine/__tests__/hook-phases.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, defineFeature, HookPhases } from "../index";
 import type { PostSaveHookFn } from "../types";

package/src/engine/__tests__/identifiers.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { parseTenantId } from "../types/identifiers";
 
 describe("parseTenantId", () => {

package/src/engine/__tests__/lifecycle-hooks.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, defineFeature } from "../index";
 import type { PostSaveHookFn, PreDeleteHookFn, PreSaveHookFn, SaveContext } from "../types";

package/src/engine/__tests__/nav.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
 import { createEntity, createTextField } from "../factories";

package/src/engine/__tests__/ownership.test.ts

@@ -1,5 +1,4 @@
-import { sql } from "drizzle-orm";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   buildOwnershipClause,
   from,
@@ -268,14 +267,14 @@ describe("userCanWriteFieldRow() — Straddle-attack prevention", () => {
 // --- buildOwnershipClause() — SQL WHERE builder ---
 
 describe("buildOwnershipClause() — SQL WHERE builder", () => {
-  // Fake Drizzle table — the builder only needs `table[columnName]` to
-  // resolve an opaque column reference, and hands it to eq()/inArray().
-  // We don't assert on the serialized SQL text (dialect-dependent); we
-  // assert on the diskriminated OwnershipClause return.
-  const fakeTable = {
-    teamId: sql.raw("team_id"),
-    assigneeId: sql.raw("assignee_id"),
-    tenantId: sql.raw("tenant_id"),
+  // Fake table — buildOwnershipClause checks (table[field] !== undefined)
+  // and falls back to snake_case mapping for column names. The fixture
+  // shape mirrors drizzle's pgTable for the purposes of the assertions
+  // here; we don't assert on the serialized SQL text.
+  const fakeTable: Record<string, unknown> = {
+    teamId: { name: "team_id" },
+    assigneeId: { name: "assignee_id" },
+    tenantId: { name: "tenant_id" },
   };
 
   test("undefined access map → pass (public entity)", () => {
@@ -372,7 +371,7 @@ describe("buildOwnershipClause() — SQL WHERE builder", () => {
   test("where-rule escape hatch: caller's SQL passed through", () => {
     const user = mkUser({ roles: ["Auditor"] });
     const map: OwnershipMap = {
-      Auditor: { kind: "where", where: () => sql`custom_expr_42 = 1` },
+      Auditor: { kind: "where", where: () => ({ sqlText: "custom_expr_42 = 1", params: [] }) },
     };
     const clause = buildOwnershipClause(user, map, fakeTable);
     expect(clause.kind).toBe("sql");

package/src/engine/__tests__/parse-ref-target.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { parseRefTarget } from "../parse-ref-target";
 
 // Tier 2.7e Cross-Feature: parser-Konvention für ReferenceFieldDef.

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

@@ -3,8 +3,8 @@
 // Sub-step-builders (branch, forEach) live in pipeline-sub-pipelines.test.ts;
 // boot-validator in validate-projection-allowlist.test.ts.
 
+import { describe, expect, it } from "bun:test";
 import { randomUUID } from "node:crypto";
-import { describe, expect, it } from "vitest";
 import { z } from "zod";
 import { TestUsers } from "../../stack";
 import { defineWriteHandler } from "../define-handler";

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

@@ -43,12 +43,12 @@
 // Unit-side tests in pipeline-vertical-slice.test.ts cover the same
 // surface against an empty ctx mock; this file is the real-stack gate.
 
-import { eq } from "drizzle-orm";
-import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
+import { table, text, timestamp, uuid } from "../../db/dialect";
 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 { eventsTable } from "../../event-store";
 import {
   setupTestStack,
@@ -129,7 +129,7 @@ const compoundHandler = defineWriteHandler({
 
 // Read-side projection-table for the unsafeProjectionUpsert handler.
 // Plain pgTable (not r.entity) — it's a read-side log, not an aggregate.
-const pipelineDemoLogTable = pgTable("pipeline_demo_log", {
+const pipelineDemoLogTable = table("pipeline_demo_log", {
   id: uuid("id").primaryKey().defaultRandom(),
   tenantId: uuid("tenant_id").notNull(),
   correlationId: text("correlation_id").notNull().unique(),
@@ -172,7 +172,7 @@ const widgetEntity = createEntity({
   table: "pipeline_widget",
   fields: { label: createTextField({ required: true }) },
 });
-const widgetTable = buildDrizzleTable("widget", widgetEntity);
+const widgetTable = buildEntityTable("widget", widgetEntity);
 const widgetExecutor = createEventStoreExecutor(widgetTable, widgetEntity, {
   entityName: "widget",
 });
@@ -341,7 +341,7 @@ const lookupHandler = defineWriteHandler({
     ({ event, r }) => [
       r.step.read.findOne("widget", {
         table: widgetTable,
-        where: () => eq(widgetTable.id, event.payload.id),
+        where: () => ({ id: event.payload.id }),
       }),
       r.step.return(({ steps }) => {
         const row = steps["widget"] as { label?: string } | null;
@@ -391,7 +391,7 @@ const purgeLogHandler = defineWriteHandler({
   perform: pipeline<z.infer<typeof purgeLogSchema>, { ok: true }>(({ event, r }) => [
     r.step.unsafeProjectionDelete({
       table: pipelineDemoLogTable,
-      where: () => eq(pipelineDemoLogTable.correlationId, event.payload.correlationId),
+      where: () => ({ correlationId: event.payload.correlationId }),
     }),
     r.step.return({ isSuccess: true as const, data: { ok: true } }),
   ]),
@@ -496,8 +496,9 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     // across runs — order-independent assertions are the only kind that
     // stay green when test-files grow (Memory `feedback_jsdom_lies_*`
     // analog: order-dependent tests are flaky-in-waiting).
-    await stack.db.delete(pipelineDemoLogTable);
-    await stack.db.delete(widgetTable);
+    // biome-ignore lint/suspicious/noExplicitAny: test cast
+    await asRawClient(stack.db).unsafe(`DELETE FROM "${(pipelineDemoLogTable as any).tableName}"`);
+    await asRawClient(stack.db).unsafe(`DELETE FROM "${widgetTable.tableName}"`);
   });
 
   test("HTTP write call goes through dispatcher → pipeline-runner → r.step.return", async () => {
@@ -571,7 +572,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     );
     expect(res.status).toBe(200);
 
-    const rows = await stack.db.select().from(pipelineDemoLogTable);
+    const rows = await selectMany(stack.db, pipelineDemoLogTable);
     expect(rows).toHaveLength(1);
     expect(rows[0]).toMatchObject({
       correlationId: "corr-1",
@@ -592,10 +593,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
       admin,
     );
 
-    const rows = await stack.db
-      .select()
-      .from(pipelineDemoLogTable)
-      .where(eq(pipelineDemoLogTable.correlationId, "corr-2"));
+    const rows = await selectMany(stack.db, pipelineDemoLogTable, { correlationId: "corr-2" });
     expect(rows).toHaveLength(1);
     expect(rows[0]?.message).toBe("v2 — overwritten");
   });
@@ -614,7 +612,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
 
     // Verify the projection-row landed too — the executor's inline
     // projection writes into the widget table in the same TX.
-    const rows = await stack.db.select().from(widgetTable);
+    const rows = await selectMany(stack.db, widgetTable);
     expect(rows).toHaveLength(1);
     expect(rows[0]).toMatchObject({ label: "first widget", id: body.data.id });
   });
@@ -640,7 +638,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     expect(updatedBody.data.id).toBe(widgetId);
 
     // Projection-row reflects the new label.
-    const rows = await stack.db.select().from(widgetTable).where(eq(widgetTable.id, widgetId));
+    const rows = await selectMany(stack.db, widgetTable, { id: widgetId });
     expect(rows).toHaveLength(1);
     expect(rows[0]).toMatchObject({ id: widgetId, label: "after" });
   });
@@ -658,10 +656,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     // The aggregate stream should carry both the auto-generated CRUD
     // event (widget.created) AND the appended annotated event. Direct
     // event-store query is the simplest assertion.
-    const events = await stack.db
-      .select()
-      .from(eventsTable)
-      .where(eq(eventsTable.aggregateId, widgetId));
+    const events = await selectMany(stack.db, eventsTable, { aggregateId: widgetId });
     const types = events.map((e) => e["type"]);
     expect(types).toContain("demo-pipeline:event:annotated");
     expect(types.length).toBeGreaterThanOrEqual(2); // created + annotated
@@ -679,7 +674,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     // Capture row-count before — beforeEach doesn't truncate widget,
     // earlier tests in this run leave rows. We assert "broken did not
     // add a new row" by comparing before/after.
-    const before = await stack.db.select().from(widgetTable);
+    const before = await selectMany(stack.db, widgetTable);
 
     const res = await stack.http.write("demo-pipeline:write:widget:create-broken", {}, admin);
     expect(res.status).not.toBe(200);
@@ -688,7 +683,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     expect(body.isSuccess).toBe(false);
     expect(body.error.code).toBeDefined();
 
-    const after = await stack.db.select().from(widgetTable);
+    const after = await selectMany(stack.db, widgetTable);
     expect(after).toHaveLength(before.length);
   });
 
@@ -728,7 +723,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
   });
 
   test("read.findMany returns the row array (count matches table state)", async () => {
-    const before = await stack.db.select().from(widgetTable);
+    const before = await selectMany(stack.db, widgetTable);
     const res = await stack.http.write("demo-pipeline:write:widget:list", {}, admin);
     expect(res.status).toBe(200);
     const body = (await res.json()) as { isSuccess: true; data: { count: number } };
@@ -739,7 +734,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     // Seed enough widgets so a limit-1 result is verifiably truncated.
     await stack.http.write("demo-pipeline:write:widget:create", { label: "limit-test-1" }, admin);
     await stack.http.write("demo-pipeline:write:widget:create", { label: "limit-test-2" }, admin);
-    const total = await stack.db.select().from(widgetTable);
+    const total = await selectMany(stack.db, widgetTable);
     expect(total.length).toBeGreaterThanOrEqual(2);
 
     const res = await stack.http.write("demo-pipeline:write:widget:list-one", {}, admin);
@@ -750,10 +745,9 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
 
   test("unsafeProjectionDelete is a silent no-op when the where-clause matches no rows", async () => {
     // Precondition: nothing with this correlation-id exists.
-    const before = await stack.db
-      .select()
-      .from(pipelineDemoLogTable)
-      .where(eq(pipelineDemoLogTable.correlationId, "no-match-id"));
+    const before = await selectMany(stack.db, pipelineDemoLogTable, {
+      correlationId: "no-match-id",
+    });
     expect(before).toHaveLength(0);
 
     // Purge anyway — drizzle's DELETE-WHERE with no match commits silently.
@@ -774,10 +768,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
       { correlationId: "to-purge", message: "delete-me" },
       admin,
     );
-    const seeded = await stack.db
-      .select()
-      .from(pipelineDemoLogTable)
-      .where(eq(pipelineDemoLogTable.correlationId, "to-purge"));
+    const seeded = await selectMany(stack.db, pipelineDemoLogTable, { correlationId: "to-purge" });
     expect(seeded).toHaveLength(1);
 
     const res = await stack.http.write(
@@ -787,10 +778,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     );
     expect(res.status).toBe(200);
 
-    const after = await stack.db
-      .select()
-      .from(pipelineDemoLogTable)
-      .where(eq(pipelineDemoLogTable.correlationId, "to-purge"));
+    const after = await selectMany(stack.db, pipelineDemoLogTable, { correlationId: "to-purge" });
     expect(after).toHaveLength(0);
   });
 
@@ -801,10 +789,9 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
       admin,
     );
     expect(res.status).toBe(200);
-    const rows = await stack.db
-      .select()
-      .from(pipelineDemoLogTable)
-      .where(eq(pipelineDemoLogTable.correlationId, "branch-truthy"));
+    const rows = await selectMany(stack.db, pipelineDemoLogTable, {
+      correlationId: "branch-truthy",
+    });
     expect(rows).toHaveLength(1);
     expect(rows[0]?.message).toBe("real");
   });
@@ -816,10 +803,9 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
       admin,
     );
     expect(res.status).toBe(200);
-    const rows = await stack.db
-      .select()
-      .from(pipelineDemoLogTable)
-      .where(eq(pipelineDemoLogTable.correlationId, "branch-falsy"));
+    const rows = await selectMany(stack.db, pipelineDemoLogTable, {
+      correlationId: "branch-falsy",
+    });
     expect(rows).toHaveLength(0);
   });
 
@@ -834,7 +820,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     const body = (await res.json()) as { isSuccess: true; data: { count: number } };
     expect(body.data.count).toBe(3);
 
-    const rows = await stack.db.select().from(pipelineDemoLogTable);
+    const rows = await selectMany(stack.db, pipelineDemoLogTable);
     const correlationIds = rows.map((r) => r["correlationId"]).sort();
     expect(correlationIds).toEqual(ids.slice().sort());
   });
@@ -858,8 +844,8 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     // projection-row insert that aggregate.create performed must
     // disappear with the rollback. Otherwise pipeline-form handlers
     // silently leak partial state on mid-pipeline failures.
-    const beforeWidgets = await stack.db.select().from(widgetTable);
-    const beforeEvents = await stack.db.select().from(eventsTable);
+    const beforeWidgets = await selectMany(stack.db, widgetTable);
+    const beforeEvents = await selectMany(stack.db, eventsTable);
 
     const res = await stack.http.write(
       "demo-pipeline:write:widget:create-then-throw",
@@ -868,8 +854,8 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     );
     expect(res.status).toBe(500);
 
-    const afterWidgets = await stack.db.select().from(widgetTable);
-    const afterEvents = await stack.db.select().from(eventsTable);
+    const afterWidgets = await selectMany(stack.db, widgetTable);
+    const afterEvents = await selectMany(stack.db, eventsTable);
     expect(afterWidgets.length).toBe(beforeWidgets.length);
     expect(afterEvents.length).toBe(beforeEvents.length);
   });
@@ -879,7 +865,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     // its own scope save/restore + sub-step-list runner. A regression
     // there would let iteration-1's aggregate.create commit while
     // iteration-2's throw aborts the rest, leaving partial state.
-    const beforeWidgets = await stack.db.select().from(widgetTable);
+    const beforeWidgets = await selectMany(stack.db, widgetTable);
 
     const res = await stack.http.write(
       "demo-pipeline:write:widget:foreach-then-throw",
@@ -888,7 +874,7 @@ describe("defineWriteHandler({ perform: pipeline(...) }) — real dispatcher pat
     );
     expect(res.status).toBe(500);
 
-    const afterWidgets = await stack.db.select().from(widgetTable);
+    const afterWidgets = await selectMany(stack.db, widgetTable);
     expect(afterWidgets.length).toBe(beforeWidgets.length);
   });
 });

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

@@ -13,7 +13,7 @@
 // every step inside a pipeline-form handler would be untraceable —
 // and we wouldn't notice until a prod incident lacks the breadcrumbs.
 
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { setupTestStack, type TestStack, TestUsers, unsafeCreateEntityTable } from "../../stack";
 import { createRecordingProvider, type RecordingProvider } from "../../testing";

package/src/engine/__tests__/{pipeline-performance.integration.ts → pipeline-performance.integration.test.ts}

@@ -22,7 +22,7 @@
 // gate; if a future regression suspect needs that breakdown, extend
 // here with a longer-pipeline handler variant.
 
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { setupTestStack, type TestStack, TestUsers, unsafeCreateEntityTable } from "../../stack";
 import { defineFeature } from "../define-feature";

package/src/engine/__tests__/pipeline-sub-pipelines.test.ts

@@ -5,7 +5,7 @@
 // to steps/_no-return-guard.ts). Tests cover happy paths, scope
 // hygiene, error-propagation and build-time guards.
 
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { z } from "zod";
 import { TestUsers } from "../../stack";
 import { defineWriteHandler } from "../define-handler";

package/src/engine/__tests__/post-query-hook.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, defineFeature } from "../index";
 import type { PostQueryHookFn } from "../types";

package/src/engine/__tests__/projection-helpers.test.ts

@@ -1,15 +1,19 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import type { StoredEvent } from "../../event-store/event-store";
 import { setFields } from "../projection-helpers";
 import type { ProjectionTable } from "../types/projection";
 
-// Minimal fake table: only the `id` column is needed for setFields, and
-// setFields only hands it to `eq()` — no actual SQL runs in the unit test.
-// The cast mirrors ProjectionTable's deliberate erasure: the framework
-// doesn't know user table shapes at compile time, so real Drizzle tables
-// go through the same `any`-ish generic parameter.
+// Minimal fake table: only the `id` column is needed for setFields, plus
+// the kumiko:schema:Name + kumiko:schema:Columns symbols that bun-db introspects for
+// table-name + column-mapping. We don't run real SQL — unsafe() is mocked.
 const fakeIdCol = { name: "id" };
-const fakeTable = { id: fakeIdCol, __name: "fake_table" } as unknown as ProjectionTable;
+const fakeTable = Object.assign(
+  { id: fakeIdCol },
+  {
+    [Symbol.for("kumiko:schema:Name")]: "fake_table",
+    [Symbol.for("kumiko:schema:Columns")]: { id: fakeIdCol },
+  },
+) as unknown as ProjectionTable;
 
 function makeFakeEvent(overrides: Partial<StoredEvent> = {}): StoredEvent {
   return {
@@ -29,30 +33,34 @@ function makeFakeEvent(overrides: Partial<StoredEvent> = {}): StoredEvent {
   };
 }
 
-// Drizzle's tx.update(...).set(...).where(...) chain — capture each step.
+// bun-db path: setFields calls updateMany(tx, table, set, where) which lands
+// on asRawClient(tx).unsafe(sqlText, params). Capture the SQL + params.
 function makeFakeTx() {
-  const where = vi.fn().mockResolvedValue(undefined);
-  const set = vi.fn(() => ({ where }));
-  const update = vi.fn(() => ({ set }));
-  return { fakeTx: { update } as never, update, set, where };
+  const unsafe = mock(async (_sqlText: string, _params: unknown[]) => [] as unknown[]);
+  const fakeTx = { unsafe, begin: mock() } as never;
+  return { fakeTx, unsafe };
 }
 
 describe("setFields", () => {
   test("returns an apply fn that UPDATEs the passed fields WHERE id = aggregateId", async () => {
     const apply = setFields(fakeTable, { status: "sent" });
-    const { fakeTx, update, set } = makeFakeTx();
+    const { fakeTx, unsafe } = makeFakeTx();
     await apply(makeFakeEvent(), fakeTx);
-    expect(update).toHaveBeenCalledWith(fakeTable);
-    expect(set).toHaveBeenCalledWith({ status: "sent" });
+    expect(unsafe).toHaveBeenCalledTimes(1);
+    const [sqlText, params] = unsafe.mock.calls[0]!;
+    expect(sqlText).toMatch(/UPDATE "fake_table" SET "status" = \$1.*WHERE "id" = \$2/);
+    expect(params).toEqual(["sent", "agg-42"]);
   });
 
   test("fields as a function receives the event and returns the field values", async () => {
     const apply = setFields(fakeTable, (event) => ({
       status: (event.payload as { newStatus: string }).newStatus,
     }));
-    const { fakeTx, set } = makeFakeTx();
+    const { fakeTx, unsafe } = makeFakeTx();
     await apply(makeFakeEvent({ payload: { newStatus: "cancelled" } }), fakeTx);
-    expect(set).toHaveBeenCalledWith({ status: "cancelled" });
+    expect(unsafe).toHaveBeenCalledTimes(1);
+    const [, params] = unsafe.mock.calls[0]!;
+    expect(params).toEqual(["cancelled", "agg-42"]);
   });
 
   test("throws at construction time when the table has no 'id' column", () => {

package/src/engine/__tests__/projection.test.ts

@@ -1,5 +1,5 @@
-import { integer, pgTable, uuid } from "drizzle-orm/pg-core";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
+import { integer, type SchemaTable, table, uuid } from "../../db/dialect";
 import type { ProjectionDefinition } from "../../engine/types";
 import { defineFeature } from "../define-feature";
 import { createEntity, createTextField } from "../factories";
@@ -9,10 +9,10 @@ import { createRegistry } from "../registry";
 // the projection itself (apply, TX semantics) is covered by the MietNomade
 // integration suite; this file focuses on the registrar/registry contracts
 // that fire BEFORE any write happens.
-const testTable = pgTable("test_projection", {
+const testTable = table("test_projection", {
   id: uuid("id").primaryKey(),
   count: integer("count").notNull().default(0),
-});
+}) as unknown as SchemaTable;
 
 function exampleEntity(name = "unit") {
   return createEntity({

package/src/engine/__tests__/qualified-name.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   isKebabSegment,
   isValidQn,