@cosmicdrift/kumiko-framework 0.307.0 → 0.309.0

package/src/pipeline/__tests__/event-dispatcher-batch-handler.integration.test.ts

@@ -0,0 +1,143 @@
+// #3227 — batchHandler wired into a real dispatcher pass: a successful
+// batch is delivered in one call (handler never runs, cursor lands at the
+// last event) and a batch+handler failure still dead-letters through the
+// normal errorPolicy machinery, delivering the poisoned event via handler
+// exactly once before it does.
+
+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";
+import type { StoredEvent } from "../../event-store";
+import {
+  createEventDispatcher,
+  type EventConsumer,
+  type EventDispatcher,
+  getConsumerState,
+} from "../../pipeline";
+import {
+  resetEventStore,
+  setupTestStack,
+  type TestStack,
+  TestUsers,
+  unsafeCreateEntityTable,
+} from "../../stack";
+import { sharedWidgetEntity, sharedWidgetTable } from "../../testing";
+
+const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
+  entityName: "widget",
+});
+
+const feature = defineFeature("batchhandlerintegration", (r) => {
+  r.entity("widget", sharedWidgetEntity);
+});
+
+const admin = TestUsers.admin;
+let stack: TestStack;
+let tdb: TenantDb;
+
+beforeAll(async () => {
+  stack = await setupTestStack({ features: [feature], systemHooks: [] });
+  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
+  tdb = createTenantDb(stack.db, admin.tenantId);
+});
+
+afterEach(async () => {
+  await resetEventStore(stack, ["read_widgets"]);
+});
+
+async function appendWidget(name: string): Promise<string> {
+  const created = await executor.create({ name }, admin, tdb);
+  if (!created.isSuccess) throw new Error("create failed");
+  return String(created.data.id);
+}
+
+function buildDispatcher(consumers: readonly EventConsumer[]): EventDispatcher {
+  return createEventDispatcher({
+    db: stack.db,
+    consumers,
+    context: { db: stack.db, redis: stack.redis.redis, registry: stack.registry },
+    batchSize: 200,
+    // No timer/LISTEN involved — runOnce() below drives every pass
+    // explicitly, so pollIntervalMs never fires a competing pass.
+    pollIntervalMs: 60_000,
+  });
+}
+
+describe("event-dispatcher — batchHandler", () => {
+  test("a successful batch delivers all events in one call, handler stays unused, cursor lands on the last event", async () => {
+    const consumerName = "batchhandlerintegration:success";
+    const batchSizes: number[] = [];
+    const batchIds: bigint[] = [];
+    const handlerIds: string[] = [];
+
+    const consumer: EventConsumer = {
+      name: consumerName,
+      batchHandler: async (events) => {
+        batchSizes.push(events.length);
+        for (const event of events) batchIds.push(BigInt(event.id));
+      },
+      handler: async (event) => {
+        handlerIds.push(event.aggregateId);
+      },
+    };
+
+    const dispatcher = buildDispatcher([consumer]);
+    await dispatcher.ensureRegistered();
+
+    await appendWidget("one");
+    await appendWidget("two");
+    await appendWidget("three");
+
+    const result = await dispatcher.runOnce();
+
+    expect(batchSizes).toEqual([3]);
+    expect(handlerIds).toEqual([]);
+    expect(result.byConsumer[consumerName]).toEqual({ processed: 3, failed: 0 });
+
+    const state = await getConsumerState(stack.db, consumerName);
+    expect(state?.status).toBe("idle");
+    expect(state?.lastProcessedEventId).toBe(batchIds.at(-1));
+  });
+
+  test("batch throws, handler poisons the 2nd event: dead-letters at maxAttempts, first event delivered exactly once via handler", async () => {
+    const consumerName = "batchhandlerintegration:poison";
+    const handlerCalls: StoredEvent[] = [];
+    let poisonAggregateId: string | undefined;
+
+    const consumer: EventConsumer = {
+      name: consumerName,
+      errorPolicy: { maxAttempts: 2 },
+      batchHandler: async () => {
+        throw new Error("batch always fails in this test");
+      },
+      handler: async (event) => {
+        handlerCalls.push(event);
+        if (event.aggregateId === poisonAggregateId) {
+          throw new Error("poisoned event");
+        }
+      },
+    };
+
+    const dispatcher = buildDispatcher([consumer]);
+    await dispatcher.ensureRegistered();
+
+    await appendWidget("first");
+    poisonAggregateId = await appendWidget("second");
+
+    const firstPass = await dispatcher.runOnce();
+    expect(firstPass.byConsumer[consumerName]?.failed).toBeGreaterThan(0);
+
+    const secondPass = await dispatcher.runOnce();
+    expect(secondPass.byConsumer[consumerName]).toBeDefined();
+
+    const state = await getConsumerState(stack.db, consumerName);
+    expect(state?.status).toBe("dead");
+
+    const firstEventDeliveries = handlerCalls.filter(
+      (event) => event.aggregateId === handlerCalls[0]?.aggregateId,
+    );
+    expect(firstEventDeliveries).toHaveLength(1);
+    expect(state?.lastProcessedEventId).toBe(BigInt(handlerCalls[0]?.id ?? "0"));
+  });
+});

