@relaybus/core 0.3.0 → 0.3.1

package/dist/index.d.cts

@@ -1,15 +1,5 @@
-import { E as EventEnvelope, D as DomainEvent, S as StandardSchemaV1, P as PayloadOf, a as EventHeaders, b as EventReference, C as Clock, c as EventClass } from './event-DCRTuYKI.cjs';
-export { d as DefineEventKeyOptions, e as DefineEventOptions, f as EventKeyFunction, g as assertEventType, h as defineEvent, s as systemClock, v as validatePayload } from './event-DCRTuYKI.cjs';
-
-/**
- * A duration in milliseconds, or a string such as `'250ms'`, `'30s'`, `'5m'`,
- * `'1h'` or `'7d'`.
- */
-type Duration = number | `${number}${DurationUnit}`;
-type DurationUnit = 'ms' | 's' | 'm' | 'h' | 'd';
-declare function toMilliseconds(value: Duration, name: string): number;
-/** Largest delay Node.js timers support. Longer values fire after 1ms instead. */
-declare const MAX_TIMER_DELAY_MS = 2147483647;
+import { D as Duration, E as EventEnvelope, a as DomainEvent, S as StandardSchemaV1, P as PayloadOf, C as ClaimedDelivery, b as EventHeaders, c as EventStoreStatistics, d as ErrorInfo, e as PurgeResult, f as EventStore, T as Transport, g as EventReference, h as Clock, A as AppendEntry, i as AppendResult, j as ClaimRequest, L as LeaseReference, k as DeliveryQuery, l as DeliveryRecord, m as PurgeRequest, n as EventClass } from './transport-BlfzIBZD.cjs';
+export { o as AttemptsExhaustedError, p as CloseOptions, q as ConfigurationError, r as DELIVERY_STATUSES, s as DefineEventKeyOptions, t as DefineEventOptions, u as DeliveryStatus, v as DispatcherStoppedError, w as DrainIncompleteError, x as EventKeyFunction, y as EventStoreTransactionOptions, z as EventValidationError, H as HandlerTimeoutError, I as InvalidEnvelopeError, B as InvalidTransportMessage, F as LeaseLostError, G as LifecycleError, M as MAX_TIMER_DELAY_MS, N as NewDelivery, J as NonRetryableError, R as RelayBusError, K as TransactionRequiredError, O as TransactionTimeoutError, Q as TransportMessage, U as TransportMessageHandler, V as TransportSubscriptionHooks, W as ValidationIssue, X as assertEventType, Y as defineEvent, Z as systemClock, _ as toErrorInfo, $ as toMilliseconds, a0 as validatePayload } from './transport-BlfzIBZD.cjs';
 
 /**
  * How the delay between attempts is randomized.
@@ -358,326 +348,6 @@ declare function consume<TCatalog extends Catalog, const TName extends keyof TCa
  */
 declare function produce<TCatalog extends Catalog, const TName extends keyof TCatalog = keyof TCatalog>(catalog: TCatalog, options?: CatalogEventSelection<TName>): CatalogDeclaration<TCatalog, TName>;
 
