@relaybus/core 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,153 +1,14 @@
+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 { hostname } from 'os';
 import { AsyncLocalStorage } from 'async_hooks';
+import { hostname } from 'os';
 
 // src/clock.ts
 var systemClock = {
   now: () => /* @__PURE__ */ new Date()
 };
 
-// src/errors.ts
-var RelayBusError = class extends Error {
-  // Explicit names survive minification, unlike `new.target.name`.
-  name = "RelayBusError";
-};
-var ConfigurationError = class extends RelayBusError {
-  name = "ConfigurationError";
-};
-var TransactionRequiredError = class extends RelayBusError {
-  name = "TransactionRequiredError";
-};
-var NonRetryableError = class extends RelayBusError {
-  name = "NonRetryableError";
-};
-var EventValidationError = class extends NonRetryableError {
-  constructor(message, issues) {
-    super(message);
-    this.issues = issues;
-  }
-  issues;
-  name = "EventValidationError";
-};
-var InvalidEnvelopeError = class extends NonRetryableError {
-  name = "InvalidEnvelopeError";
-};
-var LeaseLostError = class extends RelayBusError {
-  name = "LeaseLostError";
-  /**
-   * Whether the store said so (a fenced write returned false). A worker that only noticed
-   * locally that its lease ran out may still own the delivery in the store and has to give it back.
-   */
-  storeConfirmed;
-  constructor(message, options = {}) {
-    super(message);
-    this.storeConfirmed = options.storeConfirmed ?? false;
-  }
-};
-var HandlerTimeoutError = class extends RelayBusError {
-  name = "HandlerTimeoutError";
-};
-var DispatcherStoppedError = class extends RelayBusError {
-  name = "DispatcherStoppedError";
-};
-function toErrorInfo(error) {
-  if (error instanceof Error) {
-    return { name: error.name, message: error.message, stack: error.stack };
-  }
-  return { name: "NonError", message: safeStringify(error) };
-}
-function safeStringify(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-
-// 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/event.ts
-var EVENT_TYPE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,254}$/;
-function assertEventType(type) {
-  if (!EVENT_TYPE_PATTERN.test(type)) {
-    throw new ConfigurationError(
-      `Event type '${type}' must be 1-255 characters of letters, digits, '.', '_', ':', '/' or '-', starting with a letter or digit`
-    );
-  }
-}
-function defineEvent(type, options) {
-  assertEventType(type);
-  const schema = options?.schema;
-  return class DefinedEvent {
-    constructor(payload) {
-      this.payload = payload;
-    }
-    payload;
-    static type = type;
-    static schema = schema;
-    type = type;
-  };
-}
-async function validatePayload(type, schema, payload) {
-  if (schema === void 0) {
-    return payload;
-  }
-  const result = await schema["~standard"].validate(payload);
-  if (result.issues !== void 0) {
-    const issues = result.issues.map((issue) => ({
-      message: issue.message,
-      path: issue.path?.map((segment) => typeof segment === "object" ? segment.key : segment)
-    }));
-    throw new EventValidationError(
-      `Payload of '${type}' failed validation: ${issues.map((issue) => issue.message).join("; ")}`,
-      issues
-    );
-  }
-  return result.value;
-}
-
 // src/catalog.ts
 var EVENT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var descriptions = /* @__PURE__ */ new WeakMap();
@@ -232,7 +93,10 @@ function requireCatalogEntry(catalog, event) {
   }
   return entry;
 }
-function resolveCatalogHandlers(catalog, handlers, options) {
+function resolveCatalogHandlers(catalog, {
+  handlers,
+  options
+}) {
   const { name } = describeCatalog(catalog);
   const { idPrefix, events, ...subscribeOptions } = options;
   const entries = selectCatalogEntries(catalog, events);
@@ -262,7 +126,7 @@ function classNameOf(handlers) {
   const className = handlers.constructor.name;
   return className === "Object" || className === "" ? void 0 : className;
 }
-function assertExactHandlers(catalog, entries, handlers) {
+function assertExactHandlers(catalog, { entries, handlers }) {
   const expected = new Set(entries.map((entry) => entry.handlerName));
   const present = Object.keys(handlers);
   const missing = [...expected].filter((handlerName) => !present.includes(handlerName));
@@ -282,7 +146,10 @@ function assertExactHandlers(catalog, entries, handlers) {
   }
 }
 function defineHandlers(catalog, handlers, options = {}) {
-  assertExactHandlers(catalog, selectCatalogEntries(catalog, options.events), handlers);
+  assertExactHandlers(catalog, {
+    entries: selectCatalogEntries(catalog, options.events),
+    handlers
+  });
   return handlers;
 }
 
@@ -336,12 +203,12 @@ var CatalogPublisher = class {
 // src/catalog-coverage.ts
 var declarations = /* @__PURE__ */ new WeakSet();
 function consume(catalog, options = {}) {
-  return declare(catalog, "consume", options);
+  return declare(catalog, { role: "consume", options });
 }
 function produce(catalog, options = {}) {
-  return declare(catalog, "produce", options);
+  return declare(catalog, { role: "produce", options });
 }
-function declare(catalog, role, options) {
+function declare(catalog, { role, options }) {
   const entries = selectCatalogEntries(catalog, options.events);
   const declaration = Object.freeze({
     catalog,
@@ -369,7 +236,7 @@ function assertCatalogsCovered(requirements, registrationsOf) {
   let onlyBareCatalogs = true;
   for (const { catalogName, entries, need } of requirements) {
     for (const entry of entries) {
-      const problem = describeGap(entry, need, registrationsOf(entry.type));
+      const problem = describeGap(entry, { need, registrations: registrationsOf(entry.type) });
       if (problem !== void 0) {
         problems.add(`${catalogName === void 0 ? "" : `${catalogName}.`}${problem}`);
         onlyBareCatalogs &&= need === "handler-or-route";
@@ -384,7 +251,10 @@ ${[...problems].map((line) => `  - ${line}`).join("\n")}`
     );
   }
 }
-function describeGap(entry, need, { handlers, routes }) {
+function describeGap(entry, {
+  need,
+  registrations: { handlers, routes }
+}) {
   const subject = `${entry.name} (${entry.type})`;
   if (need === "handler-or-route") {
     return handlers + routes > 0 ? void 0 : `${subject}: expected handler method ${entry.handlerName}`;
@@ -410,232 +280,107 @@ var DELIVERY_STATUSES = [
   "completed",
   "dead"
 ];
+var UUID_BYTES = 16;
+var TIMESTAMP_BYTES = 6;
+var BYTE_VALUES = 256;
+var LOW_NIBBLE = 15;
+var VERSION_7 = 112;
+var VARIANT_PAYLOAD = 63;
+var RFC_9562_VARIANT = 128;
 function createUuidV7(timestamp = Date.now()) {
-  const bytes = randomBytes(16);
+  const bytes = randomBytes(UUID_BYTES);
   let remaining = timestamp;
-  for (let index = 5; index >= 0; index -= 1) {
-    bytes[index] = remaining % 256;
-    remaining = Math.floor(remaining / 256);
+  for (let index = TIMESTAMP_BYTES - 1; index >= 0; index -= 1) {
+    bytes[index] = remaining % BYTE_VALUES;
+    remaining = Math.floor(remaining / BYTE_VALUES);
   }
-  bytes[6] = bytes[6] & 15 | 112;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = bytes.toString("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  bytes[6] = bytes[6] & LOW_NIBBLE | VERSION_7;
+  bytes[8] = bytes[8] & VARIANT_PAYLOAD | RFC_9562_VARIANT;
+  return bytes.toString("hex").replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
 }
 
-// src/in-memory-event-store.ts
-var InMemoryTransaction = class {
-  #operations = [];
-  #finishers = [];
-  #state = "open";
-  get state() {
-    return this.#state;
-  }
-  enqueue(operation) {
-    if (this.#state !== "open") {
-      throw new ConfigurationError(`Cannot write through a ${this.#state} in-memory transaction`);
-    }
-    this.#operations.push(operation);
-  }
-  /** Runs `finisher` once the transaction commits or rolls back, like a lock release. */
-  onFinish(finisher) {
-    this.#finishers.push(finisher);
-  }
-  commit() {
-    this.#state = "committed";
-    for (const operation of this.#operations) {
-      operation();
-    }
-    this.#finish();
-  }
-  rollback() {
-    this.#state = "rolled-back";
-    this.#finish();
-  }
-  #finish() {
-    for (const finisher of this.#finishers.splice(0)) {
-      finisher();
-    }
-  }
-};
-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();
-  #generateIdentifier;
-  #retainCompleted;
-  constructor(options = {}) {
-    if (process.env["NODE_ENV"] === "production" && options.allowInProduction !== true) {
-      throw new ConfigurationError(
-        "InMemoryEventStore loses every event on restart. Use a database store in production, or pass allowInProduction: true"
-      );
-    }
-    this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
-    this.#retainCompleted = options.retainCompleted ?? false;
-  }
-  async transaction(work) {
-    const transaction = new InMemoryTransaction();
-    try {
-      const result = await work(transaction);
-      transaction.commit();
-      return result;
-    } catch (error) {
-      transaction.rollback();
-      throw error;
-    }
-  }
-  async append(transaction, entries, now) {
-    await this.#lock(
-      transaction,
-      entries.flatMap((entry) => [
-        `event:${entry.event.id}`,
-        ...entry.event.key === null ? [] : [`key:${entry.event.key}`]
-      ])
-    );
-    const written = this.#written(transaction);
-    const pendingEventIds = written.eventIds;
-    const pendingDeliveryKeys = written.deliveryKeys;
-    const appendedEventIds = [];
-    const duplicateEventIds = [];
-    let appendedDeliveryCount = 0;
-    for (const entry of entries) {
-      const eventId = entry.event.id;
-      const serialized = serializeEnvelope(entry.event);
-      const isDuplicate = this.#events.has(eventId) || pendingEventIds.has(eventId);
-      if (isDuplicate) {
-        duplicateEventIds.push(eventId);
-      } else {
-        appendedEventIds.push(eventId);
-        pendingEventIds.add(eventId);
-      }
-      const newDeliveries = entry.deliveries.filter((delivery) => {
-        const deliveryKey = `${eventId}\0${delivery.handler}`;
-        if (pendingDeliveryKeys.has(deliveryKey) || this.#events.get(eventId)?.handlers.has(delivery.handler) === true) {
-          return false;
-        }
-        pendingDeliveryKeys.add(deliveryKey);
-        return true;
-      });
-      appendedDeliveryCount += newDeliveries.length;
-      transaction.enqueue(() => {
-        if (!isDuplicate) {
-          this.#events.set(eventId, {
-            envelope: serialized,
-            sequence: this.#nextSequence(serialized.key),
-            createdAt: now,
-            handlers: /* @__PURE__ */ new Set(),
-            completedAt: null
-          });
-        }
-        const stored = this.#events.get(eventId);
-        for (const delivery of newDeliveries) {
-          stored.handlers.add(delivery.handler);
-          this.#deliveries.set(delivery.id, {
-            id: delivery.id,
-            eventId,
-            handler: delivery.handler,
-            key: stored.envelope.key,
-            sequence: stored.sequence,
-            status: "pending",
-            attempts: 0,
-            availableAt: delivery.availableAt,
-            leaseOwner: null,
-            leaseToken: null,
-            leaseExpiresAt: null,
-            lastError: null,
-            createdAt: now,
-            updatedAt: now,
-            completedAt: null
-          });
-        }
-      });
-    }
-    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount };
-  }
-  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 claimed = [];
-    for (const delivery of due) {
-      if (claimed.length >= request.limit) {
-        break;
-      }
-      if (this.#isKeyBlocked(delivery, request.now)) {
-        continue;
-      }
-      delivery.status = "processing";
-      delivery.attempts += 1;
-      delivery.leaseOwner = request.leaseOwner;
-      delivery.leaseToken = this.#generateIdentifier();
-      delivery.leaseExpiresAt = request.leaseExpiresAt;
-      delivery.updatedAt = request.now;
-      claimed.push({
-        deliveryId: delivery.id,
-        leaseToken: delivery.leaseToken,
-        handler: delivery.handler,
-        attempt: delivery.attempts,
-        leaseExpiresAt: request.leaseExpiresAt,
-        event: this.#readEnvelope(delivery.eventId)
-      });
-    }
-    return claimed;
-  }
-  async extendLease(lease, leaseExpiresAt, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.leaseExpiresAt = leaseExpiresAt;
-      delivery.updatedAt = now;
-    });
-  }
-  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;
-  }
-  async completeMany(leases, now) {
-    return Promise.all(leases.map((lease) => this.complete(lease, now)));
+// 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;
   }
