@relaybus/mongodb 0.3.0 → 0.3.1

package/dist/index.cjs

@@ -3,9 +3,7 @@
 var core = require('@relaybus/core');
 var internal = require('@relaybus/core/internal');
 
-// src/mongo-event-store.ts
-
-// src/lanes.ts
+// src/documents.ts
 var LANE_COUNT = 256;
 var FNV_OFFSET_BASIS = 2166136261;
 var FNV_PRIME = 16777619;
@@ -17,16 +15,20 @@ function laneOf(key, eventId) {
   }
   return hash & LANE_COUNT - 1;
 }
+var LEASE_TOKENS = new internal.LaneLeaseTokenFormat({
+  laneCount: LANE_COUNT,
+  epochDigits: 15,
+  claimsDigits: 15
+});
 function formatLeaseToken(laneId, { epoch, claims }) {
-  return `${laneId}:${epoch}:${claims}`;
+  return LEASE_TOKENS.format(laneId, { epoch, claims });
 }
-var LEASE_TOKEN_PATTERN = /^(\d{1,3}):(\d{1,15}):(\d{1,15})$/;
 function parseLeaseToken(token) {
-  const match = LEASE_TOKEN_PATTERN.exec(token);
-  if (match === null || Number(match[1]) >= LANE_COUNT) {
+  const parts = LEASE_TOKENS.parse(token);
+  if (parts === void 0) {
     return void 0;
   }
-  return { laneId: Number(match[1]), epoch: Number(match[2]), claims: Number(match[3]) };
+  return { laneId: parts.lane, epoch: Number(parts.epoch), claims: parts.claims };
 }
 
 // src/documents.ts
@@ -204,9 +206,6 @@ async function runInTransactionWith(state, {
     throw error;
   }
 }
-function leaseKey(deliveryId, leaseToken) {
-  return `${deliveryId}\0${leaseToken}`;
-}
 function assertInTransaction(session, operation) {
   if (!session.inTransaction()) {
     throw new core.ConfigurationError(
@@ -252,16 +251,8 @@ var MongoAppend = class {
     const duplicateEventIds = [];
     const newEvents = [];
     const newDeliveries = [];
-    const knownHandlers = /* @__PURE__ */ new Map();
     const addedHandlers = /* @__PURE__ */ new Map();
-    const orderingByEventId = /* @__PURE__ */ new Map();
-    for (const [eventId, stored] of storedEvents) {
-      orderingByEventId.set(eventId, {
-        key: stored.key ?? null,
-        sequence: stored.sequence ?? null
-      });
-      knownHandlers.set(eventId, new Set(stored.handlers));
-    }
+    const { orderingByEventId, knownHandlers } = indexStoredEvents(storedEvents);
     for (const { event, deliveries } of entries) {
       let ordering = orderingByEventId.get(event.id);
       if (ordering === void 0) {
@@ -291,47 +282,23 @@ var MongoAppend = class {
     const { session, plan, storedEvents, now } = input;
     const { newEvents, newDeliveries, addedHandlers } = plan;
     if (newEvents.length > 0) {
-      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 }
-      );
+      await this.#state.events.bulkWrite(newEventOperations({ newEvents, addedHandlers, now }), {
+        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: eventId },
-            update: { $inc: { revision: 1 }, $push: { handlers: { $each: handlers } } }
-          }
-        })),
-        { session, ordered: true }
-      );
+      await this.#state.events.bulkWrite(extendedEventOperations(extendedEvents), {
+        session,
+        ordered: true
+      });
     }
     if (newDeliveries.length > 0) {
-      await this.#state.deliveries.bulkWrite(
-        newDeliveries.map((document) => ({
-          updateOne: {
-            filter: { eventId: document.eventId, handler: document.handler },
-            update: { $setOnInsert: document },
-            upsert: true
-          }
-        })),
-        { session, ordered: true }
-      );
+      await this.#state.deliveries.bulkWrite(newDeliveryOperations(newDeliveries), {
+        session,
+        ordered: true
+      });
     }
   }
   /** Atomically increments the counter of `key`; conflicting appends of the key serialize here. */
@@ -344,8 +311,52 @@ var MongoAppend = class {
     return counter.value;
   }
 };
