@relaybus/mongodb 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,73 +1,54 @@
-import { ConfigurationError, createUuidV7, EventValidationError } from '@relaybus/core';
+import { createUuidV7, ConfigurationError, EventValidationError } from '@relaybus/core';
+import { assertPositiveInteger } from '@relaybus/core/internal';
 
 // src/mongo-event-store.ts
 
-// src/claim-scan.ts
-var ClaimScan = class {
-  #keys = /* @__PURE__ */ new Map();
-  /** Why the delivery must wait according to what this scan already knows, if it does. */
-  verdict(orderingId, sequence) {
-    const known = this.#keys.get(orderingId);
-    if (known?.openSequence !== void 0 && sequence > known.openSequence) {
-      return "open-predecessor";
-    }
-    return known?.leaseHeld === true ? "live-lease" : void 0;
-  }
-  /** 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);
-  }
-  /** Records that this scan leased the delivery, which is now unfinished and holds a live lease. */
-  noteClaimed(orderingId, sequence) {
-    this.noteOpen(orderingId, sequence);
-    this.#know(orderingId).leaseHeld = true;
-  }
-  /** Records that a live lease of the key blocks every delivery of it. */
-  noteLeaseHeld(orderingId) {
-    this.#know(orderingId).leaseHeld = true;
-  }
-  /** Remembers a delivery that waited behind an unfinished predecessor. */
-  noteWaiting(orderingId, delivery) {
-    if (delivery.status === "pending") {
-      this.#know(orderingId).waiting.push(delivery._id);
-    }
-  }
-  /**
-   * Ids of the waiting deliveries of every key that accumulated at least
-   * `minimum` of them. Shorter queues stay in the claim index: moving them out
-   * and back would cost more than skipping them.
-   */
-  waitingBacklogs(minimum) {
-    return [...this.#keys.values()].filter((known) => known.waiting.length >= minimum).flatMap((known) => known.waiting);
+// src/lanes.ts
+var LANE_COUNT = 256;
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var utf8 = new TextEncoder();
+function laneOf(key, eventId) {
+  let hash = FNV_OFFSET_BASIS;
+  for (const byte of utf8.encode(key ?? eventId)) {
+    hash = Math.imul(hash ^ byte, FNV_PRIME);
   }
-  #know(orderingId) {
-    let known = this.#keys.get(orderingId);
-    if (known === void 0) {
-      known = { openSequence: void 0, leaseHeld: false, waiting: [] };
-      this.#keys.set(orderingId, known);
-    }
-    return known;
+  return hash & LANE_COUNT - 1;
+}
+function formatLeaseToken(laneId, { epoch, claims }) {
+  return `${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) {
+    return void 0;
   }
-};
-function orderingIdentity(handler, key) {
-  return `${handler}\0${key}`;
+  return { laneId: Number(match[1]), epoch: Number(match[2]), claims: Number(match[3]) };
 }
-function toEventDocument(event, sequence) {
+
+// src/documents.ts
+function toEventDocument(event, {
+  sequence,
+  handlers,
+  createdAt
+}) {
   const payloadJson = serializeWellFormed(event.payload, "payload");
   const headersJson = serializeWellFormed(event.headers, "headers");
   return {
     _id: event.id,
     type: event.type,
     source: event.source,
-    key: event.key,
-    sequence,
+    // Fields that are null or 0 are left out: every byte of a new document is written to the oplog too.
+    ...event.key === null ? {} : { key: event.key },
+    ...sequence === null ? {} : { sequence },
     ...payloadJson === void 0 ? {} : { payload: JSON.parse(payloadJson) },
     headers: JSON.parse(headersJson),
-    correlationId: event.correlationId,
-    causationId: event.causationId,
+    ...event.correlationId === null ? {} : { correlationId: event.correlationId },
+    ...event.causationId === null ? {} : { causationId: event.causationId },
     occurredAt: event.occurredAt,
-    revision: 0
+    handlers,
+    createdAt
   };
 }
 var LONE_SURROGATE_ESCAPE = /(?<!\\)(?:\\\\)*\\ud[89a-f][0-9a-f]{2}/i;
@@ -88,48 +69,94 @@ function toEnvelope(document) {
     id: document._id,
     type: document.type,
     source: document.source,
-    key: document.key,
+    key: document.key ?? null,
     payload: document.payload,
     headers: document.headers,
-    correlationId: document.correlationId,
-    causationId: document.causationId,
+    correlationId: document.correlationId ?? null,
+    causationId: document.causationId ?? null,
     occurredAt: document.occurredAt
   };
 }
-function toDeliveryDocument(delivery, event, ordering, now) {
+function toDeliveryDocument(delivery, {
+  event,
+  ordering,
+  now
+}) {
   return {
     _id: delivery.id,
     eventId: event.id,
     eventType: event.type,
     handler: delivery.handler,
     ...ordering.key === null || ordering.sequence === null ? {} : { key: ordering.key, sequence: ordering.sequence },
+    laneId: laneOf(ordering.key, event.id),
     status: "pending",
     lane: "ready",
     attempts: 0,
+    // No updatedAt (it equals createdAt): every byte of a new document is written to the oplog too.
     availableAt: delivery.availableAt,
     dueAt: delivery.availableAt,
-    createdAt: now,
-    updatedAt: now
+    createdAt: now
   };
 }
-function toDeliveryRecord(document, event) {
+function toDeliveryRecord(document, {
+  event,
+  runningIn
+}) {
   return {
     id: document._id,
     handler: document.handler,
-    status: document.status,
-    attempts: document.attempts,
+    status: runningIn === void 0 ? document.status : "processing",
+    attempts: runningIn === void 0 ? document.attempts : document.attempts + 1,
     availableAt: document.availableAt,
-    leaseOwner: document.leaseOwner ?? null,
-    leaseExpiresAt: document.leaseExpiresAt ?? null,
+    leaseOwner: runningIn === void 0 ? null : runningIn.owner,
+    leaseExpiresAt: runningIn === void 0 ? null : runningIn.leaseExpiresAt,
     lastError: document.lastError === void 0 ? null : toErrorInfo(document.lastError),
     createdAt: document.createdAt,
-    updatedAt: document.updatedAt,
+    updatedAt: document.updatedAt ?? document.createdAt,
     completedAt: document.completedAt ?? null,
     event
   };
 }
+function toCompletedDeliveryRecord(document, event) {
+  return {
+    id: document._id,
+    handler: document.handler,
+    status: "completed",
+    attempts: document.attempts,
+    availableAt: document.availableAt,
+    leaseOwner: null,
+    leaseExpiresAt: null,
+    lastError: null,
+    createdAt: document.createdAt,
+    updatedAt: document.completedAt,
+    completedAt: document.completedAt,
+    event
+  };
+}
+function toCompletedDeliveryDocument(document, completedAt) {
+  return {
+    _id: document._id,
+    eventId: document.eventId,
+    eventType: document.eventType,
+    handler: document.handler,
+    attempts: document.attempts + 1,
+    availableAt: document.availableAt,
+    createdAt: document.createdAt,
+    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) {
@@ -141,184 +168,97 @@ 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 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 leaseKey(deliveryId, leaseToken) {
+  return `${deliveryId}\0${leaseToken}`;
+}
+function assertInTransaction(session, operation) {
+  if (!session.inTransaction()) {
     throw new 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 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 LEASE_FIELDS = { leaseOwner: "", leaseToken: "", leaseExpiresAt: "" };
-var FINISHED_FIELDS = { dueAt: "", lane: "" };
-var MongoEventStore = class {
-  #client;
-  #database;
-  #events;
-  #deliveries;
-  #keySequences;
-  #transactionOptions;
-  #purgeBatchSize;
-  #generateIdentifier;
-  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 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" }
-    };
-    this.#events = database.collection(`${prefix}events`, collectionOptions);
-    this.#deliveries = database.collection(`${prefix}deliveries`, collectionOptions);
-    this.#keySequences = database.collection(`${prefix}key_sequences`, collectionOptions);
-    this.#transactionOptions = options.transactionOptions ?? DEFAULT_TRANSACTION_OPTIONS;
-    this.#purgeBatchSize = purgeBatchSize;
-    this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
-  }
-  /**
-   * Verifies the deployment supports transactions and creates the indexes.
-   * Safe to run repeatedly and from several processes.
-   *
-   * @throws ConfigurationError when the server is a standalone mongod.
-   */
-  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);
-    }
-    for (const collection of [this.#events, this.#deliveries, this.#keySequences]) {
-      await this.#createCollectionIfMissing(collection.collectionName);
-    }
-    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 handler in due order. Holds ready deliveries only.
-      {
-        key: { handler: 1, dueAt: 1, _id: 1 },
-        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" }
-      },
-      // Live leases: a keyed delivery may not start while another of its key is running.
-      {
-        key: { handler: 1, key: 1, dueAt: 1 },
-        name: "running",
-        partialFilterExpression: { status: "processing", key: { $exists: true } }
-      },
-      // Statistics: oldest due delivery across handlers.
-      { key: { dueAt: 1 }, name: "due", partialFilterExpression: { dueAt: { $exists: true } } },
-      // Purge of completed deliveries.
-      {
-        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" }
-    ]);
-  }
-  async #createCollectionIfMissing(name) {
-    try {
-      await this.#database.createCollection(name);
-    } catch (error) {
-      if (!(typeof error === "object" && error !== null && "code" in error && error.code === NAMESPACE_EXISTS)) {
-        throw error;
-      }
-    }
-  }
-  /**
-   * 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;
-    }
+// src/mongo-append.ts
+var MongoAppend = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
   }
-  async append(session, entries, now) {
+  /** 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.#events.find({ _id: { $in: eventIds } }, { session, projection: { key: 1, sequence: 1 } }).toArray()).map((stored) => [stored._id, stored])
-    );
-    const storedDeliveryKeys = new Set(
-      (await this.#deliveries.find({ eventId: { $in: eventIds } }, { session, projection: { eventId: 1, handler: 1 } }).toArray()).map((stored) => deliveryPairKey(stored.eventId, stored.handler))
+      (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
+    };
+  }
+  /**
+   * Decides, in entry order, which events are new (taking their key sequence) and which deliveries
+   * each event still lacks.
+   */
+  async #planAppend(input) {
+    const { session, entries, storedEvents, now } = input;
     const appendedEventIds = [];
     const duplicateEventIds = [];
     const newEvents = [];
     const newDeliveries = [];
-    const touchedEventIds = /* @__PURE__ */ new Set();
+    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, sequence: stored.sequence });
+      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);
@@ -326,44 +266,61 @@ var MongoEventStore = class {
         const sequence = event.key === null ? null : await this.#nextSequence(event.key, session);
         ordering = { key: event.key, sequence };
         orderingByEventId.set(event.id, ordering);
-        newEvents.push(toEventDocument(event, sequence));
+        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) {
-        const pairKey = deliveryPairKey(event.id, delivery.handler);
-        if (storedDeliveryKeys.has(pairKey)) {
+        if (handlers.has(delivery.handler)) {
           continue;
         }
-        storedDeliveryKeys.add(pairKey);
-        newDeliveries.push(toDeliveryDocument(delivery, event, ordering, now));
-        if (storedEvents.has(event.id)) {
-          touchedEventIds.add(event.id);
-        }
+        handlers.add(delivery.handler);
+        addedHandlers.set(event.id, [...addedHandlers.get(event.id) ?? [], delivery.handler]);
+        newDeliveries.push(toDeliveryDocument(delivery, { event, ordering, now }));
       }
     }
+    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.#events.bulkWrite(
-        newEvents.map((document) => ({
+      await this.#state.events.bulkWrite(
+        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
+            }
+          };
+        }),
+        { session, ordered: true }
+      );
+    }
+    const extendedEvents = [...addedHandlers].filter(([eventId]) => storedEvents.has(eventId));
+    if (extendedEvents.length > 0) {
+      await this.#state.events.bulkWrite(
+        extendedEvents.map(([eventId, handlers]) => ({
           updateOne: {
-            filter: { _id: document._id },
-            update: { $setOnInsert: document },
-            upsert: true
+            filter: { _id: eventId },
+            update: { $inc: { revision: 1 }, $push: { handlers: { $each: handlers } } }
           }
         })),
         { session, ordered: true }
       );
     }
-    if (touchedEventIds.size > 0) {
-      await this.#events.updateMany(
-        { _id: { $in: [...touchedEventIds] } },
-        { $inc: { revision: 1 } },
-        { session }
-      );
-    }
     if (newDeliveries.length > 0) {
-      await this.#deliveries.bulkWrite(
+      await this.#state.deliveries.bulkWrite(
         newDeliveries.map((document) => ({
           updateOne: {
             filter: { eventId: document.eventId, handler: document.handler },
@@ -374,249 +331,1033 @@ var MongoEventStore = class {
         { session, ordered: true }
       );
     }
-    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount: newDeliveries.length };
   }
-  async claim(request) {
-    if (request.handlers.length === 0 || request.limit <= 0) {
-      return [];
-    }
-    await this.#unparkNextDeliveries(request.handlers);
-    const claimed = [];
-    const scan = new ClaimScan();
-    const candidates = this.#deliveries.find(
-      { handler: { $in: [...request.handlers] }, dueAt: { $lte: request.now }, lane: "ready" },
-      {
-        sort: { dueAt: 1, _id: 1 },
-        batchSize: Math.max(request.limit * 2, MINIMUM_CANDIDATE_BATCH_SIZE)
-      }
+  /** 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 }
     );
-    try {
-      for await (const candidate of candidates) {
-        const leased = await this.#claimCandidate(candidate, request, scan);
-        if (leased !== void 0) {
-          claimed.push(leased);
-          if (claimed.length >= request.limit) {
-            break;
-          }
-        }
-      }
-    } finally {
-      await candidates.close();
-    }
-    await this.#parkDeliveries(scan.waitingBacklogs(PARK_BACKLOG_THRESHOLD));
-    return this.#toClaimedDeliveries(claimed, request.leaseExpiresAt);
+    return counter.value;
   }
-  async extendLease(lease, leaseExpiresAt, now) {
-    return this.#updateLeased(lease, void 0, {
-      $set: { leaseExpiresAt, dueAt: leaseExpiresAt, updatedAt: now }
-    });
+};
+
+// 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;
   }
-  async complete(lease, now, session) {
-    if (session !== void 0) {
-      assertInTransaction(session, "complete");
-    }
-    return this.#updateLeased(lease, session, {
-      $set: { status: "completed", completedAt: now, updatedAt: now },
-      $unset: { ...LEASE_FIELDS, ...FINISHED_FIELDS }
-    });
+  /** Whether this scan already learned anything about the key. */
+  knows(orderingId) {
+    return this.#keys.has(orderingId);
   }
-  async reschedule(lease, availableAt, error, now) {
-    return this.#updateLeased(lease, void 0, {
-      $set: {
-        status: "pending",
-        availableAt,
-        dueAt: availableAt,
-        lastError: toErrorInfo(error),
-        updatedAt: now
-      },
-      $unset: LEASE_FIELDS
-    });
+  /** 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);
   }
-  async release(lease, now) {
-    return this.#updateLeased(lease, void 0, {
-      $set: { status: "pending", availableAt: now, dueAt: now, updatedAt: now },
-      $inc: { attempts: -1 },
-      $unset: LEASE_FIELDS
-    });
+  /** 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;
   }
-  async bury(lease, error, now) {
-    return this.#updateLeased(lease, void 0, {
-      $set: { status: "dead", lastError: toErrorInfo(error), updatedAt: now },
-      $unset: { ...LEASE_FIELDS, ...FINISHED_FIELDS }
-    });
+  /**
+   * 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);
   }
-  async listDeliveries(query) {
-    const filter = {
-      ...query.status === void 0 ? {} : { status: String(query.status) },
-      ...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 documents = await this.#deliveries.find(filter, { sort: { createdAt: 1, _id: 1 }, limit: query.limit ?? DEFAULT_LIST_LIMIT }).toArray();
-    const events = await this.#readEnvelopes(documents.map((document) => document.eventId));
-    return documents.map((document) => toDeliveryRecord(document, events.get(document.eventId)));
+  #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;
   }
-  async requeue(deliveryIds, now) {
-    const result = await this.#deliveries.updateMany(
-      { _id: { $in: deliveryIds.map(String) }, status: "dead" },
+};
+function orderingIdentity(handler, key) {
+  return `${handler}\0${key}`;
+}
+
+// src/mongo-claim.ts
+var PARK_BACKLOG_THRESHOLD = 32;
+var INITIAL_LANES_PER_ROUND = 4;
+var LANES_PER_CANDIDATE_QUERY = 128;
+function scopeOf(held) {
+  return new Map(
+    held.map((lane) => [
+      lane._id,
       {
-        $set: {
-          status: "pending",
-          lane: "ready",
-          attempts: 0,
-          availableAt: now,
-          dueAt: now,
-          updatedAt: now
-        }
+        laneId: lane._id,
+        epoch: lane.epoch,
+        listed: lane.inFlight,
+        revision: lane.revision ?? 0
       }
-    );
-    return result.modifiedCount;
+    ])
+  );
+}
+var MongoClaims = class {
+  #state;
+  #laneLeases;
+  #ordering;
+  #queries;
+  constructor(state, collaborators) {
+    this.#state = state;
+    this.#laneLeases = collaborators.laneLeases;
+    this.#ordering = collaborators.ordering;
+    this.#queries = collaborators.queries;
   }
-  async purge(request) {
-    const filters = [];
-    if (request.completedBefore !== void 0) {
-      filters.push({ status: "completed", completedAt: { $lt: request.completedBefore } });
+  /** Implements {@link MongoEventStore.claim}. */
+  async claim(request) {
+    if (request.handlers.length === 0 || request.limit <= 0) {
+      return [];
     }
-    if (request.deadBefore !== void 0) {
-      filters.push({ status: "dead", updatedAt: { $lt: request.deadBefore } });
+    const owner = request.leaseOwner;
+    const previous = this.#state.claimsInProgress.get(owner) ?? Promise.resolve();
+    const claimed = previous.then(() => this.#claimReconciled(request));
+    const settled = Promise.allSettled([claimed]);
+    this.#state.claimsInProgress.set(owner, settled);
+    void settled.then(() => {
+      if (this.#state.claimsInProgress.get(owner) === settled) {
+        this.#state.claimsInProgress.delete(owner);
+      }
+    });
+    return claimed;
+  }
+  /**
+   * Runs one claim and remembers what it hands out. When the claim fails at any
+   * point, also after its record reached the database without the reply
+   * reaching this process, the lanes this owner holds on this instance are
+   * reconciled: every listed delivery this instance has not handed out, or has
+   * handed out and seen settled, is taken out of them, so nothing stays listed
+   * as running that nobody runs.
+   */
+  async #claimReconciled(request) {
+    const owner = request.leaseOwner;
+    if (this.#state.unreconciledOwners.has(owner)) {
+      await this.#reconcileLanes(owner);
+      this.#state.unreconciledOwners.delete(owner);
     }
-    let deletedDeliveries = 0;
-    let deletedEvents = 0;
-    for (const filter of filters) {
-      const result = await this.#purgeMatching(filter);
-      deletedDeliveries += result.deletedDeliveries;
-      deletedEvents += result.deletedEvents;
+    try {
+      const claimed = await this.#claimNow(request);
+      for (const delivery of claimed) {
+        const { laneId, epoch } = parseLeaseToken(delivery.leaseToken);
+        this.#state.handedOut.set(leaseKey(delivery.deliveryId, delivery.leaseToken), {
+          deliveryId: delivery.deliveryId,
+          owner: request.leaseOwner,
+          laneId,
+          epoch
+        });
+      }
+      return claimed;
+    } catch (error) {
+      const [reconciled] = await Promise.allSettled([this.#reconcileLanes(owner)]);
+      if (reconciled.status === "rejected") {
+        this.#state.unreconciledOwners.add(owner);
+      }
+      throw error;
     }
-    return { deletedDeliveries, deletedEvents };
   }
-  async statistics(now) {
-    const statuses = ["pending", "processing", "completed", "dead"];
-    const [pending, processing, completed, dead] = await Promise.all(
-      statuses.map((status) => this.#deliveries.countDocuments({ status }))
-    );
-    const oldestDue = await this.#deliveries.findOne(
-      { dueAt: { $lte: now } },
-      { sort: { dueAt: 1 }, projection: { dueAt: 1 } }
+  /**
+   * 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 runInTransaction(this.#state, async (session) => {
+      const held = await this.#state.lanes.find({ owner, holder: this.#state.instanceId }, { session }).toArray();
+      const listed = held.flatMap((lane) => lane.inFlight);
+      const claimsById = new Map(
+        (await this.#state.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, { epoch: lane.epoch, claims: claimsById.get(id) ?? 0 })
+          );
+          current.add(key);
+          return !this.#state.handedOut.has(key);
+        })
+      }));
+      for (const [key, entry] of this.#state.handedOut) {
+        if (entry.owner === owner && !current.has(key)) {
+          this.#state.handedOut.delete(key);
+        }
+      }
+      if (held.length === 0) {
+        return;
+      }
+      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 }
+      );
+    });
+  }
+  async #claimNow(request) {
+    const [held] = await Promise.all([
+      this.#state.lanes.find({
+        owner: request.leaseOwner,
+        holder: this.#state.instanceId,
+        leaseExpiresAt: { $gt: request.now }
+      }).toArray(),
+      this.#ordering.unparkNextDeliveries(request.handlers)
+    ]);
+    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
     );
-    return {
-      pending,
-      processing,
-      completed,
-      dead,
-      oldestDueAt: oldestDue?.dueAt ?? null
+    await this.#ordering.parkWaiting(scan.waitingBacklogs(PARK_BACKLOG_THRESHOLD, handedBack));
+    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)
+    }));
+  }
+  /** 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(
+          (document) => document.key === void 0 ? [] : [orderingIdentity(document.handler, document.key)]
+        )
+      )
+    }));
+  }
+  /**
+   * 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.#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.#laneLeases.findFreeLanes(request, {
+        laneCount,
+        passed: [...passed]
+      });
+      if (free.length === 0) {
+        break;
+      }
+      for (const laneId of free) {
+        passed.add(laneId);
+      }
+      const taken = await this.#laneLeases.takeLanes(free, request);
+      for (const lane of taken) {
+        scope.set(lane.laneId, lane);
+      }
+      await pickFrom(taken);
+    }
   }
-  /** 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 }
+  /**
+   * 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}`)
+      )
     );
-    return counter.value;
+    for (const [key, entry] of this.#state.handedOut) {
+      if (entry.owner === owner && gone.has(`${entry.deliveryId}\0${entry.laneId}:${entry.epoch}`)) {
+        this.#state.handedOut.delete(key);
+      }
+    }
   }