-  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);
-    });
+  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;
   }
-  async release(lease, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.status = "pending";
-      delivery.attempts -= 1;
-      delivery.availableAt = now;
-      delivery.updatedAt = now;
-      clearLease(delivery);
-    });
+  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;
   }
-  async bury(lease, error, now) {
-    return this.#updateLeased(lease, (delivery) => {
-      delivery.status = "dead";
-      delivery.lastError = error;
-      delivery.updatedAt = now;
-      clearLease(delivery);
-    });
+  if (delivery.status === "dead" && request.deadBefore !== void 0) {
+    return delivery.updatedAt < request.deadBefore;
   }
-  async listDeliveries(query) {
-    const limit = query.limit ?? 100;
-    return [...this.#deliveries.values()].filter((delivery) => matchesQuery(delivery, this.#events.get(delivery.eventId), query)).sort(
+  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,
@@ -649,13 +394,13 @@ var InMemoryEventStore = class {
       createdAt: delivery.createdAt,
       updatedAt: delivery.updatedAt,
       completedAt: delivery.completedAt,
-      event: this.#readEnvelope(delivery.eventId)
+      event: this.#tables.readEnvelope(delivery.eventId)
     }));
   }
-  async requeue(deliveryIds, now) {
+  requeue(deliveryIds, now) {
     let moved = 0;
     for (const deliveryId of new Set(deliveryIds)) {
-      const delivery = this.#deliveries.get(deliveryId);
+      const delivery = this.#tables.deliveries.get(deliveryId);
       if (delivery?.status !== "dead") {
         continue;
       }
@@ -667,36 +412,19 @@ var InMemoryEventStore = class {
     }
     return moved;
   }
-  async purge(request) {
+  purge(request) {
     let deletedDeliveries = 0;
     const touchedEventIds = /* @__PURE__ */ new Set();
-    for (const delivery of [...this.#deliveries.values()]) {
+    for (const delivery of [...this.#tables.deliveries.values()]) {
       if (isPurgeable(delivery, request)) {
-        this.#deliveries.delete(delivery.id);
+        this.#tables.deliveries.delete(delivery.id);
         touchedEventIds.add(delivery.eventId);
         deletedDeliveries += 1;
       }
     }
-    const referencedEventIds = new Set(
-      [...this.#deliveries.values()].map((delivery) => delivery.eventId)
-    );
-    const cutoffs = [request.completedBefore, request.deadBefore].filter((cutoff) => cutoff !== void 0).map((cutoff) => cutoff.getTime());
-    const orphanCutoff = cutoffs.length === 0 ? Number.NEGATIVE_INFINITY : Math.min(...cutoffs);
-    const completedCutoff = request.completedBefore?.getTime() ?? Number.NEGATIVE_INFINITY;
-    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 { deletedDeliveries, deletedEvents };
+    return { deletedDeliveries, deletedEvents: this.#purgeEvents(request, touchedEventIds) };
   }
-  async statistics(now) {
+  statistics(now) {
     const counts = {
       pending: 0,
       processing: 0,
@@ -704,7 +432,7 @@ var InMemoryEventStore = class {
       dead: 0
     };
     let oldestDueAt = null;
-    for (const delivery of this.#deliveries.values()) {
+    for (const delivery of this.#tables.deliveries.values()) {
       counts[delivery.status] += 1;
       if (isDue(delivery, now)) {
         const dueAt = dueAtOf(delivery);
@@ -715,13 +443,38 @@ var InMemoryEventStore = class {
     }
     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.
-   */
+  /** 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) {
+  written(transaction) {
     let written = this.#writes.get(transaction);
     if (written === void 0) {
       written = { eventIds: /* @__PURE__ */ new Set(), deliveryKeys: /* @__PURE__ */ new Set() };
@@ -729,7 +482,12 @@ var InMemoryEventStore = class {
     }
     return written;
   }
-  async #lock(transaction, names) {
+  /**
+   * 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) {
@@ -750,44 +508,62 @@ var InMemoryEventStore = class {
       });
     }
   }
-  #nextSequence(key) {
-    if (key === null) {
-      return null;
-    }
-    const next = (this.#keySequences.get(key) ?? 0) + 1;
-    this.#keySequences.set(key, next);
-    return next;
-  }
-  /**
-   * A keyed delivery waits while an earlier delivery of the same handler and
-   * key is unfinished, or while any other delivery of that handler and key is
-   * running under a live lease (a requeued dead letter must not run alongside
-   * its successor).
-   */
-  #isKeyBlocked(delivery, now) {
-    if (delivery.key === null) {
+};
+
+// 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;
     }
-    for (const other of this.#deliveries.values()) {
-      if (other === delivery || other.handler !== delivery.handler || other.key !== delivery.key) {
-        continue;
-      }
-      const unfinishedPredecessor = other.sequence < delivery.sequence && (other.status === "pending" || other.status === "processing");
-      const runningUnderLiveLease = other.status === "processing" && other.leaseExpiresAt > now;
-      if (unfinishedPredecessor || runningUnderLiveLease) {
-        return true;
+    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 false;
+    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.#events.get(delivery.eventId);
+    const event = this.#tables.events.get(delivery.eventId);
     if (event.completedAt === null || event.completedAt < now) {
       event.completedAt = now;
     }
     if (!this.#retainCompleted) {
-      this.#deliveries.delete(delivery.id);
+      this.#tables.deliveries.delete(delivery.id);
       return;
     }
     delivery.status = "completed";
@@ -795,450 +571,787 @@ var InMemoryEventStore = class {
     delivery.updatedAt = now;
     clearLease(delivery);
   }
-  #findLeased(lease) {
-    const delivery = this.#deliveries.get(lease.deliveryId);
-    if (delivery?.status === "processing" && delivery.leaseToken === lease.leaseToken) {
-      return delivery;
-    }
-    return void 0;
-  }
-  #updateLeased(lease, update) {
-    const delivery = this.#findLeased(lease);
-    if (delivery === void 0) {
-      return false;
+};
+
+// 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;
     }
-    update(delivery);
-    return true;
+    const next = (this.#keySequences.get(key) ?? 0) + 1;
+    this.#keySequences.set(key, next);
+    return next;
   }
-  #readEnvelope(eventId) {
-    const serialized = this.#events.get(eventId).envelope;
+  /** 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) };
   }
 };
-function serializeEnvelope(envelope) {
-  return JSON.parse(JSON.stringify(envelope));
-}
-function isDue(delivery, now) {
-  if (delivery.status === "pending") {
-    return delivery.availableAt <= now;
+
+// src/in-memory-transaction.ts
+var InMemoryTransaction = class {
+  #operations = [];
+  #finishers = [];
+  #state = "open";
+  get state() {
+    return this.#state;
   }
-  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;
+  enqueue(operation) {
+    if (this.#state !== "open") {
+      throw new ConfigurationError(`Cannot write through a ${this.#state} in-memory transaction`);
+    }
+    this.#operations.push(operation);
   }
-  if (delivery.status === "dead" && request.deadBefore !== void 0) {
-    return delivery.updatedAt < request.deadBefore;
+  /** Runs `finisher` once the transaction commits or rolls back, like a lock release. */
+  onFinish(finisher) {
+    this.#finishers.push(finisher);
   }
-  return false;
-}
+  commit() {
+    this.#state = "committed";
+    for (const operation of this.#operations) {
+      operation();
+    }
+    this.#finish();
+  }
+  rollback() {
+    this.#state = "rolled-back";
+    this.#finish();
+  }
+  #finish() {
+    for (const finisher of this.#finishers.splice(0)) {
+      finisher();
+    }
+  }
+};
 
-// 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;
+// src/in-memory-event-store.ts
+var InMemoryEventStore = class {
+  #tables = new InMemoryTables();
+  #locks = new InMemoryRowLocks();
+  #settlement;
+  #maintenance = new InMemoryMaintenance(this.#tables, this.#locks);
+  #generateIdentifier;
+  constructor(options = {}) {
+    if (process.env["NODE_ENV"] === "production" && options.allowInProduction !== true) {
+      throw new ConfigurationError(
+        "InMemoryEventStore loses every event on restart. Use a database store in production, or pass allowInProduction: true"
+      );
+    }
+    this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
+    this.#settlement = new InMemorySettlement(this.#tables, options.retainCompleted ?? false);
   }
-  /**
-   * 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();
+  async transaction(work) {
+    const transaction = new InMemoryTransaction();
+    try {
+      const result = await work(transaction);
+      transaction.commit();
+      return result;
+    } catch (error) {
+      transaction.rollback();
+      throw error;
+    }
+  }
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  async append(transaction, entries, now) {
+    await this.#locks.lock(
+      transaction,
+      entries.flatMap((entry) => [
+        `event:${entry.event.id}`,
+        ...entry.event.key === null ? [] : [`key:${entry.event.key}`]
+      ])
+    );
+    const written = this.#locks.written(transaction);
+    const pendingEventIds = written.eventIds;
+    const pendingDeliveryKeys = written.deliveryKeys;
+    const appendedEventIds = [];
+    const duplicateEventIds = [];
+    let appendedDeliveryCount = 0;
+    for (const entry of entries) {
+      const eventId = entry.event.id;
+      const serialized = serializeEnvelope(entry.event);
+      const isDuplicate = this.#tables.events.has(eventId) || pendingEventIds.has(eventId);
+      if (isDuplicate) {
+        duplicateEventIds.push(eventId);
       } else {
-        this.#timer ??= setTimeout(() => this.#flush(), this.#settings.windowMs);
+        appendedEventIds.push(eventId);
+        pendingEventIds.add(eventId);
       }
-    });
+      const newDeliveries = this.#newDeliveries(entry, pendingDeliveryKeys);
+      appendedDeliveryCount += newDeliveries.length;
+      transaction.enqueue(() => {
+        this.#applyAppend({ eventId, serialized, isDuplicate, newDeliveries, now });
+      });
+    }
+    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount };
   }
   /**
-   * 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.
+   * The deliveries of `entry` whose handler the event neither has nor gets earlier in the
+   * transaction; remembers them in `pendingDeliveryKeys`.
    */
-  setClosing(closing) {
-    this.#closing = closing;
-    if (closing && this.#pending.length > 0) {
-      this.#flush();
-    }
+  #newDeliveries(entry, pendingDeliveryKeys) {
+    const eventId = entry.event.id;
+    return entry.deliveries.filter((delivery) => {
+      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);
+      return true;
+    });
   }
-  #flush() {
-    clearTimeout(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))
-    );
+  /** 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) {
+      events.set(eventId, {
+        envelope: serialized,
+        sequence: this.#tables.nextSequence(serialized.key),
+        createdAt: now,
+        handlers: /* @__PURE__ */ new Set(),
+        completedAt: null
+      });
+    }
+    const stored = events.get(eventId);
+    for (const delivery of newDeliveries) {
+      stored.handlers.add(delivery.handler);
+      deliveries.set(delivery.id, {
+        id: delivery.id,
+        eventId,
+        handler: delivery.handler,
+        key: stored.envelope.key,
+        sequence: stored.sequence,
+        status: "pending",
+        attempts: 0,
+        availableAt: delivery.availableAt,
+        leaseOwner: null,
+        leaseToken: null,
+        leaseExpiresAt: null,
+        lastError: null,
+        createdAt: now,
+        updatedAt: now,
+        completedAt: null
+      });
+    }
   }
-};
-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/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 initialDelayMs = options?.initialDelay === void 0 ? base.initialDelayMs : toMilliseconds(options.initialDelay, "retry.initialDelay");
-  const policy = {
-    attempts: options?.attempts ?? base.attempts,
-    initialDelayMs,
-    factor: options?.factor ?? base.factor,
-    maxDelayMs: options?.maxDelay === void 0 ? (
-      // Raising only the initial delay must not trip the inherited cap.
-      Math.max(base.maxDelayMs, initialDelayMs)
-    ) : toMilliseconds(options.maxDelay, "retry.maxDelay"),
-    jitter: options?.jitter ?? base.jitter,
-    retryIf: options?.retryIf ?? base.retryIf
-  };
-  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}`
+  async claim(request) {
+    const handlers = new Set(request.handlers);
+    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) {
+        break;
+      }
+      if (this.#isKeyBlocked(delivery, request.now)) {
+        continue;
+      }
+      delivery.status = "processing";
+      delivery.attempts += 1;
+      delivery.leaseOwner = request.leaseOwner;
+      delivery.leaseToken = this.#generateIdentifier();
+      delivery.leaseExpiresAt = request.leaseExpiresAt;
+      delivery.updatedAt = request.now;
+      claimed.push({
+        deliveryId: delivery.id,
+        leaseToken: delivery.leaseToken,
+        handler: delivery.handler,
+        attempt: delivery.attempts,
+        leaseExpiresAt: request.leaseExpiresAt,
+        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.#settlement.extendLease({ lease, leaseExpiresAt, now });
+  }
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  async complete(lease, now, transaction) {
+    return this.#settlement.complete(
+      lease,
+      transaction === void 0 ? { now } : { now, transaction }
     );
   }
-  if (!Number.isFinite(policy.factor) || policy.factor < 1) {
-    throw new ConfigurationError(`retry.factor must be at least 1, received ${policy.factor}`);
+  async completeMany(leases, now) {
+    return Promise.all(leases.map((lease) => this.complete(lease, now)));
   }
-  if (policy.maxDelayMs < policy.initialDelayMs) {
-    throw new ConfigurationError("retry.maxDelay must not be smaller than retry.initialDelay");
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  async reschedule(lease, availableAt, error, now) {
+    return this.#settlement.changeClaim({
+      lease,
+      change: { kind: "reschedule", availableAt, error, now }
+    });
   }
-  if (!JITTER_STRATEGIES.includes(policy.jitter)) {
-    throw new ConfigurationError(
-      `retry.jitter must be one of ${JITTER_STRATEGIES.join(", ")}, received '${String(policy.jitter)}'`
-    );
+  async release(lease, now) {
+    return this.#settlement.changeClaim({ lease, change: { kind: "release", now } });
   }
-  return policy;
-}
-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);
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  async bury(lease, error, now) {
+    return this.#settlement.changeClaim({ lease, change: { kind: "bury", error, now } });
   }
-}
-function isRetryableError(policy, error) {
-  if (error instanceof NonRetryableError) {
+  async listDeliveries(query) {
+    return this.#maintenance.listDeliveries(query);
+  }
+  async requeue(deliveryIds, now) {
+    return this.#maintenance.requeue(deliveryIds, now);
+  }
+  async purge(request) {
+    return this.#maintenance.purge(request);
+  }
+  async statistics(now) {
+    return this.#maintenance.statistics(now);
+  }
+  /**
+   * A keyed delivery waits while an earlier delivery of the same handler and
+   * key is unfinished, or while any other delivery of that handler and key is
+   * running under a live lease (a requeued dead letter must not run alongside
+   * its successor).
+   */
+  #isKeyBlocked(delivery, now) {
+    if (delivery.key === null) {
+      return false;
+    }
+    for (const other of this.#tables.deliveries.values()) {
+      if (blocksKey(other, { delivery, now })) {
+        return true;
+      }
+    }
     return false;
   }
-  if (policy.retryIf === void 0) {
-    return true;
+};
+
+// 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]);
+  }
+  /** Cancels the timers once the shutdown is over. */
+  dispose() {
+    for (const cancel of this.#cancelTimers) {
+      cancel();
+    }
+  }
+};
+async function withinDeadline({ clock, timeoutMs }, work) {
+  const startedAt = clock.now().getTime();
+  const deadline = new ShutdownDeadline(clock, timeoutMs);
   try {
-    return policy.retryIf(error);
-  } catch {
-    return true;
+    const abandonedDeliveries = await work(deadline);
+    return {
+      graceful: !deadline.passed,
+      abandonedDeliveries,
+      durationMs: clock.now().getTime() - startedAt
+    };
+  } finally {
+    deadline.dispose();
   }
 }
 
-// src/dispatcher.ts
-var COMPLETION_RETRY_DELAYS_MS = [50, 250, 1e3];
-var WAKE_COOLDOWN_MS = 5;
-var QUIET_REFILL_MS = 10;
-var REFILL_FRACTION = 0.7;
-var defaultSleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-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;
-  constructor(dependencies) {
-    this.#dependencies = dependencies;
-    this.#sleep = dependencies.sleep ?? defaultSleep;
-    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
+// src/bus/bus-lifecycle.ts
+var BusLifecycle = class {
+  #parts;
+  #state = "idle";
+  #starting;
+  #stopping;
+  constructor(parts) {
+    this.#parts = parts;
+  }
+  get state() {
+    return this.#state;
+  }
+  /** 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}`
       );
     }
   }