package/src/pipeline/__tests__/event-dispatcher-db-outage.integration.test.ts

@@ -0,0 +1,192 @@
+// kumiko-framework#3243: a DB outage must not crash the dispatcher and must
+// not stay silent forever. The idle pre-check's error log (doPass) fires once
+// per outage, and a matching "recovered" line must fire once the DB answers
+// again, so ops can see the return without restarting the process. Routes the
+// dispatcher's own db connection through a TCP proxy (same pattern as
+// bun-db/__tests__/postgres-closed-socket-write.integration.test.ts) so the
+// outage can be simulated without touching the shared test DB other suites
+// depend on.
+
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
+import net from "node:net";
+import postgres from "postgres";
+import { createDbConnection } from "../../db/connection";
+import { createEventStoreExecutor } from "../../db/event-store-executor";
+import { createTenantDb, type TenantDb } from "../../db/tenant-db";
+import { defineFeature } from "../../engine";
+import type { StoredEvent } from "../../event-store";
+import type { Logger } from "../../logging/types";
+import { type MetricEvent, RecordingMeter, registerStandardMetrics } from "../../observability";
+import { createEventDispatcher, type EventConsumer, type EventDispatcher } from "../../pipeline";
+import {
+  resetEventStore,
+  setupTestStack,
+  type TestStack,
+  TestUsers,
+  unsafeCreateEntityTable,
+} from "../../stack";
+import { sharedWidgetEntity, sharedWidgetTable, waitFor } from "../../testing";
+import { testDatabaseUrl } from "../../testing/closed-connection-error";
+
+const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
+  entityName: "widget",
+});
+
+const feature = defineFeature("dboutage", (r) => {
+  r.entity("widget", sharedWidgetEntity);
+});
+
+const admin = TestUsers.admin;
+let stack: TestStack;
+let tdb: TenantDb;
+// setupTestStack creates its own ephemeral kumiko_test_<random> DB and never
+// exposes its name/URL. Passing an explicit name here so the proxy below
+// can build the exact connection string setupTestStack itself would have.
+const testDbName = `kumiko_test_dboutage_${crypto.randomUUID().slice(0, 8)}`;
+
+beforeAll(async () => {
+  stack = await setupTestStack({ features: [feature], systemHooks: [], dbName: testDbName });
+  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
+  tdb = createTenantDb(stack.db, admin.tenantId);
+});
+
+afterEach(async () => {
+  await resetEventStore(stack, ["read_widgets"]);
+});
+
+async function appendWidget(name: string): Promise<void> {
+  await executor.create({ name }, admin, tdb);
+}
+
+function recordingLogger(): Logger & { readonly lines: string[] } {
+  const lines: string[] = [];
+  const logger: Logger & { lines: string[] } = {
+    lines,
+    info: (msg) => lines.push(`info:${msg}`),
+    warn: (msg) => lines.push(`warn:${msg}`),
+    error: (msg) => lines.push(`error:${msg}`),
+    debug: () => {},
+    child: () => logger,
+  };
+  return logger;
+}
+
+// A TCP passthrough to the real test DB. Stopping it (server.close() +
+// destroying every live socket) simulates an outage without touching the
+// shared test DB; restarting on the SAME port simulates the DB coming back
+// without the dispatcher's client needing a new connection string.
+function startDbProxy(dbUrl: URL): { server: net.Server; stop: () => Promise<void> } {
+  const sockets = new Set<net.Socket>();
+  const server = net.createServer((downstream) => {
+    sockets.add(downstream);
+    const upstream = net.connect(Number(dbUrl.port), dbUrl.hostname);
+    sockets.add(upstream);
+    downstream.pipe(upstream).pipe(downstream);
+    downstream.on("error", () => upstream.destroy());
+    upstream.on("error", () => downstream.destroy());
+    downstream.on("close", () => sockets.delete(downstream));
+    upstream.on("close", () => sockets.delete(upstream));
+  });
+  return {
+    server,
+    stop: async () => {
+      for (const socket of sockets) socket.destroy();
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    },
+  };
+}
+
+async function listenOn(server: net.Server, port: number): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, resolve);
+  });
+}
+
+describe("E: dispatcher survives a DB outage and logs the recovery", () => {
+  test("idle pre-check logs the outage once and the recovery once, then resumes delivery", async () => {
+    const dbUrl = new URL(testDatabaseUrl().replace(/\/[^/]+$/, `/${testDbName}`));
+    const proxy1 = startDbProxy(dbUrl);
+    await listenOn(proxy1.server, 0);
+    const address = proxy1.server.address();
+    if (address === null || typeof address === "string") {
+      throw new Error("proxy did not bind to a TCP port");
+    }
+    const proxyPort = address.port;
+
+    const proxiedUrl = new URL(dbUrl.toString());
+    proxiedUrl.hostname = "127.0.0.1";
+    proxiedUrl.port = String(proxyPort);
+    const proxiedDb = createDbConnection(proxiedUrl.toString(), { maxConnections: 1 });
+
+    const observed: string[] = [];
+    const consumer: EventConsumer = {
+      name: "dboutage:consumer",
+      handler: async (event: StoredEvent) => {
+        observed.push(String(event.payload["name"]));
+      },
+    };
+
+    const logger = recordingLogger();
+    const metricEvents: MetricEvent[] = [];
+    const lastListenGauge = (): number | undefined =>
+      metricEvents
+        .filter(
+          (e) => e.type === "gauge.set" && e.name === "kumiko_event_dispatcher_listen_connected",
+        )
+        .pop()?.value;
+    const meter = new RecordingMeter((e) => metricEvents.push(e));
+    registerStandardMetrics(meter);
+    const listenClient = postgres(proxiedUrl.toString(), { max: 1 });
+    const dispatcher: EventDispatcher = createEventDispatcher({
+      db: proxiedDb.db,
+      consumers: [consumer],
+      context: { db: proxiedDb.db, log: logger },
+      pollIntervalMs: 50,
+      pgClient: listenClient,
+      meter,
+    });
+
+    try {
+      await dispatcher.start();
+      expect(lastListenGauge()).toBe(1);
+
+      await appendWidget("before-outage");
+      await waitFor(() => observed.includes("before-outage"));
+      // Delivery is at-least-once, so killing the proxy mid-commit would
+      // redeliver "before-outage" after recovery. Drain first so the turn's
+      // TX has already committed.
+      await dispatcher.drain();
+
+      await proxy1.stop();
+
+      await waitFor(() => logger.lines.some((line) => line.includes("idle pre-check failed")));
+      expect(lastListenGauge()).toBe(0);
+
+      const proxy2 = startDbProxy(dbUrl);
+      await listenOn(proxy2.server, proxyPort);
+      try {
+        await waitFor(() => logger.lines.some((line) => line.includes("idle pre-check recovered")));
+
+        await appendWidget("after-recovery");
+        await waitFor(() => observed.includes("after-recovery"));
+      } finally {
+        await proxy2.stop();
+      }
+
+      const failedCount = logger.lines.filter((line) =>
+        line.includes("idle pre-check failed"),
+      ).length;
+      const recoveredCount = logger.lines.filter((line) =>
+        line.includes("idle pre-check recovered"),
+      ).length;
+      expect(failedCount).toBe(1);
+      expect(recoveredCount).toBe(1);
+      expect(observed).toEqual(["before-outage", "after-recovery"]);
+    } finally {
+      await dispatcher.stop();
+      await listenClient.end({ timeout: 1 });
+      await proxiedDb.close();
+    }
+  });
+});

