@relaybus/core 0.3.0 → 0.3.1

package/dist/index.js

@@ -1,5 +1,5 @@
-import { ConfigurationError, assertEventType, NonRetryableError, LifecycleError, DrainIncompleteError, toErrorInfo, schedule, TransactionRequiredError, validatePayload, keyFromDefinition, assertPositiveInteger, DispatcherStoppedError, AttemptsExhaustedError, LeaseLostError, HandlerTimeoutError, TransactionTimeoutError, InvalidEnvelopeError } from './chunk-WS274DL3.js';
-export { AttemptsExhaustedError, ConfigurationError, DispatcherStoppedError, DrainIncompleteError, EventValidationError, HandlerTimeoutError, InvalidEnvelopeError, LeaseLostError, LifecycleError, NonRetryableError, RelayBusError, TransactionRequiredError, TransactionTimeoutError, assertEventType, defineEvent, toErrorInfo, validatePayload } from './chunk-WS274DL3.js';
+import { ConfigurationError, assertEventType, CompositeKey, Milliseconds, NonRetryableError, DrainIncompleteError, LifecycleError, schedule, toErrorInfo, LeaseSettlement, TransactionTimeoutError, PositiveInteger, DispatcherStoppedError, DeliveryLeaseIdentity, LeaseLostError, AttemptsExhaustedError, validatePayload, HandlerTimeoutError, TransactionRequiredError, keyFromDefinition, InvalidEnvelopeError } from './chunk-NOR5JHVN.js';
+export { AttemptsExhaustedError, ConfigurationError, DispatcherStoppedError, DrainIncompleteError, EventValidationError, HandlerTimeoutError, InvalidEnvelopeError, LeaseLostError, LifecycleError, MAX_TIMER_DELAY_MS, NonRetryableError, RelayBusError, TransactionRequiredError, TransactionTimeoutError, assertEventType, defineEvent, toErrorInfo, toMilliseconds, validatePayload } from './chunk-NOR5JHVN.js';
 import { randomBytes } from 'crypto';
 import { AsyncLocalStorage } from 'async_hooks';
 import { hostname } from 'os';
@@ -9,47 +9,6 @@ var systemClock = {
   now: () => /* @__PURE__ */ new Date()
 };
 
-// src/duration.ts
-var MILLISECONDS_PER_UNIT = {
-  ms: 1,
-  s: 1e3,
-  m: 6e4,
-  h: 36e5,
-  d: 864e5
-};
-var DURATION_PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/;
-function toMilliseconds(value, name) {
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || value < 0) {
-      throw new ConfigurationError(
-        `${name} must be a non-negative finite number of milliseconds, received ${value}`
-      );
-    }
-    return value;
-  }
-  const match = DURATION_PATTERN.exec(value);
-  if (match === null) {
-    throw new ConfigurationError(
-      `${name} must look like '500ms', '30s', '5m', '1h' or '7d', received '${value}'`
-    );
-  }
-  const [, amount, unit] = match;
-  return Number(amount) * MILLISECONDS_PER_UNIT[unit];
-}
-var MAX_TIMER_DELAY_MS = 2147483647;
-function toTimerMilliseconds(value, name) {
-  const milliseconds = toMilliseconds(value, name);
-  if (milliseconds === 0) {
-    throw new ConfigurationError(`${name} must be greater than zero`);
-  }
-  if (milliseconds > MAX_TIMER_DELAY_MS) {
-    throw new ConfigurationError(
-      `${name} must not exceed ${MAX_TIMER_DELAY_MS}ms (about 24.8 days), received ${milliseconds}ms`
-    );
-  }
-  return milliseconds;
-}
-
 // src/catalog.ts
 var EVENT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var descriptions = /* @__PURE__ */ new WeakMap();
@@ -340,6 +299,302 @@ function createUuidV7(timestamp = Date.now()) {
   return bytes.toString("hex").replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
 }
 