-  async #claimCandidate(candidate, request, scan) {
-    const { key, sequence } = candidate;
-    if (key === void 0) {
-      return this.#lease(candidate, request);
+  /**
+   * 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 orderingId = orderingIdentity(candidate.handler, key);
-    const known = scan.verdict(orderingId, sequence);
-    if (known === "open-predecessor") {
-      scan.noteWaiting(orderingId, candidate);
-      return void 0;
+    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];
     }
-    if (known === "live-lease") {
-      return void 0;
+    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]);
     }
-    const predecessor = await this.#findUnfinishedPredecessor(candidate.handler, key, sequence);
-    if (predecessor !== void 0) {
-      scan.noteOpen(orderingId, predecessor);
-      scan.noteWaiting(orderingId, candidate);
-      return void 0;
+    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 } } }
+        )
+      )
+    );
+  }
+};
+
+// src/mongo-completion.ts
+var FINISHED_FIELDS = { dueAt: "", lane: "" };
+var MongoCompletion = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Implements {@link MongoEventStore.extendLease}. */
+  async extendLease(lease, leaseExpiresAt) {
+    const held = parseLeaseToken(lease.leaseToken);
+    if (held === void 0) {
+      return false;
     }
-    if (await this.#hasLiveLease(candidate.handler, key, request.now)) {
-      scan.noteLeaseHeld(orderingId);
-      return void 0;
+    const deliveryId = String(lease.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.#state.lanes.updateOne(
+        { _id: held.laneId, epoch: held.epoch, inFlight: deliveryId },
+        { $max: { leaseExpiresAt } },
+        { session }
+      );
+      return renewed.matchedCount === 1;
+    });
+  }
+  /** Implements {@link MongoEventStore.complete}. */
+  async complete(lease, { now, session }) {
+    if (session !== void 0) {
+      assertInTransaction(session, "complete");
     }
-    const leased = await this.#lease(candidate, request);
-    if (leased === void 0) {
-      return void 0;
+    return (await this.#completeLeases([lease], { now, session }))[0];
+  }
+  /** Implements {@link MongoEventStore.completeMany}. */
+  completeMany(leases, now) {
+    return this.#completeLeases(leases, { now, session: void 0 });
+  }
+  /** Implements {@link MongoEventStore.reschedule}. */
+  async reschedule(lease, {
+    availableAt,
+    error,
+    now
+  }) {
+    return this.#leaveFlight(lease, {
+      $set: { availableAt, dueAt: availableAt, lastError: toErrorInfo(error), updatedAt: now },
+      $inc: { attempts: 1, claims: 1 }
+    });
+  }
+  /** Implements {@link MongoEventStore.release}. */
+  async release(lease, now) {
+    return this.#leaveFlight(lease, {
+      $set: { availableAt: now, dueAt: now, updatedAt: now },
+      $inc: { claims: 1 }
+    });
+  }
+  /** Implements {@link MongoEventStore.bury}. */
+  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 }
+    });
+  }
+  /**
+   * 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.#state.handedOut.delete(leaseKey(String(lease.deliveryId), String(lease.leaseToken)));
     }
-    const lateBlocker = await this.#findUnfinishedPredecessor(candidate.handler, key, sequence);
-    if (lateBlocker !== void 0) {
-      await this.#restore(candidate, leased);
-      scan.noteOpen(orderingId, lateBlocker);
-      return void 0;
+    return result;
+  }
+  /**
+   * 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 #completeLeases(leases, { now, session }) {
+    return session === void 0 ? this.#settle(leases, () => this.#completeIssued(leases, { now, session: void 0 })) : this.#completeIssued(leases, { now, session });
+  }
+  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.#state.completionHistory) {
+        completed = await runInTransaction(
+          this.#state,
+          (own) => this.#deleteCompleted(issued, { now, session: own })
+        );
+      } else {
+        completed = await this.#deleteFenced(issued, now);
+      }
     }
-    scan.noteClaimed(orderingId, sequence);
-    return leased;
+    return leases.map(
+      (lease, index) => parsed[index] !== void 0 && completed.delete(leaseIdentity({ deliveryId: String(lease.deliveryId), ...parsed[index] }))
+    );
+  }
+  /**
+   * 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.#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])
+    );
+    const fenced = fencedLeases(issued, { lanes, documents });
+    if (fenced.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    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();
+  }
+  /**
+   * 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 }
+    );
   }
   /**
-   * Takes the delivery with one conditional update that pins the exact state
-   * that was selected, so a competing claimer, a finished lease, a reschedule
-   * or a parking since then makes it match nothing.
+   * 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 #lease(candidate, request) {
-    const leased = await this.#deliveries.findOneAndUpdate(
+  async #leaveFlight(lease, update) {
+    const held = parseLeaseToken(lease.leaseToken);
+    if (held === void 0) {
+      return false;
+    }
+    const deliveryId = String(lease.deliveryId);
+    const ofThisClaim = ofClaim({ ...held, deliveryId });
+    return this.#settle(
+      [lease],
+      () => this.#leaveFlightNow(held, { deliveryId, ofThisClaim, update })
+    );
+  }
+  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 `${lease.deliveryId}\0${formatLeaseToken(lease.laneId, { epoch: lease.epoch, claims: lease.claims })}`;
+}
+
+// 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 `ClaimScan.waitingBacklogs`).
+   */
+  async findFreeLanes(request, { laneCount, passed }) {
+    const lanes = await this.#state.lanes.aggregate([
       {
-        _id: candidate._id,
-        status: candidate.status,
-        lane: "ready",
-        attempts: candidate.attempts,
-        dueAt: candidate.dueAt
+        $match: {
+          _id: { $nin: passed },
+          $or: [{ leaseExpiresAt: null }, { leaseExpiresAt: { $lte: request.now } }]
+        }
       },
       {
-        $set: {
-          status: "processing",
-          leaseOwner: request.leaseOwner,
-          leaseToken: this.#generateIdentifier(),
-          leaseExpiresAt: request.leaseExpiresAt,
-          dueAt: request.leaseExpiresAt,
-          updatedAt: request.now
-        },
-        $inc: { attempts: 1 }
+        $lookup: {
+          from: this.#state.deliveries.collectionName,
+          localField: "_id",
+          foreignField: "laneId",
+          pipeline: [
+            {
+              $match: {
+                handler: { $in: [...request.handlers] },
+                lane: "ready",
+                dueAt: { $lte: request.now }
+              }
+            },
+            { $sort: { dueAt: 1, _id: 1 } },
+            { $limit: 1 },
+            { $project: { dueAt: 1 } }
+          ],
+          as: "oldest"
+        }
       },
-      { returnDocument: "after" }
+      { $unwind: "$oldest" },
+      { $sort: { "oldest.dueAt": 1, "oldest._id": 1 } },
+      { $limit: laneCount },
+      { $project: { _id: 1 } }
+    ]).toArray();
+    return lanes.map((lane) => lane._id);
+  }
+  /**
+   * 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 MongoLaneLeases.chargeLost}).
+   */
+  async takeLanes(laneIds, request) {
+    const after = await Promise.all(
+      laneIds.map(
+        (laneId) => this.#state.lanes.findOneAndUpdate(
+          {
+            _id: laneId,
+            $or: [{ leaseExpiresAt: null }, { leaseExpiresAt: { $lte: request.now } }]
+          },
+          [
+            {
+              $set: {
+                epoch: { $add: ["$epoch", 1] },
+                owner: { $literal: request.leaseOwner },
+                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: {
+                  $setUnion: [
+                    { $ifNull: ["$lost", []] },
+                    { $map: { input: "$inFlight", in: { id: "$$this", epoch: "$epoch" } } }
+                  ]
+                },
+                inFlight: { $literal: [] }
+              }
+            }
+          ],
+          { returnDocument: "after" }
+        )
+      )
     );