package/src/pipeline/__tests__/event-dispatcher-idle.integration.test.ts

@@ -0,0 +1,94 @@
+// A provably-idle consumer's doPass turn must not take the state row's
+// FOR UPDATE SKIP LOCKED lock: that lock sets xmax on the row, requires an
+// xid, writes WAL, and forces a commit fsync — on every poll tick, forever,
+// even with zero events in the system. The pre-check in
+// selectIdleConsumerKeys (event-dispatcher-delivery.ts) must keep an idle
+// consumer's row untouched entirely, verified here via the row's own
+// system column `xmax`: unchanged across an idle runOnce() means no lock
+// was ever taken on it.
+
+import { afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { createEventStoreExecutor } from "../../db/event-store-executor";
+import { asRawClient } from "../../db/query";
+import { createTenantDb, type TenantDb } from "../../db/tenant-db";
+import { defineFeature } from "../../engine";
+import {
+  resetEventStore,
+  setupTestStack,
+  type TestStack,
+  TestUsers,
+  unsafeCreateEntityTable,
+} from "../../stack";
+import { sharedWidgetEntity, sharedWidgetTable } from "../../testing";
+import { SHARED_INSTANCE_SENTINEL } from "../event-consumer-state";
+
+const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
+  entityName: "widget",
+});
+
+let observed: Array<{ name: string }> = [];
+
+const idleFeature = defineFeature("idletest", (r) => {
+  r.entity("widget", sharedWidgetEntity);
+
+  r.multiStreamProjection({
+    name: "observer",
+    apply: {
+      "widget.created": async (event) => {
+        observed.push({ name: event.payload["name"] as string });
+      },
+    },
+  });
+});
+
+const admin = TestUsers.admin;
+const qn = "idletest:projection:observer";
+let stack: TestStack;
+let tdb: TenantDb;
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [idleFeature],
+    systemHooks: [],
+  });
+  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
+  tdb = createTenantDb(stack.db, admin.tenantId);
+});
+
+afterEach(async () => {
+  observed = [];
+  await resetEventStore(stack, ["read_widgets"]);
+});
+
+async function appendWidget(name: string): Promise<void> {
+  await executor.create({ name }, admin, tdb);
+}
+
+async function readConsumerRowXmax(): Promise<string> {
+  const rows = (await asRawClient(stack.db).unsafe(
+    `SELECT xmax::text FROM "kumiko_event_consumers" WHERE "name" = $1 AND "instance_id" = $2`,
+    [qn, SHARED_INSTANCE_SENTINEL],
+  )) as ReadonlyArray<{ xmax: string }>;
+  const xmax = rows[0]?.xmax;
+  if (xmax === undefined) throw new Error("consumer state row missing");
+  return xmax;
+}
+
+describe("idle event-dispatcher passes take no row lock", () => {
+  test("xmax is unchanged across an idle runOnce() after draining, then a new event is still delivered", async () => {
+    await appendWidget("drain-me");
+    await stack.eventDispatcher?.runOnce();
+    expect(observed).toEqual([{ name: "drain-me" }]);
+
+    const xmaxBeforeIdlePass = await readConsumerRowXmax();
+
+    await stack.eventDispatcher?.runOnce();
+    const xmaxAfterIdlePass = await readConsumerRowXmax();
+    expect(xmaxAfterIdlePass).toBe(xmaxBeforeIdlePass);
+
+    await appendWidget("wake-me");
+    const result = await stack.eventDispatcher?.runOnce();
+    expect(result?.processed).toBeGreaterThan(0);
+    expect(observed).toEqual([{ name: "drain-me" }, { name: "wake-me" }]);
+  });
+});