-
-// src/claim-scan.ts
+function indexStoredEvents(storedEvents) {
+  const orderingByEventId = /* @__PURE__ */ new Map();
+  const knownHandlers = /* @__PURE__ */ new Map();
+  for (const [eventId, stored] of storedEvents) {
+    orderingByEventId.set(eventId, {
+      key: stored.key ?? null,
+      sequence: stored.sequence ?? null
+    });
+    knownHandlers.set(eventId, new Set(stored.handlers));
+  }
+  return { orderingByEventId, knownHandlers };
+}
+function newEventOperations(input) {
+  const { newEvents, addedHandlers, now } = input;
+  return newEvents.map(({ event, sequence }) => {
+    const document = toEventDocument(event, {
+      sequence,
+      handlers: addedHandlers.get(event.id) ?? [],
+      createdAt: now
+    });
+    return {
+      updateOne: {
+        filter: { _id: document._id },
+        update: { $setOnInsert: document },
+        upsert: true
+      }
+    };
+  });
+}
+function extendedEventOperations(extendedEvents) {
+  return extendedEvents.map(([eventId, handlers]) => ({
+    updateOne: {
+      filter: { _id: eventId },
+      update: { $inc: { revision: 1 }, $push: { handlers: { $each: handlers } } }
+    }
+  }));
+}
+function newDeliveryOperations(newDeliveries) {
+  return newDeliveries.map((document) => ({
+    updateOne: {
+      filter: { eventId: document.eventId, handler: document.handler },
+      update: { $setOnInsert: document },
+      upsert: true
+    }
+  }));
+}
 var ClaimScan = class {
   #keys = /* @__PURE__ */ new Map();
   /** Whether an unfinished delivery this scan knows of comes before the delivery with `sequence`. */
@@ -389,13 +400,104 @@ var ClaimScan = class {
   }
 };
 function orderingIdentity(handler, key) {
-  return `${handler}\0${key}`;
+  return internal.CompositeKey.of(handler, key);
 }
+var MongoLaneReconciler = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /**
+   * 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 reconcile(owner) {
+    await runInTransaction(this.#state, async (session) => {
+      const held = await this.#state.lanes.find({ owner, holder: this.#state.instanceId }, { session }).toArray();
+      const claimsById = await this.#claimGenerations(
+        held.flatMap((lane) => lane.inFlight),
+        session
+      );
+      const { unclaimed, current } = this.#splitUnclaimed(held, claimsById);
+      this.#state.handedOut.forgetWhere(
+        (entry, identity) => entry.owner === owner && !current.has(identity)
+      );
+      if (held.length === 0) {
+        return;
+      }
+      await this.#takeOut(unclaimed, session);
+    });
+  }
+  /** The claim generation now of every listed delivery that is still pending. */
+  async #claimGenerations(listed, session) {
+    return new Map(
+      (await this.#state.deliveries.find({ _id: { $in: listed }, status: "pending" }, { session, projection: { claims: 1 } }).toArray()).map((document) => [document._id, document.claims ?? 0])
+    );
+  }
+  /**
+   * Per held lane, the listed deliveries this instance did not hand out under their current claim,
+   * and the identities of all current claims.
+   */
+  #splitUnclaimed(held, claimsById) {
+    const current = /* @__PURE__ */ new Set();
+    const unclaimed = held.map((lane) => ({
+      lane,
+      ids: lane.inFlight.filter((id) => {
+        const key = internal.DeliveryLeaseIdentity.of(
+          id,
+          formatLeaseToken(lane._id, { epoch: lane.epoch, claims: claimsById.get(id) ?? 0 })
+        );
+        current.add(key);
+        return !this.#state.handedOut.has(key);
+      })
+    }));
+    return { unclaimed, current };
+  }
+  /** Takes the unclaimed deliveries out of their lanes, then moves their claim generation on. */
+  async #takeOut(unclaimed, session) {
+    await this.#state.lanes.bulkWrite(
+      unclaimed.map(({ lane, ids }) => ({
+        updateOne: {
+          filter: { _id: lane._id, epoch: lane.epoch, holder: this.#state.instanceId },
+          update: { $pull: { inFlight: { $in: ids } }, $inc: { revision: 1 } }
+        }
+      })),
+      { session, ordered: false }
+    );
+    await this.#state.deliveries.updateMany(
+      { _id: { $in: unclaimed.flatMap((entry) => entry.ids) }, status: "pending" },
+      { $inc: { claims: 1 } },
+      { session }
+    );
+  }
+};
 
 // src/mongo-claim.ts
 var PARK_BACKLOG_THRESHOLD = 32;
 var INITIAL_LANES_PER_ROUND = 4;
 var LANES_PER_CANDIDATE_QUERY = 128;
