@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/engine/__tests__/raw-table.test.ts

@@ -2,16 +2,17 @@
 // aggregation. Full DB roundtrip (setupTestStack pushes the table → INSERT
 // / SELECT) lives in src/__tests__/raw-table.integration.ts.
 
-import { pgTable, text } from "drizzle-orm/pg-core";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
+import type { SchemaTable } from "../../db/dialect";
+import { table, text } from "../../db/dialect";
 import { defineFeature } from "../define-feature";
 import { createRegistry } from "../registry";
 import type { ProjectionDefinition } from "../types";
 
-const probeTable = pgTable("rt_probe_table", {
+const probeTable = table("rt_probe_table", {
   id: text("id").primaryKey(),
 });
-const probeTableTwo = pgTable("rt_probe_table_two", {
+const probeTableTwo = table("rt_probe_table_two", {
   id: text("id").primaryKey(),
 });
 
@@ -107,9 +108,9 @@ describe("createRegistry — rawTable aggregation", () => {
     // when one role writes (primary cache) and a second role reads
     // (alias view). Push-time dedupe keeps the boot to a single CREATE;
     // the registry keeps both entries so callers can resolve either name.
-    const sharedT = pgTable("rt_shared_dedupe", {
+    const sharedT = table("rt_shared_dedupe", {
       id: text("id").primaryKey(),
-    });
+    }) as unknown as SchemaTable;
     const feat = defineFeature("dedupe", (r) => {
       r.rawTable("primary", sharedT, { reason: "main writer" });
       r.rawTable("alias", sharedT, { reason: "alias for read consumers" });
@@ -126,9 +127,9 @@ describe("createRegistry — rawTable aggregation", () => {
     // r.projection() is almost always an authoring bug — two owners on
     // the same physical table, one event-sourced, one bypass. Boot
     // throws so the failure points at the misconfiguration site.
-    const sharedT = pgTable("rt_collision_phys", {
+    const sharedT = table("rt_collision_phys", {
       id: text("id").primaryKey(),
-    });
+    }) as unknown as SchemaTable;
     const projection: ProjectionDefinition = {
       name: "shared-summary",
       source: "shared",

package/src/engine/__tests__/resolve-config-or-param.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { createTenantConfig, createUserConfig } from "../config-helpers";
 import { type ClampInfo, resolveConfigOrParam } from "../resolve-config-or-param";
 import type {
@@ -25,7 +25,7 @@ function makeCtx(entries: Record<string, { def: KeyEntry; fallback: unknown }>)
     getConfigKey: (key: string) => entries[key]?.def,
   } as unknown as Registry;
 
-  const configFn = vi.fn(async <T extends ConfigKeyType>(handle: ConfigKeyHandle<T>) => {
+  const configFn = mock(async <T extends ConfigKeyType>(handle: ConfigKeyHandle<T>) => {
     return entries[handle.name]?.fallback as ConfigValue<T> | undefined;
   });
 
@@ -273,14 +273,14 @@ describe("resolveConfigOrParam — onClamp audit hook", () => {
 
   test("onClamp does NOT fire when value is within bounds", async () => {
     const { ctx } = makeCtx({ k: { def: boundedDef, fallback: 10 } });
-    const onClamp = vi.fn();
+    const onClamp = mock();
     await resolveConfigOrParam(ctx, handleFor("k", "number"), 50, { onClamp });
     expect(onClamp).not.toHaveBeenCalled();
   });
 
   test("onClamp does NOT fire on exact boundary values", async () => {
     const { ctx } = makeCtx({ k: { def: boundedDef, fallback: 10 } });
-    const onClamp = vi.fn();
+    const onClamp = mock();
     await resolveConfigOrParam(ctx, handleFor("k", "number"), 1, { onClamp });
     await resolveConfigOrParam(ctx, handleFor("k", "number"), 100, { onClamp });
     expect(onClamp).not.toHaveBeenCalled();
@@ -288,7 +288,7 @@ describe("resolveConfigOrParam — onClamp audit hook", () => {
 
   test("onClamp does NOT fire when value is coerced to NaN (no clamp happens, config fallback used)", async () => {
     const { ctx } = makeCtx({ k: { def: boundedDef, fallback: 10 } });
-    const onClamp = vi.fn();
+    const onClamp = mock();
     await resolveConfigOrParam(ctx, handleFor("k", "number"), "abc", { onClamp });
     expect(onClamp).not.toHaveBeenCalled();
   });

package/src/engine/__tests__/run-in.test.ts

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

package/src/engine/__tests__/schema-builder.test.ts

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

package/src/engine/__tests__/screen.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__/search-payload-extension.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEntity, createRegistry, defineFeature } from "../index";
 import type { SearchPayloadContributorFn } from "../types";
 
@@ -21,7 +21,7 @@ describe("searchPayloadExtension registration", () => {
       r.searchPayloadExtension(thing, noop);
     });
 
-    const entry = feature.searchPayloadExtensions["thing"];
+    const entry = feature.searchPayloadExtensions!["thing"];
     expect(entry).toHaveLength(1);
   });
 
@@ -35,7 +35,7 @@ describe("searchPayloadExtension registration", () => {
       r.searchPayloadExtension(thing, c2);
     });
 
-    expect(feature.searchPayloadExtensions["thing"]).toHaveLength(2);
+    expect(feature.searchPayloadExtensions!["thing"]).toHaveLength(2);
   });
 });
 

package/src/engine/__tests__/state-machine.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { UnprocessableError } from "../../errors";
 import { defineTransitions, guardTransition } from "../state-machine";
 

package/src/engine/__tests__/steps-aggregate-append-event.test.ts

@@ -1,9 +1,9 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import { getStep } from "../define-step";
 import { buildAggregateAppendEventStep } from "../steps/aggregate-append-event";
 import type { PipelineCtx } from "../types/step";
 
-const mockUnsafeAppendEvent = vi.fn();
+const mockUnsafeAppendEvent = mock();
 
 const mockCtx = {
   unsafeAppendEvent: mockUnsafeAppendEvent,
@@ -39,7 +39,7 @@ describe("buildAggregateAppendEventStep", () => {
 
 describe("aggregate.appendEvent run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("calls ctx.unsafeAppendEvent with resolved aggregateId and payload", async () => {
@@ -56,7 +56,7 @@ describe("aggregate.appendEvent run", () => {
       mockCtx,
     );
 
-    expect(mockUnsafeAppendEvent).toHaveBeenCalledOnce();
+    expect(mockUnsafeAppendEvent).toHaveBeenCalledTimes(1);
     const call = mockUnsafeAppendEvent.mock.calls[0]![0];
     expect(call).toMatchObject({
       aggregateId: "abc-123",
@@ -68,9 +68,9 @@ describe("aggregate.appendEvent run", () => {
 
   it("resolves function resolvers before calling unsafeAppendEvent", async () => {
     const stepDef = getStep("aggregate.appendEvent");
-    const idFn = vi.fn(() => "dynamic-id");
-    const payloadFn = vi.fn(() => ({ note: "dynamic" }));
-    const headersFn = vi.fn(() => ({ key: "val" }));
+    const idFn = mock(() => "dynamic-id");
+    const payloadFn = mock(() => ({ note: "dynamic" }));
+    const headersFn = mock(() => ({ key: "val" }));
 
     await stepDef!.run(
       {

package/src/engine/__tests__/steps-aggregate-create.test.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import type { EventStoreExecutor } from "../../db/event-store-executor";
 import { getStep } from "../define-step";
 import { buildAggregateCreateStep } from "../steps/aggregate-create";
 import type { PipelineCtx } from "../types/step";
 
-const mockCreate = vi.fn();
+const mockCreate = mock();
 const mockExecutor = { create: mockCreate } as unknown as EventStoreExecutor & {
   create: typeof mockCreate;
 };
@@ -39,7 +39,7 @@ describe("buildAggregateCreateStep", () => {
 
 describe("aggregate.create run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("resolves data and calls executor.create with user and db", async () => {
@@ -64,7 +64,7 @@ describe("aggregate.create run", () => {
 
   it("resolves a function data resolver before calling executor.create", async () => {
     const stepDef = getStep("aggregate.create");
-    const dataFn = vi.fn((ctx: PipelineCtx) => ({
+    const dataFn = mock((ctx: PipelineCtx) => ({
       label: (ctx.event.payload as { label: string }).label,
     }));
     mockExecutor.create.mockResolvedValue({

package/src/engine/__tests__/steps-aggregate-update.test.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import type { EventStoreExecutor } from "../../db/event-store-executor";
 import { getStep } from "../define-step";
 import { buildAggregateUpdateStep } from "../steps/aggregate-update";
 import type { PipelineCtx } from "../types/step";
 
-const mockUpdate = vi.fn();
+const mockUpdate = mock();
 const mockExecutor = { update: mockUpdate } as unknown as EventStoreExecutor & {
   update: typeof mockUpdate;
 };
@@ -61,7 +61,7 @@ describe("buildAggregateUpdateStep", () => {
 
 describe("aggregate.update run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("resolves id, changes, version and calls executor.update", async () => {

package/src/engine/__tests__/steps-call-feature.test.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import { getStep } from "../define-step";
 import { buildCallFeatureStep } from "../steps/call-feature";
 import type { PipelineCtx } from "../types/step";
 
-const mockWrite = vi.fn();
-const mockWriteAs = vi.fn();
+const mockWrite = mock();
+const mockWriteAs = mock();
 
 const mockCtx = {
   write: mockWrite,
@@ -37,7 +37,7 @@ describe("buildCallFeatureStep", () => {
 
 describe("callFeature run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("calls ctx.write with the resolved payload and handler name", async () => {
@@ -64,7 +64,7 @@ describe("callFeature run", () => {
 
   it("resolves a function payload resolver before calling ctx.write", async () => {
     const stepDef = getStep("callFeature");
-    const payloadFn = vi.fn((ctx: PipelineCtx) => ({
+    const payloadFn = mock((ctx: PipelineCtx) => ({
       title: (ctx.event.payload as { title: string }).title,
     }));
     mockWrite.mockResolvedValue({

package/src/engine/__tests__/steps-mail-send.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import { getStep } from "../define-step";
 import {
   STEP_DISPATCH_AGGREGATE_TYPE,
@@ -7,7 +7,7 @@ import {
 import { buildMailSendStep } from "../steps/mail-send";
 import type { PipelineCtx } from "../types/step";
 
-const mockUnsafeAppendEvent = vi.fn();
+const mockUnsafeAppendEvent = mock();
 
 const mockCtx = {
   unsafeAppendEvent: mockUnsafeAppendEvent,
@@ -61,7 +61,7 @@ describe("buildMailSendStep", () => {
 
 describe("mail.send run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("appends a step.dispatch-requested system event with the mail spec", async () => {
@@ -78,7 +78,7 @@ describe("mail.send run", () => {
       mockCtx,
     );
 
-    expect(mockUnsafeAppendEvent).toHaveBeenCalledOnce();
+    expect(mockUnsafeAppendEvent).toHaveBeenCalledTimes(1);
     const eventArg = mockUnsafeAppendEvent.mock.calls[0]![0];
 
     expect(eventArg.aggregateType).toBe(STEP_DISPATCH_AGGREGATE_TYPE);
@@ -93,9 +93,9 @@ describe("mail.send run", () => {
 
   it("resolves function-based resolvers", async () => {
     const stepDef = getStep("mail.send");
-    const toFn = vi.fn(() => "resolved@example.com");
-    const subjectFn = vi.fn(() => "Resolved Subject");
-    const bodyFn = vi.fn(() => "Resolved Body");
+    const toFn = mock(() => "resolved@example.com");
+    const subjectFn = mock(() => "Resolved Subject");
+    const bodyFn = mock(() => "Resolved Body");
 
     await stepDef!.run({ to: toFn, subject: subjectFn, body: bodyFn, mode: "deferred" }, mockCtx);
 

package/src/engine/__tests__/steps-read.test.ts

@@ -1,36 +1,27 @@
-import type { SQL } from "drizzle-orm";
-import { pgTable, text, uuid } from "drizzle-orm/pg-core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+import { table, text, uuid } from "../../db/dialect";
 import { getStep } from "../define-step";
 import { buildReadFindManyStep } from "../steps/read-find-many";
 import { buildReadFindOneStep } from "../steps/read-find-one";
 import type { PipelineCtx } from "../types/step";
 
-const testTable = pgTable("test_read", {
+const testTable = table("test_read", {
   id: uuid("id").primaryKey().defaultRandom(),
   tenantId: uuid("tenant_id").notNull(),
   label: text("label"),
 });
 
-class MockQuery {
-  rows: Record<string, unknown>[] = [];
-  where = vi.fn(() => this);
-  limit = vi.fn(() => this);
-  // biome-ignore lint/suspicious/noThenProperty: mock query builder is intentionally thenable so await resolves rows
-  then: Promise<Record<string, unknown>[]>["then"];
-
-  constructor(rows?: Record<string, unknown>[]) {
-    if (rows) this.rows = rows;
-    const promise = Promise.resolve(this.rows);
-    // biome-ignore lint/suspicious/noThenProperty: see above
-    this.then = promise.then.bind(promise);
-  }
-}
-
-const mockDb = { select: vi.fn(() => ({ from: vi.fn(() => new MockQuery([])) })) };
+// bun-db path: read-find-many/one call selectMany(ctx.db.raw, table, where, opts)
+// which goes through asRawClient(ctx.db.raw).unsafe(sqlText, params).
+// Mock the .unsafe() return value to feed back rows.
+const unsafeMock = mock(
+  async (_sqlText: string, _params: unknown[]): Promise<Record<string, unknown>[]> => [],
+);
+const rawDb = { unsafe: unsafeMock, begin: mock() };
+const ctxDb = { raw: rawDb };
 
 const mockCtx = {
-  db: mockDb,
+  db: ctxDb,
   event: { type: "test", payload: {} },
   steps: {},
   scope: {},
@@ -40,7 +31,7 @@ describe("buildReadFindOneStep", () => {
   it("returns a StepInstance with kind read.findOne", () => {
     const step = buildReadFindOneStep("myLookup", {
       table: testTable,
-      where: undefined as unknown as SQL,
+      where: { id: "x" },
     });
     expect(step.kind).toBe("read.findOne");
     expect((step.args as { name: string }).name).toBe("myLookup");
@@ -49,7 +40,7 @@ describe("buildReadFindOneStep", () => {
   it("stores the result key from the name arg", () => {
     const step = buildReadFindOneStep("lookupResult", {
       table: testTable,
-      where: undefined as unknown as SQL,
+      where: { id: "x" },
     });
     const def = getStep("read.findOne");
     expect(def?.resultKey?.(step.args as { name: string })).toBe("lookupResult");
@@ -58,16 +49,16 @@ describe("buildReadFindOneStep", () => {
 
 describe("read.findOne run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
+    unsafeMock.mockResolvedValue([]);
   });
 
   it("returns null when no row is found", async () => {
     const stepDef = getStep("read.findOne");
-    const query = new MockQuery([]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce([]);
 
     const result = await stepDef!.run(
-      { name: "lookup", table: testTable, where: undefined as unknown as SQL },
+      { name: "lookup", table: testTable, where: { id: "x" } },
       mockCtx,
     );
 
@@ -77,11 +68,10 @@ describe("read.findOne run", () => {
   it("returns the first row when found", async () => {
     const stepDef = getStep("read.findOne");
     const row = { id: "abc", tenantId: "t1", label: "hello" };
-    const query = new MockQuery([row]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce([row]);
 
     const result = await stepDef!.run(
-      { name: "lookup", table: testTable, where: undefined as unknown as SQL },
+      { name: "lookup", table: testTable, where: { id: "abc" } },
       mockCtx,
     );
 
@@ -90,14 +80,17 @@ describe("read.findOne run", () => {
 
   it("resolves a function where-clause before querying", async () => {
     const stepDef = getStep("read.findOne");
-    const whereFn = vi.fn(() => "dynamic where" as unknown as SQL);
-    const query = new MockQuery([]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    const whereFn = mock(() => ({ tenantId: "dyn-tenant" }));
+    unsafeMock.mockResolvedValueOnce([]);
 
     await stepDef!.run({ name: "lookup", table: testTable, where: whereFn }, mockCtx);
 
     expect(whereFn).toHaveBeenCalledWith(mockCtx);
-    expect(query.where).toHaveBeenCalledWith("dynamic where");
+    expect(unsafeMock).toHaveBeenCalledTimes(1);
+    const [sqlText, params] = unsafeMock.mock.calls[0]!;
+    expect(sqlText).toMatch(/SELECT \* FROM "test_read"/);
+    expect(sqlText).toMatch(/"tenant_id" = \$1/);
+    expect(params).toEqual(["dyn-tenant"]);
   });
 });
 
@@ -116,13 +109,13 @@ describe("buildReadFindManyStep", () => {
 
 describe("read.findMany run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
+    unsafeMock.mockResolvedValue([]);
   });
 
   it("returns an empty array when no rows exist", async () => {
     const stepDef = getStep("read.findMany");
-    const query = new MockQuery([]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce([]);
 
     const result = await stepDef!.run({ name: "list", table: testTable }, mockCtx);
 
@@ -132,11 +125,12 @@ describe("read.findMany run", () => {
   it("applies the limit when specified", async () => {
     const stepDef = getStep("read.findMany");
     const rows = [{ id: "a" }, { id: "b" }];
-    const query = new MockQuery(rows);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce(rows);
 
     await stepDef!.run({ name: "list", table: testTable, limit: 2 }, mockCtx);
 
-    expect(query.limit).toHaveBeenCalledWith(2);
+    expect(unsafeMock).toHaveBeenCalledTimes(1);
+    const [sqlText] = unsafeMock.mock.calls[0]!;
+    expect(sqlText).toMatch(/LIMIT 2/);
   });
 });

package/src/engine/__tests__/steps-resolver-utils.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, mock } from "bun:test";
 import { resolveOptional, resolveRequired } from "../steps/_resolver-utils";
 import type { PipelineCtx } from "../types/step";
 
@@ -13,15 +13,15 @@ describe("resolveRequired", () => {
   });
 
   it("calls a function resolver with the ctx and returns its result", () => {
-    const fn = vi.fn((_ctx: PipelineCtx) => "from-fn");
+    const fn = mock((_ctx: PipelineCtx) => "from-fn");
     expect(resolveRequired(fn, dummyCtx)).toBe("from-fn");
-    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledTimes(1);
     expect(fn).toHaveBeenCalledWith(dummyCtx);
   });
 
   it("passes the full ctx to the resolver function", () => {
     const ctx = { event: { type: "test" }, steps: { x: 1 }, scope: {} } as unknown as PipelineCtx;
-    const fn = vi.fn((c: PipelineCtx) => c.event.type);
+    const fn = mock((c: PipelineCtx) => c.event.type);
     expect(resolveRequired(fn, ctx)).toBe("test");
   });
 });
@@ -39,9 +39,9 @@ describe("resolveOptional", () => {
   });
 
   it("calls a function resolver when defined", () => {
-    const fn = vi.fn(() => "resolved");
+    const fn = mock(() => "resolved");
     expect(resolveOptional(fn, dummyCtx)).toBe("resolved");
-    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledTimes(1);
   });
 
   it("returns undefined for undefined function resolver", () => {

package/src/engine/__tests__/steps-unsafe-projection-delete.test.ts

@@ -1,21 +1,23 @@
-import type { SQL } from "drizzle-orm";
-import { pgTable, text, uuid } from "drizzle-orm/pg-core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+import { table, text, uuid } from "../../db/dialect";
 import { getStep } from "../define-step";
 import { buildUnsafeProjectionDeleteStep } from "../steps/unsafe-projection-delete";
 import type { PipelineCtx } from "../types/step";
 
-const testTable = pgTable("test_projection", {
+const testTable = table("test_projection", {
   id: uuid("id").primaryKey().defaultRandom(),
   tenantId: uuid("tenant_id").notNull(),
   label: text("label"),
 });
 
-const mockDb = { delete: vi.fn() };
-const mockDeleteBuilder = { where: vi.fn() };
+// bun-db path: step calls deleteMany(ctx.db.raw, table, where) which lands on
+// asRawClient(ctx.db.raw).unsafe(sqlText, params).
+const unsafeMock = mock(async (_sqlText: string, _params: unknown[]): Promise<unknown[]> => []);
+const rawDb = { unsafe: unsafeMock, begin: mock() };
+const ctxDb = { raw: rawDb };
 
 const mockCtx = {
-  db: mockDb,
+  db: ctxDb,
   event: { type: "test", payload: {} },
   steps: {},
   scope: {},
@@ -25,16 +27,16 @@ describe("buildUnsafeProjectionDeleteStep", () => {
   it("returns a StepInstance with kind unsafeProjectionDelete", () => {
     const step = buildUnsafeProjectionDeleteStep({
       table: testTable,
-      where: () => undefined as unknown as SQL,
+      where: () => ({}),
     });
     expect(step.kind).toBe("unsafeProjectionDelete");
     expect(step.args).toMatchObject({ table: testTable });
   });
 
-  it("accepts a static SQL where clause", () => {
+  it("accepts a static where clause", () => {
     const step = buildUnsafeProjectionDeleteStep({
       table: testTable,
-      where: undefined as unknown as SQL,
+      where: { id: "x" },
     });
     expect(step.args).toHaveProperty("table");
   });
@@ -42,28 +44,31 @@ describe("buildUnsafeProjectionDeleteStep", () => {
 
 describe("unsafeProjectionDelete run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
-    mockDb.delete.mockReturnValue(mockDeleteBuilder);
+    mock.clearAllMocks();
   });
 
-  it("calls db.delete().where() with the resolved where clause", async () => {
+  it("issues DELETE ... WHERE ... with the resolved where clause", async () => {
     const stepDef = getStep("unsafeProjectionDelete");
     expect(stepDef).toBeDefined();
 
-    const whereClause = "fake sql" as unknown as SQL;
-    await stepDef!.run({ table: testTable, where: whereClause }, mockCtx);
+    await stepDef!.run({ table: testTable, where: { id: "abc" } }, mockCtx);
 
-    expect(mockDb.delete).toHaveBeenCalledOnce();
-    expect(mockDeleteBuilder.where).toHaveBeenCalledWith(whereClause);
+    expect(unsafeMock).toHaveBeenCalledTimes(1);
+    const [sqlText, params] = unsafeMock.mock.calls[0]!;
+    expect(sqlText).toMatch(/DELETE FROM "test_projection"/);
+    expect(sqlText).toMatch(/"id" = \$1/);
+    expect(params).toEqual(["abc"]);
   });
 
   it("resolves a function where-clause before calling delete", async () => {
     const stepDef = getStep("unsafeProjectionDelete");
 
-    const whereFn = vi.fn(() => "dynamic where" as unknown as SQL);
+    const whereFn = mock(() => ({ tenantId: "t1" }));
     await stepDef!.run({ table: testTable, where: whereFn }, mockCtx);
 
     expect(whereFn).toHaveBeenCalledWith(mockCtx);
-    expect(mockDeleteBuilder.where).toHaveBeenCalledWith("dynamic where");
+    expect(unsafeMock).toHaveBeenCalledTimes(1);
+    const [, params] = unsafeMock.mock.calls[0]!;
+    expect(params).toEqual(["t1"]);
   });
 });