-  get isRunning() {
-    return this.#running;
+  /** 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;
   }
-  get inFlightCount() {
-    return this.#inFlight.size;
+  /** The start in progress settled. */
+  endStart() {
+    this.#starting = void 0;
   }
-  /**
-   * 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.
-   */
-  get watchesNewDeliveries() {
-    return this.#unwatch !== void 0;
+  markRunning() {
+    this.#state = "running";
   }
-  start() {
-    if (this.#running) {
-      return;
-    }
-    this.#running = true;
-    this.#completions?.setClosing(false);
-    this.#watching = this.#watchNewDeliveries();
-    this.#loop = this.#runLoop();
+  markStopped() {
+    this.#state = "stopped";
   }
-  /**
-   * 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.#exhaustedHandlers.clear();
-    this.#wakeGeneration += 1;
-    const wait = this.#lastClaimStartedAt + WAKE_COOLDOWN_MS - Date.now();
-    if (wait <= 0) {
-      this.#requestClaim();
-      return;
+  /** 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 };
     }
-    this.#cooldownTimer ??= setTimeout(() => {
-      this.#cooldownTimer = void 0;
-      this.#requestClaim();
-    }, wait);
-  }
-  /** 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?.();
+    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 };
   }
   /**
-   * 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.
+   * 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 #watchNewDeliveries() {
-    const { store, notifier } = this.#dependencies;
-    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);
-    }
-  }
-  /** 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);
+  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)
+    );
   }
   /**
-   * Stops claiming, waits up to the shutdown timeout for running handlers,
-   * then aborts the rest and releases their deliveries for another process.
+   * 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 stop() {
-    if (!this.#running) {
-      await this.#closeRecovery(Date.now() + this.#dependencies.settings.shutdownTimeoutMs);
-      return;
-    }
-    this.#running = false;
-    this.#completions?.setClosing(true);
-    clearTimeout(this.#cooldownTimer);
-    this.#cooldownTimer = void 0;
-    clearTimeout(this.#quietRefillTimer);
-    this.#quietRefillTimer = void 0;
-    this.#signal(this.#refillThreshold);
-    const deadline = Date.now() + this.#dependencies.settings.shutdownTimeoutMs;
-    await this.#waitUntil(this.#stopWatching(), deadline);
-    await this.#waitUntil(this.#loop, deadline);
-    const settled = Promise.allSettled([...this.#inFlight].map((delivery) => delivery.settled));
-    if (await this.#waitUntil(settled, deadline) === "timeout") {
-      for (const delivery of this.#inFlight) {
-        delivery.controller.abort(new DispatcherStoppedError("relaybus dispatcher stopped"));
-      }
-      await settled;
+  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";
     }
-    await this.#closeRecovery(deadline);
-    await this.#waitUntil(this.#relinquish(), deadline);
   }
-  /**
-   * 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) {
-    clearInterval(this.#recoveryTimer);
-    this.#recoveryTimer = void 0;
-    const lastTry = (async () => {
-      await this.#recovery;
-      await this.#recoverSettlements();
-    })();
-    await this.#waitUntil(lastTry, deadline);
-    this.#pending.clear();
+  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;
+  #clock;
+  #publishes;
+  #receives;
+  #sends;
+  constructor(input) {
+    this.#notifier = input.notifier;
+    this.#tracer = input.tracer;
+    this.#clock = input.clock;
+    this.#publishes = input.notifier.wants("onPublishFinished");
+    this.#receives = input.notifier.wants("onReceiveFinished");
+    this.#sends = input.notifier.wants("onTransportSent");
+  }
+  /** An observation, or undefined when no observer hook and no tracer would see anything. */
+  static create(input) {
+    const observed = input.tracer !== void 0 || ["onPublishFinished", "onReceiveFinished", "onTransportSent", "onBacklog"].some(
+      (method) => input.notifier.wants(method)
+    );
+    return observed ? new _BusObservation(input) : void 0;
+  }
+  /** Runs a publish call inside the tracer's publish span, reporting its duration and outcome. */
+  async publish(input, run) {
+    const startedAt = this.#publishes ? this.#now() : 0;
+    const tracer = this.#tracer;
+    const traced = tracer?.publish === void 0 ? run({}) : tracer.publish(input, run);
+    if (!this.#publishes) {
+      return traced;
+    }
+    const report = (outcome, error) => {
+      this.#notifier.notify("onPublishFinished", {
+        eventTypes: input.eventTypes,
+        durationMs: this.#now() - startedAt,
+        outcome,
+        ...error === void 0 ? {} : { error: toErrorInfo(error) }
+      });
+    };
+    try {
+      const result = await traced;
+      report("success");
+      return result;
+    } catch (error) {
+      report("error", error);
+      throw error;
+    }
+  }
+  /** Runs `receive` for one event, reporting where it came from and what became of it. */
+  async receive(input, run) {
+    if (!this.#receives) {
+      return run();
+    }
+    const startedAt = this.#now();
+    try {
+      const outcome = await run();
+      this.#reportReceive(input, { outcome, startedAt, failure: void 0 });
+      return outcome;
+    } catch (error) {
+      const outcome = error instanceof InvalidEnvelopeError ? "invalid" : "error";
+      this.#reportReceive(input, { outcome, startedAt, failure: error });
+      throw error;
+    }
+  }
+  #reportReceive({ envelope, origin }, report) {
+    const { headers } = envelope;
+    this.#notifier.notify("onReceiveFinished", {
+      transport: origin?.transport.name,
+      system: origin === void 0 ? void 0 : systemOf(origin.transport),
+      destination: origin?.destination,
+      eventType: textOrUndefined(envelope.type),
+      source: textOrUndefined(envelope.source),
+      traceContext: isObject(headers) ? traceContextOf(headers) : void 0,
+      outcome: report.outcome,
+      durationMs: this.#now() - report.startedAt,
+      ...report.failure === void 0 ? {} : { error: toErrorInfo(report.failure) }
+    });
+  }
+  /** The handler of a route: sends inside the tracer's send span and reports each send. */
+  sender(transport, destination) {
+    if (this.#tracer?.send === void 0 && !this.#sends) {
+      return (envelope) => transport.publish(envelope, destination);
+    }
+    return (envelope) => this.#send({ envelope, transport, destination });
+  }
+  async #send({ envelope, transport, destination }) {
+    const startedAt = this.#sends ? this.#now() : 0;
+    const system = systemOf(transport);
+    const run = (headers) => transport.publish(
+      Object.keys(headers).length === 0 ? envelope : { ...envelope, headers: { ...envelope.headers, ...headers } },
+      destination
+    );
+    const tracer = this.#tracer;
+    const sent = tracer?.send === void 0 ? run({}) : tracer.send({ envelope, transport: transport.name, system, destination }, run);
+    if (!this.#sends) {
+      return sent;
+    }
+    const report = (outcome, error) => {
+      this.#notifier.notify("onTransportSent", {
+        envelope,
+        transport: transport.name,
+        system,
+        destination,
+        durationMs: this.#now() - startedAt,
+        outcome,
+        ...error === void 0 ? {} : { error: toErrorInfo(error) }
+      });
+    };
+    try {
+      await sent;
+      report("success");
+    } catch (error) {
+      report("error", error);
+      throw error;
+    }
   }
   /**
-   * 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).
+   * Reads the backlog every `intervalMs` and reports it, when an observer wants it. A reading that
+   * is still running when the next one is due is not overlapped. Returns the cancel of the timer.
    */
