@relaybus/mongodb 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -1,57 +1,9 @@
 'use strict';
 
 var core = require('@relaybus/core');
+var internal = require('@relaybus/core/internal');
 
-// src/mongo-event-store.ts
-
-// src/claim-scan.ts
-var ClaimScan = class {
-  #keys = /* @__PURE__ */ new Map();
-  /** Whether an unfinished delivery this scan knows of comes before the delivery with `sequence`. */
-  waits(orderingId, sequence) {
-    const known = this.#keys.get(orderingId);
-    return known?.openSequence !== void 0 && sequence > known.openSequence;
-  }
-  /** Whether this scan already learned anything about the key. */
-  knows(orderingId) {
-    return this.#keys.has(orderingId);
-  }
-  /** Records an unfinished delivery of the key with this sequence. */
-  noteOpen(orderingId, sequence) {
-    const known = this.#know(orderingId);
-    known.openSequence = Math.min(known.openSequence ?? sequence, sequence);
-  }
-  /** Remembers a pending delivery of lane `laneId` that waited behind an unfinished predecessor. */
-  noteWaiting(orderingId, deliveryId, laneId) {
-    const known = this.#know(orderingId);
-    known.waiting.push(deliveryId);
-    known.laneId = laneId;
-  }
-  /**
-   * Ids of the waiting deliveries of every key that accumulated at least
-   * `minimum` of them, or that lives in one of `handedBack`. Shorter queues
-   * of a lane that stays held remain in the claim index: moving them out and
-   * back would cost more than skipping them. In a lane handed back they are
-   * all its due work, and leaving them ready would make every later claim take
-   * the lane for nothing.
-   */
-  waitingBacklogs(minimum, handedBack) {
-    return [...this.#keys.values()].filter((known) => known.waiting.length >= minimum || handedBack.has(known.laneId)).flatMap((known) => known.waiting);
-  }
-  #know(orderingId) {
-    let known = this.#keys.get(orderingId);
-    if (known === void 0) {
-      known = { openSequence: void 0, waiting: [], laneId: void 0 };
-      this.#keys.set(orderingId, known);
-    }
-    return known;
-  }
-};
-function orderingIdentity(handler, key) {
-  return `${handler}\0${key}`;
-}
-
-// src/lanes.ts
+// src/documents.ts
 var LANE_COUNT = 256;
 var FNV_OFFSET_BASIS = 2166136261;
 var FNV_PRIME = 16777619;
@@ -63,20 +15,28 @@ function laneOf(key, eventId) {
   }
   return hash & LANE_COUNT - 1;
 }
-function formatLeaseToken(laneId, epoch, claims) {
-  return `${laneId}:${epoch}:${claims}`;
+var LEASE_TOKENS = new internal.LaneLeaseTokenFormat({
+  laneCount: LANE_COUNT,
+  epochDigits: 15,
+  claimsDigits: 15
+});
+function formatLeaseToken(laneId, { epoch, claims }) {
+  return LEASE_TOKENS.format(laneId, { epoch, claims });
 }
-var LEASE_TOKEN_PATTERN = /^(\d{1,3}):(\d{1,15}):(\d{1,15})$/;
 function parseLeaseToken(token) {
-  const match = LEASE_TOKEN_PATTERN.exec(token);
-  if (match === null || Number(match[1]) >= LANE_COUNT) {
+  const parts = LEASE_TOKENS.parse(token);
+  if (parts === void 0) {
     return void 0;
   }
-  return { laneId: Number(match[1]), epoch: Number(match[2]), claims: Number(match[3]) };
+  return { laneId: parts.lane, epoch: Number(parts.epoch), claims: parts.claims };
 }
 
 // src/documents.ts
-function toEventDocument(event, sequence, handlers, createdAt) {
+function toEventDocument(event, {
+  sequence,
+  handlers,
+  createdAt
+}) {
   const payloadJson = serializeWellFormed(event.payload, "payload");
   const headersJson = serializeWellFormed(event.headers, "headers");
   return {
@@ -121,7 +81,11 @@ function toEnvelope(document) {
     occurredAt: document.occurredAt
   };
 }
-function toDeliveryDocument(delivery, event, ordering, now) {
+function toDeliveryDocument(delivery, {
+  event,
+  ordering,
+  now
+}) {
   return {
     _id: delivery.id,
     eventId: event.id,
@@ -138,7 +102,10 @@ function toDeliveryDocument(delivery, event, ordering, now) {
     createdAt: now
   };
 }
-function toDeliveryRecord(document, event, runningIn) {
+function toDeliveryRecord(document, {
+  event,
+  runningIn
+}) {
   return {
     id: document._id,
     handler: document.handler,
@@ -183,7 +150,17 @@ function toCompletedDeliveryDocument(document, completedAt) {
   };
 }
 function toErrorInfo(error) {
-  return error.stack === void 0 ? { name: error.name, message: error.message } : { name: error.name, message: error.message, stack: error.stack };
+  const info = {
+    name: error.name,
+    message: error.message
+  };
+  if (error.stack !== void 0) {
+    info.stack = error.stack;
+  }
+  if (error.code !== void 0) {
+    info.code = error.code;
+  }
+  return info;
 }
 var ILLEGAL_OPERATION = 20;
 function isTransactionsUnsupportedError(error) {
@@ -195,463 +172,362 @@ function createTransactionsUnsupportedError(cause) {
     { cause }
   );
 }
-var COLLECTION_PREFIX_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,39}$/;
-var DATABASE_NAME_PATTERN = /^[A-Za-z0-9_-]{1,63}$/;
-function assertCollectionPrefix(prefix) {
-  if (!COLLECTION_PREFIX_PATTERN.test(prefix)) {
-    throw new core.ConfigurationError(
-      `collectionPrefix '${prefix}' must be 1-40 characters of letters, digits or '_', starting with a letter or '_'`
-    );
+
+// src/mongo-store-state.ts
+async function runInTransaction(state, work) {
+  return runInTransactionWith(state, { work, transactionOptions: state.transactionOptions });
+}
+async function runInBudgetedTransaction(state, {
+  work,
+  timeoutMs
+}) {
+  const budget = Math.ceil(timeoutMs);
+  return runInTransactionWith(state, {
+    work,
+    transactionOptions: { ...state.transactionOptions, maxCommitTimeMS: budget }
+  });
+}
+async function runInTransactionWith(state, {
+  work,
+  transactionOptions
+}) {
+  try {
+    return await state.client.withSession(async (session) => {
+      let result;
+      await session.withTransaction(async () => {
+        result = await work(session);
+      }, transactionOptions);
+      return result;
+    });
+  } catch (error) {
+    if (isTransactionsUnsupportedError(error)) {
+      throw createTransactionsUnsupportedError(error);
+    }
+    throw error;
   }
 }
-function assertDatabaseName(name) {
-  if (!DATABASE_NAME_PATTERN.test(name)) {
+function assertInTransaction(session, operation) {
+  if (!session.inTransaction()) {
     throw new core.ConfigurationError(
-      `database '${name}' must be 1-63 characters of letters, digits, '_' or '-'`
+      `MongoEventStore.${operation} needs a ClientSession inside a started transaction (session.withTransaction or startTransaction). Without one, MongoDB commits each write immediately and the write is no longer atomic with yours`
     );
   }
 }
+function atCount(count) {
+  return count === 0 ? { $not: { $gt: 0 } } : count;
+}
 
-// src/mongo-event-store.ts
-var DEFAULT_TRANSACTION_OPTIONS = {
-  readConcern: { level: "snapshot" },
-  writeConcern: { w: "majority" },
-  readPreference: "primary"
-};
-var NAMESPACE_EXISTS = 48;
-var INDEX_NOT_FOUND = 27;
-var DEFAULT_PURGE_BATCH_SIZE = 500;
-var DEFAULT_LIST_LIMIT = 100;
-var MINIMUM_CANDIDATE_BATCH_SIZE = 32;
-var PARK_BACKLOG_THRESHOLD = 32;
-var PARK_UPDATE_CHUNK_SIZE = 1e3;
-var UPGRADE_BATCH_SIZE = 1e3;
-var INITIAL_LANES_PER_ROUND = 4;
-var LANES_PER_CANDIDATE_QUERY = 128;
-var CLAIM_INDEX_KEY = { laneId: 1, dueAt: 1, _id: 1, handler: 1 };
-var OBSOLETE_INDEXES = ["running"];
-var LEASE_FIELDS = { leaseOwner: "", leaseToken: "", leaseExpiresAt: "" };
-var FINISHED_FIELDS = { dueAt: "", lane: "" };
-var MongoEventStore = class {
-  #client;
-  #database;
-  #events;
-  #deliveries;
-  #keySequences;
-  #lanes;
-  #completions;
-  #completionHistory;
-  #transactionOptions;
-  #purgeBatchSize;
-  #logger;
-  /**
-   * Identifies this store instance in the lanes it holds. A process that restarts
-   * with the same `leaseOwner` gets a new instance, so it never mistakes the
-   * lanes of its dead predecessor for its own: it waits for their leases to
-   * expire and takes them over like any other worker.
-   */
-  #instanceId = core.createUuidV7();
-  /** The last claim of each owner still running on this instance; the next one waits for it. */
-  #claimsInProgress = /* @__PURE__ */ new Map();
-  /**
-   * Claims this instance handed out that are not settled yet, keyed by
-   * {@link leaseKey} (delivery id and exact lease token), with the owner. A
-   * claim is settled when a completion, retry, release or burial of exactly
-   * that lease returned, or, for a completion inside the caller's transaction
-   * (which may still retry or roll back), when a later claim of the owner finds
-   * the delivery gone. After a failed claim, a listed delivery stays listed only
-   * if one of these is its current claim (current lane epoch and claim generation).
-   */
-  #handedOut = /* @__PURE__ */ new Map();
-  /** Owners whose lanes on this instance still need reconciling after a failed claim. */
-  #unreconciledOwners = /* @__PURE__ */ new Set();
-  constructor(options) {
-    const prefix = options.collectionPrefix ?? "relaybus_";
-    assertCollectionPrefix(prefix);
-    if (options.database !== void 0) {
-      assertDatabaseName(options.database);
-    }
-    const purgeBatchSize = options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE;
-    if (!Number.isInteger(purgeBatchSize) || purgeBatchSize < 1) {
-      throw new core.ConfigurationError(
-        `purgeBatchSize must be a positive integer, received ${String(purgeBatchSize)}`
-      );
-    }
-    this.#client = options.client;
-    const database = options.client.db(options.database);
-    this.#database = database;
-    const collectionOptions = {
-      readPreference: "primary",
-      writeConcern: { w: "majority" }
+// src/mongo-append.ts
+var MongoAppend = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Implements {@link MongoEventStore.append}. */
+  async append(session, { entries, now }) {
+    assertInTransaction(session, "append");
+    const eventIds = [...new Set(entries.map((entry) => entry.event.id))];
+    const storedEvents = new Map(
+      (await this.#state.events.find(
+        { _id: { $in: eventIds } },
+        { session, projection: { key: 1, sequence: 1, handlers: 1 } }
+      ).toArray()).map((stored) => [stored._id, stored])
+    );
+    const plan = await this.#planAppend({ session, entries, storedEvents, now });
+    await this.#writeAppend({ session, plan, storedEvents, now });
+    return {
+      appendedEventIds: plan.appendedEventIds,
+      duplicateEventIds: plan.duplicateEventIds,
+      appendedDeliveryCount: plan.newDeliveries.length
     };
-    this.#events = database.collection(`${prefix}events`, collectionOptions);
-    this.#deliveries = database.collection(`${prefix}deliveries`, collectionOptions);
-    this.#keySequences = database.collection(`${prefix}key_sequences`, collectionOptions);
-    this.#lanes = database.collection(`${prefix}lanes`, collectionOptions);
-    this.#completions = database.collection(`${prefix}completed_deliveries`, collectionOptions);
-    this.#completionHistory = options.completionHistory ?? false;
-    this.#transactionOptions = options.transactionOptions ?? DEFAULT_TRANSACTION_OPTIONS;
-    this.#purgeBatchSize = purgeBatchSize;
-    this.#logger = options.logger ?? console;
   }
   /**
-   * Verifies the deployment supports transactions, creates the collections and
-   * indexes and seeds the lane documents. Upgrades a 0.1.0 database in place
-   * first (see {@link MongoEventStore.#upgradeFromVersion010}); the seeded lanes
-   * mark the upgrade as done, so later runs skip it. Safe to run repeatedly and
-   * from several processes. Stop 0.1.0 workers before the first run.
-   *
-   * @throws ConfigurationError when the server is a standalone mongod.
+   * Decides, in entry order, which events are new (taking their key sequence) and which deliveries
+   * each event still lacks.
    */
-  async setup() {
-    const hello = await this.#client.db("admin").command({ hello: 1 });
-    const supportsTransactions = typeof hello["setName"] === "string" || hello["msg"] === "isdbgrid";
-    if (!supportsTransactions) {
-      throw createTransactionsUnsupportedError(void 0);
+  async #planAppend(input) {
+    const { session, entries, storedEvents, now } = input;
+    const appendedEventIds = [];
+    const duplicateEventIds = [];
+    const newEvents = [];
+    const newDeliveries = [];
+    const addedHandlers = /* @__PURE__ */ new Map();
+    const { orderingByEventId, knownHandlers } = indexStoredEvents(storedEvents);
+    for (const { event, deliveries } of entries) {
+      let ordering = orderingByEventId.get(event.id);
+      if (ordering === void 0) {
+        const sequence = event.key === null ? null : await this.#nextSequence(event.key, session);
+        ordering = { key: event.key, sequence };
+        orderingByEventId.set(event.id, ordering);
+        knownHandlers.set(event.id, /* @__PURE__ */ new Set());
+        newEvents.push({ event, sequence });
+        appendedEventIds.push(event.id);
+      } else {
+        duplicateEventIds.push(event.id);
+      }
+      const handlers = knownHandlers.get(event.id);
+      for (const delivery of deliveries) {
+        if (handlers.has(delivery.handler)) {
+          continue;
+        }
+        handlers.add(delivery.handler);
+        addedHandlers.set(event.id, [...addedHandlers.get(event.id) ?? [], delivery.handler]);
+        newDeliveries.push(toDeliveryDocument(delivery, { event, ordering, now }));
+      }
     }
-    const collectionNames = [
-      this.#events.collectionName,
-      this.#deliveries.collectionName,
-      this.#keySequences.collectionName,
-      this.#lanes.collectionName,
-      ...this.#completionHistory ? [this.#completions.collectionName] : []
-    ];
-    for (const name of collectionNames) {
-      await this.#createCollectionIfMissing(name);
+    return { appendedEventIds, duplicateEventIds, newEvents, newDeliveries, addedHandlers };
+  }
+  /** Writes the new events, the handlers added to existing events and the new deliveries, in that order. */
+  async #writeAppend(input) {
+    const { session, plan, storedEvents, now } = input;
+    const { newEvents, newDeliveries, addedHandlers } = plan;
+    if (newEvents.length > 0) {
+      await this.#state.events.bulkWrite(newEventOperations({ newEvents, addedHandlers, now }), {
+        session,
+        ordered: true
+      });
     }
-    if (await this.#lanes.countDocuments() < LANE_COUNT) {
-      await this.#upgradeFromVersion010();
-      await this.#seedLanes();
+    const extendedEvents = [...addedHandlers].filter(([eventId]) => storedEvents.has(eventId));
+    if (extendedEvents.length > 0) {
+      await this.#state.events.bulkWrite(extendedEventOperations(extendedEvents), {
+        session,
+        ordered: true
+      });
     }
-    await this.#dropObsoleteIndexes();
-    await this.#deliveries.createIndexes([
-      // Idempotent appends and lookups by event.
-      { key: { eventId: 1, handler: 1 }, name: "event_handler", unique: true },
-      // Claim: due work of a lane in due order. Holds ready deliveries only. The handler is
-      // last, so a query over many lanes and handlers stays a merge of one scan per lane.
-      { key: CLAIM_INDEX_KEY, name: "claim", partialFilterExpression: { lane: "ready" } },
-      // Ordering: unfinished predecessors of a keyed delivery, parked or not.
-      {
-        key: { handler: 1, key: 1, sequence: 1 },
-        name: "ordering",
-        partialFilterExpression: { dueAt: { $exists: true }, sequence: { $exists: true } }
-      },
-      // Parked deliveries: the lowest parked delivery of each key, to move it back once it is next.
-      {
-        key: { handler: 1, key: 1, sequence: 1 },
-        name: "parked",
-        partialFilterExpression: { lane: "parked" }
-      },
-      // Statistics: oldest due delivery across handlers.
-      { key: { dueAt: 1 }, name: "due", partialFilterExpression: { dueAt: { $exists: true } } },
-      // Purge of completed deliveries left by 0.1.0.
-      {
-        key: { completedAt: 1 },
-        name: "completed",
-        partialFilterExpression: { completedAt: { $exists: true } }
-      },
-      // Listing and status counts.
-      { key: { status: 1, createdAt: 1 }, name: "status_created" },
-      // Purge of dead deliveries.
-      { key: { status: 1, updatedAt: 1 }, name: "status_updated" },
-      { key: { handler: 1, createdAt: 1 }, name: "handler_created" },
-      { key: { eventType: 1, createdAt: 1 }, name: "type_created" }
-    ]);
-    await this.#events.createIndexes([
-      { key: { createdAt: 1, _id: 1 }, name: "created" },
-      // Purge of events whose deliveries all completed: they are kept until `completedBefore` passes this.
-      {
-        key: { completedAt: 1, _id: 1 },
-        name: "completed",
-        partialFilterExpression: { completedAt: { $exists: true } }
-      }
-    ]);
-    if (this.#completionHistory) {
-      await this.#completions.createIndexes([
-        { key: { completedAt: 1, _id: 1 }, name: "completed" },
-        { key: { eventId: 1 }, name: "event" },
-        { key: { createdAt: 1, _id: 1 }, name: "created" }
-      ]);
+    if (newDeliveries.length > 0) {
+      await this.#state.deliveries.bulkWrite(newDeliveryOperations(newDeliveries), {
+        session,
+        ordered: true
+      });
     }
   }
-  async #createCollectionIfMissing(name) {
-    try {
-      await this.#database.createCollection(name);
-    } catch (error) {
-      if (!hasErrorCode(error, NAMESPACE_EXISTS)) {
-        throw error;
+  /** Atomically increments the counter of `key`; conflicting appends of the key serialize here. */
+  async #nextSequence(key, session) {
+    const counter = await this.#state.keySequences.findOneAndUpdate(
+      { _id: key },
+      { $inc: { value: 1 } },
+      { upsert: true, returnDocument: "after", session }
+    );
+    return counter.value;
+  }
+};
+function indexStoredEvents(storedEvents) {
+  const orderingByEventId = /* @__PURE__ */ new Map();
+  const knownHandlers = /* @__PURE__ */ new Map();
+  for (const [eventId, stored] of storedEvents) {
+    orderingByEventId.set(eventId, {
+      key: stored.key ?? null,
+      sequence: stored.sequence ?? null
+    });
+    knownHandlers.set(eventId, new Set(stored.handlers));
+  }
+  return { orderingByEventId, knownHandlers };
+}
+function newEventOperations(input) {
+  const { newEvents, addedHandlers, now } = input;
+  return newEvents.map(({ event, sequence }) => {
+    const document = toEventDocument(event, {
+      sequence,
+      handlers: addedHandlers.get(event.id) ?? [],
+      createdAt: now
+    });
+    return {
+      updateOne: {
+        filter: { _id: document._id },
+        update: { $setOnInsert: document },
+        upsert: true
       }
+    };
+  });
+}
+function extendedEventOperations(extendedEvents) {
+  return extendedEvents.map(([eventId, handlers]) => ({
+    updateOne: {
+      filter: { _id: eventId },
+      update: { $inc: { revision: 1 }, $push: { handlers: { $each: handlers } } }
     }
+  }));
+}
+function newDeliveryOperations(newDeliveries) {
+  return newDeliveries.map((document) => ({
+    updateOne: {
+      filter: { eventId: document.eventId, handler: document.handler },
+      update: { $setOnInsert: document },
+      upsert: true
+    }
+  }));
+}
+var ClaimScan = class {
+  #keys = /* @__PURE__ */ new Map();
+  /** Whether an unfinished delivery this scan knows of comes before the delivery with `sequence`. */
+  waits(orderingId, sequence) {
+    const known = this.#keys.get(orderingId);
+    return known?.openSequence !== void 0 && sequence > known.openSequence;
+  }
+  /** Whether this scan already learned anything about the key. */
+  knows(orderingId) {
+    return this.#keys.has(orderingId);
+  }
+  /** Records an unfinished delivery of the key with this sequence. */
+  noteOpen(orderingId, sequence) {
+    const known = this.#know(orderingId);
+    known.openSequence = Math.min(known.openSequence ?? sequence, sequence);
+  }
+  /** Remembers a pending delivery of lane `laneId` that waited behind an unfinished predecessor. */
+  noteWaiting(orderingId, { deliveryId, laneId }) {
+    const known = this.#know(orderingId);
+    known.waiting.push(deliveryId);
+    known.laneId = laneId;
   }
   /**
-   * Converts the documents of a 0.1.0 database; every step is idempotent, so a
-   * run that crashed is simply repeated. Deliveries that were `processing`
-   * become `pending`, due at once (their attempt stays counted, as a lost lease
-   * would count it). The per-delivery lease fields go, every delivery gets its
-   * lane, and every event learns which handlers it already has deliveries for
-   * and when it was created. Deliveries completed under 0.1.0 stay as
-   * `completed` documents until a purge removes them.
+   * Ids of the waiting deliveries of every key that accumulated at least
+   * `minimum` of them, or that lives in one of `handedBack`. Shorter queues
+   * of a lane that stays held remain in the claim index: moving them out and
+   * back would cost more than skipping them. In a lane handed back they are
+   * all its due work, and leaving them ready would make every later claim take
+   * the lane for nothing.
    */
-  async #upgradeFromVersion010() {
-    const legacy = this.#database.collection(this.#deliveries.collectionName);
-    await legacy.updateMany({ status: "processing" }, [
-      { $set: { status: "pending", lane: "ready", dueAt: "$availableAt" } }
-    ]);
-    await legacy.updateMany(
-      {
-        $or: [
-          { leaseOwner: { $exists: true } },
-          { leaseToken: { $exists: true } },
-          { leaseExpiresAt: { $exists: true } }
-        ]
-      },
-      { $unset: LEASE_FIELDS }
-    );
-    await inBatches(
-      this.#deliveries.find(
-        { laneId: { $exists: false } },
-        { projection: { eventId: 1, key: 1 }, batchSize: UPGRADE_BATCH_SIZE }
-      ),
-      async (documents) => {
-        await this.#deliveries.bulkWrite(
-          documents.map((document) => ({
-            updateOne: {
-              filter: { _id: document._id },
-              update: { $set: { laneId: laneOf(document.key ?? null, document.eventId) } }
-            }
-          })),
-          { ordered: false }
-        );
-      }
-    );
-    await inBatches(
-      this.#events.find(
-        { handlers: { $exists: false } },
-        { projection: { occurredAt: 1 }, batchSize: UPGRADE_BATCH_SIZE }
-      ),
-      async (events) => {
-        const known = new Map(
-          (await this.#deliveries.aggregate([
-            { $match: { eventId: { $in: events.map((event) => event._id) } } },
-            {
-              $group: {
-                _id: "$eventId",
-                handlers: { $addToSet: "$handler" },
-                createdAt: { $min: "$createdAt" }
-              }
-            }
-          ]).toArray()).map((group) => [group._id, group])
-        );
-        await this.#events.bulkWrite(
-          events.map((event) => {
-            const group = known.get(event._id);
-            return {
-              updateOne: {
-                // Only an event nobody converted yet: another process may have finished and subscribed a handler.
-                filter: { _id: event._id, handlers: { $exists: false } },
-                update: {
-                  $set: group === void 0 ? { handlers: [], createdAt: event.occurredAt } : { handlers: group.handlers, createdAt: group.createdAt }
-                }
-              }
-            };
-          }),
-          { ordered: false }
-        );
-      }
-    );
-  }
-  /** Creates the lane documents that do not exist yet. */
-  async #seedLanes() {
-    await this.#lanes.bulkWrite(
-      Array.from({ length: LANE_COUNT }, (_, laneId) => ({
-        updateOne: {
-          filter: { _id: laneId },
-          update: {
-            $setOnInsert: {
-              epoch: 0,
-              owner: null,
-              holder: null,
-              leaseExpiresAt: null,
-              inFlight: [],
-              lost: []
-            }
-          },
-          upsert: true
-        }
-      })),
-      { ordered: false }
-    );
+  waitingBacklogs(minimum, handedBack) {
+    return [...this.#keys.values()].filter((known) => known.waiting.length >= minimum || handedBack.has(known.laneId)).flatMap((known) => known.waiting);
   }
-  /** Drops the 0.1.0 indexes that no query uses, and a `claim` index with the 0.1.0 key. */
-  async #dropObsoleteIndexes() {
-    for (const index of await this.#deliveries.indexes()) {
-      const obsolete = OBSOLETE_INDEXES.includes(index.name) || index.name === "claim" && Object.keys(index.key).join() !== Object.keys(CLAIM_INDEX_KEY).join();
-      if (obsolete) {
-        try {
-          await this.#deliveries.dropIndex(index.name);
-        } catch (error) {
-          if (!hasErrorCode(error, INDEX_NOT_FOUND)) {
-            throw error;
-          }
-        }
-      }
+  #know(orderingId) {
+    let known = this.#keys.get(orderingId);
+    if (known === void 0) {
+      known = { openSequence: void 0, waiting: [], laneId: void 0 };
+      this.#keys.set(orderingId, known);
     }
+    return known;
   }
-  /**
-   * Runs `work` in a transaction on a new session and commits when it resolves.
-   *
-   * `work` can run more than once. The driver restarts the whole callback after
-   * a transient failure such as a write conflict, and re-sends only the commit
-   * after an unknown commit result. A restart is safe for everything written
-   * through the session, because the aborted attempt left nothing behind. It is
-   * not safe for side effects outside the session (HTTP calls, other databases),
-   * so keep those out of `work`; relaybus handlers are already at-least-once.
-   *
-   * @throws ConfigurationError when the deployment does not support transactions.
-   */
-  async transaction(work) {
-    try {
-      return await this.#client.withSession(async (session) => {
-        let result;
-        await session.withTransaction(async () => {
-          result = await work(session);
-        }, this.#transactionOptions);
-        return result;
-      });
-    } catch (error) {
-      if (isTransactionsUnsupportedError(error)) {
-        throw createTransactionsUnsupportedError(error);
-      }
-      throw error;
-    }
+};
+function orderingIdentity(handler, key) {
+  return internal.CompositeKey.of(handler, key);
+}
+var MongoLaneReconciler = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
   }
   /**
-   * Writes the entries in `session`. An existing event gets a delivery only for
-   * handlers it does not list yet; the added handlers are appended to its list
-   * together with a `revision` increment, a real write that makes a concurrent
-   * purge of the event conflict with this transaction.
+   * Takes every delivery this instance does not run out of the lanes `owner`
+   * holds on it: every listed delivery whose current claim (lane epoch and
+   * claim generation now) was not handed out by this instance, or was settled.
+   * One transaction, and the lanes are written first under their epoch and
+   * holder: a worker taking a lane over meanwhile conflicts with it, so its
+   * claim is never touched. The claim generation of every delivery taken out
+   * moves on, so no lease of those claims (a completion that failed and is
+   * retried later, say) can ever match a later claim of the same delivery.
+   * Registrations of this owner that are not the current claim of a listed
+   * delivery are dropped.
    */