-/**
- * Base class of every error thrown by relaybus.
- */
-declare class RelayBusError extends Error {
-    name: string;
-    /**
-     * Stable, machine-readable identifier of the error class, such as `RELAYBUS_LEASE_LOST`.
-     * Unlike `name` and `message`, a code is never renamed once released; branch on it in
-     * alerts and dashboards. Subclasses declared outside relaybus inherit `RELAYBUS_ERROR`.
-     */
-    readonly code: string;
-}
-/** Invalid options passed to a relaybus component. */
-declare class ConfigurationError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/**
- * Thrown by `publish` when no transaction can be found and the bus runs with
- * `transactionMode: 'required'` (the default). Publishing outside a transaction
- * would reintroduce the dual-write problem the outbox exists to prevent.
- */
-declare class TransactionRequiredError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/**
- * A `bus.transaction` (or `@RelayBusTransaction()` method) ran past its `transactionTimeout` and
- * was rolled back. Its `cause` is the error the database raised when it ended the transaction,
- * when there was one. Usually a slow call to another service made inside the transaction.
- */
-declare class TransactionTimeoutError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/**
- * Throw from a handler to dead-letter the delivery immediately, skipping the
- * remaining retry attempts.
- */
-declare class NonRetryableError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/** A payload failed its event schema. Never retried: the payload will not change. */
-declare class EventValidationError extends NonRetryableError {
-    readonly issues: readonly ValidationIssue[];
-    name: string;
-    readonly code: string;
-    constructor(message: string, issues: readonly ValidationIssue[]);
-}
-/**
- * A message received from a broker is not a valid event. Never retried:
- * transports should dead-letter it instead of redelivering it forever.
- */
-declare class InvalidEnvelopeError extends NonRetryableError {
-    name: string;
-    readonly code: string;
-}
-/** The worker no longer owns the delivery it was processing. */
-declare class LeaseLostError extends RelayBusError {
-    name: string;
-    readonly code: string;
-    /**
-     * 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.
-     */
-    readonly storeConfirmed: boolean;
-    constructor(message: string, options?: {
-        readonly storeConfirmed?: boolean;
-    });
-}
-/** A handler did not settle within its configured timeout. Retried like any failure. */
-declare class HandlerTimeoutError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/**
- * Reason of a handler's abort signal when the bus stops before the handler
- * finished. The delivery is released and runs again without losing an attempt.
- */
-declare class DispatcherStoppedError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/**
- * A delivery came back after its lease expired on its last attempt, so it is
- * dead-lettered without running its handler again.
- */
-declare class AttemptsExhaustedError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/** A lifecycle method was called in a state that does not allow it, such as starting a bus twice. */
-declare class LifecycleError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-/** `drain` still found due deliveries after its maximum number of batches. */
-declare class DrainIncompleteError extends RelayBusError {
-    name: string;
-    readonly code: string;
-}
-interface ValidationIssue {
-    readonly message: string;
-    readonly path?: readonly PropertyKey[] | undefined;
-}
-/** Serializable snapshot of an error, stored with failed deliveries. */
-interface ErrorInfo {
-    readonly name: string;
-    readonly message: string;
-    readonly stack?: string | undefined;
-    /** The {@link RelayBusError.code} of a relaybus error; absent for any other error. */
-    readonly code?: string | undefined;
-}
-declare function toErrorInfo(error: unknown): ErrorInfo;
-
-/**
- * Lifecycle of one handler's delivery of one event.
- * `pending` (waiting or scheduled for retry) -> `processing` (leased by a worker)
- * -> `completed` | `pending` (retry) | `dead` (exhausted or non-retryable).
- * `dead` -> `pending` only through an explicit requeue.
- *
- * A completed delivery is deleted. `completed` records exist only in stores
- * configured to keep a completion history (`retainCompleted` /
- * `completionHistory`), where they are listed, counted and purged like before.
- */
-type DeliveryStatus = 'pending' | 'processing' | 'completed' | 'dead';
-declare const DELIVERY_STATUSES: readonly DeliveryStatus[];
-interface NewDelivery {
-    readonly id: string;
-    /** Stable handler id. Together with the event id it is unique. */
-    readonly handler: string;
-    readonly availableAt: Date;
-}
-interface AppendEntry {
-    readonly event: EventEnvelope;
-    readonly deliveries: readonly NewDelivery[];
-}
-interface AppendResult {
-    /** Events written by this call. */
-    readonly appendedEventIds: readonly string[];
-    /** Events that already existed. Their missing deliveries were still added. */
-    readonly duplicateEventIds: readonly string[];
-    /** Deliveries written by this call. Existing (event, handler) pairs are skipped. */
-    readonly appendedDeliveryCount: number;
-}
-/**
- * Lease expiry is compared with the `now` the caller passes, taken from the
- * bus clock. Keep worker clocks synchronized (NTP): a skew larger than a third
- * of the lease duration lets another worker reclaim a delivery that is still running.
- *
- * Stores may grant the lease on a group of deliveries (a lane) instead of on
- * each delivery. The group is exclusive to `leaseOwner` while the lease is
- * live, so other owners do not see its pending deliveries until it expires or
- * is relinquished; every delivery of the group carries the group's fencing token.
- */
-interface ClaimRequest {
-    /** Only deliveries of these handlers are claimed. */
-    readonly handlers: readonly string[];
-    readonly limit: number;
-    readonly leaseOwner: string;
-    readonly leaseExpiresAt: Date;
-    readonly now: Date;
-}
-/**
- * Proof of ownership. Every state change after a claim must present it
- * (fencing). A lease stays valid until another claim replaces it, even after
- * its expiry time; expiry only makes the delivery claimable again.
- */
-interface LeaseReference {
-    readonly deliveryId: string;
-    readonly leaseToken: string;
-}
-interface ClaimedDelivery extends LeaseReference {
-    readonly handler: string;
-    /** Attempt number of this claim, starting at 1. */
-    readonly attempt: number;
-    readonly leaseExpiresAt: Date;
-    readonly event: EventEnvelope;
-}
-interface DeliveryRecord {
-    readonly id: string;
-    readonly handler: string;
-    readonly status: DeliveryStatus;
-    readonly attempts: number;
-    readonly availableAt: Date;
-    readonly leaseOwner: string | null;
-    readonly leaseExpiresAt: Date | null;
-    readonly lastError: ErrorInfo | null;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readonly completedAt: Date | null;
-    readonly event: EventEnvelope;
-}
-interface DeliveryQuery {
-    readonly status?: DeliveryStatus;
-    readonly handler?: string;
-    readonly eventType?: string;
-    readonly eventId?: string;
-    /** Default 100. */
-    readonly limit?: number;
-}
-interface PurgeRequest {
-    /** Delete completed deliveries completed before this instant. */
-    readonly completedBefore?: Date;
-    /** Delete dead deliveries last updated before this instant. */
-    readonly deadBefore?: Date;
-}
-interface PurgeResult {
-    readonly deletedDeliveries: number;
-    /** Events deleted because no delivery referenced them any more. */
-    readonly deletedEvents: number;
-}
-interface EventStoreStatistics {
-    readonly pending: number;
-    readonly processing: number;
-    readonly completed: number;
-    readonly dead: number;
-    /** `availableAt` of the oldest delivery that is due but not yet processed. */
-    readonly oldestDueAt: Date | null;
-}
-/** How `stop` closes a transport or a store. */
-interface CloseOptions {
-    /**
-     * Aborted when the shutdown deadline passes (`bus.stop({ timeout })`), possibly before `close` is
-     * called. From then on, close what you opened yourself at once (destroy connections, cancel
-     * running queries) instead of waiting for it to finish; the bus no longer waits for `close`.
-     * Leave alone what the application passed in.
-     */
-    readonly signal?: AbortSignal;
-}
-/** How a store runs one transaction of `bus.transaction`. */
-interface EventStoreTransactionOptions {
-    /**
-     * Time budget of the whole transaction, in milliseconds. A store makes the database enforce it
-     * where it can (for example a statement or idle-in-transaction timeout), so a transaction that
-     * waits on something slow is ended by the server and its locks are released. The bus rolls back
-     * a transaction that still ran past the budget, so a store may also ignore it.
-     */
-    readonly timeoutMs: number;
-}
-/**
- * Storage port. Implementations persist events and deliveries in the same
- * database as the application's business data so that both commit atomically.
- *
- * Every implementation must pass the contract suite in `@relaybus/testing`.
- */
-interface EventStore<TTransaction = unknown> {
-    /** Creates tables, collections and indexes when they do not exist. */
-    setup?(): Promise<void>;
-    /**
-     * Runs `work` inside a new database transaction and commits when it resolves. `options` come
-     * from `bus.transaction`; the store's own transactions and the dispatcher's pass none.
-     */
-    transaction<T>(work: (transaction: TTransaction) => Promise<T>, options?: EventStoreTransactionOptions): Promise<T>;
-    /**
-     * Writes events and their deliveries inside `transaction`. Idempotent on
-     * event id and on (event id, handler). Assigns a per-key sequence to keyed
-     * events in commit order.
-     */
-    append(transaction: TTransaction, entries: readonly AppendEntry[], now: Date): Promise<AppendResult>;
-    /**
-     * Leases up to `limit` deliveries that are due: pending with `availableAt <= now`,
-     * or processing with an expired lease. A keyed delivery is only claimable when
-     * no earlier delivery of the same handler and key is pending or processing.
-     * Counts the attempt (`attempt` of the result; a store may persist the count
-     * only when the attempt fails or its lease is lost). Safe to call from many
-     * processes at once.
-     */
-    claim(request: ClaimRequest): Promise<ClaimedDelivery[]>;
-    /** Extends a lease the caller still holds. Returns false when the lease was lost. */
-    extendLease(lease: LeaseReference, leaseExpiresAt: Date, now: Date): Promise<boolean>;
-    /**
-     * Marks a leased delivery completed by deleting it (or moving it to the
-     * completion history, when the store keeps one). With `transaction` the change
-     * commits together with the handler's own writes. Returns false when the lease
-     * was lost.
-     */
-    complete(lease: LeaseReference, now: Date, transaction?: TTransaction): Promise<boolean>;
-    /** Returns a leased delivery to pending, due at `availableAt`. */
-    reschedule(lease: LeaseReference, availableAt: Date, error: ErrorInfo, now: Date): Promise<boolean>;
-    /**
-     * Gives a leased delivery back without counting the attempt: pending, due
-     * now, attempts decremented. Used when a handler is aborted at shutdown.
-     */
-    release(lease: LeaseReference, now: Date): Promise<boolean>;
-    /**
-     * Marks many leased deliveries completed with one round trip. Returns, for
-     * every lease in the same order, whether it was completed (false: lease lost
-     * or already finished). Each lease is fenced individually, exactly as in
-     * {@link EventStore.complete}. Optional: the dispatcher falls back to
-     * `complete` when a store does not implement it.
-     */
-    completeMany?(leases: readonly LeaseReference[], now: Date): Promise<boolean[]>;
-    /** Moves a leased delivery to dead. */
-    bury(lease: LeaseReference, error: ErrorInfo, now: Date): Promise<boolean>;
-    listDeliveries(query: DeliveryQuery): Promise<DeliveryRecord[]>;
-    /** Moves dead deliveries back to pending with a fresh attempt budget. Returns how many moved. */
-    requeue(deliveryIds: readonly string[], now: Date): Promise<number>;
-    purge(request: PurgeRequest): Promise<PurgeResult>;
-    statistics(now: Date): Promise<EventStoreStatistics>;
-    /**
-     * Hands back every lease group that `leaseOwner` holds without running work,
-     * so other workers can take them at once instead of after lease expiry.
-     * Called at graceful shutdown after the owner's deliveries settled. Groups
-     * with running deliveries stay leased. Optional.
-     */
-    relinquish?(leaseOwner: string, now: Date): Promise<void>;
-    /**
-     * Calls `listener` soon after a transaction that added deliveries due at once has committed, in this
-     * process or in any other one, so an idle dispatcher claims them without waiting for its next poll.
-     * A hint, never a guarantee: a report may be late, merged with others, or lost (while a connection
-     * is re-established, for instance), and polling still finds every delivery. Resolves with a function
-     * that stops listening, or with `undefined` when this store cannot listen. Optional.
-     */
-    watchNewDeliveries?(listener: () => void): Promise<(() => Promise<void>) | undefined>;
-    /** Releases connections the store opened itself; forced once `options.signal` aborts. */
-    close?(options?: CloseOptions): Promise<void>;
-}
-
 /**
  * RFC 9562 UUID version 7: 48-bit Unix millisecond timestamp followed by random
  * bits. Time-ordered, so it keeps B-tree indexes compact, and globally unique,
@@ -915,69 +585,6 @@ interface RelayBusLogger {
     error(message: string): void;
 }
 
-/** Where an incoming message came from, for observers and traces. */
-interface TransportMessage {
-    /** Topic, routing key or queue the message arrived on. */
-    readonly destination: string;
-}
-/** A message the transport could not turn into an event, so it never reaches the bus. */
-interface InvalidTransportMessage {
-    /** Topic, routing key or queue the message arrived on. */
-    readonly destination: string;
-    /** What the codec or decoder threw. */
-    readonly error: unknown;
-}
-/**
- * What the bus offers a transport at `subscribe`, beyond the message handler. Present only when
- * an observer implements the matching hook, so a transport can skip the work otherwise.
- */
-interface TransportSubscriptionHooks {
-    /**
-     * Call once for each inbound message the transport rejected as undecodable (dead-lettered or
-     * skipped) before it reached `onMessage`. Messages the bus rejected itself are reported by
-     * `onReceiveFinished` and must not be reported here. Never throws.
-     */
-    readonly onInvalidMessage: (message: InvalidTransportMessage) => void;
-}
-/**
- * Receives an event from a broker. Resolve only after it is durably stored. Transports pass
- * `message` to tell where the event arrived; it is optional for transports written before it.
- */
-type TransportMessageHandler = (envelope: EventEnvelope, message?: TransportMessage) => Promise<void>;
-/**
- * Broker port used to exchange events between services.
- *
- * Outbound: the bus calls `publish` from a delivery, so a broker outage only
- * delays events; the outbox keeps them. `publish` must resolve only after the
- * broker acknowledged the message.
- *
- * Inbound: `subscribe` must acknowledge a message only after `onMessage`
- * resolved, and redeliver it when `onMessage` rejects (at-least-once).
- */
-interface Transport {
-    /** Unique name referenced by routes and subscriptions. */
-    readonly name: string;
-    /**
-     * The messaging system, as OpenTelemetry names it (`kafka`, `rabbitmq`), reported to observers
-     * and traces. Default: the transport's name.
-     */
-    readonly system?: string;
-    connect?(): Promise<void>;
-    publish(envelope: EventEnvelope, destination: string): Promise<void>;
-    subscribe?(destinations: readonly string[], onMessage: TransportMessageHandler, hooks?: TransportSubscriptionHooks): Promise<void>;
-    /**
-     * Whether the transport can currently publish and, when subscribed, is
-     * consuming. Health checks use it to report a dead consumer or a lost
-     * connection. Transports without it count as ready.
-     */
-    isReady?(): boolean;
-    /**
-     * Releases connections. A closed transport is not reopened. Once `options.signal` aborts (the
-     * shutdown deadline passed), stop waiting and drop the connections it opened itself.
-     */
-    close(options?: CloseOptions): Promise<void>;
-}
-
 /**
  * - `required`: `publish` throws {@link TransactionRequiredError} when it finds no transaction.
  * - `optional`: `publish` opens its own transaction instead. The event is still durable,
@@ -1152,6 +759,85 @@ interface PublishOneOptions<TTransaction = unknown> extends PublishOptions<TTran
 }
 type ReceiveStatus = 'accepted' | 'duplicate' | 'ignored';
 
+/** The publishing half of a bus, which a {@link CatalogPublisher} delegates to. */
+interface PublishTarget<TTransaction> {
+    publish<TPayload>(event: DomainEvent<TPayload>, options?: PublishOneOptions<TTransaction>): Promise<EventEnvelope<TPayload>>;
+    publishAll(events: readonly DomainEvent[], options?: PublishOptions<TTransaction>): Promise<EventEnvelope[]>;
+}
+/**
+ * A view of a bus that publishes only the events of one catalog, or only the
+ * events a service produces from it. Obtain it with `bus.forCatalog(catalog)`
+ * or `bus.forCatalog(catalog, { events: ['OrderPlaced'] })`. Publishing an
+ * event outside the view fails to compile; a mistyped event that gets past the
+ * compiler (a cast, plain JavaScript, or a class with a structurally identical
+ * payload) is rejected with a {@link ConfigurationError} before anything is stored.
+ *
+ * ```ts
+ * const orders = bus.forCatalog(OrderEvents);
+ * await orders.publish(new OrderPlaced({ orderId }));
+ * await orders.publish(new UserRegistered({ userId })); // compile error
+ * ```
+ */
+declare class CatalogPublisher<TCatalog extends Catalog, TTransaction = unknown, TName extends keyof TCatalog = keyof TCatalog> {
+    #private;
+    /**
+     * Throws {@link ConfigurationError} when `catalog` was not created with
+     * `defineCatalog` or `options.events` names no event, an unknown event or
+     * the same event twice.
+     */
+    constructor(catalog: TCatalog, target: PublishTarget<TTransaction>, options?: CatalogEventSelection<TName>);
+    /** Same as `bus.publish`, limited to the events of the view. */
+    publish<TEvent extends CatalogEvents<TCatalog, TName>>(event: TEvent, options?: PublishOneOptions<TTransaction>): Promise<EventEnvelope<TEvent['payload']>>;
+    /** Same as `bus.publishAll`, limited to the events of the view. Nothing is stored unless every event belongs to it. */
+    publishAll(events: readonly CatalogEvents<TCatalog, TName>[], options?: PublishOptions<TTransaction>): Promise<EventEnvelope[]>;
+}
+
+/** Transaction handle of {@link InMemoryEventStore}. Writes apply on commit only. */
+declare class InMemoryTransaction {
+    #private;
+    get state(): 'open' | 'committed' | 'rolled-back';
+    enqueue(operation: () => void): void;
+    /** Runs `finisher` once the transaction commits or rolls back, like a lock release. */
+    onFinish(finisher: () => void): void;
+    commit(): void;
+    rollback(): void;
+}
+
+interface InMemoryEventStoreOptions {
+    /** Allow use when `NODE_ENV` is `production`. Data is lost on restart. Default false. */
+    readonly allowInProduction?: boolean;
+    readonly generateIdentifier?: IdentifierGenerator;
+    /**
+     * Keep a record of completed deliveries (status `completed`, listed, counted
+     * and purged by `retention.completed`). Default false: a completed delivery
+     * is deleted, like in the database stores.
+     */
+    readonly retainCompleted?: boolean;
+}
+/**
+ * Event store kept in process memory, with the same semantics as the database
+ * stores: transactional appends, leases, fencing and per-key ordering. Payloads
+ * are round-tripped through JSON exactly like a database would store them.
+ * Meant for tests and local development.
+ */
+declare class InMemoryEventStore implements EventStore<InMemoryTransaction> {
+    #private;
+    constructor(options?: InMemoryEventStoreOptions);
+    transaction<T>(work: (transaction: InMemoryTransaction) => Promise<T>): Promise<T>;
+    append(transaction: InMemoryTransaction, entries: readonly AppendEntry[], now: Date): Promise<AppendResult>;
+    claim(request: ClaimRequest): Promise<ClaimedDelivery[]>;
+    extendLease(lease: LeaseReference, leaseExpiresAt: Date, now: Date): Promise<boolean>;
+    complete(lease: LeaseReference, now: Date, transaction?: InMemoryTransaction): Promise<boolean>;
+    completeMany(leases: readonly LeaseReference[], now: Date): Promise<boolean[]>;
+    reschedule(lease: LeaseReference, availableAt: Date, error: ErrorInfo, now: Date): Promise<boolean>;
+    release(lease: LeaseReference, now: Date): Promise<boolean>;
+    bury(lease: LeaseReference, error: ErrorInfo, now: Date): Promise<boolean>;
+    listDeliveries(query: DeliveryQuery): Promise<DeliveryRecord[]>;
+    requeue(deliveryIds: readonly string[], now: Date): Promise<number>;
+    purge(request: PurgeRequest): Promise<PurgeResult>;
+    statistics(now: Date): Promise<EventStoreStatistics>;
+}
+
 interface StopOptions {
     /**
      * Longest the whole `stop` may take. Default: `dispatcher.shutdownTimeout`. Keep it below the time
@@ -1286,83 +972,4 @@ declare class RelayBus<TTransaction = unknown> {
     purgeExpired(): Promise<PurgeResult>;
 }
 
-/** The publishing half of a bus, which a {@link CatalogPublisher} delegates to. */
-interface PublishTarget<TTransaction> {
-    publish<TPayload>(event: DomainEvent<TPayload>, options?: PublishOneOptions<TTransaction>): Promise<EventEnvelope<TPayload>>;
-    publishAll(events: readonly DomainEvent[], options?: PublishOptions<TTransaction>): Promise<EventEnvelope[]>;
-}
-/**
- * A view of a bus that publishes only the events of one catalog, or only the
- * events a service produces from it. Obtain it with `bus.forCatalog(catalog)`
- * or `bus.forCatalog(catalog, { events: ['OrderPlaced'] })`. Publishing an
- * event outside the view fails to compile; a mistyped event that gets past the
- * compiler (a cast, plain JavaScript, or a class with a structurally identical
- * payload) is rejected with a {@link ConfigurationError} before anything is stored.
- *
- * ```ts
- * const orders = bus.forCatalog(OrderEvents);
- * await orders.publish(new OrderPlaced({ orderId }));
- * await orders.publish(new UserRegistered({ userId })); // compile error
- * ```
- */
-declare class CatalogPublisher<TCatalog extends Catalog, TTransaction = unknown, TName extends keyof TCatalog = keyof TCatalog> {
-    #private;
-    /**
-     * Throws {@link ConfigurationError} when `catalog` was not created with
-     * `defineCatalog` or `options.events` names no event, an unknown event or
-     * the same event twice.
-     */
-    constructor(catalog: TCatalog, target: PublishTarget<TTransaction>, options?: CatalogEventSelection<TName>);
-    /** Same as `bus.publish`, limited to the events of the view. */
-    publish<TEvent extends CatalogEvents<TCatalog, TName>>(event: TEvent, options?: PublishOneOptions<TTransaction>): Promise<EventEnvelope<TEvent['payload']>>;
-    /** Same as `bus.publishAll`, limited to the events of the view. Nothing is stored unless every event belongs to it. */
-    publishAll(events: readonly CatalogEvents<TCatalog, TName>[], options?: PublishOptions<TTransaction>): Promise<EventEnvelope[]>;
-}
-
-/** Transaction handle of {@link InMemoryEventStore}. Writes apply on commit only. */
-declare class InMemoryTransaction {
-    #private;
-    get state(): 'open' | 'committed' | 'rolled-back';
-    enqueue(operation: () => void): void;
-    /** Runs `finisher` once the transaction commits or rolls back, like a lock release. */
-    onFinish(finisher: () => void): void;
-    commit(): void;
-    rollback(): void;
-}
-
-interface InMemoryEventStoreOptions {
-    /** Allow use when `NODE_ENV` is `production`. Data is lost on restart. Default false. */
-    readonly allowInProduction?: boolean;
-    readonly generateIdentifier?: IdentifierGenerator;
-    /**
-     * Keep a record of completed deliveries (status `completed`, listed, counted
-     * and purged by `retention.completed`). Default false: a completed delivery
-     * is deleted, like in the database stores.
-     */
-    readonly retainCompleted?: boolean;
-}
-/**
- * Event store kept in process memory, with the same semantics as the database
- * stores: transactional appends, leases, fencing and per-key ordering. Payloads
- * are round-tripped through JSON exactly like a database would store them.
- * Meant for tests and local development.
- */
-declare class InMemoryEventStore implements EventStore<InMemoryTransaction> {
-    #private;
-    constructor(options?: InMemoryEventStoreOptions);
-    transaction<T>(work: (transaction: InMemoryTransaction) => Promise<T>): Promise<T>;
-    append(transaction: InMemoryTransaction, entries: readonly AppendEntry[], now: Date): Promise<AppendResult>;
-    claim(request: ClaimRequest): Promise<ClaimedDelivery[]>;
-    extendLease(lease: LeaseReference, leaseExpiresAt: Date, now: Date): Promise<boolean>;
-    complete(lease: LeaseReference, now: Date, transaction?: InMemoryTransaction): Promise<boolean>;
-    completeMany(leases: readonly LeaseReference[], now: Date): Promise<boolean[]>;
-    reschedule(lease: LeaseReference, availableAt: Date, error: ErrorInfo, now: Date): Promise<boolean>;
-    release(lease: LeaseReference, now: Date): Promise<boolean>;
-    bury(lease: LeaseReference, error: ErrorInfo, now: Date): Promise<boolean>;
-    listDeliveries(query: DeliveryQuery): Promise<DeliveryRecord[]>;
-    requeue(deliveryIds: readonly string[], now: Date): Promise<number>;
-    purge(request: PurgeRequest): Promise<PurgeResult>;
-    statistics(now: Date): Promise<EventStoreStatistics>;
-}
-
-export { type AppendEntry, type AppendResult, AttemptsExhaustedError, type BacklogEvent, type Catalog, type CatalogDeclaration, type CatalogDescription, type CatalogEntry, type CatalogEventClass, type CatalogEventName, type CatalogEventSelection, type CatalogEvents, CatalogPublisher, type CatalogRole, type ClaimFinishedEvent, type ClaimRequest, type ClaimedDelivery, Clock, type CloseOptions, ConfigurationError, DEFAULT_RETRY_POLICY, DEFAULT_ROUTE_RETRY_POLICY, DELIVERY_STATUSES, type DefineCatalogOptions, type DeliveryKind, type DeliveryQuery, type DeliveryRecord, type DeliveryStatus, type DispatcherOptions, DispatcherStoppedError, DomainEvent, DrainIncompleteError, type Duration, type ErrorInfo, EventClass, EventEnvelope, type EventHandler, EventHeaders, type EventOf, EventReference, type EventStore, type EventStoreStatistics, type EventStoreTransactionOptions, EventValidationError, type FailureStage, type HandlerContext, type HandlerDescriptor, type HandlerFinishedEvent, type HandlerShapeOf, type HandlerStartedEvent, HandlerTimeoutError, type HandlersOf, type IdentifierGenerator, InMemoryEventStore, type InMemoryEventStoreOptions, InMemoryTransaction, type InboundSubscriptionOptions, InvalidEnvelopeError, type InvalidMessageEvent, type InvalidTransportMessage, type JitterStrategy, LeaseLostError, type LeaseReference, LifecycleError, MAX_TIMER_DELAY_MS, type MatchingHandlers, type NewDelivery, type NoExtraHandlers, NonRetryableError, type OperationOutcome, type PartialHandlersOf, PayloadOf, type ProcessTraceInput, type PublishFinishedEvent, type PublishOneOptions, type PublishOptions, type PublishTarget, type PublishTraceInput, type PurgeRequest, type PurgeResult, type ReceiveFinishedEvent, type ReceiveOutcome, type ReceiveStatus, RelayBus, RelayBusError, type RelayBusLogger, type RelayBusObserver, type RelayBusOptions, type RelayBusTracer, type RetentionOptions, type RetryPolicy, type RetryPolicyOptions, type RouteOptions, type SendTraceInput, StandardSchemaV1, type StopOptions, type StopResult, type SubscribeCatalogOptions, type SubscribeOptions, TRACEPARENT_HEADER, TRACESTATE_HEADER, type TraceContext, type TransactionMode, TransactionRequiredError, TransactionTimeoutError, type Transport, type TransportMessage, type TransportMessageHandler, type TransportSentEvent, type TransportSubscriptionHooks, type UnroutedEventPolicy, type ValidationIssue, computeRetryDelay, consume, createRetryPolicy, createUuidV7, defineCatalog, defineHandlers, describeCatalog, isRetryableError, produce, toErrorInfo, toMilliseconds, traceContextOf };
+export { AppendEntry, AppendResult, type BacklogEvent, type Catalog, type CatalogDeclaration, type CatalogDescription, type CatalogEntry, type CatalogEventClass, type CatalogEventName, type CatalogEventSelection, type CatalogEvents, CatalogPublisher, type CatalogRole, type ClaimFinishedEvent, ClaimRequest, ClaimedDelivery, Clock, DEFAULT_RETRY_POLICY, DEFAULT_ROUTE_RETRY_POLICY, type DefineCatalogOptions, type DeliveryKind, DeliveryQuery, DeliveryRecord, type DispatcherOptions, DomainEvent, Duration, ErrorInfo, EventClass, EventEnvelope, type EventHandler, EventHeaders, type EventOf, EventReference, EventStore, EventStoreStatistics, type FailureStage, type HandlerContext, type HandlerDescriptor, type HandlerFinishedEvent, type HandlerShapeOf, type HandlerStartedEvent, type HandlersOf, type IdentifierGenerator, InMemoryEventStore, type InMemoryEventStoreOptions, InMemoryTransaction, type InboundSubscriptionOptions, type InvalidMessageEvent, type JitterStrategy, LeaseReference, type MatchingHandlers, type NoExtraHandlers, type OperationOutcome, type PartialHandlersOf, PayloadOf, type ProcessTraceInput, type PublishFinishedEvent, type PublishOneOptions, type PublishOptions, type PublishTarget, type PublishTraceInput, PurgeRequest, PurgeResult, type ReceiveFinishedEvent, type ReceiveOutcome, type ReceiveStatus, RelayBus, type RelayBusLogger, type RelayBusObserver, type RelayBusOptions, type RelayBusTracer, type RetentionOptions, type RetryPolicy, type RetryPolicyOptions, type RouteOptions, type SendTraceInput, StandardSchemaV1, type StopOptions, type StopResult, type SubscribeCatalogOptions, type SubscribeOptions, TRACEPARENT_HEADER, TRACESTATE_HEADER, type TraceContext, type TransactionMode, Transport, type TransportSentEvent, type UnroutedEventPolicy, computeRetryDelay, consume, createRetryPolicy, createUuidV7, defineCatalog, defineHandlers, describeCatalog, isRetryableError, produce, traceContextOf };