-  #recoverSettlements() {
-    this.#recovery ??= this.#recoverAll().finally(() => {
-      this.#recovery = void 0;
+  startBacklog({ intervalMs, statistics }) {
+    if (!this.#notifier.wants("onBacklog")) {
+      return void 0;
+    }
+    let reading = false;
+    return schedule(this.#clock, {
+      run: () => {
+        if (reading) {
+          return;
+        }
+        reading = true;
+        statistics().then((result) => this.#reportBacklog(result)).catch((error) => this.#notifier.failure("backlog", error)).finally(() => {
+          reading = false;
+        });
+      },
+      delayMs: intervalMs,
+      repeat: true,
+      unref: true
     });
-    return this.#recovery;
   }
-  async #recoverAll() {
-    for (const [key, entry] of [...this.#pending]) {
-      if (this.#pending.get(key) !== entry) {
-        continue;
-      }
-      try {
-        const applied = await entry.settle();
-        this.#pending.delete(pendingKey(entry.delivery));
-        if (applied) {
-          entry.applied();
-        } else {
-          this.#dependencies.notifier.notify("onLeaseLost", { delivery: entry.delivery });
-        }
-      } catch {
-      }
+  #reportBacklog(statistics) {
+    const oldestDueAt = statistics.oldestDueAt;
+    this.#notifier.notify("onBacklog", {
+      pending: statistics.pending,
+      oldestPendingAgeMs: oldestDueAt === null ? 0 : Math.max(0, this.#now() - oldestDueAt.getTime()),
+      statistics
+    });
+  }
+  #now() {
+    return this.#clock.now().getTime();
+  }
+};
+function systemOf(transport) {
+  return transport.system ?? transport.name;
+}
+function textOrUndefined(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/dispatch-observation.ts
+var DispatchObservation = class _DispatchObservation {
+  #notifier;
+  #tracer;
+  #clock;
+  #claims;
+  #runs;
+  constructor(input) {
+    this.#notifier = input.notifier;
+    this.#tracer = input.tracer;
+    this.#clock = input.clock;
+    this.#claims = input.notifier.wants("onClaimFinished");
+    this.#runs = input.notifier.wants("onHandlerStarted") || input.notifier.wants("onHandlerFinished");
+  }
+  /** An observation, or undefined when no observer hook and no tracer would see anything. */
+  static create(input) {
+    const observation = new _DispatchObservation(input);
+    return observation.#claims || observation.#runs || input.tracer?.process !== void 0 ? observation : void 0;
+  }
+  /** Claims through `store`, reporting the query's size, lanes and duration. */
+  async claim(store, request) {
+    if (!this.#claims) {
+      return store.claim(request);
+    }
+    const startedAt = this.#clock.now().getTime();
+    const report = { handlers: request.handlers, requested: request.limit };
+    try {
+      const claimed = await store.claim(request);
+      this.#notifier.notify("onClaimFinished", {
+        ...report,
+        claimed: claimed.length,
+        lanes: new Set(claimed.map((delivery) => delivery.leaseToken)).size,
+        durationMs: this.#clock.now().getTime() - startedAt,
+        outcome: "success"
+      });
+      return claimed;
+    } catch (error) {
+      this.#notifier.notify("onClaimFinished", {
+        ...report,
+        claimed: 0,
+        lanes: 0,
+        durationMs: this.#clock.now().getTime() - startedAt,
+        outcome: "error",
+        error: toErrorInfo(error)
+      });
+      throw error;
     }
   }
-  #retain(entry) {
-    this.#pending.set(pendingKey(entry.delivery), entry);
-    this.#recoveryTimer ??= setInterval(
-      () => void this.#recoverSettlements(),
-      this.#dependencies.settings.pollIntervalMs
-    );
-    this.#recoveryTimer.unref();
+  /** Runs a local handler inside the tracer's process span; routes are traced as sends instead. */
+  process(run, handle) {
+    const tracer = this.#tracer;
+    if (tracer?.process === void 0 || run.registration.forwardsToTransport) {
+      return handle();
+    }
+    return tracer.process({ delivery: run.delivery }, async () => handle());
   }