-    return leased ?? void 0;
+    const taken = after.filter((lane) => lane !== null);
+    await this.chargeLost(taken);
+    return taken.map((lane) => ({
+      laneId: lane._id,
+      epoch: lane.epoch,
+      listed: lane.inFlight,
+      revision: lane.revision ?? 0
+    }));
   }
-  /** Puts a delivery that was leased a moment ago back exactly as it was selected. */
-  async #restore(selected, leased) {
-    const state = {
-      status: selected.status,
-      attempts: selected.attempts,
-      dueAt: selected.dueAt,
-      updatedAt: selected.updatedAt
+  /**
+   * Charges one attempt to every pending delivery listed in the `lost` lists of
+   * `lanes` (deliveries whose lane was taken while they ran), then clears those
+   * lists under the lanes' current epochs. The charge is a write on each lost
+   * delivery that comes before any read of the lane's deliveries: a completion
+   * of the previous owner deletes the same documents, so the two conflict and
+   * cannot both succeed. The charge also moves the claim generation on, which
+   * fences every lease of the lost claim, and records the lost claim
+   * (`lostAt` = lane and epoch it was claimed under): a holder that charges the
+   * list again after a failure before the clear skips deliveries already
+   * charged for that claim.
+   */
+  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.#state.deliveries.bulkWrite(
+      lost.map(({ id, epoch }) => ({
+        updateOne: {
+          filter: { _id: id, status: "pending", lostAt: { $not: { $gte: epoch } } },
+          update: { $inc: { attempts: 1, claims: 1 }, $set: { lostAt: epoch } }
+        }
+      })),
+      { ordered: true }
+    );
+    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();
+    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(
+          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);
+      }
+    }
+    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
     };