package/src/pipeline/__tests__/event-dispatcher-start-from.integration.test.ts

@@ -13,12 +13,12 @@
 // event-triggered workflow hits in production.
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import type { DbTx } from "../../db/connection";
-import { insertOne } from "../../db/query";
+import type { DbConnection, DbTx } from "../../db/connection";
+import { asRawClient, insertOne } from "../../db/query";
 import type { AppContext } from "../../engine/types";
 import { eventsTable } from "../../event-store";
 import { createTestDb, type TestDb, TestUsers } from "../../stack";
-import { createEventConsumerStateTable } from "../event-consumer-state";
+import { createEventConsumerStateTable, SHARED_INSTANCE_SENTINEL } from "../event-consumer-state";
 import { createEventDispatcher, type EventConsumer, getConsumerState } from "../event-dispatcher";
 import { fetchPendingEvents } from "../event-dispatcher-delivery";
 
@@ -49,6 +49,40 @@ async function appendHistoricalEvent(type: string): Promise<void> {
   historicalEventCount += 1;
 }
 
+// Grabs an id (like appendHistoricalEvent) but never commits — the row
+// stays invisible until the caller releases and awaits the enclosing tx.
+async function appendEventRawHoldingTx(tx: DbTx, type: string): Promise<void> {
+  await asRawClient(tx).unsafe(
+    `INSERT INTO "kumiko_events"
+       (aggregate_id, aggregate_type, tenant_id, version, type, payload, metadata, created_by)
+     VALUES ($1::uuid, 'start-from-test-source', $2::uuid, 1, $3, '{}'::jsonb, '{}'::jsonb, 'test')`,
+    [crypto.randomUUID(), admin.tenantId, type],
+  );
+}
+
+async function selectVisibleMaxEventId(): Promise<bigint> {
+  const rows = (await asRawClient(testDb.db).unsafe(
+    `SELECT COALESCE(MAX("id"), 0)::text AS max FROM "kumiko_events"`,
+  )) as ReadonlyArray<{ max: string }>;
+  return BigInt(rows[0]?.max ?? "0");
+}
+
+async function readPendingGaps(
+  db: DbConnection,
+  consumerName: string,
+): Promise<ReadonlyArray<{ from: string; to: string; xmax: string }>> {
+  const rows = (await asRawClient(db).unsafe(
+    `SELECT "pending_gaps", jsonb_typeof("pending_gaps") AS kind FROM "kumiko_event_consumers" WHERE "name" = $1 AND "instance_id" = $2`,
+    [consumerName, SHARED_INSTANCE_SENTINEL],
+  )) as ReadonlyArray<{
+    pending_gaps: ReadonlyArray<{ from: string; to: string; xmax: string }>;
+    kind: string;
+  }>;
+  // A double-encoded write lands as a jsonb string scalar, not an array.
+  if (rows[0] && rows[0].kind !== "array") throw new Error(`pending_gaps is jsonb ${rows[0].kind}`);
+  return rows[0]?.pending_gaps ?? [];
+}
+
 beforeAll(async () => {
   // createTestDb() already materializes kumiko_events (see stack/db.ts).
   testDb = await createTestDb();
@@ -173,4 +207,70 @@ describe("EventConsumer.startFrom", () => {
     const afterRedeploy = await getConsumerState(testDb.db, consumer.name);
     expect(afterRedeploy?.lastProcessedEventId).toBe(advanced?.lastProcessedEventId);
   });
+
+  test("'now' registered while a lower-id write is still uncommitted seeds a pending gap and later delivers it", async () => {
+    const captured: string[] = [];
+    const consumer: EventConsumer = {
+      name: "test:consumer:now-out-of-order",
+      startFrom: "now",
+      handler: async (event) => {
+        captured.push(event.type);
+      },
+    };
+
+    // Tx A grabs the LOW id first but holds its transaction open — invisible
+    // to insertConsumerIfAbsent's horizon read below, same mechanic as the
+    // live-dispatcher out-of-order case in event-dispatcher-commit-order.
+    let releaseA!: () => void;
+    const aGate = new Promise<void>((resolve) => {
+      releaseA = resolve;
+    });
+    let markAInserted!: () => void;
+    const aInserted = new Promise<void>((resolve) => {
+      markAInserted = resolve;
+    });
+    const aDone = testDb.db
+      .begin(async (tx: DbTx) => {
+        await appendEventRawHoldingTx(tx, "start-from-test.low-id");
+        markAInserted();
+        await aGate;
+      })
+      .catch(() => {});
+    await aInserted;
+
+    // Tx B commits AFTER A grabbed its id, so B's id is the higher, visible
+    // MAX(id) when the consumer is registered below. A's still-open tx
+    // already consumed a sequence value, so B's actual id is one past
+    // historicalEventCount, not equal to it — read the real MAX(id).
+    await appendHistoricalEvent("start-from-test.high-id");
+    const headAtMount = await selectVisibleMaxEventId();
+
+    const dispatcher = createEventDispatcher({
+      db: testDb.db,
+      consumers: [consumer],
+      context: stubContext(),
+    });
+
+    try {
+      await dispatcher.ensureRegistered();
+
+      const seeded = await getConsumerState(testDb.db, consumer.name);
+      expect(seeded?.lastProcessedEventId).toBe(headAtMount);
+      expect(await readPendingGaps(testDb.db, consumer.name)).not.toEqual([]);
+
+      // Nothing to deliver yet — A's transaction hasn't committed.
+      const passWhileOpen = await dispatcher.runOnce();
+      expect(passWhileOpen.byConsumer[consumer.name]).toEqual({ processed: 0, failed: 0 });
+    } finally {
+      releaseA();
+      await aDone;
+    }
+
+    // A commits now — its lower id is delivered as a resolved pending gap,
+    // even though the cursor already sits above it from registration.
+    const pass = await dispatcher.runOnce();
+    expect(pass.byConsumer[consumer.name]).toEqual({ processed: 1, failed: 0 });
+    expect(captured).toEqual(["start-from-test.low-id"]);
+    expect(await readPendingGaps(testDb.db, consumer.name)).toEqual([]);
+  });
 });

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