-  /** 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;
+  /** Reports the start of a handler run now and its end when `settled` settles, passing it through. */
+  async observe(run, settled) {
+    if (!this.#runs) {
+      await settled;
+      return;
+    }
+    const { delivery } = run;
+    const kind = run.registration.forwardsToTransport ? "route" : "handler";
+    const startedAt = this.#clock.now().getTime();
+    this.#notifier.notify("onHandlerStarted", {
+      delivery,
+      kind,
+      endToEndLatencyMs: startedAt - delivery.event.occurredAt.getTime()
+    });
     try {
-      await store.relinquish?.(settings.owner, clock.now());
+      await settled;
     } catch (error) {
-      notifier.failure("relinquish", error);
+      const durationMs2 = this.#clock.now().getTime() - startedAt;
+      const errorInfo = toErrorInfo(error);
+      this.#notifier.notify("onHandlerFinished", {
+        delivery,
+        kind,
+        durationMs: durationMs2,
+        outcome: "error",
+        error: errorInfo
+      });
+      throw error;
     }
+    const durationMs = this.#clock.now().getTime() - startedAt;
+    this.#notifier.notify("onHandlerFinished", { delivery, kind, durationMs, outcome: "success" });
   }
-  /** 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/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);
   }
-  async #waitUntil(work, deadline) {
-    let timer;
-    const timedOut = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("timeout"), Math.max(0, deadline - Date.now()));
+  /**
+   * 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.#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
     });
-    const outcome = await Promise.race([work.then(() => "done"), timedOut]);
-    clearTimeout(timer);
-    return outcome;
   }
   /**
-   * Claims until stopped. A claim that filled its batch is followed by the next one at once while enough
+   * 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.
    */
-  async #runLoop() {
+  async run() {
     let minimumFree = 1;
     while (this.#running) {
       let round = { requested: 0, claimed: 0 };
       if (this.#freeSlots() >= minimumFree) {
         try {
-          round = await this.#claimAndStart();
+          round = await this.claimAndStart();
         } catch (error) {
-          this.#dependencies.notifier.failure("claim", error);
+          this.#parts.dependencies.notifier.failure("claim", error);
         }
       }
       if (round.requested > 0 && round.claimed === round.requested && this.#freeSlots() >= this.#refillThreshold) {
@@ -1251,16 +1364,74 @@ var Dispatcher = class {
       }
     }
   }
+  /**
+   * 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();
+    }
+  }
+  /** 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 };
+  }
+  #markExhausted(handlers, exhausted) {
+    for (const handler of handlers) {
+      if (exhausted) {
+        this.#exhaustedHandlers.add(handler);
+      } else {
+        this.#exhaustedHandlers.delete(handler);
+      }
+    }
+  }
+  /** 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?.();
+  }
   /** 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 timer = setTimeout(() => {
-          this.#signalledMinimum = 1;
-          resolve();
-        }, this.#dependencies.settings.pollIntervalMs);
+        const cancel = schedule(this.#parts.dependencies.clock, {
+          run: () => {
+            this.#signalledMinimum = 1;
+            resolve();
+          },
+          delayMs: this.#parts.dependencies.settings.pollIntervalMs
+        });
         this.#wakeUp = () => {
-          clearTimeout(timer);
+          cancel();
           resolve();
         };
       });
@@ -1270,16 +1441,6 @@ var Dispatcher = class {
     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();
-    }
-  }
   /**
    * 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
@@ -1296,111 +1457,163 @@ var Dispatcher = class {
         });
       }
     } else if (free > 0) {
-      this.#quietRefillTimer ??= setTimeout(
-        () => {
+      this.#quietRefillTimer ??= schedule(this.#parts.dependencies.clock, {
+        run: () => {
           this.#quietRefillTimer = void 0;
           this.#signal(1);
         },
-        Math.max(0, this.#lastClaimStartedAt + QUIET_REFILL_MS - Date.now())
-      );
+        delayMs: Math.max(0, this.#lastClaimStartedAt + QUIET_REFILL_MS - Date.now())
+      });
     }
   }
   #freeSlots() {
-    return this.#dependencies.settings.concurrency - this.#inFlight.size;
+    return this.#parts.dependencies.settings.concurrency - this.#parts.inFlight.size;
   }
-  /** Claims for every handler with room and starts what was claimed. */
-  async #claimAndStart() {
-    const { store, registry, clock, settings } = 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();
-      clearTimeout(this.#quietRefillTimer);
-      this.#quietRefillTimer = void 0;
-      requested += request.limit;
-      const claimed = await store.claim({
-        handlers: request.handlers,
-        limit: request.limit,
-        leaseOwner: settings.owner,
-        leaseExpiresAt: new Date(now.getTime() + settings.leaseDurationMs),
-        now
-      });
-      for (const handler of request.handlers) {
-        if (claimed.length < request.limit && wakeGeneration === this.#wakeGeneration) {
-          this.#exhaustedHandlers.add(handler);
-        } else {
-          this.#exhaustedHandlers.delete(handler);
-        }
-      }
-      for (const delivery of claimed) {
-        started.push(this.#start(delivery));
-      }
-    }
-    return { requested, claimed: started.length, started };
+};
+
+// src/dispatch/claim-planner.ts
+var ClaimPlanner = class {
+  #inFlight;
+  #batchSize;
+  constructor(inFlight, batchSize) {
+    this.#inFlight = inFlight;
+    this.#batchSize = batchSize;
   }
   /** 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);
+  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.#countInFlight(registration.id);
+      const room = registration.concurrency - this.#inFlight.countOf(registration);
       const limit = Math.min(room, free);
       if (limit > 0) {
-        plans.push({ handlers: [registration.id], limit });
+        plans.push({ handlers: [...registration.claimIds], limit });
         free -= limit;
       }
     }
     if (unlimited.length > 0 && free > 0) {
-      plans.push({ handlers: unlimited.map((registration) => registration.id), limit: free });
+      plans.push({
+        handlers: unlimited.flatMap((registration) => registration.claimIds),
+        limit: free
+      });
     }
     return plans;
   }
-  #countInFlight(handler) {
-    let count = 0;
-    for (const delivery of this.#inFlight) {
-      if (delivery.handler === handler) {
-        count += 1;
-      }
-    }
-    return count;
+};
+
+// src/dispatch/dispatch-context.ts
+var ShutdownLatch = class {
+  #abandoned = false;
+  get abandoned() {
+    return this.#abandoned;
   }
-  #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;
+  abandon() {
+    this.#abandoned = true;
   }
-  /** 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);
-    }
-    notifier.notify("onDeliveryStarted", { delivery });
+};
+
+// src/lease-heartbeat.ts
+var RENEWALS_PER_LEASE = 3;
+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: () => renewal.beat(),
+    delayMs: Math.max(1, Math.floor(settings.leaseDurationMs / RENEWALS_PER_LEASE)),
+    repeat: true,
+    unref: true
+  });
+}
+
+// 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;
+  }
+  /** 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;
+  }
+  /** 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();
+  }
+  /** 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 this.#bury(
+      await outcomes.bury(
         delivery,
-        new RelayBusError(
+        new AttemptsExhaustedError(
           `Delivery reached attempt ${delivery.attempt} of ${registration.retry.attempts} after its lease expired`
         )
       );
@@ -1408,37 +1621,54 @@ var Dispatcher = class {
     }
     let stopHeartbeat = () => void 0;
     try {
-      stopHeartbeat = registration.transactional ? await this.#guardTransactionalLease(registration, delivery, controller) : this.#startHeartbeat(delivery, controller);
-      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 })
-        });
-      }
+      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 (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);
+      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 })
+      });
     }
   }
-  async #runHandler(registration, delivery, controller) {
-    const { store, clock } = this.#dependencies;
+  /** 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,
@@ -1447,7 +1677,7 @@ var Dispatcher = class {
     const event = { ...delivery.event, payload };
     if (registration.transactional) {
       await store.transaction(async (transaction) => {
-        await this.#invoke(registration, event, delivery, controller, 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
@@ -1456,26 +1686,154 @@ var Dispatcher = class {
       });
       return "completed";
     }
-    await this.#invoke(registration, event, delivery, controller, void 0);
-    return this.#confirmCompletion(delivery);
+    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);
+  }
+}
+function isRetryableError(policy, error) {
+  if (error instanceof NonRetryableError) {
+    return false;
+  }
+  if (policy.retryIf === void 0) {
+    return true;
+  }
+  try {
+    return policy.retryIf(error);
+  } catch {
+    return true;
+  }
+}
+
+// src/dispatch/delivery-outcomes.ts
+var FIRST_COMPLETION_RETRY_MS = 50;
+var SECOND_COMPLETION_RETRY_MS = 250;
+var LAST_COMPLETION_RETRY_MS = 1e3;
+var COMPLETION_RETRY_DELAYS_MS = [
+  FIRST_COMPLETION_RETRY_MS,
+  SECOND_COMPLETION_RETRY_MS,
+  LAST_COMPLETION_RETRY_MS
+];
+var DeliveryOutcomes = class {
+  #parts;
+  constructor(parts) {
+    this.#parts = parts;
   }
   /**
    * 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;
+  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);
+        completed = await this.complete(delivery);
       } catch (error) {
         const delay = COMPLETION_RETRY_DELAYS_MS[attempt];
         if (delay === void 0) {
-          notifier.failure("complete", error);
+          dependencies.notifier.failure("complete", error);
           return "unconfirmed";
         }
-        await this.#sleep(delay);
+        await sleep(delay);
         continue;
       }
       if (!completed) {
@@ -1487,46 +1845,159 @@ var Dispatcher = class {
     }
   }
   /** 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);
+  complete(delivery) {
+    const { dependencies, completions } = this.#parts;
+    const { store, clock } = dependencies;
+    return completions === void 0 ? store.complete(delivery, clock.now()) : completions.submit(delivery);
   }
-  async #invoke(registration, event, delivery, controller, transaction) {
-    const context = {
-      deliveryId: delivery.deliveryId,
-      handler: delivery.handler,
-      attempt: delivery.attempt,
-      maxAttempts: registration.retry.attempts,
-      signal: controller.signal,
-      transaction
-    };
+  async fail(registration, { delivery, error }) {
+    const policy = registration.retry;
+    if (delivery.attempt >= policy.attempts || !isRetryableError(policy, error)) {
+      await this.bury(delivery, error);
+      return;
+    }
+    await this.#reschedule(registration, { delivery, error });
+  }
+  /**
+   * 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 });
+    }
+  }
+  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 })
+    });
+  }
+  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 })
+    });
+  }
+  /** 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 {
+      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 });
+    }
+  }
+};
+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(
-      () => runInIsolatedScope(scope, () => registration.handle(event, context))
+      observation === void 0 ? handle : () => observation.process({ registration, delivery }, handle)
     );
     work.catch(() => void 0);
-    let timer;
-    if (registration.timeoutMs !== null) {
-      const timeoutMs = registration.timeoutMs;
-      timer = setTimeout(() => {
-        controller.abort(
-          new HandlerTimeoutError(
-            `Handler '${registration.id}' did not settle within ${timeoutMs}ms`
-          )
-        );
-      }, timeoutMs);
-    }
+    const cancelTimeout = this.#startTimeout(registration, controller);
     try {
-      await Promise.race([work, rejectOnAbort(controller.signal)]);
+      const settled = Promise.race([work, rejectOnAbort(controller.signal)]);
+      await (observation === void 0 ? settled : observation.observe({ registration, delivery }, settled));
     } catch (error) {
-      await this.#awaitAbandonedHandler(work, error, transaction !== void 0);
+      await this.#awaitAbandonedHandler(work, {
+        reason: error,
+        transactional: transaction !== void 0
+      });
       throw error;
     } finally {
-      clearTimeout(timer);
+      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
+    });
   }
   /**
    * After an abort the handler may still be running. Waiting for it keeps a
@@ -1535,7 +2006,7 @@ var Dispatcher = class {
    * Transactional handlers are always awaited; others for one lease duration,
    * except at shutdown, which already waited.
    */
-  async #awaitAbandonedHandler(work, reason, transactional) {
+  async #awaitAbandonedHandler(work, { reason, transactional }) {
     const settledWork = work.then(
       () => void 0,
       () => void 0
@@ -1548,413 +2019,1264 @@ var Dispatcher = class {
       return;
     }
     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
-        });
-      }
-    }
-    const timer = setTimeout(
-      () => {
-        controller.abort(new LeaseLostError(`Lease on delivery ${delivery.deliveryId} expired`));
-      },
-      Math.max(0, expiry - clock.now().getTime())
-    );
-    timer.unref();
-    return () => clearTimeout(timer);
+    await waitUntil(this.#dependencies.clock, { work: settledWork, deadline });
   }