-  async append(session, entries, now) {
-    assertInTransaction(session, "append");
-    const eventIds = [...new Set(entries.map((entry) => entry.event.id))];
-    const storedEvents = new Map(
-      (await this.#events.find(
-        { _id: { $in: eventIds } },
-        { session, projection: { key: 1, sequence: 1, handlers: 1 } }
-      ).toArray()).map((stored) => [stored._id, stored])
-    );
-    const appendedEventIds = [];
-    const duplicateEventIds = [];
-    const newEvents = [];
-    const newDeliveries = [];
-    const knownHandlers = /* @__PURE__ */ new Map();
-    const addedHandlers = /* @__PURE__ */ new Map();
-    const orderingByEventId = /* @__PURE__ */ new Map();
-    for (const [eventId, stored] of storedEvents) {
-      orderingByEventId.set(eventId, {
-        key: stored.key ?? null,
-        sequence: stored.sequence ?? null
-      });
-      knownHandlers.set(eventId, new Set(stored.handlers));
-    }
-    for (const { event, deliveries } of entries) {
-      let ordering = orderingByEventId.get(event.id);
-      if (ordering === void 0) {
-        const sequence = event.key === null ? null : await this.#nextSequence(event.key, session);
-        ordering = { key: event.key, sequence };
-        orderingByEventId.set(event.id, ordering);
-        knownHandlers.set(event.id, /* @__PURE__ */ new Set());
-        newEvents.push({ event, sequence });
-        appendedEventIds.push(event.id);
-      } else {
-        duplicateEventIds.push(event.id);
-      }
-      const handlers = knownHandlers.get(event.id);
-      for (const delivery of deliveries) {
-        if (handlers.has(delivery.handler)) {
-          continue;
-        }
-        handlers.add(delivery.handler);
-        addedHandlers.set(event.id, [...addedHandlers.get(event.id) ?? [], delivery.handler]);
-        newDeliveries.push(toDeliveryDocument(delivery, event, ordering, now));
-      }
-    }
-    if (newEvents.length > 0) {
-      await this.#events.bulkWrite(
-        newEvents.map(({ event, sequence }) => {
-          const document = toEventDocument(event, sequence, addedHandlers.get(event.id) ?? [], now);
-          return {
-            updateOne: {
-              filter: { _id: document._id },
-              update: { $setOnInsert: document },
-              upsert: true
-            }
-          };
-        }),
-        { session, ordered: true }
-      );
-    }
-    const extendedEvents = [...addedHandlers].filter(([eventId]) => storedEvents.has(eventId));
-    if (extendedEvents.length > 0) {
-      await this.#events.bulkWrite(
-        extendedEvents.map(([eventId, handlers]) => ({
-          updateOne: {
-            filter: { _id: eventId },
-            update: { $inc: { revision: 1 }, $push: { handlers: { $each: handlers } } }
-          }
-        })),
-        { session, ordered: true }
+  async reconcile(owner) {
+    await runInTransaction(this.#state, async (session) => {
+      const held = await this.#state.lanes.find({ owner, holder: this.#state.instanceId }, { session }).toArray();
+      const claimsById = await this.#claimGenerations(
+        held.flatMap((lane) => lane.inFlight),
+        session
       );
-    }
-    if (newDeliveries.length > 0) {
-      await this.#deliveries.bulkWrite(
-        newDeliveries.map((document) => ({
-          updateOne: {
-            filter: { eventId: document.eventId, handler: document.handler },
-            update: { $setOnInsert: document },
-            upsert: true
-          }
-        })),
-        { session, ordered: true }
+      const { unclaimed, current } = this.#splitUnclaimed(held, claimsById);
+      this.#state.handedOut.forgetWhere(
+        (entry, identity) => entry.owner === owner && !current.has(identity)
       );
-    }
-    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount: newDeliveries.length };
+      if (held.length === 0) {
+        return;
+      }
+      await this.#takeOut(unclaimed, session);
+    });
+  }
+  /** The claim generation now of every listed delivery that is still pending. */
+  async #claimGenerations(listed, session) {
+    return new Map(
+      (await this.#state.deliveries.find({ _id: { $in: listed }, status: "pending" }, { session, projection: { claims: 1 } }).toArray()).map((document) => [document._id, document.claims ?? 0])
+    );
   }
   /**
-   * Claims up to `limit` due deliveries. It claims from the lanes this owner
-   * (and this store instance) holds under a live lease first, then takes free
-   * lanes with due work, a few at a time (4, 8, 16, ...) and the lane with the
-   * oldest due delivery first, so a worker holds only as many lanes as it
-   * needs. It then records the batch with one write per lane and hands back the
-   * lanes that yielded nothing and run nothing. No delivery document is
-   * written, except for the attempt charged to deliveries of a lane taken over
-   * and for parking (see {@link MongoEventStore.#parkDeliveries}).
-   *
-   * Taking a lane is one conditional `findOneAndUpdate` that also moves the
-   * previous owner's in-flight list to the lane's `lost` list; a lane another
-   * claimer took first is skipped, never waited for. Lost deliveries are charged
-   * one attempt before anything is read from the lane, and `lost` is cleared
-   * only after that. Whoever holds the lane next charges a `lost` list it finds
-   * first, so a claim that fails anywhere after the take loses no charge; the
-   * charge of a lost claim is recorded on the delivery, so charging the list
-   * again after a failure before the clear charges nothing twice.
-   * Nothing a failed claim did leaves a delivery listed as running.
+   * Per held lane, the listed deliveries this instance did not hand out under their current claim,
+   * and the identities of all current claims.
    */
