@cosmicdrift/kumiko-framework 0.328.0 → 0.329.0

package/src/pipeline/__tests__/event-dispatcher-per-consumer-turns.integration.test.ts

@@ -1,126 +0,0 @@
-// A consumer stuck in a slow handler (Meili index+waitTask, for example) must
-// not hold back delivery to the other consumers.
-
-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 {
-  createEventDispatcher,
-  type EventConsumer,
-  type EventDispatcher,
-  getConsumerState,
-} from "../../pipeline";
-import {
-  resetEventStore,
-  setupTestStack,
-  type TestStack,
-  TestUsers,
-  unsafeCreateEntityTable,
-} from "../../stack";
-import { sharedWidgetEntity, sharedWidgetTable, waitFor } from "../../testing";
-
-const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
-  entityName: "widget",
-});
-
-const feature = defineFeature("perconsumerturns", (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<void> {
-  await executor.create({ name }, admin, tdb);
-}
-
-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,
-    pollIntervalMs: 30,
-  });
-}
-
-describe("event-dispatcher — per-consumer turns", () => {
-  test("a blocked consumer does not delay another consumer's delivery", async () => {
-    const blockingName = "perconsumerturns:blocking";
-    const fastName = "perconsumerturns:fast";
-
-    let aEntered = false;
-    let releaseA: (() => void) | undefined;
-    const aGate = new Promise<void>((resolve) => {
-      releaseA = resolve;
-    });
-    const fastSeen: string[] = [];
-
-    // Order matters: A first. The old serial doPass() iterated consumers in
-    // array order, so with the blocking consumer first, a regression back
-    // to that code blocks the fast one too — this test must be red on it.
-    const blockingConsumer: EventConsumer = {
-      name: blockingName,
-      handler: async () => {
-        aEntered = true;
-        await aGate;
-      },
-    };
-    const fastConsumer: EventConsumer = {
-      name: fastName,
-      handler: async (event) => {
-        fastSeen.push(String(event.payload["name"]));
-      },
-    };
-
-    const dispatcher = buildDispatcher([blockingConsumer, fastConsumer]);
-    await dispatcher.start();
-    try {
-      await appendWidget("one");
-
-      await waitFor(() => aEntered === true, { delays: [20, 50, 100, 250] });
-
-      // The fast consumer must advance while the blocking one is still stuck
-      // inside its handler — proves the two no longer share a pass barrier.
-      await waitFor(
-        async () => {
-          const fastState = await getConsumerState(stack.db, fastName);
-          return fastState?.lastProcessedEventId === 1n;
-        },
-        { delays: [20, 50, 100, 250, 500] },
-      );
-      expect(fastSeen).toEqual(["one"]);
-
-      const blockingStateWhileStuck = await getConsumerState(stack.db, blockingName);
-      expect(blockingStateWhileStuck?.lastProcessedEventId).toBe(0n);
-
-      releaseA?.();
-
-      await waitFor(
-        async () => {
-          const blockingState = await getConsumerState(stack.db, blockingName);
-          return blockingState?.lastProcessedEventId === 1n;
-        },
-        { delays: [20, 50, 100, 250, 500] },
-      );
-    } finally {
-      // Release before stop() unconditionally — stop() drains in-flight
-      // turns, which would hang forever if the blocking handler never
-      // settles (e.g. the assertions above threw before releaseA() ran).
-      releaseA?.();
-      await dispatcher.stop();
-    }
-  });
-});

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