-    await this.#deliveries.updateOne(
-      { _id: leased._id, status: "processing", leaseToken: leased.leaseToken },
-      selected.status === "processing" ? {
-        $set: {
-          ...state,
-          leaseOwner: selected.leaseOwner,
-          leaseToken: selected.leaseToken,
-          leaseExpiresAt: selected.leaseExpiresAt
+  }
+  /** 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
+   * and not in flight in its lane. A keyed candidate is claimable only when
+   * (a) no earlier delivery of its handler and key is pending (a running one is
+   * still a pending document) and (b) no other delivery of them runs. Running
+   * deliveries of a key live in the key's lane, which this owner holds, so the
+   * running keys (loaded once from the held lanes) and this claim's own picks
+   * are all of them.
+   *
+   * Candidates are read in pages with a limit, so no cursor is left open, and
+   * the predecessors of the keys of a page are looked up in parallel, one
+   * lookup per key.
+   */
+  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) }
+    };
+    let after;
+    for (; ; ) {
+      const [page, { keys }] = await Promise.all([
+        this.#state.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(),
+        running
+      ]);
+      if (await this.#pickFromPage(page, { request, scan, picked, keys })) {
+        return;
+      }
+      if (page.length < pageSize) {
+        return;
+      }
+      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
+   * this claim knows nothing about yet, and tells `scan`. The earliest candidate
+   * is itself unfinished, so every later candidate of its key waits at least for it.
+   */
+  async #notePredecessors(page, scan) {
+    const earliest = /* @__PURE__ */ new Map();
+    for (const candidate of page) {
+      if (candidate.key !== void 0) {
+        const orderingId = orderingIdentity(candidate.handler, candidate.key);
+        const known = earliest.get(orderingId);
+        if (!scan.knows(orderingId) && (known?.sequence ?? Infinity) > candidate.sequence) {
+          earliest.set(orderingId, candidate);
         }
-      } : { $set: state, $unset: LEASE_FIELDS }
+      }
+    }
+    await Promise.all(
+      [...earliest].map(async ([orderingId, candidate]) => {
+        const predecessor = await this.#findUnfinishedPredecessor(candidate.handler, {
+          key: candidate.key,
+          sequence: candidate.sequence
+        });
+        scan.noteOpen(orderingId, predecessor ?? candidate.sequence);
+      })
     );
   }