-  async claim(request) {
-    if (request.handlers.length === 0 || request.limit <= 0) {
-      return [];
-    }
-    const owner = request.leaseOwner;
-    const previous = this.#claimsInProgress.get(owner) ?? Promise.resolve();
-    const claimed = previous.then(() => this.#claimReconciled(request));
-    const settled = Promise.allSettled([claimed]);
-    this.#claimsInProgress.set(owner, settled);
-    void settled.then(() => {
-      if (this.#claimsInProgress.get(owner) === settled) {
-        this.#claimsInProgress.delete(owner);
+  #splitUnclaimed(held, claimsById) {
+    const current = /* @__PURE__ */ new Set();
+    const unclaimed = held.map((lane) => ({
+      lane,
+      ids: lane.inFlight.filter((id) => {
+        const key = internal.DeliveryLeaseIdentity.of(
+          id,
+          formatLeaseToken(lane._id, { epoch: lane.epoch, claims: claimsById.get(id) ?? 0 })
+        );
+        current.add(key);
+        return !this.#state.handedOut.has(key);
+      })
+    }));
+    return { unclaimed, current };
+  }
+  /** Takes the unclaimed deliveries out of their lanes, then moves their claim generation on. */
+  async #takeOut(unclaimed, session) {
+    await this.#state.lanes.bulkWrite(
+      unclaimed.map(({ lane, ids }) => ({
+        updateOne: {
+          filter: { _id: lane._id, epoch: lane.epoch, holder: this.#state.instanceId },
+          update: { $pull: { inFlight: { $in: ids } }, $inc: { revision: 1 } }
+        }
+      })),
+      { session, ordered: false }
+    );
+    await this.#state.deliveries.updateMany(
+      { _id: { $in: unclaimed.flatMap((entry) => entry.ids) }, status: "pending" },
+      { $inc: { claims: 1 } },
+      { session }
+    );
+  }
+};
+
+// src/mongo-claim.ts
+var PARK_BACKLOG_THRESHOLD = 32;
+var INITIAL_LANES_PER_ROUND = 4;
+var LANES_PER_CANDIDATE_QUERY = 128;
+function toClaimedDeliveries(claimed, context) {
+  const { scope, events, request } = context;
+  return claimed.map((document) => ({
+    deliveryId: document._id,
+    leaseToken: formatLeaseToken(document.laneId, {
+      epoch: scope.get(document.laneId).epoch,
+      claims: document.claims ?? 0
+    }),
+    handler: document.handler,
+    attempt: document.attempts + 1,
+    leaseExpiresAt: request.leaseExpiresAt,
+    event: events.get(document.eventId)
+  }));
+}
+function scopeOf(held) {
+  return new Map(
+    held.map((lane) => [
+      lane._id,
+      {
+        laneId: lane._id,
+        epoch: lane.epoch,
+        listed: lane.inFlight,
+        revision: lane.revision ?? 0
       }
-    });
-    return claimed;
+    ])
+  );
+}
+var MongoClaims = class extends internal.OwnerSerializedClaims {
+  #state;
+  #laneLeases;
+  #ordering;
+  #queries;
+  #reconciler;
+  constructor(state, collaborators) {
+    super();
+    this.#state = state;
+    this.#laneLeases = collaborators.laneLeases;
+    this.#ordering = collaborators.ordering;
+    this.#queries = collaborators.queries;
+    this.#reconciler = new MongoLaneReconciler(state);
+  }
+  /** Mongo claims nothing for a limit of 0 or below (a limit that is not a number is tried). */
+  claimsNothing(request) {
+    return request.handlers.length === 0 || request.limit <= 0;
   }
   /**
    * Runs one claim and remembers what it hands out. When the claim fails at any
@@ -661,17 +537,17 @@ var MongoEventStore = class {
    * handed out and seen settled, is taken out of them, so nothing stays listed
    * as running that nobody runs.
    */
-  async #claimReconciled(request) {
+  async claimInTurn(request) {
     const owner = request.leaseOwner;
-    if (this.#unreconciledOwners.has(owner)) {
-      await this.#reconcileLanes(owner);
-      this.#unreconciledOwners.delete(owner);
+    if (this.#state.unreconciledOwners.has(owner)) {
+      await this.#reconciler.reconcile(owner);
+      this.#state.unreconciledOwners.delete(owner);
     }
     try {
       const claimed = await this.#claimNow(request);
       for (const delivery of claimed) {
         const { laneId, epoch } = parseLeaseToken(delivery.leaseToken);
-        this.#handedOut.set(leaseKey(delivery.deliveryId, delivery.leaseToken), {
+        this.#state.handedOut.register(delivery, {
           deliveryId: delivery.deliveryId,
           owner: request.leaseOwner,
           laneId,
@@ -680,103 +556,51 @@ var MongoEventStore = class {
       }
       return claimed;
     } catch (error) {
-      const [reconciled] = await Promise.allSettled([this.#reconcileLanes(owner)]);
+      const [reconciled] = await Promise.allSettled([this.#reconciler.reconcile(owner)]);
       if (reconciled.status === "rejected") {
-        this.#unreconciledOwners.add(owner);
+        this.#state.unreconciledOwners.add(owner);
       }
       throw error;
     }
   }
-  /**
-   * Takes every delivery this instance does not run out of the lanes `owner`
-   * holds on it: every listed delivery whose current claim (lane epoch and
-   * claim generation now) was not handed out by this instance, or was settled.
-   * One transaction, and the lanes are written first under their epoch and
-   * holder: a worker taking a lane over meanwhile conflicts with it, so its
-   * claim is never touched. The claim generation of every delivery taken out
-   * moves on, so no lease of those claims (a completion that failed and is
-   * retried later, say) can ever match a later claim of the same delivery.
-   * Registrations of this owner that are not the current claim of a listed
-   * delivery are dropped.
-   */
-  async #reconcileLanes(owner) {
-    await this.transaction(async (session) => {
-      const held = await this.#lanes.find({ owner, holder: this.#instanceId }, { session }).toArray();
-      const listed = held.flatMap((lane) => lane.inFlight);
-      const claimsById = new Map(
-        (await this.#deliveries.find(
-          { _id: { $in: listed }, status: "pending" },
-          { session, projection: { claims: 1 } }
-        ).toArray()).map((document) => [document._id, document.claims ?? 0])
-      );
-      const current = /* @__PURE__ */ new Set();
-      const unclaimed = held.map((lane) => ({
-        lane,
-        ids: lane.inFlight.filter((id) => {
-          const key = leaseKey(id, formatLeaseToken(lane._id, lane.epoch, claimsById.get(id) ?? 0));
-          current.add(key);
-          return !this.#handedOut.has(key);
-        })
-      }));
-      for (const [key, entry] of this.#handedOut) {
-        if (entry.owner === owner && !current.has(key)) {
-          this.#handedOut.delete(key);
-        }
-      }
-      if (held.length === 0) {
-        return;
-      }
-      await this.#lanes.bulkWrite(
-        unclaimed.map(({ lane, ids }) => ({
-          updateOne: {
-            filter: { _id: lane._id, epoch: lane.epoch, holder: this.#instanceId },
-            update: { $pull: { inFlight: { $in: ids } }, $inc: { revision: 1 } }
-          }
-        })),
-        { session, ordered: false }
-      );
-      await this.#deliveries.updateMany(
-        { _id: { $in: unclaimed.flatMap((entry) => entry.ids) }, status: "pending" },
-        { $inc: { claims: 1 } },
-        { session }
-      );
+  async #claimNow(request) {
+    const held = await this.#readHeldLanes(request);
+    await this.#laneLeases.chargeLost(held);
+    const scope = scopeOf(held);
+    const running = this.#loadRunning(held);
+    const scan = new ClaimScan();
+    const picked = [];
+    await this.#pickAcrossLanes({ request, scope, scan, running, picked });
+    const events = await this.#queries.readEnvelopes(picked.map((document) => document.eventId));
+    const runningIds = (await running).ids;
+    this.#forgetSettled(held, { runningIds, owner: request.leaseOwner });
+    const { recorded, handedBack } = await this.#laneLeases.recordClaim(scope, {
+      picked,
+      runningIds,
+      request
     });
+    const claimed = await this.#releaseOvertaken(
+      picked.filter((document) => recorded.has(document.laneId)),
+      scope
+    );
+    await this.#ordering.parkWaiting(scan.waitingBacklogs(PARK_BACKLOG_THRESHOLD, handedBack));
+    return toClaimedDeliveries(claimed, { scope, events, request });
   }
-  /**
-   * Runs `operation`, which ends the claims of `leases` (completion, retry,
-   * release, burial), and once it returned forgets exactly those leases as
-   * handed out. When it throws, they stay registered: the caller may retry
-   * with the same lease, which must still find its claim.
-   */
-  async #settle(leases, operation) {
-    const result = await operation();
-    for (const lease of leases) {
-      this.#handedOut.delete(leaseKey(String(lease.deliveryId), String(lease.leaseToken)));
-    }
-    return result;
-  }
-  async #claimNow(request) {
+  /** The lanes the owner holds on this instance, read while the next deliveries are unparked. */
+  async #readHeldLanes(request) {
     const [held] = await Promise.all([
-      this.#lanes.find({
+      this.#state.lanes.find({
         owner: request.leaseOwner,
-        holder: this.#instanceId,
+        holder: this.#state.instanceId,
         leaseExpiresAt: { $gt: request.now }
       }).toArray(),
-      this.#unparkNextDeliveries(request.handlers)
+      this.#ordering.unparkNextDeliveries(request.handlers)
     ]);
-    await this.#chargeLost(held);
-    const scope = new Map(
-      held.map((lane) => [
-        lane._id,
-        {
-          laneId: lane._id,
-          epoch: lane.epoch,
-          listed: lane.inFlight,
-          revision: lane.revision ?? 0
-        }
-      ])
-    );
-    const running = this.#findRunning(held.flatMap((lane) => lane.inFlight)).then((documents) => ({
+    return held;
+  }
+  /** The deliveries still running in the held lanes, with their (handler, key) identities. */
+  #loadRunning(held) {
+    return this.#queries.findRunning(held.flatMap((lane) => lane.inFlight)).then((documents) => ({
       ids: new Set(documents.map((document) => document._id)),
       keys: new Set(
         documents.flatMap(
@@ -784,88 +608,161 @@ var MongoEventStore = class {
         )
       )
     }));
-    const scan = new ClaimScan();
-    const picked = [];
+  }
+  /**
+   * Picks from the lanes in `scope`, then takes free lanes with due work, a few more each round
+   * (4, 8, 16, ...), and picks from them, until the claim is full or no free lane is left.
+   */
+  async #pickAcrossLanes(input) {
+    const { request, scope, scan, running, picked } = input;
     const pickFrom = async (lanes) => {
       for (let offset = 0; offset < lanes.length; offset += LANES_PER_CANDIDATE_QUERY) {
         if (picked.length < request.limit) {
-          await this.#pickCandidates(
-            lanes.slice(offset, offset + LANES_PER_CANDIDATE_QUERY),
+          await this.#ordering.pickCandidates({
+            lanes: lanes.slice(offset, offset + LANES_PER_CANDIDATE_QUERY),
             request,
             scan,
             running,
             picked
-          );
+          });
         }
       }
     };
     await pickFrom([...scope.values()]);
     const passed = new Set(scope.keys());
     for (let laneCount = INITIAL_LANES_PER_ROUND; picked.length < request.limit; laneCount *= 2) {
-      const free = await this.#findFreeLanes(request, laneCount, [...passed]);
+      const free = await this.#laneLeases.findFreeLanes(request, {
+        laneCount,
+        passed: [...passed]
+      });
       if (free.length === 0) {
         break;
       }
       for (const laneId of free) {
         passed.add(laneId);
       }
-      const taken = await this.#takeLanes(free, request);
+      const taken = await this.#laneLeases.takeLanes(free, request);
       for (const lane of taken) {
         scope.set(lane.laneId, lane);
       }
       await pickFrom(taken);
     }
-    const events = await this.#readEnvelopes(picked.map((document) => document.eventId));
-    const runningIds = (await running).ids;
+  }
+  /**
+   * Forgets the claims of `owner` that are listed in the held lanes but no longer pending:
+   * completed (a burial or retry would have unlisted it). Such a claim is settled, also when it was
+   * completed inside a caller's transaction that committed. Only this owner's registrations of the
+   * lane epochs it read: the same delivery may meanwhile have been requeued and handed out again,
+   * under another owner or lane epoch.
+   */
+  #forgetSettled(held, { runningIds, owner }) {
     const gone = new Set(
       held.flatMap(
-        (lane) => lane.inFlight.filter((id) => !runningIds.has(id)).map((id) => `${id}\0${lane._id}:${lane.epoch}`)
+        (lane) => lane.inFlight.filter((id) => !runningIds.has(id)).map((id) => internal.CompositeKey.of(id, `${lane._id}:${lane.epoch}`))
       )
     );
-    for (const [key, entry] of this.#handedOut) {
-      if (entry.owner === request.leaseOwner && gone.has(`${entry.deliveryId}\0${entry.laneId}:${entry.epoch}`)) {
-        this.#handedOut.delete(key);
-      }
-    }
-    const { recorded, handedBack } = await this.#recordClaim(scope, picked, runningIds, request);
-    const claimed = await this.#releaseOvertaken(
-      picked.filter((document) => recorded.has(document.laneId)),
-      scope
+    this.#state.handedOut.forgetWhere(
+      (entry) => entry.owner === owner && gone.has(internal.CompositeKey.of(entry.deliveryId, `${entry.laneId}:${entry.epoch}`))
     );
-    await this.#parkWaiting(scan.waitingBacklogs(PARK_BACKLOG_THRESHOLD, handedBack));
-    return claimed.map((document) => ({
-      deliveryId: document._id,
-      leaseToken: formatLeaseToken(
-        document.laneId,
-        scope.get(document.laneId).epoch,
-        document.claims ?? 0
-      ),
-      handler: document.handler,
-      attempt: document.attempts + 1,
-      leaseExpiresAt: request.leaseExpiresAt,
-      event: events.get(document.eventId)
-    }));
   }
   /**
-   * Extends the lease of the lane a running delivery belongs to. The lane lease
-   * never shrinks, so a repeated renewal with the same value still holds. An
-   * expired lease nobody took over is still renewed, so `_now` is not needed.
-   */
-  async extendLease(lease, leaseExpiresAt, _now) {
-    const held = parseLeaseToken(lease.leaseToken);
-    if (held === void 0) {
-      return false;
-    }
+   * Gives back the recorded keyed picks that a delivery requeued during the
+   * claim now precedes, without charging an attempt, and returns the rest. The
+   * claim checked their predecessors before recording them; a dead letter
+   * requeued in between would otherwise wait behind its own successor. Once a
+   * pick is recorded, a later requeue waits for it like for any running delivery.
+   */
+  async #releaseOvertaken(claimed, scope) {
+    const keyed = claimed.filter((document) => document.key !== void 0);
+    if (keyed.length === 0) {
+      return [...claimed];
+    }
+    const blockers = await this.#state.deliveries.find(
+      {
+        $or: keyed.map((document) => ({
+          handler: document.handler,
+          key: document.key,
+          sequence: { $lt: document.sequence },
+          dueAt: { $exists: true }
+        }))
+      },
+      { projection: { handler: 1, key: 1 } }
+    ).toArray();
+    const blocked = new Set(
+      blockers.map((blocker) => orderingIdentity(blocker.handler, blocker.key))
+    );
+    const overtaken = new Set(
+      keyed.filter((document) => blocked.has(orderingIdentity(document.handler, document.key))).map((document) => document._id)
+    );
+    if (overtaken.size === 0) {
+      return [...claimed];
+    }
+    await this.#releasePicks(
+      claimed.filter((document) => overtaken.has(document._id)),
+      scope
+    );
+    return claimed.filter((document) => !overtaken.has(document._id));
+  }
+  /** Takes recorded picks out of their lanes' in-flight lists again, under the claim's epochs and record revisions. */
+  async #releasePicks(documents, scope) {
+    const idsByLane = /* @__PURE__ */ new Map();
+    for (const document of documents) {
+      idsByLane.set(document.laneId, [...idsByLane.get(document.laneId) ?? [], document._id]);
+    }
+    await Promise.all(
+      [...idsByLane].map(
+        ([laneId, ids]) => this.#state.lanes.updateOne(
+          // Under the revision the record left: a pull that reaches the server late, after a
+          // reconciliation and a newer claim of the same delivery, matches nothing.
+          {
+            _id: laneId,
+            epoch: scope.get(laneId).epoch,
+            revision: scope.get(laneId).revision + 1
+          },
+          { $pull: { inFlight: { $in: ids } } }
+        )
+      )
+    );
+  }
+};
+var FINISHED_FIELDS = { dueAt: "", lane: "" };
+var MongoCompletion = class extends internal.LeaseSettlement {
+  #state;
+  constructor(state) {
+    super();
+    this.#state = state;
+  }
+  /** Implements {@link MongoEventStore.complete}. */
+  async complete(lease, { now, session }) {
+    if (session !== void 0) {
+      assertInTransaction(session, "complete");
+    }
+    return (await this.#completeLeases([lease], { now, session }))[0];
+  }
+  /** Implements {@link MongoEventStore.completeMany}. */
+  completeMany(leases, now) {
+    return this.#completeLeases(leases, { now, session: void 0 });
+  }
+  /** A lease this store issued; any other token cannot be held. */
+  findHeld(lease) {
+    return parseLeaseToken(lease.leaseToken);
+  }
+  /**
+   * Renews the lane lease of a running claim. One transaction: a stale lease must not extend the
+   * lane of a newer claim of the delivery. A claim ending or starting meanwhile writes the delivery
+   * or the lane, so the two conflict.
+   */
+  writeExtension(held, { lease, leaseExpiresAt }) {
     const deliveryId = String(lease.deliveryId);
-    return this.transaction(async (session) => {
-      const running = await this.#deliveries.findOne(ofClaim({ ...held, deliveryId }), {
+    return runInTransaction(this.#state, async (session) => {
+      const running = await this.#state.deliveries.findOne(ofClaim({ ...held, deliveryId }), {
         session,
         projection: { _id: 1 }
       });
       if (running === null) {
         return false;
       }
-      const renewed = await this.#lanes.updateOne(
+      const renewed = await this.#state.lanes.updateOne(
         { _id: held.laneId, epoch: held.epoch, inFlight: deliveryId },
         { $max: { leaseExpiresAt } },
         { session }
@@ -874,248 +771,246 @@ var MongoEventStore = class {
     });
   }
   /**
-   * Deletes the delivery (and records it in the completion history, when kept).
-   * With `session` the deletion commits with the caller's transaction; without,
-   * it runs in a transaction of its own. Returns false when the lease was lost.
-   */
-  async complete(lease, now, session) {
-    if (session !== void 0) {
-      assertInTransaction(session, "complete");
-    }
-    return (await this.#completeLeases([lease], now, session))[0];
-  }
-  /**
-   * Completes many leases with a fixed number of round trips, whatever lanes
-   * they belong to: three commands without a completion history, one
-   * transaction with it (see {@link MongoEventStore.#deleteFenced}).
-   * Returns one flag per lease in input order; a lease listed twice completes
-   * once, and a token this store cannot have issued is refused.
+   * Applies the change to the running delivery and takes it out of its lane's in-flight list, if
+   * the lane still has the lease's epoch.
    */
-  completeMany(leases, now) {
-    return this.#completeLeases(leases, now, void 0);
-  }
-  /** Returns a running delivery to pending, due at `availableAt`, and counts the attempt that ended. */
-  async reschedule(lease, availableAt, error, now) {
-    return this.#leaveFlight(lease, {
-      $set: { availableAt, dueAt: availableAt, lastError: toErrorInfo(error), updatedAt: now },
-      $inc: { attempts: 1, claims: 1 }
+  writeChange(held, { lease, change }) {
+    const deliveryId = String(lease.deliveryId);
+    return this.#leaveFlightNow(held, {
+      deliveryId,
+      ofThisClaim: ofClaim({ ...held, deliveryId }),
+      update: updateFor(change)
     });
   }
-  /** Gives a running delivery back without counting the attempt: pending, due `now`. */
-  async release(lease, now) {
-    return this.#leaveFlight(lease, {
-      $set: { availableAt: now, dueAt: now, updatedAt: now },
-      $inc: { claims: 1 }
-    });
+  forgetHandedOut(lease) {
+    this.#forget(lease);
   }
-  /** Moves a running delivery to dead and counts the attempt that ended. */
-  async bury(lease, error, now) {
-    return this.#leaveFlight(lease, {
-      $set: { status: "dead", lastError: toErrorInfo(error), updatedAt: now },
-      $unset: FINISHED_FIELDS,
-      $inc: { attempts: 1, claims: 1 }
+  /** Forgets a lease as handed out: its claim ended. */
+  #forget(lease) {
+    this.#state.handedOut.forget({
+      deliveryId: String(lease.deliveryId),
+      leaseToken: String(lease.leaseToken)
     });
   }
   /**
-   * Frees every lane `leaseOwner` holds that runs no delivery, so other workers
-   * need not wait for the lease to expire. Lanes with running deliveries stay leased.
+   * Runs `operation`, which ends the claims of `leases` (completion, retry,
+   * release, burial), and once it returned forgets exactly those leases as
+   * handed out. When it throws, they stay registered: the caller may retry
+   * with the same lease, which must still find its claim.
    */