-  /**
-   * Renews the lease every third of its duration. A worker that cannot renew
-   * aborts its handler once the last confirmed expiry passes, because another
-   * worker may then claim the delivery (self-fencing).
-   */
-  #startHeartbeat(delivery, controller) {
-    const { store, clock, notifier, settings } = this.#dependencies;
-    let confirmedExpiry = delivery.leaseExpiresAt.getTime();
-    let renewing = false;
-    const abortLeaseLost = (storeConfirmed = false) => {
-      controller.abort(
-        new LeaseLostError(`Lease on delivery ${delivery.deliveryId} was lost`, { storeConfirmed })
-      );
-    };
-    const timer = setInterval(
-      () => {
-        const now = clock.now();
-        if (now.getTime() >= confirmedExpiry) {
-          abortLeaseLost();
-          return;
-        }
-        if (renewing) {
-          return;
+};
+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;
+  }
+  /** 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);
+    }
+  }
+};
+
+// 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;
+    }
+    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
+    });
+  }
+  /** 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);
+    }
+  }
+  /**
+   * 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 close(deadline) {
+    this.#stopTimer();
+    const lastTry = (async () => {
+      await this.#recovery;
+      await this.#recoverSettlements();
+    })();
+    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).
+   */
+  #recoverSettlements() {
+    this.#recovery ??= this.#recoverAll().finally(() => {
+      this.#recovery = void 0;
+    });
+    return this.#recovery;
+  }
+  async #recoverAll() {
+    for (const [key, entry] of [...this.#pending]) {
+      if (this.#pending.get(key) !== entry) {
+        continue;
+      }
+      try {
+        const applied = await entry.settle();
+        this.#pending.delete(pendingKeyOf(entry.delivery));
+        if (applied) {
+          entry.applied();
+        } else {
+          this.#dependencies.notifier.notify("onLeaseLost", { delivery: entry.delivery });
         }
-        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;
+      } catch {
+      }
+    }
+  }
+};
+
+// 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;
+  }
+  /**
+   * 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
         });
+      }
+    });
+  }
+  /**
+   * 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.
+   */
+  setClosing(closing) {
+    this.#closing = closing;
+    if (closing && this.#pending.length > 0) {
+      this.#flush();
+    }
+  }
+  #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();
+    }
+  }
+  #start(task, onCancel) {
+    const cancel = () => {
+      cancelTimer();
+      this.#waiting.delete(cancel);
+    };
+    const cancelTimer = schedule(this.#clock, {
+      run: () => {
+        this.#waiting.delete(cancel);
+        task.run();
       },
-      Math.max(1, Math.floor(settings.leaseDurationMs / 3))
+      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
     );
-    timer.unref();
-    return () => clearInterval(timer);
   }
-  async #fail(registration, delivery, error) {
-    const policy = registration.retry;
-    if (delivery.attempt >= policy.attempts || !isRetryableError(policy, error)) {
-      await this.#bury(delivery, error);
+  #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;
+  }
+  /**
+   * 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.
+   */
+  get watchesNewDeliveries() {
+    return this.#unwatch !== void 0;
+  }
+  start() {
+    if (this.#loop.isRunning) {
       return;
     }
-    await this.#reschedule(registration, delivery, error);
+    this.#loop.open();
+    this.#completions?.setClosing(false);
+    this.#watching = this.#watchNewDeliveries();
+    this.#looping = this.#loop.run();
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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;
+      }
+      this.#unwatch = unwatch;
+      if (unwatch !== void 0) {
+        this.wake();
+      }
+    } catch (error) {
+      notifier.failure("watch", error);
+    }
+  }
+  /** 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);
+    }
+  }
+  /**
+   * 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();
+      }
+    }
+  }
+  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();
+      }
+    }
+    await this.#recovery.close(deadline);
+    await deadline.race(this.#relinquish());
+    return 0;
+  }
+  /**
+   * 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;
+  }
+  /** 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.#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 '-'`
+      );
+    }
+    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`);
+      }
+    }
+  }
+  #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);
+    }
+  }
+  /** 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 {
+        observer[method]?.call(
+          observer,
+          argument
+        );
+      } catch (error) {
+        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;
+      }
+      try {
+        observer.onFailure?.({ stage: "observer", error: errorInfo });
+      } catch (observerError) {
+        this.#logObserverFailure(observerError);
+      }
+    }
+  }
+  #logObserverFailure(error) {
+    const errorInfo = toErrorInfo(error);
+    this.#logger.warn(
+      `[Notifier](logObserverFailure) relaybus observer threw | ${errorInfo.name}: ${errorInfo.message}`
+    );
+  }
+};
+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;
+}
+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)}'`
+    );
+  }
+  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 });
+    }
+  }
+  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`);
+      }
+    }
+  }
+  /** True while every transport reports itself ready. */
+  allReady() {
+    for (const transport of this.#transports.values()) {
+      if (transport.isReady?.() === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /** 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)
+    );
+  }
+  /** 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
+        });
+      }
+    };
+  }
+  #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.#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 }
+    );
+  }
+  #requireTransport(name) {
+    const transport = this.#transports.get(name);
+    if (transport === void 0) {
+      throw new ConfigurationError(`No transport named '${name}' is configured`);
+    }
+    return transport;
   }
-  /** 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)
-    );
-    let rescheduled;
+};
+
+// src/bus/bus-maintenance.ts
+var BusMaintenance = class {
+  #parts;
+  #retentionTimer;
+  #backlogTimer;
+  constructor(parts) {
+    this.#parts = parts;
+  }
+  /** Applies the retention policy once. */
+  async purgeExpired() {
+    const { store, clock, notifier, retention } = this.#parts;
+    const now = clock.now().getTime();
+    const { completedMs, deadMs } = retention;
     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 })
+      const result = await store.purge({
+        ...completedMs === null ? {} : { completedBefore: new Date(now - completedMs) },
+        ...deadMs === null ? {} : { deadBefore: new Date(now - deadMs) }
       });
-      return;
-    }
-    if (rescheduled) {
-      notifier.notify("onDeliveryRetryScheduled", { delivery, error: errorInfo, availableAt });
-    } else {
-      notifier.notify("onLeaseLost", { delivery });
+      notifier.notify("onPurged", { result });
+      return result;
+    } catch (error) {
+      notifier.failure("purge", error);
+      throw error;
     }
   }
