@zudojs/events 0.0.1 → 1.0.0

package/dist/eventBus/eventBus.registration.js

@@ -1,7 +1,7 @@
 /**
  * Event bus registration and subscription methods for Zudojs.
  */
-import { createEventMiddlewareId, isFunctionEventMiddleware, isObjectEventMiddleware, } from "../eventMiddleware/eventMiddleware.helper.js";
+import { createEventMiddleware, isEventMiddleware, } from "../eventMiddleware/eventMiddleware.helper.js";
 /**
  * Registers an event definition on the given registry.
  */
@@ -39,17 +39,12 @@ export function busOff(emitter, subscription, ensureNotDisposed) {
     return emitter.off(subscription);
 }
 /**
- * Adds middleware to the bus.
+ * Adds middleware to the bus. The middleware is validated
+ * eagerly (invalid middleware or a non-finite priority throw
+ * here, not on the next publish).
  */
 export function busUse(busMiddleware, middleware, options = {}) {
-    const id = options.id ?? createEventMiddlewareId();
-    const registered = {
-        id,
-        description: options.description,
-        priority: options.priority ?? 0,
-        enabled: options.enabled ?? true,
-        middleware,
-    };
+    const registered = createEventMiddleware(middleware, options);
     busMiddleware.push(registered);
     return () => {
         const idx = busMiddleware.indexOf(registered);
@@ -58,27 +53,35 @@ export function busUse(busMiddleware, middleware, options = {}) {
         }
     };
 }
+/**
+ * Determines whether a value is an already registered middleware
+ * (created by createEventMiddleware or a builder helper).
+ */
+export function isRegisteredEventMiddleware(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.id === "string" &&
+        typeof value.enabled === "boolean" &&
+        isEventMiddleware(value.middleware));
+}
 /**
  * Normalizes a middleware item into a RegisteredEventMiddleware.
+ *
+ * `prefix` keeps generated ids stable per source ("bus-mw" for
+ * constructor middleware, "publish-mw" for per-publication
+ * middleware).
  */