+function toClaimedDeliveries(claimed, context) {
+  const { scope, events, request } = context;
+  return claimed.map((document) => ({
+    deliveryId: document._id,
+    leaseToken: formatLeaseToken(document.laneId, {
+      epoch: scope.get(document.laneId).epoch,
+      claims: document.claims ?? 0
+    }),
+    handler: document.handler,
+    attempt: document.attempts + 1,
+    leaseExpiresAt: request.leaseExpiresAt,
+    event: events.get(document.eventId)
+  }));
+}
 function scopeOf(held) {
   return new Map(
     held.map((lane) => [
@@ -409,33 +511,23 @@ function scopeOf(held) {
     ])
   );
 }
-var MongoClaims = class {
+var MongoClaims = class extends internal.OwnerSerializedClaims {
   #state;
   #laneLeases;
   #ordering;
   #queries;
+  #reconciler;
   constructor(state, collaborators) {
+    super();
     this.#state = state;
     this.#laneLeases = collaborators.laneLeases;
     this.#ordering = collaborators.ordering;
     this.#queries = collaborators.queries;
+    this.#reconciler = new MongoLaneReconciler(state);
   }
-  /** Implements {@link MongoEventStore.claim}. */
-  async claim(request) {
-    if (request.handlers.length === 0 || request.limit <= 0) {
-      return [];
-    }
-    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;
+  /** Mongo claims nothing for a limit of 0 or below (a limit that is not a number is tried). */
+  claimsNothing(request) {
+    return request.handlers.length === 0 || request.limit <= 0;
   }
   /**
    * Runs one claim and remembers what it hands out. When the claim fails at any
@@ -445,17 +537,17 @@ var MongoClaims = class {
    * handed out and seen settled, is taken out of them, so nothing stays listed
    * as running that nobody runs.
    */
-  async #claimReconciled(request) {
+  async claimInTurn(request) {
     const owner = request.leaseOwner;
     if (this.#state.unreconciledOwners.has(owner)) {
-      await this.#reconcileLanes(owner);
+      await this.#reconciler.reconcile(owner);
       this.#state.unreconciledOwners.delete(owner);
     }
     try {
       const claimed = await this.#claimNow(request);
       for (const delivery of claimed) {
         const { laneId, epoch } = parseLeaseToken(delivery.leaseToken);
-        this.#state.handedOut.set(leaseKey(delivery.deliveryId, delivery.leaseToken), {
+        this.#state.handedOut.register(delivery, {
           deliveryId: delivery.deliveryId,
           owner: request.leaseOwner,
           laneId,
@@ -464,80 +556,15 @@ var MongoClaims = class {
       }
       return claimed;
     } catch (error) {
-      const [reconciled] = await Promise.allSettled([this.#reconcileLanes(owner)]);
+      const [reconciled] = await Promise.allSettled([this.#reconciler.reconcile(owner)]);
       if (reconciled.status === "rejected") {
         this.#state.unreconciledOwners.add(owner);
       }
       throw error;
     }
   }
-  /**
-   * Takes every delivery this instance does not run out of the lanes `owner`
-   * holds on it: every listed delivery whose current claim (lane epoch and
-   * claim generation now) was not handed out by this instance, or was settled.
-   * One transaction, and the lanes are written first under their epoch and
-   * holder: a worker taking a lane over meanwhile conflicts with it, so its
-   * claim is never touched. The claim generation of every delivery taken out
-   * moves on, so no lease of those claims (a completion that failed and is
-   * retried later, say) can ever match a later claim of the same delivery.
-   * Registrations of this owner that are not the current claim of a listed
-   * delivery are dropped.
-   */
-  async #reconcileLanes(owner) {
-    await 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)
-    ]);
+    const held = await this.#readHeldLanes(request);
     await this.#laneLeases.chargeLost(held);
     const scope = scopeOf(held);
     const running = this.#loadRunning(held);
@@ -557,17 +584,19 @@ var MongoClaims = class {
       scope
     );
     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)
-    }));
+    return toClaimedDeliveries(claimed, { scope, events, request });
+  }
+  /** The lanes the owner holds on this instance, read while the next deliveries are unparked. */
+  async #readHeldLanes(request) {
+    const [held] = await Promise.all([
+      this.#state.lanes.find({
+        owner: request.leaseOwner,
+        holder: this.#state.instanceId,
+        leaseExpiresAt: { $gt: request.now }
+      }).toArray(),
+      this.#ordering.unparkNextDeliveries(request.handlers)
+    ]);
+    return held;
   }
   /** The deliveries still running in the held lanes, with their (handler, key) identities. */
   #loadRunning(held) {
