@relaybus/testing 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,5 +1,5 @@
-import { createUuidV7 } from '@relaybus/core';
 import { describe, beforeEach, afterEach, it, expect } from 'vitest';
+import { createUuidV7 } from '@relaybus/core';
 
 // src/event-store-contract.ts
 function createDeferred() {
@@ -31,1251 +31,1327 @@ function createEnvelope(overrides = {}) {
 function createDelivery(handler, availableAt = at(0)) {
   return { id: createUuidV7(), handler, availableAt };
 }
-function eventStoreContract(name, options) {
-  const keepsCompleted = options.keepsCompletedRecords ?? false;
-  describe(`${name} satisfies the EventStore contract`, () => {
-    let store;
-    beforeEach(async () => {
-      store = await options.createStore();
+
+// src/contract/append-and-claim.ts
+function appendAndClaimContract(suite) {
+  const { append, claim } = suite;
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("setup", () => {
+    it("can run more than once", async () => {
+      await store.setup?.();
+      await store.setup?.();
+      expect(await store.statistics(at(0))).toMatchObject({ pending: 0 });
     });
-    afterEach(async () => {
-      await options.destroyStore?.(store);
+  });
+  describe("append", () => {
+    it("stores events and deliveries when the transaction commits", async () => {
+      const event = createEnvelope();
+      const result = await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      expect(result).toEqual({
+        appendedEventIds: [event.id],
+        duplicateEventIds: [],
+        appendedDeliveryCount: 2
+      });
+      const records = await store.listDeliveries({ eventId: event.id });
+      expect(records.map((record) => record.handler).sort()).toEqual(["handler-a", "handler-b"]);
+      expect(records.every((record) => record.status === "pending" && record.attempts === 0)).toBe(
+        true
+      );
     });
-    async function append(entries, now = at(0)) {
-      return store.transaction((transaction) => store.append(transaction, entries, now));
-    }
-    async function completeMany(target, leases, now) {
-      if (target.completeMany !== void 0) {
-        return target.completeMany(leases, now);
-      }
-      const outcomes = [];
-      for (const lease of leases) {
-        outcomes.push(await target.complete(lease, now));
-      }
-      return outcomes;
-    }
-    async function claim(handlers, now = at(0), limit = 100, owner = "worker-1") {
-      return store.claim({
-        handlers,
-        limit,
-        leaseOwner: owner,
-        leaseExpiresAt: new Date(now.getTime() + LEASE_MS),
-        now
-      });
-    }
-    describe("setup", () => {
-      it("can run more than once", async () => {
-        await store.setup?.();
-        await store.setup?.();
-        expect(await store.statistics(at(0))).toMatchObject({ pending: 0 });
-      });
+    it("stores nothing when the transaction rolls back", async () => {
+      const event = createEnvelope();
+      const failure = new Error("rollback");
+      await expect(
+        store.transaction(async (transaction) => {
+          await store.append(
+            transaction,
+            [{ event, deliveries: [createDelivery("handler-a")] }],
+            at(0)
+          );
+          throw failure;
+        })
+      ).rejects.toBe(failure);
+      expect(await store.listDeliveries({})).toEqual([]);
+      expect(await claim(["handler-a"])).toEqual([]);
     });
-    describe("append", () => {
-      it("stores events and deliveries when the transaction commits", async () => {
-        const event = createEnvelope();
-        const result = await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        expect(result).toEqual({
-          appendedEventIds: [event.id],
-          duplicateEventIds: [],
-          appendedDeliveryCount: 2
-        });
-        const records = await store.listDeliveries({ eventId: event.id });
-        expect(records.map((record) => record.handler).sort()).toEqual(["handler-a", "handler-b"]);
-        expect(
-          records.every((record) => record.status === "pending" && record.attempts === 0)
-        ).toBe(true);
-      });
-      it("stores nothing when the transaction rolls back", async () => {
-        const event = createEnvelope();
-        const failure = new Error("rollback");
-        await expect(
-          store.transaction(async (transaction) => {
-            await store.append(
-              transaction,
-              [{ event, deliveries: [createDelivery("handler-a")] }],
-              at(0)
-            );
-            throw failure;
-          })
-        ).rejects.toBe(failure);
-        expect(await store.listDeliveries({})).toEqual([]);
-        expect(await claim(["handler-a"])).toEqual([]);
-      });
-      it("returns the value of the transaction work", async () => {
-        await expect(store.transaction(async () => "result")).resolves.toBe("result");
-      });
-      it("round-trips the envelope exactly as JSON would", async () => {
-        const event = createEnvelope({
-          key: "order-42",
-          payload: { text: "\xE7\u011F\u0131\xF6\u015F\xFC \u{1F680}", nested: { list: [1, "two", null, true] }, amount: 12.5 },
-          headers: { traceparent: "00-abc-def-01", tenant: "acme" },
-          correlationId: createUuidV7(),
-          causationId: createUuidV7(),
-          occurredAt: /* @__PURE__ */ new Date("2026-03-04T05:06:07.089Z")
-        });
-        await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        const [claimed] = await claim(["handler-a"]);
-        expect(claimed.event).toEqual(event);
-        expect(claimed.event.occurredAt).toBeInstanceOf(Date);
-      });
-      it("skips an event id that already exists but adds its missing deliveries", async () => {
-        const event = createEnvelope();
-        await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        const result = await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        expect(result).toEqual({
-          appendedEventIds: [],
-          duplicateEventIds: [event.id],
-          appendedDeliveryCount: 1
-        });
-        const records = await store.listDeliveries({ eventId: event.id });
-        expect(records.map((record) => record.handler).sort()).toEqual(["handler-a", "handler-b"]);
-      });
-      it("deduplicates repeated events and handlers inside one call", async () => {
-        const event = createEnvelope();
-        const result = await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-a")] },
-          { event, deliveries: [createDelivery("handler-a")] }
-        ]);
-        expect(result.appendedEventIds).toEqual([event.id]);
-        expect(result.duplicateEventIds).toEqual([event.id]);
-        expect(result.appendedDeliveryCount).toBe(1);
-        expect(await store.listDeliveries({})).toHaveLength(1);
-      });
-      it("keeps events written by concurrent transactions apart", async () => {
-        const events = Array.from({ length: 20 }, () => createEnvelope());
-        await Promise.all(
-          events.map((event) => append([{ event, deliveries: [createDelivery("handler-a")] }]))
-        );
-        expect(await store.listDeliveries({ limit: 1e3 })).toHaveLength(20);
-      });
+    it("returns the value of the transaction work", async () => {
+      await expect(store.transaction(async () => "result")).resolves.toBe("result");
     });
-    describe("claim", () => {
-      it("leases due deliveries of the requested handlers and counts the attempt", async () => {
-        const event = createEnvelope();
-        await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        const claimed = await claim(["handler-a"], at(1e3));
-        expect(claimed).toHaveLength(1);
-        expect(claimed[0]).toMatchObject({
-          handler: "handler-a",
-          attempt: 1,
-          leaseExpiresAt: at(1e3 + LEASE_MS)
-        });
-        expect(claimed[0].leaseToken).toEqual(expect.any(String));
-        const [record] = await store.listDeliveries({ handler: "handler-a" });
-        expect(record).toMatchObject({ status: "processing", attempts: 1, leaseOwner: "worker-1" });
-        expect(record.leaseExpiresAt).toEqual(at(1e3 + LEASE_MS));
-      });
-      it("ignores deliveries that are not due yet", async () => {
-        await append([
-          { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(5e3))] }
-        ]);
-        expect(await claim(["handler-a"], at(4999))).toEqual([]);
-        expect(await claim(["handler-a"], at(5e3))).toHaveLength(1);
-      });
-      it("returns nothing for an empty handler list", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        expect(await claim([])).toEqual([]);
-      });
-      it("respects the limit and claims the earliest due first", async () => {
-        const late = createEnvelope();
-        const early = createEnvelope();
-        const middle = createEnvelope();
-        await append([
-          { event: late, deliveries: [createDelivery("handler-a", at(300))] },
-          { event: early, deliveries: [createDelivery("handler-a", at(100))] },
-          { event: middle, deliveries: [createDelivery("handler-a", at(200))] }
-        ]);
-        const first = await claim(["handler-a"], at(1e3), 2);
-        expect(first.map((delivery) => delivery.event.id)).toEqual([early.id, middle.id]);
-        const second = await claim(["handler-a"], at(1e3), 2);
-        expect(second.map((delivery) => delivery.event.id)).toEqual([late.id]);
-      });
-      it("breaks ties between equally due deliveries by delivery id", async () => {
-        const ids = [createUuidV7(), createUuidV7(), createUuidV7()].sort();
-        await append([
-          {
-            event: createEnvelope(),
-            deliveries: [{ id: ids[2], handler: "handler-a", availableAt: at(0) }]
-          },
-          {
-            event: createEnvelope(),
-            deliveries: [{ id: ids[0], handler: "handler-a", availableAt: at(0) }]
-          },
-          {
-            event: createEnvelope(),
-            deliveries: [{ id: ids[1], handler: "handler-a", availableAt: at(0) }]
-          }
-        ]);
-        const claimed = await claim(["handler-a"], at(0), 3);
-        expect(claimed.map((delivery) => delivery.deliveryId)).toEqual(ids);
-      });
-      it("does not hand out a leased delivery until its lease expires", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [first] = await claim(["handler-a"], at(0));
-        expect(await claim(["handler-a"], at(LEASE_MS - 1), 100, "worker-2")).toEqual([]);
-        const [second] = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(second).toMatchObject({ deliveryId: first.deliveryId, attempt: 2 });
-        expect(second.leaseToken).not.toBe(first.leaseToken);
-      });
-      it("never gives the same delivery to two concurrent claimers", async () => {
-        const entries = Array.from({ length: 40 }, () => ({
-          event: createEnvelope(),
-          deliveries: [createDelivery("handler-a")]
-        }));
-        await append(entries);
-        const batches = await Promise.all(
-          Array.from({ length: 8 }, async (_, index) => {
-            const own = [];
-            for (; ; ) {
-              const batch = await claim(["handler-a"], at(0), 10, `worker-${index}`);
-              if (batch.length === 0) {
-                return own;
-              }
-              own.push(...batch);
-            }
-          })
-        );
-        const leftovers = await claim(["handler-a"], at(0), 100, "worker-late");
-        const claimedIds = [...batches.flat(), ...leftovers].map((delivery) => delivery.deliveryId);
-        expect(new Set(claimedIds).size).toBe(claimedIds.length);
-        expect(claimedIds).toHaveLength(40);
-      });
+    it("round-trips the envelope exactly as JSON would", async () => {
+      const event = createEnvelope({
+        key: "order-42",
+        payload: { text: "\xE7\u011F\u0131\xF6\u015F\xFC \u{1F680}", nested: { list: [1, "two", null, true] }, amount: 12.5 },
+        headers: { traceparent: "00-abc-def-01", tenant: "acme" },
+        correlationId: createUuidV7(),
+        causationId: createUuidV7(),
+        occurredAt: /* @__PURE__ */ new Date("2026-03-04T05:06:07.089Z")
+      });
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [claimed] = await claim(["handler-a"]);
+      expect(claimed.event).toEqual(event);
+      expect(claimed.event.occurredAt).toBeInstanceOf(Date);
     });
-    describe("fencing", () => {
-      it("completes a delivery only with its current lease", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [stale] = await claim(["handler-a"], at(0));
-        const [current] = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
-        expect(await store.extendLease(stale, at(LEASE_MS * 3), at(LEASE_MS + 1))).toBe(false);
-        expect(
-          await store.reschedule(stale, at(0), { name: "Error", message: "x" }, at(LEASE_MS + 1))
-        ).toBe(false);
-        expect(await store.bury(stale, { name: "Error", message: "x" }, at(LEASE_MS + 1))).toBe(
-          false
-        );
-        expect(await store.complete(current, at(LEASE_MS + 2))).toBe(true);
-        if (!keepsCompleted) {
-          expect(await store.listDeliveries({})).toEqual([]);
-          return;
-        }
-        const [record] = await store.listDeliveries({});
-        expect(record).toMatchObject({
-          status: "completed",
-          leaseOwner: null,
-          leaseExpiresAt: null
-        });
-        expect(record.completedAt).toEqual(at(LEASE_MS + 2));
-      });
-      it("refuses to complete twice", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        expect(await store.complete(delivery, at(1))).toBe(true);
-        expect(await store.complete(delivery, at(2))).toBe(false);
-      });
-      it("refuses leases of unknown deliveries", async () => {
-        const lease = { deliveryId: createUuidV7(), leaseToken: createUuidV7() };
-        expect(await store.complete(lease, at(0))).toBe(false);
-        expect(await store.extendLease(lease, at(1), at(0))).toBe(false);
-      });
-      it("extends a held lease", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        expect(await store.extendLease(delivery, at(LEASE_MS * 2), at(10))).toBe(true);
-        expect(await claim(["handler-a"], at(LEASE_MS + 1), 100, "worker-2")).toEqual([]);
-        const [record] = await store.listDeliveries({});
-        expect(record.leaseExpiresAt).toEqual(at(LEASE_MS * 2));
-      });
-      it("completes inside a transaction together with it", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        await expect(
-          store.transaction(async (transaction) => {
-            expect(await store.complete(delivery, at(1), transaction)).toBe(true);
-            throw new Error("rollback");
-          })
-        ).rejects.toThrow("rollback");
-        expect((await store.listDeliveries({}))[0].status).toBe("processing");
-        await store.transaction(async (transaction) => {
-          expect(await store.complete(delivery, at(2), transaction)).toBe(true);
-        });
-        if (keepsCompleted) {
-          expect((await store.listDeliveries({}))[0].status).toBe("completed");
-        } else {
-          expect(await store.listDeliveries({})).toEqual([]);
-        }
-      });
-      it("refuses a transactional completion with a lost lease", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [stale] = await claim(["handler-a"], at(0));
-        await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        await store.transaction(async (transaction) => {
-          expect(await store.complete(stale, at(LEASE_MS + 1), transaction)).toBe(false);
-        });
-        expect((await store.listDeliveries({}))[0].status).toBe("processing");
-      });
+    it("skips an event id that already exists but adds its missing deliveries", async () => {
+      const event = createEnvelope();
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const result = await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      expect(result).toEqual({
+        appendedEventIds: [],
+        duplicateEventIds: [event.id],
+        appendedDeliveryCount: 1
+      });
+      const records = await store.listDeliveries({ eventId: event.id });
+      expect(records.map((record) => record.handler).sort()).toEqual(["handler-a", "handler-b"]);
     });
-    describe("retries and dead letters", () => {
-      it("reschedules a delivery with its error", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        const error = { name: "TypeError", message: "boom", stack: "TypeError: boom\n    at x" };
-        expect(await store.reschedule(delivery, at(1e4), error, at(5))).toBe(true);
-        const [record] = await store.listDeliveries({});
-        expect(record).toMatchObject({
-          status: "pending",
-          attempts: 1,
-          lastError: error,
-          leaseOwner: null
-        });
-        expect(record.availableAt).toEqual(at(1e4));
-        expect(await claim(["handler-a"], at(9999))).toEqual([]);
-        const [retry] = await claim(["handler-a"], at(1e4));
-        expect(retry.attempt).toBe(2);
-      });
-      it("buries a delivery so it is never claimed again", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        const error = { name: "Error", message: "fatal" };
-        expect(await store.bury(delivery, error, at(5))).toBe(true);
-        expect(await claim(["handler-a"], at(LEASE_MS * 10))).toEqual([]);
-        const [record] = await store.listDeliveries({ status: "dead" });
-        expect(record).toMatchObject({ status: "dead", lastError: error });
-        expect(record.updatedAt).toEqual(at(5));
-      });
-      it("requeues only dead deliveries, with a fresh attempt budget", async () => {
-        const event = createEnvelope();
-        await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        const [dead] = await claim(["handler-a"]);
-        await store.bury(dead, { name: "Error", message: "fatal" }, at(1));
-        const [pending] = await store.listDeliveries({ handler: "handler-b" });
-        const moved = await store.requeue(
-          [dead.deliveryId, dead.deliveryId, pending.id, createUuidV7()],
-          at(100)
-        );
-        expect(moved).toBe(1);
-        const [record] = await store.listDeliveries({ handler: "handler-a" });
-        expect(record).toMatchObject({ status: "pending", attempts: 0 });
-        expect(record.availableAt).toEqual(at(100));
-        const [again] = await claim(["handler-a"], at(100));
-        expect(again.attempt).toBe(1);
-      });
+    it("deduplicates repeated events and handlers inside one call", async () => {
+      const event = createEnvelope();
+      const result = await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-a")] },
+        { event, deliveries: [createDelivery("handler-a")] }
+      ]);
+      expect(result.appendedEventIds).toEqual([event.id]);
+      expect(result.duplicateEventIds).toEqual([event.id]);
+      expect(result.appendedDeliveryCount).toBe(1);
+      expect(await store.listDeliveries({})).toHaveLength(1);
     });
-    describe("ordering keys", () => {
-      async function appendKeyed(key, count, handlers = ["handler-a"]) {
-        const events = Array.from({ length: count }, () => createEnvelope({ key }));
-        for (const event of events) {
-          await append([{ event, deliveries: handlers.map((handler) => createDelivery(handler)) }]);
-        }
-        return events;
-      }
-      it("hands out one delivery per handler and key, in publish order", async () => {
-        const [first, second, third] = await appendKeyed("order-1", 3);
-        const batch1 = await claim(["handler-a"]);
-        expect(batch1.map((delivery) => delivery.event.id)).toEqual([first.id]);
-        expect(await claim(["handler-a"])).toEqual([]);
-        await store.complete(batch1[0], at(1));
-        const batch2 = await claim(["handler-a"]);
-        expect(batch2.map((delivery) => delivery.event.id)).toEqual([second.id]);
-        await store.complete(batch2[0], at(2));
-        expect((await claim(["handler-a"])).map((delivery) => delivery.event.id)).toEqual([
-          third.id
-        ]);
-      });
-      it("keeps later events waiting while the head is retrying", async () => {
-        const [first, second] = await appendKeyed("order-1", 2);
-        const [head] = await claim(["handler-a"]);
-        await store.reschedule(head, at(6e4), { name: "Error", message: "retry" }, at(1));
-        expect(await claim(["handler-a"], at(3e4))).toEqual([]);
-        const [retried] = await claim(["handler-a"], at(6e4));
-        expect(retried.event.id).toBe(first.id);
-        await store.complete(retried, at(60001));
-        expect((await claim(["handler-a"], at(60002)))[0].event.id).toBe(second.id);
-      });
-      it("releases the key when the head is dead-lettered", async () => {
-        const [, second] = await appendKeyed("order-1", 2);
-        const [head] = await claim(["handler-a"]);
-        await store.bury(head, { name: "Error", message: "fatal" }, at(1));
-        expect((await claim(["handler-a"]))[0].event.id).toBe(second.id);
-      });
-      it("orders each handler independently", async () => {
-        const [first, second] = await appendKeyed("order-1", 2, ["handler-a", "handler-b"]);
-        const [fromA] = await claim(["handler-a"]);
-        await store.complete(fromA, at(1));
-        const [nextA] = await claim(["handler-a"]);
-        expect(nextA.event.id).toBe(second.id);
-        const [fromB] = await claim(["handler-b"]);
-        expect(fromB.event.id).toBe(first.id);
-      });
-      it("runs different keys and unkeyed events in parallel", async () => {
-        await appendKeyed("order-1", 2);
-        await appendKeyed("order-2", 2);
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        expect(await claim(["handler-a"])).toHaveLength(3);
-      });
-      it("orders concurrent publishers of the same key by commit", async () => {
-        const events = Array.from(
-          { length: 10 },
-          (_, index) => createEnvelope({ key: "shared", payload: { index } })
-        );
-        await Promise.all(
-          events.map((event) => append([{ event, deliveries: [createDelivery("handler-a")] }]))
-        );
-        const seen = [];
-        for (let round = 0; round < 10; round += 1) {
-          const batch = await claim(["handler-a"]);
-          expect(batch).toHaveLength(1);
-          seen.push(batch[0].event.id);
-          await store.complete(batch[0], at(round + 1));
-        }
-        expect(new Set(seen).size).toBe(10);
-      });
+    it("keeps events written by concurrent transactions apart", async () => {
+      const events = Array.from({ length: 20 }, () => createEnvelope());
+      await Promise.all(
+        events.map((event) => append([{ event, deliveries: [createDelivery("handler-a")] }]))
+      );
+      expect(await store.listDeliveries({ limit: 1e3 })).toHaveLength(20);
     });
-    describe("queries", () => {
-      it("filters deliveries and applies the limit in creation order", async () => {
-        const first = createEnvelope({ type: "contract.first.v1" });
-        const second = createEnvelope({ type: "contract.second.v1" });
-        await append([{ event: first, deliveries: [createDelivery("handler-a")] }], at(1));
-        await append(
-          [
-            {
-              event: second,
-              deliveries: [createDelivery("handler-a"), createDelivery("handler-b")]
-            }
-          ],
-          at(2)
-        );
-        expect(await store.listDeliveries({ eventType: "contract.second.v1" })).toHaveLength(2);
-        expect(await store.listDeliveries({ handler: "handler-b" })).toHaveLength(1);
-        expect(
-          await store.listDeliveries({ status: "pending", handler: "handler-a" })
-        ).toHaveLength(2);
-        expect(await store.listDeliveries({ status: "dead" })).toEqual([]);
-        const limited = await store.listDeliveries({ limit: 1 });
-        expect(limited).toHaveLength(1);
-        expect(limited[0].event.id).toBe(first.id);
-        expect(limited[0].createdAt).toEqual(at(1));
-      });
-      it("reports counts and the oldest due delivery", async () => {
-        await append([
-          { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(100))] },
-          { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(200))] },
-          { event: createEnvelope(), deliveries: [createDelivery("handler-b", at(5e4))] },
-          { event: createEnvelope(), deliveries: [createDelivery("handler-c", at(0))] }
-        ]);
-        const [processing] = await claim(["handler-c"], at(0));
-        const [dead] = await claim(["handler-a"], at(100), 1);
-        await store.bury(dead, { name: "Error", message: "x" }, at(101));
-        expect(await store.statistics(at(1e3))).toEqual({
-          pending: 2,
-          processing: 1,
-          completed: 0,
-          dead: 1,
-          oldestDueAt: at(200)
-        });
-        expect((await store.statistics(at(LEASE_MS))).oldestDueAt).toEqual(at(200));
-        await store.complete(processing, at(1));
-        expect(await store.statistics(at(0))).toMatchObject({
-          completed: keepsCompleted ? 1 : 0,
-          processing: 0,
-          oldestDueAt: null
-        });
-      });
-      it("counts an expired lease as due", async () => {
-        await append([
-          { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(LEASE_MS * 5))] }
-        ]);
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-b")] }]);
-        await claim(["handler-b"], at(0));
-        expect((await store.statistics(at(LEASE_MS + 1))).oldestDueAt).toEqual(at(LEASE_MS));
-      });
+  });
+  describe("claim", () => {
+    it("leases due deliveries of the requested handlers and counts the attempt", async () => {
+      const event = createEnvelope();
+      await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      const claimed = await claim(["handler-a"], at(1e3));
+      expect(claimed).toHaveLength(1);
+      expect(claimed[0]).toMatchObject({
+        handler: "handler-a",
+        attempt: 1,
+        leaseExpiresAt: at(1e3 + LEASE_MS)
+      });
+      expect(claimed[0].leaseToken).toEqual(expect.any(String));
+      const [record] = await store.listDeliveries({ handler: "handler-a" });
+      expect(record).toMatchObject({ status: "processing", attempts: 1, leaseOwner: "worker-1" });
+      expect(record.leaseExpiresAt).toEqual(at(1e3 + LEASE_MS));
     });
-    describe("purge", () => {
-      async function appendDoneFailedShared() {
-        const done = createEnvelope();
-        const failed = createEnvelope();
-        const shared = createEnvelope();
-        await append([
-          { event: done, deliveries: [createDelivery("handler-a")] },
-          { event: failed, deliveries: [createDelivery("handler-b")] },
-          { event: shared, deliveries: [createDelivery("handler-c"), createDelivery("handler-d")] }
-        ]);
-        const [doneDelivery] = await claim(["handler-a"]);
-        await store.complete(doneDelivery, at(10));
-        const [failedDelivery] = await claim(["handler-b"]);
-        await store.bury(failedDelivery, { name: "Error", message: "x" }, at(10));
-        const [sharedDelivery] = await claim(["handler-c"]);
-        await store.complete(sharedDelivery, at(10));
-        return { shared };
-      }
-      it.runIf(keepsCompleted)(
-        "deletes old completed and dead deliveries and their orphaned events",
-        async () => {
-          const { shared } = await appendDoneFailedShared();
-          expect(await store.purge({})).toEqual({ deletedDeliveries: 0, deletedEvents: 0 });
-          expect(await store.purge({ completedBefore: at(10) })).toEqual({
-            deletedDeliveries: 0,
-            deletedEvents: 0
-          });
-          expect(await store.purge({ completedBefore: at(11) })).toEqual({
-            deletedDeliveries: 2,
-            deletedEvents: 1
-          });
-          expect(await store.purge({ deadBefore: at(11) })).toEqual({
-            deletedDeliveries: 1,
-            deletedEvents: 1
-          });
-          const remaining = await store.listDeliveries({});
-          expect(remaining.map((record) => record.handler)).toEqual(["handler-d"]);
-          expect(remaining[0].event.id).toBe(shared.id);
+    it("ignores deliveries that are not due yet", async () => {
+      await append([
+        { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(5e3))] }
+      ]);
+      expect(await claim(["handler-a"], at(4999))).toEqual([]);
+      expect(await claim(["handler-a"], at(5e3))).toHaveLength(1);
+    });
+    it("returns nothing for an empty handler list", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      expect(await claim([])).toEqual([]);
+    });
+    it("respects the limit and claims the earliest due first", async () => {
+      const late = createEnvelope();
+      const early = createEnvelope();
+      const middle = createEnvelope();
+      await append([
+        { event: late, deliveries: [createDelivery("handler-a", at(300))] },
+        { event: early, deliveries: [createDelivery("handler-a", at(100))] },
+        { event: middle, deliveries: [createDelivery("handler-a", at(200))] }
+      ]);
+      const first = await claim(["handler-a"], at(1e3), 2);
+      expect(first.map((delivery) => delivery.event.id)).toEqual([early.id, middle.id]);
+      const second = await claim(["handler-a"], at(1e3), 2);
+      expect(second.map((delivery) => delivery.event.id)).toEqual([late.id]);
+    });
+    it("breaks ties between equally due deliveries by delivery id", async () => {
+      const ids = [createUuidV7(), createUuidV7(), createUuidV7()].sort();
+      await append([
+        {
+          event: createEnvelope(),
+          deliveries: [{ id: ids[2], handler: "handler-a", availableAt: at(0) }]
+        },
+        {
+          event: createEnvelope(),
+          deliveries: [{ id: ids[0], handler: "handler-a", availableAt: at(0) }]
+        },
+        {
+          event: createEnvelope(),
+          deliveries: [{ id: ids[1], handler: "handler-a", availableAt: at(0) }]
         }
+      ]);
+      const claimed = await claim(["handler-a"], at(0), 3);
+      expect(claimed.map((delivery) => delivery.deliveryId)).toEqual(ids);
+    });
+    it("does not hand out a leased delivery until its lease expires", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [first] = await claim(["handler-a"], at(0));
+      expect(await claim(["handler-a"], at(LEASE_MS - 1), 100, "worker-2")).toEqual([]);
+      const [second] = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(second).toMatchObject({ deliveryId: first.deliveryId, attempt: 2 });
+      expect(second.leaseToken).not.toBe(first.leaseToken);
+    });
+    it("never gives the same delivery to two concurrent claimers", async () => {
+      const entries = Array.from({ length: 40 }, () => ({
+        event: createEnvelope(),
+        deliveries: [createDelivery("handler-a")]
+      }));
+      await append(entries);
+      const batches = await Promise.all(
+        Array.from({ length: 8 }, async (_, index) => {
+          const own = [];
+          for (; ; ) {
+            const batch = await claim(["handler-a"], at(0), 10, `worker-${index}`);
+            if (batch.length === 0) {
+              return own;
+            }
+            own.push(...batch);
+          }
+        })
       );
-      it.runIf(!keepsCompleted)(
-        "deletes old dead deliveries and the events no delivery references any more",
-        async () => {
-          const { shared } = await appendDoneFailedShared();
-          expect(await store.purge({})).toEqual({ deletedDeliveries: 0, deletedEvents: 0 });
-          expect(await store.purge({ completedBefore: at(0) })).toEqual({
-            deletedDeliveries: 0,
-            deletedEvents: 0
-          });
-          expect(await store.purge({ completedBefore: at(11) })).toEqual({
-            deletedDeliveries: 0,
-            deletedEvents: 1
-          });
-          expect(await store.purge({ deadBefore: at(11) })).toEqual({
-            deletedDeliveries: 1,
-            deletedEvents: 1
-          });
-          const remaining = await store.listDeliveries({});
-          expect(remaining.map((record) => record.handler)).toEqual(["handler-d"]);
-          expect(remaining[0].event.id).toBe(shared.id);
-        }
+      const leftovers = await claim(["handler-a"], at(0), 100, "worker-late");
+      const claimedIds = [...batches.flat(), ...leftovers].map((delivery) => delivery.deliveryId);
+      expect(new Set(claimedIds).size).toBe(claimedIds.length);
+      expect(claimedIds).toHaveLength(40);
+    });
+  });
+}
+function fencingContract(suite) {
+  const { append, claim, keepsCompleted } = suite;
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("fencing", () => {
+    it("completes a delivery only with its current lease", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [stale] = await claim(["handler-a"], at(0));
+      const [current] = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
+      expect(await store.extendLease(stale, at(LEASE_MS * 3), at(LEASE_MS + 1))).toBe(false);
+      expect(
+        await store.reschedule(stale, at(0), { name: "Error", message: "x" }, at(LEASE_MS + 1))
+      ).toBe(false);
+      expect(await store.bury(stale, { name: "Error", message: "x" }, at(LEASE_MS + 1))).toBe(
+        false
       );
-      it("lets a purged event id be appended again", async () => {
-        const event = createEnvelope();
-        await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        await store.complete(delivery, at(1));
-        await store.purge({ completedBefore: at(2) });
-        const result = await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        expect(result.appendedEventIds).toEqual([event.id]);
+      expect(await store.complete(current, at(LEASE_MS + 2))).toBe(true);
+      if (!keepsCompleted) {
+        expect(await store.listDeliveries({})).toEqual([]);
+        return;
+      }
+      const [record] = await store.listDeliveries({});
+      expect(record).toMatchObject({
+        status: "completed",
+        leaseOwner: null,
+        leaseExpiresAt: null
       });
+      expect(record.completedAt).toEqual(at(LEASE_MS + 2));
     });
-    describe("release", () => {
-      it("gives a leased delivery back without counting the attempt", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"], at(0));
-        expect(await store.release(delivery, at(500))).toBe(true);
-        const [record] = await store.listDeliveries({});
-        expect(record).toMatchObject({
-          status: "pending",
-          attempts: 0,
-          leaseOwner: null,
-          leaseExpiresAt: null
-        });
-        expect(record.availableAt).toEqual(at(500));
-        expect(record.updatedAt).toEqual(at(500));
-        expect(await store.release(delivery, at(501))).toBe(false);
-        const [again] = await claim(["handler-a"], at(500));
-        expect(again.attempt).toBe(1);
-      });
+    it("refuses to complete twice", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      expect(await store.complete(delivery, at(1))).toBe(true);
+      expect(await store.complete(delivery, at(2))).toBe(false);
     });
-    describe("transactions in flight", () => {
-      it("hides uncommitted appends from every reader", async () => {
-        const inside = createDeferred();
-        const finish = createDeferred();
-        const event = createEnvelope();
-        const open = store.transaction(async (transaction) => {
-          await store.append(
-            transaction,
-            [{ event, deliveries: [createDelivery("handler-a")] }],
-            at(0)
-          );
-          inside.resolve();
-          await finish.promise;
-        });
-        await inside.promise;
-        expect(await claim(["handler-a"])).toEqual([]);
+    it("refuses leases of unknown deliveries", async () => {
+      const lease = { deliveryId: createUuidV7(), leaseToken: createUuidV7() };
+      expect(await store.complete(lease, at(0))).toBe(false);
+      expect(await store.extendLease(lease, at(1), at(0))).toBe(false);
+    });
+    it("extends a held lease", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      expect(await store.extendLease(delivery, at(LEASE_MS * 2), at(10))).toBe(true);
+      expect(await claim(["handler-a"], at(LEASE_MS + 1), 100, "worker-2")).toEqual([]);
+      const [record] = await store.listDeliveries({});
+      expect(record.leaseExpiresAt).toEqual(at(LEASE_MS * 2));
+    });
+    it("completes inside a transaction together with it", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      await expect(
+        store.transaction(async (transaction) => {
+          expect(await store.complete(delivery, at(1), transaction)).toBe(true);
+          throw new Error("rollback");
+        })
+      ).rejects.toThrow("rollback");
+      expect((await store.listDeliveries({}))[0].status).toBe("processing");
+      await store.transaction(async (transaction) => {
+        expect(await store.complete(delivery, at(2), transaction)).toBe(true);
+      });
+      if (keepsCompleted) {
+        expect((await store.listDeliveries({}))[0].status).toBe("completed");
+      } else {
         expect(await store.listDeliveries({})).toEqual([]);
-        expect((await store.statistics(at(0))).pending).toBe(0);
-        finish.resolve();
-        await open;
-        expect(await claim(["handler-a"])).toHaveLength(1);
-      });
-      it("orders same-key events by commit, not by first write", async () => {
-        const first = createEnvelope({ key: "race" });
-        const second = createEnvelope({ key: "race" });
-        const firstWritten = createDeferred();
-        const releaseFirst = createDeferred();
-        const firstTransaction = store.transaction(async (transaction) => {
-          await store.append(
-            transaction,
-            [{ event: first, deliveries: [createDelivery("handler-a")] }],
-            at(0)
-          );
-          firstWritten.resolve();
-          await releaseFirst.promise;
-        });
-        await firstWritten.promise;
-        const secondTransaction = store.transaction(
-          (transaction) => store.append(
-            transaction,
-            [{ event: second, deliveries: [createDelivery("handler-a")] }],
-            at(0)
-          )
-        );
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        releaseFirst.resolve();
-        await firstTransaction;
-        await secondTransaction;
-        const [head] = await claim(["handler-a"]);
-        expect(head.event.id).toBe(first.id);
-        await store.complete(head, at(1));
-        expect((await claim(["handler-a"]))[0].event.id).toBe(second.id);
-      });
-      it("stores an event id written by two concurrent transactions once", async () => {
-        const event = createEnvelope({ key: "same" });
-        const results = await Promise.all([
-          append([{ event, deliveries: [createDelivery("handler-a")] }]),
-          append([
-            { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-          ])
-        ]);
-        const appended = results.flatMap((result) => result.appendedEventIds);
-        expect(appended).toEqual([event.id]);
-        const records = await store.listDeliveries({});
-        expect(records.map((record) => record.handler).sort()).toEqual(["handler-a", "handler-b"]);
-      });
+      }
     });
-    describe("ordering keys under load", () => {
-      it("does not let a blocked key starve unrelated deliveries", async () => {
-        const blocked = Array.from({ length: 120 }, () => ({
-          event: createEnvelope({ key: "hot" }),
-          deliveries: [createDelivery("handler-a", at(0))]
-        }));
-        await append(blocked);
-        const unrelated = Array.from({ length: 5 }, () => ({
-          event: createEnvelope(),
-          deliveries: [createDelivery("handler-a", at(10))]
-        }));
-        await append(unrelated);
-        const claimed = await claim(["handler-a"], at(100), 10);
-        expect(claimed).toHaveLength(6);
-        expect(claimed.filter((delivery) => delivery.event.key === "hot")).toHaveLength(1);
-      });
-      it("keeps successors blocked behind an expired, delayed or requeued head", async () => {
-        const head = createEnvelope({ key: "k" });
-        const next = createEnvelope({ key: "k" });
-        await append([{ event: head, deliveries: [createDelivery("handler-a")] }]);
-        await append([{ event: next, deliveries: [createDelivery("handler-a")] }]);
-        const [claimedHead] = await claim(["handler-a"], at(0));
-        const reclaimed = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(reclaimed.map((delivery) => delivery.event.id)).toEqual([head.id]);
-        expect(
-          await store.reschedule(
-            reclaimed[0],
-            at(LEASE_MS * 10),
-            { name: "Error", message: "x" },
-            at(LEASE_MS)
-          )
-        ).toBe(true);
-        expect(await claim(["handler-a"], at(LEASE_MS * 5))).toEqual([]);
-        const [delayedHead] = await claim(["handler-a"], at(LEASE_MS * 10));
-        await store.bury(delayedHead, { name: "Error", message: "x" }, at(LEASE_MS * 10));
-        expect(await store.requeue([delayedHead.deliveryId], at(LEASE_MS * 11))).toBe(1);
-        const [requeuedHead] = await claim(["handler-a"], at(LEASE_MS * 11));
-        expect(requeuedHead.event.id).toBe(head.id);
-        expect(await claim(["handler-a"], at(LEASE_MS * 11))).toEqual([]);
-        expect(claimedHead).toBeDefined();
-      });
+    it("refuses a transactional completion with a lost lease", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [stale] = await claim(["handler-a"], at(0));
+      await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      await store.transaction(async (transaction) => {
+        expect(await store.complete(stale, at(LEASE_MS + 1), transaction)).toBe(false);
+      });
+      expect((await store.listDeliveries({}))[0].status).toBe("processing");
     });
-    describe("requeued keyed dead letters", () => {
-      it("never runs a requeued dead letter alongside its running successor", async () => {
-        const first = createEnvelope({ key: "k" });
-        const second = createEnvelope({ key: "k" });
-        await append([{ event: first, deliveries: [createDelivery("handler-a")] }]);
-        await append([{ event: second, deliveries: [createDelivery("handler-a")] }]);
-        const [head] = await claim(["handler-a"], at(0));
-        await store.bury(head, { name: "Error", message: "x" }, at(1));
-        const [successor] = await claim(["handler-a"], at(2));
-        expect(successor.event.id).toBe(second.id);
-        expect(await store.requeue([head.deliveryId], at(3))).toBe(1);
-        expect(await claim(["handler-a"], at(4))).toEqual([]);
-        await store.complete(successor, at(5));
-        const [requeued] = await claim(["handler-a"], at(6));
-        expect(requeued.event.id).toBe(first.id);
-      });
-      it("recovers when the running successor crashes after the requeue", async () => {
-        const first = createEnvelope({ key: "k" });
-        const second = createEnvelope({ key: "k" });
-        await append([{ event: first, deliveries: [createDelivery("handler-a")] }]);
-        await append([{ event: second, deliveries: [createDelivery("handler-a")] }]);
-        const [head] = await claim(["handler-a"], at(0));
-        await store.bury(head, { name: "Error", message: "x" }, at(1));
-        await claim(["handler-a"], at(2));
-        await store.requeue([head.deliveryId], at(3));
-        const recovered = await claim(["handler-a"], at(2 + LEASE_MS));
-        expect(recovered.map((delivery) => delivery.event.id)).toEqual([first.id]);
-        await store.complete(recovered[0], at(3 + LEASE_MS));
-        const [retried] = await claim(["handler-a"], at(4 + LEASE_MS));
-        expect(retried).toMatchObject({ attempt: 2 });
-        expect(retried.event.id).toBe(second.id);
-      });
+  });
+  describe("retries and dead letters", () => {
+    it("reschedules a delivery with its error", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      const error = { name: "TypeError", message: "boom", stack: "TypeError: boom\n    at x" };
+      expect(await store.reschedule(delivery, at(1e4), error, at(5))).toBe(true);
+      const [record] = await store.listDeliveries({});
+      expect(record).toMatchObject({
+        status: "pending",
+        attempts: 1,
+        lastError: error,
+        leaseOwner: null
+      });
+      expect(record.availableAt).toEqual(at(1e4));
+      expect(await claim(["handler-a"], at(9999))).toEqual([]);
+      const [retry] = await claim(["handler-a"], at(1e4));
+      expect(retry.attempt).toBe(2);
     });
-    describe("lease semantics", () => {
-      it("confirms a repeated renewal with identical values", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"], at(0));
-        expect(await store.extendLease(delivery, at(LEASE_MS * 2), at(10))).toBe(true);
-        expect(await store.extendLease(delivery, at(LEASE_MS * 2), at(10))).toBe(true);
-      });
-      it("accepts an expired lease that nobody reclaimed", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"], at(0));
-        expect(await store.extendLease(delivery, at(LEASE_MS * 3), at(LEASE_MS * 2))).toBe(true);
-        expect(await store.complete(delivery, at(LEASE_MS * 2))).toBe(true);
-      });
-      it("rejects every lease operation once the delivery left processing", async () => {
-        const error = { name: "Error", message: "x" };
-        await append([
+    it("buries a delivery so it is never claimed again", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      const error = { name: "Error", message: "fatal" };
+      expect(await store.bury(delivery, error, at(5))).toBe(true);
+      expect(await claim(["handler-a"], at(LEASE_MS * 10))).toEqual([]);
+      const [record] = await store.listDeliveries({ status: "dead" });
+      expect(record).toMatchObject({ status: "dead", lastError: error });
+      expect(record.updatedAt).toEqual(at(5));
+    });
+    it("requeues only dead deliveries, with a fresh attempt budget", async () => {
+      const event = createEnvelope();
+      await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      const [dead] = await claim(["handler-a"]);
+      await store.bury(dead, { name: "Error", message: "fatal" }, at(1));
+      const [pending] = await store.listDeliveries({ handler: "handler-b" });
+      const moved = await store.requeue(
+        [dead.deliveryId, dead.deliveryId, pending.id, createUuidV7()],
+        at(100)
+      );
+      expect(moved).toBe(1);
+      const [record] = await store.listDeliveries({ handler: "handler-a" });
+      expect(record).toMatchObject({ status: "pending", attempts: 0 });
+      expect(record.availableAt).toEqual(at(100));
+      const [again] = await claim(["handler-a"], at(100));
+      expect(again.attempt).toBe(1);
+    });
+  });
+  describe("ordering keys", () => {
+    async function appendKeyed(key, count, handlers = ["handler-a"]) {
+      const events = Array.from({ length: count }, () => createEnvelope({ key }));
+      for (const event of events) {
+        await append([{ event, deliveries: handlers.map((handler) => createDelivery(handler)) }]);
+      }
+      return events;
+    }
+    it("hands out one delivery per handler and key, in publish order", async () => {
+      const [first, second, third] = await appendKeyed("order-1", 3);
+      const batch1 = await claim(["handler-a"]);
+      expect(batch1.map((delivery) => delivery.event.id)).toEqual([first.id]);
+      expect(await claim(["handler-a"])).toEqual([]);
+      await store.complete(batch1[0], at(1));
+      const batch2 = await claim(["handler-a"]);
+      expect(batch2.map((delivery) => delivery.event.id)).toEqual([second.id]);
+      await store.complete(batch2[0], at(2));
+      expect((await claim(["handler-a"])).map((delivery) => delivery.event.id)).toEqual([
+        third.id
+      ]);
+    });
+    it("keeps later events waiting while the head is retrying", async () => {
+      const [first, second] = await appendKeyed("order-1", 2);
+      const [head] = await claim(["handler-a"]);
+      await store.reschedule(head, at(6e4), { name: "Error", message: "retry" }, at(1));
+      expect(await claim(["handler-a"], at(3e4))).toEqual([]);
+      const [retried] = await claim(["handler-a"], at(6e4));
+      expect(retried.event.id).toBe(first.id);
+      await store.complete(retried, at(60001));
+      expect((await claim(["handler-a"], at(60002)))[0].event.id).toBe(second.id);
+    });
+    it("releases the key when the head is dead-lettered", async () => {
+      const [, second] = await appendKeyed("order-1", 2);
+      const [head] = await claim(["handler-a"]);
+      await store.bury(head, { name: "Error", message: "fatal" }, at(1));
+      expect((await claim(["handler-a"]))[0].event.id).toBe(second.id);
+    });
+    it("orders each handler independently", async () => {
+      const [first, second] = await appendKeyed("order-1", 2, ["handler-a", "handler-b"]);
+      const [fromA] = await claim(["handler-a"]);
+      await store.complete(fromA, at(1));
+      const [nextA] = await claim(["handler-a"]);
+      expect(nextA.event.id).toBe(second.id);
+      const [fromB] = await claim(["handler-b"]);
+      expect(fromB.event.id).toBe(first.id);
+    });
+    it("runs different keys and unkeyed events in parallel", async () => {
+      await appendKeyed("order-1", 2);
+      await appendKeyed("order-2", 2);
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      expect(await claim(["handler-a"])).toHaveLength(3);
+    });
+    it("orders concurrent publishers of the same key by commit", async () => {
+      const events = Array.from(
+        { length: 10 },
+        (_, index) => createEnvelope({ key: "shared", payload: { index } })
+      );
+      await Promise.all(
+        events.map((event) => append([{ event, deliveries: [createDelivery("handler-a")] }]))
+      );
+      const seen = [];
+      for (let round = 0; round < 10; round += 1) {
+        const batch = await claim(["handler-a"]);
+        expect(batch).toHaveLength(1);
+        seen.push(batch[0].event.id);
+        await store.complete(batch[0], at(round + 1));
+      }
+      expect(new Set(seen).size).toBe(10);
+    });
+  });
+}
+function maintenanceContract(suite) {
+  const { append, claim, keepsCompleted } = suite;
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("queries", () => {
+    it("filters deliveries and applies the limit in creation order", async () => {
+      const first = createEnvelope({ type: "contract.first.v1" });
+      const second = createEnvelope({ type: "contract.second.v1" });
+      await append([{ event: first, deliveries: [createDelivery("handler-a")] }], at(1));
+      await append(
+        [
           {
-            event: createEnvelope(),
-            deliveries: [createDelivery("a"), createDelivery("b"), createDelivery("c")]
+            event: second,
+            deliveries: [createDelivery("handler-a"), createDelivery("handler-b")]
           }
-        ]);
-        const [completed] = await claim(["a"]);
-        await store.complete(completed, at(1));
-        const [buried] = await claim(["b"]);
-        await store.bury(buried, error, at(1));
-        const [rescheduled] = await claim(["c"]);
-        await store.reschedule(rescheduled, at(100), error, at(1));
-        for (const lease of [completed, buried, rescheduled]) {
-          expect(await store.extendLease(lease, at(LEASE_MS), at(2))).toBe(false);
-          expect(await store.reschedule(lease, at(3), error, at(2))).toBe(false);
-          expect(await store.bury(lease, error, at(2))).toBe(false);
-          expect(await store.release(lease, at(2))).toBe(false);
-          expect(await store.complete(lease, at(2))).toBe(false);
-        }
+        ],
+        at(2)
+      );
+      expect(await store.listDeliveries({ eventType: "contract.second.v1" })).toHaveLength(2);
+      expect(await store.listDeliveries({ handler: "handler-b" })).toHaveLength(1);
+      expect(await store.listDeliveries({ status: "pending", handler: "handler-a" })).toHaveLength(
+        2
+      );
+      expect(await store.listDeliveries({ status: "dead" })).toEqual([]);
+      const limited = await store.listDeliveries({ limit: 1 });
+      expect(limited).toHaveLength(1);
+      expect(limited[0].event.id).toBe(first.id);
+      expect(limited[0].createdAt).toEqual(at(1));
+    });
+    it("reports counts and the oldest due delivery", async () => {
+      await append([
+        { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(100))] },
+        { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(200))] },
+        { event: createEnvelope(), deliveries: [createDelivery("handler-b", at(5e4))] },
+        { event: createEnvelope(), deliveries: [createDelivery("handler-c", at(0))] }
+      ]);
+      const [processing] = await claim(["handler-c"], at(0));
+      const [dead] = await claim(["handler-a"], at(100), 1);
+      await store.bury(dead, { name: "Error", message: "x" }, at(101));
+      expect(await store.statistics(at(1e3))).toEqual({
+        pending: 2,
+        processing: 1,
+        completed: 0,
+        dead: 1,
+        oldestDueAt: at(200)
+      });
+      expect((await store.statistics(at(LEASE_MS))).oldestDueAt).toEqual(at(200));
+      await store.complete(processing, at(1));
+      expect(await store.statistics(at(0))).toMatchObject({
+        completed: keepsCompleted ? 1 : 0,
+        processing: 0,
+        oldestDueAt: null
       });
-      it("rejects made-up leases on pending deliveries and requeues only dead ones", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("a")] }]);
-        const [pending] = await store.listDeliveries({});
-        const fake = { deliveryId: pending.id, leaseToken: createUuidV7() };
-        expect(await store.reschedule(fake, at(1), { name: "Error", message: "x" }, at(1))).toBe(
-          false
-        );
-        expect(await store.bury(fake, { name: "Error", message: "x" }, at(1))).toBe(false);
-        const [processing] = await claim(["a"]);
-        expect(await store.requeue([processing.deliveryId], at(1))).toBe(0);
-        expect(await store.purge({ completedBefore: at(1e9), deadBefore: at(1e9) })).toEqual({
+    });
+    it("counts an expired lease as due", async () => {
+      await append([
+        { event: createEnvelope(), deliveries: [createDelivery("handler-a", at(LEASE_MS * 5))] }
+      ]);
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-b")] }]);
+      await claim(["handler-b"], at(0));
+      expect((await store.statistics(at(LEASE_MS + 1))).oldestDueAt).toEqual(at(LEASE_MS));
+    });
+  });
+  describe("purge", () => {
+    async function appendDoneFailedShared() {
+      const done = createEnvelope();
+      const failed = createEnvelope();
+      const shared = createEnvelope();
+      await append([
+        { event: done, deliveries: [createDelivery("handler-a")] },
+        { event: failed, deliveries: [createDelivery("handler-b")] },
+        { event: shared, deliveries: [createDelivery("handler-c"), createDelivery("handler-d")] }
+      ]);
+      const [doneDelivery] = await claim(["handler-a"]);
+      await store.complete(doneDelivery, at(10));
+      const [failedDelivery] = await claim(["handler-b"]);
+      await store.bury(failedDelivery, { name: "Error", message: "x" }, at(10));
+      const [sharedDelivery] = await claim(["handler-c"]);
+      await store.complete(sharedDelivery, at(10));
+      return { shared };
+    }
+    it.runIf(keepsCompleted)(
+      "deletes old completed and dead deliveries and their orphaned events",
+      async () => {
+        const { shared } = await appendDoneFailedShared();
+        expect(await store.purge({})).toEqual({ deletedDeliveries: 0, deletedEvents: 0 });
+        expect(await store.purge({ completedBefore: at(10) })).toEqual({
           deletedDeliveries: 0,
           deletedEvents: 0
         });
-        expect(await store.listDeliveries({})).toHaveLength(1);
-      });
+        expect(await store.purge({ completedBefore: at(11) })).toEqual({
+          deletedDeliveries: 2,
+          deletedEvents: 1
+        });
+        expect(await store.purge({ deadBefore: at(11) })).toEqual({
+          deletedDeliveries: 1,
+          deletedEvents: 1
+        });
+        const remaining = await store.listDeliveries({});
+        expect(remaining.map((record) => record.handler)).toEqual(["handler-d"]);
+        expect(remaining[0].event.id).toBe(shared.id);
+      }
+    );
+    it.runIf(!keepsCompleted)(
+      "deletes old dead deliveries and the events no delivery references any more",
+      async () => {
+        const { shared } = await appendDoneFailedShared();
+        expect(await store.purge({})).toEqual({ deletedDeliveries: 0, deletedEvents: 0 });
+        expect(await store.purge({ completedBefore: at(0) })).toEqual({
+          deletedDeliveries: 0,
+          deletedEvents: 0
+        });
+        expect(await store.purge({ completedBefore: at(11) })).toEqual({
+          deletedDeliveries: 0,
+          deletedEvents: 1
+        });
+        expect(await store.purge({ deadBefore: at(11) })).toEqual({
+          deletedDeliveries: 1,
+          deletedEvents: 1
+        });
+        const remaining = await store.listDeliveries({});
+        expect(remaining.map((record) => record.handler)).toEqual(["handler-d"]);
+        expect(remaining[0].event.id).toBe(shared.id);
+      }
+    );
+    it("lets a purged event id be appended again", async () => {
+      const event = createEnvelope();
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      await store.complete(delivery, at(1));
+      await store.purge({ completedBefore: at(2) });
+      const result = await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      expect(result.appendedEventIds).toEqual([event.id]);
     });
-    describe("data fidelity", () => {
-      it.each([null, 0, 42.5, "text", [1, { two: 2 }], { deep: { list: [] } }, true])(
-        "round-trips the payload %j",
-        async (payload) => {
-          const event = createEnvelope({ payload });
-          await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-          const [claimed] = await claim(["handler-a"]);
-          expect(claimed.event.payload).toEqual(payload);
+  });
+  describe("release", () => {
+    it("gives a leased delivery back without counting the attempt", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"], at(0));
+      expect(await store.release(delivery, at(500))).toBe(true);
+      const [record] = await store.listDeliveries({});
+      expect(record).toMatchObject({
+        status: "pending",
+        attempts: 0,
+        leaseOwner: null,
+        leaseExpiresAt: null
+      });
+      expect(record.availableAt).toEqual(at(500));
+      expect(record.updatedAt).toEqual(at(500));
+      expect(await store.release(delivery, at(501))).toBe(false);
+      const [again] = await claim(["handler-a"], at(500));
+      expect(again.attempt).toBe(1);
+    });
+  });
+  describe("transactions in flight", () => {
+    it("hides uncommitted appends from every reader", async () => {
+      const inside = createDeferred();
+      const finish = createDeferred();
+      const event = createEnvelope();
+      const open = store.transaction(async (transaction) => {
+        await store.append(
+          transaction,
+          [{ event, deliveries: [createDelivery("handler-a")] }],
+          at(0)
+        );
+        inside.resolve();
+        await finish.promise;
+      });
+      await inside.promise;
+      expect(await claim(["handler-a"])).toEqual([]);
+      expect(await store.listDeliveries({})).toEqual([]);
+      expect((await store.statistics(at(0))).pending).toBe(0);
+      finish.resolve();
+      await open;
+      expect(await claim(["handler-a"])).toHaveLength(1);
+    });
+    it("orders same-key events by commit, not by first write", async () => {
+      const first = createEnvelope({ key: "race" });
+      const second = createEnvelope({ key: "race" });
+      const firstWritten = createDeferred();
+      const releaseFirst = createDeferred();
+      const firstTransaction = store.transaction(async (transaction) => {
+        await store.append(
+          transaction,
+          [{ event: first, deliveries: [createDelivery("handler-a")] }],
+          at(0)
+        );
+        firstWritten.resolve();
+        await releaseFirst.promise;
+      });
+      await firstWritten.promise;
+      const secondTransaction = store.transaction(
+        (transaction) => store.append(
+          transaction,
+          [{ event: second, deliveries: [createDelivery("handler-a")] }],
+          at(0)
+        )
+      );
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      releaseFirst.resolve();
+      await firstTransaction;
+      await secondTransaction;
+      const [head] = await claim(["handler-a"]);
+      expect(head.event.id).toBe(first.id);
+      await store.complete(head, at(1));
+      expect((await claim(["handler-a"]))[0].event.id).toBe(second.id);
+    });
+    it("stores an event id written by two concurrent transactions once", async () => {
+      const event = createEnvelope({ key: "same" });
+      const results = await Promise.all([
+        append([{ event, deliveries: [createDelivery("handler-a")] }]),
+        append([{ event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }])
+      ]);
+      const appended = results.flatMap((result) => result.appendedEventIds);
+      expect(appended).toEqual([event.id]);
+      const records = await store.listDeliveries({});
+      expect(records.map((record) => record.handler).sort()).toEqual(["handler-a", "handler-b"]);
+    });
+  });
+}
+function orderingAndLeasesContract(suite) {
+  const { append, claim } = suite;
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("ordering keys under load", () => {
+    it("does not let a blocked key starve unrelated deliveries", async () => {
+      const blocked = Array.from({ length: 120 }, () => ({
+        event: createEnvelope({ key: "hot" }),
+        deliveries: [createDelivery("handler-a", at(0))]
+      }));
+      await append(blocked);
+      const unrelated = Array.from({ length: 5 }, () => ({
+        event: createEnvelope(),
+        deliveries: [createDelivery("handler-a", at(10))]
+      }));
+      await append(unrelated);
+      const claimed = await claim(["handler-a"], at(100), 10);
+      expect(claimed).toHaveLength(6);
+      expect(claimed.filter((delivery) => delivery.event.key === "hot")).toHaveLength(1);
+    });
+    it("keeps successors blocked behind an expired, delayed or requeued head", async () => {
+      const head = createEnvelope({ key: "k" });
+      const next = createEnvelope({ key: "k" });
+      await append([{ event: head, deliveries: [createDelivery("handler-a")] }]);
+      await append([{ event: next, deliveries: [createDelivery("handler-a")] }]);
+      const [claimedHead] = await claim(["handler-a"], at(0));
+      const reclaimed = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(reclaimed.map((delivery) => delivery.event.id)).toEqual([head.id]);
+      expect(
+        await store.reschedule(
+          reclaimed[0],
+          at(LEASE_MS * 10),
+          { name: "Error", message: "x" },
+          at(LEASE_MS)
+        )
+      ).toBe(true);
+      expect(await claim(["handler-a"], at(LEASE_MS * 5))).toEqual([]);
+      const [delayedHead] = await claim(["handler-a"], at(LEASE_MS * 10));
+      await store.bury(delayedHead, { name: "Error", message: "x" }, at(LEASE_MS * 10));
+      expect(await store.requeue([delayedHead.deliveryId], at(LEASE_MS * 11))).toBe(1);
+      const [requeuedHead] = await claim(["handler-a"], at(LEASE_MS * 11));
+      expect(requeuedHead.event.id).toBe(head.id);
+      expect(await claim(["handler-a"], at(LEASE_MS * 11))).toEqual([]);
+      expect(claimedHead).toBeDefined();
+    });
+  });
+  describe("requeued keyed dead letters", () => {
+    it("never runs a requeued dead letter alongside its running successor", async () => {
+      const first = createEnvelope({ key: "k" });
+      const second = createEnvelope({ key: "k" });
+      await append([{ event: first, deliveries: [createDelivery("handler-a")] }]);
+      await append([{ event: second, deliveries: [createDelivery("handler-a")] }]);
+      const [head] = await claim(["handler-a"], at(0));
+      await store.bury(head, { name: "Error", message: "x" }, at(1));
+      const [successor] = await claim(["handler-a"], at(2));
+      expect(successor.event.id).toBe(second.id);
+      expect(await store.requeue([head.deliveryId], at(3))).toBe(1);
+      expect(await claim(["handler-a"], at(4))).toEqual([]);
+      await store.complete(successor, at(5));
+      const [requeued] = await claim(["handler-a"], at(6));
+      expect(requeued.event.id).toBe(first.id);
+    });
+    it("recovers when the running successor crashes after the requeue", async () => {
+      const first = createEnvelope({ key: "k" });
+      const second = createEnvelope({ key: "k" });
+      await append([{ event: first, deliveries: [createDelivery("handler-a")] }]);
+      await append([{ event: second, deliveries: [createDelivery("handler-a")] }]);
+      const [head] = await claim(["handler-a"], at(0));
+      await store.bury(head, { name: "Error", message: "x" }, at(1));
+      await claim(["handler-a"], at(2));
+      await store.requeue([head.deliveryId], at(3));
+      const recovered = await claim(["handler-a"], at(2 + LEASE_MS));
+      expect(recovered.map((delivery) => delivery.event.id)).toEqual([first.id]);
+      await store.complete(recovered[0], at(3 + LEASE_MS));
+      const [retried] = await claim(["handler-a"], at(4 + LEASE_MS));
+      expect(retried).toMatchObject({ attempt: 2 });
+      expect(retried.event.id).toBe(second.id);
+    });
+  });
+  describe("lease semantics", () => {
+    it("confirms a repeated renewal with identical values", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"], at(0));
+      expect(await store.extendLease(delivery, at(LEASE_MS * 2), at(10))).toBe(true);
+      expect(await store.extendLease(delivery, at(LEASE_MS * 2), at(10))).toBe(true);
+    });
+    it("accepts an expired lease that nobody reclaimed", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"], at(0));
+      expect(await store.extendLease(delivery, at(LEASE_MS * 3), at(LEASE_MS * 2))).toBe(true);
+      expect(await store.complete(delivery, at(LEASE_MS * 2))).toBe(true);
+    });
+    it("rejects every lease operation once the delivery left processing", async () => {
+      const error = { name: "Error", message: "x" };
+      await append([
+        {
+          event: createEnvelope(),
+          deliveries: [createDelivery("a"), createDelivery("b"), createDelivery("c")]
         }
+      ]);
+      const [completed] = await claim(["a"]);
+      await store.complete(completed, at(1));
+      const [buried] = await claim(["b"]);
+      await store.bury(buried, error, at(1));
+      const [rescheduled] = await claim(["c"]);
+      await store.reschedule(rescheduled, at(100), error, at(1));
+      for (const lease of [completed, buried, rescheduled]) {
+        expect(await store.extendLease(lease, at(LEASE_MS), at(2))).toBe(false);
+        expect(await store.reschedule(lease, at(3), error, at(2))).toBe(false);
+        expect(await store.bury(lease, error, at(2))).toBe(false);
+        expect(await store.release(lease, at(2))).toBe(false);
+        expect(await store.complete(lease, at(2))).toBe(false);
+      }
+    });
+    it("rejects made-up leases on pending deliveries and requeues only dead ones", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("a")] }]);
+      const [pending] = await store.listDeliveries({});
+      const fake = { deliveryId: pending.id, leaseToken: createUuidV7() };
+      expect(await store.reschedule(fake, at(1), { name: "Error", message: "x" }, at(1))).toBe(
+        false
       );
-      it("accepts long identifiers and non-UUID event ids", async () => {
-        const handler = "h".repeat(255);
-        const event = createEnvelope({
-          id: `order-42:placed:${"x".repeat(200)}`,
-          key: "k".repeat(255),
-          type: "t".repeat(255)
-        });
-        await append([{ event, deliveries: [createDelivery(handler)] }]);
-        const [claimed] = await claim([handler]);
-        expect(claimed.event).toEqual(event);
-        expect(claimed.handler).toBe(handler);
-      });
-      it("lists at most 100 deliveries by default", async () => {
-        await append(
-          Array.from({ length: 101 }, () => ({
-            event: createEnvelope(),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        expect(await store.listDeliveries({})).toHaveLength(100);
-      });
-      it("hands out copies that callers cannot use to change stored data", async () => {
-        const event = createEnvelope({ payload: { amount: 1 }, headers: { a: "1" } });
+      expect(await store.bury(fake, { name: "Error", message: "x" }, at(1))).toBe(false);
+      const [processing] = await claim(["a"]);
+      expect(await store.requeue([processing.deliveryId], at(1))).toBe(0);
+      expect(await store.purge({ completedBefore: at(1e9), deadBefore: at(1e9) })).toEqual({
+        deletedDeliveries: 0,
+        deletedEvents: 0
+      });
+      expect(await store.listDeliveries({})).toHaveLength(1);
+    });
+  });
+  describe("data fidelity", () => {
+    it.each([null, 0, 42.5, "text", [1, { two: 2 }], { deep: { list: [] } }, true])(
+      "round-trips the payload %j",
+      async (payload) => {
+        const event = createEnvelope({ payload });
         await append([{ event, deliveries: [createDelivery("handler-a")] }]);
         const [claimed] = await claim(["handler-a"]);
-        claimed.event.payload.amount = 999;
-        claimed.event.headers["a"] = "changed";
-        const [listed] = await store.listDeliveries({});
-        expect(listed.event.payload).toEqual({ amount: 1 });
-        expect(listed.event.headers).toEqual({ a: "1" });
-      });
+        expect(claimed.event.payload).toEqual(payload);
+      }
+    );
+    it("accepts long identifiers and non-UUID event ids", async () => {
+      const handler = "h".repeat(255);
+      const event = createEnvelope({
+        id: `order-42:placed:${"x".repeat(200)}`,
+        key: "k".repeat(255),
+        type: "t".repeat(255)
+      });
+      await append([{ event, deliveries: [createDelivery(handler)] }]);
+      const [claimed] = await claim([handler]);
+      expect(claimed.event).toEqual(event);
+      expect(claimed.handler).toBe(handler);
     });
-    describe("completion", () => {
-      it("removes a completed delivery from every listing", async () => {
-        const event = createEnvelope();
-        await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        const [delivery] = await claim(["handler-a"]);
-        expect(await store.complete(delivery, at(5))).toBe(true);
-        const records = await store.listDeliveries({ eventId: event.id });
-        if (keepsCompleted) {
-          expect(records.map((record) => [record.handler, record.status]).sort()).toEqual([
-            ["handler-a", "completed"],
-            ["handler-b", "pending"]
-          ]);
-          const [completed] = await store.listDeliveries({ status: "completed" });
-          expect(completed).toMatchObject({ handler: "handler-a", attempts: 1 });
-          expect(completed.completedAt).toEqual(at(5));
-        } else {
-          expect(records.map((record) => [record.handler, record.status])).toEqual([
-            ["handler-b", "pending"]
-          ]);
-          expect(await store.listDeliveries({ status: "completed" })).toEqual([]);
-        }
-        expect(await claim(["handler-a"], at(LEASE_MS * 10))).toEqual([]);
-        expect(await store.statistics(at(0))).toMatchObject({
-          pending: 1,
-          processing: 0,
-          completed: keepsCompleted ? 1 : 0
-        });
-      });
-      it("does not create the delivery of a handler that already completed again", async () => {
-        const event = createEnvelope();
-        await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        await store.complete(delivery, at(1));
-        const result = await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        expect(result).toEqual({
-          appendedEventIds: [],
-          duplicateEventIds: [event.id],
-          appendedDeliveryCount: 1
-        });
-        expect(await claim(["handler-a"], at(LEASE_MS * 10))).toEqual([]);
-        expect(await claim(["handler-b"], at(LEASE_MS * 10))).toHaveLength(1);
-        const again = await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        expect(again.appendedDeliveryCount).toBe(0);
-      });
-      it("completes many leases at once and reports each one", async () => {
-        await append(
-          Array.from({ length: 5 }, () => ({
-            event: createEnvelope(),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        const claimed = await claim(["handler-a"]);
-        expect(claimed).toHaveLength(5);
-        expect(await completeMany(store, [], at(1))).toEqual([]);
-        expect(await completeMany(store, claimed.slice(0, 3), at(1))).toEqual([true, true, true]);
-        expect(await store.statistics(at(2))).toMatchObject({ processing: 2, pending: 0 });
-        expect(await completeMany(store, claimed, at(2))).toEqual([
-          false,
-          false,
-          false,
-          true,
-          true
+    it("lists at most 100 deliveries by default", async () => {
+      await append(
+        Array.from({ length: 101 }, () => ({
+          event: createEnvelope(),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      expect(await store.listDeliveries({})).toHaveLength(100);
+    });
+    it("hands out copies that callers cannot use to change stored data", async () => {
+      const event = createEnvelope({ payload: { amount: 1 }, headers: { a: "1" } });
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [claimed] = await claim(["handler-a"]);
+      claimed.event.payload.amount = 999;
+      claimed.event.headers["a"] = "changed";
+      const [listed] = await store.listDeliveries({});
+      expect(listed.event.payload).toEqual({ amount: 1 });
+      expect(listed.event.headers).toEqual({ a: "1" });
+    });
+  });
+}
+function completionContract(suite) {
+  const { append, claim, completeMany, keepsCompleted } = suite;
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("completion", () => {
+    it("removes a completed delivery from every listing", async () => {
+      const event = createEnvelope();
+      await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      const [delivery] = await claim(["handler-a"]);
+      expect(await store.complete(delivery, at(5))).toBe(true);
+      const records = await store.listDeliveries({ eventId: event.id });
+      if (keepsCompleted) {
+        expect(records.map((record) => [record.handler, record.status]).sort()).toEqual([
+          ["handler-a", "completed"],
+          ["handler-b", "pending"]
         ]);
-        expect(await store.statistics(at(3))).toMatchObject({ processing: 0, pending: 0 });
-      });
-      it("completes a lease listed twice only once", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        expect(await completeMany(store, [delivery, delivery], at(1))).toEqual([true, false]);
-      });
-      it("fences every lease of a batch on its own", async () => {
-        await append(
-          Array.from({ length: 3 }, () => ({
-            event: createEnvelope(),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        const stale = await claim(["handler-a"], at(0));
-        const current = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(current).toHaveLength(3);
-        await append(
-          [{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }],
-          at(1)
-        );
-        const [fresh] = await claim(["handler-a"], at(LEASE_MS + 1), 100, "worker-2");
-        expect(
-          await completeMany(store, [stale[0], fresh, stale[1], current[2]], at(LEASE_MS + 2))
-        ).toEqual([false, true, false, true]);
-        expect(await store.statistics(at(LEASE_MS + 3))).toMatchObject({ processing: 2 });
-      });
-      it("does not complete a lease of a delivery that went back to pending", async () => {
-        const error = { name: "Error", message: "x" };
-        await append([
-          { event: createEnvelope(), deliveries: [createDelivery("a"), createDelivery("b")] }
+        const [completed] = await store.listDeliveries({ status: "completed" });
+        expect(completed).toMatchObject({ handler: "handler-a", attempts: 1 });
+        expect(completed.completedAt).toEqual(at(5));
+      } else {
+        expect(records.map((record) => [record.handler, record.status])).toEqual([
+          ["handler-b", "pending"]
         ]);
-        const [retrying] = await claim(["a"]);
-        const [released] = await claim(["b"]);
-        await store.reschedule(retrying, at(1e3), error, at(1));
-        await store.release(released, at(1));
-        expect(await completeMany(store, [retrying, released], at(2))).toEqual([false, false]);
-        expect(await store.statistics(at(2))).toMatchObject({ pending: 2, processing: 0 });
+        expect(await store.listDeliveries({ status: "completed" })).toEqual([]);
+      }
+      expect(await claim(["handler-a"], at(LEASE_MS * 10))).toEqual([]);
+      expect(await store.statistics(at(0))).toMatchObject({
+        pending: 1,
+        processing: 0,
+        completed: keepsCompleted ? 1 : 0
       });
     });
-    describe("stale leases of one delivery", () => {
+    it("does not create the delivery of a handler that already completed again", async () => {
+      const event = createEnvelope();
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      await store.complete(delivery, at(1));
+      const result = await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      expect(result).toEqual({
+        appendedEventIds: [],
+        duplicateEventIds: [event.id],
+        appendedDeliveryCount: 1
+      });
+      expect(await claim(["handler-a"], at(LEASE_MS * 10))).toEqual([]);
+      expect(await claim(["handler-b"], at(LEASE_MS * 10))).toHaveLength(1);
+      const again = await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      expect(again.appendedDeliveryCount).toBe(0);
+    });
+    it("completes many leases at once and reports each one", async () => {
+      await append(
+        Array.from({ length: 5 }, () => ({
+          event: createEnvelope(),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      const claimed = await claim(["handler-a"]);
+      expect(claimed).toHaveLength(5);
+      expect(await completeMany(store, [], at(1))).toEqual([]);
+      expect(await completeMany(store, claimed.slice(0, 3), at(1))).toEqual([true, true, true]);
+      expect(await store.statistics(at(2))).toMatchObject({ processing: 2, pending: 0 });
+      expect(await completeMany(store, claimed, at(2))).toEqual([false, false, false, true, true]);
+      expect(await store.statistics(at(3))).toMatchObject({ processing: 0, pending: 0 });
+    });
+    it("completes a lease listed twice only once", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      expect(await completeMany(store, [delivery, delivery], at(1))).toEqual([true, false]);
+    });
+    it("fences every lease of a batch on its own", async () => {
+      await append(
+        Array.from({ length: 3 }, () => ({
+          event: createEnvelope(),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      const stale = await claim(["handler-a"], at(0));
+      const current = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(current).toHaveLength(3);
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }], at(1));
+      const [fresh] = await claim(["handler-a"], at(LEASE_MS + 1), 100, "worker-2");
+      expect(
+        await completeMany(store, [stale[0], fresh, stale[1], current[2]], at(LEASE_MS + 2))
+      ).toEqual([false, true, false, true]);
+      expect(await store.statistics(at(LEASE_MS + 3))).toMatchObject({ processing: 2 });
+    });
+    it("does not complete a lease of a delivery that went back to pending", async () => {
       const error = { name: "Error", message: "x" };
-      it("refuses the lease of an attempt that was released when the same owner claims it again", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
-        expect(await store.release(stale, at(1))).toBe(true);
-        const [current] = await claim(["handler-a"], at(2), 100, "worker-1");
-        expect(current.deliveryId).toBe(stale.deliveryId);
-        expect(current.leaseToken).not.toBe(stale.leaseToken);
-        expect(await store.complete(stale, at(3))).toBe(false);
-        expect(await store.bury(stale, error, at(3))).toBe(false);
-        expect(await store.reschedule(stale, at(9), error, at(3))).toBe(false);
-        expect(await store.release(stale, at(3))).toBe(false);
-        expect(await store.extendLease(stale, at(LEASE_MS * 3), at(3))).toBe(false);
-        expect(await store.complete(current, at(4))).toBe(true);
-      });
-      it("refuses the lease of an attempt that was rescheduled when the same owner claims it again", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
-        expect(await store.reschedule(stale, at(10), error, at(1))).toBe(true);
-        const [current] = await claim(["handler-a"], at(10), 100, "worker-1");
-        expect(current).toMatchObject({ deliveryId: stale.deliveryId, attempt: 2 });
-        expect(await store.complete(stale, at(11))).toBe(false);
-        expect(await store.bury(stale, error, at(11))).toBe(false);
-        expect(await completeMany(store, [stale], at(11))).toEqual([false]);
-        expect(await store.complete(current, at(12))).toBe(true);
-      });
-      it("matches the results of completeMany to the lease, not to the delivery id", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
-        await store.release(stale, at(1));
-        const [current] = await claim(["handler-a"], at(2), 100, "worker-1");
-        expect(await completeMany(store, [stale, current], at(3))).toEqual([false, true]);
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-b")] }]);
-        const [staleB] = await claim(["handler-b"], at(4), 100, "worker-1");
-        await store.release(staleB, at(5));
-        const [currentB] = await claim(["handler-b"], at(6), 100, "worker-1");
-        expect(await completeMany(store, [currentB, staleB], at(7))).toEqual([true, false]);
+      await append([
+        { event: createEnvelope(), deliveries: [createDelivery("a"), createDelivery("b")] }
+      ]);
+      const [retrying] = await claim(["a"]);
+      const [released] = await claim(["b"]);
+      await store.reschedule(retrying, at(1e3), error, at(1));
+      await store.release(released, at(1));
+      expect(await completeMany(store, [retrying, released], at(2))).toEqual([false, false]);
+      expect(await store.statistics(at(2))).toMatchObject({ pending: 2, processing: 0 });
+    });
+  });
+  describe("stale leases of one delivery", () => {
+    const error = { name: "Error", message: "x" };
+    it("refuses the lease of an attempt that was released when the same owner claims it again", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
+      expect(await store.release(stale, at(1))).toBe(true);
+      const [current] = await claim(["handler-a"], at(2), 100, "worker-1");
+      expect(current.deliveryId).toBe(stale.deliveryId);
+      expect(current.leaseToken).not.toBe(stale.leaseToken);
+      expect(await store.complete(stale, at(3))).toBe(false);
+      expect(await store.bury(stale, error, at(3))).toBe(false);
+      expect(await store.reschedule(stale, at(9), error, at(3))).toBe(false);
+      expect(await store.release(stale, at(3))).toBe(false);
+      expect(await store.extendLease(stale, at(LEASE_MS * 3), at(3))).toBe(false);
+      expect(await store.complete(current, at(4))).toBe(true);
+    });
+    it("refuses the lease of an attempt that was rescheduled when the same owner claims it again", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
+      expect(await store.reschedule(stale, at(10), error, at(1))).toBe(true);
+      const [current] = await claim(["handler-a"], at(10), 100, "worker-1");
+      expect(current).toMatchObject({ deliveryId: stale.deliveryId, attempt: 2 });
+      expect(await store.complete(stale, at(11))).toBe(false);
+      expect(await store.bury(stale, error, at(11))).toBe(false);
+      expect(await completeMany(store, [stale], at(11))).toEqual([false]);
+      expect(await store.complete(current, at(12))).toBe(true);
+    });
+    it("matches the results of completeMany to the lease, not to the delivery id", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
+      await store.release(stale, at(1));
+      const [current] = await claim(["handler-a"], at(2), 100, "worker-1");
+      expect(await completeMany(store, [stale, current], at(3))).toEqual([false, true]);
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-b")] }]);
+      const [staleB] = await claim(["handler-b"], at(4), 100, "worker-1");
+      await store.release(staleB, at(5));
+      const [currentB] = await claim(["handler-b"], at(6), 100, "worker-1");
+      expect(await completeMany(store, [currentB, staleB], at(7))).toEqual([true, false]);
+    });
+  });
+  describe("retention of the deduplication record", () => {
+    const DAY = 864e5;
+    it("keeps an event for the retention window after its last delivery completed, however old it is", async () => {
+      const event = createEnvelope();
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"], at(30 * DAY));
+      expect(await store.complete(delivery, at(30 * DAY + 1))).toBe(true);
+      expect(await store.purge({ completedBefore: at(29 * DAY) })).toMatchObject({
+        deletedEvents: 0
+      });
+      const again = await append(
+        [{ event, deliveries: [createDelivery("handler-a")] }],
+        at(30 * DAY + 2)
+      );
+      expect(again.appendedDeliveryCount).toBe(0);
+      expect(await store.purge({ completedBefore: at(31 * DAY) })).toMatchObject({
+        deletedEvents: 1
       });
+      const afterwards = await append(
+        [{ event, deliveries: [createDelivery("handler-a")] }],
+        at(31 * DAY)
+      );
+      expect(afterwards.appendedEventIds).toEqual([event.id]);
     });
-    describe("retention of the deduplication record", () => {
-      const DAY = 864e5;
-      it("keeps an event for the retention window after its last delivery completed, however old it is", async () => {
-        const event = createEnvelope();
-        await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"], at(30 * DAY));
-        expect(await store.complete(delivery, at(30 * DAY + 1))).toBe(true);
-        expect(await store.purge({ completedBefore: at(29 * DAY) })).toMatchObject({
-          deletedEvents: 0
-        });
-        const again = await append(
-          [{ event, deliveries: [createDelivery("handler-a")] }],
-          at(30 * DAY + 2)
-        );
-        expect(again.appendedDeliveryCount).toBe(0);
-        expect(await store.purge({ completedBefore: at(31 * DAY) })).toMatchObject({
-          deletedEvents: 1
-        });
-        const afterwards = await append(
+    it("keeps the later completion time of an event when completions are recorded out of order", async () => {
+      const event = createEnvelope();
+      await append([
+        { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
+      ]);
+      const claimed = await claim(["handler-a", "handler-b"]);
+      expect(claimed).toHaveLength(2);
+      const [first, second] = claimed.sort(
+        (left, right) => left.handler.localeCompare(right.handler)
+      );
+      expect(await store.complete(first, at(200))).toBe(true);
+      expect(await store.complete(second, at(100))).toBe(true);
+      expect(await store.purge({ completedBefore: at(150) })).toMatchObject({ deletedEvents: 0 });
+      const again = await append(
+        [{ event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }],
+        at(201)
+      );
+      expect(again.appendedDeliveryCount).toBe(0);
+    });
+    it("remembers every handler of an event appended twice in one transaction", async () => {
+      const event = createEnvelope();
+      const result = await store.transaction(async (transaction) => {
+        await store.append(
+          transaction,
           [{ event, deliveries: [createDelivery("handler-a")] }],
-          at(31 * DAY)
+          at(0)
         );
-        expect(afterwards.appendedEventIds).toEqual([event.id]);
-      });
-      it("keeps the later completion time of an event when completions are recorded out of order", async () => {
-        const event = createEnvelope();
-        await append([
-          { event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }
-        ]);
-        const claimed = await claim(["handler-a", "handler-b"]);
-        expect(claimed).toHaveLength(2);
-        const [first, second] = claimed.sort(
-          (left, right) => left.handler.localeCompare(right.handler)
+        return store.append(
+          transaction,
+          [{ event, deliveries: [createDelivery("handler-b")] }],
+          at(0)
         );
-        expect(await store.complete(first, at(200))).toBe(true);
-        expect(await store.complete(second, at(100))).toBe(true);
-        expect(await store.purge({ completedBefore: at(150) })).toMatchObject({ deletedEvents: 0 });
-        const again = await append(
-          [{ event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }],
-          at(201)
-        );
-        expect(again.appendedDeliveryCount).toBe(0);
-      });
-      it("remembers every handler of an event appended twice in one transaction", async () => {
-        const event = createEnvelope();
-        const result = await store.transaction(async (transaction) => {
-          await store.append(
-            transaction,
-            [{ event, deliveries: [createDelivery("handler-a")] }],
-            at(0)
-          );
-          return store.append(
-            transaction,
-            [{ event, deliveries: [createDelivery("handler-b")] }],
-            at(0)
-          );
-        });
-        expect(result).toMatchObject({ duplicateEventIds: [event.id], appendedDeliveryCount: 1 });
-        const claimed = await claim(["handler-a", "handler-b"]);
-        expect(claimed).toHaveLength(2);
-        for (const delivery of claimed) {
-          expect(await store.complete(delivery, at(1))).toBe(true);
-        }
-        const again = await append(
-          [{ event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }],
-          at(2)
-        );
-        expect(again).toMatchObject({ duplicateEventIds: [event.id], appendedDeliveryCount: 0 });
-      });
-      it("does not let the dead-letter cutoff remove events whose deliveries completed", async () => {
-        const event = createEnvelope();
-        await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"]);
-        await store.complete(delivery, at(1));
-        expect(await store.purge({ deadBefore: at(100 * DAY) })).toMatchObject({
-          deletedEvents: 0
-        });
-        const again = await append([{ event, deliveries: [createDelivery("handler-a")] }], at(2));
-        expect(again.appendedDeliveryCount).toBe(0);
       });
+      expect(result).toMatchObject({ duplicateEventIds: [event.id], appendedDeliveryCount: 1 });
+      const claimed = await claim(["handler-a", "handler-b"]);
+      expect(claimed).toHaveLength(2);
+      for (const delivery of claimed) {
+        expect(await store.complete(delivery, at(1))).toBe(true);
+      }
+      const again = await append(
+        [{ event, deliveries: [createDelivery("handler-a"), createDelivery("handler-b")] }],
+        at(2)
+      );
+      expect(again).toMatchObject({ duplicateEventIds: [event.id], appendedDeliveryCount: 0 });
     });
-    describe("lost leases", () => {
-      it("hands a delivery of a crashed worker to the next claimer with the attempt counted", async () => {
-        await append(
-          Array.from({ length: 4 }, () => ({
-            event: createEnvelope(),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        const first = await claim(["handler-a"], at(0), 100, "worker-1");
-        expect(first.map((delivery) => delivery.attempt)).toEqual([1, 1, 1, 1]);
-        expect(await claim(["handler-a"], at(LEASE_MS - 1), 100, "worker-2")).toEqual([]);
-        const second = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(second.map((delivery) => delivery.deliveryId).sort()).toEqual(
-          first.map((delivery) => delivery.deliveryId).sort()
-        );
-        expect(second.map((delivery) => delivery.attempt)).toEqual([2, 2, 2, 2]);
-        for (const stale of first) {
-          expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
-        }
-        expect(await completeMany(store, first, at(LEASE_MS + 1))).toEqual([
-          false,
-          false,
-          false,
-          false
-        ]);
-        expect(await completeMany(store, second, at(LEASE_MS + 2))).toEqual([
-          true,
-          true,
-          true,
-          true
-        ]);
-      });
-      it("keeps counting attempts of a poison delivery until it is dead-lettered", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        for (let crash = 0; crash < 4; crash += 1) {
-          const [delivery] = await claim(
-            ["handler-a"],
-            at(crash * LEASE_MS),
-            100,
-            `worker-${crash}`
-          );
-          expect(delivery.attempt).toBe(crash + 1);
-        }
-        const [last] = await claim(["handler-a"], at(4 * LEASE_MS), 100, "worker-4");
-        expect(last.attempt).toBe(5);
-        expect(
-          await store.bury(last, { name: "Error", message: "poison" }, at(4 * LEASE_MS))
-        ).toBe(true);
-        const [dead] = await store.listDeliveries({ status: "dead" });
-        expect(dead).toMatchObject({ attempts: 5, lastError: { message: "poison" } });
-        expect(await claim(["handler-a"], at(100 * LEASE_MS))).toEqual([]);
-      });
-      it("does not count an attempt that was reported as failed twice", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [delivery] = await claim(["handler-a"], at(0), 100, "worker-1");
-        await store.reschedule(delivery, at(10), { name: "Error", message: "x" }, at(1));
-        const [retry] = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(retry.attempt).toBe(2);
-        const [afterCrash] = await claim(["handler-a"], at(LEASE_MS * 2), 100, "worker-3");
-        expect(afterCrash.attempt).toBe(3);
-      });
-      it("keeps the order of a key across a takeover", async () => {
-        const [head, next] = await (async () => {
-          const events = [createEnvelope({ key: "k" }), createEnvelope({ key: "k" })];
-          for (const event of events) {
-            await append([{ event, deliveries: [createDelivery("handler-a")] }]);
-          }
-          return events;
-        })();
-        const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
-        expect(stale.event.id).toBe(head.id);
-        const taken = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
-        expect(taken.map((delivery) => delivery.event.id)).toEqual([head.id]);
+    it("does not let the dead-letter cutoff remove events whose deliveries completed", async () => {
+      const event = createEnvelope();
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"]);
+      await store.complete(delivery, at(1));
+      expect(await store.purge({ deadBefore: at(100 * DAY) })).toMatchObject({
+        deletedEvents: 0
+      });
+      const again = await append([{ event, deliveries: [createDelivery("handler-a")] }], at(2));
+      expect(again.appendedDeliveryCount).toBe(0);
+    });
+  });
+}
+function lostLeasesContract(suite) {
+  const { append, claim, completeMany, options } = suite;
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("lost leases", () => {
+    it("hands a delivery of a crashed worker to the next claimer with the attempt counted", async () => {
+      await append(
+        Array.from({ length: 4 }, () => ({
+          event: createEnvelope(),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      const first = await claim(["handler-a"], at(0), 100, "worker-1");
+      expect(first.map((delivery) => delivery.attempt)).toEqual([1, 1, 1, 1]);
+      expect(await claim(["handler-a"], at(LEASE_MS - 1), 100, "worker-2")).toEqual([]);
+      const second = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(second.map((delivery) => delivery.deliveryId).sort()).toEqual(
+        first.map((delivery) => delivery.deliveryId).sort()
+      );
+      expect(second.map((delivery) => delivery.attempt)).toEqual([2, 2, 2, 2]);
+      for (const stale of first) {
         expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
-        expect(await store.complete(taken[0], at(LEASE_MS + 2))).toBe(true);
-        const [following] = await claim(["handler-a"], at(LEASE_MS + 3), 100, "worker-2");
-        expect(following.event.id).toBe(next.id);
-      });
-      it("lets every worker see only deliveries nobody else holds, and none twice", async () => {
-        await append(
-          Array.from({ length: 30 }, () => ({
-            event: createEnvelope(),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        const seen = [];
-        for (let round = 0; round < 40; round += 1) {
-          const owners = ["worker-1", "worker-2", "worker-3"];
-          const batches = await Promise.all(
-            owners.map((owner) => claim(["handler-a"], at(round), 4, owner))
-          );
-          for (const batch of batches) {
-            seen.push(...batch.map((delivery) => delivery.deliveryId));
-            expect(await completeMany(store, batch, at(round))).toEqual(batch.map(() => true));
-          }
-        }
-        expect(seen).toHaveLength(30);
-        expect(new Set(seen).size).toBe(30);
-      });
+      }
+      expect(await completeMany(store, first, at(LEASE_MS + 1))).toEqual([
+        false,
+        false,
+        false,
+        false
+      ]);
+      expect(await completeMany(store, second, at(LEASE_MS + 2))).toEqual([true, true, true, true]);
     });
-    describe("relinquish", () => {
-      it("hands idle leases to other workers at once and keeps leases with running work", async (context) => {
-        if (store.relinquish === void 0) {
-          return context.skip();
+    it("keeps counting attempts of a poison delivery until it is dead-lettered", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      for (let crash = 0; crash < 4; crash += 1) {
+        const [delivery] = await claim(["handler-a"], at(crash * LEASE_MS), 100, `worker-${crash}`);
+        expect(delivery.attempt).toBe(crash + 1);
+      }
+      const [last] = await claim(["handler-a"], at(4 * LEASE_MS), 100, "worker-4");
+      expect(last.attempt).toBe(5);
+      expect(await store.bury(last, { name: "Error", message: "poison" }, at(4 * LEASE_MS))).toBe(
+        true
+      );
+      const [dead] = await store.listDeliveries({ status: "dead" });
+      expect(dead).toMatchObject({ attempts: 5, lastError: { message: "poison" } });
+      expect(await claim(["handler-a"], at(100 * LEASE_MS))).toEqual([]);
+    });
+    it("does not count an attempt that was reported as failed twice", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [delivery] = await claim(["handler-a"], at(0), 100, "worker-1");
+      await store.reschedule(delivery, at(10), { name: "Error", message: "x" }, at(1));
+      const [retry] = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(retry.attempt).toBe(2);
+      const [afterCrash] = await claim(["handler-a"], at(LEASE_MS * 2), 100, "worker-3");
+      expect(afterCrash.attempt).toBe(3);
+    });
+    it("keeps the order of a key across a takeover", async () => {
+      const [head, next] = await (async () => {
+        const events = [createEnvelope({ key: "k" }), createEnvelope({ key: "k" })];
+        for (const event of events) {
+          await append([{ event, deliveries: [createDelivery("handler-a")] }]);
         }
-        await append([
-          { event: createEnvelope(), deliveries: [createDelivery("handler-a")] },
-          { event: createEnvelope(), deliveries: [createDelivery("handler-a")] }
-        ]);
-        const claimed = await claim(["handler-a"], at(0), 100, "worker-1");
-        expect(claimed).toHaveLength(2);
-        await store.relinquish("worker-1", at(1));
-        expect(await store.complete(claimed[0], at(2))).toBe(true);
-        expect(await store.complete(claimed[1], at(2))).toBe(true);
-        await store.relinquish("worker-1", at(3));
-        await append(
-          [{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }],
-          at(4)
+        return events;
+      })();
+      const [stale] = await claim(["handler-a"], at(0), 100, "worker-1");
+      expect(stale.event.id).toBe(head.id);
+      const taken = await claim(["handler-a"], at(LEASE_MS), 100, "worker-2");
+      expect(taken.map((delivery) => delivery.event.id)).toEqual([head.id]);
+      expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
+      expect(await store.complete(taken[0], at(LEASE_MS + 2))).toBe(true);
+      const [following] = await claim(["handler-a"], at(LEASE_MS + 3), 100, "worker-2");
+      expect(following.event.id).toBe(next.id);
+    });
+    it("lets every worker see only deliveries nobody else holds, and none twice", async () => {
+      await append(
+        Array.from({ length: 30 }, () => ({
+          event: createEnvelope(),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      const seen = [];
+      for (let round = 0; round < 40; round += 1) {
+        const owners = ["worker-1", "worker-2", "worker-3"];
+        const batches = await Promise.all(
+          owners.map((owner) => claim(["handler-a"], at(round), 4, owner))
         );
-        expect(await claim(["handler-a"], at(4), 100, "worker-2")).toHaveLength(1);
-      });
-      it("does not give away a delivery that is still running", async (context) => {
-        if (store.relinquish === void 0) {
-          return context.skip();
+        for (const batch of batches) {
+          seen.push(...batch.map((delivery) => delivery.deliveryId));
+          expect(await completeMany(store, batch, at(round))).toEqual(batch.map(() => true));
         }
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [running] = await claim(["handler-a"], at(0), 100, "worker-1");
-        await store.relinquish("worker-1", at(1));
-        expect(await claim(["handler-a"], at(2), 100, "worker-2")).toEqual([]);
-        expect(await store.complete(running, at(3))).toBe(true);
-      });
+      }
+      expect(seen).toHaveLength(30);
+      expect(new Set(seen).size).toBe(30);
     });
-    describe.skipIf(options.createPeerStore === void 0)("across store instances", () => {
-      let peer;
-      beforeEach(async () => {
-        peer = await options.createPeerStore(store);
-      });
-      afterEach(async () => {
-        await options.destroyStore?.(peer);
-      });
-      it("never gives one delivery to claimers in different processes", async () => {
-        await append(
-          Array.from({ length: 60 }, (_, index) => ({
-            event: createEnvelope({ key: index % 3 === 0 ? `key-${index % 9}` : null }),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        const request = (owner) => ({
-          handlers: ["handler-a"],
-          limit: 7,
-          leaseOwner: owner,
-          leaseExpiresAt: at(LEASE_MS),
-          now: at(0)
-        });
-        const batches = await Promise.all([
-          ...Array.from({ length: 5 }, (_, index) => store.claim(request(`primary-${index}`))),
-          ...Array.from({ length: 5 }, (_, index) => peer.claim(request(`peer-${index}`)))
-        ]);
-        const claimed = batches.flat();
-        expect(new Set(claimed.map((delivery) => delivery.deliveryId)).size).toBe(claimed.length);
-        const keys = claimed.map((delivery) => delivery.event.key).filter((key) => key !== null);
-        expect(new Set(keys).size).toBe(keys.length);
-      });
-      it("fences a lease taken over by another process", async () => {
-        await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
-        const [stale] = await claim(["handler-a"], at(0));
-        const [current] = await peer.claim({
-          handlers: ["handler-a"],
-          limit: 1,
-          leaseOwner: "peer",
-          leaseExpiresAt: at(LEASE_MS * 2),
-          now: at(LEASE_MS)
-        });
-        expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
-        expect(await peer.complete(current, at(LEASE_MS + 1))).toBe(true);
+  });
+  describe("relinquish", () => {
+    it("hands idle leases to other workers at once and keeps leases with running work", async (context) => {
+      if (store.relinquish === void 0) {
+        return context.skip();
+      }
+      await append([
+        { event: createEnvelope(), deliveries: [createDelivery("handler-a")] },
+        { event: createEnvelope(), deliveries: [createDelivery("handler-a")] }
+      ]);
+      const claimed = await claim(["handler-a"], at(0), 100, "worker-1");
+      expect(claimed).toHaveLength(2);
+      await store.relinquish("worker-1", at(1));
+      expect(await store.complete(claimed[0], at(2))).toBe(true);
+      expect(await store.complete(claimed[1], at(2))).toBe(true);
+      await store.relinquish("worker-1", at(3));
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }], at(4));
+      expect(await claim(["handler-a"], at(4), 100, "worker-2")).toHaveLength(1);
+    });
+    it("does not give away a delivery that is still running", async (context) => {
+      if (store.relinquish === void 0) {
+        return context.skip();
+      }
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [running] = await claim(["handler-a"], at(0), 100, "worker-1");
+      await store.relinquish("worker-1", at(1));
+      expect(await claim(["handler-a"], at(2), 100, "worker-2")).toEqual([]);
+      expect(await store.complete(running, at(3))).toBe(true);
+    });
+  });
+  describe.skipIf(options.createPeerStore === void 0)("across store instances", () => {
+    let peer;
+    beforeEach(async () => {
+      peer = await options.createPeerStore(store);
+    });
+    afterEach(async () => {
+      await options.destroyStore?.(peer);
+    });
+    it("never gives one delivery to claimers in different processes", async () => {
+      await append(
+        Array.from({ length: 60 }, (_, index) => ({
+          event: createEnvelope({ key: index % 3 === 0 ? `key-${index % 9}` : null }),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      const request = (owner) => ({
+        handlers: ["handler-a"],
+        limit: 7,
+        leaseOwner: owner,
+        leaseExpiresAt: at(LEASE_MS),
+        now: at(0)
+      });
+      const batches = await Promise.all([
+        ...Array.from({ length: 5 }, (_, index) => store.claim(request(`primary-${index}`))),
+        ...Array.from({ length: 5 }, (_, index) => peer.claim(request(`peer-${index}`)))
+      ]);
+      const claimed = batches.flat();
+      expect(new Set(claimed.map((delivery) => delivery.deliveryId)).size).toBe(claimed.length);
+      const keys = claimed.map((delivery) => delivery.event.key).filter((key) => key !== null);
+      expect(new Set(keys).size).toBe(keys.length);
+    });
+    it("fences a lease taken over by another process", async () => {
+      await append([{ event: createEnvelope(), deliveries: [createDelivery("handler-a")] }]);
+      const [stale] = await claim(["handler-a"], at(0));
+      const [current] = await peer.claim({
+        handlers: ["handler-a"],
+        limit: 1,
+        leaseOwner: "peer",
+        leaseExpiresAt: at(LEASE_MS * 2),
+        now: at(LEASE_MS)
+      });
+      expect(await store.complete(stale, at(LEASE_MS + 1))).toBe(false);
+      expect(await peer.complete(current, at(LEASE_MS + 1))).toBe(true);
+    });
+    it("completes batches in either process and fences the one that lost its lease", async () => {
+      await append(
+        Array.from({ length: 6 }, () => ({
+          event: createEnvelope(),
+          deliveries: [createDelivery("handler-a")]
+        }))
+      );
+      const request = (owner, now) => ({
+        handlers: ["handler-a"],
+        limit: 100,
+        leaseOwner: owner,
+        leaseExpiresAt: new Date(now.getTime() + LEASE_MS),
+        now
       });
-      it("completes batches in either process and fences the one that lost its lease", async () => {
-        await append(
-          Array.from({ length: 6 }, () => ({
-            event: createEnvelope(),
-            deliveries: [createDelivery("handler-a")]
-          }))
-        );
-        const request = (owner, now) => ({
-          handlers: ["handler-a"],
-          limit: 100,
-          leaseOwner: owner,
-          leaseExpiresAt: new Date(now.getTime() + LEASE_MS),
-          now
-        });
-        const stale = await store.claim(request("primary", at(0)));
-        const current = await peer.claim(request("peer", at(LEASE_MS)));
-        expect(current).toHaveLength(6);
-        expect(await completeMany(store, stale, at(LEASE_MS + 1))).toEqual(stale.map(() => false));
-        expect(await completeMany(peer, current, at(LEASE_MS + 1))).toEqual(
-          current.map(() => true)
-        );
-        expect(await store.statistics(at(LEASE_MS + 2))).toMatchObject({
-          pending: 0,
-          processing: 0
-        });
+      const stale = await store.claim(request("primary", at(0)));
+      const current = await peer.claim(request("peer", at(LEASE_MS)));
+      expect(current).toHaveLength(6);
+      expect(await completeMany(store, stale, at(LEASE_MS + 1))).toEqual(stale.map(() => false));
+      expect(await completeMany(peer, current, at(LEASE_MS + 1))).toEqual(current.map(() => true));
+      expect(await store.statistics(at(LEASE_MS + 2))).toMatchObject({
+        pending: 0,
+        processing: 0
       });
     });
   });
 }
 
+// src/event-store-contract.ts
+function eventStoreContract(name, options) {
+  const keepsCompleted = options.keepsCompletedRecords ?? false;
+  describe(`${name} satisfies the EventStore contract`, () => {
+    let store;
+    beforeEach(async () => {
+      store = await options.createStore();
+    });
+    afterEach(async () => {
+      await options.destroyStore?.(store);
+    });
+    async function append(entries, now = at(0)) {
+      return store.transaction((transaction) => store.append(transaction, entries, now));
+    }
+    async function completeMany(target, leases, now) {
+      if (target.completeMany !== void 0) {
+        return target.completeMany(leases, now);
+      }
+      const outcomes = [];
+      for (const lease of leases) {
+        outcomes.push(await target.complete(lease, now));
+      }
+      return outcomes;
+    }
+    async function claim(handlers, now = at(0), limit = 100, owner = "worker-1") {
+      return store.claim({
+        handlers,
+        limit,
+        leaseOwner: owner,
+        leaseExpiresAt: new Date(now.getTime() + LEASE_MS),
+        now
+      });
+    }
+    const suite = {
+      options,
+      keepsCompleted,
+      store: () => store,
+      append,
+      claim,
+      completeMany
+    };
+    appendAndClaimContract(suite);
+    fencingContract(suite);
+    maintenanceContract(suite);
+    orderingAndLeasesContract(suite);
+    completionContract(suite);
+    lostLeasesContract(suite);
+  });
+}
+
 // src/fake-clock.ts
 var FakeClock = class {
   #now;
-  constructor(start = "2026-01-01T00:00:00.000Z") {
+  #timers = /* @__PURE__ */ new Set();
+  #sequence = 0;
+  /** Present only with `controlTimers: true`; see {@link Clock.schedule}. */
+  schedule;
+  constructor(start = "2026-01-01T00:00:00.000Z", options = {}) {
     this.#now = new Date(start).getTime();
+    if (options.controlTimers === true) {
+      this.schedule = (task) => this.#schedule(task);
+    }
   }
   now() {
     return new Date(this.#now);
   }
+  /** Moves the clock forward, running every controlled timer that falls due on the way, in time order. */
   advance(milliseconds) {
-    this.#now += milliseconds;
+    const target = this.#now + milliseconds;
+    for (let timer = this.#nextDue(target); timer !== void 0; timer = this.#nextDue(target)) {
+      this.#now = Math.max(this.#now, timer.dueAt);
+      if (timer.task.repeat === true) {
+        timer.dueAt += Math.max(1, timer.task.delayMs);
+      } else {
+        this.#timers.delete(timer);
+      }
+      timer.task.run();
+    }
+    this.#now = target;
     return this.now();
   }
   set(instant) {
     this.#now = new Date(instant).getTime();
     return this.now();
   }
+  /** Controlled timers still waiting to run. */
+  get pendingTimers() {
+    return this.#timers.size;
+  }
+  #schedule(task) {
+    const timer = {
+      task,
+      dueAt: this.#now + Math.max(0, task.delayMs),
+      sequence: this.#sequence++
+    };
+    this.#timers.add(timer);
+    return () => {
+      this.#timers.delete(timer);
+    };
+  }
+  #nextDue(limit) {
+    let next;
+    for (const timer of this.#timers) {
+      if (timer.dueAt <= limit && (next === void 0 || timer.dueAt < next.dueAt || timer.dueAt === next.dueAt && timer.sequence < next.sequence)) {
+        next = timer;
+      }
+    }
+    return next;
+  }
 };
 
 // src/in-memory-transport.ts
@@ -1315,20 +1391,11 @@ var InMemoryTransport = class {
    * a subscriber that rejects up to `maxRedeliveries` times. Resolves with the
    * total number of handler calls.
    */
+  // eslint-disable-next-line relaybus/max-two-params -- public InMemoryTransport.deliver signature
   async deliver(destination, envelope, maxRedeliveries = 0) {
     let calls = 0;
     for (const handler of this.#subscribers.get(destination) ?? []) {
-      for (let attempt = 0; ; attempt += 1) {
-        calls += 1;
-        try {
-          await handler(envelope);
-          break;
-        } catch (error) {
-          if (attempt >= maxRedeliveries) {
-            throw error;
-          }
-        }
-      }
+      calls += await deliverWithRedeliveries(handler, { envelope, destination, maxRedeliveries });
     }
     return calls;
   }
@@ -1336,6 +1403,18 @@ var InMemoryTransport = class {
     this.closed = true;
   }
 };
+async function deliverWithRedeliveries(handler, delivery) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await handler(delivery.envelope, { destination: delivery.destination });
+      return attempt + 1;
+    } catch (error) {
+      if (attempt >= delivery.maxRedeliveries) {
+        throw error;
+      }
+    }
+  }
+}
 
 export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract };
 //# sourceMappingURL=index.js.map