+// src/in-memory/stored-records.ts
+function applyTransition(delivery, change) {
+  if (change.kind === "reschedule") {
+    delivery.status = "pending";
+    delivery.availableAt = change.availableAt;
+    delivery.lastError = change.error;
+  } else if (change.kind === "release") {
+    delivery.status = "pending";
+    delivery.attempts -= 1;
+    delivery.availableAt = change.now;
+  } else {
+    delivery.status = "dead";
+    delivery.lastError = change.error;
+  }
+  delivery.updatedAt = change.now;
+  clearLease(delivery);
+}
+function blocksKey(other, { delivery, now }) {
+  if (other === delivery || other.handler !== delivery.handler || other.key !== delivery.key) {
+    return false;
+  }
+  const unfinishedPredecessor = other.sequence < delivery.sequence && (other.status === "pending" || other.status === "processing");
+  const runningUnderLiveLease = other.status === "processing" && other.leaseExpiresAt > now;
+  return unfinishedPredecessor || runningUnderLiveLease;
+}
+function eventCutoffs(request) {
+  const cutoffs = [request.completedBefore, request.deadBefore].filter((cutoff) => cutoff !== void 0).map((cutoff) => cutoff.getTime());
+  return {
+    orphanCutoff: cutoffs.length === 0 ? Number.NEGATIVE_INFINITY : Math.min(...cutoffs),
+    completedCutoff: request.completedBefore?.getTime() ?? Number.NEGATIVE_INFINITY
+  };
+}
+function serializeEnvelope(envelope) {
+  return JSON.parse(JSON.stringify(envelope));
+}
+function isDue(delivery, now) {
+  if (delivery.status === "pending") {
+    return delivery.availableAt <= now;
+  }
+  return delivery.status === "processing" && delivery.leaseExpiresAt <= now;
+}
+function dueAtOf(delivery) {
+  return delivery.status === "pending" ? delivery.availableAt : delivery.leaseExpiresAt;
+}
+function compareDue(left, right) {
+  const byDueTime = dueAtOf(left).getTime() - dueAtOf(right).getTime();
+  return byDueTime === 0 ? compareIds(left.id, right.id) : byDueTime;
+}
+function compareIds(left, right) {
+  return Number(left > right) - Number(left < right);
+}
+function clearLease(delivery) {
+  delivery.leaseOwner = null;
+  delivery.leaseToken = null;
+  delivery.leaseExpiresAt = null;
+}
+function matchesQuery(delivery, { event, query }) {
+  return (query.status === void 0 || delivery.status === query.status) && (query.handler === void 0 || delivery.handler === query.handler) && (query.eventType === void 0 || event.envelope.type === query.eventType) && (query.eventId === void 0 || delivery.eventId === query.eventId);
+}
+function isPurgeable(delivery, request) {
+  if (delivery.status === "completed" && request.completedBefore !== void 0) {
+    return delivery.completedAt < request.completedBefore;
+  }
+  if (delivery.status === "dead" && request.deadBefore !== void 0) {
+    return delivery.updatedAt < request.deadBefore;
+  }
+  return false;
+}
+
+// src/in-memory/in-memory-maintenance.ts
+var DEFAULT_LIST_LIMIT = 100;
+var InMemoryMaintenance = class {
+  #tables;
+  #locks;
+  constructor(tables, locks) {
+    this.#tables = tables;
+    this.#locks = locks;
+  }
+  listDeliveries(query) {
+    const limit = query.limit ?? DEFAULT_LIST_LIMIT;
+    const { events, deliveries } = this.#tables;
+    return [...deliveries.values()].filter((delivery) => matchesQuery(delivery, { event: events.get(delivery.eventId), query })).sort(
+      (left, right) => left.createdAt.getTime() - right.createdAt.getTime() || compareIds(left.id, right.id)
+    ).slice(0, limit).map((delivery) => ({
+      id: delivery.id,
+      handler: delivery.handler,
+      status: delivery.status,
+      attempts: delivery.attempts,
+      availableAt: delivery.availableAt,
+      leaseOwner: delivery.leaseOwner,
+      leaseExpiresAt: delivery.leaseExpiresAt,
+      lastError: delivery.lastError,
+      createdAt: delivery.createdAt,
+      updatedAt: delivery.updatedAt,
+      completedAt: delivery.completedAt,
+      event: this.#tables.readEnvelope(delivery.eventId)
+    }));
+  }
+  requeue(deliveryIds, now) {
+    let moved = 0;
+    for (const deliveryId of new Set(deliveryIds)) {
+      const delivery = this.#tables.deliveries.get(deliveryId);
+      if (delivery?.status !== "dead") {
+        continue;
+      }
+      delivery.status = "pending";
+      delivery.attempts = 0;
+      delivery.availableAt = now;
+      delivery.updatedAt = now;
+      moved += 1;
+    }
+    return moved;
+  }
+  purge(request) {
+    let deletedDeliveries = 0;
+    const touchedEventIds = /* @__PURE__ */ new Set();
+    for (const delivery of [...this.#tables.deliveries.values()]) {
+      if (isPurgeable(delivery, request)) {
+        this.#tables.deliveries.delete(delivery.id);
+        touchedEventIds.add(delivery.eventId);
+        deletedDeliveries += 1;
+      }
+    }
+    return { deletedDeliveries, deletedEvents: this.#purgeEvents(request, touchedEventIds) };
+  }
+  statistics(now) {
+    const counts = {
+      pending: 0,
+      processing: 0,
+      completed: 0,
+      dead: 0
+    };
+    let oldestDueAt = null;
+    for (const delivery of this.#tables.deliveries.values()) {
+      counts[delivery.status] += 1;
+      if (isDue(delivery, now)) {
+        const dueAt = dueAtOf(delivery);
+        if (oldestDueAt === null || dueAt < oldestDueAt) {
+          oldestDueAt = dueAt;
+        }
+      }
+    }
+    return { ...counts, oldestDueAt };
+  }
+  /** Deletes the events no delivery references whose retention ran out; returns how many. */
+  #purgeEvents(request, touchedEventIds) {
+    const { events, deliveries } = this.#tables;
+    const referencedEventIds = new Set(
+      [...deliveries.values()].map((delivery) => delivery.eventId)
+    );
+    const { orphanCutoff, completedCutoff } = eventCutoffs(request);
+    let deletedEvents = 0;
+    for (const [eventId, event] of [...events]) {
+      if (referencedEventIds.has(eventId) || this.#locks.isHeld(`event:${eventId}`)) {
+        continue;
+      }
+      const expired = event.completedAt === null ? touchedEventIds.has(eventId) || event.createdAt.getTime() < orphanCutoff : event.completedAt.getTime() < completedCutoff;
+      if (expired) {
+        events.delete(eventId);
+        deletedEvents += 1;
+      }
+    }
+    return deletedEvents;
+  }
+};
+
+// src/in-memory/in-memory-row-locks.ts
+var InMemoryRowLocks = class {
+  #locks = /* @__PURE__ */ new Map();
+  #writes = /* @__PURE__ */ new WeakMap();
+  /** Whether an open transaction holds `name`. */
+  isHeld(name) {
+    return this.#locks.has(name);
+  }
+  /** The events and deliveries the transaction appended so far, which are not applied before it commits. */
+  written(transaction) {
+    let written = this.#writes.get(transaction);
+    if (written === void 0) {
+      written = { eventIds: /* @__PURE__ */ new Set(), deliveryKeys: /* @__PURE__ */ new Set() };
+      this.#writes.set(transaction, written);
+    }
+    return written;
+  }
+  /**
+   * Waits for other open transactions holding any of `names`, then holds them
+   * until `transaction` finishes, the way a database holds row locks. Sorted
+   * acquisition keeps two transactions from waiting on each other.
+   */
+  async lock(transaction, names) {
+    for (const name of [...new Set(names)].sort()) {
+      let held = this.#locks.get(name);
+      while (held !== void 0 && held.owner !== transaction) {
+        await held.released;
+        held = this.#locks.get(name);
+      }
+      if (held !== void 0) {
+        continue;
+      }
+      let release;
+      const released = new Promise((resolve) => {
+        release = resolve;
+      });
+      this.#locks.set(name, { owner: transaction, released });
+      transaction.onFinish(() => {
+        this.#locks.delete(name);
+        release();
+      });
+    }
+  }
+};
+
+// src/in-memory/in-memory-settlement.ts
+var InMemorySettlement = class extends LeaseSettlement {
+  #tables;
+  #retainCompleted;
+  constructor(tables, retainCompleted) {
+    super();
+    this.#tables = tables;
+    this.#retainCompleted = retainCompleted;
+  }
+  /** Completes now, or when `transaction` commits if the lease is still held then. */
+  complete(lease, { now, transaction }) {
+    const delivery = this.findHeld(lease);
+    if (delivery === void 0) {
+      return false;
+    }
+    if (transaction === void 0) {
+      this.#finish(delivery, now);
+      return true;
+    }
+    transaction.enqueue(() => {
+      const held = this.findHeld(lease);
+      if (held !== void 0) {
+        this.#finish(held, now);
+      }
+    });
+    return true;
+  }
+  findHeld(lease) {
+    const delivery = this.#tables.deliveries.get(lease.deliveryId);
+    if (delivery?.status === "processing" && delivery.leaseToken === lease.leaseToken) {
+      return delivery;
+    }
+    return void 0;
+  }
+  writeChange(held, { change }) {
+    applyTransition(held, change);
+    return true;
+  }
+  /** The in-memory store always passes `now`: its `extendLease` takes it from the port. */
+  writeExtension(held, { leaseExpiresAt, now }) {
+    held.leaseExpiresAt = leaseExpiresAt;
+    held.updatedAt = now;
+    return true;
+  }
+  forgetHandedOut() {
+  }
+  /** Deletes a completed delivery, or marks it completed when a history is kept. */
+  #finish(delivery, now) {
+    const event = this.#tables.events.get(delivery.eventId);
+    if (event.completedAt === null || event.completedAt < now) {
+      event.completedAt = now;
+    }
+    if (!this.#retainCompleted) {
+      this.#tables.deliveries.delete(delivery.id);
+      return;
+    }
+    delivery.status = "completed";
+    delivery.completedAt = now;
+    delivery.updatedAt = now;
+    clearLease(delivery);
+  }
+};
+
+// src/in-memory/in-memory-tables.ts
+var InMemoryTables = class {
+  events = /* @__PURE__ */ new Map();
+  deliveries = /* @__PURE__ */ new Map();
+  #keySequences = /* @__PURE__ */ new Map();
+  /** The next sequence of `key`; null for an unkeyed event. */
+  nextSequence(key) {
+    if (key === null) {
+      return null;
+    }
+    const next = (this.#keySequences.get(key) ?? 0) + 1;
+    this.#keySequences.set(key, next);
+    return next;
+  }
+  /** A fresh copy of a stored event, as a database would read it back. */
+  readEnvelope(eventId) {
+    const serialized = this.events.get(eventId).envelope;
+    const copy = JSON.parse(JSON.stringify(serialized));
+    return { ...copy, occurredAt: new Date(copy.occurredAt) };
+  }
+};
+
 // src/in-memory-transaction.ts
 var InMemoryTransaction = class {
   #operations = [];
@@ -377,16 +632,12 @@ var InMemoryTransaction = class {
 };
 
 // src/in-memory-event-store.ts
-var DEFAULT_LIST_LIMIT = 100;
 var InMemoryEventStore = class {
-  #events = /* @__PURE__ */ new Map();
-  #deliveries = /* @__PURE__ */ new Map();
-  #keySequences = /* @__PURE__ */ new Map();
-  /** Row-lock emulation: event ids and ordering keys written by open transactions. */
-  #locks = /* @__PURE__ */ new Map();
-  #writes = /* @__PURE__ */ new WeakMap();
+  #tables = new InMemoryTables();
+  #locks = new InMemoryRowLocks();
+  #settlement;
+  #maintenance = new InMemoryMaintenance(this.#tables, this.#locks);
   #generateIdentifier;
-  #retainCompleted;
   constructor(options = {}) {
     if (process.env["NODE_ENV"] === "production" && options.allowInProduction !== true) {
       throw new ConfigurationError(
@@ -394,7 +645,7 @@ var InMemoryEventStore = class {
       );
     }
     this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
-    this.#retainCompleted = options.retainCompleted ?? false;
+    this.#settlement = new InMemorySettlement(this.#tables, options.retainCompleted ?? false);
   }
   async transaction(work) {
     const transaction = new InMemoryTransaction();
@@ -409,14 +660,14 @@ var InMemoryEventStore = class {
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   async append(transaction, entries, now) {
-    await this.#lock(
+    await this.#locks.lock(
       transaction,
       entries.flatMap((entry) => [
         `event:${entry.event.id}`,
         ...entry.event.key === null ? [] : [`key:${entry.event.key}`]
       ])
     );
-    const written = this.#written(transaction);
+    const written = this.#locks.written(transaction);
     const pendingEventIds = written.eventIds;
     const pendingDeliveryKeys = written.deliveryKeys;
     const appendedEventIds = [];
@@ -425,7 +676,7 @@ var InMemoryEventStore = class {
     for (const entry of entries) {
       const eventId = entry.event.id;
       const serialized = serializeEnvelope(entry.event);
-      const isDuplicate = this.#events.has(eventId) || pendingEventIds.has(eventId);
+      const isDuplicate = this.#tables.events.has(eventId) || pendingEventIds.has(eventId);
       if (isDuplicate) {
         duplicateEventIds.push(eventId);
       } else {
@@ -447,8 +698,8 @@ var InMemoryEventStore = class {
   #newDeliveries(entry, pendingDeliveryKeys) {
     const eventId = entry.event.id;
     return entry.deliveries.filter((delivery) => {
-      const deliveryKey = `${eventId}\0${delivery.handler}`;
-      if (pendingDeliveryKeys.has(deliveryKey) || this.#events.get(eventId)?.handlers.has(delivery.handler) === true) {
+      const deliveryKey = CompositeKey.of(eventId, delivery.handler);
+      if (pendingDeliveryKeys.has(deliveryKey) || this.#tables.events.get(eventId)?.handlers.has(delivery.handler) === true) {
         return false;
       }
       pendingDeliveryKeys.add(deliveryKey);
@@ -458,19 +709,20 @@ var InMemoryEventStore = class {
   /** Applies one entry of an append when its transaction commits. */
   #applyAppend(input) {
     const { eventId, serialized, isDuplicate, newDeliveries, now } = input;
+    const { events, deliveries } = this.#tables;
     if (!isDuplicate) {
-      this.#events.set(eventId, {
+      events.set(eventId, {
         envelope: serialized,
-        sequence: this.#nextSequence(serialized.key),
+        sequence: this.#tables.nextSequence(serialized.key),
         createdAt: now,
         handlers: /* @__PURE__ */ new Set(),
         completedAt: null
       });
     }
-    const stored = this.#events.get(eventId);
+    const stored = events.get(eventId);
     for (const delivery of newDeliveries) {
       stored.handlers.add(delivery.handler);
-      this.#deliveries.set(delivery.id, {
+      deliveries.set(delivery.id, {
         id: delivery.id,
         eventId,
         handler: delivery.handler,
@@ -491,7 +743,7 @@ var InMemoryEventStore = class {
   }
   async claim(request) {
     const handlers = new Set(request.handlers);
-    const due = [...this.#deliveries.values()].filter((delivery) => handlers.has(delivery.handler) && isDue(delivery, request.now)).sort(compareDue);
+    const due = [...this.#tables.deliveries.values()].filter((delivery) => handlers.has(delivery.handler) && isDue(delivery, request.now)).sort(compareDue);
     const claimed = [];
     for (const delivery of due) {
       if (claimed.length >= request.limit) {
@@ -512,193 +764,50 @@ var InMemoryEventStore = class {
         handler: delivery.handler,
         attempt: delivery.attempts,
         leaseExpiresAt: request.leaseExpiresAt,
-        event: this.#readEnvelope(delivery.eventId)
+        event: this.#tables.readEnvelope(delivery.eventId)
       });
     }
     return claimed;
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   async extendLease(lease, leaseExpiresAt, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.leaseExpiresAt = leaseExpiresAt;
-      delivery.updatedAt = now;
-    });
+    return this.#settlement.extendLease({ lease, leaseExpiresAt, now });
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   async complete(lease, now, transaction) {
-    if (transaction === void 0) {
-      return this.#updateLeased(lease, (delivery) => this.#finish(delivery, now));
-    }
-    if (this.#findLeased(lease) === void 0) {
-      return false;
-    }
-    transaction.enqueue(() => {
-      const delivery = this.#findLeased(lease);
-      if (delivery !== void 0) {
-        this.#finish(delivery, now);
-      }
-    });
-    return true;
+    return this.#settlement.complete(
+      lease,
+      transaction === void 0 ? { now } : { now, transaction }
+    );
   }
   async completeMany(leases, now) {
     return Promise.all(leases.map((lease) => this.complete(lease, now)));
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   async reschedule(lease, availableAt, error, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.status = "pending";
-      delivery.availableAt = availableAt;
-      delivery.lastError = error;
-      delivery.updatedAt = now;
-      clearLease(delivery);
+    return this.#settlement.changeClaim({
+      lease,
+      change: { kind: "reschedule", availableAt, error, now }
     });
   }
   async release(lease, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.status = "pending";
-      delivery.attempts -= 1;
-      delivery.availableAt = now;
-      delivery.updatedAt = now;
-      clearLease(delivery);
-    });
+    return this.#settlement.changeClaim({ lease, change: { kind: "release", now } });
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   async bury(lease, error, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.status = "dead";
-      delivery.lastError = error;
-      delivery.updatedAt = now;
-      clearLease(delivery);
-    });
+    return this.#settlement.changeClaim({ lease, change: { kind: "bury", error, now } });
   }
   async listDeliveries(query) {
-    const limit = query.limit ?? DEFAULT_LIST_LIMIT;
-    return [...this.#deliveries.values()].filter(
-      (delivery) => matchesQuery(delivery, { event: this.#events.get(delivery.eventId), query })
-    ).sort(
-      (left, right) => left.createdAt.getTime() - right.createdAt.getTime() || compareIds(left.id, right.id)
-    ).slice(0, limit).map((delivery) => ({
-      id: delivery.id,
-      handler: delivery.handler,
-      status: delivery.status,
-      attempts: delivery.attempts,
-      availableAt: delivery.availableAt,
-      leaseOwner: delivery.leaseOwner,
-      leaseExpiresAt: delivery.leaseExpiresAt,
-      lastError: delivery.lastError,
-      createdAt: delivery.createdAt,
-      updatedAt: delivery.updatedAt,
-      completedAt: delivery.completedAt,
-      event: this.#readEnvelope(delivery.eventId)
-    }));
+    return this.#maintenance.listDeliveries(query);
   }
   async requeue(deliveryIds, now) {
-    let moved = 0;
-    for (const deliveryId of new Set(deliveryIds)) {
-      const delivery = this.#deliveries.get(deliveryId);
-      if (delivery?.status !== "dead") {
-        continue;
-      }
-      delivery.status = "pending";
-      delivery.attempts = 0;
-      delivery.availableAt = now;
-      delivery.updatedAt = now;
-      moved += 1;
-    }
-    return moved;
+    return this.#maintenance.requeue(deliveryIds, now);
   }
   async purge(request) {
-    let deletedDeliveries = 0;
-    const touchedEventIds = /* @__PURE__ */ new Set();
-    for (const delivery of [...this.#deliveries.values()]) {
-      if (isPurgeable(delivery, request)) {
-        this.#deliveries.delete(delivery.id);
-        touchedEventIds.add(delivery.eventId);
-        deletedDeliveries += 1;
-      }
-    }
-    return { deletedDeliveries, deletedEvents: this.#purgeEvents(request, touchedEventIds) };
-  }
-  /** Deletes the events no delivery references whose retention ran out; returns how many. */
-  #purgeEvents(request, touchedEventIds) {
-    const referencedEventIds = new Set(
-      [...this.#deliveries.values()].map((delivery) => delivery.eventId)
-    );
-    const { orphanCutoff, completedCutoff } = eventCutoffs(request);
-    let deletedEvents = 0;
-    for (const [eventId, event] of [...this.#events]) {
-      if (referencedEventIds.has(eventId) || this.#locks.has(`event:${eventId}`)) {
-        continue;
-      }
-      const expired = event.completedAt === null ? touchedEventIds.has(eventId) || event.createdAt.getTime() < orphanCutoff : event.completedAt.getTime() < completedCutoff;
-      if (expired) {
-        this.#events.delete(eventId);
-        deletedEvents += 1;
-      }
-    }
-    return deletedEvents;
+    return this.#maintenance.purge(request);
   }
   async statistics(now) {
-    const counts = {
-      pending: 0,
-      processing: 0,
-      completed: 0,
-      dead: 0
-    };
-    let oldestDueAt = null;
-    for (const delivery of this.#deliveries.values()) {
-      counts[delivery.status] += 1;
-      if (isDue(delivery, now)) {
-        const dueAt = dueAtOf(delivery);
-        if (oldestDueAt === null || dueAt < oldestDueAt) {
-          oldestDueAt = dueAt;
-        }
-      }
-    }
-    return { ...counts, oldestDueAt };
-  }
-  /**
-   * Waits for other open transactions holding any of `names`, then holds them
-   * until `transaction` finishes, the way a database holds row locks. Sorted
-   * acquisition keeps two transactions from waiting on each other.
-   */
-  /** The events and deliveries the transaction appended so far, which are not applied before it commits. */
-  #written(transaction) {
-    let written = this.#writes.get(transaction);
-    if (written === void 0) {
-      written = { eventIds: /* @__PURE__ */ new Set(), deliveryKeys: /* @__PURE__ */ new Set() };
-      this.#writes.set(transaction, written);
-    }
-    return written;
-  }
-  async #lock(transaction, names) {
-    for (const name of [...new Set(names)].sort()) {
-      let held = this.#locks.get(name);
-      while (held !== void 0 && held.owner !== transaction) {
-        await held.released;
-        held = this.#locks.get(name);
-      }
-      if (held !== void 0) {
-        continue;
-      }
-      let release;
-      const released = new Promise((resolve) => {
-        release = resolve;
-      });
-      this.#locks.set(name, { owner: transaction, released });
-      transaction.onFinish(() => {
-        this.#locks.delete(name);
-        release();
-      });
-    }
-  }
-  #nextSequence(key) {
-    if (key === null) {
-      return null;
-    }
-    const next = (this.#keySequences.get(key) ?? 0) + 1;
-    this.#keySequences.set(key, next);
-    return next;
+    return this.#maintenance.statistics(now);
   }
   /**
    * A keyed delivery waits while an earlier delivery of the same handler and
@@ -710,121 +819,210 @@ var InMemoryEventStore = class {
     if (delivery.key === null) {
       return false;
     }
-    for (const other of this.#deliveries.values()) {
+    for (const other of this.#tables.deliveries.values()) {
       if (blocksKey(other, { delivery, now })) {
         return true;
       }
     }
     return false;
   }
-  /** Deletes a completed delivery, or marks it completed when a history is kept. */
-  #finish(delivery, now) {
-    const event = this.#events.get(delivery.eventId);
-    if (event.completedAt === null || event.completedAt < now) {
-      event.completedAt = now;
-    }
-    if (!this.#retainCompleted) {
-      this.#deliveries.delete(delivery.id);
-      return;
-    }
-    delivery.status = "completed";
-    delivery.completedAt = now;
-    delivery.updatedAt = now;
-    clearLease(delivery);
+};
+
+// src/shutdown-deadline.ts
+var DRAIN_SHARE = 0.8;
+var ShutdownDeadline = class {
+  #controller = new AbortController();
+  #drained;
+  #expired;
+  #cancelTimers;
+  constructor(clock, timeoutMs) {
+    let drain;
+    this.#drained = new Promise((resolve) => {
+      drain = () => resolve("timeout");
+    });
+    const signal = this.#controller.signal;
+    this.#expired = new Promise((resolve) => {
+      signal.addEventListener("abort", () => resolve("timeout"), { once: true });
+    });
+    this.#cancelTimers = [
+      schedule(clock, { run: drain, delayMs: Math.floor(timeoutMs * DRAIN_SHARE) }),
+      schedule(clock, { run: () => this.#controller.abort(), delayMs: timeoutMs })
+    ];
   }
-  #findLeased(lease) {
-    const delivery = this.#deliveries.get(lease.deliveryId);
-    if (delivery?.status === "processing" && delivery.leaseToken === lease.leaseToken) {
-      return delivery;
-    }
-    return void 0;
+  /** Aborted when the deadline passes. */
+  get signal() {
+    return this.#controller.signal;
   }
-  #updateLeased(lease, update) {
-    const delivery = this.#findLeased(lease);
-    if (delivery === void 0) {
-      return false;
-    }
-    update(delivery);
-    return true;
+  get passed() {
+    return this.#controller.signal.aborted;
   }
-  #readEnvelope(eventId) {
-    const serialized = this.#events.get(eventId).envelope;
-    const copy = JSON.parse(JSON.stringify(serialized));
-    return { ...copy, occurredAt: new Date(copy.occurredAt) };
+  /** Waits for `work` until the deadline. Rejects when `work` rejects before it. */
+  race(work) {
+    return Promise.race([work.then(() => "done"), this.#expired]);
+  }
+  /** Waits for running handlers until the drain point, when they are aborted. */
+  raceDrain(work) {
+    return Promise.race([work.then(() => "done"), this.#drained]);
+  }
+  /** Cancels the timers once the shutdown is over. */
+  dispose() {
+    for (const cancel of this.#cancelTimers) {
+      cancel();
+    }
   }
 };
-function blocksKey(other, { delivery, now }) {
-  if (other === delivery || other.handler !== delivery.handler || other.key !== delivery.key) {
-    return false;
+async function withinDeadline({ clock, timeoutMs }, work) {
+  const startedAt = clock.now().getTime();
+  const deadline = new ShutdownDeadline(clock, timeoutMs);
+  try {
+    const abandonedDeliveries = await work(deadline);
+    return {
+      graceful: !deadline.passed,
+      abandonedDeliveries,
+      durationMs: clock.now().getTime() - startedAt
+    };
+  } finally {
+    deadline.dispose();
   }
-  const unfinishedPredecessor = other.sequence < delivery.sequence && (other.status === "pending" || other.status === "processing");
-  const runningUnderLiveLease = other.status === "processing" && other.leaseExpiresAt > now;
-  return unfinishedPredecessor || runningUnderLiveLease;
-}
-function eventCutoffs(request) {
-  const cutoffs = [request.completedBefore, request.deadBefore].filter((cutoff) => cutoff !== void 0).map((cutoff) => cutoff.getTime());
-  return {
-    orphanCutoff: cutoffs.length === 0 ? Number.NEGATIVE_INFINITY : Math.min(...cutoffs),
-    completedCutoff: request.completedBefore?.getTime() ?? Number.NEGATIVE_INFINITY
-  };
-}
-function serializeEnvelope(envelope) {
-  return JSON.parse(JSON.stringify(envelope));
 }
-function isDue(delivery, now) {
-  if (delivery.status === "pending") {
-    return delivery.availableAt <= now;
+
+// src/bus/bus-lifecycle.ts
+var BusLifecycle = class {
+  #parts;
+  #state = "idle";
+  #starting;
+  #stopping;
+  constructor(parts) {
+    this.#parts = parts;
   }
-  return delivery.status === "processing" && delivery.leaseExpiresAt <= now;
-}
-function dueAtOf(delivery) {
-  return delivery.status === "pending" ? delivery.availableAt : delivery.leaseExpiresAt;
-}
-function compareDue(left, right) {
-  const byDueTime = dueAtOf(left).getTime() - dueAtOf(right).getTime();
-  return byDueTime === 0 ? compareIds(left.id, right.id) : byDueTime;
-}
-function compareIds(left, right) {
-  return Number(left > right) - Number(left < right);
-}
-function clearLease(delivery) {
-  delivery.leaseOwner = null;
-  delivery.leaseToken = null;
-  delivery.leaseExpiresAt = null;
-}
-function matchesQuery(delivery, { event, query }) {
-  return (query.status === void 0 || delivery.status === query.status) && (query.handler === void 0 || delivery.handler === query.handler) && (query.eventType === void 0 || event.envelope.type === query.eventType) && (query.eventId === void 0 || delivery.eventId === query.eventId);
-}
-function isPurgeable(delivery, request) {
-  if (delivery.status === "completed" && request.completedBefore !== void 0) {
-    return delivery.completedAt < request.completedBefore;
+  get state() {
+    return this.#state;
   }
-  if (delivery.status === "dead" && request.deadBefore !== void 0) {
-    return delivery.updatedAt < request.deadBefore;
+  /** Throws unless the bus is idle: a bus starts once. */
+  assertStartable() {
+    if (this.#state !== "idle") {
+      throw new LifecycleError(
+        this.#state === "stopped" ? "A stopped relaybus cannot be started again; create a new instance" : `Cannot start a relaybus that is ${this.#state}`
+      );
+    }
   }
-  return false;
-}
-
-// src/tracing.ts
-var TRACEPARENT_HEADER = "traceparent";
-var TRACESTATE_HEADER = "tracestate";
-var TRACEPARENT_FIELDS = "(?!0{32})[\\da-f]{32}-(?!0{16})[\\da-f]{16}-[\\da-f]{2}";
-var TRACEPARENT = new RegExp(
-  `^(?:00-${TRACEPARENT_FIELDS}|(?!00|ff)[\\da-f]{2}-${TRACEPARENT_FIELDS}(?:-.*)?)$`
-);
-function traceContextOf(headers) {
-  const traceparent = headers[TRACEPARENT_HEADER];
-  if (traceparent === void 0 || !TRACEPARENT.test(traceparent)) {
-    return void 0;
+  /** Runs `startComponents` as the start in progress, which a stop waits for; returns it. */
+  beginStart(startComponents) {
+    this.#state = "starting";
+    this.#starting = startComponents();
+    return this.#starting;
   }
-  const tracestate = headers[TRACESTATE_HEADER];
-  return tracestate === void 0 ? { traceparent } : { traceparent, tracestate };
-}
-
-// src/bus-observation.ts
-function withTraceHeaders(options, headers) {
-  return Object.keys(headers).length === 0 ? options : { ...options, headers: { ...headers, ...options.headers } };
-}
+  /** The start in progress settled. */
+  endStart() {
+    this.#starting = void 0;
+  }
+  markRunning() {
+    this.#state = "running";
+  }
+  markStopped() {
+    this.#state = "stopped";
+  }
+  /** The stop of the bus within `timeoutMs`; a later call shares the first one's. */
+  stop(timeoutMs) {
+    if (this.#stopping !== void 0) {
+      return { stopping: this.#stopping, first: false };
+    }
+    if (this.#state !== "running" && this.#state !== "starting") {
+      return { stopping: this.#stopOutsideRun(timeoutMs), first: false };
+    }
+    this.#stopping = this.#stopComponents(timeoutMs);
+    return { stopping: this.#stopping, first: true };
+  }
+  /**
+   * A bus that is not running: an idle one only settles what batches run by hand left behind (and
+   * stays startable); a stopped one has nothing left to do.
+   */
+  async #stopOutsideRun(timeoutMs) {
+    if (this.#state !== "idle") {
+      return { graceful: true, abandonedDeliveries: 0, durationMs: 0 };
+    }
+    return withinDeadline(
+      { clock: this.#parts.clock, timeoutMs },
+      (deadline) => this.#parts.dispatcher.stop(deadline)
+    );
+  }
+  /**
+   * Waits for a start in progress (a failed start leaves nothing to stop), then stops the dispatcher
+   * and closes the transports and the store. A start still running at the deadline is given up: the
+   * transports and the store are force-closed and the start rejects when it resumes.
+   */
+  async #stopComponents(timeoutMs) {
+    try {
+      return await withinDeadline({ clock: this.#parts.clock, timeoutMs }, async (deadline) => {
+        if (this.#state === "starting") {
+          const started = await deadline.race(this.#starting.catch(() => void 0));
+          if (started === "timeout") {
+            this.#state = "stopping";
+            await this.#closeConnections(deadline);
+            return 0;
+          }
+        }
+        if (this.#state !== "running") {
+          return 0;
+        }
+        this.#state = "stopping";
+        this.#parts.maintenance.stop();
+        const abandoned = await this.#parts.dispatcher.stop(deadline);
+        await this.#closeConnections(deadline);
+        return abandoned;
+      });
+    } finally {
+      this.#state = "stopped";
+    }
+  }
+  async #closeConnections(deadline) {
+    await this.#parts.closeTransports(deadline);
+    const options = { signal: deadline.signal };
+    await deadline.race(Promise.resolve(this.#parts.store.close?.(options)));
+  }
+};
+
+// src/bus/handler-descriptions.ts
+function toDescriptor(registration, eventType) {
+  return {
+    id: registration.id,
+    eventType,
+    retry: registration.retry,
+    timeoutMs: registration.timeoutMs,
+    concurrency: registration.concurrency,
+    transactional: registration.transactional,
+    forwardsToTransport: registration.forwardsToTransport
+  };
+}
+function describeEvent(event) {
+  if (typeof event === "string") {
+    assertEventType(event);
+    return { type: event, schema: void 0 };
+  }
+  assertEventType(event.type);
+  return { type: event.type, schema: event.schema };
+}
+
+// src/tracing.ts
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var TRACEPARENT_FIELDS = "(?!0{32})[\\da-f]{32}-(?!0{16})[\\da-f]{16}-[\\da-f]{2}";
+var TRACEPARENT = new RegExp(
+  `^(?:00-${TRACEPARENT_FIELDS}|(?!00|ff)[\\da-f]{2}-${TRACEPARENT_FIELDS}(?:-.*)?)$`
+);
+function traceContextOf(headers) {
+  const traceparent = headers[TRACEPARENT_HEADER];
+  if (traceparent === void 0 || !TRACEPARENT.test(traceparent)) {
+    return void 0;
+  }
+  const tracestate = headers[TRACESTATE_HEADER];
+  return tracestate === void 0 ? { traceparent } : { traceparent, tracestate };
+}
+
+// src/bus-observation.ts
+function withTraceHeaders(options, headers) {
+  return Object.keys(headers).length === 0 ? options : { ...options, headers: { ...headers, ...options.headers } };
+}
 var BusObservation = class _BusObservation {
   #notifier;
   #tracer;
@@ -1075,291 +1273,516 @@ var DispatchObservation = class _DispatchObservation {
   }
 };
 
-// src/completion-batcher.ts
-var CompletionBatcher = class {
-  #store;
-  #clock;
-  #settings;
-  #runningCount;
-  #pending = [];
-  #timer;
-  #closing = false;
+// src/dispatch/claim-loop.ts
+var WAKE_COOLDOWN_MS = 5;
+var QUIET_REFILL_MS = 10;
+var REFILL_FRACTION = 0.7;
+var ClaimLoop = class {
+  #parts;
+  #running = false;
+  #wakeUp;
+  /** Free slots the claim the loop was woken for needs at least; undefined while nobody woke it. */
+  #signalledMinimum;
+  /** Free slots a claim needs unless the poll interval or the quiet refill time passed: claims refill in groups. */
+  #refillThreshold;
+  /** Handlers whose last claim got less than it asked for: the store has nothing more for them right now. */
+  #exhaustedHandlers = /* @__PURE__ */ new Set();
+  /** Grows with every wake-up: a claim that started before one must not mark a handler exhausted. */
+  #wakeGeneration = 0;
+  #lastClaimStartedAt = Number.NEGATIVE_INFINITY;
+  #cooldownTimer;
+  #refillScheduled = false;
+  #quietRefillTimer;
+  constructor(parts) {
+    this.#parts = parts;
+    const { concurrency, batchSize } = parts.dependencies.settings;
+    this.#refillThreshold = Math.ceil(Math.min(concurrency, batchSize) * REFILL_FRACTION);
+  }
+  get isRunning() {
+    return this.#running;
+  }
+  /** Marks the loop running; {@link ClaimLoop.run} then claims until {@link ClaimLoop.halt}. */
+  open() {
+    this.#running = true;
+  }
+  /** Stops claiming: the running pass ends at its next wait. */
+  halt() {
+    this.#running = false;
+  }
+  /** Cancels the claims waiting for a timer and ends the current wait, so a halted loop returns. */
+  interrupt() {
+    this.#cooldownTimer?.();
+    this.#cooldownTimer = void 0;
+    this.#quietRefillTimer?.();
+    this.#quietRefillTimer = void 0;
+    this.#signal(this.#refillThreshold);
+  }
   /**
-   * @param runningCount Number of deliveries the dispatcher is running right
-   * now, including the ones waiting in this batcher.
+   * Asks for a claim soon, for example right after a publish: at once after a quiet period, otherwise
+   * at the end of a short cooldown that merges the wake-ups arriving meanwhile into one claim.
    */
-  constructor(store, clock, settings, runningCount) {
-    this.#store = store;
-    this.#clock = clock;
-    this.#settings = settings;
-    this.#runningCount = runningCount;
+  wake() {
+    this.#exhaustedHandlers.clear();
+    this.#wakeGeneration += 1;
+    const wait = this.#lastClaimStartedAt + WAKE_COOLDOWN_MS - Date.now();
+    if (wait <= 0) {
+      this.#requestClaim();
+      return;
+    }
+    this.#cooldownTimer ??= schedule(this.#parts.dependencies.clock, {
+      run: () => {
+        this.#cooldownTimer = void 0;
+        this.#requestClaim();
+      },
+      delayMs: wait
+    });
   }
   /**
-   * Queues a completion. Resolves with whether the lease was still held;
-   * rejects with the store error when the batch could not be written.
+   * Claims until halted. A claim that filled its batch is followed by the next one at once while enough
+   * slots are free. Otherwise the loop sleeps until a wake-up (a publish, a store notification, or enough
+   * deliveries settling to refill a group of slots) or the poll interval. Only the poll interval claims
+   * for fewer free slots than the refill threshold, so a busy dispatcher never claims slot by slot.
    */
-  submit(lease) {
-    return new Promise((resolve, reject) => {
-      this.#pending.push({ lease, resolve, reject });
-      if (this.#closing || this.#pending.length >= this.#settings.maxBatchSize || this.#pending.length >= this.#runningCount()) {
-        this.#flush();
-      } else {
-        this.#timer ??= schedule(this.#clock, {
-          run: () => this.#flush(),
-          delayMs: this.#settings.windowMs
-        });
+  async run() {
+    let minimumFree = 1;
+    while (this.#running) {
+      let round = { requested: 0, claimed: 0 };
+      if (this.#freeSlots() >= minimumFree) {
+        try {
+          round = await this.claimAndStart();
+        } catch (error) {
+          this.#parts.dependencies.notifier.failure("claim", error);
+        }
       }
-    });
+      if (round.requested > 0 && round.claimed === round.requested && this.#freeSlots() >= this.#refillThreshold) {
+        minimumFree = this.#refillThreshold;
+        continue;
+      }
+      minimumFree = await this.#waitForWakeUp();
+      if (this.#freeSlots() < minimumFree) {
+        this.#requestClaim();
+      }
+    }
   }
   /**
-   * Shutdown has begun (or ended): while closing, nothing waits for company any more, so the completions
-   * already queued are written now and later ones at once.
+   * A delivery settled. Its slot is worth refilling when the store may have more for its handler: a keyed
+   * delivery unblocks the next one of its key, a delivery that did not succeed may be due again at once
+   * (a retry without delay, a release), and a handler whose last claim was full may have a backlog.
    */
-  setClosing(closing) {
-    this.#closing = closing;
-    if (closing && this.#pending.length > 0) {
-      this.#flush();
+  onSettled(delivery, succeeded) {
+    if (delivery.event.key !== null || !succeeded || !this.#exhaustedHandlers.has(delivery.handler)) {
+      this.#requestClaim();
     }
   }
-  #flush() {
-    this.#timer?.();
-    this.#timer = void 0;
-    const batch = this.#pending;
-    this.#pending = [];
-    Promise.resolve().then(
-      () => this.#store.completeMany(
-        batch.map((entry) => entry.lease),
-        this.#clock.now()
-      )
-    ).then(
-      (outcomes) => batch.forEach((entry, index) => entry.resolve(outcomes[index])),
-      (error) => batch.forEach((entry) => entry.reject(error))
-    );
+  /** Claims for every handler with room and starts what was claimed. */
+  async claimAndStart() {
+    const { dependencies, planner, shutdown, start } = this.#parts;
+    const { store, registry, clock, settings, observation } = dependencies;
+    const started = [];
+    let requested = 0;
+    for (const request of planner.plan(registry.all(), this.#freeSlots())) {
+      const now = clock.now();
+      const wakeGeneration = this.#wakeGeneration;
+      this.#lastClaimStartedAt = Date.now();
+      this.#quietRefillTimer?.();
+      this.#quietRefillTimer = void 0;
+      requested += request.limit;
+      const claim = {
+        handlers: request.handlers,
+        limit: request.limit,
+        leaseOwner: settings.owner,
+        leaseExpiresAt: new Date(now.getTime() + settings.leaseDurationMs),
+        now
+      };
+      const claimed = await (observation === void 0 ? store.claim(claim) : observation.claim(store, claim));
+      this.#markExhausted(
+        request.handlers,
+        claimed.length < request.limit && wakeGeneration === this.#wakeGeneration
+      );
+      for (const delivery of shutdown.abandoned ? [] : claimed) {
+        started.push(start(delivery));
+      }
+    }
+    return { requested, claimed: started.length, started };
   }
-};
-
-// src/delivery-timers.ts
-var DeliveryTimers = class {
-  #clock;
-  /** Cancel of every timer still waiting, with what its cancellation must also do. */
-  #waiting = /* @__PURE__ */ new Map();
-  constructor(clock) {
-    this.#clock = clock;
+  #markExhausted(handlers, exhausted) {
+    for (const handler of handlers) {
+      if (exhausted) {
+        this.#exhaustedHandlers.add(handler);
+      } else {
+        this.#exhaustedHandlers.delete(handler);
+      }
+    }
   }
-  /** Runs `task.run` after `task.delayMs`; returns what cancels it. */
-  start(task) {
-    return this.#start(task, () => void 0);
+  /** Ends the current wait of the claim loop, or the next one at once, for a claim once `minimumFree` slots are free. */
+  #signal(minimumFree) {
+    this.#signalledMinimum = Math.min(this.#signalledMinimum ?? minimumFree, minimumFree);
+    this.#wakeUp?.();
   }
-  /** Resolves after `milliseconds`, or at once when {@link DeliveryTimers.cancelAll} runs. */
-  sleep(milliseconds) {
-    return new Promise((resolve) => {
-      this.#start({ run: resolve, delayMs: milliseconds }, resolve);
-    });
+  /** Waits for a wake-up or the poll interval. Resolves with the free slots the next claim needs. */
+  async #waitForWakeUp() {
+    if (this.#signalledMinimum === void 0) {
+      await new Promise((resolve) => {
+        const cancel = schedule(this.#parts.dependencies.clock, {
+          run: () => {
+            this.#signalledMinimum = 1;
+            resolve();
+          },
+          delayMs: this.#parts.dependencies.settings.pollIntervalMs
+        });
+        this.#wakeUp = () => {
+          cancel();
+          resolve();
+        };
+      });
+      this.#wakeUp = void 0;
+    }
+    const minimumFree = this.#signalledMinimum;
+    this.#signalledMinimum = void 0;
+    return minimumFree;
   }
-  cancelAll() {
-    for (const [cancel, onCancel] of [...this.#waiting]) {
-      cancel();
-      onCancel();
+  /**
+   * Asks the loop for a claim. Once a group of slots is free the claim waits only for the deliveries
+   * settling in the same tick, so they are claimed for together; fewer free slots are refilled when no
+   * claim started for a short while. With no free slot the next settlement asks again.
+   */
+  #requestClaim() {
+    const free = this.#freeSlots();
+    if (free >= this.#refillThreshold) {
+      if (!this.#refillScheduled) {
+        this.#refillScheduled = true;
+        setImmediate(() => {
+          this.#refillScheduled = false;
+          this.#signal(this.#refillThreshold);
+        });
+      }
+    } else if (free > 0) {
+      this.#quietRefillTimer ??= schedule(this.#parts.dependencies.clock, {
+        run: () => {
+          this.#quietRefillTimer = void 0;
+          this.#signal(1);
+        },
+        delayMs: Math.max(0, this.#lastClaimStartedAt + QUIET_REFILL_MS - Date.now())
+      });
     }
   }
-  #start(task, onCancel) {
-    const cancel = () => {
-      cancelTimer();
-      this.#waiting.delete(cancel);
-    };
-    const cancelTimer = schedule(this.#clock, {
-      run: () => {
-        this.#waiting.delete(cancel);
-        task.run();
-      },
-      delayMs: task.delayMs
-    });
-    this.#waiting.set(cancel, onCancel);
-    return cancel;
+  #freeSlots() {
+    return this.#parts.dependencies.settings.concurrency - this.#parts.inFlight.size;
   }
 };
 
-// src/dispatcher-support.ts
-function pendingKey(delivery) {
-  return `${delivery.deliveryId}\0${delivery.leaseToken}`;
-}
-function rejectOnAbort(signal) {
-  return new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-  });
-}
-var storage = new AsyncLocalStorage();
-function runInScope(scope, work) {
-  return storage.run({ ...storage.getStore(), ...scope }, work);
-}
-function runInIsolatedScope(scope, work) {
-  return storage.run(scope, work);
-}
-function getCurrentScope() {
-  return storage.getStore();
-}
-
-// src/shutdown-deadline.ts
-var DRAIN_SHARE = 0.8;
-var ShutdownDeadline = class {
-  #controller = new AbortController();
-  #drained;
-  #expired;
-  #cancelTimers;
-  constructor(clock, timeoutMs) {
-    let drain;
-    this.#drained = new Promise((resolve) => {
-      drain = () => resolve("timeout");
-    });
-    const signal = this.#controller.signal;
-    this.#expired = new Promise((resolve) => {
-      signal.addEventListener("abort", () => resolve("timeout"), { once: true });
-    });
-    this.#cancelTimers = [
-      schedule(clock, { run: drain, delayMs: Math.floor(timeoutMs * DRAIN_SHARE) }),
-      schedule(clock, { run: () => this.#controller.abort(), delayMs: timeoutMs })
-    ];
-  }
-  /** Aborted when the deadline passes. */
-  get signal() {
-    return this.#controller.signal;
-  }
-  get passed() {
-    return this.#controller.signal.aborted;
-  }
-  /** Waits for `work` until the deadline. Rejects when `work` rejects before it. */
-  race(work) {
-    return Promise.race([work.then(() => "done"), this.#expired]);
-  }
-  /** Waits for running handlers until the drain point, when they are aborted. */
-  raceDrain(work) {
-    return Promise.race([work.then(() => "done"), this.#drained]);
+// src/dispatch/claim-planner.ts
+var ClaimPlanner = class {
+  #inFlight;
+  #batchSize;
+  constructor(inFlight, batchSize) {
+    this.#inFlight = inFlight;
+    this.#batchSize = batchSize;
   }
-  /** Cancels the timers once the shutdown is over. */
-  dispose() {
-    for (const cancel of this.#cancelTimers) {
-      cancel();
+  /** One claim for handlers without a concurrency limit, one per limited handler with room. */
+  plan(registrations, freeSlots) {
+    let free = Math.min(freeSlots, this.#batchSize);
+    const plans = [];
+    const unlimited = registrations.filter((registration) => registration.concurrency === null);
+    for (const registration of registrations) {
+      if (registration.concurrency === null || free === 0) {
+        continue;
+      }
+      const room = registration.concurrency - this.#inFlight.countOf(registration);
+      const limit = Math.min(room, free);
+      if (limit > 0) {
+        plans.push({ handlers: [...registration.claimIds], limit });
+        free -= limit;
+      }
+    }
+    if (unlimited.length > 0 && free > 0) {
+      plans.push({
+        handlers: unlimited.flatMap((registration) => registration.claimIds),
+        limit: free
+      });
     }
+    return plans;
   }
 };
-async function withinDeadline({ clock, timeoutMs }, work) {
-  const startedAt = clock.now().getTime();
-  const deadline = new ShutdownDeadline(clock, timeoutMs);
-  try {
-    const abandonedDeliveries = await work(deadline);
-    return {
-      graceful: !deadline.passed,
-      abandonedDeliveries,
-      durationMs: clock.now().getTime() - startedAt
-    };
-  } finally {
-    deadline.dispose();
+
+// src/dispatch/dispatch-context.ts
+var ShutdownLatch = class {
+  #abandoned = false;
+  get abandoned() {
+    return this.#abandoned;
   }
-}
+  abandon() {
+    this.#abandoned = true;
+  }
+};
 
 // src/lease-heartbeat.ts
 var RENEWALS_PER_LEASE = 3;
-function startLeaseHeartbeat({ store, clock, notifier, settings }, { delivery, controller }) {
-  let confirmedExpiry = delivery.leaseExpiresAt.getTime();
-  let renewing = false;
-  const abortLeaseLost = (storeConfirmed = false) => {
+var LeaseRenewal = class {
+  #dependencies;
+  #target;
+  #confirmedExpiry;
+  #renewing = false;
+  constructor(dependencies, target) {
+    this.#dependencies = dependencies;
+    this.#target = target;
+    this.#confirmedExpiry = target.delivery.leaseExpiresAt.getTime();
+  }
+  /** One beat: aborts once the confirmed expiry passed, else renews unless a renewal is running. */
+  beat() {
+    const { store, clock, notifier, settings } = this.#dependencies;
+    const now = clock.now();
+    if (now.getTime() >= this.#confirmedExpiry) {
+      this.#abortLeaseLost();
+      return;
+    }
+    if (this.#renewing) {
+      return;
+    }
+    this.#renewing = true;
+    const expiry = now.getTime() + settings.leaseDurationMs;
+    store.extendLease(this.#target.delivery, new Date(expiry), now).then((extended) => {
+      if (extended) {
+        this.#confirmedExpiry = expiry;
+      } else {
+        this.#abortLeaseLost(true);
+      }
+    }).catch((error) => notifier.failure("extend-lease", error)).finally(() => {
+      this.#renewing = false;
+    });
+  }
+  #abortLeaseLost(storeConfirmed = false) {
+    const { delivery, controller } = this.#target;
     controller.abort(
       new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, { storeConfirmed })
     );
-  };
+  }
+};
+function startLeaseHeartbeat(dependencies, target) {
+  const renewal = new LeaseRenewal(dependencies, target);
+  const { clock, settings } = dependencies;
   return schedule(clock, {
-    run: () => {
-      const now = clock.now();
-      if (now.getTime() >= confirmedExpiry) {
-        abortLeaseLost();
-        return;
-      }
-      if (renewing) {
-        return;
-      }
-      renewing = true;
-      const expiry = now.getTime() + settings.leaseDurationMs;
-      store.extendLease(delivery, new Date(expiry), now).then((extended) => {
-        if (extended) {
-          confirmedExpiry = expiry;
-        } else {
-          abortLeaseLost(true);
-        }
-      }).catch((error) => notifier.failure("extend-lease", error)).finally(() => {
-        renewing = false;
-      });
-    },
+    run: () => renewal.beat(),
     delayMs: Math.max(1, Math.floor(settings.leaseDurationMs / RENEWALS_PER_LEASE)),
     repeat: true,
     unref: true
   });
 }
 
-// src/retry-policy.ts
-var DEFAULT_RETRY_POLICY = {
-  attempts: 10,
-  initialDelayMs: 1e3,
-  factor: 2,
-  maxDelayMs: 6e5,
-  jitter: "full",
-  retryIf: void 0
-};
-var DEFAULT_ROUTE_RETRY_POLICY = {
-  attempts: Number.POSITIVE_INFINITY,
-  initialDelayMs: 1e3,
-  factor: 2,
-  maxDelayMs: 3e5,
-  jitter: "full",
-  retryIf: void 0
-};
-var JITTER_STRATEGIES = ["full", "equal", "none"];
-function createRetryPolicy(options, base = DEFAULT_RETRY_POLICY) {
-  const policy = mergeRetryPolicy(options, base);
-  assertValidRetryPolicy(policy);
-  return policy;
-}
-function mergeRetryPolicy(options, base) {
-  const overrides = options ?? {};
-  const initialDelayMs = overrides.initialDelay === void 0 ? base.initialDelayMs : toMilliseconds(overrides.initialDelay, "retry.initialDelay");
-  return {
-    attempts: overrides.attempts ?? base.attempts,
-    initialDelayMs,
-    factor: overrides.factor ?? base.factor,
-    maxDelayMs: overrides.maxDelay === void 0 ? (
-      // Raising only the initial delay must not trip the inherited cap.
-      Math.max(base.maxDelayMs, initialDelayMs)
-    ) : toMilliseconds(overrides.maxDelay, "retry.maxDelay"),
-    jitter: overrides.jitter ?? base.jitter,
-    retryIf: overrides.retryIf ?? base.retryIf
-  };
-}
-function assertValidRetryPolicy(policy) {
-  if (policy.attempts !== Number.POSITIVE_INFINITY && (!Number.isInteger(policy.attempts) || policy.attempts < 1)) {
-    throw new ConfigurationError(
-      `retry.attempts must be a positive integer or Infinity, received ${policy.attempts}`
-    );
-  }
-  if (!Number.isFinite(policy.factor) || policy.factor < 1) {
-    throw new ConfigurationError(`retry.factor must be at least 1, received ${policy.factor}`);
+// src/dispatch/delivery-executor.ts
+var DeliveryExecutor = class {
+  #parts;
+  /** Stops the lease renewal (or transactional lease guard) of each delivery whose handler runs. */
+  #leaseKeepers = /* @__PURE__ */ new Map();
+  constructor(parts) {
+    this.#parts = parts;
   }
-  if (policy.maxDelayMs < policy.initialDelayMs) {
-    throw new ConfigurationError("retry.maxDelay must not be smaller than retry.initialDelay");
+  /** Starts a delivery and tracks it as in flight until it settled. */
+  start(delivery) {
+    const { dependencies, inFlight, onSettled } = this.#parts;
+    const controller = new AbortController();
+    let succeeded = false;
+    const entry = {
+      handler: delivery.handler,
+      controller,
+      settled: Promise.resolve().then(async () => {
+        succeeded = await this.#execute(delivery, controller);
+      }).catch((error) => dependencies.notifier.failure("dispatch", error)).finally(() => {
+        inFlight.delete(entry);
+        onSettled(delivery, succeeded);
+      })
+    };
+    inFlight.add(entry);
+    return entry;
   }
-  if (!JITTER_STRATEGIES.includes(policy.jitter)) {
-    throw new ConfigurationError(
-      `retry.jitter must be one of ${JITTER_STRATEGIES.join(", ")}, received '${String(policy.jitter)}'`
-    );
+  /** Stop gave up: lets every lease run out, so that another process takes the deliveries. */
+  abandon() {
+    for (const stopKeeping of this.#leaseKeepers.values()) {
+      stopKeeping();
+    }
+    this.#leaseKeepers.clear();
   }
-}
-function computeRetryDelay(policy, failedAttempts, random = Math.random) {
-  const exponential = policy.initialDelayMs * policy.factor ** (failedAttempts - 1);
-  const capped = Math.min(policy.maxDelayMs, exponential);
-  switch (policy.jitter) {
-    case "full":
-      return Math.round(random() * capped);
-    case "equal":
-      return Math.round(capped / 2 + random() * capped / 2);
-    case "none":
+  /** Runs one delivery. Resolves true when its handler succeeded, so the delivery is done for good. */
+  async #execute(delivery, controller) {
+    const { dependencies, recovery, outcomes } = this.#parts;
+    const { registry, notifier, clock } = dependencies;
+    const registration = registry.get(delivery.handler);
+    recovery.forgetEarlierClaims(delivery);
+    notifier.notify("onDeliveryStarted", { delivery });
+    const startedAt = clock.now().getTime();
+    if (delivery.attempt > registration.retry.attempts) {
+      await outcomes.bury(
+        delivery,
+        new AttemptsExhaustedError(
+          `Delivery reached attempt ${delivery.attempt} of ${registration.retry.attempts} after its lease expired`
+        )
+      );
+      return false;
+    }
+    let stopHeartbeat = () => void 0;
+    try {
+      stopHeartbeat = registration.transactional ? await this.#guardTransactionalLease(registration, { delivery, controller }) : startLeaseHeartbeat(dependencies, { delivery, controller });
+      this.#leaseKeepers.set(delivery, stopHeartbeat);
+      const outcome = await this.#runHandler(registration, { delivery, controller });
+      this.#reportSuccess(delivery, { outcome, durationMs: clock.now().getTime() - startedAt });
+      return true;
+    } catch (error) {
+      if (this.#parts.shutdown.abandoned) {
+        return false;
+      }
+      const recording = this.#recordFailure(registration, { delivery, error });
+      if (recording !== void 0) {
+        await recording;
+      }
+      return false;
+    } finally {
+      stopHeartbeat();
+      this.#leaseKeepers.delete(delivery);
+    }
+  }
+  /** Reports a success now, or once a completion the store did not confirm is recovered. */
+  #reportSuccess(delivery, { outcome, durationMs }) {
+    const { dependencies, outcomes, recovery } = this.#parts;
+    const { notifier } = dependencies;
+    if (outcome === "completed") {
+      notifier.notify("onDeliverySucceeded", { delivery, durationMs });
+    } else {
+      recovery.retain({
+        delivery,
+        settle: () => outcomes.complete(delivery),
+        applied: () => notifier.notify("onDeliverySucceeded", { delivery, durationMs })
+      });
+    }
+  }
+  /** Records a failed run; undefined when there is nothing to record (the store confirmed the lost lease). */
+  #recordFailure(registration, { delivery, error }) {
+    const { dependencies, outcomes } = this.#parts;
+    if (error instanceof LeaseLostError) {
+      dependencies.notifier.notify("onLeaseLost", { delivery });
+      return error.storeConfirmed ? void 0 : outcomes.giveBack(registration, { delivery, error });
+    }
+    if (error instanceof DispatcherStoppedError) {
+      return outcomes.release(delivery);
+    }
+    return outcomes.fail(registration, { delivery, error });
+  }
+  async #runHandler(registration, { delivery, controller }) {
+    const { dependencies, invocation, outcomes } = this.#parts;
+    const { store, clock } = dependencies;
+    const payload = await validatePayload(
+      delivery.event.type,
+      registration.schema,
+      delivery.event.payload
+    );
+    const event = { ...delivery.event, payload };
+    if (registration.transactional) {
+      await store.transaction(async (transaction) => {
+        await invocation.invoke({ registration, event, delivery, controller, transaction });
+        if (!await store.complete(delivery, clock.now(), transaction)) {
+          throw new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, {
+            storeConfirmed: true
+          });
+        }
+      });
+      return "completed";
+    }
+    await invocation.invoke({ registration, event, delivery, controller, transaction: void 0 });
+    return outcomes.confirmCompletion(delivery);
+  }
+  /**
+   * Transactional handlers get no renewals: a renewal would write the delivery
+   * the open transaction completes, which databases with snapshot isolation
+   * (MongoDB) turn into a write conflict that reruns the handler. Instead the
+   * lease is extended once to cover the handler timeout, and the handler is
+   * aborted when that lease ends.
+   */
+  async #guardTransactionalLease(registration, { delivery, controller }) {
+    const { store, clock, settings } = this.#parts.dependencies;
+    const now = clock.now();
+    let expiry = delivery.leaseExpiresAt.getTime();
+    if (registration.timeoutMs !== null && now.getTime() + registration.timeoutMs >= expiry) {
+      expiry = now.getTime() + registration.timeoutMs + settings.leaseDurationMs;
+      if (!await store.extendLease(delivery, new Date(expiry), now)) {
+        throw new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, {
+          storeConfirmed: true
+        });
+      }
+    }
+    return schedule(clock, {
+      run: () => {
+        controller.abort(new LeaseLostError(`Lease on delivery ${delivery.deliveryId} expired`));
+      },
+      delayMs: Math.max(0, expiry - clock.now().getTime()),
+      unref: true
+    });
+  }
+};
+
+// src/retry-policy.ts
+var DEFAULT_RETRY_POLICY = {
+  attempts: 10,
+  initialDelayMs: 1e3,
+  factor: 2,
+  maxDelayMs: 6e5,
+  jitter: "full",
+  retryIf: void 0
+};
+var DEFAULT_ROUTE_RETRY_POLICY = {
+  attempts: Number.POSITIVE_INFINITY,
+  initialDelayMs: 1e3,
+  factor: 2,
+  maxDelayMs: 3e5,
+  jitter: "full",
+  retryIf: void 0
+};
+var JITTER_STRATEGIES = ["full", "equal", "none"];
+function createRetryPolicy(options, base = DEFAULT_RETRY_POLICY) {
+  const policy = mergeRetryPolicy(options, base);
+  assertValidRetryPolicy(policy);
+  return policy;
+}
+function mergeRetryPolicy(options, base) {
+  const overrides = options ?? {};
+  const initialDelayMs = overrides.initialDelay === void 0 ? base.initialDelayMs : Milliseconds.of(overrides.initialDelay, "retry.initialDelay");
+  return {
+    attempts: overrides.attempts ?? base.attempts,
+    initialDelayMs,
+    factor: overrides.factor ?? base.factor,
+    maxDelayMs: overrides.maxDelay === void 0 ? (
+      // Raising only the initial delay must not trip the inherited cap.
+      Math.max(base.maxDelayMs, initialDelayMs)
+    ) : Milliseconds.of(overrides.maxDelay, "retry.maxDelay"),
+    jitter: overrides.jitter ?? base.jitter,
+    retryIf: overrides.retryIf ?? base.retryIf
+  };
+}
+function assertValidRetryPolicy(policy) {
+  if (policy.attempts !== Number.POSITIVE_INFINITY && (!Number.isInteger(policy.attempts) || policy.attempts < 1)) {
+    throw new ConfigurationError(
+      `retry.attempts must be a positive integer or Infinity, received ${policy.attempts}`
+    );
+  }
+  if (!Number.isFinite(policy.factor) || policy.factor < 1) {
+    throw new ConfigurationError(`retry.factor must be at least 1, received ${policy.factor}`);
+  }
+  if (policy.maxDelayMs < policy.initialDelayMs) {
+    throw new ConfigurationError("retry.maxDelay must not be smaller than retry.initialDelay");
+  }
+  if (!JITTER_STRATEGIES.includes(policy.jitter)) {
+    throw new ConfigurationError(
+      `retry.jitter must be one of ${JITTER_STRATEGIES.join(", ")}, received '${String(policy.jitter)}'`
+    );
+  }
+}
+function computeRetryDelay(policy, failedAttempts, random = Math.random) {
+  const exponential = policy.initialDelayMs * policy.factor ** (failedAttempts - 1);
+  const capped = Math.min(policy.maxDelayMs, exponential);
+  switch (policy.jitter) {
+    case "full":
+      return Math.round(random() * capped);
+    case "equal":
+      return Math.round(capped / 2 + random() * capped / 2);
+    case "none":
       return Math.round(capped);
   }
 }
@@ -1377,7 +1800,7 @@ function isRetryableError(policy, error) {
   }
 }
 
-// src/dispatcher.ts
+// src/dispatch/delivery-outcomes.ts
 var FIRST_COMPLETION_RETRY_MS = 50;
 var SECOND_COMPLETION_RETRY_MS = 250;
 var LAST_COMPLETION_RETRY_MS = 1e3;
@@ -1386,205 +1809,317 @@ var COMPLETION_RETRY_DELAYS_MS = [
   SECOND_COMPLETION_RETRY_MS,
   LAST_COMPLETION_RETRY_MS
 ];
-var WAKE_COOLDOWN_MS = 5;
-var QUIET_REFILL_MS = 10;
-var REFILL_FRACTION = 0.7;
-var Dispatcher = class {
-  #dependencies;
-  #sleep;
-  #inFlight = /* @__PURE__ */ new Set();
-  #completions;
-  #pending = /* @__PURE__ */ new Map();
-  #recoveryTimer;
-  #recovery;
-  #running = false;
-  #loop;
-  #wakeUp;
-  /** Free slots the claim the loop was woken for needs at least; undefined while nobody woke it. */
-  #signalledMinimum;
-  /** Free slots a claim needs unless the poll interval or the quiet refill time passed: claims refill in groups. */
-  #refillThreshold;
-  /** Handlers whose last claim got less than it asked for: the store has nothing more for them right now. */
-  #exhaustedHandlers = /* @__PURE__ */ new Set();
-  /** Grows with every wake-up: a claim that started before one must not mark a handler exhausted. */
-  #wakeGeneration = 0;
-  #lastClaimStartedAt = Number.NEGATIVE_INFINITY;
-  #cooldownTimer;
-  #refillScheduled = false;
-  #quietRefillTimer;
-  #unwatch;
-  #watching;
-  /** Set when a stop gave up at its deadline: the store may be closed, so nothing more is started or retried. */
-  #abandoned = false;
-  /** Stops the lease renewal (or transactional lease guard) of each delivery whose handler runs. */
-  #leaseKeepers = /* @__PURE__ */ new Map();
-  #timers;
-  constructor(dependencies) {
-    this.#dependencies = dependencies;
-    this.#timers = new DeliveryTimers(dependencies.clock);
-    this.#sleep = dependencies.sleep ?? ((milliseconds) => this.#timers.sleep(milliseconds));
-    const { store, clock, settings } = dependencies;
-    this.#refillThreshold = Math.ceil(
-      Math.min(settings.concurrency, settings.batchSize) * REFILL_FRACTION
-    );
-    const { completionBatchWindowMs: windowMs = 0, completionBatchSize: maxBatchSize = 1 } = settings;
-    if (store.completeMany !== void 0 && windowMs > 0) {
-      this.#completions = new CompletionBatcher(
-        { completeMany: (leases, now) => store.completeMany(leases, now) },
-        clock,
-        { windowMs, maxBatchSize },
-        () => this.#inFlight.size
-      );
-    }
-  }
-  get isRunning() {
-    return this.#running;
-  }
-  get inFlightCount() {
-    return this.#inFlight.size;
+var DeliveryOutcomes = class {
+  #parts;
+  constructor(parts) {
+    this.#parts = parts;
   }
   /**
-   * True while the store reports new deliveries to this dispatcher by itself (see
-   * {@link EventStore.watchNewDeliveries}), from every process: a publisher then has no reason to wake it.
+   * Records a completion, retrying transient store errors while the lease is
+   * still held. Gives up to lease expiry, which reruns the handler: at-least-once.
    */
-  get watchesNewDeliveries() {
-    return this.#unwatch !== void 0;
+  async confirmCompletion(delivery) {
+    const { dependencies, shutdown, sleep } = this.#parts;
+    for (let attempt = 0; ; attempt += 1) {
+      if (shutdown.abandoned) {
+        return "unconfirmed";
+      }
+      let completed;
+      try {
+        completed = await this.complete(delivery);
+      } catch (error) {
+        const delay = COMPLETION_RETRY_DELAYS_MS[attempt];
+        if (delay === void 0) {
+          dependencies.notifier.failure("complete", error);
+          return "unconfirmed";
+        }
+        await sleep(delay);
+        continue;
+      }
+      if (!completed) {
+        throw new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, {
+          storeConfirmed: true
+        });
+      }
+      return "completed";
+    }
   }
-  start() {
-    if (this.#running) {
+  /** Records one completion, grouped with its neighbours when the store can complete many at once. */
+  complete(delivery) {
+    const { dependencies, completions } = this.#parts;
+    const { store, clock } = dependencies;
+    return completions === void 0 ? store.complete(delivery, clock.now()) : completions.submit(delivery);
+  }
+  async fail(registration, { delivery, error }) {
+    const policy = registration.retry;
+    if (delivery.attempt >= policy.attempts || !isRetryableError(policy, error)) {
+      await this.bury(delivery, error);
       return;
     }
-    this.#running = true;
-    this.#completions?.setClosing(false);
-    this.#watching = this.#watchNewDeliveries();
-    this.#loop = this.#runLoop();
+    await this.#reschedule(registration, { delivery, error });
   }
   /**
-   * Asks for a claim soon, for example right after a publish: at once after a quiet period, otherwise
-   * at the end of a short cooldown that merges the wake-ups arriving meanwhile into one claim.
+   * A worker that only noticed locally that its lease ran out may still own the delivery in the
+   * store, where other deliveries of its lane keep renewing the lane: it must not stay in flight
+   * for ever. The attempt took longer than its lease, so it counts as a failed attempt (an
+   * exhausted delivery is dead-lettered, whatever a custom `retryIf` says): a handler that always
+   * outlives its lease cannot run for ever at attempt 1. If the lease is gone for real the store
+   * refuses and nothing changes. The lost lease was reported already.
    */
-  wake() {
-    this.#exhaustedHandlers.clear();
-    this.#wakeGeneration += 1;
-    const wait = this.#lastClaimStartedAt + WAKE_COOLDOWN_MS - Date.now();
-    if (wait <= 0) {
-      this.#requestClaim();
-      return;
+  async giveBack(registration, { delivery, error }) {
+    if (delivery.attempt >= registration.retry.attempts) {
+      await this.bury(delivery, error);
+    } else {
+      await this.#reschedule(registration, { delivery, error });
     }
-    this.#cooldownTimer ??= schedule(this.#dependencies.clock, {
-      run: () => {
-        this.#cooldownTimer = void 0;
-        this.#requestClaim();
-      },
-      delayMs: wait
+  }
+  bury(delivery, error) {
+    const { store, clock, notifier } = this.#parts.dependencies;
+    const errorInfo = toErrorInfo(error);
+    return this.#change({
+      operation: "bury",
+      delivery,
+      write: () => store.bury(delivery, errorInfo, clock.now()),
+      rewrite: () => store.bury(delivery, errorInfo, clock.now()),
+      applied: () => notifier.notify("onDeliveryDead", { delivery, error: errorInfo })
     });
   }
-  /** Ends the current wait of the claim loop, or the next one at once, for a claim once `minimumFree` slots are free. */
-  #signal(minimumFree) {
-    this.#signalledMinimum = Math.min(this.#signalledMinimum ?? minimumFree, minimumFree);
-    this.#wakeUp?.();
+  release(delivery) {
+    const { store, clock, notifier } = this.#parts.dependencies;
+    return this.#change({
+      operation: "release",
+      delivery,
+      write: () => store.release(delivery, clock.now()),
+      rewrite: () => store.release(delivery, clock.now()),
+      applied: () => notifier.notify("onDeliveryReleased", { delivery })
+    });
   }
-  /**
-   * Starts listening to the store's reports of new deliveries. Polling stays the safety net: a store
-   * that cannot listen, or fails to, only costs latency, so a failure is reported and otherwise ignored.
-   */
-  async #watchNewDeliveries() {
-    const { store, notifier } = this.#dependencies;
+  /** Schedules the next attempt with the retry policy's backoff. */
+  #reschedule(registration, { delivery, error }) {
+    const { store, clock, random, notifier } = this.#parts.dependencies;
+    const policy = registration.retry;
+    const errorInfo = toErrorInfo(error);
+    const now = clock.now();
+    const availableAt = new Date(
+      now.getTime() + computeRetryDelay(policy, delivery.attempt, random)
+    );
+    const write = () => store.reschedule(delivery, availableAt, errorInfo, now);
+    return this.#change({
+      operation: "reschedule",
+      delivery,
+      write,
+      rewrite: write,
+      applied: () => notifier.notify("onDeliveryRetryScheduled", { delivery, error: errorInfo, availableAt })
+    });
+  }
+  /** Writes a state change; reports it, or the lost lease, or retains it when the store failed. */
+  async #change(change) {
+    const { dependencies, recovery } = this.#parts;
+    const { delivery } = change;
+    let changed;
     try {
-      const unwatch = await store.watchNewDeliveries?.(() => this.wake());
-      if (unwatch !== void 0 && !this.#running) {
-        await unwatch();
-        return;
-      }
-      this.#unwatch = unwatch;
-      if (unwatch !== void 0) {
-        this.wake();
-      }
-    } catch (error) {
-      notifier.failure("watch", error);
+      changed = await change.write();
+    } catch (storeError) {
+      dependencies.notifier.failure(change.operation, storeError);
+      recovery.retain({ delivery, settle: change.rewrite, applied: change.applied });
+      return;
+    }
+    if (changed) {
+      change.applied();
+    } else {
+      dependencies.notifier.notify("onLeaseLost", { delivery });
     }
   }
-  /** Stops listening to the store's reports of new deliveries. */
-  async #stopWatching() {
-    await this.#watching;
-    const unwatch = this.#unwatch;
-    this.#unwatch = void 0;
+};
+var storage = new AsyncLocalStorage();
+function runInScope(scope, work) {
+  return storage.run({ ...storage.getStore(), ...scope }, work);
+}
+function runInIsolatedScope(scope, work) {
+  return storage.run(scope, work);
+}
+function getCurrentScope() {
+  return storage.getStore();
+}
+
+// src/dispatch/handler-invocation.ts
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+  });
+}
+var HandlerInvocation = class {
+  #dependencies;
+  #timers;
+  constructor(dependencies, timers) {
+    this.#dependencies = dependencies;
+    this.#timers = timers;
+  }
+  async invoke(input) {
+    const { registration, event, delivery, controller, transaction } = input;
+    const context = contextOf(input);
+    const scope = transaction === void 0 ? { event } : { event, transaction };
+    if (controller.signal.aborted) {
+      throw controller.signal.reason;
+    }
+    const handle = () => runInIsolatedScope(scope, () => registration.handle(event, context));
+    const { observation } = this.#dependencies;
+    const work = Promise.resolve().then(
+      observation === void 0 ? handle : () => observation.process({ registration, delivery }, handle)
+    );
+    work.catch(() => void 0);
+    const cancelTimeout = this.#startTimeout(registration, controller);
     try {
-      await unwatch?.();
+      const settled = Promise.race([work, rejectOnAbort(controller.signal)]);
+      await (observation === void 0 ? settled : observation.observe({ registration, delivery }, settled));
     } catch (error) {
-      this.#dependencies.notifier.failure("watch", error);
+      await this.#awaitAbandonedHandler(work, {
+        reason: error,
+        transactional: transaction !== void 0
+      });
+      throw error;
+    } finally {
+      cancelTimeout?.();
+    }
+  }
+  /** Aborts the handler when its timeout passes; undefined for a handler without one. */
+  #startTimeout(registration, controller) {
+    if (registration.timeoutMs === null) {
+      return void 0;
     }
+    const timeoutMs = registration.timeoutMs;
+    return this.#timers.start({
+      run: () => {
+        controller.abort(
+          new HandlerTimeoutError(
+            `Handler '${registration.id}' did not settle within ${timeoutMs}ms`
+          )
+        );
+      },
+      delayMs: timeoutMs
+    });
   }
   /**
-   * Stops claiming and waits for running handlers until the drain point of `deadline` (default: the
-   * shutdown timeout from now), then aborts the rest and releases their deliveries for another
-   * process. Deliveries still in flight when the deadline itself passes are abandoned: their leases
-   * expire and they run again elsewhere. Resolves with how many were abandoned.
+   * After an abort the handler may still be running. Waiting for it keeps a
+   * retry from overlapping the abandoned run, and keeps a transactional
+   * handler from writing through a transaction that was already released.
+   * Transactional handlers are always awaited; others for one lease duration,
+   * except at shutdown, which already waited.
    */
-  async stop(deadline) {
-    const { clock, settings } = this.#dependencies;
-    const own = deadline ?? new ShutdownDeadline(clock, settings.shutdownTimeoutMs);
-    try {
-      return await this.#stopWithin(own);
-    } finally {
-      if (deadline === void 0) {
-        own.dispose();
+  async #awaitAbandonedHandler(work, { reason, transactional }) {
+    const settledWork = work.then(
+      () => void 0,
+      () => void 0
+    );
+    if (transactional) {
+      await settledWork;
+      return;
+    }
+    if (reason instanceof DispatcherStoppedError) {
+      return;
+    }
+    const deadline = Date.now() + this.#dependencies.settings.leaseDurationMs;
+    await waitUntil(this.#dependencies.clock, { work: settledWork, deadline });
+  }
+};
+function contextOf(input) {
+  const { registration, delivery, controller, transaction } = input;
+  return {
+    deliveryId: delivery.deliveryId,
+    handler: delivery.handler,
+    attempt: delivery.attempt,
+    maxAttempts: registration.retry.attempts,
+    signal: controller.signal,
+    transaction
+  };
+}
+async function waitUntil(clock, { work, deadline }) {
+  let cancel;
+  const timedOut = new Promise((resolve) => {
+    cancel = schedule(clock, {
+      run: () => resolve("timeout"),
+      delayMs: Math.max(0, deadline - Date.now())
+    });
+  });
+  const outcome = await Promise.race([work.then(() => "done"), timedOut]);
+  cancel?.();
+  return outcome;
+}
+
+// src/dispatch/in-flight-deliveries.ts
+var InFlightDeliveries = class {
+  #deliveries = /* @__PURE__ */ new Set();
+  get size() {
+    return this.#deliveries.size;
+  }
+  add(delivery) {
+    this.#deliveries.add(delivery);
+  }
+  delete(delivery) {
+    this.#deliveries.delete(delivery);
+  }
+  /** How many of the deliveries run a handler of `registration`. */
+  countOf(registration) {
+    let count = 0;
+    for (const delivery of this.#deliveries) {
+      if (registration.claimIds.includes(delivery.handler)) {
+        count += 1;
       }
     }
+    return count;
   }
-  async #stopWithin(deadline) {
-    if (!this.#running) {
-      await this.#closeRecovery(deadline);
-      return 0;
+  /** Settles once every delivery running now settled, whatever its outcome. */
+  allSettled() {
+    return Promise.allSettled([...this.#deliveries].map((delivery) => delivery.settled));
+  }
+  abortAll(reason) {
+    for (const delivery of this.#deliveries) {
+      delivery.controller.abort(reason);
     }
-    this.#running = false;
-    this.#completions?.setClosing(true);
-    this.#cooldownTimer?.();
-    this.#cooldownTimer = void 0;
-    this.#quietRefillTimer?.();
-    this.#quietRefillTimer = void 0;
-    this.#signal(this.#refillThreshold);
-    await deadline.race(this.#stopWatching());
-    await deadline.race(this.#loop);
-    const settled = Promise.allSettled([...this.#inFlight].map((delivery) => delivery.settled));
-    if (await deadline.raceDrain(settled) === "timeout") {
-      for (const delivery of this.#inFlight) {
-        delivery.controller.abort(new DispatcherStoppedError("relaybus dispatcher stopped"));
-      }
-      if (await deadline.race(settled) === "timeout") {
-        return this.#abandon();
-      }
+  }
+};
+
+// src/dispatch/settlement-recovery.ts
+function pendingKeyOf(delivery) {
+  return DeliveryLeaseIdentity.of(delivery.deliveryId, delivery.leaseToken);
+}
+var SettlementRecovery = class {
+  #dependencies;
+  #shutdown;
+  #pending = /* @__PURE__ */ new Map();
+  #recoveryTimer;
+  #recovery;
+  constructor(dependencies, shutdown) {
+    this.#dependencies = dependencies;
+    this.#shutdown = shutdown;
+  }
+  retain(entry) {
+    if (this.#shutdown.abandoned) {
+      return;
     }
-    await this.#closeRecovery(deadline);
-    await deadline.race(this.#relinquish());
-    return 0;
+    this.#pending.set(pendingKeyOf(entry.delivery), entry);
+    this.#recoveryTimer ??= schedule(this.#dependencies.clock, {
+      run: () => void this.#recoverSettlements(),
+      delayMs: this.#dependencies.settings.pollIntervalMs,
+      repeat: true,
+      unref: true
+    });
   }
-  /**
-   * The deadline passed with deliveries still in flight (aborted, their release not answered): forgets
-   * them and every settlement still to retry. Whatever they release or complete from now on may reach a
-   * closed store; a delivery whose state change is lost stays leased until the lease expires and then
-   * runs again (at-least-once).
-   */
-  #abandon() {
-    this.#abandoned = true;
-    for (const stopKeeping of this.#leaseKeepers.values()) {
-      stopKeeping();
+  /** A new claim of this delivery makes whatever was pending for its earlier claims moot. */
+  forgetEarlierClaims(delivery) {
+    for (const key of [...this.#pending.keys()].filter(
+      (pending) => pending.startsWith(DeliveryLeaseIdentity.prefixOf(delivery.deliveryId))
+    )) {
+      this.#pending.delete(key);
     }
-    this.#leaseKeepers.clear();
-    this.#timers.cancelAll();
-    this.#recoveryTimer?.();
-    this.#recoveryTimer = void 0;
-    this.#pending.clear();
-    return this.#inFlight.size;
   }
   /**
    * Gives the settlements still pending one last try and forgets them. A pass of the timer may be inside the
    * store: it ends before the last pass starts. A store that does not answer before the deadline gets no
    * further call, since it may be closed right after.
    */
-  async #closeRecovery(deadline) {
-    this.#recoveryTimer?.();
-    this.#recoveryTimer = void 0;
+  async close(deadline) {
+    this.#stopTimer();
     const lastTry = (async () => {
       await this.#recovery;
       await this.#recoverSettlements();
@@ -1592,6 +2127,15 @@ var Dispatcher = class {
     await deadline.race(lastTry);
     this.#pending.clear();
   }
+  /** Stop gave up: forgets every settlement still to retry, which may reach a closed store. */
+  abandon() {
+    this.#stopTimer();
+    this.#pending.clear();
+  }
+  #stopTimer() {
+    this.#recoveryTimer?.();
+    this.#recoveryTimer = void 0;
+  }
   /**
    * Retries every pending settlement once; a pass that is already running is the one returned. A store that
    * still fails leaves the settlement for the next attempt (it was reported when it first failed).
@@ -1609,7 +2153,7 @@ var Dispatcher = class {
       }
       try {
         const applied = await entry.settle();
-        this.#pending.delete(pendingKey(entry.delivery));
+        this.#pending.delete(pendingKeyOf(entry.delivery));
         if (applied) {
           entry.applied();
         } else {
@@ -1619,671 +2163,888 @@ var Dispatcher = class {
       }
     }
   }
-  #retain(entry) {
-    if (this.#abandoned) {
-      return;
-    }
-    this.#pending.set(pendingKey(entry.delivery), entry);
-    this.#recoveryTimer ??= schedule(this.#dependencies.clock, {
-      run: () => void this.#recoverSettlements(),
-      delayMs: this.#dependencies.settings.pollIntervalMs,
-      repeat: true,
-      unref: true
-    });
-  }
-  /** Gives lease groups the owner no longer works on back to the store, so other workers need not wait for expiry. */
-  async #relinquish() {
-    const { store, clock, notifier, settings } = this.#dependencies;
-    try {
-      await store.relinquish?.(settings.owner, clock.now());
-    } catch (error) {
-      notifier.failure("relinquish", error);
-    }
-  }
-  /** Claims one batch and resolves when every claimed delivery settled. Returns how many ran. */
-  async processBatch() {
-    const { started } = await this.#claimAndStart();
-    await Promise.allSettled(started.map((delivery) => delivery.settled));
-    return started.length;
+};
+
+// src/completion-batcher.ts
+var CompletionBatcher = class {
+  #store;
+  #clock;
+  #settings;
+  #runningCount;
+  #pending = [];
+  #timer;
+  #closing = false;
+  /**
+   * @param runningCount Number of deliveries the dispatcher is running right
+   * now, including the ones waiting in this batcher.
+   */
+  constructor(store, clock, settings, runningCount) {
+    this.#store = store;
+    this.#clock = clock;
+    this.#settings = settings;
+    this.#runningCount = runningCount;
   }
-  async #waitUntil(work, deadline) {
-    let cancel;
-    const timedOut = new Promise((resolve) => {
-      cancel = schedule(this.#dependencies.clock, {
-        run: () => resolve("timeout"),
-        delayMs: Math.max(0, deadline - Date.now())
-      });
+  /**
+   * Queues a completion. Resolves with whether the lease was still held;
+   * rejects with the store error when the batch could not be written.
+   */
+  submit(lease) {
+    return new Promise((resolve, reject) => {
+      this.#pending.push({ lease, resolve, reject });
+      if (this.#closing || this.#pending.length >= this.#settings.maxBatchSize || this.#pending.length >= this.#runningCount()) {
+        this.#flush();
+      } else {
+        this.#timer ??= schedule(this.#clock, {
+          run: () => this.#flush(),
+          delayMs: this.#settings.windowMs
+        });
+      }
     });
-    const outcome = await Promise.race([work.then(() => "done"), timedOut]);
-    cancel?.();
-    return outcome;
   }
   /**
-   * Claims until stopped. A claim that filled its batch is followed by the next one at once while enough
-   * slots are free. Otherwise the loop sleeps until a wake-up (a publish, a store notification, or enough
-   * deliveries settling to refill a group of slots) or the poll interval. Only the poll interval claims
-   * for fewer free slots than the refill threshold, so a busy dispatcher never claims slot by slot.
+   * Shutdown has begun (or ended): while closing, nothing waits for company any more, so the completions
+   * already queued are written now and later ones at once.
    */
-  async #runLoop() {
-    let minimumFree = 1;
-    while (this.#running) {
-      let round = { requested: 0, claimed: 0 };
-      if (this.#freeSlots() >= minimumFree) {
-        try {
-          round = await this.#claimAndStart();
-        } catch (error) {
-          this.#dependencies.notifier.failure("claim", error);
-        }
-      }
-      if (round.requested > 0 && round.claimed === round.requested && this.#freeSlots() >= this.#refillThreshold) {
-        minimumFree = this.#refillThreshold;
-        continue;
-      }
-      minimumFree = await this.#waitForWakeUp();
-      if (this.#freeSlots() < minimumFree) {
-        this.#requestClaim();
-      }
+  setClosing(closing) {
+    this.#closing = closing;
+    if (closing && this.#pending.length > 0) {
+      this.#flush();
     }
   }
-  /** Waits for a wake-up or the poll interval. Resolves with the free slots the next claim needs. */
-  async #waitForWakeUp() {
-    if (this.#signalledMinimum === void 0) {
-      await new Promise((resolve) => {
-        const cancel = schedule(this.#dependencies.clock, {
-          run: () => {
-            this.#signalledMinimum = 1;
-            resolve();
-          },
-          delayMs: this.#dependencies.settings.pollIntervalMs
-        });
-        this.#wakeUp = () => {
-          cancel();
-          resolve();
-        };
-      });
-      this.#wakeUp = void 0;
+  #flush() {
+    this.#timer?.();
+    this.#timer = void 0;
+    const batch = this.#pending;
+    this.#pending = [];
+    Promise.resolve().then(
+      () => this.#store.completeMany(
+        batch.map((entry) => entry.lease),
+        this.#clock.now()
+      )
+    ).then(
+      (outcomes) => batch.forEach((entry, index) => entry.resolve(outcomes[index])),
+      (error) => batch.forEach((entry) => entry.reject(error))
+    );
+  }
+};
+
+// src/delivery-timers.ts
+var DeliveryTimers = class {
+  #clock;
+  /** Cancel of every timer still waiting, with what its cancellation must also do. */
+  #waiting = /* @__PURE__ */ new Map();
+  constructor(clock) {
+    this.#clock = clock;
+  }
+  /** Runs `task.run` after `task.delayMs`; returns what cancels it. */
+  start(task) {
+    return this.#start(task, () => void 0);
+  }
+  /** Resolves after `milliseconds`, or at once when {@link DeliveryTimers.cancelAll} runs. */
+  sleep(milliseconds) {
+    return new Promise((resolve) => {
+      this.#start({ run: resolve, delayMs: milliseconds }, resolve);
+    });
+  }
+  cancelAll() {
+    for (const [cancel, onCancel] of [...this.#waiting]) {
+      cancel();
+      onCancel();
     }
-    const minimumFree = this.#signalledMinimum;
-    this.#signalledMinimum = void 0;
-    return minimumFree;
   }
-  /**
-   * A delivery settled. Its slot is worth refilling when the store may have more for its handler: a keyed
-   * delivery unblocks the next one of its key, a delivery that did not succeed may be due again at once
-   * (a retry without delay, a release), and a handler whose last claim was full may have a backlog.
-   */
-  #onSettled(delivery, succeeded) {
-    if (delivery.event.key !== null || !succeeded || !this.#exhaustedHandlers.has(delivery.handler)) {
-      this.#requestClaim();
+  #start(task, onCancel) {
+    const cancel = () => {
+      cancelTimer();
+      this.#waiting.delete(cancel);
+    };
+    const cancelTimer = schedule(this.#clock, {
+      run: () => {
+        this.#waiting.delete(cancel);
+        task.run();
+      },
+      delayMs: task.delayMs
+    });
+    this.#waiting.set(cancel, onCancel);
+    return cancel;
+  }
+};
+
+// src/dispatcher.ts
+var Dispatcher = class {
+  #dependencies;
+  #inFlight = new InFlightDeliveries();
+  #shutdown = new ShutdownLatch();
+  #timers;
+  #completions;
+  #recovery;
+  #executor;
+  #loop;
+  #looping;
+  #unwatch;
+  #watching;
+  constructor(dependencies) {
+    this.#dependencies = dependencies;
+    this.#timers = new DeliveryTimers(dependencies.clock);
+    this.#completions = this.#createCompletionBatcher();
+    this.#recovery = new SettlementRecovery(dependencies, this.#shutdown);
+    this.#executor = this.#createExecutor();
+    this.#loop = new ClaimLoop({
+      dependencies,
+      inFlight: this.#inFlight,
+      planner: new ClaimPlanner(this.#inFlight, dependencies.settings.batchSize),
+      shutdown: this.#shutdown,
+      start: (delivery) => this.#executor.start(delivery)
+    });
+  }
+  #createCompletionBatcher() {
+    const { store, clock, settings } = this.#dependencies;
+    const { completionBatchWindowMs: windowMs = 0, completionBatchSize: maxBatchSize = 1 } = settings;
+    if (store.completeMany === void 0 || !(windowMs > 0)) {
+      return void 0;
     }
+    return new CompletionBatcher(
+      { completeMany: (leases, now) => store.completeMany(leases, now) },
+      clock,
+      { windowMs, maxBatchSize },
+      () => this.#inFlight.size
+    );
+  }
+  #createExecutor() {
+    const dependencies = this.#dependencies;
+    const outcomes = new DeliveryOutcomes({
+      dependencies,
+      recovery: this.#recovery,
+      shutdown: this.#shutdown,
+      completions: this.#completions,
+      sleep: dependencies.sleep ?? ((milliseconds) => this.#timers.sleep(milliseconds))
+    });
+    return new DeliveryExecutor({
+      dependencies,
+      inFlight: this.#inFlight,
+      recovery: this.#recovery,
+      outcomes,
+      invocation: new HandlerInvocation(dependencies, this.#timers),
+      timers: this.#timers,
+      shutdown: this.#shutdown,
+      onSettled: (delivery, succeeded) => this.#loop.onSettled(delivery, succeeded)
+    });
+  }
+  get isRunning() {
+    return this.#loop.isRunning;
+  }
+  get inFlightCount() {
+    return this.#inFlight.size;
   }
   /**
-   * Asks the loop for a claim. Once a group of slots is free the claim waits only for the deliveries
-   * settling in the same tick, so they are claimed for together; fewer free slots are refilled when no
-   * claim started for a short while. With no free slot the next settlement asks again.
+   * True while the store reports new deliveries to this dispatcher by itself (see
+   * {@link EventStore.watchNewDeliveries}), from every process: a publisher then has no reason to wake it.
    */
-  #requestClaim() {
-    const free = this.#freeSlots();
-    if (free >= this.#refillThreshold) {
-      if (!this.#refillScheduled) {
-        this.#refillScheduled = true;
-        setImmediate(() => {
-          this.#refillScheduled = false;
-          this.#signal(this.#refillThreshold);
-        });
-      }
-    } else if (free > 0) {
-      this.#quietRefillTimer ??= schedule(this.#dependencies.clock, {
-        run: () => {
-          this.#quietRefillTimer = void 0;
-          this.#signal(1);
-        },
-        delayMs: Math.max(0, this.#lastClaimStartedAt + QUIET_REFILL_MS - Date.now())
-      });
+  get watchesNewDeliveries() {
+    return this.#unwatch !== void 0;
+  }
+  start() {
+    if (this.#loop.isRunning) {
+      return;
     }
+    this.#loop.open();
+    this.#completions?.setClosing(false);
+    this.#watching = this.#watchNewDeliveries();
+    this.#looping = this.#loop.run();
   }
-  #freeSlots() {
-    return this.#dependencies.settings.concurrency - this.#inFlight.size;
+  /**
+   * Asks for a claim soon, for example right after a publish: at once after a quiet period, otherwise
+   * at the end of a short cooldown that merges the wake-ups arriving meanwhile into one claim.
+   */
+  wake() {
+    this.#loop.wake();
   }
-  /** Claims for every handler with room and starts what was claimed. */
-  async #claimAndStart() {
-    const { store, registry, clock, settings, observation } = this.#dependencies;
-    const started = [];
-    let requested = 0;
-    for (const request of this.#planClaims(registry.all())) {
-      const now = clock.now();
-      const wakeGeneration = this.#wakeGeneration;
-      this.#lastClaimStartedAt = Date.now();
-      this.#quietRefillTimer?.();
-      this.#quietRefillTimer = void 0;
-      requested += request.limit;
-      const claim = {
-        handlers: request.handlers,
-        limit: request.limit,
-        leaseOwner: settings.owner,
-        leaseExpiresAt: new Date(now.getTime() + settings.leaseDurationMs),
-        now
-      };
-      const claimed = await (observation === void 0 ? store.claim(claim) : observation.claim(store, claim));
-      for (const handler of request.handlers) {
-        if (claimed.length < request.limit && wakeGeneration === this.#wakeGeneration) {
-          this.#exhaustedHandlers.add(handler);
-        } else {
-          this.#exhaustedHandlers.delete(handler);
-        }
+  /**
+   * Starts listening to the store's reports of new deliveries. Polling stays the safety net: a store
+   * that cannot listen, or fails to, only costs latency, so a failure is reported and otherwise ignored.
+   */
+  async #watchNewDeliveries() {
+    const { store, notifier } = this.#dependencies;
+    try {
+      const unwatch = await store.watchNewDeliveries?.(() => this.wake());
+      if (unwatch !== void 0 && !this.#loop.isRunning) {
+        await unwatch();
+        return;
       }
-      for (const delivery of this.#abandoned ? [] : claimed) {
-        started.push(this.#start(delivery));
+      this.#unwatch = unwatch;
+      if (unwatch !== void 0) {
+        this.wake();
       }
+    } catch (error) {
+      notifier.failure("watch", error);
     }
-    return { requested, claimed: started.length, started };
   }
-  /** One claim for handlers without a concurrency limit, one per limited handler with room. */
-  #planClaims(registrations) {
-    let free = Math.min(this.#freeSlots(), this.#dependencies.settings.batchSize);
-    const plans = [];
-    const unlimited = registrations.filter((registration) => registration.concurrency === null);
-    for (const registration of registrations) {
-      if (registration.concurrency === null || free === 0) {
-        continue;
-      }
-      const room = registration.concurrency - this.#countInFlight(registration);
-      const limit = Math.min(room, free);
-      if (limit > 0) {
-        plans.push({ handlers: [...registration.claimIds], limit });
-        free -= limit;
-      }
+  /** Stops listening to the store's reports of new deliveries. */
+  async #stopWatching() {
+    await this.#watching;
+    const unwatch = this.#unwatch;
+    this.#unwatch = void 0;
+    try {
+      await unwatch?.();
+    } catch (error) {
+      this.#dependencies.notifier.failure("watch", error);
     }
-    if (unlimited.length > 0 && free > 0) {
-      plans.push({
-        handlers: unlimited.flatMap((registration) => registration.claimIds),
-        limit: free
-      });
+  }
+  /**
+   * Stops claiming and waits for running handlers until the drain point of `deadline` (default: the
+   * shutdown timeout from now), then aborts the rest and releases their deliveries for another
+   * process. Deliveries still in flight when the deadline itself passes are abandoned: their leases
+   * expire and they run again elsewhere. Resolves with how many were abandoned.
+   */
+  async stop(deadline) {
+    const { clock, settings } = this.#dependencies;
+    const own = deadline ?? new ShutdownDeadline(clock, settings.shutdownTimeoutMs);
+    try {
+      return await this.#stopWithin(own);
+    } finally {
+      if (deadline === void 0) {
+        own.dispose();
+      }
     }
-    return plans;
   }
-  #countInFlight(registration) {
-    let count = 0;
-    for (const delivery of this.#inFlight) {
-      if (registration.claimIds.includes(delivery.handler)) {
-        count += 1;
+  async #stopWithin(deadline) {
+    if (!this.#loop.isRunning) {
+      await this.#recovery.close(deadline);
+      return 0;
+    }
+    this.#loop.halt();
+    this.#completions?.setClosing(true);
+    this.#loop.interrupt();
+    await deadline.race(this.#stopWatching());
+    await deadline.race(this.#looping);
+    const settled = this.#inFlight.allSettled();
+    if (await deadline.raceDrain(settled) === "timeout") {
+      this.#inFlight.abortAll(new DispatcherStoppedError("relaybus dispatcher stopped"));
+      if (await deadline.race(settled) === "timeout") {
+        return this.#abandon();
       }
     }
-    return count;
+    await this.#recovery.close(deadline);
+    await deadline.race(this.#relinquish());
+    return 0;
   }
-  #start(delivery) {
-    const controller = new AbortController();
-    let succeeded = false;
-    const entry = {
-      handler: delivery.handler,
-      controller,
-      settled: Promise.resolve().then(async () => {
-        succeeded = await this.#execute(delivery, controller);
-      }).catch((error) => this.#dependencies.notifier.failure("dispatch", error)).finally(() => {
-        this.#inFlight.delete(entry);
-        this.#onSettled(delivery, succeeded);
-      })
-    };
-    this.#inFlight.add(entry);
-    return entry;
+  /**
+   * The deadline passed with deliveries still in flight (aborted, their release not answered): forgets
+   * them and every settlement still to retry. Whatever they release or complete from now on may reach a
+   * closed store; a delivery whose state change is lost stays leased until the lease expires and then
+   * runs again (at-least-once).
+   */
+  #abandon() {
+    this.#shutdown.abandon();
+    this.#executor.abandon();
+    this.#timers.cancelAll();
+    this.#recovery.abandon();
+    return this.#inFlight.size;
   }
-  /** Runs one delivery. Resolves true when its handler succeeded, so the delivery is done for good. */
-  async #execute(delivery, controller) {
-    const { registry, notifier, clock } = this.#dependencies;
-    const registration = registry.get(delivery.handler);
-    for (const key of [...this.#pending.keys()].filter(
-      (pending) => pending.startsWith(`${delivery.deliveryId}\0`)
-    )) {
-      this.#pending.delete(key);
+  /** Gives lease groups the owner no longer works on back to the store, so other workers need not wait for expiry. */
+  async #relinquish() {
+    const { store, clock, notifier, settings } = this.#dependencies;
+    try {
+      await store.relinquish?.(settings.owner, clock.now());
+    } catch (error) {
+      notifier.failure("relinquish", error);
     }
-    notifier.notify("onDeliveryStarted", { delivery });
-    const startedAt = clock.now().getTime();
-    if (delivery.attempt > registration.retry.attempts) {
-      await this.#bury(
-        delivery,
-        new AttemptsExhaustedError(
-          `Delivery reached attempt ${delivery.attempt} of ${registration.retry.attempts} after its lease expired`
-        )
+  }
+  /** Claims one batch and resolves when every claimed delivery settled. Returns how many ran. */
+  async processBatch() {
+    const { started } = await this.#loop.claimAndStart();
+    await Promise.allSettled(started.map((delivery) => delivery.settled));
+    return started.length;
+  }
+};
+
+// src/handler-registry.ts
+var HANDLER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,254}$/;
+var HandlerRegistry = class {
+  #byId = /* @__PURE__ */ new Map();
+  #byClaimId = /* @__PURE__ */ new Map();
+  #byEventType = /* @__PURE__ */ new Map();
+  register(input, defaults) {
+    const { options } = input;
+    if (!HANDLER_ID_PATTERN.test(options.id)) {
+      throw new ConfigurationError(
+        `Handler id '${options.id}' must be 1-255 characters of letters, digits, '.', '_', ':', '/' or '-'`
       );
-      return false;
     }
-    let stopHeartbeat = () => void 0;
-    try {
-      stopHeartbeat = registration.transactional ? await this.#guardTransactionalLease(registration, { delivery, controller }) : startLeaseHeartbeat(this.#dependencies, { delivery, controller });
-      this.#leaseKeepers.set(delivery, stopHeartbeat);
-      const outcome = await this.#runHandler(registration, { delivery, controller });
-      const durationMs = clock.now().getTime() - startedAt;
-      if (outcome === "completed") {
-        notifier.notify("onDeliverySucceeded", { delivery, durationMs });
-      } else {
-        this.#retain({
-          delivery,
-          settle: () => this.#complete(delivery),
-          applied: () => notifier.notify("onDeliverySucceeded", { delivery, durationMs })
-        });
-      }
-      return true;
-    } catch (error) {
-      if (this.#abandoned) {
-        return false;
-      }
-      if (error instanceof LeaseLostError) {
-        notifier.notify("onLeaseLost", { delivery });
-        if (!error.storeConfirmed) {
-          await this.#giveBack(registration, { delivery, error });
-        }
-      } else if (error instanceof DispatcherStoppedError) {
-        await this.#release(delivery);
-      } else {
-        await this.#fail(registration, { delivery, error });
+    const claimIds = [options.id, ...input.legacyIds ?? []];
+    this.#assertUnregistered(claimIds);
+    if (options.concurrency !== void 0) {
+      PositiveInteger.of(options.concurrency, `Concurrency of handler '${options.id}'`);
+    }
+    const registration = {
+      id: options.id,
+      eventTypes: input.eventTypes,
+      claimIds,
+      schema: input.schema,
+      handle: input.handle,
+      retry: createRetryPolicy(options.retry, defaults.retry),
+      timeoutMs: resolveTimeout(options.timeout, {
+        fallback: defaults.timeoutMs,
+        handlerId: options.id
+      }),
+      concurrency: options.concurrency ?? null,
+      transactional: options.transactional ?? false,
+      forwardsToTransport: input.forwardsToTransport
+    };
+    this.#index(registration);
+    return registration;
+  }
+  #assertUnregistered(claimIds) {
+    for (const id of claimIds) {
+      if (this.#byClaimId.has(id)) {
+        throw new ConfigurationError(`Handler id '${id}' is already registered`);
       }
-      return false;
-    } finally {
-      stopHeartbeat();
-      this.#leaseKeepers.delete(delivery);
     }
   }
-  async #runHandler(registration, {
-    delivery,
-    controller
-  }) {
-    const { store, clock } = this.#dependencies;
-    const payload = await validatePayload(
-      delivery.event.type,
-      registration.schema,
-      delivery.event.payload
-    );
-    const event = { ...delivery.event, payload };
-    if (registration.transactional) {
-      await store.transaction(async (transaction) => {
-        await this.#invoke({ registration, event, delivery, controller, transaction });
-        if (!await store.complete(delivery, clock.now(), transaction)) {
-          throw new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, {
-            storeConfirmed: true
-          });
-        }
-      });
-      return "completed";
+  #index(registration) {
+    this.#byId.set(registration.id, registration);
+    for (const id of registration.claimIds) {
+      this.#byClaimId.set(id, registration);
+    }
+    for (const eventType of registration.eventTypes) {
+      const forType = this.#byEventType.get(eventType) ?? [];
+      forType.push(registration);
+      this.#byEventType.set(eventType, forType);
     }
-    await this.#invoke({ registration, event, delivery, controller, transaction: void 0 });
-    return this.#confirmCompletion(delivery);
   }
-  /**
-   * Records a completion, retrying transient store errors while the lease is
-   * still held. Gives up to lease expiry, which reruns the handler: at-least-once.
-   */
-  async #confirmCompletion(delivery) {
-    const { notifier } = this.#dependencies;
-    for (let attempt = 0; ; attempt += 1) {
-      if (this.#abandoned) {
-        return "unconfirmed";
-      }
-      let completed;
+  /** The registration that runs deliveries stored under `id`, its own id or a legacy one. */
+  get(id) {
+    return this.#byClaimId.get(id);
+  }
+  forEventType(eventType) {
+    return this.#byEventType.get(eventType) ?? [];
+  }
+  all() {
+    return [...this.#byId.values()];
+  }
+};
+function resolveTimeout(timeout, { fallback, handlerId }) {
+  if (timeout === void 0) {
+    return fallback;
+  }
+  if (timeout === false) {
+    return null;
+  }
+  return Milliseconds.forTimer(timeout, `Timeout of handler '${handlerId}'`);
+}
+
+// src/notifier.ts
+var Notifier = class {
+  #observers;
+  #logger;
+  /** Hooks at least one observer implements, so callers skip building events nobody reads. */
+  #implemented;
+  constructor(observers, logger) {
+    this.#observers = observers;
+    this.#logger = logger;
+    this.#implemented = new Set(
+      observers.flatMap((observer) => hookNames(observer))
+    );
+  }
+  /** True when some observer implements `method`. */
+  wants(method) {
+    return this.#implemented.has(method);
+  }
+  notify(method, argument) {
+    for (const observer of this.#observers) {
       try {
-        completed = await this.#complete(delivery);
+        observer[method]?.call(
+          observer,
+          argument
+        );
       } catch (error) {
-        const delay = COMPLETION_RETRY_DELAYS_MS[attempt];
-        if (delay === void 0) {
-          notifier.failure("complete", error);
-          return "unconfirmed";
-        }
-        await this.#sleep(delay);
+        this.#reportObserverFailure(observer, error);
+      }
+    }
+  }
+  failure(stage, error) {
+    const errorInfo = toErrorInfo(error);
+    this.#logger.error(
+      `[Notifier](failure) relaybus ${stage} failed | ${errorInfo.name}: ${errorInfo.message}`
+    );
+    for (const observer of this.#observers) {
+      try {
+        observer.onFailure?.({ stage, error: errorInfo });
+      } catch (observerError) {
+        this.#logObserverFailure(observerError);
+      }
+    }
+  }
+  #reportObserverFailure(failedObserver, error) {
+    this.#logObserverFailure(error);
+    const errorInfo = toErrorInfo(error);
+    for (const observer of this.#observers) {
+      if (observer === failedObserver) {
         continue;
       }
-      if (!completed) {
-        throw new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, {
-          storeConfirmed: true
-        });
+      try {
+        observer.onFailure?.({ stage: "observer", error: errorInfo });
+      } catch (observerError) {
+        this.#logObserverFailure(observerError);
       }
-      return "completed";
     }
   }
-  /** Records one completion, grouped with its neighbours when the store can complete many at once. */
-  #complete(delivery) {
-    const { store, clock } = this.#dependencies;
-    return this.#completions === void 0 ? store.complete(delivery, clock.now()) : this.#completions.submit(delivery);
+  #logObserverFailure(error) {
+    const errorInfo = toErrorInfo(error);
+    this.#logger.warn(
+      `[Notifier](logObserverFailure) relaybus observer threw | ${errorInfo.name}: ${errorInfo.message}`
+    );
   }
-  async #invoke(input) {
-    const { registration, event, delivery, controller, transaction } = input;
-    const context = {
-      deliveryId: delivery.deliveryId,
-      handler: delivery.handler,
-      attempt: delivery.attempt,
-      maxAttempts: registration.retry.attempts,
-      signal: controller.signal,
-      transaction
-    };
-    const scope = transaction === void 0 ? { event } : { event, transaction };
-    if (controller.signal.aborted) {
-      throw controller.signal.reason;
-    }
-    const handle = () => runInIsolatedScope(scope, () => registration.handle(event, context));
-    const { observation } = this.#dependencies;
-    const work = Promise.resolve().then(
-      observation === void 0 ? handle : () => observation.process({ registration, delivery }, handle)
+};
+function hookNames(observer) {
+  const names = [];
+  for (let target = observer; target !== null && target !== Object.prototype; target = Object.getPrototypeOf(target)) {
+    names.push(
+      ...Object.getOwnPropertyNames(target).filter(
+        (name) => typeof observer[name] === "function"
+      )
     );
-    work.catch(() => void 0);
-    let cancelTimeout;
-    if (registration.timeoutMs !== null) {
-      const timeoutMs = registration.timeoutMs;
-      cancelTimeout = this.#timers.start({
-        run: () => {
-          controller.abort(
-            new HandlerTimeoutError(
-              `Handler '${registration.id}' did not settle within ${timeoutMs}ms`
-            )
-          );
-        },
-        delayMs: timeoutMs
-      });
-    }
-    try {
-      const settled = Promise.race([work, rejectOnAbort(controller.signal)]);
-      await (observation === void 0 ? settled : observation.observe({ registration, delivery }, settled));
-    } catch (error) {
-      await this.#awaitAbandonedHandler(work, {
-        reason: error,
-        transactional: transaction !== void 0
-      });
-      throw error;
-    } finally {
-      cancelTimeout?.();
-    }
   }
-  /**
-   * After an abort the handler may still be running. Waiting for it keeps a
-   * retry from overlapping the abandoned run, and keeps a transactional
-   * handler from writing through a transaction that was already released.
-   * Transactional handlers are always awaited; others for one lease duration,
-   * except at shutdown, which already waited.
-   */
-  async #awaitAbandonedHandler(work, { reason, transactional }) {
-    const settledWork = work.then(
-      () => void 0,
-      () => void 0
+  return names;
+}
+var DEFAULTS = {
+  concurrency: 10,
+  pollInterval: "1s",
+  leaseDuration: "30s",
+  shutdownTimeout: "30s",
+  completionBatchWindow: "2ms",
+  completionBatchSize: 200,
+  completedRetention: "7d",
+  retentionInterval: "1h",
+  routeTimeoutMs: 3e4,
+  transactionTimeout: "5s"
+};
+function oneOf(value, { allowed, name }) {
+  if (!allowed.includes(value)) {
+    throw new ConfigurationError(
+      `${name} must be one of ${allowed.map((option) => `'${option}'`).join(", ")}, received '${String(value)}'`
     );
-    if (transactional) {
-      await settledWork;
-      return;
-    }
-    if (reason instanceof DispatcherStoppedError) {
-      return;
+  }
+  return value;
+}
+function isDispatcherEnabled(options) {
+  return options.dispatcher?.enabled ?? true;
+}
+function resolveBacklogInterval(options) {
+  return options.backlogInterval === void 0 ? void 0 : Milliseconds.forTimer(options.backlogInterval, "backlogInterval");
+}
+function resolveTransactionTimeout(options) {
+  return Milliseconds.forTimer(
+    options.transactionTimeout ?? DEFAULTS.transactionTimeout,
+    "transactionTimeout"
+  );
+}
+function createHandlerDefaults(options) {
+  return {
+    retry: createRetryPolicy(options.retry),
+    timeoutMs: options.handlerTimeout === void 0 || options.handlerTimeout === false ? null : Milliseconds.forTimer(options.handlerTimeout, "handlerTimeout")
+  };
+}
+function createDispatcherSettings(options, generateIdentifier) {
+  const dispatcher = options ?? {};
+  const concurrency = PositiveInteger.of(
+    dispatcher.concurrency ?? DEFAULTS.concurrency,
+    "dispatcher.concurrency"
+  );
+  return {
+    owner: `${hostname()}:${process.pid}:${generateIdentifier()}`,
+    concurrency,
+    batchSize: PositiveInteger.of(dispatcher.batchSize ?? concurrency, "dispatcher.batchSize"),
+    ...createDispatcherTimings(dispatcher)
+  };
+}
+function createDispatcherTimings(dispatcher) {
+  return {
+    pollIntervalMs: Milliseconds.forTimer(
+      dispatcher.pollInterval ?? DEFAULTS.pollInterval,
+      "dispatcher.pollInterval"
+    ),
+    leaseDurationMs: Milliseconds.forTimer(
+      dispatcher.leaseDuration ?? DEFAULTS.leaseDuration,
+      "dispatcher.leaseDuration"
+    ),
+    shutdownTimeoutMs: Milliseconds.forTimer(
+      dispatcher.shutdownTimeout ?? DEFAULTS.shutdownTimeout,
+      "dispatcher.shutdownTimeout"
+    ),
+    completionBatchWindowMs: Milliseconds.of(
+      dispatcher.completionBatchWindow ?? DEFAULTS.completionBatchWindow,
+      "dispatcher.completionBatchWindow"
+    ),
+    completionBatchSize: PositiveInteger.of(
+      dispatcher.completionBatchSize ?? DEFAULTS.completionBatchSize,
+      "dispatcher.completionBatchSize"
+    )
+  };
+}
+function createRetentionSettings(options) {
+  const completed = options?.completed ?? DEFAULTS.completedRetention;
+  const dead = options?.dead ?? false;
+  return {
+    completedMs: completed === false ? null : Milliseconds.of(completed, "retention.completed"),
+    deadMs: dead === false ? null : Milliseconds.of(dead, "retention.dead"),
+    intervalMs: Milliseconds.forTimer(
+      options?.interval ?? DEFAULTS.retentionInterval,
+      "retention.interval"
+    )
+  };
+}
+
+// src/route-groups.ts
+var TRANSPORT_HANDLER_PREFIX = "relaybus.transport";
+function groupRoutes(routes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const type = routedType(route.event);
+    const destination = route.destination ?? type;
+    const id = `${TRANSPORT_HANDLER_PREFIX}:${route.transport}:${destination}`;
+    const group = groups.get(id);
+    if (group === void 0) {
+      groups.set(id, createGroup(route, { id, destination, type }));
+    } else {
+      addRoute(group, { route, type, destination });
     }
-    const deadline = Date.now() + this.#dependencies.settings.leaseDurationMs;
-    await this.#waitUntil(settledWork, deadline);
   }
-  /**
-   * Transactional handlers get no renewals: a renewal would write the delivery
-   * the open transaction completes, which databases with snapshot isolation
-   * (MongoDB) turn into a write conflict that reruns the handler. Instead the
-   * lease is extended once to cover the handler timeout, and the handler is
-   * aborted when that lease ends.
-   */
-  async #guardTransactionalLease(registration, {
-    delivery,
-    controller
-  }) {
-    const { store, clock, settings } = this.#dependencies;
-    const now = clock.now();
-    let expiry = delivery.leaseExpiresAt.getTime();
-    if (registration.timeoutMs !== null && now.getTime() + registration.timeoutMs >= expiry) {
-      expiry = now.getTime() + registration.timeoutMs + settings.leaseDurationMs;
-      if (!await store.extendLease(delivery, new Date(expiry), now)) {
-        throw new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, {
-          storeConfirmed: true
-        });
+  return [...groups.values()];
+}
+function createGroup(route, {
+  id,
+  destination,
+  type
+}) {
+  return {
+    transport: route.transport,
+    destination,
+    id,
+    eventTypes: [type],
+    legacyIds: [`${id}:${type}`],
+    route,
+    ...resolveSettings(route, id)
+  };
+}
+function addRoute(group, {
+  route,
+  type,
+  destination
+}) {
+  const target = `'${group.destination}' of transport '${group.transport}'`;
+  if (route.transport !== group.transport) {
+    throw new ConfigurationError(
+      `Routes to ${target} and to '${destination}' of transport '${route.transport}' would share the handler id '${group.id}'; rename the transport or the destination`
+    );
+  }
+  if (group.eventTypes.includes(type)) {
+    throw new ConfigurationError(`Event type ${type} is routed to ${target} twice`);
+  }
+  const { retry, timeoutMs } = resolveSettings(route, group.id);
+  if (timeoutMs !== group.timeoutMs || !sameRetryPolicy(retry, group.retry)) {
+    throw new ConfigurationError(
+      `Routes to ${target} must share retry and timeout, because their events are sent in one queue per key | types=${group.eventTypes[0]},${type}`
+    );
+  }
+  group.eventTypes.push(type);
+  group.legacyIds.push(`${group.id}:${type}`);
+}
+function resolveSettings(route, id) {
+  return {
+    retry: createRetryPolicy(route.retry, DEFAULT_ROUTE_RETRY_POLICY),
+    timeoutMs: route.timeout === void 0 ? DEFAULTS.routeTimeoutMs : Milliseconds.forTimer(route.timeout, `Timeout of handler '${id}'`)
+  };
+}
+function sameRetryPolicy(left, right) {
+  return Object.keys(left).every(
+    (field) => left[field] === right[field]
+  );
+}
+function routedType(event) {
+  const type = typeof event === "string" ? event : event.type;
+  assertEventType(type);
+  return type;
+}
+
+// src/bus/bus-connections.ts
+var BusConnections = class {
+  #parts;
+  #transports = /* @__PURE__ */ new Map();
+  #subscriptions;
+  constructor(parts, subscriptions) {
+    this.#parts = parts;
+    this.#subscriptions = subscriptions;
+  }
+  /** Every transport, in the order it was configured. */
+  get transports() {
+    return this.#transports.values();
+  }
+  /** Registers the transports, then the routes, and checks the subscriptions. */
+  register({ transports, routes }) {
+    for (const transport of transports) {
+      if (this.#transports.has(transport.name)) {
+        throw new ConfigurationError(`Transport name '${transport.name}' is used twice`);
+      }
+      this.#transports.set(transport.name, transport);
+    }
+    this.#registerRoutes(routes);
+    for (const subscription of this.#subscriptions) {
+      const transport = this.#requireTransport(subscription.transport);
+      if (transport.subscribe === void 0) {
+        throw new ConfigurationError(`Transport '${transport.name}' cannot subscribe`);
       }
     }
-    return schedule(clock, {
-      run: () => {
-        controller.abort(new LeaseLostError(`Lease on delivery ${delivery.deliveryId} expired`));
-      },
-      delayMs: Math.max(0, expiry - clock.now().getTime()),
-      unref: true
-    });
   }
-  async #fail(registration, { delivery, error }) {
-    const policy = registration.retry;
-    if (delivery.attempt >= policy.attempts || !isRetryableError(policy, error)) {
-      await this.#bury(delivery, error);
-      return;
+  /** True while every transport reports itself ready. */
+  allReady() {
+    for (const transport of this.#transports.values()) {
+      if (transport.isReady?.() === false) {
+        return false;
+      }
     }
-    await this.#reschedule(registration, { delivery, error });
+    return true;
   }
-  /** Schedules the next attempt with the retry policy's backoff. */
-  async #reschedule(registration, { delivery, error }) {
-    const { store, clock, random, notifier } = this.#dependencies;
-    const policy = registration.retry;
-    const errorInfo = toErrorInfo(error);
-    const now = clock.now();
-    const availableAt = new Date(
-      now.getTime() + computeRetryDelay(policy, delivery.attempt, random)
+  /** The inbound subscriptions, each with a transport that can subscribe. */
+  get subscriptions() {
+    return this.#subscriptions;
+  }
+  /** Subscribes one subscription, handing its messages to `receive`; the transport's own promise. */
+  subscribe(subscription, receive) {
+    const transport = this.#transports.get(subscription.transport);
+    return transport.subscribe(
+      subscription.destinations,
+      async (envelope, message) => {
+        await receive(envelope, { transport, destination: message?.destination });
+      },
+      this.#subscriptionHooks(transport)
     );
-    let rescheduled;
-    try {
-      rescheduled = await store.reschedule(delivery, availableAt, errorInfo, now);
-    } catch (storeError) {
-      notifier.failure("reschedule", storeError);
-      this.#retain({
-        delivery,
-        settle: () => store.reschedule(delivery, availableAt, errorInfo, now),
-        applied: () => notifier.notify("onDeliveryRetryScheduled", { delivery, error: errorInfo, availableAt })
-      });
-      return;
-    }
-    if (rescheduled) {
-      notifier.notify("onDeliveryRetryScheduled", { delivery, error: errorInfo, availableAt });
-    } else {
-      notifier.notify("onLeaseLost", { delivery });
+  }
+  /** What a transport may report back while subscribed; undefined when no observer wants it. */
+  #subscriptionHooks(transport) {
+    const { notifier } = this.#parts;
+    if (!notifier.wants("onInvalidMessage")) {
+      return void 0;
     }
+    return {
+      onInvalidMessage: ({ destination, error }) => {
+        const errorInfo = toErrorInfo(error);
+        notifier.notify("onInvalidMessage", {
+          transport: transport.name,
+          system: transport.system ?? transport.name,
+          destination,
+          reason: errorInfo.message,
+          error: errorInfo
+        });
+      }
+    };
   }
-  async #bury(delivery, error) {
-    const { store, clock, notifier } = this.#dependencies;
-    const errorInfo = toErrorInfo(error);
-    let buried;
-    try {
-      buried = await store.bury(delivery, errorInfo, clock.now());
-    } catch (storeError) {
-      notifier.failure("bury", storeError);
-      this.#retain({
-        delivery,
-        settle: () => store.bury(delivery, errorInfo, clock.now()),
-        applied: () => notifier.notify("onDeliveryDead", { delivery, error: errorInfo })
-      });
-      return;
+  #registerRoutes(routes) {
+    for (const route of routes) {
+      this.#requireTransport(route.transport);
     }
-    if (buried) {
-      notifier.notify("onDeliveryDead", { delivery, error: errorInfo });
-    } else {
-      notifier.notify("onLeaseLost", { delivery });
+    for (const group of groupRoutes(routes)) {
+      this.#registerRoute(group);
     }
   }
-  /**
-   * A worker that only noticed locally that its lease ran out may still own the delivery in the
-   * store, where other deliveries of its lane keep renewing the lane: it must not stay in flight
-   * for ever. The attempt took longer than its lease, so it counts as a failed attempt (an
-   * exhausted delivery is dead-lettered, whatever a custom `retryIf` says): a handler that always
-   * outlives its lease cannot run for ever at attempt 1. If the lease is gone for real the store
-   * refuses and nothing changes. The lost lease was reported already.
-   */
-  async #giveBack(registration, { delivery, error }) {
-    if (delivery.attempt >= registration.retry.attempts) {
-      await this.#bury(delivery, error);
-    } else {
-      await this.#reschedule(registration, { delivery, error });
-    }
+  /** Registers one handler for every route to a destination, so a key's events reach it in commit order. */
+  #registerRoute(group) {
+    const transport = this.#transports.get(group.transport);
+    const { route, destination } = group;
+    this.#parts.registry.register(
+      {
+        eventTypes: group.eventTypes,
+        legacyIds: group.legacyIds,
+        schema: void 0,
+        handle: this.#parts.observation?.sender(transport, destination) ?? ((envelope) => transport.publish(envelope, destination)),
+        options: {
+          id: group.id,
+          ...route.retry === void 0 ? {} : { retry: route.retry },
+          ...route.timeout === void 0 ? {} : { timeout: route.timeout }
+        },
+        forwardsToTransport: true
+      },
+      { retry: DEFAULT_ROUTE_RETRY_POLICY, timeoutMs: DEFAULTS.routeTimeoutMs }
+    );
   }
-  async #release(delivery) {
-    const { store, clock, notifier } = this.#dependencies;
-    let released;
-    try {
-      released = await store.release(delivery, clock.now());
-    } catch (storeError) {
-      notifier.failure("release", storeError);
-      this.#retain({
-        delivery,
-        settle: () => store.release(delivery, clock.now()),
-        applied: () => notifier.notify("onDeliveryReleased", { delivery })
-      });
-      return;
-    }
-    if (released) {
-      notifier.notify("onDeliveryReleased", { delivery });
-    } else {
-      notifier.notify("onLeaseLost", { delivery });
+  #requireTransport(name) {
+    const transport = this.#transports.get(name);
+    if (transport === void 0) {
+      throw new ConfigurationError(`No transport named '${name}' is configured`);
     }
+    return transport;
   }
 };
 
-// src/handler-registry.ts
-var HANDLER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,254}$/;
-var HandlerRegistry = class {
-  #byId = /* @__PURE__ */ new Map();
-  #byClaimId = /* @__PURE__ */ new Map();
-  #byEventType = /* @__PURE__ */ new Map();
-  register(input, defaults) {
-    const { options } = input;
-    if (!HANDLER_ID_PATTERN.test(options.id)) {
-      throw new ConfigurationError(
-        `Handler id '${options.id}' must be 1-255 characters of letters, digits, '.', '_', ':', '/' or '-'`
-      );
-    }
-    const claimIds = [options.id, ...input.legacyIds ?? []];
-    this.#assertUnregistered(claimIds);
-    if (options.concurrency !== void 0) {
-      assertPositiveInteger(options.concurrency, `Concurrency of handler '${options.id}'`);
-    }
-    const registration = {
-      id: options.id,
-      eventTypes: input.eventTypes,
-      claimIds,
-      schema: input.schema,
-      handle: input.handle,
-      retry: createRetryPolicy(options.retry, defaults.retry),
-      timeoutMs: resolveTimeout(options.timeout, {
-        fallback: defaults.timeoutMs,
-        handlerId: options.id
-      }),
-      concurrency: options.concurrency ?? null,
-      transactional: options.transactional ?? false,
-      forwardsToTransport: input.forwardsToTransport
-    };
-    this.#index(registration);
-    return registration;
+// src/bus/bus-maintenance.ts
+var BusMaintenance = class {
+  #parts;
+  #retentionTimer;
+  #backlogTimer;
+  constructor(parts) {
+    this.#parts = parts;
   }
-  #assertUnregistered(claimIds) {
-    for (const id of claimIds) {
-      if (this.#byClaimId.has(id)) {
-        throw new ConfigurationError(`Handler id '${id}' is already registered`);
-      }
+  /** Applies the retention policy once. */
+  async purgeExpired() {
+    const { store, clock, notifier, retention } = this.#parts;
+    const now = clock.now().getTime();
+    const { completedMs, deadMs } = retention;
+    try {
+      const result = await store.purge({
+        ...completedMs === null ? {} : { completedBefore: new Date(now - completedMs) },
+        ...deadMs === null ? {} : { deadBefore: new Date(now - deadMs) }
+      });
+      notifier.notify("onPurged", { result });
+      return result;
+    } catch (error) {
+      notifier.failure("purge", error);
+      throw error;
     }
   }
-  #index(registration) {
-    this.#byId.set(registration.id, registration);
-    for (const id of registration.claimIds) {
-      this.#byClaimId.set(id, registration);
-    }
-    for (const eventType of registration.eventTypes) {
-      const forType = this.#byEventType.get(eventType) ?? [];
-      forType.push(registration);
-      this.#byEventType.set(eventType, forType);
-    }
+  /** Starts the retention purge and the backlog report, each when it has anything to do. */
+  start() {
+    this.#scheduleRetention();
+    this.#scheduleBacklog();
   }
-  /** The registration that runs deliveries stored under `id`, its own id or a legacy one. */
-  get(id) {
-    return this.#byClaimId.get(id);
+  stop() {
+    this.#retentionTimer?.();
+    this.#backlogTimer?.();
   }
-  forEventType(eventType) {
-    return this.#byEventType.get(eventType) ?? [];
+  /** Applies the retention policy every `retention.interval` while the bus runs, when it deletes anything. */
+  #scheduleRetention() {
+    const { clock, retention } = this.#parts;
+    if (retention.completedMs !== null || retention.deadMs !== null) {
+      this.#retentionTimer = schedule(clock, {
+        run: () => {
+          this.purgeExpired().catch(() => void 0);
+        },
+        delayMs: retention.intervalMs,
+        repeat: true,
+        unref: true
+      });
+    }
   }
-  all() {
-    return [...this.#byId.values()];
+  /** Reports the backlog every `backlogInterval` while the bus runs, when an observer wants it. */
+  #scheduleBacklog() {
+    const { observation, backlogIntervalMs, statistics } = this.#parts;
+    if (backlogIntervalMs !== void 0) {
+      this.#backlogTimer = observation?.startBacklog({ intervalMs: backlogIntervalMs, statistics });
+    }
   }
 };
-function resolveTimeout(timeout, { fallback, handlerId }) {
-  if (timeout === void 0) {
-    return fallback;
-  }
-  if (timeout === false) {
-    return null;
-  }
-  return toTimerMilliseconds(timeout, `Timeout of handler '${handlerId}'`);
-}
 
-// src/notifier.ts
-var Notifier = class {
-  #observers;
-  #logger;
-  /** Hooks at least one observer implements, so callers skip building events nobody reads. */
-  #implemented;
-  constructor(observers, logger) {
-    this.#observers = observers;
-    this.#logger = logger;
-    this.#implemented = new Set(
-      observers.flatMap((observer) => hookNames(observer))
+// src/bus/event-publisher.ts
+var EventPublisher = class {
+  #parts;
+  constructor(parts) {
+    this.#parts = parts;
+  }
+  /** Publishes inside the tracer's span, with its trace headers, when the bus is observed. */
+  publish(events, call) {
+    const { observation } = this.#parts;
+    if (observation === void 0) {
+      return this.#publish(events, call);
+    }
+    return observation.publish(
+      { eventTypes: events.map((event) => String(event.type)) },
+      (headers) => this.#publish(events, { ...call, options: withTraceHeaders(call.options, headers) })
     );
   }
-  /** True when some observer implements `method`. */
-  wants(method) {
-    return this.#implemented.has(method);
+  async #publish(events, { options, id }) {
+    if (events.length === 0) {
+      return [];
+    }
+    const now = this.#parts.clock.now();
+    const delayMs = options.delay === void 0 ? 0 : Milliseconds.of(options.delay, "delay");
+    const availableAt = new Date(now.getTime() + delayMs);
+    const context = { options, id, scope: getCurrentScope(), now };
+    const entries = await this.#createEntries(events, { context, availableAt });
+    const deliverable = entries.filter((entry) => entry.deliveries.length > 0);
+    if (deliverable.length > 0) {
+      await this.#appendDeliverable(deliverable, { context, delayMs });
+    }
+    return entries.map((entry) => entry.event);
   }
-  notify(method, argument) {
-    for (const observer of this.#observers) {
-      try {
-        observer[method]?.call(
-          observer,
-          argument
-        );
-      } catch (error) {
-        this.#reportObserverFailure(observer, error);
+  /** One entry per event, in order: its envelope and a delivery for every registration of its type. */
+  async #createEntries(events, {
+    context,
+    availableAt
+  }) {
+    const { registry, createDelivery, reportUnrouted } = this.#parts;
+    const entries = [];
+    const { options, scope } = context;
+    let correlationId = options.correlationId ?? scope?.event?.correlationId ?? scope?.event?.id;
+    for (const event of events) {
+      const envelope = await this.#createEnvelope({ ...context, event, correlationId });
+      correlationId = envelope.correlationId;
+      const registrations = registry.forEventType(envelope.type);
+      if (registrations.length === 0) {
+        reportUnrouted(envelope);
       }
+      entries.push({
+        event: envelope,
+        deliveries: registrations.map((registration) => createDelivery(registration, availableAt))
+      });
     }
+    return entries;
   }
-  failure(stage, error) {
-    const errorInfo = toErrorInfo(error);
-    this.#logger.error(
-      `[Notifier](failure) relaybus ${stage} failed | ${errorInfo.name}: ${errorInfo.message}`
-    );
-    for (const observer of this.#observers) {
-      try {
-        observer.onFailure?.({ stage, error: errorInfo });
-      } catch (observerError) {
-        this.#logObserverFailure(observerError);
+  /** Appends the entries that have deliveries, reports what was new and wakes the dispatcher when it is due now. */
+  async #appendDeliverable(entries, {
+    context,
+    delayMs
+  }) {
+    const result = await this.#appendInTransaction(entries, context);
+    const appended = new Set(result.appendedEventIds);
+    const published = entries.map((entry) => entry.event).filter((envelope) => appended.has(envelope.id));
+    if (published.length > 0) {
+      this.#parts.notifier.notify("onPublished", {
+        envelopes: published,
+        deliveries: result.appendedDeliveryCount
+      });
+      if (delayMs === 0) {
+        this.#parts.scheduleWake();
       }
     }
   }
-  #reportObserverFailure(failedObserver, error) {
-    this.#logObserverFailure(error);
-    const errorInfo = toErrorInfo(error);
-    for (const observer of this.#observers) {
-      if (observer === failedObserver) {
-        continue;
-      }
-      try {
-        observer.onFailure?.({ stage: "observer", error: errorInfo });
-      } catch (observerError) {
-        this.#logObserverFailure(observerError);
-      }
+  async #appendInTransaction(entries, { options, scope, now }) {
+    const { store, transactionMode, transactionResolver } = this.#parts;
+    const transaction = options.transaction ?? scope?.transaction ?? transactionResolver?.();
+    if (transaction !== void 0) {
+      return store.append(transaction, entries, now);
+    }
+    if (transactionMode === "required") {
+      throw new TransactionRequiredError(
+        "publish found no transaction. Pass { transaction }, publish inside bus.transaction(), configure transactionResolver, or set transactionMode to optional"
+      );
     }
+    return store.transaction((ownTransaction) => store.append(ownTransaction, entries, now));
   }
-  #logObserverFailure(error) {
-    const errorInfo = toErrorInfo(error);
-    this.#logger.warn(
-      `[Notifier](logObserverFailure) relaybus observer threw | ${errorInfo.name}: ${errorInfo.message}`
-    );
+  async #createEnvelope(input) {
+    const { event, options, id, scope, now, correlationId } = input;
+    if (typeof event.type !== "string") {
+      throw new ConfigurationError(
+        "publish expects an instance of a class created with defineEvent"
+      );
+    }
+    assertEventType(event.type);
+    const schema = event.constructor.schema;
+    const payload = await validatePayload(event.type, schema, event.payload);
+    if (options.key !== void 0 && options.key.length === 0) {
+      throw new ConfigurationError("key must not be empty");
+    }
+    const eventId = id ?? this.#parts.generateIdentifier();
+    return {
+      id: eventId,
+      type: event.type,
+      source: this.#parts.source,
+      key: options.key ?? keyFromDefinition(event, payload),
+      payload,
+      headers: { ...options.headers },
+      correlationId: correlationId ?? eventId,
+      causationId: scope?.event?.id ?? null,
+      occurredAt: now
+    };
   }
 };
-function hookNames(observer) {
-  const names = [];
-  for (let target = observer; target !== null && target !== Object.prototype; target = Object.getPrototypeOf(target)) {
-    names.push(
-      ...Object.getOwnPropertyNames(target).filter(
-        (name) => typeof observer[name] === "function"
-      )
-    );
-  }
-  return names;
-}
 
 // src/received-envelope.ts
 function normalizeEnvelope(envelope) {
@@ -2321,165 +3082,126 @@ function toDate(value) {
 function optionalText(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-var DEFAULTS = {
-  concurrency: 10,
-  pollInterval: "1s",
-  leaseDuration: "30s",
-  shutdownTimeout: "30s",
-  completionBatchWindow: "2ms",
-  completionBatchSize: 200,
-  completedRetention: "7d",
-  retentionInterval: "1h",
-  routeTimeoutMs: 3e4,
-  transactionTimeout: "5s"
-};
-function oneOf(value, { allowed, name }) {
-  if (!allowed.includes(value)) {
-    throw new ConfigurationError(
-      `${name} must be one of ${allowed.map((option) => `'${option}'`).join(", ")}, received '${String(value)}'`
+
+// src/bus/event-receiver.ts
+var EventReceiver = class {
+  #parts;
+  constructor(parts) {
+    this.#parts = parts;
+  }
+  /** Stores `envelope` for local handlers; observed when the bus is, with where it came from. */
+  receive(envelope, origin) {
+    const { observation } = this.#parts;
+    return observation === void 0 ? this.#receive(envelope) : observation.receive({ envelope, origin }, () => this.#receive(envelope));
+  }
+  async #receive(envelope) {
+    const { store, registry, clock, notifier, createDelivery, scheduleWake } = this.#parts;
+    const normalized = normalizeEnvelope(envelope);
+    const registrations = registry.forEventType(normalized.type).filter((registration) => !registration.forwardsToTransport);
+    if (registrations.length === 0) {
+      notifier.notify("onReceived", { envelope: normalized, status: "ignored" });
+      return "ignored";
+    }
+    const now = clock.now();
+    const entry = {
+      event: normalized,
+      deliveries: registrations.map((registration) => createDelivery(registration, now))
+    };
+    const result = await store.transaction(
+      (transaction) => store.append(transaction, [entry], now)
     );
+    const status = result.duplicateEventIds.length > 0 ? "duplicate" : "accepted";
+    notifier.notify("onReceived", { envelope: normalized, status });
+    if (result.appendedDeliveryCount > 0) {
+      scheduleWake();
+    }
+    return status;
   }
-  return value;
-}
-function isDispatcherEnabled(options) {
-  return options.dispatcher?.enabled ?? true;
-}
-function resolveBacklogInterval(options) {
-  return options.backlogInterval === void 0 ? void 0 : toTimerMilliseconds(options.backlogInterval, "backlogInterval");
-}
-function resolveTransactionTimeout(options) {
-  return toTimerMilliseconds(
-    options.transactionTimeout ?? DEFAULTS.transactionTimeout,
-    "transactionTimeout"
-  );
-}
-function createHandlerDefaults(options) {
-  return {
-    retry: createRetryPolicy(options.retry),
-    timeoutMs: options.handlerTimeout === void 0 || options.handlerTimeout === false ? null : toTimerMilliseconds(options.handlerTimeout, "handlerTimeout")
-  };
-}
-function createDispatcherSettings(options, generateIdentifier) {
-  const dispatcher = options ?? {};
-  const concurrency = assertPositiveInteger(
-    dispatcher.concurrency ?? DEFAULTS.concurrency,
-    "dispatcher.concurrency"
-  );
-  return {
-    owner: `${hostname()}:${process.pid}:${generateIdentifier()}`,
-    concurrency,
-    batchSize: assertPositiveInteger(dispatcher.batchSize ?? concurrency, "dispatcher.batchSize"),
-    ...createDispatcherTimings(dispatcher)
-  };
-}
-function createDispatcherTimings(dispatcher) {
-  return {
-    pollIntervalMs: toTimerMilliseconds(
-      dispatcher.pollInterval ?? DEFAULTS.pollInterval,
-      "dispatcher.pollInterval"
-    ),
-    leaseDurationMs: toTimerMilliseconds(
-      dispatcher.leaseDuration ?? DEFAULTS.leaseDuration,
-      "dispatcher.leaseDuration"
-    ),
-    shutdownTimeoutMs: toTimerMilliseconds(
-      dispatcher.shutdownTimeout ?? DEFAULTS.shutdownTimeout,
-      "dispatcher.shutdownTimeout"
-    ),
-    completionBatchWindowMs: toMilliseconds(
-      dispatcher.completionBatchWindow ?? DEFAULTS.completionBatchWindow,
-      "dispatcher.completionBatchWindow"
-    ),
-    completionBatchSize: assertPositiveInteger(
-      dispatcher.completionBatchSize ?? DEFAULTS.completionBatchSize,
-      "dispatcher.completionBatchSize"
-    )
-  };
-}
-function createRetentionSettings(options) {
-  const completed = options?.completed ?? DEFAULTS.completedRetention;
-  const dead = options?.dead ?? false;
+};
+
+// src/bus/relay-bus-assembly.ts
+function assembleRelayBus(options, hooks) {
+  const core = resolveCore(options);
+  const backlogIntervalMs = resolveBacklogInterval(options);
+  const maintenance = new BusMaintenance({
+    ...core,
+    retention: createRetentionSettings(options.retention),
+    backlogIntervalMs,
+    statistics: hooks.statistics
+  });
+  const connections = new BusConnections(core, options.subscriptions ?? []);
+  connections.register({ transports: options.transports ?? [], routes: options.routes ?? [] });
+  const catalogRequirements = [];
+  for (const catalog of options.catalogs ?? []) {
+    catalogRequirements.push(toCatalogRequirement(catalog));
+  }
+  const dispatcherEnabled = isDispatcherEnabled(options);
+  const settings = createDispatcherSettings(options.dispatcher, core.generateIdentifier);
+  const dispatcher = new Dispatcher({
+    ...core,
+    random: options.random ?? Math.random,
+    settings,
+    observation: DispatchObservation.create({ ...core, tracer: options.tracer })
+  });
   return {
-    completedMs: completed === false ? null : toMilliseconds(completed, "retention.completed"),
-    deadMs: dead === false ? null : toMilliseconds(dead, "retention.dead"),
-    intervalMs: toTimerMilliseconds(
-      options?.interval ?? DEFAULTS.retentionInterval,
-      "retention.interval"
-    )
+    ...core,
+    maintenance,
+    connections,
+    catalogRequirements,
+    dispatcherEnabled,
+    shutdownTimeoutMs: settings.shutdownTimeoutMs,
+    dispatcher,
+    ...createInboxAndOutbox(core, hooks)
   };
 }
-
-// src/route-groups.ts
-var TRANSPORT_HANDLER_PREFIX = "relaybus.transport";
-function groupRoutes(routes) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const type = routedType(route.event);
-    const destination = route.destination ?? type;
-    const id = `${TRANSPORT_HANDLER_PREFIX}:${route.transport}:${destination}`;
-    const group = groups.get(id);
-    if (group === void 0) {
-      groups.set(id, createGroup(route, { id, destination, type }));
-    } else {
-      addRoute(group, { route, type, destination });
-    }
-  }
-  return [...groups.values()];
-}
-function createGroup(route, {
-  id,
-  destination,
-  type
-}) {
+function resolveCore(options) {
+  const source = options.source ?? "relaybus";
+  const transactionMode = oneOf(options.transactionMode ?? "required", {
+    allowed: ["required", "optional"],
+    name: "transactionMode"
+  });
+  const unroutedEvents = oneOf(options.unroutedEvents ?? "warn", {
+    allowed: ["warn", "throw"],
+    name: "unroutedEvents"
+  });
+  const transactionTimeoutMs = resolveTransactionTimeout(options);
+  const defaults = createHandlerDefaults(options);
+  const logger = options.logger ?? console;
+  const notifier = new Notifier(options.observers ?? [], logger);
+  const clock = options.clock ?? systemClock;
   return {
-    transport: route.transport,
-    destination,
-    id,
-    eventTypes: [type],
-    legacyIds: [`${id}:${type}`],
-    route,
-    ...resolveSettings(route, id)
+    store: options.store,
+    source,
+    transactionMode,
+    unroutedEvents,
+    transactionResolver: options.transactionResolver,
+    transactionTimeoutMs,
+    registry: new HandlerRegistry(),
+    defaults,
+    logger,
+    notifier,
+    clock,
+    observation: BusObservation.create({ notifier, tracer: options.tracer, clock }),
+    generateIdentifier: options.generateIdentifier ?? (() => createUuidV7()),
+    setupStore: options.setupStore ?? true
   };
 }
-function addRoute(group, {
-  route,
-  type,
-  destination
-}) {
-  const target = `'${group.destination}' of transport '${group.transport}'`;
-  if (route.transport !== group.transport) {
-    throw new ConfigurationError(
-      `Routes to ${target} and to '${destination}' of transport '${route.transport}' would share the handler id '${group.id}'; rename the transport or the destination`
-    );
-  }
-  if (group.eventTypes.includes(type)) {
-    throw new ConfigurationError(`Event type ${type} is routed to ${target} twice`);
-  }
-  const { retry, timeoutMs } = resolveSettings(route, group.id);
-  if (timeoutMs !== group.timeoutMs || !sameRetryPolicy(retry, group.retry)) {
-    throw new ConfigurationError(
-      `Routes to ${target} must share retry and timeout, because their events are sent in one queue per key | types=${group.eventTypes[0]},${type}`
-    );
-  }
-  group.eventTypes.push(type);
-  group.legacyIds.push(`${group.id}:${type}`);
-}
-function resolveSettings(route, id) {
+function createInboxAndOutbox(core, hooks) {
+  const createDelivery = (registration, availableAt) => ({
+    id: core.generateIdentifier(),
+    handler: registration.id,
+    availableAt
+  });
   return {
-    retry: createRetryPolicy(route.retry, DEFAULT_ROUTE_RETRY_POLICY),
-    timeoutMs: route.timeout === void 0 ? DEFAULTS.routeTimeoutMs : toTimerMilliseconds(route.timeout, `Timeout of handler '${id}'`)
+    publisher: new EventPublisher({
+      ...core,
+      createDelivery,
+      reportUnrouted: hooks.reportUnrouted,
+      scheduleWake: hooks.scheduleWake
+    }),
+    receiver: new EventReceiver({ ...core, createDelivery, scheduleWake: hooks.scheduleWake })
   };
 }
-function sameRetryPolicy(left, right) {
-  return Object.keys(left).every(
-    (field) => left[field] === right[field]
-  );
-}
-function routedType(event) {
-  const type = typeof event === "string" ? event : event.type;
-  assertEventType(type);
-  return type;
-}
 
 // src/transaction-budget.ts
 async function runBudgetedTransaction(store, { clock, timeoutMs, work }) {
@@ -2512,125 +3234,36 @@ function createTimeoutError(timeoutMs, cause) {
 }
 
 // src/relay-bus.ts
-var DEFAULT_DRAIN_BATCHES = 1e3;
-var WAKE_DELAY_MS = 25;
-var RelayBus = class {
-  #store;
-  #source;
-  #transactionMode;
-  #transactionTimeoutMs;
-  #transactionResolver;
-  #unroutedEvents;
-  #registry = new HandlerRegistry();
-  #defaults;
-  #transports = /* @__PURE__ */ new Map();
-  #subscriptions;
-  #notifier;
-  #logger;
-  #clock;
-  #generateIdentifier;
-  #dispatcher;
-  #dispatcherEnabled;
-  #catalogRequirements = [];
-  #setupStore;
-  #retention;
-  #retentionTimer;
-  #observation;
-  #backlogIntervalMs;
-  #backlogTimer;
-  #shutdownTimeoutMs;
-  #state = "idle";
-  #starting;
-  #stopping;
-  constructor(options) {
-    this.#store = options.store;
-    this.#source = options.source ?? "relaybus";
-    this.#transactionMode = oneOf(options.transactionMode ?? "required", {
-      allowed: ["required", "optional"],
-      name: "transactionMode"
-    });
-    this.#unroutedEvents = oneOf(options.unroutedEvents ?? "warn", {
-      allowed: ["warn", "throw"],
-      name: "unroutedEvents"
-    });
-    this.#transactionResolver = options.transactionResolver;
-    this.#transactionTimeoutMs = resolveTransactionTimeout(options);
-    this.#defaults = createHandlerDefaults(options);
-    this.#logger = options.logger ?? console;
-    this.#notifier = new Notifier(options.observers ?? [], this.#logger);
-    this.#clock = options.clock ?? systemClock;
-    this.#observation = BusObservation.create({
-      notifier: this.#notifier,
-      tracer: options.tracer,
-      clock: this.#clock
-    });
-    this.#backlogIntervalMs = resolveBacklogInterval(options);
-    this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
-    this.#setupStore = options.setupStore ?? true;
-    this.#retention = createRetentionSettings(options.retention);
-    this.#subscriptions = options.subscriptions ?? [];
-    this.#registerConnections(options);
-    this.#dispatcherEnabled = isDispatcherEnabled(options);
-    const settings = createDispatcherSettings(options.dispatcher, this.#generateIdentifier);
-    this.#shutdownTimeoutMs = settings.shutdownTimeoutMs;
-    this.#dispatcher = this.#createDispatcher(settings, options);
-  }
-  #createDispatcher(settings, options) {
-    return new Dispatcher({
-      store: this.#store,
-      registry: this.#registry,
-      clock: this.#clock,
-      random: options.random ?? Math.random,
-      notifier: this.#notifier,
-      settings,
-      observation: DispatchObservation.create({
-        notifier: this.#notifier,
-        tracer: options.tracer,
-        clock: this.#clock
-      })
-    });
-  }
-  /** Registers the transports, then the routes, checks the subscriptions and registers the catalogs. */
-  #registerConnections(options) {
-    for (const transport of options.transports ?? []) {
-      if (this.#transports.has(transport.name)) {
-        throw new ConfigurationError(`Transport name '${transport.name}' is used twice`);
-      }
-      this.#transports.set(transport.name, transport);
-    }
-    this.#registerRoutes(options.routes ?? []);
-    for (const subscription of this.#subscriptions) {
-      const transport = this.#requireTransport(subscription.transport);
-      if (transport.subscribe === void 0) {
-        throw new ConfigurationError(`Transport '${transport.name}' cannot subscribe`);
-      }
-    }
-    for (const catalog of options.catalogs ?? []) {
-      this.registerCatalog(catalog);
-    }
+var DEFAULT_DRAIN_BATCHES = 1e3;
+var WAKE_DELAY_MS = 25;
+var RelayBus = class {
+  #parts;
+  #lifecycle;
+  constructor(options) {
+    this.#parts = assembleRelayBus(options, {
+      reportUnrouted: (envelope) => this.#reportUnrouted(envelope),
+      scheduleWake: () => this.#scheduleWake(),
+      statistics: () => this.statistics()
+    });
+    this.#lifecycle = new BusLifecycle({
+      ...this.#parts,
+      closeTransports: (deadline) => this.#closeTransports(deadline)
+    });
   }
   get store() {
-    return this.#store;
+    return this.#parts.store;
   }
   get isRunning() {
-    return this.#state === "running";
+    return this.#lifecycle.state === "running";
   }
   /** True while the bus runs and every transport reports itself ready. */
   isReady() {
-    if (this.#state !== "running") {
-      return false;
-    }
-    for (const transport of this.#transports.values()) {
-      if (transport.isReady?.() === false) {
-        return false;
-      }
-    }
-    return true;
+    return this.#lifecycle.state === "running" && this.#parts.connections.allReady();
   }
   // eslint-disable-next-line relaybus/max-two-params -- public RelayBus.subscribe signature
   subscribe(event, handler, options) {
     const { type, schema } = describeEvent(event);
-    this.#registry.register(
+    this.#parts.registry.register(
       {
         eventTypes: [type],
         schema,
@@ -2638,7 +3271,7 @@ var RelayBus = class {
         options,
         forwardsToTransport: false
       },
-      this.#defaults
+      this.#parts.defaults
     );
   }
   // eslint-disable-next-line relaybus/max-two-params -- public RelayBus.subscribeCatalog signature
@@ -2654,7 +3287,7 @@ var RelayBus = class {
    * option.
    */
   registerCatalog(catalog) {
-    this.#catalogRequirements.push(toCatalogRequirement(catalog));
+    this.#parts.catalogRequirements.push(toCatalogRequirement(catalog));
   }
   /**
    * A view of this bus that publishes only the events of `catalog`, or only
@@ -2666,7 +3299,7 @@ var RelayBus = class {
   }
   /** Registered handlers and routes, for diagnostics. */
   handlers() {
-    return this.#registry.all().flatMap(
+    return this.#parts.registry.all().flatMap(
       (registration) => registration.eventTypes.map((eventType) => toDescriptor(registration, eventType))
     );
   }
@@ -2676,12 +3309,12 @@ var RelayBus = class {
    * have been written when the id already exists.
    */
   async publish(event, options = {}) {
-    const [envelope] = await this.#observedPublish([event], { options, id: options.id });
+    const [envelope] = await this.#parts.publisher.publish([event], { options, id: options.id });
     return envelope;
   }
   /** Stores several events atomically, in order, sharing one correlation id. */
   async publishAll(events, options = {}) {
-    return this.#observedPublish(events, { options, id: void 0 });
+    return this.#parts.publisher.publish(events, { options, id: void 0 });
   }
   /**
    * Runs `work` in a new store transaction. `publish` calls inside it join the
@@ -2689,9 +3322,9 @@ var RelayBus = class {
    * and rolled back with a {@link TransactionTimeoutError} when it runs past it.
    */
   async transaction(work) {
-    return runBudgetedTransaction(this.#store, {
-      clock: this.#clock,
-      timeoutMs: this.#transactionTimeoutMs,
+    return runBudgetedTransaction(this.#parts.store, {
+      clock: this.#parts.clock,
+      timeoutMs: this.#parts.transactionTimeoutMs,
       work: (transaction) => runInScope({ transaction }, () => work(transaction))
     });
   }
@@ -2701,7 +3334,7 @@ var RelayBus = class {
    * `transactionResolver` finds. Repositories use it to write in the same transaction.
    */
   currentTransaction() {
-    return getCurrentScope()?.transaction ?? this.#transactionResolver?.();
+    return getCurrentScope()?.transaction ?? this.#parts.transactionResolver?.();
   }
   /**
    * Stores an event received from a broker and schedules it for local handlers.
@@ -2710,32 +3343,7 @@ var RelayBus = class {
    * events, which transports should dead-letter instead of redelivering.
    */
   receive(envelope) {
-    return this.#observation === void 0 ? this.#receive(envelope) : this.#observedReceive(envelope, void 0);
-  }
-  #observedReceive(envelope, origin) {
-    return this.#observation.receive({ envelope, origin }, () => this.#receive(envelope));
-  }
-  async #receive(envelope) {
-    const normalized = normalizeEnvelope(envelope);
-    const registrations = this.#registry.forEventType(normalized.type).filter((registration) => !registration.forwardsToTransport);
-    if (registrations.length === 0) {
-      this.#notifier.notify("onReceived", { envelope: normalized, status: "ignored" });
-      return "ignored";
-    }
-    const now = this.#clock.now();
-    const entry = {
-      event: normalized,
-      deliveries: registrations.map((registration) => this.#createDelivery(registration, now))
-    };
-    const result = await this.#store.transaction(
-      (transaction) => this.#store.append(transaction, [entry], now)
-    );
-    const status = result.duplicateEventIds.length > 0 ? "duplicate" : "accepted";
-    this.#notifier.notify("onReceived", { envelope: normalized, status });
-    if (result.appendedDeliveryCount > 0) {
-      this.#scheduleWake();
-    }
-    return status;
+    return this.#parts.receiver.receive(envelope);
   }
   /**
    * Creates the store schema, connects transports, subscribes and starts
@@ -2743,18 +3351,13 @@ var RelayBus = class {
    * stopped for good, because its transports are closed; create a new instance.
    */
   async start() {
-    if (this.#state !== "idle") {
-      throw new LifecycleError(
-        this.#state === "stopped" ? "A stopped relaybus cannot be started again; create a new instance" : `Cannot start a relaybus that is ${this.#state}`
-      );
-    }
-    assertCatalogsCovered(this.#catalogRequirements, (type) => this.#registrationsOf(type));
-    this.#state = "starting";
-    this.#starting = this.#startComponents();
+    this.#lifecycle.assertStartable();
+    assertCatalogsCovered(this.#parts.catalogRequirements, (type) => this.#registrationsOf(type));
+    const starting = this.#lifecycle.beginStart(() => this.#startComponents());
     try {
-      await this.#starting;
+      await starting;
     } finally {
-      this.#starting = void 0;
+      this.#lifecycle.endStart();
     }
   }
   /**
@@ -2767,41 +3370,25 @@ var RelayBus = class {
    * get the result of the first.
    */
   async stop(options = {}) {
-    const timeoutMs = options.timeout === void 0 ? this.#shutdownTimeoutMs : toTimerMilliseconds(options.timeout, "timeout");
-    if (this.#stopping !== void 0) {
-      return this.#stopping;
+    const timeoutMs = options.timeout === void 0 ? this.#parts.shutdownTimeoutMs : Milliseconds.forTimer(options.timeout, "timeout");
+    const { stopping, first } = this.#lifecycle.stop(timeoutMs);
+    if (!first) {
+      return stopping;
     }
-    if (this.#state !== "running" && this.#state !== "starting") {
-      return this.#stopOutsideRun(timeoutMs);
-    }
-    this.#stopping = this.#stopComponents(timeoutMs);
-    const result = await this.#stopping;
+    const result = await stopping;
     if (!result.graceful) {
-      this.#logger.warn(
+      this.#parts.logger.warn(
         `[RelayBus](stop) Shutdown deadline passed, forced close | abandoned=${result.abandonedDeliveries} | timeoutMs=${timeoutMs}`
       );
     }
     return result;
   }
-  /**
-   * A bus that is not running: an idle one only settles what batches run by hand left behind (and
-   * stays startable); a stopped one has nothing left to do.
-   */
-  async #stopOutsideRun(timeoutMs) {
-    if (this.#state !== "idle") {
-      return { graceful: true, abandonedDeliveries: 0, durationMs: 0 };
-    }
-    return withinDeadline(
-      { clock: this.#clock, timeoutMs },
-      (deadline) => this.#dispatcher.stop(deadline)
-    );
-  }
   /**
    * Claims and runs one batch of due deliveries, resolving when they settle.
    * Returns how many ran. Intended for tests and scripts.
    */
   async runOnce() {
-    return this.#dispatcher.processBatch();
+    return this.#parts.dispatcher.processBatch();
   }
   /**
    * Runs batches until nothing is due. Deliveries scheduled in the future
@@ -2819,325 +3406,85 @@ var RelayBus = class {
     throw new DrainIncompleteError(`drain did not finish within ${maxBatches} batches`);
   }
   listDeliveries(query = {}) {
-    return this.#store.listDeliveries(query);
+    return this.#parts.store.listDeliveries(query);
   }
   /** Moves dead deliveries back to pending with a fresh attempt budget. */
   async requeue(deliveryIds) {
-    const moved = await this.#store.requeue(deliveryIds, this.#clock.now());
+    const moved = await this.#parts.store.requeue(deliveryIds, this.#parts.clock.now());
     if (moved > 0) {
-      this.#dispatcher.wake();
+      this.#parts.dispatcher.wake();
     }
     return moved;
   }
   statistics() {
-    return this.#store.statistics(this.#clock.now());
+    return this.#parts.store.statistics(this.#parts.clock.now());
   }
   /** Applies the retention policy once. Runs automatically while the bus is running. */
-  async purgeExpired() {
-    const now = this.#clock.now().getTime();
-    const { completedMs, deadMs } = this.#retention;
-    try {
-      const result = await this.#store.purge({
-        ...completedMs === null ? {} : { completedBefore: new Date(now - completedMs) },
-        ...deadMs === null ? {} : { deadBefore: new Date(now - deadMs) }
-      });
-      this.#notifier.notify("onPurged", { result });
-      return result;
-    } catch (error) {
-      this.#notifier.failure("purge", error);
-      throw error;
-    }
+  purgeExpired() {
+    return this.#parts.maintenance.purgeExpired();
   }
+  // The awaits stay in this method, as many as before: with no store setup and no transport a
+  // start completes synchronously, so the bus is running as soon as start() returns.
   async #startComponents() {
+    const { setupStore, store, connections } = this.#parts;
     try {
-      if (this.#setupStore) {
-        await this.#store.setup?.();
+      if (setupStore) {
+        await store.setup?.();
       }
-      for (const transport of this.#transports.values()) {
+      for (const transport of connections.transports) {
         await transport.connect?.();
       }
-      for (const subscription of this.#subscriptions) {
-        const transport = this.#transports.get(subscription.transport);
-        await transport.subscribe(
-          subscription.destinations,
-          async (envelope, message) => {
-            await (this.#observation === void 0 ? this.#receive(envelope) : this.#observedReceive(envelope, { transport, destination: message?.destination }));
-          },
-          this.#subscriptionHooks(transport)
+      for (const subscription of connections.subscriptions) {
+        await connections.subscribe(
+          subscription,
+          (envelope, origin) => this.#parts.receiver.receive(envelope, origin)
         );
       }
     } catch (error) {
-      await withinDeadline(
-        { clock: this.#clock, timeoutMs: this.#shutdownTimeoutMs },
-        async (deadline) => {
-          await this.#closeTransports(deadline);
-          return 0;
-        }
-      );
-      this.#state = "stopped";
+      await this.#closeAfterFailedStart();
+      this.#lifecycle.markStopped();
       throw error;
     }
-    if (this.#state !== "starting") {
+    if (this.#lifecycle.state !== "starting") {
       throw new LifecycleError("relaybus was stopped before it finished starting");
     }
-    if (this.#dispatcherEnabled) {
-      this.#dispatcher.start();
+    if (this.#parts.dispatcherEnabled) {
+      this.#parts.dispatcher.start();
     }
-    this.#scheduleRetention();
-    this.#scheduleBacklog();
-    this.#state = "running";
-    this.#logger.log(
-      `[RelayBus](startComponents) relaybus started | handlers=${this.#registry.all().length} dispatcher=${this.#dispatcherEnabled}`
+    this.#parts.maintenance.start();
+    this.#lifecycle.markRunning();
+    this.#parts.logger.log(
+      `[RelayBus](startComponents) relaybus started | handlers=${this.#parts.registry.all().length} dispatcher=${this.#parts.dispatcherEnabled}`
     );
   }
-  /** What a transport may report back while subscribed; undefined when no observer wants it. */
-  #subscriptionHooks(transport) {
-    if (!this.#notifier.wants("onInvalidMessage")) {
-      return void 0;
-    }
-    return {
-      onInvalidMessage: ({ destination, error }) => {
-        const errorInfo = toErrorInfo(error);
-        this.#notifier.notify("onInvalidMessage", {
-          transport: transport.name,
-          system: transport.system ?? transport.name,
-          destination,
-          reason: errorInfo.message,
-          error: errorInfo
-        });
+  /** Closes the transports a failed start may have connected, within the shutdown timeout. */
+  #closeAfterFailedStart() {
+    return withinDeadline(
+      { clock: this.#parts.clock, timeoutMs: this.#parts.shutdownTimeoutMs },
+      async (deadline) => {
+        await this.#closeTransports(deadline);
+        return 0;
       }
-    };
-  }
-  /** Applies the retention policy every `retention.interval` while the bus runs, when it deletes anything. */
-  #scheduleRetention() {
-    if (this.#retention.completedMs !== null || this.#retention.deadMs !== null) {
-      this.#retentionTimer = schedule(this.#clock, {
-        run: () => {
-          this.purgeExpired().catch(() => void 0);
-        },
-        delayMs: this.#retention.intervalMs,
-        repeat: true,
-        unref: true
-      });
-    }
-  }
-  /** Reports the backlog every `backlogInterval` while the bus runs, when an observer wants it. */
-  #scheduleBacklog() {
-    if (this.#backlogIntervalMs !== void 0) {
-      this.#backlogTimer = this.#observation?.startBacklog({
-        intervalMs: this.#backlogIntervalMs,
-        statistics: () => this.statistics()
-      });
-    }
-  }
-  /**
-   * Waits for a start in progress (a failed start leaves nothing to stop), then stops the dispatcher
-   * and closes the transports and the store. A start still running at the deadline is given up: the
-   * transports and the store are force-closed and the start rejects when it resumes.
-   */
-  async #stopComponents(timeoutMs) {
-    try {
-      return await withinDeadline({ clock: this.#clock, timeoutMs }, async (deadline) => {
-        if (this.#state === "starting") {
-          const started = await deadline.race(this.#starting.catch(() => void 0));
-          if (started === "timeout") {
-            this.#state = "stopping";
-            await this.#closeConnections(deadline);
-            return 0;
-          }
-        }
-        if (this.#state !== "running") {
-          return 0;
-        }
-        this.#state = "stopping";
-        this.#retentionTimer?.();
-        this.#backlogTimer?.();
-        const abandoned = await this.#dispatcher.stop(deadline);
-        await this.#closeConnections(deadline);
-        return abandoned;
-      });
-    } finally {
-      this.#state = "stopped";
-    }
-  }
-  async #closeConnections(deadline) {
-    await this.#closeTransports(deadline);
-    const options = { signal: deadline.signal };
-    await deadline.race(Promise.resolve(this.#store.close?.(options)));
-  }
-  /** Publishes inside the tracer's span, with its trace headers, when the bus is observed. */
-  #observedPublish(events, input) {
-    const observation = this.#observation;
-    if (observation === void 0) {
-      return this.#publish(events, input);
-    }
-    return observation.publish(
-      { eventTypes: events.map((event) => String(event.type)) },
-      (headers) => this.#publish(events, { ...input, options: withTraceHeaders(input.options, headers) })
     );
   }
-  async #publish(events, {
-    options,
-    id
-  }) {
-    if (events.length === 0) {
-      return [];
-    }
-    const now = this.#clock.now();
-    const delayMs = options.delay === void 0 ? 0 : toMilliseconds(options.delay, "delay");
-    const availableAt = new Date(now.getTime() + delayMs);
-    const scope = getCurrentScope();
-    const entries = await this.#createEntries({ events, options, id, scope, now, availableAt });
-    const deliverable = entries.filter((entry) => entry.deliveries.length > 0);
-    if (deliverable.length > 0) {
-      await this.#appendDeliverable({ entries: deliverable, options, scope, now, delayMs });
-    }
-    return entries.map((entry) => entry.event);
-  }
-  /** One entry per event, in order: its envelope and a delivery for every registration of its type. */
-  async #createEntries(input) {
-    const { events, options, id, scope, now, availableAt } = input;
-    const entries = [];
-    let correlationId = options.correlationId ?? scope?.event?.correlationId ?? scope?.event?.id;
-    for (const event of events) {
-      const envelope = await this.#createEnvelope({
-        event,
-        options,
-        id,
-        scope,
-        now,
-        correlationId
-      });
-      correlationId = envelope.correlationId;
-      const registrations = this.#registry.forEventType(envelope.type);
-      if (registrations.length === 0) {
-        this.#reportUnrouted(envelope);
-      }
-      entries.push({
-        event: envelope,
-        deliveries: registrations.map(
-          (registration) => this.#createDelivery(registration, availableAt)
-        )
-      });
-    }
-    return entries;
-  }
-  /** Appends the entries that have deliveries, reports what was new and wakes the dispatcher when it is due now. */
-  async #appendDeliverable(input) {
-    const { entries, options, scope, now, delayMs } = input;
-    const result = await this.#appendInTransaction(entries, { options, scope, now });
-    const appended = new Set(result.appendedEventIds);
-    const published = entries.map((entry) => entry.event).filter((envelope) => appended.has(envelope.id));
-    if (published.length > 0) {
-      this.#notifier.notify("onPublished", {
-        envelopes: published,
-        deliveries: result.appendedDeliveryCount
-      });
-      if (delayMs === 0) {
-        this.#scheduleWake();
-      }
-    }
-  }
   #reportUnrouted(envelope) {
     const message = `No handler or route for event type, event not stored | type=${envelope.type} id=${envelope.id}`;
-    if (this.#unroutedEvents === "throw") {
+    if (this.#parts.unroutedEvents === "throw") {
       throw new ConfigurationError(message);
     }
-    this.#logger.warn(`[RelayBus](reportUnrouted) ${message}`);
-  }
-  async #appendInTransaction(entries, {
-    options,
-    scope,
-    now
-  }) {
-    const transaction = options.transaction ?? scope?.transaction ?? this.#transactionResolver?.();
-    if (transaction !== void 0) {
-      return this.#store.append(transaction, entries, now);
-    }
-    if (this.#transactionMode === "required") {
-      throw new TransactionRequiredError(
-        "publish found no transaction. Pass { transaction }, publish inside bus.transaction(), configure transactionResolver, or set transactionMode to optional"
-      );
-    }
-    return this.#store.transaction(
-      (ownTransaction) => this.#store.append(ownTransaction, entries, now)
-    );
-  }
-  async #createEnvelope(input) {
-    const { event, options, id, scope, now, correlationId } = input;
-    if (typeof event.type !== "string") {
-      throw new ConfigurationError(
-        "publish expects an instance of a class created with defineEvent"
-      );
-    }
-    assertEventType(event.type);
-    const schema = event.constructor.schema;
-    const payload = await validatePayload(event.type, schema, event.payload);
-    if (options.key !== void 0 && options.key.length === 0) {
-      throw new ConfigurationError("key must not be empty");
-    }
-    const eventId = id ?? this.#generateIdentifier();
-    return {
-      id: eventId,
-      type: event.type,
-      source: this.#source,
-      key: options.key ?? keyFromDefinition(event, payload),
-      payload,
-      headers: { ...options.headers },
-      correlationId: correlationId ?? eventId,
-      causationId: scope?.event?.id ?? null,
-      occurredAt: now
-    };
-  }
-  #createDelivery(registration, availableAt) {
-    return { id: this.#generateIdentifier(), handler: registration.id, availableAt };
+    this.#parts.logger.warn(`[RelayBus](reportUnrouted) ${message}`);
   }
   #registrationsOf(eventType) {
-    const registrations = this.#registry.forEventType(eventType);
+    const registrations = this.#parts.registry.forEventType(eventType);
     const routes = registrations.filter((registration) => registration.forwardsToTransport).length;
     return { handlers: registrations.length - routes, routes };
   }
-  #registerRoutes(routes) {
-    for (const route of routes) {
-      this.#requireTransport(route.transport);
-    }
-    for (const group of groupRoutes(routes)) {
-      this.#registerRoute(group);
-    }
-  }
-  /** Registers one handler for every route to a destination, so a key's events reach it in commit order. */
-  #registerRoute(group) {
-    const transport = this.#transports.get(group.transport);
-    const { route, destination } = group;
-    this.#registry.register(
-      {
-        eventTypes: group.eventTypes,
-        legacyIds: group.legacyIds,
-        schema: void 0,
-        handle: this.#observation?.sender(transport, destination) ?? ((envelope) => transport.publish(envelope, destination)),
-        options: {
-          id: group.id,
-          ...route.retry === void 0 ? {} : { retry: route.retry },
-          ...route.timeout === void 0 ? {} : { timeout: route.timeout }
-        },
-        forwardsToTransport: true
-      },
-      { retry: DEFAULT_ROUTE_RETRY_POLICY, timeoutMs: DEFAULTS.routeTimeoutMs }
-    );
-  }
-  #requireTransport(name) {
-    const transport = this.#transports.get(name);
-    if (transport === void 0) {
-      throw new ConfigurationError(`No transport named '${name}' is configured`);
-    }
-    return transport;
-  }
   #scheduleWake() {