+  /**
+   * 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.#state.logger.warn(
+        `[MongoOrdering](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(
+  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 predecessor?.sequence;
   }
-  /** Whether some delivery of the handler and key runs under a lease that has not expired. */
-  async #hasLiveLease(handler, key, now) {
-    const running = await this.#deliveries.findOne(
-      { handler, key, status: "processing", dueAt: { $gt: now } },
-      { projection: { _id: 1 } }
-    );
-    return running !== null;
-  }
   /**
    * 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
@@ -625,7 +1366,7 @@ var MongoEventStore = class {
    */
   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",
@@ -642,8 +1383,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 } }
@@ -651,103 +1392,809 @@ var MongoEventStore = class {
     if (anyParked === null) {
       return;
     }
-    for (const handler of new Set(handlers)) {
-      let afterKey;
-      for (; ; ) {
-        const lowest = await this.#deliveries.findOne(
+    const lowest = (await Promise.all(
+      [...new Set(handlers)].map(
+        (handler) => this.#state.deliveries.aggregate([
+          { $match: { handler, lane: "parked" } },
+          { $sort: { handler: 1, key: 1, sequence: 1 } },
           {
-            handler,
-            lane: "parked",
-            ...afterKey === void 0 ? {} : { key: { $gt: afterKey } }
-          },
-          { sort: { key: 1, sequence: 1 }, projection: { key: 1, sequence: 1 } }
-        );
-        if (lowest === null) {
-          break;
-        }
-        afterKey = lowest.key;
-        if (await this.#findUnfinishedPredecessor(handler, afterKey, lowest.sequence) === void 0) {
-          await this.#deliveries.updateOne(
-            { _id: lowest._id, lane: "parked" },
-            { $set: { lane: "ready" } }
-          );
-        }
-      }
+            $group: { _id: "$key", id: { $first: "$_id" }, sequence: { $first: "$sequence" } }
+          }
+        ]).toArray().then((groups) => groups.map((group) => ({ ...group, handler })))
+      )
+    )).flat();
+    const next = await Promise.all(
+      lowest.map(
+        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.#state.deliveries.updateMany(
+        { _id: { $in: ready }, lane: "parked" },
+        { $set: { lane: "ready" } }
+      );
     }
   }
