@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

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

@@ -1,282 +0,0 @@
-// Second-audit fixes — two latent silent-broken behaviours in the async
-// event-dispatcher that only surface when specific call-sites materialise.
-// Pinned here so regressions fail loudly:
-//
-//   1. Prune-vs-new-consumer race. Before the fix, a fresh deploy that
-//      adds a new MSP + simultaneously runs prune could silently delete
-//      events before the new consumer ever saw them. Two pieces close
-//      this: (a) pre-registering every consumer row on dispatcher.start()
-//      so the retention guard sees it, (b) a SHARE-mode table lock in
-//      pruneEvents as defence-in-depth.
-//
-//   2. LISTEN-subscription health is now emitted as a gauge
-//      (kumiko_event_dispatcher_listen_connected). Ops can see the
-//      moment delivery latency regresses from TCP-round-trip to
-//      pollIntervalMs.
-
-import { afterEach, beforeAll, describe, expect, test } from "bun:test";
-import { asRawClient, insertOne, selectMany, updateMany } from "../../db/query";
-import { defineFeature } from "../../engine";
-import { eventsTable } from "../../event-store";
-import {
-  DEFAULT_SENSITIVE_CONFIG,
-  type MetricEvent,
-  type ObservabilityProvider,
-  RecordingMeter,
-  RecordingTracer,
-} from "../../observability";
-import { ConsumerLagError, eventConsumerStateTable, pruneEvents } from "../../pipeline";
-import {
-  resetEventStore,
-  setupTestStack,
-  type TestStack,
-  TestUsers,
-  unsafeCreateEntityTable,
-} from "../../stack";
-import { sharedWidgetEntity, waitFor } from "../../testing";
-import { generateId } from "../../utils";
-
-// --- Fixture ---
-
-const auditFeature = defineFeature("audit", (r) => {
-  r.entity("widget", sharedWidgetEntity);
-
-  // Two MSPs so the dispatcher has two consumer rows to register in the
-  // pre-registration tests below. Both no-op — the tests observe the
-  // kumiko_event_consumers rows, not the apply handlers.
-  r.multiStreamProjection({
-    name: "default-scope",
-    apply: { "widget.created": async () => {} },
-  });
-  r.multiStreamProjection({
-    name: "system-opt-out",
-    apply: { "widget.created": async () => {} },
-  });
-});
-
-const admin = TestUsers.admin;
-let stack: TestStack;
-
-beforeAll(async () => {
-  stack = await setupTestStack({
-    features: [auditFeature],
-    systemHooks: [],
-  });
-  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
-});
-
-afterEach(async () => {
-  await resetEventStore(stack, ["read_widgets"]);
-});
-
-async function seedOldWidgetEvent(createdAt: Temporal.Instant): Promise<void> {
-  await insertOne(stack.db, eventsTable, {
-    aggregateId: generateId(),
-    aggregateType: "widget",
-    tenantId: admin.tenantId,
-    version: 1,
-    type: "widget.created",
-    payload: {},
-    metadata: { userId: admin.id },
-    createdAt,
-    createdBy: admin.id,
-  });
-}
-
-// --- Fix #1 — Prune-vs-new-consumer race (pre-registration) ---
-
-describe("Second audit — consumer pre-registration on start()", () => {
-  test("start() inserts a state row for every registered consumer", async () => {
-    // Before the fix, state rows were created lazily on first runOnce. A
-    // deploy that brought up the process AND immediately ran prune (in a
-    // separate service) could prune past a consumer that hadn't run yet.
-    // Pre-registration closes that window: start() inserts, prune sees
-    // every consumer at cursor=0, refuses to prune past them.
-    await stack.eventDispatcher?.start();
-    try {
-      const rows = await selectMany(stack.db, eventConsumerStateTable);
-      const names = new Set(rows.map((r) => r.name));
-
-      // The test-stack wires only feature MSP consumers (systemHooks: []),
-      // so we expect the two r.multiStreamProjection entries.
-      expect(names.has("audit:projection:default-scope")).toBe(true);
-      expect(names.has("audit:projection:system-opt-out")).toBe(true);
-
-      // Every pre-registered row starts at cursor 0 with status=idle.
-      for (const row of rows) {
-        expect(row.lastProcessedEventId).toBe(0n);
-        expect(row.status).toBe("idle");
-      }
-    } finally {
-      await stack.eventDispatcher?.stop();
-    }
-  });
-
-  test("pre-registered consumer blocks prune via ConsumerLagError", async () => {
-    // The integration-level guarantee: after start(), prune refuses to
-    // delete events below any pre-registered consumer's cursor. This is
-    // the race fix made deterministic — no Promise.all timing, just the
-    // invariant the fix guarantees.
-    await seedOldWidgetEvent(Temporal.Now.instant().subtract({ hours: 240 }));
-
-    await stack.eventDispatcher?.start();
-    try {
-      await expect(
-        pruneEvents(stack.db, { olderThanDays: 1, aggregateTypes: ["widget"] }),
-      ).rejects.toBeInstanceOf(ConsumerLagError);
-    } finally {
-      await stack.eventDispatcher?.stop();
-    }
-  });
-
-  test("start() is idempotent — two starts don't duplicate state rows", async () => {
-    // ON CONFLICT DO NOTHING guarantees this. Guarded so a buildServer
-    // double-start (or process-wide restart) doesn't trip unique-violation
-    // or regress the cursor.
-    await stack.eventDispatcher?.start();
-    await stack.eventDispatcher?.stop();
-
-    // Advance the cursor explicitly so we can prove the second start
-    // doesn't clobber it back to 0.
-    await updateMany(
-      stack.db,
-      eventConsumerStateTable,
-      { lastProcessedEventId: 42n },
-      { name: "audit:projection:default-scope" },
-    );
-
-    await stack.eventDispatcher?.start();
-    try {
-      const [row] = await selectMany(stack.db, eventConsumerStateTable, {
-        name: "audit:projection:default-scope",
-      });
-      expect(row?.lastProcessedEventId).toBe(42n);
-    } finally {
-      await stack.eventDispatcher?.stop();
-    }
-  });
-});
-
-// --- Fix #2 — LISTEN observability ---
-
-describe("Second audit — LISTEN gauge", () => {
-  test("kumiko_event_dispatcher_listen_connected is 1 after start() with pgClient", async () => {
-    const metricEvents: MetricEvent[] = [];
-    const meter = new RecordingMeter((e) => metricEvents.push(e));
-    const tracer = new RecordingTracer({
-      sensitiveConfig: DEFAULT_SENSITIVE_CONFIG,
-      onSpanEnd: () => {},
-    });
-    const recordingProvider: ObservabilityProvider = {
-      name: "recording",
-      meter,
-      tracer,
-      shutdown: async () => {},
-    };
-
-    const recStack = await setupTestStack({
-      features: [auditFeature],
-      systemHooks: [],
-      observability: recordingProvider,
-    });
-    try {
-      await unsafeCreateEntityTable(recStack.db, sharedWidgetEntity, "widget");
-
-      await recStack.eventDispatcher?.start();
-      try {
-        // Filter for gauge.set events on the LISTEN metric. Expect the
-        // sequence: 0 (start() resets) → 1 (onlisten callback fires).
-        const gauges = metricEvents.filter(
-          (e) => e.type === "gauge.set" && e.name === "kumiko_event_dispatcher_listen_connected",
-        );
-        expect(gauges.length).toBeGreaterThanOrEqual(2);
-        expect(gauges[0]?.value).toBe(0);
-        expect(gauges[gauges.length - 1]?.value).toBe(1);
-      } finally {
-        await recStack.eventDispatcher?.stop();
-      }
-
-      // After stop(), the gauge must flip back to 0 so ops can tell the
-      // subscription was deliberately torn down (vs. silently dropped).
-      const postStop = metricEvents
-        .filter(
-          (e) => e.type === "gauge.set" && e.name === "kumiko_event_dispatcher_listen_connected",
-        )
-        .pop();
-      expect(postStop?.value).toBe(0);
-    } finally {
-      await recStack.cleanup();
-    }
-  });
-
-  test("onlisten fires again on silent reconnect — gauge flips to 1 a second time", async () => {
-    // This is the claim that justifies the onlisten-callback over a
-    // simpler .set(1) after `await listen()`: on a dropped TCP, postgres.js
-    // re-subscribes automatically and invokes onlisten again, and ops
-    // needs to see the recovery window. Proved here by killing the
-    // LISTEN backend and observing a second gauge.set(1).
-    const metricEvents: MetricEvent[] = [];
-    const meter = new RecordingMeter((e) => metricEvents.push(e));
-    const tracer = new RecordingTracer({
-      sensitiveConfig: DEFAULT_SENSITIVE_CONFIG,
-      onSpanEnd: () => {},
-    });
-    const recordingProvider: ObservabilityProvider = {
-      name: "recording",
-      meter,
-      tracer,
-      shutdown: async () => {},
-    };
-
-    const recStack = await setupTestStack({
-      features: [auditFeature],
-      systemHooks: [],
-      observability: recordingProvider,
-    });
-    try {
-      await unsafeCreateEntityTable(recStack.db, sharedWidgetEntity, "widget");
-
-      await recStack.eventDispatcher?.start();
-      try {
-        const connectsWithValue1 = (): number =>
-          metricEvents.filter(
-            (e) =>
-              e.type === "gauge.set" &&
-              e.name === "kumiko_event_dispatcher_listen_connected" &&
-              e.value === 1,
-          ).length;
-
-        // Wait for the initial onlisten (gauge.set 1) to land.
-        await waitFor(() => connectsWithValue1() >= 1, { delays: Array(40).fill(50) });
-        const initialConnects = connectsWithValue1();
-        expect(initialConnects).toBeGreaterThanOrEqual(1);
-
-        // Terminate the LISTEN backend. postgres.js runs LISTEN on a
-        // dedicated max=1 sub-pool — the backend whose last query is
-        // `LISTEN "kumiko_events_new"` and is now idle. pg_terminate_backend
-        // on it closes the TCP; postgres.js's onclose handler re-subscribes
-        // and fires onlisten again.
-        await asRawClient(
-          recStack.db,
-        ).unsafe(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity
-              WHERE datname = current_database()
-                AND query ILIKE 'listen%'
-                AND state = 'idle'
-                AND pid <> pg_backend_pid()`);
-
-        // Wait for the SECOND gauge.set(1) — the reconnect. Generous timeout
-        // because postgres.js's reconnect loop includes backoff.
-        await waitFor(() => connectsWithValue1() > initialConnects, {
-          delays: Array(50).fill(200),
-        });
-        expect(connectsWithValue1()).toBeGreaterThan(initialConnects);
-      } finally {
-        await recStack.eventDispatcher?.stop();
-      }
-    } finally {
-      await recStack.cleanup();
-    }
-  });
-});
-
-// --- Helpers ---

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

@@ -1,276 +0,0 @@
-// EventConsumer.startFrom — opt-in cursor seed on FIRST registration
-// (fw#2482/1). Mounting a NEW consumer into an app whose event log is
-// already populated must not replay history and fire every side-effect
-// step retroactively.
-//
-// setupTestStack's own dispatcher pre-registers every consumer eagerly at
-// stack construction time (test-stack.ts: "Pre-register consumer state
-// rows..."), before any test body can seed historical events — so it can't
-// reproduce "mount into an already-running app" the way this fix needs.
-// This test instead builds its own EventDispatcher via createEventDispatcher()
-// against a plain createTestDb(), and only calls ensureRegistered() AFTER
-// historical events already exist — the same order a real deploy of a new
-// event-triggered workflow hits in production.
-
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-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, SHARED_INSTANCE_SENTINEL } from "../event-consumer-state";
-import { createEventDispatcher, type EventConsumer, getConsumerState } from "../event-dispatcher";
-import { fetchPendingEvents } from "../event-dispatcher-delivery";
-
-const admin = TestUsers.admin;
-let testDb: TestDb;
-let historicalEventCount = 0;
-
-function stubContext(): AppContext {
-  return {
-    db: {} as unknown as AppContext["db"],
-    redis: {} as unknown as AppContext["redis"],
-    registry: {} as unknown as AppContext["registry"],
-  } as AppContext;
-}
-
-async function appendHistoricalEvent(type: string): Promise<void> {
-  await insertOne(testDb.db, eventsTable, {
-    aggregateId: crypto.randomUUID(),
-    aggregateType: "start-from-test-source",
-    tenantId: admin.tenantId,
-    version: 1,
-    type,
-    eventVersion: 1,
-    payload: {},
-    metadata: { userId: admin.id },
-    createdBy: admin.id,
-  });
-  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();
-  await createEventConsumerStateTable(testDb.db);
-});
-
-afterAll(async () => {
-  await testDb.cleanup();
-});
-
-describe("EventConsumer.startFrom", () => {
-  test("'now' seeds the cursor at MAX(events.id) on first registration and skips the historical log", async () => {
-    await appendHistoricalEvent("start-from-test.one");
-    await appendHistoricalEvent("start-from-test.two");
-    await appendHistoricalEvent("start-from-test.three");
-    const headAtMount = BigInt(historicalEventCount);
-
-    const captured: string[] = [];
-    const consumer: EventConsumer = {
-      name: "test:consumer:mounted-now",
-      startFrom: "now",
-      handler: async (event) => {
-        captured.push(event.type);
-      },
-    };
-
-    // Mirrors mounting a new event-triggered workflow into a production app
-    // that already has a populated event log: the dispatcher (and its
-    // consumer) is only constructed AFTER the historical events above exist.
-    const dispatcher = createEventDispatcher({
-      db: testDb.db,
-      consumers: [consumer],
-      context: stubContext(),
-    });
-    await dispatcher.ensureRegistered();
-
-    const state = await getConsumerState(testDb.db, consumer.name);
-    expect(state?.lastProcessedEventId).toBe(headAtMount);
-    expect(state?.status).toBe("idle");
-
-    const result = await dispatcher.runOnce();
-    expect(result.byConsumer[consumer.name]).toEqual({ processed: 0, failed: 0 });
-    expect(captured).toHaveLength(0);
-
-    // Not just "not delivered" — proves the id > cursor contract directly:
-    // no historical row is even fetched on the first pass.
-    await testDb.db.begin(async (tx: DbTx) => {
-      const pending = await fetchPendingEvents(tx, headAtMount, 100);
-      expect(pending).toHaveLength(0);
-    });
-  });
-
-  test("without startFrom (default 'beginning') a freshly-registered consumer replays the full historical log", async () => {
-    await appendHistoricalEvent("start-from-test.four");
-    await appendHistoricalEvent("start-from-test.five");
-    const expectedReplayCount = historicalEventCount;
-
-    const captured: string[] = [];
-    const consumer: EventConsumer = {
-      name: "test:consumer:mounted-beginning",
-      handler: async (event) => {
-        captured.push(event.type);
-      },
-    };
-
-    const dispatcher = createEventDispatcher({
-      db: testDb.db,
-      consumers: [consumer],
-      context: stubContext(),
-    });
-    await dispatcher.ensureRegistered();
-
-    const stateBefore = await getConsumerState(testDb.db, consumer.name);
-    expect(stateBefore?.lastProcessedEventId).toBe(0n);
-
-    const result = await dispatcher.runOnce();
-    expect(result.byConsumer[consumer.name]).toEqual({ processed: expectedReplayCount, failed: 0 });
-    expect(captured).toEqual([
-      "start-from-test.one",
-      "start-from-test.two",
-      "start-from-test.three",
-      "start-from-test.four",
-      "start-from-test.five",
-    ]);
-  });
-
-  test("re-registering an already-registered consumer never clobbers an advanced cursor", async () => {
-    const consumer: EventConsumer = {
-      name: "test:consumer:advanced-then-remounted",
-      startFrom: "now",
-      handler: async () => {},
-    };
-
-    const dispatcher = createEventDispatcher({
-      db: testDb.db,
-      consumers: [consumer],
-      context: stubContext(),
-    });
-    await dispatcher.ensureRegistered();
-    const seeded = await getConsumerState(testDb.db, consumer.name);
-    expect(seeded?.lastProcessedEventId).toBe(BigInt(historicalEventCount));
-
-    await appendHistoricalEvent("start-from-test.six");
-    await dispatcher.runOnce();
-    const advanced = await getConsumerState(testDb.db, consumer.name);
-    expect(advanced?.lastProcessedEventId).toBe(BigInt(historicalEventCount));
-
-    // A new historical event exists again, not yet consumed by this consumer.
-    await appendHistoricalEvent("start-from-test.seven");
-
-    // A second dispatcher instance for the SAME consumer name simulates a
-    // process restart re-running the boot-time pre-registration — the row
-    // already exists, so ON CONFLICT DO NOTHING must leave its advanced
-    // cursor untouched, not reseed it at the new (higher) MAX(events.id).
-    const redeployedDispatcher = createEventDispatcher({
-      db: testDb.db,
-      consumers: [consumer],
-      context: stubContext(),
-    });
-    await redeployedDispatcher.ensureRegistered();
-
-    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__/event-dispatcher-strict.test.ts

@@ -1,67 +0,0 @@
-// Strict-precondition contract: runOnce() without a preceding start() /
-// ensureRegistered() must throw, not silently bootstrap. The throw is the
-// dispatcher's last line of defense against the prune-race — if pre-reg
-// is skipped, the state rows are absent, and acquireConsumerState would
-// return skip="not_registered" for every consumer. Failing loudly surfaces
-// the misuse instead of swallowing events.
-//
-// Unit-level because the check happens before any DB call — no pgClient,
-// no event-store schema, no setupTestStack needed.
-
-import { describe, expect, test } from "bun:test";
-import type { AppContext, Registry } from "../../engine/types";
-import { createEventDispatcher, type EventConsumer } from "../event-dispatcher";
-
-function stubContext(): AppContext {
-  return {
-    db: {} as unknown as AppContext["db"],
-    redis: {} as unknown as AppContext["redis"],
-    registry: {} as unknown as Registry,
-  } as AppContext;
-}
-
-describe("event-dispatcher — strict runOnce precondition", () => {
-  test("runOnce() before start() throws a clear 'not registered' error", async () => {
-    const consumers: EventConsumer[] = [{ name: "noop", handler: async () => {} }];
-    const dispatcher = createEventDispatcher({
-      db: {} as never,
-      consumers,
-      context: stubContext(),
-    });
-
-    await expect(dispatcher.runOnce()).rejects.toThrow(/runOnce\(\) called before start\(\)/);
-  });
-
-  test("ensureRegistered() is a valid alternative to start() — runOnce no longer throws", async () => {
-    const consumers: EventConsumer[] = [{ name: "noop", handler: async () => {} }];
-    let insertCalls = 0;
-    // bun-db path: dispatcher uses db/queries/ for transition guard + transaction().
-    // INSERT/SELECT/UPDATE. Match by SQL substring so we count INSERTs and
-    // hand back empty rows for SELECT.
-    const unsafe = async (sqlText: string): Promise<unknown[]> => {
-      if (/INSERT INTO "kumiko_event_consumers"/.test(sqlText)) {
-        insertCalls += 1;
-        return [];
-      }
-      return [];
-    };
-    const stubDb = {
-      unsafe,
-      begin: async (fn: (tx: unknown) => Promise<unknown>) => fn(stubDb),
-      transaction: async (fn: (tx: unknown) => Promise<unknown>) => fn(stubDb),
-    };
-    const dispatcher = createEventDispatcher({
-      db: stubDb as never,
-      consumers,
-      context: stubContext(),
-    });
-
-    await dispatcher.ensureRegistered();
-    expect(insertCalls).toBe(1);
-    // runOnce() no longer throws — it drains against the stubbed transaction.
-    await expect(dispatcher.runOnce()).resolves.toMatchObject({
-      processed: 0,
-      failed: 0,
-    });
-  });
-});