@@ -1,106 +0,0 @@
-// E.4 — PG LISTEN/NOTIFY wake-up. Without this, delivery latency is
-// bounded below by pollIntervalMs. With LISTEN, event-store.append fires
-// `pg_notify` on commit and any subscribed dispatcher wakes immediately.
-//
-// The polling timer stays as a safety net. These tests pin NOTIFY wake
-// without waiting for the timer, and that start/stop still leaves LISTEN
-// working. #2042: poll interval is 60s here; assert delivery inside 5s —
-// if LISTEN is dead the timer cannot rescue the assertion.
-
-import { afterAll, 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 { setupTestStack, type TestStack, TestUsers, unsafeCreateEntityTable } from "../../stack";
-import { sharedWidgetEntity, sharedWidgetTable, waitFor } from "../../testing";
-
-// --- Fixture ---
-
-const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
-  entityName: "widget",
-});
-
-let deliveryCount = 0;
-
-const listenFeature = defineFeature("listen", (r) => {
-  r.entity("widget", sharedWidgetEntity);
-
-  r.multiStreamProjection({
-    name: "latency-probe",
-    apply: {
-      "widget.created": async () => {
-        deliveryCount += 1;
-      },
-    },
-  });
-});
-
-const admin = TestUsers.admin;
-let stack: TestStack;
-let tdb: TenantDb;
-
-beforeAll(async () => {
-  stack = await setupTestStack({
-    features: [listenFeature],
-    systemHooks: [],
-    // Timer effectively off — see file header (#2042). If LISTEN is
-    // broken, delivery only happens via this timer, so nothing arrives
-    // before the 60s mark; the tests below wait a mere 5s.
-    eventDispatcherPollIntervalMs: 60_000,
-  });
-  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
-  tdb = createTenantDb(stack.db, admin.tenantId);
-});
-
-afterAll(async () => {
-  // setupTestStack's cleanup handles eventDispatcher.stop(), which in
-  // turn unlistens.
-});
-
-// --- Tests ---
-
-describe("E.4 — PG NOTIFY/LISTEN wake-up", () => {
-  test("NOTIFY on commit triggers runOnce without waiting for the poll timer", async () => {
-    deliveryCount = 0;
-
-    await stack.eventDispatcher?.start();
-    try {
-      await executor.create({ name: "latency-test" }, admin, tdb);
-
-      await waitFor(
-        () => {
-          expect(deliveryCount).toBe(1);
-        },
-        { delays: [100, 500, 1000, 3500] },
-      );
-    } finally {
-      await stack.eventDispatcher?.stop();
-    }
-  });
-
-  test("dispatcher start/stop cycle with LISTEN attached still delivers after restart", async () => {
-    // Repeated start/stop must not leak connections or break LISTEN.
-    // Two start/stop cycles, then a third start() that must still wake on
-    // NOTIFY — if the unlisten handle was mishandled, the subscription
-    // would be stale or double-registered.
-    for (let i = 0; i < 2; i++) {
-      await stack.eventDispatcher?.start();
-      await stack.eventDispatcher?.stop();
-    }
-
-    deliveryCount = 0;
-    await stack.eventDispatcher?.start();
-    try {
-      await executor.create({ name: "restart-probe" }, admin, tdb);
-
-      await waitFor(
-        () => {
-          expect(deliveryCount).toBe(1);
-        },
-        { delays: [100, 500, 1000, 3500] },
-      );
-    } finally {
-      await stack.eventDispatcher?.stop();
-    }
-  });
-});

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