-  async #toClaimedDeliveries(leased, leaseExpiresAt) {
-    const events = await this.#readEnvelopes(leased.map((document) => document.eventId));
-    return leased.map((document) => ({
-      deliveryId: document._id,
-      leaseToken: document.leaseToken,
-      handler: document.handler,
-      attempt: document.attempts,
-      leaseExpiresAt,
-      event: events.get(document.eventId)
-    }));
+};
+function isClaimable(candidate, { scan, blockedKeys }) {
+  const { key, sequence } = candidate;
+  if (key === void 0) {
+    return true;
   }
-  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)]));
+  const orderingId = orderingIdentity(candidate.handler, key);
+  if (scan.waits(orderingId, sequence)) {
+    scan.noteWaiting(orderingId, { deliveryId: candidate._id, laneId: candidate.laneId });
+    return false;
   }
-  async #updateLeased(lease, session, update) {
-    const result = await this.#deliveries.updateOne(
-      { _id: lease.deliveryId, status: "processing", leaseToken: lease.leaseToken },
-      update,
-      session === void 0 ? {} : { session }
-    );
-    return result.matchedCount === 1;
+  if (blockedKeys.has(orderingId)) {
+    return false;
+  }
+  blockedKeys.add(orderingId);
+  return true;
+}
+
+// src/mongo-purge.ts
+var MongoPurge = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Implements {@link MongoEventStore.purge}. */
+  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.#state.deliveries.collectionName), {
+          filter: { status: "completed", completedAt: { $lt: completedBefore } },
+          completedBefore
+        })
+      );
+      if (this.#state.completionHistory) {
+        steps.push(
+          () => this.#purgeMatching(this.#purgeable(this.#state.completions.collectionName), {
+            filter: { completedAt: { $lt: completedBefore } },
+            completedBefore
+          })
+        );
+      }
+    }
+    if (deadBefore !== void 0) {
+      steps.push(
+        () => this.#purgeMatching(this.#purgeable(this.#state.deliveries.collectionName), {
+          filter: { 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;
   }
   /**
-   * Deletes batches of matching deliveries together with the events no delivery
-   * references any more, each batch in one transaction, so a crash can never
-   * leave an event without deliveries behind. An append adding a delivery to the
-   * same event writes the event document, so the two conflict and one restarts
-   * instead of leaving a delivery without event. A delivery requeued since the
-   * batch was read conflicts with its deletion and is read again.
+   * Deletes batches of matching documents (deliveries, or completion history
+   * records) together with the events nothing references any more, each batch
+   * in one transaction, so a crash can never leave an event without deliveries
+   * behind. An append adding a delivery to the same event writes the event
+   * document, so the two conflict and one restarts instead of leaving a delivery
+   * without event. A delivery requeued since the batch was read conflicts with
+   * its deletion and is read again.
    */
-  async #purgeMatching(filter) {
+  async #purgeMatching(collection, {
+    filter,
+    completedBefore
+  }) {
     let deletedDeliveries = 0;
     let deletedEvents = 0;
     for (; ; ) {
-      const step = await this.transaction(async (session) => {
-        const batch = await this.#deliveries.find(filter, { session, projection: { eventId: 1 }, limit: this.#purgeBatchSize }).toArray();
+      const step = await runInTransaction(this.#state, async (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 deliveries = await this.#deliveries.deleteMany(
+        const deleted = await collection.deleteMany(
           { _id: { $in: batch.map((document) => document._id) } },
           { session }
         );
-        const stillReferenced = new Set(
-          (await this.#deliveries.find({ eventId: { $in: eventIds } }, { session, projection: { eventId: 1 } }).toArray()).map((document) => document.eventId)
-        );
-        const events = await this.#events.deleteMany(
-          { _id: { $in: eventIds.filter((eventId) => !stillReferenced.has(eventId)) } },
+        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: deliveries.deletedCount,
+          deletedDeliveries: deleted.deletedCount,
           deletedEvents: events.deletedCount
         };
       });
       deletedDeliveries += step.deletedDeliveries;
       deletedEvents += step.deletedEvents;
-      if (step.batchSize < this.#purgeBatchSize) {
+      if (step.batchSize < this.#state.purgeBatchSize) {
         return { deletedDeliveries, deletedEvents };
       }
     }
   }
+  /** A view of a collection that purge deletes from: deliveries or completion history records. */
+  #purgeable(name) {
+    return this.#state.database.collection(name, {
+      readPreference: "primary",
+      writeConcern: { w: "majority" }
+    });
+  }
+  /** Those of `eventIds` that a delivery or a completion history record references. */
+  async #referencedEventIds(eventIds, session) {
+    const filter = { eventId: { $in: [...eventIds] } };
+    const options = { session, projection: { eventId: 1 } };
+    const references = [
+      ...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));
+  }
+  /**
+   * Deletes, in batches, events created before `cutoff` that no delivery (or
+   * completion history record) references. Each batch is found and deleted in
+   * one transaction: an append adding a delivery to one of them writes the
+   * event, so it conflicts with the deletion, which then restarts and sees the
+   * delivery. Returns how many events were deleted.
+   */
+  async #purgeOrphanEvents(cutoff, completedBefore) {
+    const references = [
+      this.#state.deliveries.collectionName,
+      ...this.#state.completionHistory ? [this.#state.completions.collectionName] : []
+    ];
+    let deletedEvents = 0;
+    for (; ; ) {
+      const step = await runInTransaction(this.#state, async (session) => {
+        const orphans = await this.#state.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.#state.purgeBatchSize },
+            { $project: { _id: 1 } }
+          ],
+          { session }
+        ).toArray();
+        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.#state.purgeBatchSize) {
+        return deletedEvents;
+      }
+    }
+  }
+};
+
+// src/mongo-queries.ts
+var DEFAULT_LIST_LIMIT = 100;
+var MongoQueries = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /** 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 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.#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)
+    ]);
+    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)
+    ).slice(0, limit);
+  }
+  /** 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;
+  }
+  /** 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 deliveryPairKey(eventId, handler) {
-  return `${eventId}\0${handler}`;
+function compareText(left, right) {
+  return Number(left > right) - Number(left < right);
 }
-function assertInTransaction(session, operation) {
-  if (!session.inTransaction()) {
+function commonFilter(query) {
+  return {
+    ...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([
+      // 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.#state.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.#state.completionHistory) {
+      await this.#state.completions.createIndexes([
+        { key: { completedAt: 1, _id: 1 }, name: "completed" },
+        { key: { eventId: 1 }, name: "event" },
+        { key: { createdAt: 1, _id: 1 }, name: "created" }
+      ]);
+    }
+  }
+  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 = new Map(
+          (await this.#state.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.#state.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.#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 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) {
+    batch.push(document);
+    if (batch.length === UPGRADE_BATCH_SIZE) {
+      await work(batch);
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    await work(batch);
+  }
+}
+function hasErrorCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+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 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`
+      `collectionPrefix '${prefix}' must be 1-40 characters of letters, digits or '_', starting with a letter or '_'`
     );
   }
 }
+function assertDatabaseName(name) {
+  if (!DATABASE_NAME_PATTERN.test(name)) {
+    throw new ConfigurationError(
+      `database '${name}' must be 1-63 characters of letters, digits, '_' or '-'`
+    );
+  }
+}
+
+// src/mongo-event-store.ts
+var DEFAULT_TRANSACTION_OPTIONS = {
+  readConcern: { level: "snapshot" },
+  writeConcern: { w: "majority" },
+  readPreference: "primary"
+};
+var DEFAULT_PURGE_BATCH_SIZE = 500;
+var MongoEventStore = class {
+  #state;
+  #schema;
+  #appender;
+  #claims;
+  #laneLeases;
+  #completion;
+  #queries;
+  #purger;
+  constructor(options) {
+    const prefix = options.collectionPrefix ?? "relaybus_";
+    assertCollectionPrefix(prefix);
+    if (options.database !== void 0) {
+      assertDatabaseName(options.database);
+    }
+    const purgeBatchSize = assertPositiveInteger(
+      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: createUuidV7(),
+      claimsInProgress: /* @__PURE__ */ new Map(),
+      handedOut: /* @__PURE__ */ new Map(),
+      unreconciledOwners: /* @__PURE__ */ new Set()
+    };
+    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 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 this.#completion.reschedule(lease, { availableAt, error, now });
+  }
+  /** Gives a running delivery back without counting the attempt: pending, due `now`. */
+  release(lease, now) {
+    return this.#completion.release(lease, 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 this.#completion.bury(lease, { 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);
+  }
+};
 
 export { MongoEventStore };
 //# sourceMappingURL=index.js.map