-  async relinquish(leaseOwner) {
-    const held = await this.#lanes.find({ owner: String(leaseOwner), holder: this.#instanceId }).toArray();
-    const runningIds = new Set(
-      (await this.#findRunning(held.flatMap((lane) => lane.inFlight))).map(
-        (document) => document._id
-      )
-    );
-    const idle = held.filter((lane) => lane.inFlight.every((id) => !runningIds.has(id)));
-    if (idle.length > 0) {
-      await this.#lanes.bulkWrite(
-        idle.map((lane) => freeLane(lane._id, lane.epoch, lane.revision ?? 0, lane.inFlight)),
-        { ordered: false }
-      );
+  async #settle(leases, operation) {
+    const result = await operation();
+    for (const lease of leases) {
+      this.#forget(lease);
     }
+    return result;
   }
   /**
-   * Lists deliveries in creation order. A delivery is `processing` while its
-   * document exists as `pending` and its lane lists it; its attempt count then
-   * includes the running attempt, and owner and expiry are those of the lane
-   * lease. Completion history records (when kept) are listed as `completed`.
+   * Deletes the delivery of every lease whose lane still has the lease's epoch
+   * and lists the delivery, in one transaction (the caller's, when given).
+   * Returns one flag per lease, in order; a lease listed twice completes once.
    */
-  async listDeliveries(query) {
-    const status = query.status === void 0 ? void 0 : String(query.status);
-    const common = {
-      ...query.handler === void 0 ? {} : { handler: String(query.handler) },
-      ...query.eventType === void 0 ? {} : { eventType: String(query.eventType) },
-      ...query.eventId === void 0 ? {} : { eventId: String(query.eventId) }
-    };
-    const limit = query.limit ?? DEFAULT_LIST_LIMIT;
-    const lanes = await this.#lanes.find({ "inFlight.0": { $exists: true } }, { projection: { epoch: 0 } }).toArray();
-    const listed = lanes.flatMap((lane) => lane.inFlight);
-    const derivedStatuses = /* @__PURE__ */ new Map([
-      ["processing", { status: "pending", _id: { $in: listed } }],
-      ["pending", { status: "pending", _id: { $nin: listed } }]
-    ]);
-    const filter = {
-      ...common,
-      ...status === void 0 ? {} : derivedStatuses.get(status) ?? { status }
-    };
-    const sort = { createdAt: 1, _id: 1 };
-    const documents = await this.#deliveries.find(filter, { sort, limit }).toArray();
-    const history = this.#completionHistory && (status === void 0 || status === "completed") ? await this.#completions.find(common, { sort, limit }).toArray() : [];
-    const events = await this.#readEnvelopes([
-      ...documents.map((document) => document.eventId),
-      ...history.map((document) => document.eventId)
-    ]);
-    const laneById = new Map(lanes.map((lane) => [lane._id, lane]));
-    const records = [
-      ...documents.map((document) => {
-        const lane = laneById.get(document.laneId);
-        const runs = document.status === "pending" && lane?.inFlight.includes(document._id) === true;
-        return toDeliveryRecord(document, events.get(document.eventId), runs ? lane : void 0);
-      }),
-      ...history.map(
-        (document) => toCompletedDeliveryRecord(document, events.get(document.eventId))
-      )
-    ];
-    return records.sort(
-      (left, right) => left.createdAt.getTime() - right.createdAt.getTime() || compareText(left.id, right.id)
-    ).slice(0, limit);
+  async #completeLeases(leases, { now, session }) {
+    return session === void 0 ? this.#settle(leases, () => this.#completeIssued(leases, { now, session: void 0 })) : this.#completeIssued(leases, { now, session });
   }
-  /** Moves dead deliveries back to pending with a fresh attempt budget. */
-  async requeue(deliveryIds, now) {
-    const result = await this.#deliveries.updateMany(
-      { _id: { $in: deliveryIds.map(String) }, status: "dead" },
-      {
-        $set: {
-          status: "pending",
-          lane: "ready",
-          attempts: 0,
-          availableAt: now,
-          dueAt: now,
-          updatedAt: now
-        }
-      }
+  async #completeIssued(leases, { now, session }) {
+    const parsed = leases.map((lease) => parseLeaseToken(lease.leaseToken));
+    const issued = leases.flatMap(
+      (lease, index) => parsed[index] === void 0 ? [] : [{ deliveryId: String(lease.deliveryId), ...parsed[index] }]
     );
-    return result.modifiedCount;
-  }
-  /**
-   * Deletes, in batches of `purgeBatchSize`, dead deliveries last updated before
-   * `deadBefore`, and completion history records (and `completed` documents left
-   * by 0.1.0) completed before `completedBefore`, each batch in one transaction
-   * together with the events it left without any reference. Finally, events
-   * nothing references are deleted: one with a completed delivery once its last
-   * completion is before `completedBefore` (never by `deadBefore` alone), one
-   * that never had a completion (no subscribers, or only dead letters) once it
-   * was created before the earliest given cutoff. The batch step applies the
-   * same rule to events whose last completion is recorded.
-   */
-  async purge(request) {
-    const total = { deletedDeliveries: 0, deletedEvents: 0 };
-    const steps = [];
-    const { completedBefore, deadBefore } = request;
-    if (completedBefore !== void 0) {
-      steps.push(
-        () => this.#purgeMatching(
-          this.#purgeable(this.#deliveries.collectionName),
-          { status: "completed", completedAt: { $lt: completedBefore } },
-          completedBefore
-        )
-      );
-      if (this.#completionHistory) {
-        steps.push(
-          () => this.#purgeMatching(
-            this.#purgeable(this.#completions.collectionName),
-            { completedAt: { $lt: completedBefore } },
-            completedBefore
-          )
+    let completed = /* @__PURE__ */ new Set();
+    if (issued.length > 0) {
+      if (session !== void 0) {
+        completed = await this.#deleteCompleted(issued, { now, session });
+      } else if (this.#state.completionHistory) {
+        completed = await runInTransaction(
+          this.#state,
+          (own) => this.#deleteCompleted(issued, { now, session: own })
         );
+      } else {
+        completed = await this.#deleteFenced(issued, now);
       }
     }
-    if (deadBefore !== void 0) {
-      steps.push(
-        () => this.#purgeMatching(
-          this.#purgeable(this.#deliveries.collectionName),
-          { status: "dead", updatedAt: { $lt: deadBefore } },
-          completedBefore
-        )
-      );
-    }
-    for (const step of steps) {
-      const result = await step();
-      total.deletedDeliveries += result.deletedDeliveries;
-      total.deletedEvents += result.deletedEvents;
-    }
-    const orphanCutoff = [completedBefore, deadBefore].filter((cutoff) => cutoff !== void 0).sort((first, second) => first.getTime() - second.getTime())[0];
-    if (orphanCutoff !== void 0) {
-      total.deletedEvents += await this.#purgeOrphanEvents(orphanCutoff, completedBefore);
-    }
-    return total;
+    return leases.map(
+      (lease, index) => parsed[index] !== void 0 && completed.delete(leaseIdentity({ deliveryId: String(lease.deliveryId), ...parsed[index] }))
+    );
   }
   /**
-   * Counts by derived status. `pending` excludes running deliveries; `completed`
-   * counts history records and 0.1.0 `completed` documents. `oldestDueAt` is the
-   * oldest instant at which a delivery became claimable: the due time of a
-   * pending delivery nobody runs, or the lease expiry of a lane that still runs
-   * deliveries.
+   * Completion without a transaction, used when no history record has to be
+   * written with the deletion. The deliveries' claim generations are read
+   * first, then the lanes, and a delivery is deleted only if it still has the
+   * lease's generation. A takeover moves the generation of every delivery it
+   * takes from the previous owner on before it reads anything, and so do a
+   * retry, a release and a burial, so:
+   * - a takeover before the delivery read shows up in the lane read (new epoch);
+   * - a takeover between the two reads shows up in the lane read as well;
+   * - a takeover, retry, release or burial after the lane read changed the
+   *   generation, so the delete matches nothing.
+   * A completion and a takeover (or the end of the claim) therefore never both succeed. Two concurrent
+   * completions of the same lease may both report true (the dispatcher never
+   * issues them); one call with a lease listed twice reports it once.
    */
-  async statistics(now) {
-    const lanes = await this.#lanes.find({ "inFlight.0": { $exists: true } }, { projection: { inFlight: 1, leaseExpiresAt: 1 } }).toArray();
-    const [stored, dead, legacyCompleted, history, running] = await Promise.all([
-      this.#deliveries.countDocuments({ status: "pending" }),
-      this.#deliveries.countDocuments({ status: "dead" }),
-      this.#deliveries.countDocuments({ status: "completed" }),
-      this.#completionHistory ? this.#completions.countDocuments() : Promise.resolve(0),
-      this.#findRunning(lanes.flatMap((lane) => lane.inFlight))
-    ]);
-    const runningIds = new Set(running.map((document) => document._id));
-    const waiting = await this.#deliveries.findOne(
-      { dueAt: { $lte: now }, _id: { $nin: [...runningIds] } },
-      { sort: { dueAt: 1 }, projection: { dueAt: 1 } }
-    );
-    const dueTimes = lanes.filter(
-      (lane) => lane.leaseExpiresAt !== null && lane.leaseExpiresAt <= now && lane.inFlight.some((id) => runningIds.has(id))
-    ).map((lane) => lane.leaseExpiresAt.getTime());
-    if (waiting !== null) {
-      dueTimes.push(waiting.dueAt.getTime());
-    }
-    return {
-      // The counts are separate reads; a completion between them must not make this negative.
-      pending: Math.max(0, stored - running.length),
-      processing: running.length,
-      completed: legacyCompleted + history,
-      dead,
-      oldestDueAt: dueTimes.length === 0 ? null : new Date(Math.min(...dueTimes))
-    };
-  }
-  /** Atomically increments the counter of `key`; conflicting appends of the key serialize here. */
-  async #nextSequence(key, session) {
-    const counter = await this.#keySequences.findOneAndUpdate(
-      { _id: key },
-      { $inc: { value: 1 } },
-      { upsert: true, returnDocument: "after", session }
+  async #deleteFenced(issued, now) {
+    const ids = [...new Set(issued.map((lease) => lease.deliveryId))];
+    const documents = await this.#state.deliveries.find({ _id: { $in: ids }, status: "pending" }, { projection: { claims: 1, eventId: 1 } }).toArray();
+    const lanes = new Map(
+      (await this.#state.lanes.find(
+        { _id: { $in: [...new Set(issued.map((lease) => lease.laneId))] } },
+        { projection: { epoch: 1, inFlight: 1 } }
+      ).toArray()).map((lane) => [lane._id, lane])
     );