-  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 })
+  /** Starts the retention purge and the backlog report, each when it has anything to do. */
+  start() {
+    this.#scheduleRetention();
+    this.#scheduleBacklog();
+  }
+  stop() {
+    this.#retentionTimer?.();
+    this.#backlogTimer?.();
+  }
+  /** 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
       });
-      return;
     }
-    if (buried) {
-      notifier.notify("onDeliveryDead", { delivery, error: errorInfo });
-    } else {
-      notifier.notify("onLeaseLost", { delivery });
+  }
+  /** 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 });
     }
   }
-  /**
-   * 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);
+};
+
+// 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) })
+    );
+  }
+  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);
   }
-  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 })
+  /** 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;
     }
-    if (released) {
-      notifier.notify("onDeliveryReleased", { delivery });
-    } else {
-      notifier.notify("onLeaseLost", { delivery });
+    return entries;
+  }
+  /** 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();
+      }
     }
   }
-};
-function pendingKey(delivery) {
-  return `${delivery.deliveryId}\0${delivery.leaseToken}`;
-}
-function rejectOnAbort(signal) {
-  return new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-  });
-}
-
-// 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();
-  #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 '-'`
-      );
+  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 (this.#byId.has(options.id)) {
-      throw new ConfigurationError(`Handler id '${options.id}' is already registered`);
+    if (transactionMode === "required") {
+      throw new TransactionRequiredError(
+        "publish found no transaction. Pass { transaction }, publish inside bus.transaction(), configure transactionResolver, or set transactionMode to optional"
+      );
     }
-    if (options.concurrency !== void 0 && (!Number.isInteger(options.concurrency) || options.concurrency < 1)) {
+    return store.transaction((ownTransaction) => store.append(ownTransaction, entries, now));
+  }
+  async #createEnvelope(input) {
+    const { event, options, id, scope, now, correlationId } = input;
+    if (typeof event.type !== "string") {
       throw new ConfigurationError(
-        `Concurrency of handler '${options.id}' must be a positive integer, received ${options.concurrency}`
+        "publish expects an instance of a class created with defineEvent"
       );
     }
-    const registration = {
-      id: options.id,
-      eventType: input.eventType,
-      schema: input.schema,
-      handle: input.handle,
-      retry: createRetryPolicy(options.retry, defaults.retry),
-      timeoutMs: resolveTimeout(options.timeout, defaults.timeoutMs, options.id),
-      concurrency: options.concurrency ?? null,
-      transactional: options.transactional ?? false,
-      forwardsToTransport: input.forwardsToTransport
+    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
     };
-    this.#byId.set(registration.id, registration);
-    const forType = this.#byEventType.get(registration.eventType) ?? [];
-    forType.push(registration);
-    this.#byEventType.set(registration.eventType, forType);
-    return registration;
-  }
-  get(id) {
-    return this.#byId.get(id);
   }
-  forEventType(eventType) {
-    return this.#byEventType.get(eventType) ?? [];
+};
+
+// src/received-envelope.ts
+function normalizeEnvelope(envelope) {
+  if (typeof envelope.id !== "string" || envelope.id.length === 0) {
+    throw new InvalidEnvelopeError("Received event has no id");
   }
-  all() {
-    return [...this.#byId.values()];
+  if (typeof envelope.type !== "string") {
+    throw new InvalidEnvelopeError(`Received event ${envelope.id} has no type`);
   }
-};
-function resolveTimeout(timeout, fallback, handlerId) {
-  if (timeout === void 0) {
-    return fallback;
+  try {
+    assertEventType(envelope.type);
+  } catch (error) {
+    throw new InvalidEnvelopeError(toErrorInfo(error).message);
   }
-  if (timeout === false) {
-    return null;
+  const occurredAt = toDate(envelope.occurredAt);
+  if (occurredAt === void 0) {
+    throw new InvalidEnvelopeError(`Received event ${envelope.id} has an invalid occurredAt`);
   }
-  return toTimerMilliseconds(timeout, `Timeout of handler '${handlerId}'`);
+  return {
+    id: envelope.id,
+    type: envelope.type,
+    source: typeof envelope.source === "string" ? envelope.source : "unknown",
+    key: optionalText(envelope.key),
+    payload: envelope.payload,
+    headers: { ...envelope.headers },
+    correlationId: optionalText(envelope.correlationId),
+    causationId: optionalText(envelope.causationId),
+    occurredAt
+  };
+}
+function toDate(value) {
+  const date = typeof value === "string" ? new Date(value) : value;
+  return date instanceof Date && !Number.isNaN(date.getTime()) ? date : void 0;
+}
+function optionalText(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
 }
 
-// src/notifier.ts
-var Notifier = class {
-  #observers;
-  #logger;
-  constructor(observers, logger) {
-    this.#observers = observers;
-    this.#logger = logger;
-  }
-  notify(method, argument) {
-    for (const observer of this.#observers) {
-      try {
-        observer[method]?.call(
-          observer,
-          argument
-        );
-      } catch (error) {
-        this.#reportObserverFailure(observer, error);
-      }
+// 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";
     }
-  }
-  failure(stage, error) {
-    const errorInfo = toErrorInfo(error);
-    this.#logger.error(
-      `[Notifier](failure) relaybus ${stage} failed | ${errorInfo.name}: ${errorInfo.message}`
+    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)
     );
-    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;
-      }
-      try {
-        observer.onFailure?.({ stage: "observer", error: errorInfo });
-      } catch (observerError) {
-        this.#logObserverFailure(observerError);
-      }
+    const status = result.duplicateEventIds.length > 0 ? "duplicate" : "accepted";
+    notifier.notify("onReceived", { envelope: normalized, status });
+    if (result.appendedDeliveryCount > 0) {
+      scheduleWake();
     }
-  }
-  #logObserverFailure(error) {
-    const errorInfo = toErrorInfo(error);
-    this.#logger.warn(
-      `[Notifier](notify) relaybus observer threw | ${errorInfo.name}: ${errorInfo.message}`
-    );
+    return status;
   }
 };
 
-// src/relay-bus.ts
-var DEFAULTS = {
-  concurrency: 10,
-  pollInterval: "1s",
-  leaseDuration: "30s",
-  shutdownTimeout: "30s",
-  completionBatchWindow: "2ms",
-  completionBatchSize: 200,
-  completedRetention: "7d",
-  retentionInterval: "1h",
-  routeTimeoutMs: 3e4
-};
-var TRANSPORT_HANDLER_PREFIX = "relaybus.transport";
+// 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 {
+    ...core,
+    maintenance,
+    connections,
+    catalogRequirements,
+    dispatcherEnabled,
+    shutdownTimeoutMs: settings.shutdownTimeoutMs,
+    dispatcher,
+    ...createInboxAndOutbox(core, hooks)
+  };
+}
+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 {
+    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 createInboxAndOutbox(core, hooks) {
+  const createDelivery = (registration, availableAt) => ({
+    id: core.generateIdentifier(),
+    handler: registration.id,
+    availableAt
+  });
+  return {
+    publisher: new EventPublisher({
+      ...core,
+      createDelivery,
+      reportUnrouted: hooks.reportUnrouted,
+      scheduleWake: hooks.scheduleWake
+    }),
+    receiver: new EventReceiver({ ...core, createDelivery, scheduleWake: hooks.scheduleWake })
+  };
+}
+
+// src/transaction-budget.ts
+async function runBudgetedTransaction(store, { clock, timeoutMs, work }) {
+  const startedAt = clock.now().getTime();
+  const overrun = () => clock.now().getTime() - startedAt >= timeoutMs;
+  let committing = false;
+  try {
+    return await store.transaction(
+      async (transaction) => {
+        committing = false;
+        const result = await work(transaction);
+        if (overrun()) {
+          throw createTimeoutError(timeoutMs, void 0);
+        }
+        committing = true;
+        return result;
+      },
+      { timeoutMs }
+    );
+  } catch (error) {
+    if (error instanceof TransactionTimeoutError || committing || !overrun()) {
+      throw error;
+    }
+    throw createTimeoutError(timeoutMs, error);
+  }
+}
+function createTimeoutError(timeoutMs, cause) {
+  const message = `The transaction ran past its ${timeoutMs} ms budget (transactionTimeout) and was rolled back. The usual cause is a slow call to another service (HTTP, gRPC, a broker, a lock) inside the transaction: make external calls before the transaction starts or after it commits, or raise transactionTimeout`;
+  return cause === void 0 ? new TransactionTimeoutError(message) : new TransactionTimeoutError(`${message} | cause=${toErrorInfo(cause).message}`, { cause });
+}
+
+// src/relay-bus.ts
+var DEFAULT_DRAIN_BATCHES = 1e3;
 var WAKE_DELAY_MS = 25;
 var RelayBus = class {
-  #store;
-  #source;
-  #transactionMode;
-  #transactionResolver;
-  #unroutedEvents;
-  #registry = new HandlerRegistry();
-  #defaults;
-  #transports = /* @__PURE__ */ new Map();
-  #subscriptions;
-  #notifier;
-  #logger;
-  #clock;
-  #generateIdentifier;
-  #dispatcher;
-  #dispatcherEnabled;
-  #catalogRequirements = [];
-  #setupStore;
-  #retention;
-  #retentionTimer;
-  #state = "idle";
-  #starting;
-  #stopping;
+  #parts;
+  #lifecycle;
   constructor(options) {
-    this.#store = options.store;
-    this.#source = options.source ?? "relaybus";
-    this.#transactionMode = oneOf(
-      options.transactionMode ?? "required",
-      ["required", "optional"],
-      "transactionMode"
-    );
-    this.#unroutedEvents = oneOf(
-      options.unroutedEvents ?? "warn",
-      ["warn", "throw"],
-      "unroutedEvents"
-    );
-    this.#transactionResolver = options.transactionResolver;
-    this.#defaults = {
-      retry: createRetryPolicy(options.retry),
-      timeoutMs: options.handlerTimeout === void 0 || options.handlerTimeout === false ? null : toTimerMilliseconds(options.handlerTimeout, "handlerTimeout")
-    };
-    this.#logger = options.logger ?? console;
-    this.#notifier = new Notifier(options.observers ?? [], this.#logger);
-    this.#clock = options.clock ?? systemClock;
-    this.#generateIdentifier = options.generateIdentifier ?? (() => createUuidV7());
-    this.#setupStore = options.setupStore ?? true;
-    this.#retention = createRetentionSettings(options.retention);
-    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);
-    }
-    for (const route of options.routes ?? []) {
-      this.#registerRoute(route);
-    }
-    this.#subscriptions = options.subscriptions ?? [];
-    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);
-    }
-    this.#dispatcherEnabled = options.dispatcher?.enabled ?? true;
-    this.#dispatcher = new Dispatcher({
-      store: this.#store,
-      registry: this.#registry,
-      clock: this.#clock,
-      random: options.random ?? Math.random,
-      notifier: this.#notifier,
-      settings: createDispatcherSettings(options.dispatcher, this.#generateIdentifier)
+    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(
       {
-        eventType: type,
+        eventTypes: [type],
         schema,
         handle: handler,
         options,
         forwardsToTransport: false
       },
-      this.#defaults
+      this.#parts.defaults
     );
   }
+  // eslint-disable-next-line relaybus/max-two-params -- public RelayBus.subscribeCatalog signature
   subscribeCatalog(catalog, handlers, options = {}) {
-    for (const binding of resolveCatalogHandlers(catalog, handlers, options)) {
+    for (const binding of resolveCatalogHandlers(catalog, { handlers, options })) {
       this.subscribe(binding.eventClass, binding.handle, binding.options);
     }
   }
@@ -1965,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
@@ -1977,7 +3299,9 @@ var RelayBus = class {
   }
   /** Registered handlers and routes, for diagnostics. */
   handlers() {
-    return this.#registry.all().map(toDescriptor);
+    return this.#parts.registry.all().flatMap(
+      (registration) => registration.eventTypes.map((eventType) => toDescriptor(registration, eventType))
+    );
   }
   /**
    * Stores an event in the current transaction. Handlers run after the
@@ -1985,21 +3309,32 @@ var RelayBus = class {
    * have been written when the id already exists.
    */
   async publish(event, options = {}) {
-    const [envelope] = await this.#publish([event], options, 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.#publish(events, options, 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
-   * transaction without passing it explicitly.
+   * transaction without passing it explicitly. The transaction is held to `transactionTimeout`
+   * and rolled back with a {@link TransactionTimeoutError} when it runs past it.
    */
   async transaction(work) {
-    return this.#store.transaction(
-      (transaction) => runInScope({ transaction }, () => work(transaction))
-    );
+    return runBudgetedTransaction(this.#parts.store, {
+      clock: this.#parts.clock,
+      timeoutMs: this.#parts.transactionTimeoutMs,
+      work: (transaction) => runInScope({ transaction }, () => work(transaction))
+    });
+  }
+  /**
+   * The transaction `publish` would join right now: the one of the enclosing `bus.transaction`
+   * (or `@RelayBusTransaction()` method, or transactional handler), else the one
+   * `transactionResolver` finds. Repositories use it to write in the same transaction.
+   */
+  currentTransaction() {
+    return getCurrentScope()?.transaction ?? this.#parts.transactionResolver?.();
   }
   /**
    * Stores an event received from a broker and schedules it for local handlers.
@@ -2007,27 +3342,8 @@ var RelayBus = class {
    * only after it resolves. Throws {@link InvalidEnvelopeError} for malformed
    * events, which transports should dead-letter instead of redelivering.
    */