@@ -1,263 +0,0 @@
-// Issue #1350 — bounded auto-revival of a dead consumer.
-//
-// acquireConsumerState no longer parks a dead consumer forever: once its
-// last write is older than rearmCooldownMs it gets reset to idle and
-// retried, up to maxRearmCount times. A poison event (permanent failure)
-// still ends up permanently dead once the budget is exhausted — the
-// mechanism is a bounded number of extra chances, not unlimited retry.
-
-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 {
-  DEFAULT_SENSITIVE_CONFIG,
-  type MetricEvent,
-  type ObservabilityProvider,
-  RecordingMeter,
-  RecordingTracer,
-} from "../../observability";
-import { getConsumerState } from "../../pipeline";
-import {
-  resetEventStore,
-  setupTestStack,
-  type TestStack,
-  TestUsers,
-  unsafeCreateEntityTable,
-} from "../../stack";
-import { sharedWidgetEntity, sharedWidgetTable } from "../../testing";
-import { withoutAmbientTemporal } from "../../testing/without-ambient-temporal";
-import { SHARED_INSTANCE_SENTINEL } from "../event-consumer-state";
-
-const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
-  entityName: "widget",
-});
-
-let poisonNames = new Set<string>();
-let observed: Array<{ name: string }> = [];
-
-const rearmFeature = defineFeature("rearmtest", (r) => {
-  r.entity("widget", sharedWidgetEntity);
-
-  r.multiStreamProjection({
-    name: "observer",
-    apply: {
-      "widget.created": async (event) => {
-        const name = event.payload["name"] as string;
-        if (poisonNames.has(name)) {
-          throw new Error(`poisoned: ${name}`);
-        }
-        observed.push({ name });
-      },
-    },
-  });
-});
-
-const admin = TestUsers.admin;
-const qn = "rearmtest:projection:observer";
-let stack: TestStack;
-let tdb: TenantDb;
-
-beforeAll(async () => {
-  stack = await setupTestStack({
-    features: [rearmFeature],
-    systemHooks: [],
-  });
-  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
-  tdb = createTenantDb(stack.db, admin.tenantId);
-});
-
-afterEach(async () => {
-  poisonNames = new Set();
-  observed = [];
-  await resetEventStore(stack, ["read_widgets"]);
-});
-
-async function appendWidget(name: string): Promise<void> {
-  await executor.create({ name }, admin, tdb);
-}
-
-async function driveUntilDead(): Promise<void> {
-  for (let i = 0; i < 10; i++) {
-    await stack.eventDispatcher?.runOnce();
-  }
-}
-
-// Simulates cooldown elapsed without waiting real wall-clock time.
-async function backdateUpdatedAt(minutesAgo: number): Promise<void> {
-  await asRawClient(stack.db).unsafe(
-    `UPDATE "kumiko_event_consumers" SET "updated_at" = now() - make_interval(mins => $1)
-     WHERE "name" = $2 AND "instance_id" = $3`,
-    [minutesAgo, qn, SHARED_INSTANCE_SENTINEL],
-  );
-}
-
-describe("issue #1350 — bounded dead-consumer re-arm", () => {
-  test("stays dead within the cooldown window", async () => {
-    poisonNames.add("poison");
-    await appendWidget("poison");
-    await driveUntilDead();
-
-    const dead = await getConsumerState(stack.db, qn);
-    expect(dead?.status).toBe("dead");
-    expect(dead?.rearmCount).toBe(0);
-
-    // No backdate — cooldown (5min default) hasn't elapsed.
-    await stack.eventDispatcher?.runOnce();
-    const stillDead = await getConsumerState(stack.db, qn);
-    expect(stillDead?.status).toBe("dead");
-    expect(stillDead?.rearmCount).toBe(0);
-  });
-
-  test("auto-revives once cooldown elapses, and re-dies on the same poison event", async () => {
-    poisonNames.add("poison");
-    await appendWidget("poison");
-    await driveUntilDead();
-
-    await backdateUpdatedAt(10);
-    await stack.eventDispatcher?.runOnce();
-
-    const revived = await getConsumerState(stack.db, qn);
-    expect(revived?.status).toBe("idle");
-    expect(revived?.rearmCount).toBe(1);
-    // Same pass that revives it also retries the pending poisoned event —
-    // acquireConsumerState's reset (attempts=0) is followed immediately by
-    // one failed delivery attempt within this runOnce() call.
-    expect(revived?.attempts).toBe(1);
-
-    // Handler still throws on "poison" — climbs back to dead.
-    await driveUntilDead();
-    const deadAgain = await getConsumerState(stack.db, qn);
-    expect(deadAgain?.status).toBe("dead");
-    expect(deadAgain?.rearmCount).toBe(1);
-  });
-
-  test("a re-arm that leads to a real delivery resets rearmCount to 0", async () => {
-    poisonNames.add("poison");
-    await appendWidget("poison");
-    await driveUntilDead();
-
-    // Cause is gone by the time the cooldown elapses — the retried event
-    // now succeeds instead of re-poisoning the consumer.
-    poisonNames.delete("poison");
-    await backdateUpdatedAt(10);
-    await stack.eventDispatcher?.runOnce();
-
-    const recovered = await getConsumerState(stack.db, qn);
-    expect(recovered?.status).toBe("idle");
-    expect(recovered?.rearmCount).toBe(0);
-    expect(observed.map((o) => o.name)).toEqual(["poison"]);
-
-    // A later, unrelated poison event gets its own fresh maxRearmCount
-    // budget instead of inheriting the spent counter from the resolved one.
-    poisonNames.add("later-poison");
-    await appendWidget("later-poison");
-    await driveUntilDead();
-    const deadAgain = await getConsumerState(stack.db, qn);
-    expect(deadAgain?.status).toBe("dead");
-    expect(deadAgain?.rearmCount).toBe(0);
-  });
-
-  test("kumiko-framework#1525: cooldown-elapsed re-arm check works without relying on globalThis.Temporal", async () => {
-    poisonNames.add("poison");
-    await appendWidget("poison");
-    await driveUntilDead();
-    await backdateUpdatedAt(10);
-
-    // ensureTemporalPolyfill re-installs if the ambient global was torn down,
-    // so runOnce stays safe if a nested path calls it during this window.
-    await withoutAmbientTemporal(async () => {
-      await stack.eventDispatcher?.runOnce();
-    });
-
-    const revived = await getConsumerState(stack.db, qn);
-    expect(revived?.status).toBe("idle");
-    expect(revived?.rearmCount).toBe(1);
-  });
-
-  test("permanently dead after maxRearmCount cycles, even once cooldown elapses again", async () => {
-    poisonNames.add("poison");
-    await appendWidget("poison");
-    await driveUntilDead();
-
-    // Cycles 1..3: each backdate+drive re-arms once, then re-dies on the
-    // same poison event. Default maxRearmCount is 3.
-    for (let cycle = 1; cycle <= 3; cycle++) {
-      await backdateUpdatedAt(10);
-      await stack.eventDispatcher?.runOnce();
-      const revived = await getConsumerState(stack.db, qn);
-      expect(revived?.rearmCount).toBe(cycle);
-      await driveUntilDead();
-    }
-
-    const exhausted = await getConsumerState(stack.db, qn);
-    expect(exhausted?.status).toBe("dead");
-    expect(exhausted?.rearmCount).toBe(3);
-
-    // Cooldown elapsed again, but the budget is spent — stays dead.
-    await backdateUpdatedAt(10);
-    await stack.eventDispatcher?.runOnce();
-    const stillExhausted = await getConsumerState(stack.db, qn);
-    expect(stillExhausted?.status).toBe("dead");
-    expect(stillExhausted?.rearmCount).toBe(3);
-  });
-
-  test("kumiko_event_consumer_rearm_exhausted_total fires once, not per still-dead pass (#1362)", async () => {
-    // Dedicated stack with a RecordingMeter — module-level `stack` above is
-    // shared across every test in this file and has no metric capture.
-    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: [rearmFeature],
-      systemHooks: [],
-      observability: recordingProvider,
-    });
-    try {
-      await unsafeCreateEntityTable(recStack.db, sharedWidgetEntity, "widget");
-      const recTdb = createTenantDb(recStack.db, admin.tenantId);
-
-      poisonNames.add("poison-metric");
-      await executor.create({ name: "poison-metric" }, admin, recTdb);
-      for (let i = 0; i < 10; i++) {
-        await recStack.eventDispatcher?.runOnce();
-      }
-      // The 10th pass is the one whose failed delivery flips status to
-      // "dead" (persisted for the NEXT pass to see) — acquireConsumerState's
-      // dead-branch (where the exhausted-metric fires) only runs starting
-      // from the pass AFTER that transition, same as the "stays dead within
-      // cooldown window" test above needing one extra runOnce().
-      await recStack.eventDispatcher?.runOnce();
-
-      const exhaustedEvents = () =>
-        metricEvents.filter(
-          (e) =>
-            e.type === "counter.inc" && e.name === "kumiko_event_consumer_rearm_exhausted_total",
-        );
-      expect(exhaustedEvents().length).toBe(1);
-
-      // Several more passes while it's still dead — must stay at 1, not
-      // re-fire on every pass that observes "still dead" (log/metric spam
-      // the finding flagged).
-      for (let i = 0; i < 5; i++) {
-        await recStack.eventDispatcher?.runOnce();
-      }
-      expect(exhaustedEvents().length).toBe(1);
-      expect(exhaustedEvents()[0]?.labels?.["consumer"]).toBe(qn);
-    } finally {
-      await resetEventStore(recStack, ["read_widgets"]);
-      await recStack.cleanup();
-    }
-  });
-});

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