-    if (this.#state !== "running" || this.#dispatcher.watchesNewDeliveries) {
+    if (this.#lifecycle.state !== "running" || this.#parts.dispatcher.watchesNewDeliveries) {
       return;
     }
-    schedule(this.#clock, {
-      run: () => this.#dispatcher.wake(),
+    schedule(this.#parts.clock, {
+      run: () => this.#parts.dispatcher.wake(),
       delayMs: WAKE_DELAY_MS,
       unref: true
     });
@@ -3145,37 +3492,18 @@ var RelayBus = class {
   /** Closes every transport, each at most until the deadline; past it they are asked to force. */
   async #closeTransports(deadline) {
     const options = { signal: deadline.signal };
-    for (const transport of this.#transports.values()) {
+    for (const transport of this.#parts.connections.transports) {
       try {
         await deadline.race(transport.close(options));
       } catch (error) {
-        this.#logger.error(
+        this.#parts.logger.error(
           `[RelayBus](closeTransports) Failed to close transport | transport=${transport.name} error=${toErrorInfo(error).message}`
         );
       }
     }
   }
 };
-function toDescriptor(registration, eventType) {
-  return {
-    id: registration.id,
-    eventType,
-    retry: registration.retry,
-    timeoutMs: registration.timeoutMs,
-    concurrency: registration.concurrency,
-    transactional: registration.transactional,
-    forwardsToTransport: registration.forwardsToTransport
-  };
-}
-function describeEvent(event) {
-  if (typeof event === "string") {
-    assertEventType(event);
-    return { type: event, schema: void 0 };
-  }
-  assertEventType(event.type);
-  return { type: event.type, schema: event.schema };
-}
 
-export { CatalogPublisher, DEFAULT_RETRY_POLICY, DEFAULT_ROUTE_RETRY_POLICY, DELIVERY_STATUSES, InMemoryEventStore, InMemoryTransaction, MAX_TIMER_DELAY_MS, RelayBus, TRACEPARENT_HEADER, TRACESTATE_HEADER, computeRetryDelay, consume, createRetryPolicy, createUuidV7, defineCatalog, defineHandlers, describeCatalog, isRetryableError, produce, systemClock, toMilliseconds, traceContextOf };
+export { CatalogPublisher, DEFAULT_RETRY_POLICY, DEFAULT_ROUTE_RETRY_POLICY, DELIVERY_STATUSES, InMemoryEventStore, InMemoryTransaction, RelayBus, TRACEPARENT_HEADER, TRACESTATE_HEADER, computeRetryDelay, consume, createRetryPolicy, createUuidV7, defineCatalog, defineHandlers, describeCatalog, isRetryableError, produce, systemClock, traceContextOf };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map