-    return counter.value;
-  }
-  /** The listed deliveries that run: those whose document still exists as pending. */
-  async #findRunning(listed) {
-    if (listed.length === 0) {
-      return [];
+    const fenced = fencedLeases(issued, { lanes, documents });
+    if (fenced.length === 0) {
+      return /* @__PURE__ */ new Set();
     }
-    return this.#deliveries.find(
-      { _id: { $in: [...listed] }, status: "pending" },
-      { projection: { handler: 1, key: 1, laneId: 1 } }
-    ).toArray();
+    await this.#markEventsCompleted(fenced, { documents, now });
+    const deleted = await this.#state.deliveries.deleteMany({ $or: fenced.map(ofClaim) });
+    return deleted.deletedCount === fenced.length ? new Set(fenced.map((lease) => leaseIdentity(lease))) : /* @__PURE__ */ new Set();
   }
   /**
-   * Up to `laneCount` lanes nobody holds under a live lease that have a due,
-   * ready delivery of the requested handlers, the lane with the oldest such
+   * The transactional part of a completion. The lanes are only read: the
+   * conflict with a takeover comes from the deleted delivery documents, which a
+   * takeover writes before it reads them (see `MongoLaneLeases.takeLanes`).
+   * So whichever of the two commits second either fails with a write conflict
+   * and is retried against the new state, or waits for the first.
+   */
+  async #deleteCompleted(issued, { now, session }) {
+    const lanes = new Map(
+      (await this.#state.lanes.find(
+        { _id: { $in: [...new Set(issued.map((lease) => lease.laneId))] } },
+        { session, projection: { epoch: 1, inFlight: 1 } }
+      ).toArray()).map((lane) => [lane._id, lane])
+    );
+    const documents = await this.#state.deliveries.find(
+      { _id: { $in: [...new Set(issued.map((lease) => lease.deliveryId))] }, status: "pending" },
+      { session }
+    ).toArray();
+    const fenced = fencedLeases(issued, { lanes, documents });
+    if (fenced.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    await this.#markEventsCompleted(fenced, { documents, now, session });
+    await this.#state.deliveries.deleteMany({ $or: fenced.map(ofClaim) }, { session });
+    if (this.#state.completionHistory) {
+      const completedIds = new Set(fenced.map((lease) => lease.deliveryId));
+      await this.#state.completions.insertMany(
+        documents.filter((document) => completedIds.has(document._id)).map((document) => toCompletedDeliveryDocument(document, now)),
+        { session }
+      );
+    }
+    return new Set(fenced.map((lease) => leaseIdentity(lease)));
+  }
+  /**
+   * Records `now` as the latest completion of the events of the fenced
+   * deliveries (`$max`, so an earlier clock never moves it back). Written
+   * before the deletion, it can only be later than the real last completion
+   * (when the deletion then fails), which keeps the event longer, never shorter.
+   * Inside a transaction it is part of it: the transaction may hold the event
+   * already (a transactional handler that appended to its own event), and a
+   * write from outside would wait for it forever. Deliveries of one event that
+   * complete in concurrent transactions (fan-out to transactional handlers)
+   * therefore conflict on the event document, and one of them retries.
+   */
+  async #markEventsCompleted(fenced, {
+    documents,
+    now,
+    session
+  }) {
+    const completedIds = new Set(fenced.map((lease) => lease.deliveryId));
+    const eventIds = [
+      ...new Set(
+        documents.filter((document) => completedIds.has(document._id)).map((document) => document.eventId)
+      )
+    ];
+    await this.#state.events.updateMany(
+      { _id: { $in: eventIds } },
+      { $max: { completedAt: now } },
+      session === void 0 ? {} : { session }
+    );
+  }
+  /** One transaction: the lane write fences the change against a takeover. */
+  async #leaveFlightNow(held, {
+    deliveryId,
+    ofThisClaim,
+    update
+  }) {
+    return runInTransaction(this.#state, async (session) => {
+      if (await this.#state.deliveries.findOne(ofThisClaim, { session, projection: { _id: 1 } }) === null) {
+        return false;
+      }
+      const fence = await this.#state.lanes.updateOne(
+        { _id: held.laneId, epoch: held.epoch, inFlight: deliveryId },
+        { $pull: { inFlight: deliveryId } },
+        { session }
+      );
+      if (fence.matchedCount === 0) {
+        return false;
+      }
+      const changed = await this.#state.deliveries.updateOne(ofThisClaim, update, { session });
+      return changed.matchedCount === 1;
+    });
+  }
+};
+function fencedLeases(issued, {
+  lanes,
+  documents
+}) {
+  const claimsById = new Map(documents.map((document) => [document._id, document.claims ?? 0]));
+  const fenced = /* @__PURE__ */ new Map();
+  for (const lease of issued) {
+    const lane = lanes.get(lease.laneId);
+    if (claimsById.get(lease.deliveryId) === lease.claims && lane.epoch === lease.epoch && lane.inFlight.includes(lease.deliveryId)) {
+      fenced.set(leaseIdentity(lease), lease);
+    }
+  }
+  return [...fenced.values()];
+}
+function ofClaim(lease) {
+  return { _id: lease.deliveryId, status: "pending", claims: atCount(lease.claims) };
+}
+function leaseIdentity(lease) {
+  return internal.DeliveryLeaseIdentity.of(
+    lease.deliveryId,
+    formatLeaseToken(lease.laneId, { epoch: lease.epoch, claims: lease.claims })
+  );
+}
+function updateFor(change) {
+  if (change.kind === "reschedule") {
+    const { availableAt, error, now } = change;
+    return {
+      $set: { availableAt, dueAt: availableAt, lastError: toErrorInfo(error), updatedAt: now },
+      $inc: { attempts: 1, claims: 1 }
+    };
+  }
+  if (change.kind === "release") {
+    const { now } = change;
+    return { $set: { availableAt: now, dueAt: now, updatedAt: now }, $inc: { claims: 1 } };
+  }
+  return {
+    $set: { status: "dead", lastError: toErrorInfo(change.error), updatedAt: change.now },
+    $unset: FINISHED_FIELDS,
+    $inc: { attempts: 1, claims: 1 }
+  };
+}
+
+// src/mongo-lane-leases.ts
+var MongoLaneLeases = class {
+  #state;
+  #queries;
+  constructor(state, collaborators) {
+    this.#state = state;
+    this.#queries = collaborators.queries;
+  }
+  /**
+   * Up to `laneCount` lanes nobody holds under a live lease that have a due,
+   * ready delivery of the requested handlers, the lane with the oldest such
    * delivery first, leaving out `passed`. One round trip: the oldest delivery
    * of each lane is one index probe on the server. A lane whose due deliveries
    * all wait behind an unfinished predecessor is taken at most once: the claim
-   * that hands it back parks them (see {@link ClaimScan.waitingBacklogs}).
+   * that hands it back parks them (see `ClaimScan.waitingBacklogs`).
    */
-  async #findFreeLanes(request, laneCount, passed) {
-    const lanes = await this.#lanes.aggregate([
+  async findFreeLanes(request, { laneCount, passed }) {
+    const lanes = await this.#state.lanes.aggregate([
       {
         $match: {
           _id: { $nin: passed },
@@ -1124,7 +1019,7 @@ var MongoEventStore = class {
       },
       {
         $lookup: {
-          from: this.#deliveries.collectionName,
+          from: this.#state.deliveries.collectionName,
           localField: "_id",
           foreignField: "laneId",
           pipeline: [
@@ -1153,12 +1048,12 @@ var MongoEventStore = class {
    * Takes the lanes with one conditional write each, run in parallel; a lane
    * taken by someone else meanwhile is skipped. The same write moves the
    * previous owner's in-flight list to `lost`, which is charged before any
-   * delivery of the lanes is read (see {@link MongoEventStore.#chargeLost}).
+   * delivery of the lanes is read (see {@link MongoLaneLeases.chargeLost}).
    */
-  async #takeLanes(laneIds, request) {
+  async takeLanes(laneIds, request) {
     const after = await Promise.all(
       laneIds.map(
-        (laneId) => this.#lanes.findOneAndUpdate(
+        (laneId) => this.#state.lanes.findOneAndUpdate(
           {
             _id: laneId,
             $or: [{ leaseExpiresAt: null }, { leaseExpiresAt: { $lte: request.now } }]
@@ -1168,7 +1063,7 @@ var MongoEventStore = class {
               $set: {
                 epoch: { $add: ["$epoch", 1] },
                 owner: { $literal: request.leaseOwner },
-                holder: { $literal: this.#instanceId },
+                holder: { $literal: this.#state.instanceId },
                 leaseExpiresAt: { $literal: request.leaseExpiresAt },
                 // Each lost delivery keeps the epoch it was claimed under: the key of its charge.
                 lost: {
@@ -1186,7 +1081,7 @@ var MongoEventStore = class {
       )
     );
     const taken = after.filter((lane) => lane !== null);
-    await this.#chargeLost(taken);
+    await this.chargeLost(taken);
     return taken.map((lane) => ({
       laneId: lane._id,
       epoch: lane.epoch,
@@ -1206,13 +1101,13 @@ var MongoEventStore = class {
    * list again after a failure before the clear skips deliveries already
    * charged for that claim.
    */
-  async #chargeLost(lanes) {
+  async chargeLost(lanes) {
     const losing = lanes.filter((lane) => lane.lost.length > 0);
     if (losing.length === 0) {
       return;
     }
     const lost = losing.flatMap((lane) => lane.lost).sort((left, right) => left.epoch - right.epoch);
-    await this.#deliveries.bulkWrite(
+    await this.#state.deliveries.bulkWrite(
       lost.map(({ id, epoch }) => ({
         updateOne: {
           filter: { _id: id, status: "pending", lostAt: { $not: { $gte: epoch } } },
@@ -1221,13 +1116,175 @@ var MongoEventStore = class {
       })),
       { ordered: true }
     );
-    await this.#lanes.bulkWrite(
+    await this.#state.lanes.bulkWrite(
       losing.map((lane) => ({
         updateOne: { filter: { _id: lane._id, epoch: lane.epoch }, update: { $set: { lost: [] } } }
       })),
       { ordered: false }
     );
   }
+  /**
+   * Records the picks in their lanes, one conditional write per lane and one
+   * round trip for all of them, and frees the lanes that yielded nothing and run
+   * nothing. A picked lane lists its running deliveries plus the new ones (ids
+   * whose documents are gone are pruned) and its lease reaches
+   * `request.leaseExpiresAt`. Returns the lanes whose picks were recorded: every
+   * write is conditional on the claim's epoch, owner and store instance, so a
+   * lane that changed hands, or was handed back by `relinquish`, in the meantime
+   * keeps its deliveries for whoever takes it next.
+   */
+  async recordClaim(scope, {
+    picked,
+    runningIds,
+    request
+  }) {
+    const picksByLane = /* @__PURE__ */ new Map();
+    for (const document of picked) {
+      picksByLane.set(document.laneId, [...picksByLane.get(document.laneId) ?? [], document._id]);
+    }
+    const { operations, handedBack } = this.#planLaneRecords(scope, {
+      picksByLane,
+      runningIds,
+      request
+    });
+    if (operations.length === 0) {
+      return { recorded: /* @__PURE__ */ new Set(), handedBack };
+    }
+    const result = await this.#state.lanes.bulkWrite(operations, { ordered: false });
+    if (result.matchedCount === operations.length) {
+      return { recorded: new Set(picksByLane.keys()), handedBack };
+    }
+    return {
+      recorded: await this.#readRecorded(scope, { laneIds: [...picksByLane.keys()], request }),
+      handedBack
+    };
+  }
+  /**
+   * One conditional write per lane of the claim: a picked lane records its picks, a lane that
+   * yielded nothing and runs nothing is freed (and reported as handed back).
+   */
+  #planLaneRecords(scope, {
+    picksByLane,
+    runningIds,
+    request
+  }) {
+    const handedBack = /* @__PURE__ */ new Set();
+    const operations = [];
+    for (const lane of scope.values()) {
+      const gone = lane.listed.filter((id) => !runningIds.has(id));
+      const ids = picksByLane.get(lane.laneId);
+      if (ids !== void 0) {
+        operations.push(
+          recordInFlight({ lane, ids, gone, request, instanceId: this.#state.instanceId })
+        );
+      } else if (gone.length === lane.listed.length) {
+        operations.push(
+          freeLane(lane.laneId, { epoch: lane.epoch, revision: lane.revision, finished: gone })
+        );
+        handedBack.add(lane.laneId);
+      }
+    }
+    return { operations, handedBack };
+  }
+  /** The lanes of `laneIds` whose record of this claim applied, read back after a partial bulk write. */
+  async #readRecorded(scope, { laneIds, request }) {
+    const current = await this.#state.lanes.find(
+      { _id: { $in: [...laneIds] } },
+      { projection: { epoch: 1, owner: 1, holder: 1, revision: 1 } }
+    ).toArray();
+    return new Set(
+      current.filter(
+        (lane) => lane.epoch === scope.get(lane._id).epoch && lane.revision === scope.get(lane._id).revision + 1 && lane.owner === request.leaseOwner && lane.holder === this.#state.instanceId
+      ).map((lane) => lane._id)
+    );
+  }
+  /** Implements {@link MongoEventStore.relinquish}. */
+  async relinquish(leaseOwner) {
+    const held = await this.#state.lanes.find({ owner: String(leaseOwner), holder: this.#state.instanceId }).toArray();
+    const runningIds = new Set(
+      (await this.#queries.findRunning(held.flatMap((lane) => lane.inFlight))).map(
+        (document) => document._id
+      )
+    );
+    const idle = held.filter((lane) => lane.inFlight.every((id) => !runningIds.has(id)));
+    if (idle.length > 0) {
+      await this.#state.lanes.bulkWrite(
+        idle.map(
+          (lane) => freeLane(lane._id, {
+            epoch: lane.epoch,
+            revision: lane.revision ?? 0,
+            finished: lane.inFlight
+          })
+        ),
+        { ordered: false }
+      );
+    }
+  }
+};
+function recordInFlight(input) {
+  const { lane, ids, gone, request, instanceId } = input;
+  return {
+    updateOne: {
+      filter: {
+        _id: lane.laneId,
+        epoch: lane.epoch,
+        owner: request.leaseOwner,
+        holder: instanceId,
+        // A record that reaches the server late (after its claim failed and reconciled)
+        // finds a newer revision and changes nothing.
+        revision: atCount(lane.revision)
+      },
+      update: [
+        {
+          $set: {
+            inFlight: {
+              $concatArrays: [
+                {
+                  $filter: {
+                    input: "$inFlight",
+                    cond: { $not: [{ $in: ["$$this", { $literal: gone }] }] }
+                  }
+                },
+                { $literal: ids }
+              ]
+            },
+            leaseExpiresAt: { $max: ["$leaseExpiresAt", request.leaseExpiresAt] },
+            revision: { $add: [{ $ifNull: ["$revision", 0] }, 1] }
+          }
+        }
+      ]
+    }
+  };
+}
+function freeLane(laneId, {
+  epoch,
+  revision,
+  finished
+}) {
+  return {
+    updateOne: {
+      filter: {
+        _id: laneId,
+        epoch,
+        revision: atCount(revision),
+        inFlight: { $not: { $elemMatch: { $nin: [...finished] } } }
+      },
+      update: {
+        $set: { owner: null, holder: null, leaseExpiresAt: null, inFlight: [] },
+        $inc: { revision: 1 }
+      }
+    }
+  };
+}
+
+// src/mongo-ordering.ts
+var MINIMUM_CANDIDATE_BATCH_SIZE = 32;
+var PARK_UPDATE_CHUNK_SIZE = 1e3;
+var MongoOrdering = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
   /**
    * Adds the claimable candidates of `lanes` to `picked`, in due order, until
    * `request.limit` is reached. A delivery is a candidate when it is ready, due
@@ -1242,46 +1299,18 @@ var MongoEventStore = class {
    * the predecessors of the keys of a page are looked up in parallel, one
    * lookup per key.
    */
-  async #pickCandidates(lanes, request, scan, running, picked) {
+  async pickCandidates(input) {
+    const { lanes, request, scan, running, picked } = input;
     const pageSize = Math.max((request.limit - picked.length) * 2, MINIMUM_CANDIDATE_BATCH_SIZE);
-    const filter = {
-      laneId: { $in: lanes.map((lane) => lane.laneId) },
-      handler: { $in: [...request.handlers] },
-      lane: "ready",
-      dueAt: { $lte: request.now },
-      _id: { $nin: lanes.flatMap((lane) => lane.listed) }
-    };
+    const filter = candidateFilter(lanes, request);
     let after;
     for (; ; ) {
       const [page, { keys }] = await Promise.all([
-        this.#deliveries.find(
-          after === void 0 ? filter : {
-            $and: [
-              filter,
-              {
-                $or: [
-                  { dueAt: { $gt: after.dueAt } },
-                  { dueAt: after.dueAt, _id: { $gt: after._id } }
-                ]
-              }
-            ]
-          },
-          { sort: { dueAt: 1, _id: 1 }, limit: pageSize }
-        ).toArray(),
+        this.#state.deliveries.find(pageAfter(filter, after), { sort: { dueAt: 1, _id: 1 }, limit: pageSize }).toArray(),
         running
       ]);
-      for (let offset = 0; offset < page.length; ) {
-        const slice = page.slice(offset, offset + request.limit - picked.length);
-        offset += slice.length;
-        await this.#notePredecessors(slice, scan);
-        for (const candidate of slice) {
-          if (isClaimable(candidate, scan, keys)) {
-            picked.push(candidate);
-          }
-        }
-        if (picked.length >= request.limit) {
-          return;
-        }
+      if (await this.#pickFromPage(page, { request, scan, picked, keys })) {
+        return;
       }
       if (page.length < pageSize) {
         return;
@@ -1289,6 +1318,27 @@ var MongoEventStore = class {
       after = page.at(-1);
     }
   }
+  /**
+   * Adds the claimable candidates of `page` to `picked`. Looks up predecessors only for as many
+   * candidates as the claim still needs, then more. True once the claim has `request.limit` picks.
+   */
+  async #pickFromPage(page, claim) {
+    const { request, scan, picked, keys } = claim;
+    for (let offset = 0; offset < page.length; ) {
+      const slice = page.slice(offset, offset + request.limit - picked.length);
+      offset += slice.length;
+      await this.#notePredecessors(slice, scan);
+      for (const candidate of slice) {
+        if (isClaimable(candidate, { scan, blockedKeys: keys })) {
+          picked.push(candidate);
+        }
+      }
+      if (picked.length >= request.limit) {
+        return true;
+      }
+    }
+    return false;
+  }
   /**
    * Looks up, in parallel and once per key, whether an unfinished delivery
    * precedes the earliest candidate of each keyed (handler, key) of `page` that
@@ -1308,181 +1358,45 @@ var MongoEventStore = class {
     }
     await Promise.all(
       [...earliest].map(async ([orderingId, candidate]) => {
-        const predecessor = await this.#findUnfinishedPredecessor(
-          candidate.handler,
-          candidate.key,
-          candidate.sequence
-        );
+        const predecessor = await this.#findUnfinishedPredecessor(candidate.handler, {
+          key: candidate.key,
+          sequence: candidate.sequence
+        });
         scan.noteOpen(orderingId, predecessor ?? candidate.sequence);
       })
     );
   }
   /**
-   * Records the picks in their lanes, one conditional write per lane and one
-   * round trip for all of them, and frees the lanes that yielded nothing and run
-   * nothing. A picked lane lists its running deliveries plus the new ones (ids
-   * whose documents are gone are pruned) and its lease reaches
-   * `request.leaseExpiresAt`. Returns the lanes whose picks were recorded: every
-   * write is conditional on the claim's epoch, owner and store instance, so a
-   * lane that changed hands, or was handed back by `relinquish`, in the meantime
-   * keeps its deliveries for whoever takes it next.
+   * Parks the waiting backlogs a claim found. Best effort: parking only saves
+   * later claims work, so a failure is logged and the claim still returns its
+   * batch; the next claim that meets the backlog parks it.
    */
-  async #recordClaim(scope, picked, runningIds, request) {
-    const picksByLane = /* @__PURE__ */ new Map();
-    const handedBack = /* @__PURE__ */ new Set();
-    for (const document of picked) {
-      picksByLane.set(document.laneId, [...picksByLane.get(document.laneId) ?? [], document._id]);
-    }
-    const operations = [];
-    for (const lane of scope.values()) {
-      const gone = lane.listed.filter((id) => !runningIds.has(id));
-      const ids = picksByLane.get(lane.laneId);
-      if (ids !== void 0) {
-        operations.push({
-          updateOne: {
-            filter: {
-              _id: lane.laneId,
-              epoch: lane.epoch,
-              owner: request.leaseOwner,
-              holder: this.#instanceId,
-              // A record that reaches the server late (after its claim failed and reconciled)
-              // finds a newer revision and changes nothing.
-              revision: atCount(lane.revision)
-            },
-            update: [
-              {
-                $set: {
-                  inFlight: {
-                    $concatArrays: [
-                      {
-                        $filter: {
-                          input: "$inFlight",
-                          cond: { $not: [{ $in: ["$$this", { $literal: gone }] }] }
-                        }
-                      },
-                      { $literal: ids }
-                    ]
-                  },
-                  leaseExpiresAt: { $max: ["$leaseExpiresAt", request.leaseExpiresAt] },
-                  revision: { $add: [{ $ifNull: ["$revision", 0] }, 1] }
-                }
-              }
-            ]
-          }
-        });
-      } else if (gone.length === lane.listed.length) {
-        operations.push(freeLane(lane.laneId, lane.epoch, lane.revision, gone));
-        handedBack.add(lane.laneId);
-      }
-    }
-    if (operations.length === 0) {
-      return { recorded: /* @__PURE__ */ new Set(), handedBack };
-    }
-    const result = await this.#lanes.bulkWrite(operations, { ordered: false });
-    if (result.matchedCount === operations.length) {
-      return { recorded: new Set(picksByLane.keys()), handedBack };
+  async parkWaiting(deliveryIds) {
+    try {
+      await this.#parkDeliveries(deliveryIds);
+    } catch (error) {
+      this.#state.logger.warn(
+        `[MongoOrdering](parkWaiting) Parking waiting deliveries failed, a later claim parks them | count=${deliveryIds.length} | error=${String(error)}`
+      );
     }
-    const current = await this.#lanes.find(
-      { _id: { $in: [...picksByLane.keys()] } },
-      { projection: { epoch: 1, owner: 1, holder: 1, revision: 1 } }
-    ).toArray();
-    const recorded = new Set(
-      current.filter(
-        (lane) => lane.epoch === scope.get(lane._id).epoch && lane.revision === scope.get(lane._id).revision + 1 && lane.owner === request.leaseOwner && lane.holder === this.#instanceId
-      ).map((lane) => lane._id)
+  }
+  /** Sequence of the lowest unfinished delivery of the handler and key before `sequence`, if any. */
+  async #findUnfinishedPredecessor(handler, { key, sequence }) {
+    const predecessor = await this.#state.deliveries.findOne(
+      { handler, key, sequence: { $lt: sequence }, dueAt: { $exists: true } },
+      { sort: { sequence: 1 }, projection: { sequence: 1 } }
     );
-    return { recorded, handedBack };
+    return predecessor?.sequence;
   }
   /**
-   * Gives back the recorded keyed picks that a delivery requeued during the
-   * claim now precedes, without charging an attempt, and returns the rest. The
-   * claim checked their predecessors before recording them; a dead letter
-   * requeued in between would otherwise wait behind its own successor. Once a
-   * pick is recorded, a later requeue waits for it like for any running delivery.
-   */
-  async #releaseOvertaken(claimed, scope) {
-    const keyed = claimed.filter((document) => document.key !== void 0);
-    if (keyed.length === 0) {
-      return [...claimed];
-    }
-    const blockers = await this.#deliveries.find(
-      {
-        $or: keyed.map((document) => ({
-          handler: document.handler,
-          key: document.key,
-          sequence: { $lt: document.sequence },
-          dueAt: { $exists: true }
-        }))
-      },
-      { projection: { handler: 1, key: 1 } }
-    ).toArray();
-    const blocked = new Set(
-      blockers.map((blocker) => orderingIdentity(blocker.handler, blocker.key))
-    );
-    const overtaken = new Set(
-      keyed.filter((document) => blocked.has(orderingIdentity(document.handler, document.key))).map((document) => document._id)
-    );
-    if (overtaken.size === 0) {
-      return [...claimed];
-    }
-    await this.#releasePicks(
-      claimed.filter((document) => overtaken.has(document._id)),
-      scope
-    );
-    return claimed.filter((document) => !overtaken.has(document._id));
-  }
-  /** Takes recorded picks out of their lanes' in-flight lists again, under the claim's epochs and record revisions. */
-  async #releasePicks(documents, scope) {
-    const idsByLane = /* @__PURE__ */ new Map();
-    for (const document of documents) {
-      idsByLane.set(document.laneId, [...idsByLane.get(document.laneId) ?? [], document._id]);
-    }
-    await Promise.all(
-      [...idsByLane].map(
-        ([laneId, ids]) => this.#lanes.updateOne(
-          // Under the revision the record left: a pull that reaches the server late, after a
-          // reconciliation and a newer claim of the same delivery, matches nothing.
-          {
-            _id: laneId,
-            epoch: scope.get(laneId).epoch,
-            revision: scope.get(laneId).revision + 1
-          },
-          { $pull: { inFlight: { $in: ids } } }
-        )
-      )
-    );
-  }
-  /**
-   * Parks the waiting backlogs a claim found. Best effort: parking only saves
-   * later claims work, so a failure is logged and the claim still returns its
-   * batch; the next claim that meets the backlog parks it.
-   */
-  async #parkWaiting(deliveryIds) {
-    try {
-      await this.#parkDeliveries(deliveryIds);
-    } catch (error) {
-      this.#logger.warn(
-        `[MongoEventStore](parkWaiting) Parking waiting deliveries failed, a later claim parks them | count=${deliveryIds.length} | error=${String(error)}`
-      );
-    }
-  }
-  /** Sequence of the lowest unfinished delivery of the handler and key before `sequence`, if any. */
-  async #findUnfinishedPredecessor(handler, key, sequence) {
-    const predecessor = await this.#deliveries.findOne(
-      { handler, key, sequence: { $lt: sequence }, dueAt: { $exists: true } },
-      { sort: { sequence: 1 }, projection: { sequence: 1 } }
-    );
-    return predecessor?.sequence;
-  }
-  /**
-   * Parks pending deliveries that waited behind an unfinished predecessor, which
-   * removes them from the claim index until their turn. Parking is a hint, not a
-   * guarantee: a predecessor that finishes meanwhile is found by the next
-   * {@link MongoEventStore.claim}, which moves the lowest parked delivery back.
+   * Parks pending deliveries that waited behind an unfinished predecessor, which
+   * removes them from the claim index until their turn. Parking is a hint, not a
+   * guarantee: a predecessor that finishes meanwhile is found by the next
+   * {@link MongoEventStore.claim}, which moves the lowest parked delivery back.
    */
   async #parkDeliveries(deliveryIds) {
     for (let offset = 0; offset < deliveryIds.length; offset += PARK_UPDATE_CHUNK_SIZE) {
-      await this.#deliveries.updateMany(
+      await this.#state.deliveries.updateMany(
         {
           _id: { $in: deliveryIds.slice(offset, offset + PARK_UPDATE_CHUNK_SIZE) },
           status: "pending",
@@ -1499,8 +1413,8 @@ var MongoEventStore = class {
    * predecessor finishing while its followers were being parked, can delay a key
    * until the next claim but never strand it.
    */
-  async #unparkNextDeliveries(handlers) {
-    const anyParked = await this.#deliveries.findOne(
+  async unparkNextDeliveries(handlers) {
+    const anyParked = await this.#state.deliveries.findOne(
       { handler: { $in: [...handlers] }, lane: "parked" },
       // The sort lets the planner pick the small partial index over the handler's whole history.
       { sort: { handler: 1, key: 1, sequence: 1 }, projection: { _id: 1 } }
@@ -1508,180 +1422,131 @@ var MongoEventStore = class {
     if (anyParked === null) {
       return;
     }
-    const lowest = (await Promise.all(
-      [...new Set(handlers)].map(
-        (handler) => this.#deliveries.aggregate([
-          { $match: { handler, lane: "parked" } },
-          { $sort: { handler: 1, key: 1, sequence: 1 } },
-          {
-            $group: { _id: "$key", id: { $first: "$_id" }, sequence: { $first: "$sequence" } }
-          }
-        ]).toArray().then((groups) => groups.map((group) => ({ ...group, handler })))
-      )
-    )).flat();
+    const lowest = await this.#lowestParkedPerKey(handlers);
     const next = await Promise.all(
       lowest.map(
-        async (parked) => await this.#findUnfinishedPredecessor(parked.handler, parked._id, parked.sequence) === void 0 ? [parked.id] : []
+        async (parked) => await this.#findUnfinishedPredecessor(parked.handler, {
+          key: parked._id,
+          sequence: parked.sequence
+        }) === void 0 ? [parked.id] : []
       )
     );
     const ready = next.flat();
     if (ready.length > 0) {
-      await this.#deliveries.updateMany(
+      await this.#state.deliveries.updateMany(
         { _id: { $in: ready }, lane: "parked" },
         { $set: { lane: "ready" } }
       );
     }
   }
-  async #readEnvelopes(eventIds) {
-    const documents = await this.#events.find({ _id: { $in: [...new Set(eventIds)] } }).toArray();
-    return new Map(documents.map((document) => [document._id, toEnvelope(document)]));
-  }
   /**
-   * Deletes the delivery of every lease whose lane still has the lease's epoch
-   * and lists the delivery, in one transaction (the caller's, when given).
-   * Returns one flag per lease, in order; a lease listed twice completes once.
+   * The lowest parked delivery of every parked key of `handlers`, one aggregation per handler in
+   * parallel.
    */
-  async #completeLeases(leases, now, session) {
-    return session === void 0 ? this.#settle(leases, () => this.#completeIssued(leases, now, void 0)) : this.#completeIssued(leases, now, session);
+  async #lowestParkedPerKey(handlers) {
+    return (await Promise.all(
+      [...new Set(handlers)].map(
+        (handler) => this.#state.deliveries.aggregate([
+          { $match: { handler, lane: "parked" } },
+          { $sort: { handler: 1, key: 1, sequence: 1 } },
+          {
+            $group: { _id: "$key", id: { $first: "$_id" }, sequence: { $first: "$sequence" } }
+          }
+        ]).toArray().then((groups) => groups.map((group) => ({ ...group, handler })))
+      )
+    )).flat();
   }
-  async #completeIssued(leases, now, session) {
-    const parsed = leases.map((lease) => parseLeaseToken(lease.leaseToken));
-    const issued = leases.flatMap(
-      (lease, index) => parsed[index] === void 0 ? [] : [{ deliveryId: String(lease.deliveryId), ...parsed[index] }]
-    );
-    let completed = /* @__PURE__ */ new Set();
-    if (issued.length > 0) {
-      if (session !== void 0) {
-        completed = await this.#deleteCompleted(issued, now, session);
-      } else if (this.#completionHistory) {
-        completed = await this.transaction((own) => this.#deleteCompleted(issued, now, own));
-      } else {
-        completed = await this.#deleteFenced(issued, now);
+};
+function candidateFilter(lanes, request) {
+  return {
+    laneId: { $in: lanes.map((lane) => lane.laneId) },
+    handler: { $in: [...request.handlers] },
+    lane: "ready",
+    dueAt: { $lte: request.now },
+    _id: { $nin: lanes.flatMap((lane) => lane.listed) }
+  };
+}
+function pageAfter(filter, after) {
+  return after === void 0 ? filter : {
+    $and: [
+      filter,
+      {
+        $or: [
+          { dueAt: { $gt: after.dueAt } },
+          { dueAt: after.dueAt, _id: { $gt: after._id } }
+        ]
       }
-    }
-    return leases.map(
-      (lease, index) => parsed[index] !== void 0 && completed.delete(leaseIdentity({ deliveryId: String(lease.deliveryId), ...parsed[index] }))
-    );
+    ]
+  };
+}
+function isClaimable(candidate, { scan, blockedKeys }) {
+  const { key, sequence } = candidate;
+  if (key === void 0) {
+    return true;
   }
-  /**
-   * Completion without a transaction, used when no history record has to be
-   * written with the deletion. The deliveries' claim generations are read
-   * first, then the lanes, and a delivery is deleted only if it still has the
-   * lease's generation. A takeover moves the generation of every delivery it
-   * takes from the previous owner on before it reads anything, and so do a
-   * retry, a release and a burial, so:
-   * - a takeover before the delivery read shows up in the lane read (new epoch);
-   * - a takeover between the two reads shows up in the lane read as well;
-   * - a takeover, retry, release or burial after the lane read changed the
-   *   generation, so the delete matches nothing.
-   * A completion and a takeover (or the end of the claim) therefore never both succeed. Two concurrent
-   * completions of the same lease may both report true (the dispatcher never
-   * issues them); one call with a lease listed twice reports it once.
-   */
-  async #deleteFenced(issued, now) {
-    const ids = [...new Set(issued.map((lease) => lease.deliveryId))];
-    const documents = await this.#deliveries.find({ _id: { $in: ids }, status: "pending" }, { projection: { claims: 1, eventId: 1 } }).toArray();
-    const lanes = new Map(
-      (await this.#lanes.find(
-        { _id: { $in: [...new Set(issued.map((lease) => lease.laneId))] } },
-        { projection: { epoch: 1, inFlight: 1 } }
-      ).toArray()).map((lane) => [lane._id, lane])
-    );
-    const fenced = fencedLeases(issued, lanes, documents);
-    if (fenced.length === 0) {
-      return /* @__PURE__ */ new Set();
-    }
-    await this.#markEventsCompleted(fenced, documents, now);
-    const deleted = await this.#deliveries.deleteMany({ $or: fenced.map(ofClaim) });
-    return deleted.deletedCount === fenced.length ? new Set(fenced.map((lease) => leaseIdentity(lease))) : /* @__PURE__ */ new Set();
+  const orderingId = orderingIdentity(candidate.handler, key);
+  if (scan.waits(orderingId, sequence)) {
+    scan.noteWaiting(orderingId, { deliveryId: candidate._id, laneId: candidate.laneId });
+    return false;
   }
-  /**
-   * The transactional part of a completion. The lanes are only read: the
-   * conflict with a takeover comes from the deleted delivery documents, which a
-   * takeover writes before it reads them (see {@link MongoEventStore.#takeLanes}).
-   * So whichever of the two commits second either fails with a write conflict
-   * and is retried against the new state, or waits for the first.
-   */
-  async #deleteCompleted(issued, now, session) {
-    const lanes = new Map(
-      (await this.#lanes.find(
-        { _id: { $in: [...new Set(issued.map((lease) => lease.laneId))] } },
-        { session, projection: { epoch: 1, inFlight: 1 } }
-      ).toArray()).map((lane) => [lane._id, lane])
-    );
-    const documents = await this.#deliveries.find(
-      { _id: { $in: [...new Set(issued.map((lease) => lease.deliveryId))] }, status: "pending" },
-      { session }
-    ).toArray();
-    const fenced = fencedLeases(issued, lanes, documents);
-    if (fenced.length === 0) {
-      return /* @__PURE__ */ new Set();
-    }
-    await this.#markEventsCompleted(fenced, documents, now, session);
-    await this.#deliveries.deleteMany({ $or: fenced.map(ofClaim) }, { session });
-    if (this.#completionHistory) {
-      const completedIds = new Set(fenced.map((lease) => lease.deliveryId));
-      await this.#completions.insertMany(
-        documents.filter((document) => completedIds.has(document._id)).map((document) => toCompletedDeliveryDocument(document, now)),
-        { session }
-      );
-    }
-    return new Set(fenced.map((lease) => leaseIdentity(lease)));
+  if (blockedKeys.has(orderingId)) {
+    return false;
   }