-  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;
+  receive(envelope) {
+    return this.#parts.receiver.receive(envelope);
   }
   /**
    * Creates the store schema, connects transports, subscribes and starts
@@ -2035,53 +3351,50 @@ var RelayBus = class {
    * stopped for good, because its transports are closed; create a new instance.
    */
   async start() {
-    if (this.#state !== "idle") {
-      throw new RelayBusError(
-        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();
     }
   }
   /**
-   * Stops dispatching, waits for running handlers, closes transports and the
-   * store. Waits for a start in progress first. Safe to call more than once.
+   * Stops claiming, waits for running handlers, hands back leases, closes transports and the store,
+   * all within `options.timeout` (default `dispatcher.shutdownTimeout`). When the deadline passes it
+   * aborts the handlers still running, force-closes what relaybus opened itself (never pools or
+   * clients the application passed in) and resolves anyway: it never rejects because of the
+   * deadline. Abandoned deliveries stay leased until their lease expires and then run again
+   * (at-least-once). Waits for a start in progress first. Safe to call more than once: later calls
+   * get the result of the first.
    */
-  async stop() {
-    if (this.#stopping !== void 0) {
-      return this.#stopping;
-    }
-    if (this.#state === "starting") {
-      await this.#starting.catch(() => void 0);
-    }
-    if (this.#state === "idle") {
-      await this.#dispatcher.stop();
-      return;
-    }
-    if (this.#state !== "running") {
-      return;
+  async stop(options = {}) {
+    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;
+    }
+    const result = await stopping;
+    if (!result.graceful) {
+      this.#parts.logger.warn(
+        `[RelayBus](stop) Shutdown deadline passed, forced close | abandoned=${result.abandonedDeliveries} | timeoutMs=${timeoutMs}`
+      );
     }
-    this.#stopping = this.#stopComponents();
-    return this.#stopping;
+    return result;
   }
   /**
    * 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
    * (retries, delays) are not waited for. Intended for tests.
    */
-  async drain(maxBatches = 1e3) {
+  async drain(maxBatches = DEFAULT_DRAIN_BATCHES) {
     let total = 0;
     for (let batch = 0; batch < maxBatches; batch += 1) {
       const processed = await this.runOnce();
@@ -2090,333 +3403,107 @@ var RelayBus = class {
       }
       total += processed;
     }
-    throw new RelayBusError(`drain did not finish within ${maxBatches} batches`);
+    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) => {
-          await this.receive(envelope);
-        });
+      for (const subscription of connections.subscriptions) {
+        await connections.subscribe(
+          subscription,
+          (envelope, origin) => this.#parts.receiver.receive(envelope, origin)
+        );
       }
     } catch (error) {
-      await this.#closeTransports();
-      this.#state = "stopped";
+      await this.#closeAfterFailedStart();
+      this.#lifecycle.markStopped();
       throw error;
     }
-    if (this.#dispatcherEnabled) {
-      this.#dispatcher.start();
+    if (this.#lifecycle.state !== "starting") {
+      throw new LifecycleError("relaybus was stopped before it finished starting");
     }
-    if (this.#retention.completedMs !== null || this.#retention.deadMs !== null) {
-      this.#retentionTimer = setInterval(() => {
-        this.purgeExpired().catch(() => void 0);
-      }, this.#retention.intervalMs);
-      this.#retentionTimer.unref();
+    if (this.#parts.dispatcherEnabled) {
+      this.#parts.dispatcher.start();
     }
-    this.#state = "running";
-    this.#logger.log(
-      `[RelayBus](start) 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}`
     );
   }
-  async #stopComponents() {
-    this.#state = "stopping";
-    clearInterval(this.#retentionTimer);
-    try {
-      await this.#dispatcher.stop();
-      await this.#closeTransports();
-      await this.#store.close?.();
-    } finally {
-      this.#state = "stopped";
-    }
-  }
-  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 = [];
-    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)
-        )
-      });
-    }
-    const deliverable = entries.filter((entry) => entry.deliveries.length > 0);
-    if (deliverable.length > 0) {
-      const result = await this.#appendInTransaction(deliverable, options, scope, now);
-      const appended = new Set(result.appendedEventIds);
-      const published = deliverable.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();
-        }
+  /** 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;
       }
-    }
-    return entries.map((entry) => entry.event);
+    );
   }
   #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](publish) ${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(event, options, id, scope, now, correlationId) {
-    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 ?? null,
-      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 };
   }
-  #registerRoute(route) {
-    const transport = this.#requireTransport(route.transport);
-    const { type } = describeEvent(route.event);
-    const destination = route.destination ?? type;
-    this.#registry.register(
-      {
-        eventType: type,
-        schema: void 0,
-        handle: (envelope) => transport.publish(envelope, destination),
-        options: {
-          id: `${TRANSPORT_HANDLER_PREFIX}:${transport.name}:${destination}:${type}`,
-          ...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;
     }
-    setTimeout(() => this.#dispatcher.wake(), WAKE_DELAY_MS).unref();
+    schedule(this.#parts.clock, {
+      run: () => this.#parts.dispatcher.wake(),
+      delayMs: WAKE_DELAY_MS,
+      unref: true
+    });
   }
-  async #closeTransports() {
-    for (const transport of this.#transports.values()) {
+  /** 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.#parts.connections.transports) {
       try {
-        await transport.close();
+        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) {
-  return {
-    id: registration.id,
-    eventType: registration.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 };
-}
-function normalizeEnvelope(envelope) {
-  if (typeof envelope.id !== "string" || envelope.id.length === 0) {
-    throw new InvalidEnvelopeError("Received event has no id");
-  }
-  if (typeof envelope.type !== "string") {
-    throw new InvalidEnvelopeError(`Received event ${envelope.id} has no type`);
-  }
-  try {
-    assertEventType(envelope.type);
-  } catch (error) {
-    throw new InvalidEnvelopeError(toErrorInfo(error).message);
-  }
-  const occurredAt = toDate(envelope.occurredAt);
-  if (occurredAt === void 0) {
-    throw new InvalidEnvelopeError(`Received event ${envelope.id} has an invalid occurredAt`);
-  }
-  return {
-    id: envelope.id,
-    type: envelope.type,
-    source: typeof envelope.source === "string" ? envelope.source : "unknown",
-    key: optionalText(envelope.key),
-    payload: envelope.payload,
-    headers: { ...envelope.headers },
-    correlationId: optionalText(envelope.correlationId),
-    causationId: optionalText(envelope.causationId),
-    occurredAt
-  };
-}
-function toDate(value) {
-  const date = typeof value === "string" ? new Date(value) : value;
-  return date instanceof Date && !Number.isNaN(date.getTime()) ? date : void 0;
-}
-function optionalText(value) {
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-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)}'`
-    );
-  }
-  return value;
-}
-function positiveInteger(value, name) {
-  if (!Number.isInteger(value) || value < 1) {
-    throw new ConfigurationError(`${name} must be a positive integer, received ${value}`);
-  }
-  return value;
-}
-function createDispatcherSettings(options, generateIdentifier) {
-  const concurrency = positiveInteger(
-    options?.concurrency ?? DEFAULTS.concurrency,
-    "dispatcher.concurrency"
-  );
-  return {
-    owner: `${hostname()}:${process.pid}:${generateIdentifier()}`,
-    concurrency,
-    batchSize: positiveInteger(options?.batchSize ?? concurrency, "dispatcher.batchSize"),
-    pollIntervalMs: toTimerMilliseconds(
-      options?.pollInterval ?? DEFAULTS.pollInterval,
-      "dispatcher.pollInterval"
-    ),
-    leaseDurationMs: toTimerMilliseconds(
-      options?.leaseDuration ?? DEFAULTS.leaseDuration,
-      "dispatcher.leaseDuration"
-    ),
-    shutdownTimeoutMs: toTimerMilliseconds(
-      options?.shutdownTimeout ?? DEFAULTS.shutdownTimeout,
-      "dispatcher.shutdownTimeout"
-    ),
-    completionBatchWindowMs: toMilliseconds(
-      options?.completionBatchWindow ?? DEFAULTS.completionBatchWindow,
-      "dispatcher.completionBatchWindow"
-    ),
-    completionBatchSize: positiveInteger(
-      options?.completionBatchSize ?? DEFAULTS.completionBatchSize,
-      "dispatcher.completionBatchSize"
-    )
-  };
-}
-function createRetentionSettings(options) {
-  const completed = options?.completed ?? DEFAULTS.completedRetention;
-  const dead = options?.dead ?? false;
-  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"
-    )
-  };
-}
 
-export { CatalogPublisher, ConfigurationError, DEFAULT_RETRY_POLICY, DEFAULT_ROUTE_RETRY_POLICY, DELIVERY_STATUSES, DispatcherStoppedError, EventValidationError, HandlerTimeoutError, InMemoryEventStore, InMemoryTransaction, InvalidEnvelopeError, LeaseLostError, MAX_TIMER_DELAY_MS, NonRetryableError, RelayBus, RelayBusError, TransactionRequiredError, assertEventType, computeRetryDelay, consume, createRetryPolicy, createUuidV7, defineCatalog, defineEvent, defineHandlers, describeCatalog, isRetryableError, produce, systemClock, toErrorInfo, toMilliseconds, validatePayload };
+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