@@ -629,14 +658,12 @@ var MongoClaims = class {
   #forgetSettled(held, { runningIds, owner }) {
     const gone = new Set(
       held.flatMap(
-        (lane) => lane.inFlight.filter((id) => !runningIds.has(id)).map((id) => `${id}\0${lane._id}:${lane.epoch}`)
+        (lane) => lane.inFlight.filter((id) => !runningIds.has(id)).map((id) => internal.CompositeKey.of(id, `${lane._id}:${lane.epoch}`))
       )
     );
-    for (const [key, entry] of this.#state.handedOut) {
-      if (entry.owner === owner && gone.has(`${entry.deliveryId}\0${entry.laneId}:${entry.epoch}`)) {
-        this.#state.handedOut.delete(key);
-      }
-    }
+    this.#state.handedOut.forgetWhere(
+      (entry) => entry.owner === owner && gone.has(internal.CompositeKey.of(entry.deliveryId, `${entry.laneId}:${entry.epoch}`))
+    );
   }
   /**
    * Gives back the recorded keyed picks that a delivery requeued during the
@@ -698,20 +725,34 @@ var MongoClaims = class {
     );
   }
 };
-
-// src/mongo-completion.ts
 var FINISHED_FIELDS = { dueAt: "", lane: "" };
-var MongoCompletion = class {
+var MongoCompletion = class extends internal.LeaseSettlement {
   #state;
   constructor(state) {
+    super();
     this.#state = state;
   }
-  /** Implements {@link MongoEventStore.extendLease}. */
-  async extendLease(lease, leaseExpiresAt) {
-    const held = parseLeaseToken(lease.leaseToken);
-    if (held === void 0) {
-      return false;
+  /** Implements {@link MongoEventStore.complete}. */
+  async complete(lease, { now, session }) {
+    if (session !== void 0) {
+      assertInTransaction(session, "complete");
     }
+    return (await this.#completeLeases([lease], { now, session }))[0];
+  }
+  /** Implements {@link MongoEventStore.completeMany}. */
+  completeMany(leases, now) {
+    return this.#completeLeases(leases, { now, session: void 0 });
+  }
+  /** A lease this store issued; any other token cannot be held. */
+  findHeld(lease) {
+    return parseLeaseToken(lease.leaseToken);
+  }
+  /**
+   * Renews the lane lease of a running claim. One transaction: a stale lease must not extend the
+   * lane of a newer claim of the delivery. A claim ending or starting meanwhile writes the delivery
+   * or the lane, so the two conflict.
+   */
+  writeExtension(held, { lease, leaseExpiresAt }) {
     const deliveryId = String(lease.deliveryId);
     return runInTransaction(this.#state, async (session) => {
       const running = await this.#state.deliveries.findOne(ofClaim({ ...held, deliveryId }), {
@@ -729,41 +770,26 @@ var MongoCompletion = class {
       return renewed.matchedCount === 1;
     });
   }
-  /** Implements {@link MongoEventStore.complete}. */
-  async complete(lease, { now, session }) {
-    if (session !== void 0) {
-      assertInTransaction(session, "complete");
-    }
-    return (await this.#completeLeases([lease], { now, session }))[0];
-  }
-  /** Implements {@link MongoEventStore.completeMany}. */
-  completeMany(leases, now) {
-    return this.#completeLeases(leases, { now, session: void 0 });
-  }
-  /** 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 }
+  /**
+   * Applies the change to the running delivery and takes it out of its lane's in-flight list, if
+   * the lane still has the lease's epoch.
+   */
+  writeChange(held, { lease, change }) {
+    const deliveryId = String(lease.deliveryId);
+    return this.#leaveFlightNow(held, {
+      deliveryId,
+      ofThisClaim: ofClaim({ ...held, deliveryId }),
+      update: updateFor(change)
     });
   }
-  /** Implements {@link MongoEventStore.release}. */
-  async release(lease, now) {
-    return this.#leaveFlight(lease, {
-      $set: { availableAt: now, dueAt: now, updatedAt: now },
-      $inc: { claims: 1 }
-    });
+  forgetHandedOut(lease) {
+    this.#forget(lease);
   }
-  /** 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 }
+  /** Forgets a lease as handed out: its claim ended. */
+  #forget(lease) {
+    this.#state.handedOut.forget({
+      deliveryId: String(lease.deliveryId),
+      leaseToken: String(lease.leaseToken)
     });
   }
   /**
@@ -775,7 +801,7 @@ var MongoCompletion = class {
   async #settle(leases, operation) {
     const result = await operation();
     for (const lease of leases) {
-      this.#state.handedOut.delete(leaseKey(String(lease.deliveryId), String(lease.leaseToken)));
+      this.#forget(lease);
     }
     return result;
   }
@@ -902,23 +928,7 @@ var MongoCompletion = class {
       session === void 0 ? {} : { session }
     );
   }
-  /**
-   * Applies `update` to a running delivery and takes it out of its lane's
-   * in-flight list, if the lane still has the lease's epoch. One transaction:
-   * the lane write fences the change against a takeover.
-   */
-  async #leaveFlight(lease, update) {
-    const held = parseLeaseToken(lease.leaseToken);
-    if (held === void 0) {
-      return false;
-    }
-    const deliveryId = String(lease.deliveryId);
-    const ofThisClaim = ofClaim({ ...held, deliveryId });
-    return this.#settle(
-      [lease],
-      () => this.#leaveFlightNow(held, { deliveryId, ofThisClaim, update })
-    );
-  }
+  /** One transaction: the lane write fences the change against a takeover. */
   async #leaveFlightNow(held, {
     deliveryId,
     ofThisClaim,