-export function registerMiddlewareItem(item, index) {
-    const id = `bus-mw-${index}`;
-    if (isFunctionEventMiddleware(item)) {
-        return {
-            id,
-            priority: 0,
-            enabled: true,
-            middleware: item,
-        };
-    }
-    if (isObjectEventMiddleware(item)) {
-        return {
-            id,
-            priority: 0,
-            enabled: true,
-            middleware: item,
-        };
+export function registerMiddlewareItem(item, index, prefix = "bus-mw") {
+    if (isRegisteredEventMiddleware(item)) {
+        return createEventMiddleware(item.middleware, {
+            id: item.id,
+            description: item.description,
+            priority: item.priority,
+            enabled: item.enabled,
+        });
     }
-    return item;
+    return createEventMiddleware(item, {
+        id: `${prefix}-${index}`,
+    });
 }
 //# sourceMappingURL=eventBus.registration.js.map

package/dist/eventBus/eventBus.type.d.ts

@@ -3,33 +3,96 @@
  */
 import type { Event } from "../eventTypes/eventDefinition.type.js";
 import type { EventEmitterMode, EventErrorMode } from "../eventEmitter/eventEmitter.type.js";
-import type { EventMiddlewareLike } from "../eventMiddleware/eventMiddleware.type.js";
+import type { EventMiddlewareLike, RegisteredEventMiddleware } from "../eventMiddleware/eventMiddleware.type.js";
+import type { DuplicateHandlerIdPolicy, EventRegistryWarning } from "../eventRegistry/eventRegistry.type.js";
+/**
+ * Middleware accepted by bus options: a plain middleware function
+ * or object, or a registered middleware created with
+ * createEventMiddleware() / the builder helpers.
+ */
+export type EventBusMiddlewareItem = EventMiddlewareLike | RegisteredEventMiddleware;
+/**
+ * Context passed to the bus `onError` hook.
+ */
+export interface EventBusErrorContext {
+    /**
+     * "handler"  → a handler failed during a CONTINUE-mode publish
+     * "observer" → a bus lifecycle observer threw
+     */
+    readonly source: "handler" | "observer";
+    readonly event?: Event;
+}
 export interface EventBusOptions {
     readonly emitter?: {
         readonly mode?: EventEmitterMode;
         readonly errorMode?: EventErrorMode;
+        /**
+         * Deep-freeze events (payload included) before dispatch.
+         * Defaults to true.
+         */
         readonly freezeEvents?: boolean;
+        /**
+         * Maximum handlers per event pattern before a leak warning is
+         * emitted (0 disables). Defaults to 100.
+         */
+        readonly maxListeners?: number;
     };
     readonly registry?: {
         readonly allowDuplicateDefinitions?: boolean;
+        /**
+         * @deprecated Use `onDuplicateHandlerId: "replace"`.
+         */
         readonly allowDuplicateHandlerIds?: boolean;
+        readonly onDuplicateHandlerId?: DuplicateHandlerIdPolicy;
     };
+    /**
+     * Reject publishes for event types that were not registered
+     * with register(). Defaults to false.
+     */
     readonly requireRegistration?: boolean;
-    readonly middleware?: readonly EventMiddlewareLike[];
+    readonly middleware?: readonly EventBusMiddlewareItem[];
+    /**
+     * Receives leak warnings. Defaults to console.warn.
+     */
+    readonly onWarning?: (warning: EventRegistryWarning) => void;
+    /**
+     * Receives handler errors from CONTINUE-mode publishes and
+     * errors thrown by bus/registry observers. Useful for
+     * fire-and-forget publishes whose result is never inspected.
+     */
+    readonly onError?: (error: unknown, context: EventBusErrorContext) => void;
 }
 export interface PublishOptions {
     readonly mode?: EventEmitterMode;
     readonly errorMode?: EventErrorMode;
     readonly signal?: AbortSignal;
     readonly metadata?: Readonly<Record<string, unknown>>;
-    readonly middleware?: readonly EventMiddlewareLike[];
+    readonly middleware?: readonly EventBusMiddlewareItem[];
 }
 export interface EventPublishResult<TEvent extends Event = Event> {
     readonly event: TEvent;
+    /**
+     * True when at least one handler completed successfully.
+     */
     readonly handled: boolean;
+    /**
+     * Number of handlers invoked.
+     */
     readonly handlerCount: number;
+    /**
+     * Number of handlers that completed successfully.
+     */
+    readonly succeeded: number;
+    /**
+     * Number of handlers that threw.
+     */
+    readonly failed: number;
     readonly results: readonly unknown[];
     readonly errors: readonly unknown[];
+    /**
+     * True when a middleware did not call next(), so no handler ran.
+     */
+    readonly shortCircuited: boolean;
     readonly middlewareExecutions?: readonly {
         readonly middlewareId: string;
         readonly result: unknown;
@@ -37,8 +100,17 @@ export interface EventPublishResult<TEvent extends Event = Event> {
     }[];
 }
 export declare enum EventBusState {
+    /**
+     * Created, never started. The first publish/subscribe starts
+     * the bus automatically.
+     */
     CREATED = "created",
     ACTIVE = "active",
+    /**
+     * Stopped with stop(). Publishing and subscribing throw
+     * EventBusStoppedError until start() is called again.
+     */
+    STOPPED = "stopped",
     DISPOSED = "disposed"
 }
 export interface EventBusEvent {

package/dist/eventBus/eventBus.type.js

@@ -3,8 +3,17 @@
  */
 export var EventBusState;
 (function (EventBusState) {
+    /**
+     * Created, never started. The first publish/subscribe starts
+     * the bus automatically.
+     */
     EventBusState["CREATED"] = "created";
     EventBusState["ACTIVE"] = "active";
+    /**
+     * Stopped with stop(). Publishing and subscribing throw
+     * EventBusStoppedError until start() is called again.
+     */
+    EventBusState["STOPPED"] = "stopped";
     EventBusState["DISPOSED"] = "disposed";
 })(EventBusState || (EventBusState = {}));
 //# sourceMappingURL=eventBus.type.js.map

package/dist/eventBus/index.d.ts

@@ -6,4 +6,6 @@
 export * from "./eventBus.type.js";
 export * from "./eventBus.core.js";
 export * from "./eventBus.factory.js";
+export { isRegisteredEventMiddleware } from "./eventBus.registration.js";
+export { isEventEmitResult } from "./eventBus.publish.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/eventBus/index.js

@@ -6,4 +6,6 @@
 export * from "./eventBus.type.js";
 export * from "./eventBus.core.js";
 export * from "./eventBus.factory.js";
+export { isRegisteredEventMiddleware } from "./eventBus.registration.js";
+export { isEventEmitResult } from "./eventBus.publish.js";
 //# sourceMappingURL=index.js.map

package/dist/eventEmitter/eventEmitter.abort.d.ts

@@ -1,8 +1,17 @@
 /**
  * Event emitter abort error helper for Zudojs.
  */
+import type { Event } from "../eventTypes/eventDefinition.type.js";
+import { EventDispatchAbortedError } from "../eventErrors/eventError.base.js";
+import type { EventHandlerExecutionResult } from "./eventEmitter.type.js";
 /**
- * Creates an AbortError consistently across runtimes.
+ * Creates the error thrown when dispatch is aborted through an
+ * AbortSignal. Partial results and errors gathered before the
+ * abort are attached to the error.
  */
-export declare function createAbortError(): Error;
+export declare function createAbortError(event?: Event, results?: readonly EventHandlerExecutionResult[], errors?: readonly unknown[]): EventDispatchAbortedError;
+/**
+ * Determines whether an error represents an aborted dispatch.
+ */
+export declare function isAbortError(error: unknown): boolean;
 //# sourceMappingURL=eventEmitter.abort.d.ts.map

package/dist/eventEmitter/eventEmitter.abort.js

@@ -1,12 +1,27 @@
 /**
  * Event emitter abort error helper for Zudojs.
  */
+import { EventDispatchAbortedError } from "../eventErrors/eventError.base.js";
 /**
- * Creates an AbortError consistently across runtimes.
+ * Creates the error thrown when dispatch is aborted through an
+ * AbortSignal. Partial results and errors gathered before the
+ * abort are attached to the error.
  */
-export function createAbortError() {
-    const error = new Error("Event dispatch was aborted.");
-    error.name = "AbortError";
-    return error;
+export function createAbortError(event, results = [], errors = []) {
+    return new EventDispatchAbortedError("Event dispatch was aborted.", {
+        eventType: event?.type,
+        eventId: event?.id,
+        results,
+        errors,
+    });
+}
+/**
+ * Determines whether an error represents an aborted dispatch.
+ */
+export function isAbortError(error) {
+    return (error instanceof EventDispatchAbortedError ||
+        (typeof error === "object" &&
+            error !== null &&
+            error.name === "AbortError"));
 }
 //# sourceMappingURL=eventEmitter.abort.js.map

package/dist/eventEmitter/eventEmitter.core.d.ts

@@ -1,34 +1,45 @@
 /**
  * Event emitter core class for Zudojs.
+ *
+ * The emitter dispatches events to handlers. Handlers are stored
+ * in an EventHandlerStore (an EventRegistry by default) so that a
+ * bus and its registry share one set of handlers.
  */
 import type { Event, EventInput } from "../eventTypes/eventDefinition.type.js";
 import type { EventTypePattern } from "../eventTypes/eventType.type.js";
 import type { EventHandlerLike, EventHandlerOptions, RegisteredEventHandler } from "../eventHandler/eventHandler.core.js";
 import type { EventSubscription } from "../eventSubscription/eventSubscription.core.js";
 import { EventSubscriptionGroup } from "../eventSubscription/eventSubscription.core.js";
+import type { EventHandlerStore } from "../eventRegistry/eventRegistry.type.js";
 import type { EventEmitterOptions, EmitOptions, EventEmitResult } from "./eventEmitter.type.js";
 /**
  * Main local event emitter.
  */
 export declare class EventEmitter {
-    private readonly listeners;
+    private readonly store;
     private readonly options;
     private disposed;
     constructor(options?: EventEmitterOptions);
     on<TEvent extends Event = Event>(eventType: EventTypePattern, handler: EventHandlerLike<TEvent>, options?: Omit<EventHandlerOptions, "eventType">): EventSubscription;
     once<TEvent extends Event = Event>(eventType: EventTypePattern, handler: EventHandlerLike<TEvent>, options?: Omit<EventHandlerOptions, "eventType" | "once">): EventSubscription;
     onAny<TEvent extends Event = Event>(handler: EventHandlerLike<TEvent>, options?: Omit<EventHandlerOptions, "eventType">): EventSubscription;
+    /**
+     * Cancels a subscription. Returns true when the subscription
+     * was active (and is now cancelled).
+     */
     off(subscription: EventSubscription): boolean;
     emit<TEvent extends Event>(event: TEvent, options?: EmitOptions): Promise<EventEmitResult<TEvent>>;
     emitEvent<TPayload>(input: EventInput<TPayload>, options?: EmitOptions): Promise<EventEmitResult<Event<TPayload>>>;
     get listenerCount(): number;
+    /**
+     * Returns the handler store backing this emitter.
+     */
+    getStore(): EventHandlerStore;
     getRegistrations(): readonly RegisteredEventHandler[];
     removeAllListeners(): void;
     createSubscriptionGroup(): EventSubscriptionGroup;
     dispose(): void;
     isDisposed(): boolean;
-    private addRegistration;
-    private removeHandler;
     private ensureActive;
 }
 /**

package/dist/eventEmitter/eventEmitter.core.js

@@ -1,9 +1,16 @@
 /**
  * Event emitter core class for Zudojs.
+ *
+ * The emitter dispatches events to handlers. Handlers are stored
+ * in an EventHandlerStore (an EventRegistry by default) so that a
+ * bus and its registry share one set of handlers.
  */
-import { createEvent } from "../eventTypes/eventDefinition.type.js";
-import { createEventHandler, createEventHandlerContext, getMatchingEventHandlers, } from "../eventHandler/eventHandler.core.js";
-import { EventSubscriptionGroup, createEventSubscription, } from "../eventSubscription/eventSubscription.core.js";
+import { createEvent, isEvent } from "../eventTypes/eventDefinition.type.js";
+import { deepFreeze } from "../eventTypes/eventPayload.type.js";
+import { createEventHandlerContext } from "../eventHandler/eventHandler.core.js";
+import { EventSubscriptionGroup } from "../eventSubscription/eventSubscription.core.js";
+import { EventRegistry } from "../eventRegistry/eventRegistry.store.js";
+import { EventEmitterDisposedError, InvalidEventError, } from "../eventErrors/eventError.base.js";
 import { EventEmitterMode, EventErrorMode } from "./eventEmitter.type.js";
 import { emitSequential } from "./eventEmitter.sequential.js";
 import { emitParallel } from "./eventEmitter.parallel.js";
@@ -12,7 +19,7 @@ import { createAbortError } from "./eventEmitter.abort.js";
  * Main local event emitter.
  */
 export class EventEmitter {
-    listeners = new Map();
+    store;
     options;
     disposed = false;
     constructor(options = {}) {
@@ -21,14 +28,16 @@ export class EventEmitter {
             errorMode: options.errorMode ?? EventErrorMode.THROW,
             freezeEvents: options.freezeEvents ?? true,
         };
+        this.store =
+            options.store ??
+                new EventRegistry({
+                    maxHandlersPerPattern: options.maxListeners,
+                    onWarning: options.onWarning,
+                });
     }
     on(eventType, handler, options = {}) {
         this.ensureActive();
-        const registration = createEventHandler(handler, {
-            ...options,
-            eventType,
-        });
-        return this.addRegistration(registration);
+        return this.store.registerHandler(eventType, handler, options);
     }
     once(eventType, handler, options = {}) {
         return this.on(eventType, handler, {
@@ -39,48 +48,64 @@ export class EventEmitter {
     onAny(handler, options = {}) {
         return this.on("*", handler, options);
     }
+    /**
+     * Cancels a subscription. Returns true when the subscription
+     * was active (and is now cancelled).
+     */
     off(subscription) {
         this.ensureActive();
-        const removed = this.listeners.delete(subscription.id);
-        if (removed && subscription.active) {
-            subscription.unsubscribe();
-        }
-        return removed;
+        const wasActive = subscription.active;
+        subscription.unsubscribe();
+        return wasActive;
     }
     async emit(event, options = {}) {
         this.ensureActive();
+        if (!isEvent(event)) {
+            throw new InvalidEventError("emit() requires an Event (use emitEvent() for event input).");
+        }
         if (options.signal?.aborted) {
-            throw createAbortError();
+            throw createAbortError(event);
         }
         const mode = options.mode ?? this.options.mode;
         const errorMode = options.errorMode ?? this.options.errorMode;
-        const handlers = getMatchingEventHandlers(this.getRegistrations(), event);
-        const context = createEventHandlerContext(event, {
+        const dispatched = this.options.freezeEvents ? deepFreeze(event) : event;
+        const handlers = this.store.getHandlersForEvent(dispatched);
+        const context = createEventHandlerContext(dispatched, {
             signal: options.signal,
             metadata: options.metadata,
         });
+        const results = [];
+        const errors = [];
         if (handlers.length === 0) {
             return {
-                event,
+                event: dispatched,
                 handled: false,
-                results: [],
-                errors: [],
+                results,
+                errors,
+                succeeded: 0,
+                failed: 0,
             };
         }
-        const results = [];
-        const errors = [];
-        const removeOnceHandler = (handlerId) => this.removeHandler(handlerId);
+        const hooks = {
+            isRegistered: (handlerId) => this.store.hasHandler(handlerId),
+            removeOnce: (handlerId) => {
+                this.store.unregisterHandler(handlerId);
+            },
+        };
         if (mode === EventEmitterMode.PARALLEL) {
-            await emitParallel(handlers, event, context, errorMode, results, errors, removeOnceHandler);
+            await emitParallel(handlers, dispatched, context, errorMode, results, errors, hooks);
         }
         else {
-            await emitSequential(handlers, event, context, errorMode, results, errors, removeOnceHandler);
+            await emitSequential(handlers, dispatched, context, errorMode, results, errors, hooks);
         }
+        const succeeded = results.filter((result) => result.ok).length;
         return {
-            event,
-            handled: results.length > 0,
+            event: dispatched,
+            handled: succeeded > 0,
             results,
             errors,
+            succeeded,
+            failed: results.length - succeeded,
         };
     }
     async emitEvent(input, options = {}) {
@@ -88,18 +113,22 @@ export class EventEmitter {
         return this.emit(event, options);
     }
     get listenerCount() {
-        return this.listeners.size;
+        return this.store.handlerCount;
+    }
+    /**
+     * Returns the handler store backing this emitter.
+     */
+    getStore() {
+        return this.store;
     }
     getRegistrations() {
-        return [...this.listeners.values()].map(({ registration }) => registration);
+        return this.store.getHandlers();
     }
     removeAllListeners() {
         this.ensureActive();
-        const subscriptions = [...this.listeners.values()].map(({ subscription }) => subscription);
-        for (const subscription of subscriptions) {
-            subscription.unsubscribe();
+        for (const registration of this.store.getHandlers()) {
+            this.store.unregisterHandler(registration.id);
         }
-        this.listeners.clear();
     }
     createSubscriptionGroup() {
         this.ensureActive();
@@ -115,30 +144,9 @@ export class EventEmitter {
     isDisposed() {
         return this.disposed;
     }
-    addRegistration(registration) {
-        const subscription = createEventSubscription(() => {
-            this.listeners.delete(registration.id);
-        }, {
-            id: registration.id,
-            description: registration.description,
-        });
-        this.listeners.set(registration.id, {
-            registration,
-            subscription,
-        });
-        return subscription;
-    }
-    removeHandler(id) {
-        const listener = this.listeners.get(id);
-        if (!listener) {
-            return;
-        }
-        this.listeners.delete(id);
-        listener.subscription.unsubscribe();
-    }
     ensureActive() {
         if (this.disposed) {
-            throw new Error("EventEmitter has already been disposed.");
+            throw new EventEmitterDisposedError();
         }
     }
 }

package/dist/eventEmitter/eventEmitter.parallel.d.ts

@@ -1,12 +1,18 @@
 /**
  * Parallel event handler dispatch for Zudojs.
+ *
+ * All handlers start together; an AbortSignal that fires after
+ * the handlers have started cannot stop them. Handlers can observe
+ * `context.signal` to cooperate. Only a signal that is already
+ * aborted when dispatch begins rejects the emit.
  */
 import type { Event } from "../eventTypes/eventDefinition.type.js";
 import type { EventHandlerContext, RegisteredEventHandler } from "../eventHandler/eventHandler.core.js";
 import type { EventHandlerExecutionResult } from "./eventEmitter.type.js";
 import { EventErrorMode } from "./eventEmitter.type.js";
+import type { DispatchHooks } from "./eventEmitter.sequential.js";
 /**
  * Executes handlers concurrently.
  */
-export declare function emitParallel<TEvent extends Event>(handlers: readonly RegisteredEventHandler<TEvent>[], event: TEvent, context: EventHandlerContext<TEvent>, errorMode: EventErrorMode, results: EventHandlerExecutionResult[], errors: unknown[], onOnceHandler: (handlerId: string) => void): Promise<void>;
+export declare function emitParallel<TEvent extends Event>(handlers: readonly RegisteredEventHandler<TEvent>[], event: TEvent, context: EventHandlerContext<TEvent>, errorMode: EventErrorMode, results: EventHandlerExecutionResult[], errors: unknown[], hooks: DispatchHooks): Promise<void>;
 //# sourceMappingURL=eventEmitter.parallel.d.ts.map

package/dist/eventEmitter/eventEmitter.parallel.js

@@ -1,35 +1,53 @@
 /**
  * Parallel event handler dispatch for Zudojs.
+ *
+ * All handlers start together; an AbortSignal that fires after
+ * the handlers have started cannot stop them. Handlers can observe
+ * `context.signal` to cooperate. Only a signal that is already
+ * aborted when dispatch begins rejects the emit.
  */
-import { executeEventHandler } from "../eventHandler/eventHandler.core.js";
+import { executeRegisteredEventHandler } from "../eventHandler/eventHandler.core.js";
+import { createEventHandlerError } from "../eventErrors/eventError.base.js";
 import { EventErrorMode } from "./eventEmitter.type.js";
 import { createAbortError } from "./eventEmitter.abort.js";
 /**
  * Executes handlers concurrently.
  */
-export async function emitParallel(handlers, event, context, errorMode, results, errors, onOnceHandler) {
-    const executions = handlers.map(async (handler) => {
-        if (context.signal.aborted) {
-            throw createAbortError();
+export async function emitParallel(handlers, event, context, errorMode, results, errors, hooks) {
+    if (context.signal.aborted) {
+        throw createAbortError(event, results, errors);
+    }
+    /**
+     * Consume once-handlers synchronously before anything starts so
+     * an overlapping dispatch cannot invoke them a second time.
+     */
+    const runnable = handlers.filter((handler) => {
+        if (!handler.once) {
+            return true;
+        }
+        if (!hooks.isRegistered(handler.id)) {
+            return false;
         }
+        hooks.removeOnce(handler.id);
+        return true;
+    });
+    const executions = runnable.map(async (handler) => {
         const started = performance.now();
         try {
-            const result = await executeEventHandler(handler.handler, event, context);
-            const execution = {
+            const result = await executeRegisteredEventHandler(handler, event, context);
+            return {
                 handlerId: handler.id,
                 eventId: event.id,
+                ok: true,
                 result,
                 duration: performance.now() - started,
             };
-            if (handler.once) {
-                onOnceHandler(handler.id);
-            }
-            return execution;
         }
         catch (error) {
             return {
                 handlerId: handler.id,
                 eventId: event.id,
+                ok: false,
                 result: undefined,
                 duration: performance.now() - started,
                 error,
@@ -39,8 +57,8 @@ export async function emitParallel(handlers, event, context, errorMode, results,
     const settled = await Promise.all(executions);
     for (const result of settled) {
         results.push(result);
-        if (result.error !== undefined) {
-            errors.push(result.error);
+        if (!result.ok) {
+            errors.push(createEventHandlerError(result.handlerId, event.type, event.id, result.error));
         }
     }
     if (errors.length > 0 && errorMode === EventErrorMode.THROW) {

package/dist/eventEmitter/eventEmitter.sequential.d.ts

@@ -5,8 +5,24 @@ import type { Event } from "../eventTypes/eventDefinition.type.js";
 import type { EventHandlerContext, RegisteredEventHandler } from "../eventHandler/eventHandler.core.js";
 import type { EventHandlerExecutionResult } from "./eventEmitter.type.js";
 import { EventErrorMode } from "./eventEmitter.type.js";
+/**
+ * Callbacks the dispatch strategies use to interact with the
+ * handler store.
+ */
+export interface DispatchHooks {
+    /**
+     * Returns whether a handler is still registered.
+     */
+    readonly isRegistered: (handlerId: string) => boolean;
+    /**
+     * Removes a once-handler. Called before the handler runs so a
+     * throwing or concurrently dispatched once-handler never fires
+     * twice.
+     */
+    readonly removeOnce: (handlerId: string) => void;
+}
 /**
  * Executes handlers sequentially.
  */
-export declare function emitSequential<TEvent extends Event>(handlers: readonly RegisteredEventHandler<TEvent>[], event: TEvent, context: EventHandlerContext<TEvent>, errorMode: EventErrorMode, results: EventHandlerExecutionResult[], errors: unknown[], onOnceHandler: (handlerId: string) => void): Promise<void>;
+export declare function emitSequential<TEvent extends Event>(handlers: readonly RegisteredEventHandler<TEvent>[], event: TEvent, context: EventHandlerContext<TEvent>, errorMode: EventErrorMode, results: EventHandlerExecutionResult[], errors: unknown[], hooks: DispatchHooks): Promise<void>;
 //# sourceMappingURL=eventEmitter.sequential.d.ts.map