@procedures/client 0.47.2 → 0.48.0

package/src/client/errors/http-status.ts

@@ -1,82 +1,85 @@
 /**
  * HTTP Status Code Constants
  *
- * Comprehensive enum of HTTP status codes.
+ * All HTTP status codes.
  * NO MAGIC NUMBERS - use these constants everywhere!
  */
 
-export enum HTTPStatus {
+export const HTTPStatus = {
   // 1xx Informational
-  CONTINUE = 100,
-  SWITCHING_PROTOCOLS = 101,
-  PROCESSING = 102,
-  EARLY_HINTS = 103,
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
 
   // 2xx Success
-  OK = 200,
-  CREATED = 201,
-  ACCEPTED = 202,
-  NON_AUTHORITATIVE_INFORMATION = 203,
-  NO_CONTENT = 204,
-  RESET_CONTENT = 205,
-  PARTIAL_CONTENT = 206,
-  MULTI_STATUS = 207,
-  ALREADY_REPORTED = 208,
-  IM_USED = 226,
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
 
   // 3xx Redirection
-  MULTIPLE_CHOICES = 300,
-  MOVED_PERMANENTLY = 301,
-  FOUND = 302,
-  SEE_OTHER = 303,
-  NOT_MODIFIED = 304,
-  USE_PROXY = 305,
-  TEMPORARY_REDIRECT = 307,
-  PERMANENT_REDIRECT = 308,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
 
   // 4xx Client Errors
-  BAD_REQUEST = 400,
-  UNAUTHORIZED = 401,
-  PAYMENT_REQUIRED = 402,
-  FORBIDDEN = 403,
-  NOT_FOUND = 404,
-  METHOD_NOT_ALLOWED = 405,
-  NOT_ACCEPTABLE = 406,
-  PROXY_AUTHENTICATION_REQUIRED = 407,
-  REQUEST_TIMEOUT = 408,
-  CONFLICT = 409,
-  GONE = 410,
-  LENGTH_REQUIRED = 411,
-  PRECONDITION_FAILED = 412,
-  PAYLOAD_TOO_LARGE = 413,
-  URI_TOO_LONG = 414,
-  UNSUPPORTED_MEDIA_TYPE = 415,
-  RANGE_NOT_SATISFIABLE = 416,
-  EXPECTATION_FAILED = 417,
-  IM_A_TEAPOT = 418,
-  MISDIRECTED_REQUEST = 421,
-  UNPROCESSABLE_ENTITY = 422,
-  LOCKED = 423,
-  FAILED_DEPENDENCY = 424,
-  TOO_EARLY = 425,
-  UPGRADE_REQUIRED = 426,
-  PRECONDITION_REQUIRED = 428,
-  TOO_MANY_REQUESTS = 429,
-  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
-  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
-  CLIENT_CLOSED_REQUEST = 499, // nginx-specific
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  CLIENT_CLOSED_REQUEST: 499, // nginx-specific
 
   // 5xx Server Errors
-  INTERNAL_SERVER_ERROR = 500,
-  NOT_IMPLEMENTED = 501,
-  BAD_GATEWAY = 502,
-  SERVICE_UNAVAILABLE = 503,
-  GATEWAY_TIMEOUT = 504,
-  HTTP_VERSION_NOT_SUPPORTED = 505,
-  VARIANT_ALSO_NEGOTIATES = 506,
-  INSUFFICIENT_STORAGE = 507,
-  LOOP_DETECTED = 508,
-  NOT_EXTENDED = 510,
-  NETWORK_AUTHENTICATION_REQUIRED = 511,
-  NETWORK_CONNECT_TIMEOUT = 599, // non-standard
-}
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511,
+  NETWORK_CONNECT_TIMEOUT: 599, // non-standard
+} as const;
+
+/** This type is the union of the values of `HTTPStatus`. */
+export type HTTPStatus = (typeof HTTPStatus)[keyof typeof HTTPStatus];

package/src/client/errors/types.ts