@@ -959,7 +969,28 @@ 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 })}`;
+  return internal.DeliveryLeaseIdentity.of(
+    lease.deliveryId,
+    formatLeaseToken(lease.laneId, { epoch: lease.epoch, claims: lease.claims })
+  );
+}
+function updateFor(change) {
+  if (change.kind === "reschedule") {
+    const { availableAt, error, now } = change;
+    return {
+      $set: { availableAt, dueAt: availableAt, lastError: toErrorInfo(error), updatedAt: now },
+      $inc: { attempts: 1, claims: 1 }
+    };
+  }
+  if (change.kind === "release") {
+    const { now } = change;
+    return { $set: { availableAt: now, dueAt: now, updatedAt: now }, $inc: { claims: 1 } };
+  }
+  return {
+    $set: { status: "dead", lastError: toErrorInfo(change.error), updatedAt: change.now },
+    $unset: FINISHED_FIELDS,
+    $inc: { attempts: 1, claims: 1 }
+  };
 }
 
 // src/mongo-lane-leases.ts
@@ -1108,10 +1139,36 @@ var MongoLaneLeases = class {
     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, handedBack } = this.#planLaneRecords(scope, {
+      picksByLane,
+      runningIds,
+      request
+    });
+    if (operations.length === 0) {
+      return { recorded: /* @__PURE__ */ new Set(), handedBack };
+    }
+    const result = await this.#state.lanes.bulkWrite(operations, { ordered: false });
+    if (result.matchedCount === operations.length) {
+      return { recorded: new Set(picksByLane.keys()), handedBack };
+    }
+    return {
+      recorded: await this.#readRecorded(scope, { laneIds: [...picksByLane.keys()], request }),
+      handedBack
+    };
+  }
+  /**
+   * One conditional write per lane of the claim: a picked lane records its picks, a lane that
+   * yielded nothing and runs nothing is freed (and reported as handed back).
+   */
+  #planLaneRecords(scope, {
+    picksByLane,
+    runningIds,
+    request
+  }) {
+    const handedBack = /* @__PURE__ */ new Set();
     const operations = [];
     for (const lane of scope.values()) {
       const gone = lane.listed.filter((id) => !runningIds.has(id));
@@ -1127,17 +1184,7 @@ var MongoLaneLeases = class {
         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
-    };
+    return { operations, handedBack };
   }
   /** The lanes of `laneIds` whose record of this claim applied, read back after a partial bulk write. */
   async #readRecorded(scope, { laneIds, request }) {
@@ -1255,30 +1302,11 @@ var MongoOrdering = class {
   async pickCandidates(input) {
     const { lanes, request, scan, running, picked } = input;
     const pageSize = Math.max((request.limit - picked.length) * 2, MINIMUM_CANDIDATE_BATCH_SIZE);
-    const filter = {
-      laneId: { $in: lanes.map((lane) => lane.laneId) },
-      handler: { $in: [...request.handlers] },
-      lane: "ready",
-      dueAt: { $lte: request.now },
-      _id: { $nin: lanes.flatMap((lane) => lane.listed) }
-    };
+    const filter = candidateFilter(lanes, request);
     let after;
     for (; ; ) {
       const [page, { keys }] = await Promise.all([
-        this.#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(),
+        this.#state.deliveries.find(pageAfter(filter, after), { sort: { dueAt: 1, _id: 1 }, limit: pageSize }).toArray(),
         running
       ]);
       if (await this.#pickFromPage(page, { request, scan, picked, keys })) {
@@ -1394,17 +1422,7 @@ var MongoOrdering = class {
     if (anyParked === null) {
       return;
     }
-    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 } },
-          {
-            $group: { _id: "$key", id: { $first: "$_id" }, sequence: { $first: "$sequence" } }
-          }
-        ]).toArray().then((groups) => groups.map((group) => ({ ...group, handler })))
-      )
-    )).flat();
+    const lowest = await this.#lowestParkedPerKey(handlers);
     const next = await Promise.all(
       lowest.map(
         async (parked) => await this.#findUnfinishedPredecessor(parked.handler, {
@@ -1421,7 +1439,46 @@ var MongoOrdering = class {
       );
     }
   }
+  /**
+   * The lowest parked delivery of every parked key of `handlers`, one aggregation per handler in
+   * parallel.
+   */
+  async #lowestParkedPerKey(handlers) {
+    return (await Promise.all(
+      [...new Set(handlers)].map(
+        (handler) => this.#state.deliveries.aggregate([
+          { $match: { handler, lane: "parked" } },
+          { $sort: { handler: 1, key: 1, sequence: 1 } },
+          {
+            $group: { _id: "$key", id: { $first: "$_id" }, sequence: { $first: "$sequence" } }
+          }
+        ]).toArray().then((groups) => groups.map((group) => ({ ...group, handler })))
+      )
+    )).flat();
+  }
 };
+function candidateFilter(lanes, request) {
+  return {
+    laneId: { $in: lanes.map((lane) => lane.laneId) },
+    handler: { $in: [...request.handlers] },
+    lane: "ready",
+    dueAt: { $lte: request.now },
+    _id: { $nin: lanes.flatMap((lane) => lane.listed) }
+  };
+}
+function pageAfter(filter, after) {
+  return after === void 0 ? filter : {
+    $and: [
+      filter,
+      {
+        $or: [
+          { dueAt: { $gt: after.dueAt } },
+          { dueAt: after.dueAt, _id: { $gt: after._id } }
+        ]
+      }
+    ]
+  };
+}
 function isClaimable(candidate, { scan, blockedKeys }) {
   const { key, sequence } = candidate;
   if (key === void 0) {
@@ -1448,6 +1505,21 @@ var MongoPurge = class {
   /** Implements {@link MongoEventStore.purge}. */
   async purge(request) {
     const total = { deletedDeliveries: 0, deletedEvents: 0 };
+    const steps = this.#purgeSteps(request);
+    const { completedBefore, deadBefore } = request;
+    for (const step of steps) {
+      const result = await step();
+      total.deletedDeliveries += result.deletedDeliveries;
+      total.deletedEvents += result.deletedEvents;
+    }
+    const 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;
+  }
+  /** The purges the request asks for, in the order they run. */
+  #purgeSteps(request) {
     const steps = [];
     const { completedBefore, deadBefore } = request;
     if (completedBefore !== void 0) {
@@ -1474,16 +1546,7 @@ var MongoPurge = class {
         })
       );
     }
-    for (const step of steps) {
-      const result = await step();
-      total.deletedDeliveries += result.deletedDeliveries;
-      total.deletedEvents += result.deletedEvents;
-    }
-    const orphanCutoff = [completedBefore, deadBefore].filter((cutoff) => cutoff !== void 0).sort((first, second) => first.getTime() - second.getTime())[0];
-    if (orphanCutoff !== void 0) {
-      total.deletedEvents += await this.#purgeOrphanEvents(orphanCutoff, completedBefore);
-    }
-    return total;
+    return steps;
   }
   /**
    * Deletes batches of matching documents (deliveries, or completion history
@@ -1501,35 +1564,10 @@ var MongoPurge = class {
     let deletedDeliveries = 0;
     let deletedEvents = 0;
     for (; ; ) {
-      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 deleted = await collection.deleteMany(
-          { _id: { $in: batch.map((document) => document._id) } },
-          { session }
-        );
-        const stillReferenced = await this.#referencedEventIds(eventIds, session);
-        const events = await this.#state.events.deleteMany(
-          {
-            _id: { $in: eventIds.filter((eventId) => !stillReferenced.has(eventId)) },
-            // An event a delivery of which completed stays as deduplication record until
-            // `completedBefore` passes its last completion, whatever this batch purged.
-            $or: [
-              { completedAt: { $exists: false } },
-              ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
-            ]
-          },
-          { session }
-        );
-        return {
-          batchSize: batch.length,
-          deletedDeliveries: deleted.deletedCount,
-          deletedEvents: events.deletedCount
-        };
-      });
+      const step = await runInTransaction(
+        this.#state,
+        (session) => this.#purgeBatch(collection, { filter, completedBefore, session })
+      );
       deletedDeliveries += step.deletedDeliveries;
       deletedEvents += step.deletedEvents;
       if (step.batchSize < this.#state.purgeBatchSize) {
@@ -1537,6 +1575,40 @@ var MongoPurge = class {
       }
     }
   }
+  /** One batch of {@link MongoPurge.#purgeMatching}, inside the caller's transaction. */
+  async #purgeBatch(collection, {
+    filter,
+    completedBefore,
+    session
+  }) {
+    const batch = await collection.find(filter, { session, projection: { eventId: 1 }, limit: this.#state.purgeBatchSize }).toArray();
+    if (batch.length === 0) {
+      return { batchSize: 0, deletedDeliveries: 0, deletedEvents: 0 };
+    }
+    const eventIds = [...new Set(batch.map((document) => document.eventId))];
+    const deleted = await collection.deleteMany(
+      { _id: { $in: batch.map((document) => document._id) } },
+      { session }
+    );
+    const stillReferenced = await this.#referencedEventIds(eventIds, session);
+    const events = await this.#state.events.deleteMany(
+      {
+        _id: { $in: eventIds.filter((eventId) => !stillReferenced.has(eventId)) },
+        // An event a delivery of which completed stays as deduplication record until
+        // `completedBefore` passes its last completion, whatever this batch purged.
+        $or: [
+          { completedAt: { $exists: false } },
+          ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
+        ]
+      },
+      { session }
+    );
+    return {
+      batchSize: batch.length,
+      deletedDeliveries: deleted.deletedCount,
+      deletedEvents: events.deletedCount
+    };
+  }
   /** A view of a collection that purge deletes from: deliveries or completion history records. */
   #purgeable(name) {
     return this.#state.database.collection(name, {
@@ -1570,33 +1642,12 @@ var MongoPurge = class {
     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 } }
-          ],
+          orphanPipeline({
+            cutoff,
+            completedBefore,
+            references,
+            limit: this.#state.purgeBatchSize
+          }),
           { session }
         ).toArray();
         const deleted = await this.#state.events.deleteMany(
@@ -1612,6 +1663,36 @@ var MongoPurge = class {
     }
   }
 };
+function orphanPipeline(input) {
+  const { cutoff, completedBefore, references, limit } = input;
+  return [
+    {
+      $match: {
+        $or: [
+          // Never completed (no subscribers, or every delivery dead): by age.
+          { completedAt: { $exists: false }, createdAt: { $lt: cutoff } },
+          // Completed: by the time of its last completion, and only under the completed cutoff.
+          ...completedBefore === void 0 ? [] : [{ completedAt: { $lt: completedBefore } }]
+        ]
+      }
+    },
+    { $sort: { createdAt: 1, _id: 1 } },
+    ...references.flatMap((from) => [
+      {
+        $lookup: {
+          from,
+          localField: "_id",
+          foreignField: "eventId",
+          pipeline: [{ $limit: 1 }, { $project: { _id: 1 } }],
+          as: "references"
+        }
+      },
+      { $match: { references: { $size: 0 } } }
+    ]),
+    { $limit: limit },
+    { $project: { _id: 1 } }
+  ];
+}
 
 // src/mongo-queries.ts
 var DEFAULT_LIST_LIMIT = 100;
@@ -1627,14 +1708,7 @@ var MongoQueries = class {
     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 filter = { ...common, ...statusFilter(status, listed) };
     const sort = { createdAt: 1, _id: 1 };
     const documents = await this.#state.deliveries.find(filter, { sort, limit }).toArray();
     const history = this.#state.completionHistory && (status === void 0 || status === "completed") ? await this.#state.completions.find(common, { sort, limit }).toArray() : [];
@@ -1642,23 +1716,7 @@ var MongoQueries = class {
       ...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);
+    return toSortedRecords({ documents, history, events, lanes }).slice(0, limit);
   }
   /** Implements {@link MongoEventStore.requeue}. */
   async requeue(deliveryIds, now) {
@@ -1713,7 +1771,7 @@ var MongoQueries = class {
       return [];
     }
     return this.#state.deliveries.find(
-      { _id: { $in: [...listed] }, status: "pending" },
+      { _id: { $in: listed }, status: "pending" },
       { projection: { handler: 1, key: 1, laneId: 1 } }
     ).toArray();
   }
@@ -1722,6 +1780,36 @@ var MongoQueries = class {
     return new Map(documents.map((document) => [document._id, toEnvelope(document)]));
   }
 };
+function statusFilter(status, listed) {
+  if (status === void 0) {
+    return {};
+  }
+  const derivedStatuses = /* @__PURE__ */ new Map([
+    ["processing", { status: "pending", _id: { $in: listed } }],
+    ["pending", { status: "pending", _id: { $nin: listed } }]
+  ]);
+  return derivedStatuses.get(status) ?? { status };
+}
+function toSortedRecords(input) {
+  const { documents, history, events, lanes } = input;
+  const laneById = new Map(lanes.map((lane) => [lane._id, lane]));
+  const records = [
+    ...documents.map((document) => {
+      const lane = laneById.get(document.laneId);
+      const runs = document.status === "pending" && lane?.inFlight.includes(document._id) === true;
+      return toDeliveryRecord(document, {
+        event: events.get(document.eventId),
+        runningIn: runs ? lane : void 0
+      });
+    }),
+    ...history.map(
+      (document) => toCompletedDeliveryRecord(document, events.get(document.eventId))
+    )
+  ];
+  return records.sort(
+    (left, right) => left.createdAt.getTime() - right.createdAt.getTime() || compareText(left.id, right.id)
+  );
+}
 function compareText(left, right) {
   return Number(left > right) - Number(left < right);
 }
@@ -1771,54 +1859,10 @@ var MongoSchema = class {
   }
   /** 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 } }
-      }
-    ]);
+    await this.#state.deliveries.createIndexes(deliveryIndexes());
+    await this.#state.events.createIndexes(eventIndexes());
     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" }
-      ]);
+      await this.#state.completions.createIndexes(completionIndexes());
     }
   }
   async #createCollectionIfMissing(name) {
@@ -1881,36 +1925,29 @@ var MongoSchema = class {
         { 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])
-        );
+        const known = await this.#legacyEventGroups(events.map((event) => event._id));
         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 }
-                }
-              }
-            };
-          }),
+          events.map((event) => convertEvent(event, known.get(event._id))),
           { ordered: false }
         );
       }
     );
   }
+  /** The handlers and first creation time of the deliveries of each of `eventIds`, by event id. */
+  async #legacyEventGroups(eventIds) {
+    return new Map(
+      (await this.#state.deliveries.aggregate([
+        { $match: { eventId: { $in: [...eventIds] } } },
+        {
+          $group: {
+            _id: "$eventId",
+            handlers: { $addToSet: "$handler" },
+            createdAt: { $min: "$createdAt" }
+          }
+        }
+      ]).toArray()).map((group) => [group._id, group])
+    );
+  }
   /** Creates the lane documents that do not exist yet. */
   async #seedLanes() {
     await this.#state.lanes.bulkWrite(
@@ -1951,6 +1988,70 @@ var MongoSchema = class {
     }
   }
 };
+function deliveryIndexes() {
+  return [
+    // Idempotent appends and lookups by event.
+    { key: { eventId: 1, handler: 1 }, name: "event_handler", unique: true },
+    // Claim: due work of a lane in due order. Holds ready deliveries only. The handler is
+    // last, so a query over many lanes and handlers stays a merge of one scan per lane.
+    { key: CLAIM_INDEX_KEY, name: "claim", partialFilterExpression: { lane: "ready" } },
+    // Ordering: unfinished predecessors of a keyed delivery, parked or not.
+    {
+      key: { handler: 1, key: 1, sequence: 1 },
+      name: "ordering",
+      partialFilterExpression: { dueAt: { $exists: true }, sequence: { $exists: true } }
+    },
+    // Parked deliveries: the lowest parked delivery of each key, to move it back once it is next.
+    {
+      key: { handler: 1, key: 1, sequence: 1 },
+      name: "parked",
+      partialFilterExpression: { lane: "parked" }
+    },
+    // Statistics: oldest due delivery across handlers.
+    { key: { dueAt: 1 }, name: "due", partialFilterExpression: { dueAt: { $exists: true } } },
+    // Purge of completed deliveries left by 0.1.0.
+    {
+      key: { completedAt: 1 },
+      name: "completed",
+      partialFilterExpression: { completedAt: { $exists: true } }
+    },
+    // Listing and status counts.
+    { key: { status: 1, createdAt: 1 }, name: "status_created" },
+    // Purge of dead deliveries.
+    { key: { status: 1, updatedAt: 1 }, name: "status_updated" },
+    { key: { handler: 1, createdAt: 1 }, name: "handler_created" },
+    { key: { eventType: 1, createdAt: 1 }, name: "type_created" }
+  ];
+}
+function eventIndexes() {
+  return [
+    { key: { createdAt: 1, _id: 1 }, name: "created" },
+    // Purge of events whose deliveries all completed: they are kept until `completedBefore` passes this.
+    {
+      key: { completedAt: 1, _id: 1 },
+      name: "completed",
+      partialFilterExpression: { completedAt: { $exists: true } }
+    }
+  ];
+}
+function completionIndexes() {
+  return [
+    { key: { completedAt: 1, _id: 1 }, name: "completed" },
+    { key: { eventId: 1 }, name: "event" },
+    { key: { createdAt: 1, _id: 1 }, name: "created" }
+  ];
+}
+function convertEvent(event, group) {
+  return {
+    updateOne: {
+      // Only an event nobody converted yet: another process may have finished and subscribed a handler.
+      filter: { _id: event._id, handlers: { $exists: false } },
+      update: {
+        $set: group === void 0 ? { handlers: [], createdAt: event.occurredAt } : { handlers: group.handlers, createdAt: group.createdAt }
+      }
+    }
+  };
+}
 function isObsoleteIndex(index) {
   return OBSOLETE_INDEXES.includes(index.name) || index.name === "claim" && Object.keys(index.key).join() !== Object.keys(CLAIM_INDEX_KEY).join();
 }
@@ -1987,13 +2088,48 @@ function assertDatabaseName(name) {
   }
 }
 
-// src/mongo-event-store.ts
+// src/mongo-store-factory.ts
 var DEFAULT_TRANSACTION_OPTIONS = {
   readConcern: { level: "snapshot" },
   writeConcern: { w: "majority" },
   readPreference: "primary"
 };
 var DEFAULT_PURGE_BATCH_SIZE = 500;
+function createMongoStoreState(options) {
+  const prefix = options.collectionPrefix ?? "relaybus_";
+  assertCollectionPrefix(prefix);
+  if (options.database !== void 0) {
+    assertDatabaseName(options.database);
+  }
+  const purgeBatchSize = internal.PositiveInteger.of(
+    options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE,
+    "purgeBatchSize"
+  );
+  const database = options.client.db(options.database);
+  const collectionOptions = {
+    readPreference: "primary",
+    writeConcern: { w: "majority" }
+  };
+  const state = {
+    client: options.client,
+    database,
+    events: database.collection(`${prefix}events`, collectionOptions),
+    deliveries: database.collection(`${prefix}deliveries`, collectionOptions),
+    keySequences: database.collection(`${prefix}key_sequences`, collectionOptions),
+    lanes: database.collection(`${prefix}lanes`, collectionOptions),
+    completions: database.collection(`${prefix}completed_deliveries`, collectionOptions),
+    completionHistory: options.completionHistory ?? false,
+    transactionOptions: options.transactionOptions ?? DEFAULT_TRANSACTION_OPTIONS,
+    purgeBatchSize,
+    logger: options.logger ?? console,
+    instanceId: core.createUuidV7(),
+    handedOut: new internal.HandedOutLedger(),
+    unreconciledOwners: /* @__PURE__ */ new Set()
+  };
+  return state;
+}
+
+// src/mongo-event-store.ts
 var MongoEventStore = class {
   #state;
   #schema;
@@ -2004,37 +2140,7 @@ var MongoEventStore = class {
   #queries;
   #purger;
   constructor(options) {
-    const prefix = options.collectionPrefix ?? "relaybus_";
-    assertCollectionPrefix(prefix);
-    if (options.database !== void 0) {
-      assertDatabaseName(options.database);
-    }
-    const purgeBatchSize = internal.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: core.createUuidV7(),
-      claimsInProgress: /* @__PURE__ */ new Map(),
-      handedOut: /* @__PURE__ */ new Map(),
-      unreconciledOwners: /* @__PURE__ */ new Set()
-    };
+    const state = createMongoStoreState(options);
     this.#state = state;
     const queries = new MongoQueries(state);
     const ordering = new MongoOrdering(state);
@@ -2117,7 +2223,7 @@ var MongoEventStore = class {
    */
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   extendLease(lease, leaseExpiresAt, _now) {
-    return this.#completion.extendLease(lease, leaseExpiresAt);
+    return Promise.resolve(this.#completion.extendLease({ lease, leaseExpiresAt }));
   }
   /**
    * Deletes the delivery (and records it in the completion history, when kept).
@@ -2141,16 +2247,25 @@ var MongoEventStore = class {
   /** 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 });
+    return Promise.resolve(
+      this.#completion.changeClaim({
+        lease,
+        change: { kind: "reschedule", availableAt, error, now }
+      })
+    );
   }
   /** Gives a running delivery back without counting the attempt: pending, due `now`. */
   release(lease, now) {
-    return this.#completion.release(lease, now);
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "release", now } })
+    );
   }
   /** Moves a running delivery to dead and counts the attempt that ended. */
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   bury(lease, error, now) {
-    return this.#completion.bury(lease, { error, now });
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "bury", error, now } })
+    );
   }
   /**
    * Frees every lane `leaseOwner` holds that runs no delivery, so other workers