-  /**
-   * Records `now` as the latest completion of the events of the fenced
-   * deliveries (`$max`, so an earlier clock never moves it back). Written
-   * before the deletion, it can only be later than the real last completion
-   * (when the deletion then fails), which keeps the event longer, never shorter.
-   * Inside a transaction it is part of it: the transaction may hold the event
-   * already (a transactional handler that appended to its own event), and a
-   * write from outside would wait for it forever. Deliveries of one event that
-   * complete in concurrent transactions (fan-out to transactional handlers)
-   * therefore conflict on the event document, and one of them retries.
-   */
-  async #markEventsCompleted(fenced, documents, now, session) {
-    const completedIds = new Set(fenced.map((lease) => lease.deliveryId));
-    const eventIds = [
-      ...new Set(
-        documents.filter((document) => completedIds.has(document._id)).map((document) => document.eventId)
-      )
-    ];
-    await this.#events.updateMany(
-      { _id: { $in: eventIds } },
-      { $max: { completedAt: now } },
-      session === void 0 ? {} : { session }
-    );
+  blockedKeys.add(orderingId);
+  return true;
+}
+
+// src/mongo-purge.ts
+var MongoPurge = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
   }
-  /**
-   * Applies `update` to a running delivery and takes it out of its lane's
-   * in-flight list, if the lane still has the lease's epoch. One transaction:
-   * the lane write fences the change against a takeover.
-   */
-  async #leaveFlight(lease, update) {
-    const held = parseLeaseToken(lease.leaseToken);
-    if (held === void 0) {
-      return false;
+  /** Implements {@link MongoEventStore.purge}. */
+  async purge(request) {
+    const total = { deletedDeliveries: 0, deletedEvents: 0 };
+    const steps = this.#purgeSteps(request);
+    const { completedBefore, deadBefore } = request;
+    for (const step of steps) {
+      const result = await step();
+      total.deletedDeliveries += result.deletedDeliveries;
+      total.deletedEvents += result.deletedEvents;
     }
-    const deliveryId = String(lease.deliveryId);
-    const ofThisClaim = ofClaim({ ...held, deliveryId });
-    return this.#settle([lease], () => this.#leaveFlightNow(held, deliveryId, ofThisClaim, update));
+    const orphanCutoff = [completedBefore, deadBefore].filter((cutoff) => cutoff !== void 0).sort((first, second) => first.getTime() - second.getTime())[0];
+    if (orphanCutoff !== void 0) {
+      total.deletedEvents += await this.#purgeOrphanEvents(orphanCutoff, completedBefore);
+    }
+    return total;
   }
-  async #leaveFlightNow(held, deliveryId, ofThisClaim, update) {
-    return this.transaction(async (session) => {
-      if (await this.#deliveries.findOne(ofThisClaim, { session, projection: { _id: 1 } }) === null) {
-        return false;
-      }
-      const fence = await this.#lanes.updateOne(
-        { _id: held.laneId, epoch: held.epoch, inFlight: deliveryId },
-        { $pull: { inFlight: deliveryId } },
-        { session }
+  /** The purges the request asks for, in the order they run. */
+  #purgeSteps(request) {
+    const steps = [];
+    const { completedBefore, deadBefore } = request;
+    if (completedBefore !== void 0) {
+      steps.push(
+        () => this.#purgeMatching(this.#purgeable(this.#state.deliveries.collectionName), {
+          filter: { status: "completed", completedAt: { $lt: completedBefore } },
+          completedBefore
+        })
       );
-      if (fence.matchedCount === 0) {
-        return false;
+      if (this.#state.completionHistory) {
+        steps.push(
+          () => this.#purgeMatching(this.#purgeable(this.#state.completions.collectionName), {
+            filter: { completedAt: { $lt: completedBefore } },
+            completedBefore
+          })
+        );
       }
-      const changed = await this.#deliveries.updateOne(ofThisClaim, update, { session });
-      return changed.matchedCount === 1;
-    });
+    }
+    if (deadBefore !== void 0) {
+      steps.push(
+        () => this.#purgeMatching(this.#purgeable(this.#state.deliveries.collectionName), {
+          filter: { status: "dead", updatedAt: { $lt: deadBefore } },
+          completedBefore
+        })
+      );
+    }
+    return steps;
   }
   /**
    * Deletes batches of matching documents (deliveries, or completion history
@@ -1692,49 +1557,61 @@ var MongoEventStore = class {
    * without event. A delivery requeued since the batch was read conflicts with
    * its deletion and is read again.
    */