@@ -8,7 +8,7 @@
 //      consecutive versions without re-reading the DB.
 
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
-import { z } from "zod";
+import * as z from "zod";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { asRawClient } from "../../db/query-api";
 import { buildEntityTable } from "../../db/table-builder";

package/src/pipeline/__tests__/idempotency-transient-failure.integration.test.ts

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { z } from "zod";
+import * as z from "zod";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { asRawClient, selectMany } from "../../db/query";
 import { buildEntityTable } from "../../db/table-builder";

package/src/pipeline/__tests__/job-trigger-consumer.integration.test.ts

@@ -17,7 +17,7 @@
 // produce, not something exercised end-to-end by any test today.
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { z } from "zod";
+import * as z from "zod";
 import { entityEventName } from "../../db";
 import { defineFeature } from "../../engine";
 import { createInMemoryFileProvider, type InMemoryFileProvider } from "../../files";

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

@@ -1,5 +1,5 @@
 import { describe, expect, spyOn, test } from "bun:test";
-import { z } from "zod";
+import * as z from "zod";
 import {
   createEntity,
   createRegistry,

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

@@ -10,7 +10,7 @@
 
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { seedRow } from "@cosmicdrift/kumiko-framework/testing";
-import { z } from "zod";
+import * as z from "zod";
 import type { DbConnection, DbTx } from "../../db/connection";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { buildEntityTable } from "../../db/table-builder";

package/src/pipeline/__tests__/msp-multi-hop.integration.test.ts

@@ -11,7 +11,7 @@
 //   5. ctx.loadAggregate reads the triggering stream's full history.
 
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
-import { z } from "zod";
+import * as z from "zod";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
 import { selectMany } from "../../db/query";
 import { buildEntityTable } from "../../db/table-builder";