@@ -1,202 +0,0 @@
-// E.9 — Dead-Letter Recovery surface.
-//
-// The dispatcher halts-on-poison: repeated handler throws on the same event
-// mark the consumer "dead" and pause delivery for it. Without an operational
-// recovery surface, "dead" was a terminal state with only raw SQL as an
-// escape hatch. These tests pin the five recovery moves:
-//
-//   restartConsumer  status=dead → idle, attempts=0, cursor unchanged.
-//                    Dispatcher retries the failing event on the next pass.
-//   disableConsumer  status=any → disabled. Dispatcher skips it entirely.
-//   enableConsumer   status=disabled → idle. Delivery resumes.
-//   skipPoisonEvent  advances cursor past the first event after the current
-//                    cursor, resets attempts, status=idle. For events that
-//                    will never succeed (broken payload, removed code).
-//   (list/status are read-only; covered by event-dispatcher wiring tests.)
-
-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 {
-  disableConsumer,
-  enableConsumer,
-  getConsumerState,
-  restartConsumer,
-  skipPoisonEvent,
-} from "../../pipeline";
-import {
-  resetEventStore,
-  setupTestStack,
-  type TestStack,
-  TestUsers,
-  unsafeCreateEntityTable,
-} from "../../stack";
-import { sharedWidgetEntity, sharedWidgetTable } from "../../testing";
-
-// --- Fixture ---
-
-const executor = createEventStoreExecutor(sharedWidgetTable, sharedWidgetEntity, {
-  entityName: "widget",
-});
-
-// Names that make the observer throw. Reset in afterEach.
-let poisonNames = new Set<string>();
-let observed: Array<{ name: string }> = [];
-
-const recoveryFeature = defineFeature("recoverytest", (r) => {
-  r.entity("widget", sharedWidgetEntity);
-
-  r.multiStreamProjection({
-    name: "observer",
-    apply: {
-      "widget.created": async (event) => {
-        const name = event.payload["name"] as string;
-        if (poisonNames.has(name)) {
-          throw new Error(`poisoned: ${name}`);
-        }
-        observed.push({ name });
-      },
-    },
-  });
-});
-
-const admin = TestUsers.admin;
-const qn = "recoverytest:projection:observer";
-let stack: TestStack;
-let tdb: TenantDb;
-
-beforeAll(async () => {
-  stack = await setupTestStack({
-    features: [recoveryFeature],
-    systemHooks: [],
-  });
-  await unsafeCreateEntityTable(stack.db, sharedWidgetEntity, "widget");
-  tdb = createTenantDb(stack.db, admin.tenantId);
-});
-
-afterEach(async () => {
-  poisonNames = new Set();
-  observed = [];
-  await resetEventStore(stack, ["read_widgets"]);
-});
-
-async function appendWidget(name: string): Promise<void> {
-  await executor.create({ name }, admin, tdb);
-}
-
-async function driveUntilDead(): Promise<void> {
-  // Default maxAttempts is 10. Run enough passes to exhaust and land on dead.
-  for (let i = 0; i < 10; i++) {
-    await stack.eventDispatcher?.runOnce();
-  }
-}
-
-// --- Tests ---
-
-describe("E.9 — restartConsumer", () => {
-  test("revives a dead consumer: status=idle, attempts=0, cursor unchanged, handler retried next pass", async () => {
-    poisonNames.add("poison");
-    await appendWidget("poison");
-    await driveUntilDead();
-
-    const deadState = await getConsumerState(stack.db, qn);
-    expect(deadState?.status).toBe("dead");
-    expect(deadState?.attempts).toBe(10);
-    const cursorBefore = deadState?.lastProcessedEventId;
-
-    const after = await restartConsumer(stack.db, qn);
-    expect(after.status).toBe("idle");
-    expect(after.attempts).toBe(0);
-    expect(after.lastError).toBeNull();
-    // Cursor unchanged — next pass retries the SAME failing event.
-    expect(after.lastProcessedEventId).toBe(cursorBefore!);
-
-    // Retry still poisoned (handler still throws) — attempts climbs again.
-    await stack.eventDispatcher?.runOnce();
-    const afterRetry = await getConsumerState(stack.db, qn);
-    expect(afterRetry?.attempts).toBe(1);
-    expect(afterRetry?.lastError).toMatch(/poisoned: poison/);
-  });
-
-  test("refuses to restart a healthy consumer (only dead makes sense)", async () => {
-    await appendWidget("clean");
-    await stack.eventDispatcher?.runOnce();
-    const state = await getConsumerState(stack.db, qn);
-    expect(state?.status).toBe("idle");
-
-    await expect(restartConsumer(stack.db, qn)).rejects.toThrow(/not dead/);
-  });
-});
-
-describe("E.9 — disable / enable", () => {
-  test("disabled consumer skips delivery even when new events arrive; enable resumes", async () => {
-    await appendWidget("first");
-    await stack.eventDispatcher?.runOnce();
-    expect(observed.map((o) => o.name)).toEqual(["first"]);
-
-    await disableConsumer(stack.db, qn);
-    const disabled = await getConsumerState(stack.db, qn);
-    expect(disabled?.status).toBe("disabled");
-
-    await appendWidget("while-disabled");
-    await stack.eventDispatcher?.runOnce();
-    // Still only "first" — disabled consumer didn't pick up "while-disabled".
-    expect(observed.map((o) => o.name)).toEqual(["first"]);
-
-    await enableConsumer(stack.db, qn);
-    const enabled = await getConsumerState(stack.db, qn);
-    expect(enabled?.status).toBe("idle");
-
-    await stack.eventDispatcher?.runOnce();
-    expect(observed.map((o) => o.name)).toEqual(["first", "while-disabled"]);
-  });
-
-  test("enable on a non-disabled consumer throws (prevents accidental state reset)", async () => {
-    await appendWidget("healthy");
-    await stack.eventDispatcher?.runOnce();
-    await expect(enableConsumer(stack.db, qn)).rejects.toThrow(/not disabled/);
-  });
-});
-
-describe("E.9 — skipPoisonEvent", () => {
-  test("skips past a poisoned event, advances cursor, subsequent events deliver", async () => {
-    await appendWidget("before-poison");
-    await poisonNames.add("the-poison");
-    await appendWidget("the-poison");
-    poisonNames.delete("the-poison"); // no-op for current state; only matters for later retries
-    await appendWidget("after-poison");
-
-    // Restore throw-on: the handler keeps throwing on the poison name
-    // until we explicitly skip it. Re-add.
-    poisonNames.add("the-poison");
-    await driveUntilDead();
-
-    const beforeSkip = await getConsumerState(stack.db, qn);
-    expect(beforeSkip?.status).toBe("dead");
-    // "before-poison" was delivered successfully, so cursor sits at event 1.
-    expect(beforeSkip?.lastProcessedEventId).toBe(1n);
-
-    const skipResult = await skipPoisonEvent(stack.db, qn);
-    expect(skipResult.status).toBe("idle");
-    expect(skipResult.attempts).toBe(0);
-    expect(skipResult.skippedEventId).toBe(2n);
-    expect(skipResult.lastProcessedEventId).toBe(2n);
-
-    // Now the dispatcher should pick up event 3 ("after-poison").
-    await stack.eventDispatcher?.runOnce();
-    expect(observed.map((o) => o.name)).toEqual(["before-poison", "after-poison"]);
-  });
-
-  test("no-op when cursor is already at events head", async () => {
-    await appendWidget("only-one");
-    await stack.eventDispatcher?.runOnce();
-    const caught = await getConsumerState(stack.db, qn);
-    expect(caught?.lastProcessedEventId).toBe(1n);
-
-    const skipResult = await skipPoisonEvent(stack.db, qn);
-    expect(skipResult.skippedEventId).toBeNull();
-    // Cursor did not move.
-    expect(skipResult.lastProcessedEventId).toBe(1n);
-  });
-});