-  async #purgeMatching(collection, filter, completedBefore) {
+  async #purgeMatching(collection, {
+    filter,
+    completedBefore
+  }) {
     let deletedDeliveries = 0;
     let deletedEvents = 0;
     for (; ; ) {
-      const step = await this.transaction(async (session) => {
-        const batch = await collection.find(filter, { session, projection: { eventId: 1 }, limit: this.#purgeBatchSize }).toArray();
-        if (batch.length === 0) {
-          return { batchSize: 0, deletedDeliveries: 0, deletedEvents: 0 };
-        }
-        const eventIds = [...new Set(batch.map((document) => document.eventId))];
-        const deleted = await collection.deleteMany(
-          { _id: { $in: batch.map((document) => document._id) } },
-          { session }
-        );
-        const stillReferenced = await this.#referencedEventIds(eventIds, session);
-        const events = await this.#events.deleteMany(
-          {
-            _id: { $in: eventIds.filter((eventId) => !stillReferenced.has(eventId)) },
-            // An event a delivery of which completed stays as deduplication record until
-            // `completedBefore` passes its last completion, whatever this batch purged.
-            $or: [
-              { completedAt: { $exists: false } },
-              ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
-            ]
-          },
-          { session }
-        );
-        return {
-          batchSize: batch.length,
-          deletedDeliveries: deleted.deletedCount,
-          deletedEvents: events.deletedCount
-        };
-      });
+      const step = await runInTransaction(
+        this.#state,
+        (session) => this.#purgeBatch(collection, { filter, completedBefore, session })
+      );
       deletedDeliveries += step.deletedDeliveries;
       deletedEvents += step.deletedEvents;
-      if (step.batchSize < this.#purgeBatchSize) {
+      if (step.batchSize < this.#state.purgeBatchSize) {
         return { deletedDeliveries, deletedEvents };
       }
     }
   }
+  /** One batch of {@link MongoPurge.#purgeMatching}, inside the caller's transaction. */
+  async #purgeBatch(collection, {
+    filter,
+    completedBefore,
+    session
+  }) {
+    const batch = await collection.find(filter, { session, projection: { eventId: 1 }, limit: this.#state.purgeBatchSize }).toArray();
+    if (batch.length === 0) {
+      return { batchSize: 0, deletedDeliveries: 0, deletedEvents: 0 };
+    }
+    const eventIds = [...new Set(batch.map((document) => document.eventId))];
+    const deleted = await collection.deleteMany(
+      { _id: { $in: batch.map((document) => document._id) } },
+      { session }
+    );
+    const stillReferenced = await this.#referencedEventIds(eventIds, session);
+    const events = await this.#state.events.deleteMany(
+      {
+        _id: { $in: eventIds.filter((eventId) => !stillReferenced.has(eventId)) },
+        // An event a delivery of which completed stays as deduplication record until
+        // `completedBefore` passes its last completion, whatever this batch purged.
+        $or: [
+          { completedAt: { $exists: false } },
+          ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
+        ]
+      },
+      { session }
+    );
+    return {
+      batchSize: batch.length,
+      deletedDeliveries: deleted.deletedCount,
+      deletedEvents: events.deletedCount
+    };
+  }
   /** A view of a collection that purge deletes from: deliveries or completion history records. */
   #purgeable(name) {
-    return this.#database.collection(name, {
+    return this.#state.database.collection(name, {
       readPreference: "primary",
       writeConcern: { w: "majority" }
     });
@@ -1744,8 +1621,8 @@ var MongoEventStore = class {
     const filter = { eventId: { $in: [...eventIds] } };
     const options = { session, projection: { eventId: 1 } };
     const references = [
-      ...await this.#deliveries.find(filter, options).toArray(),
-      ...this.#completionHistory ? await this.#completions.find(filter, options).toArray() : []
+      ...await this.#state.deliveries.find(filter, options).toArray(),
+      ...this.#state.completionHistory ? await this.#state.completions.find(filter, options).toArray() : []
     ];
     return new Set(references.map((reference) => reference.eventId));
   }
@@ -1758,87 +1635,426 @@ var MongoEventStore = class {
    */
   async #purgeOrphanEvents(cutoff, completedBefore) {
     const references = [
-      this.#deliveries.collectionName,
-      ...this.#completionHistory ? [this.#completions.collectionName] : []
+      this.#state.deliveries.collectionName,
+      ...this.#state.completionHistory ? [this.#state.completions.collectionName] : []
     ];
     let deletedEvents = 0;
     for (; ; ) {
-      const step = await this.transaction(async (session) => {
-        const orphans = await this.#events.aggregate(
-          [
-            {
-              $match: {
-                $or: [
-                  // Never completed (no subscribers, or every delivery dead): by age.
-                  { completedAt: { $exists: false }, createdAt: { $lt: cutoff } },
-                  // Completed: by the time of its last completion, and only under the completed cutoff.
-                  ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
-                ]
-              }
-            },
-            { $sort: { createdAt: 1, _id: 1 } },
-            ...references.flatMap((from) => [
-              {
-                $lookup: {
-                  from,
-                  localField: "_id",
-                  foreignField: "eventId",
-                  pipeline: [{ $limit: 1 }, { $project: { _id: 1 } }],
-                  as: "references"
-                }
-              },
-              { $match: { references: { $size: 0 } } }
-            ]),
-            { $limit: this.#purgeBatchSize },
-            { $project: { _id: 1 } }
-          ],
+      const step = await runInTransaction(this.#state, async (session) => {
+        const orphans = await this.#state.events.aggregate(
+          orphanPipeline({
+            cutoff,
+            completedBefore,
+            references,
+            limit: this.#state.purgeBatchSize
+          }),
           { session }
         ).toArray();
-        const deleted = await this.#events.deleteMany(
+        const deleted = await this.#state.events.deleteMany(
           { _id: { $in: orphans.map((orphan) => orphan._id) } },
           { session }
         );
         return { found: orphans.length, deleted: deleted.deletedCount };
       });
       deletedEvents += step.deleted;
-      if (step.found < this.#purgeBatchSize) {
+      if (step.found < this.#state.purgeBatchSize) {
         return deletedEvents;
       }
     }
   }
 };
-function isClaimable(candidate, scan, blockedKeys) {
-  const { key, sequence } = candidate;
-  if (key === void 0) {
-    return true;
+function orphanPipeline(input) {
+  const { cutoff, completedBefore, references, limit } = input;
+  return [
+    {
+      $match: {
+        $or: [
+          // Never completed (no subscribers, or every delivery dead): by age.
+          { completedAt: { $exists: false }, createdAt: { $lt: cutoff } },
+          // Completed: by the time of its last completion, and only under the completed cutoff.
+          ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
+        ]
+      }
+    },
+    { $sort: { createdAt: 1, _id: 1 } },
+    ...references.flatMap((from) => [
+      {
+        $lookup: {
+          from,
+          localField: "_id",
+          foreignField: "eventId",
+          pipeline: [{ $limit: 1 }, { $project: { _id: 1 } }],
+          as: "references"
+        }
+      },
+      { $match: { references: { $size: 0 } } }
+    ]),
+    { $limit: limit },
+    { $project: { _id: 1 } }
+  ];
+}
+
+// src/mongo-queries.ts
+var DEFAULT_LIST_LIMIT = 100;
+var MongoQueries = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
   }
-  const orderingId = orderingIdentity(candidate.handler, key);
-  if (scan.waits(orderingId, sequence)) {
-    scan.noteWaiting(orderingId, candidate._id, candidate.laneId);
-    return false;
+  /** Implements {@link MongoEventStore.listDeliveries}. */
+  async listDeliveries(query) {
+    const status = query.status === void 0 ? void 0 : String(query.status);
+    const common = commonFilter(query);
+    const limit = query.limit ?? DEFAULT_LIST_LIMIT;
+    const lanes = await this.#state.lanes.find({ "inFlight.0": { $exists: true } }, { projection: { epoch: 0 } }).toArray();
+    const listed = lanes.flatMap((lane) => lane.inFlight);
+    const filter = { ...common, ...statusFilter(status, listed) };
+    const sort = { createdAt: 1, _id: 1 };
+    const documents = await this.#state.deliveries.find(filter, { sort, limit }).toArray();
+    const history = this.#state.completionHistory && (status === void 0 || status === "completed") ? await this.#state.completions.find(common, { sort, limit }).toArray() : [];
+    const events = await this.readEnvelopes([
+      ...documents.map((document) => document.eventId),
+      ...history.map((document) => document.eventId)
+    ]);
+    return toSortedRecords({ documents, history, events, lanes }).slice(0, limit);
   }
-  if (blockedKeys.has(orderingId)) {
-    return false;
+  /** Implements {@link MongoEventStore.requeue}. */
+  async requeue(deliveryIds, now) {
+    const result = await this.#state.deliveries.updateMany(
+      { _id: { $in: deliveryIds.map(String) }, status: "dead" },
+      {
+        $set: {
+          status: "pending",
+          lane: "ready",
+          attempts: 0,
+          availableAt: now,
+          dueAt: now,
+          updatedAt: now
+        }
+      }
+    );
+    return result.modifiedCount;
   }
-  blockedKeys.add(orderingId);
-  return true;
+  /** Implements {@link MongoEventStore.statistics}. */
+  async statistics(now) {
+    const lanes = await this.#state.lanes.find({ "inFlight.0": { $exists: true } }, { projection: { inFlight: 1, leaseExpiresAt: 1 } }).toArray();
+    const [stored, dead, legacyCompleted, history, running] = await Promise.all([
+      this.#state.deliveries.countDocuments({ status: "pending" }),
+      this.#state.deliveries.countDocuments({ status: "dead" }),
+      this.#state.deliveries.countDocuments({ status: "completed" }),
+      this.#state.completionHistory ? this.#state.completions.countDocuments() : Promise.resolve(0),
+      this.findRunning(lanes.flatMap((lane) => lane.inFlight))
+    ]);
+    const runningIds = new Set(running.map((document) => document._id));
+    const waiting = await this.#state.deliveries.findOne(
+      { dueAt: { $lte: now }, _id: { $nin: [...runningIds] } },
+      { sort: { dueAt: 1 }, projection: { dueAt: 1 } }
+    );
+    const dueTimes = lanes.filter(
+      (lane) => lane.leaseExpiresAt !== null && lane.leaseExpiresAt <= now && lane.inFlight.some((id) => runningIds.has(id))
+    ).map((lane) => lane.leaseExpiresAt.getTime());
+    if (waiting !== null) {
+      dueTimes.push(waiting.dueAt.getTime());
+    }
+    return {
+      // The counts are separate reads; a completion between them must not make this negative.
+      pending: Math.max(0, stored - running.length),
+      processing: running.length,
+      completed: legacyCompleted + history,
+      dead,
+      oldestDueAt: dueTimes.length === 0 ? null : new Date(Math.min(...dueTimes))
+    };
+  }
+  /** The listed deliveries that run: those whose document still exists as pending. */
+  async findRunning(listed) {
+    if (listed.length === 0) {
+      return [];
+    }
+    return this.#state.deliveries.find(
+      { _id: { $in: listed }, status: "pending" },
+      { projection: { handler: 1, key: 1, laneId: 1 } }
+    ).toArray();
+  }
+  async readEnvelopes(eventIds) {
+    const documents = await this.#state.events.find({ _id: { $in: [...new Set(eventIds)] } }).toArray();
+    return new Map(documents.map((document) => [document._id, toEnvelope(document)]));
+  }
+};
+function statusFilter(status, listed) {
+  if (status === void 0) {
+    return {};
+  }
+  const derivedStatuses = /* @__PURE__ */ new Map([
+    ["processing", { status: "pending", _id: { $in: listed } }],
+    ["pending", { status: "pending", _id: { $nin: listed } }]
+  ]);
+  return derivedStatuses.get(status) ?? { status };
+}
+function toSortedRecords(input) {
+  const { documents, history, events, lanes } = input;
+  const laneById = new Map(lanes.map((lane) => [lane._id, lane]));
+  const records = [
+    ...documents.map((document) => {
+      const lane = laneById.get(document.laneId);
+      const runs = document.status === "pending" && lane?.inFlight.includes(document._id) === true;
+      return toDeliveryRecord(document, {
+        event: events.get(document.eventId),
+        runningIn: runs ? lane : void 0
+      });
+    }),
+    ...history.map(
+      (document) => toCompletedDeliveryRecord(document, events.get(document.eventId))
+    )
+  ];
+  return records.sort(
+    (left, right) => left.createdAt.getTime() - right.createdAt.getTime() || compareText(left.id, right.id)
+  );
+}
+function compareText(left, right) {
+  return Number(left > right) - Number(left < right);
 }