@@ -8,39 +8,68 @@
 /**
  * Error severity levels.
  */
-export enum ErrorSeverity {
+export const ErrorSeverity = {
   /** Informational - not an actual error */
-  INFO = "info",
+  INFO: "info",
   /** Warning - degraded but functional */
-  WARNING = "warning",
+  WARNING: "warning",
   /** Error - operation failed */
-  ERROR = "error",
+  ERROR: "error",
   /** Critical - system-level failure */
-  CRITICAL = "critical",
+  CRITICAL: "critical",
+} as const;
+
+/** This type is the union of the values of `ErrorSeverity`. */
+export type ErrorSeverity = (typeof ErrorSeverity)[keyof typeof ErrorSeverity];
+
+/** These types keep each member of `ErrorSeverity` usable as a type. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace ErrorSeverity {
+  export type INFO = typeof ErrorSeverity.INFO;
+  export type WARNING = typeof ErrorSeverity.WARNING;
+  export type ERROR = typeof ErrorSeverity.ERROR;
+  export type CRITICAL = typeof ErrorSeverity.CRITICAL;
 }
 
 /**
  * Error categories for classification.
  */
-export enum ErrorCategory {
+export const ErrorCategory = {
   /** Network-level errors (connectivity, DNS, etc.) */
-  NETWORK = "network",
+  NETWORK: "network",
   /** Client-side errors (validation, configuration) */
-  CLIENT = "client",
+  CLIENT: "client",
   /** Server-side errors (5xx, internal errors) */
-  SERVER = "server",
+  SERVER: "server",
   /** Protocol-level errors (parsing, encoding) */
-  PROTOCOL = "protocol",
+  PROTOCOL: "protocol",
   /** Authentication/authorization errors */
-  AUTH = "auth",
+  AUTH: "auth",
   /** Rate limiting and throttling */
-  RATE_LIMIT = "rate_limit",
+  RATE_LIMIT: "rate_limit",
   /** Timeout errors */
-  TIMEOUT = "timeout",
+  TIMEOUT: "timeout",
   /** Cancellation errors */
-  CANCELLED = "cancelled",
+  CANCELLED: "cancelled",
   /** Unknown/uncategorized errors */
-  UNKNOWN = "unknown",
+  UNKNOWN: "unknown",
+} as const;
+
+/** This type is the union of the values of `ErrorCategory`. */
+export type ErrorCategory = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+
+/** These types keep each member of `ErrorCategory` usable as a type. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace ErrorCategory {
+  export type NETWORK = typeof ErrorCategory.NETWORK;
+  export type CLIENT = typeof ErrorCategory.CLIENT;
+  export type SERVER = typeof ErrorCategory.SERVER;
+  export type PROTOCOL = typeof ErrorCategory.PROTOCOL;
+  export type AUTH = typeof ErrorCategory.AUTH;
+  export type RATE_LIMIT = typeof ErrorCategory.RATE_LIMIT;
+  export type TIMEOUT = typeof ErrorCategory.TIMEOUT;
+  export type CANCELLED = typeof ErrorCategory.CANCELLED;
+  export type UNKNOWN = typeof ErrorCategory.UNKNOWN;
 }
 
 /**

package/src/client/middleware/circuit-breaker.ts

@@ -116,13 +116,18 @@ export interface CircuitBreakerStats {
  * Circuit breaker error thrown when circuit is open.
  */
 export class CircuitBreakerError extends Error {
+  public readonly state: CircuitState;
+  public readonly lastError: Error | null;
+
   constructor(
-    public readonly state: CircuitState,
-    public readonly lastError: Error | null
+    state: CircuitState,
+    lastError: Error | null
   ) {
     super(
       `Circuit breaker is ${state}${lastError ? `: ${lastError.message}` : ""}`
     );
+    this.state = state;
+    this.lastError = lastError;
     this.name = "CircuitBreakerError";
   }
 }

package/src/client/middleware/lru.ts

@@ -8,6 +8,9 @@
  * `hashMap` of that package).
  */
 export class LruMap<K, V> {
+  private readonly capacity: number;
+  private readonly onEvict?: ((key: K, value: V) => void) | undefined;
+
   private readonly entries = new Map<K, V>();
 
   /**
@@ -15,9 +18,11 @@ export class LruMap<K, V> {
    * @param onEvict - Called for each key that a write removes to keep the capacity.
    */
   constructor(
-    private readonly capacity: number,
-    private readonly onEvict?: (key: K, value: V) => void
+    capacity: number,
+    onEvict?: (key: K, value: V) => void
   ) {
+    this.capacity = capacity;
+    this.onEvict = onEvict;
     if (!Number.isInteger(capacity) || capacity < 1) {
       throw new RangeError(`The capacity of an LRU map must be a positive whole number, not ${capacity}`);
     }

package/src/client/middleware/rate-limit.ts

@@ -89,11 +89,14 @@ export interface RateLimitStats {
  * Rate limit error thrown when limit exceeded.
  */
 export class RateLimitError extends Error {
+  public readonly stats: RateLimitStats;
+
   constructor(
     message: string,
-    public readonly stats: RateLimitStats
+    stats: RateLimitStats
   ) {
     super(message);
+    this.stats = stats;
     this.name = "RateLimitError";
   }
 }

package/src/client/middleware/resilience.ts

@@ -16,6 +16,7 @@
  * call goes to the server as `procedure-timeout` with each try (`client/deadline.ts`).
  */
 
+import { compose } from "@mark1russell7/collections/layers";
 import type { ClientMiddleware, ClientRunner, TypedClientMiddleware } from "../types.js";
 import type { CacheContext, CircuitBreakerContext, RateLimitContext, RetryContext, TimeoutContext } from "./contexts.js";
 import { createCacheMiddleware, type CacheOptions } from "./cache.js";
@@ -76,6 +77,6 @@ export function resilience(options: ResilienceOptions): TypedClientMiddleware<Re
     layers.push(createTimeoutMiddleware({ perAttempt: options.perAttempt, ...(message ? { message: `${message} (per-attempt)` } : {}) }) as ClientMiddleware);
   }
   const composed = <TReq, TRes>(next: ClientRunner<TReq, TRes>): ClientRunner<TReq, TRes> =>
-    layers.reduceRight<ClientRunner<TReq, TRes>>((inner, layer) => (layer as ClientMiddleware<TReq, TRes>)(inner), next);
+    compose(...(layers as ClientMiddleware<TReq, TRes>[]))(next);
   return composed as TypedClientMiddleware<ResilienceContext, {}>;
 }

package/src/client/route-resolver.ts

@@ -99,7 +99,11 @@ export interface RouteResolutionResult {
  * ```
  */
 export class RouteResolver {
-  constructor(private readonly registry: ProcedureRegistry) {}
+  private readonly registry: ProcedureRegistry;
+
+  constructor(registry: ProcedureRegistry) {
+    this.registry = registry;
+  }
 
   /**
    * Resolve a route structure to procedures.

package/src/client/types.ts

@@ -326,6 +326,9 @@ export type AccumulateContext<
  * Client error thrown when response has error status.
  */
 export class ClientError extends Error {
+  public readonly status: Extract<Status, { type: "error" }>;
+  public readonly responseId: string;
+
   /**
    * The metadata of the error response, for example `reason` of a `FORBIDDEN` error, or
    * `conflicts` of a `VERSION_CONFLICT` error (roadmap CLI-16). Empty when the response has none.
@@ -333,11 +336,13 @@ export class ClientError extends Error {
   public readonly metadata: Metadata;
 
   constructor(
-    public readonly status: Extract<Status, { type: "error" }>,
-    public readonly responseId: string,
+    status: Extract<Status, { type: "error" }>,
+    responseId: string,
     metadata: Metadata = {},
   ) {
     super(status.message);
+    this.status = status;
+    this.responseId = responseId;
     this.name = "ClientError";
     this.metadata = metadata;
   }

package/src/client/validation/types.ts

@@ -114,18 +114,25 @@ export type ValidationPhase = "input" | "output";
  * Error thrown when validation fails.
  */
 export class ValidationError extends Error {
+  /** Which phase of validation failed */
+  public readonly phase: ValidationPhase;
+  /** The underlying Zod error */
+  public readonly zodError: ZodErrorLike;
+  /** The method being called */
+  public readonly method: Method;
+
   override readonly name = "ValidationError";
 
   constructor(
     message: string,
-    /** Which phase of validation failed */
-    public readonly phase: ValidationPhase,
-    /** The underlying Zod error */
-    public readonly zodError: ZodErrorLike,
-    /** The method being called */
-    public readonly method: Method,
+    phase: ValidationPhase,
+    zodError: ZodErrorLike,
+    method: Method,
   ) {
     super(message);
+    this.phase = phase;
+    this.zodError = zodError;
+    this.method = method;
 
     // Maintain proper stack trace in V8 environments
     if (Error.captureStackTrace) {

package/src/events/bus.ts

@@ -11,6 +11,7 @@ import type {
   EventHandler,
   Unsubscribe,
   EventBusOptions,
+  EventFanOutOptions,
   EventListenOptions,
   EventWaitOptions,
 } from "./types.js";
@@ -34,6 +35,31 @@ function clearedError(channel: string): Error {
   return error;
 }
 
+/** The default of `fanOut.maxPending`. No bench chose it: a run of a slow channel can change it. */
+const DEFAULT_MAX_PENDING = 1024;
+
+/** The default of `fanOut.schedule`: a later task of the event loop. */
+function nextTask(slice: () => void): void {
+  if (typeof setImmediate === "function") setImmediate(slice);
+  else setTimeout(slice, 0);
+}
+
+/** The handlers of a channel, each with the number of its subscription, in the order of these numbers. */
+type ChannelHandlers = Map<EventHandler<unknown>, number>;
+
+/** One event that waits for its slices. */
+interface PendingEvent {
+  readonly channel: string;
+  readonly data: unknown;
+  /** The handlers of the channel at `emit()`. A new map of the channel gets no old event. */
+  readonly handlers: ChannelHandlers;
+  /** The live cursor: a removed handler gets no call, with no copy of the handlers per event. */
+  readonly cursor: Iterator<[EventHandler<unknown>, number]>;
+  /** The last subscription at `emit()`. A later handler does not get this event. */
+  readonly lastSubscription: number;
+  done: boolean;
+}
+
 // =============================================================================
 // Event Bus Implementation
 // =============================================================================
@@ -43,16 +69,34 @@ function clearedError(channel: string): Error {
  * Supports pub/sub messaging with async iteration.
  */
 export class DefaultEventBus implements EventBus {
-  private readonly subscribers = new Map<string, Set<EventHandler<unknown>>>();
+  private readonly subscribers = new Map<string, ChannelHandlers>();
+  /** The number of the last subscription of this bus. */
+  private lastSubscription = 0;
+  /** The events that wait for their slices, oldest first, from the index `pendingHead`. */
+  private pending: PendingEvent[] = [];
+  private pendingHead = 0;
+  /** For each channel, the number of its events in `pending`. */
+  private readonly pendingOn = new Map<string, number>();
+  private sliceScheduled = false;
+  private drainWaiters: Array<() => void> = [];
   private readonly buffer = new Map<string, unknown[]>();
   /**
    * For each channel, the functions that `clear()` runs: the `onClear` of each handler of `on()`
    * that has one. Each open stream has one too, so `clear()` ends it.
    */
   private readonly clearHandlers = new Map<string, Set<() => void>>();
-  private readonly options: Required<EventBusOptions>;
+  private readonly options: Required<Omit<EventBusOptions, "fanOut">>;
+  private readonly fanOut: Required<EventFanOutOptions> | undefined;
 
   constructor(options: EventBusOptions = {}) {
+    const { fanOut } = options;
+    if (fanOut && (!Number.isInteger(fanOut.sliceSize) || fanOut.sliceSize < 1)) {
+      throw new RangeError(`The option fanOut.sliceSize must be a whole number from 1 up, not ${fanOut.sliceSize}`);
+    }
+    if (fanOut?.maxPending !== undefined && (!Number.isInteger(fanOut.maxPending) || fanOut.maxPending < 1)) {
+      throw new RangeError(`The option fanOut.maxPending must be a whole number from 1 up, not ${fanOut.maxPending}`);
+    }
+    this.fanOut = fanOut && { maxPending: DEFAULT_MAX_PENDING, schedule: nextTask, ...fanOut };
     this.options = {
       bufferSize: options.bufferSize ?? 0,
       onError: options.onError ?? ((error, channel) => {
@@ -64,6 +108,12 @@ export class DefaultEventBus implements EventBus {
 
   /**
    * Emit an event on a channel.
+   *
+   * Without the option `fanOut`, each handler runs before this method returns. With it, a channel
+   * with more than `fanOut.sliceSize` handlers delivers later, in slices (roadmap CLI-90). One
+   * handler gets the events of a channel in the order of `emit()`. An unsubscribe stops the calls
+   * that wait for that handler. A handler that comes after `emit()` does not get the event. The
+   * events of two different channels can reach a handler in another order.
    */
   emit<T>(channel: string, data: T): void {
     if (this.options.debug) {
@@ -87,19 +137,104 @@ export class DefaultEventBus implements EventBus {
     const channelSubs = this.subscribers.get(channel);
     if (!channelSubs) return;
 
-    for (const handler of channelSubs) {
-      try {
-        const result = handler(data);
-        // Handle async handlers
-        if (result instanceof Promise) {
-          result.catch((error) => this.options.onError(error, channel));
-        }
-      } catch (error) {
-        this.options.onError(error instanceof Error ? error : new Error(String(error)), channel);
+    if (this.fanOut && (channelSubs.size > this.fanOut.sliceSize || this.pendingOn.has(channel))) {
+      this.enqueue(channel, data, channelSubs, this.fanOut);
+      return;
+    }
+
+    for (const handler of channelSubs.keys()) this.call(handler, data, channel);
+  }
+
+  /** This function calls one handler. An error goes to `onError`, and it stops no other handler. */
+  private call(handler: EventHandler<unknown>, data: unknown, channel: string): void {
+    try {
+      const result = handler(data);
+      // Handle async handlers
+      if (result instanceof Promise) {
+        result.catch((error) => this.options.onError(error, channel));
+      }
+    } catch (error) {
+      this.options.onError(error instanceof Error ? error : new Error(String(error)), channel);
+    }
+  }
+
+  /** This function puts an event in the queue of the slices. A full queue finishes its oldest events. */
+  private enqueue(channel: string, data: unknown, handlers: ChannelHandlers, fanOut: Required<EventFanOutOptions>): void {
+    this.pending.push({ channel, data, handlers, cursor: handlers.entries(), lastSubscription: this.lastSubscription, done: false });
+    this.pendingOn.set(channel, (this.pendingOn.get(channel) ?? 0) + 1);
+    while (this.pending.length - this.pendingHead > fanOut.maxPending) {
+      const oldest = this.pending[this.pendingHead]!;
+      this.deliverPart(oldest, Number.POSITIVE_INFINITY);
+      this.retire(oldest);
+    }
+    this.scheduleSlice(fanOut);
+  }
+
+  private scheduleSlice(fanOut: Required<EventFanOutOptions>): void {
+    if (this.sliceScheduled || this.pendingHead === this.pending.length) return;
+    this.sliceScheduled = true;
+    fanOut.schedule(() => {
+      this.sliceScheduled = false;
+      this.deliver(fanOut.sliceSize);
+      this.scheduleSlice(fanOut);
+    });
+  }
+
+  /** This function calls at most `limit` handlers of the oldest events. */
+  private deliver(limit: number): void {
+    let left = limit;
+    while (left > 0 && this.pendingHead < this.pending.length) {
+      const event = this.pending[this.pendingHead]!;
+      left -= this.deliverPart(event, left);
+      if (event.done) this.retire(event);
+    }
+    if (this.pendingHead === this.pending.length) this.drainWaiters.splice(0).forEach((resolve) => resolve());
+  }
+
+  /** This function calls at most `limit` handlers of one event, and returns the count of calls. */
+  private deliverPart(event: PendingEvent, limit: number): number {
+    let calls = 0;
+    while (calls < limit && !event.done) {
+      // clear(), or the last unsubscribe: the map of this event is not the map of the channel now
+      const step = this.subscribers.get(event.channel) === event.handlers ? event.cursor.next() : undefined;
+      if (!step || step.done || step.value[1] > event.lastSubscription) {
+        event.done = true;
+        break;
       }
+      this.call(step.value[0], event.data, event.channel);
+      calls++;
+    }
+    return calls;
+  }
+
+  /**
+   * This function takes a finished event from the queue. A handler in a slice can emit, and that
+   * emit can finish the event first, so this function examines the head.
+   */
+  private retire(event: PendingEvent): void {
+    if (this.pending[this.pendingHead] !== event) return;
+    this.pendingHead++;
+    const left = (this.pendingOn.get(event.channel) ?? 1) - 1;
+    if (left === 0) this.pendingOn.delete(event.channel);
+    else this.pendingOn.set(event.channel, left);
+    if (this.pendingHead === this.pending.length) {
+      this.pending = [];
+      this.pendingHead = 0;
+    } else if (this.pendingHead > 1024 && this.pendingHead * 2 > this.pending.length) {
+      this.pending = this.pending.slice(this.pendingHead);
+      this.pendingHead = 0;
     }
   }
 
+  /**
+   * This method resolves when no event waits for a slice. A host calls it before it stops. Without
+   * the option `fanOut`, it resolves at once.
+   */
+  drained(): Promise<void> {
+    if (this.pendingHead === this.pending.length) return Promise.resolve();
+    return new Promise((resolve) => this.drainWaiters.push(resolve));
+  }
+
   /**
    * Subscribe to events on a channel. The `onClear` of the options runs one time when `clear()`
    * or `clearAll()` removes the handler, not at an unsubscribe.
@@ -111,11 +246,14 @@ export class DefaultEventBus implements EventBus {
 
     let channelSubs = this.subscribers.get(channel);
     if (!channelSubs) {
-      channelSubs = new Set();
+      channelSubs = new Map();
       this.subscribers.set(channel, channelSubs);
     }
 
-    channelSubs.add(handler as EventHandler<unknown>);
+    // A handler that is already on the channel keeps its place and its number
+    if (!channelSubs.has(handler as EventHandler<unknown>)) {
+      channelSubs.set(handler as EventHandler<unknown>, ++this.lastSubscription);
+    }
 
     // The unsubscribe function works once, and removes only the set it added to. (Before, a
     // repeated call of an old unsubscribe removed the set of a newer subscriber: deep dive CORE-15.)
@@ -144,16 +282,7 @@ export class DefaultEventBus implements EventBus {
     // Replay buffered events if any
     const buffered = this.buffer.get(channel);
     if (buffered && buffered.length > 0) {
-      for (const data of buffered) {
-        try {
-          const result = handler(data as T);
-          if (result instanceof Promise) {
-            result.catch((error) => this.options.onError(error, channel));
-          }
-        } catch (error) {
-          this.options.onError(error instanceof Error ? error : new Error(String(error)), channel);
-        }
-      }
+      for (const data of buffered) this.call(handler as EventHandler<unknown>, data, channel);
     }
 
     return () => {

package/src/events/index.ts

@@ -40,6 +40,7 @@ export type {
   ProcedureChannels,
   DefaultChannels,
   EventBusOptions,
+  EventFanOutOptions,
   EventListenOptions,
   EventWaitOptions,
 } from "./types.js";