-function freeLane(laneId, epoch, revision, finished) {
+function commonFilter(query) {
   return {
-    updateOne: {
-      filter: {
-        _id: laneId,
-        epoch,
-        revision: atCount(revision),
-        inFlight: { $not: { $elemMatch: { $nin: [...finished] } } }
+    ...query.handler === void 0 ? {} : { handler: String(query.handler) },
+    ...query.eventType === void 0 ? {} : { eventType: String(query.eventType) },
+    ...query.eventId === void 0 ? {} : { eventId: String(query.eventId) }
+  };
+}
+
+// src/mongo-schema.ts
+var NAMESPACE_EXISTS = 48;
+var INDEX_NOT_FOUND = 27;
+var UPGRADE_BATCH_SIZE = 1e3;
+var CLAIM_INDEX_KEY = { laneId: 1, dueAt: 1, _id: 1, handler: 1 };
+var OBSOLETE_INDEXES = ["running"];
+var LEASE_FIELDS = { leaseOwner: "", leaseToken: "", leaseExpiresAt: "" };
+var MongoSchema = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Implements {@link MongoEventStore.setup}. */
+  async setup() {
+    const hello = await this.#state.client.db("admin").command({ hello: 1 });
+    const supportsTransactions = typeof hello["setName"] === "string" || hello["msg"] === "isdbgrid";
+    if (!supportsTransactions) {
+      throw createTransactionsUnsupportedError(void 0);
+    }
+    const collectionNames = [
+      this.#state.events.collectionName,
+      this.#state.deliveries.collectionName,
+      this.#state.keySequences.collectionName,
+      this.#state.lanes.collectionName,
+      ...this.#state.completionHistory ? [this.#state.completions.collectionName] : []
+    ];
+    for (const name of collectionNames) {
+      await this.#createCollectionIfMissing(name);
+    }
+    if (await this.#state.lanes.countDocuments() < LANE_COUNT) {
+      await this.#upgradeFromVersion010();
+      await this.#seedLanes();
+    }
+    await this.#dropObsoleteIndexes();
+    await this.#createIndexes();
+  }
+  /** Creates the indexes of every collection; existing indexes are left as they are. */
+  async #createIndexes() {
+    await this.#state.deliveries.createIndexes(deliveryIndexes());
+    await this.#state.events.createIndexes(eventIndexes());
+    if (this.#state.completionHistory) {
+      await this.#state.completions.createIndexes(completionIndexes());
+    }
+  }
+  async #createCollectionIfMissing(name) {
+    try {
+      await this.#state.database.createCollection(name);
+    } catch (error) {
+      if (!hasErrorCode(error, NAMESPACE_EXISTS)) {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Converts the documents of a 0.1.0 database; every step is idempotent, so a
+   * run that crashed is simply repeated. Deliveries that were `processing`
+   * become `pending`, due at once (their attempt stays counted, as a lost lease
+   * would count it). The per-delivery lease fields go, every delivery gets its
+   * lane, and every event learns which handlers it already has deliveries for
+   * and when it was created. Deliveries completed under 0.1.0 stay as
+   * `completed` documents until a purge removes them.
+   */
+  async #upgradeFromVersion010() {
+    const legacy = this.#state.database.collection(this.#state.deliveries.collectionName);
+    await legacy.updateMany({ status: "processing" }, [
+      { $set: { status: "pending", lane: "ready", dueAt: "$availableAt" } }
+    ]);
+    await legacy.updateMany(
+      {
+        $or: [
+          { leaseOwner: { $exists: true } },
+          { leaseToken: { $exists: true } },
+          { leaseExpiresAt: { $exists: true } }
+        ]
       },
+      { $unset: LEASE_FIELDS }
+    );
+    await inBatches(
+      this.#state.deliveries.find(
+        { laneId: { $exists: false } },
+        { projection: { eventId: 1, key: 1 }, batchSize: UPGRADE_BATCH_SIZE }
+      ),
+      async (documents) => {
+        await this.#state.deliveries.bulkWrite(
+          documents.map((document) => ({
+            updateOne: {
+              filter: { _id: document._id },
+              update: { $set: { laneId: laneOf(document.key ?? null, document.eventId) } }
+            }
+          })),
+          { ordered: false }
+        );
+      }
+    );
+    await this.#upgradeEventsFromVersion010();
+  }
+  /** Tells every 0.1.0 event which handlers it already has deliveries for and when it was created. */
+  async #upgradeEventsFromVersion010() {
+    await inBatches(
+      this.#state.events.find(
+        { handlers: { $exists: false } },
+        { projection: { occurredAt: 1 }, batchSize: UPGRADE_BATCH_SIZE }
+      ),
+      async (events) => {
+        const known = await this.#legacyEventGroups(events.map((event) => event._id));
+        await this.#state.events.bulkWrite(
+          events.map((event) => convertEvent(event, known.get(event._id))),
+          { ordered: false }
+        );
+      }
+    );
+  }
+  /** The handlers and first creation time of the deliveries of each of `eventIds`, by event id. */
+  async #legacyEventGroups(eventIds) {
+    return new Map(
+      (await this.#state.deliveries.aggregate([
+        { $match: { eventId: { $in: [...eventIds] } } },
+        {
+          $group: {
+            _id: "$eventId",
+            handlers: { $addToSet: "$handler" },
+            createdAt: { $min: "$createdAt" }
+          }
+        }
+      ]).toArray()).map((group) => [group._id, group])
+    );
+  }
+  /** Creates the lane documents that do not exist yet. */
+  async #seedLanes() {
+    await this.#state.lanes.bulkWrite(
+      Array.from({ length: LANE_COUNT }, (_, laneId) => ({
+        updateOne: {
+          filter: { _id: laneId },
+          update: {
+            $setOnInsert: {
+              epoch: 0,
+              owner: null,
+              holder: null,
+              leaseExpiresAt: null,
+              inFlight: [],
+              lost: []
+            }
+          },
+          upsert: true
+        }
+      })),
+      { ordered: false }
+    );
+  }
+  /** Drops the 0.1.0 indexes that no query uses, and a `claim` index with the 0.1.0 key. */
+  async #dropObsoleteIndexes() {
+    for (const index of await this.#state.deliveries.indexes()) {
+      if (isObsoleteIndex(index)) {
+        await this.#dropIndexIfPresent(index.name);
+      }
+    }
+  }
+  async #dropIndexIfPresent(name) {
+    try {
+      await this.#state.deliveries.dropIndex(name);
+    } catch (error) {
+      if (!hasErrorCode(error, INDEX_NOT_FOUND)) {
+        throw error;
+      }
+    }
+  }
+};
+function deliveryIndexes() {
+  return [
+    // Idempotent appends and lookups by event.
+    { key: { eventId: 1, handler: 1 }, name: "event_handler", unique: true },
+    // Claim: due work of a lane in due order. Holds ready deliveries only. The handler is
+    // last, so a query over many lanes and handlers stays a merge of one scan per lane.
+    { key: CLAIM_INDEX_KEY, name: "claim", partialFilterExpression: { lane: "ready" } },
+    // Ordering: unfinished predecessors of a keyed delivery, parked or not.
+    {
+      key: { handler: 1, key: 1, sequence: 1 },
+      name: "ordering",
+      partialFilterExpression: { dueAt: { $exists: true }, sequence: { $exists: true } }
+    },
+    // Parked deliveries: the lowest parked delivery of each key, to move it back once it is next.
+    {
+      key: { handler: 1, key: 1, sequence: 1 },
+      name: "parked",
+      partialFilterExpression: { lane: "parked" }
+    },
+    // Statistics: oldest due delivery across handlers.
+    { key: { dueAt: 1 }, name: "due", partialFilterExpression: { dueAt: { $exists: true } } },
+    // Purge of completed deliveries left by 0.1.0.
+    {
+      key: { completedAt: 1 },
+      name: "completed",
+      partialFilterExpression: { completedAt: { $exists: true } }
+    },
+    // Listing and status counts.
+    { key: { status: 1, createdAt: 1 }, name: "status_created" },
+    // Purge of dead deliveries.
+    { key: { status: 1, updatedAt: 1 }, name: "status_updated" },
+    { key: { handler: 1, createdAt: 1 }, name: "handler_created" },
+    { key: { eventType: 1, createdAt: 1 }, name: "type_created" }
+  ];
+}
+function eventIndexes() {
+  return [
+    { key: { createdAt: 1, _id: 1 }, name: "created" },
+    // Purge of events whose deliveries all completed: they are kept until `completedBefore` passes this.
+    {
+      key: { completedAt: 1, _id: 1 },
+      name: "completed",
+      partialFilterExpression: { completedAt: { $exists: true } }
+    }
+  ];
+}
+function completionIndexes() {
+  return [
+    { key: { completedAt: 1, _id: 1 }, name: "completed" },
+    { key: { eventId: 1 }, name: "event" },
+    { key: { createdAt: 1, _id: 1 }, name: "created" }
+  ];
+}
+function convertEvent(event, group) {
+  return {
+    updateOne: {
+      // Only an event nobody converted yet: another process may have finished and subscribed a handler.
+      filter: { _id: event._id, handlers: { $exists: false } },
       update: {
-        $set: { owner: null, holder: null, leaseExpiresAt: null, inFlight: [] },
-        $inc: { revision: 1 }
+        $set: group === void 0 ? { handlers: [], createdAt: event.occurredAt } : { handlers: group.handlers, createdAt: group.createdAt }
       }
     }
   };
 }
+function isObsoleteIndex(index) {
+  return OBSOLETE_INDEXES.includes(index.name) || index.name === "claim" && Object.keys(index.key).join() !== Object.keys(CLAIM_INDEX_KEY).join();
+}
 async function inBatches(cursor, work) {
   let batch = [];
   for await (const document of cursor) {
@@ -1852,43 +2068,251 @@ async function inBatches(cursor, work) {
     await work(batch);
   }
 }
-function atCount(count) {
-  return count === 0 ? { $not: { $gt: 0 } } : count;
-}
-function fencedLeases(issued, lanes, documents) {
-  const claimsById = new Map(documents.map((document) => [document._id, document.claims ?? 0]));
-  const fenced = /* @__PURE__ */ new Map();
-  for (const lease of issued) {
-    const lane = lanes.get(lease.laneId);
-    if (claimsById.get(lease.deliveryId) === lease.claims && lane.epoch === lease.epoch && lane.inFlight.includes(lease.deliveryId)) {
-      fenced.set(leaseIdentity(lease), lease);
-    }
-  }
-  return [...fenced.values()];
-}
-function ofClaim(lease) {
-  return { _id: lease.deliveryId, status: "pending", claims: atCount(lease.claims) };
-}
-function leaseKey(deliveryId, leaseToken) {
-  return `${deliveryId}\0${leaseToken}`;
-}
-function leaseIdentity(lease) {
-  return `${lease.deliveryId}\0${formatLeaseToken(lease.laneId, lease.epoch, lease.claims)}`;
-}
 function hasErrorCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-function compareText(left, right) {
-  return Number(left > right) - Number(left < right);
+var COLLECTION_PREFIX_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,39}$/;
+var DATABASE_NAME_PATTERN = /^[A-Za-z0-9_-]{1,63}$/;
+function assertCollectionPrefix(prefix) {
+  if (!COLLECTION_PREFIX_PATTERN.test(prefix)) {
+    throw new core.ConfigurationError(
+      `collectionPrefix '${prefix}' must be 1-40 characters of letters, digits or '_', starting with a letter or '_'`
+    );
+  }
 }
-function assertInTransaction(session, operation) {
-  if (!session.inTransaction()) {
+function assertDatabaseName(name) {
+  if (!DATABASE_NAME_PATTERN.test(name)) {
     throw new core.ConfigurationError(
-      `MongoEventStore.${operation} needs a ClientSession inside a started transaction (session.withTransaction or startTransaction). Without one, MongoDB commits each write immediately and the write is no longer atomic with yours`
+      `database '${name}' must be 1-63 characters of letters, digits, '_' or '-'`
     );
   }
 }
 
+// src/mongo-store-factory.ts
+var DEFAULT_TRANSACTION_OPTIONS = {
+  readConcern: { level: "snapshot" },
+  writeConcern: { w: "majority" },
+  readPreference: "primary"
+};
+var DEFAULT_PURGE_BATCH_SIZE = 500;
+function createMongoStoreState(options) {
+  const prefix = options.collectionPrefix ?? "relaybus_";
+  assertCollectionPrefix(prefix);
+  if (options.database !== void 0) {
+    assertDatabaseName(options.database);
+  }
+  const purgeBatchSize = internal.PositiveInteger.of(
+    options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE,
+    "purgeBatchSize"
+  );
+  const database = options.client.db(options.database);
+  const collectionOptions = {
+    readPreference: "primary",
+    writeConcern: { w: "majority" }
+  };
+  const state = {
+    client: options.client,
+    database,
+    events: database.collection(`${prefix}events`, collectionOptions),
+    deliveries: database.collection(`${prefix}deliveries`, collectionOptions),
+    keySequences: database.collection(`${prefix}key_sequences`, collectionOptions),
+    lanes: database.collection(`${prefix}lanes`, collectionOptions),
+    completions: database.collection(`${prefix}completed_deliveries`, collectionOptions),
+    completionHistory: options.completionHistory ?? false,
+    transactionOptions: options.transactionOptions ?? DEFAULT_TRANSACTION_OPTIONS,
+    purgeBatchSize,
+    logger: options.logger ?? console,
+    instanceId: core.createUuidV7(),
+    handedOut: new internal.HandedOutLedger(),
+    unreconciledOwners: /* @__PURE__ */ new Set()
+  };
+  return state;
+}
+
+// src/mongo-event-store.ts
+var MongoEventStore = class {
+  #state;
+  #schema;
+  #appender;
+  #claims;
+  #laneLeases;
+  #completion;
+  #queries;
+  #purger;
+  constructor(options) {
+    const state = createMongoStoreState(options);
+    this.#state = state;
+    const queries = new MongoQueries(state);
+    const ordering = new MongoOrdering(state);
+    const laneLeases = new MongoLaneLeases(state, { queries });
+    this.#schema = new MongoSchema(state);
+    this.#appender = new MongoAppend(state);
+    this.#claims = new MongoClaims(state, { laneLeases, ordering, queries });
+    this.#laneLeases = laneLeases;
+    this.#completion = new MongoCompletion(state);
+    this.#queries = queries;
+    this.#purger = new MongoPurge(state);
+  }
+  /**
+   * Verifies the deployment supports transactions, creates the collections and
+   * indexes and seeds the lane documents. Upgrades a 0.1.0 database in place
+   * first (see `MongoSchema.#upgradeFromVersion010`); the seeded lanes
+   * mark the upgrade as done, so later runs skip it. Safe to run repeatedly and
+   * from several processes. Stop 0.1.0 workers before the first run.
+   *
+   * @throws ConfigurationError when the server is a standalone mongod.
+   */
+  setup() {
+    return this.#schema.setup();
+  }
+  /**
+   * Runs `work` in a transaction on a new session and commits when it resolves.
+   *
+   * `work` can run more than once. The driver restarts the whole callback after
+   * a transient failure such as a write conflict, and re-sends only the commit
+   * after an unknown commit result. A restart is safe for everything written
+   * through the session, because the aborted attempt left nothing behind. It is
+   * not safe for side effects outside the session (HTTP calls, other databases),
+   * so keep those out of `work`; relaybus handlers are already at-least-once.
+   *
+   * With `options.timeoutMs` (from `bus.transaction`) the server bounds the commit with
+   * `maxCommitTimeMS`; the bus aborts a transaction that ran past the budget before its commit.
+   *
+   * @throws ConfigurationError when the deployment does not support transactions.
+   */
+  transaction(work, options) {
+    return options === void 0 ? runInTransaction(this.#state, work) : runInBudgetedTransaction(this.#state, { work, timeoutMs: options.timeoutMs });
+  }
+  /**
+   * Writes the entries in `session`. An existing event gets a delivery only for
+   * handlers it does not list yet; the added handlers are appended to its list
+   * together with a `revision` increment, a real write that makes a concurrent
+   * purge of the event conflict with this transaction.
+   */
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  append(session, entries, now) {
+    return this.#appender.append(session, { entries, now });
+  }
+  /**
+   * Claims up to `limit` due deliveries. It claims from the lanes this owner
+   * (and this store instance) holds under a live lease first, then takes free
+   * lanes with due work, a few at a time (4, 8, 16, ...) and the lane with the
+   * oldest due delivery first, so a worker holds only as many lanes as it
+   * needs. It then records the batch with one write per lane and hands back the
+   * lanes that yielded nothing and run nothing. No delivery document is
+   * written, except for the attempt charged to deliveries of a lane taken over
+   * and for parking (see `MongoOrdering.#parkDeliveries`).
+   *
+   * Taking a lane is one conditional `findOneAndUpdate` that also moves the
+   * previous owner's in-flight list to the lane's `lost` list; a lane another
+   * claimer took first is skipped, never waited for. Lost deliveries are charged
+   * one attempt before anything is read from the lane, and `lost` is cleared
+   * only after that. Whoever holds the lane next charges a `lost` list it finds
+   * first, so a claim that fails anywhere after the take loses no charge; the
+   * charge of a lost claim is recorded on the delivery, so charging the list
+   * again after a failure before the clear charges nothing twice.
+   * Nothing a failed claim did leaves a delivery listed as running.
+   */
+  claim(request) {
+    return this.#claims.claim(request);
+  }
+  /**
+   * Extends the lease of the lane a running delivery belongs to. The lane lease
+   * never shrinks, so a repeated renewal with the same value still holds. An
+   * expired lease nobody took over is still renewed, so `_now` is not needed.
+   */
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  extendLease(lease, leaseExpiresAt, _now) {
+    return Promise.resolve(this.#completion.extendLease({ lease, leaseExpiresAt }));
+  }
+  /**
+   * Deletes the delivery (and records it in the completion history, when kept).
+   * With `session` the deletion commits with the caller's transaction; without,
+   * it runs in a transaction of its own. Returns false when the lease was lost.
+   */
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  complete(lease, now, session) {
+    return this.#completion.complete(lease, { now, session });
+  }
+  /**
+   * Completes many leases with a fixed number of round trips, whatever lanes
+   * they belong to: three commands without a completion history, one
+   * transaction with it (see `MongoCompletion.#deleteFenced`).
+   * Returns one flag per lease in input order; a lease listed twice completes
+   * once, and a token this store cannot have issued is refused.
+   */
+  completeMany(leases, now) {
+    return this.#completion.completeMany(leases, now);
+  }
+  /** Returns a running delivery to pending, due at `availableAt`, and counts the attempt that ended. */
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  reschedule(lease, availableAt, error, now) {
+    return Promise.resolve(
+      this.#completion.changeClaim({
+        lease,
+        change: { kind: "reschedule", availableAt, error, now }
+      })
+    );
+  }
+  /** Gives a running delivery back without counting the attempt: pending, due `now`. */
+  release(lease, now) {
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "release", now } })
+    );
+  }
+  /** Moves a running delivery to dead and counts the attempt that ended. */
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  bury(lease, error, now) {
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "bury", error, now } })
+    );
+  }
+  /**
+   * Frees every lane `leaseOwner` holds that runs no delivery, so other workers
+   * need not wait for the lease to expire. Lanes with running deliveries stay leased.
+   */
+  relinquish(leaseOwner) {
+    return this.#laneLeases.relinquish(leaseOwner);
+  }
+  /**
+   * Lists deliveries in creation order. A delivery is `processing` while its
+   * document exists as `pending` and its lane lists it; its attempt count then
+   * includes the running attempt, and owner and expiry are those of the lane
+   * lease. Completion history records (when kept) are listed as `completed`.
+   */
+  listDeliveries(query) {
+    return this.#queries.listDeliveries(query);
+  }
+  /** Moves dead deliveries back to pending with a fresh attempt budget. */
+  requeue(deliveryIds, now) {
+    return this.#queries.requeue(deliveryIds, now);
+  }
+  /**
+   * Deletes, in batches of `purgeBatchSize`, dead deliveries last updated before
+   * `deadBefore`, and completion history records (and `completed` documents left
+   * by 0.1.0) completed before `completedBefore`, each batch in one transaction
+   * together with the events it left without any reference. Finally, events
+   * nothing references are deleted: one with a completed delivery once its last
+   * completion is before `completedBefore` (never by `deadBefore` alone), one
+   * that never had a completion (no subscribers, or only dead letters) once it
+   * was created before the earliest given cutoff. The batch step applies the
+   * same rule to events whose last completion is recorded.
+   */
+  purge(request) {
+    return this.#purger.purge(request);
+  }
+  /**
+   * Counts by derived status. `pending` excludes running deliveries; `completed`
+   * counts history records and 0.1.0 `completed` documents. `oldestDueAt` is the
+   * oldest instant at which a delivery became claimable: the due time of a
+   * pending delivery nobody runs, or the lease expiry of a lane that still runs
+   * deliveries.
+   */
+  statistics(now) {
+    return this.#queries.statistics(now);
+  }
+};
+
 exports.MongoEventStore = MongoEventStore;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map