@bandeira-tech/b3nd-save 0.8.1

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/observe-emitter/observe-emitter.d.ts

@@ -0,0 +1,35 @@
+export type ObserveListener = (uri: string, data: unknown) => void;
+/**
+ * Base class providing a write/delete listener bus and an async iterator
+ * for observing URI-pattern changes.
+ *
+ * Subclasses call `_emit(uri, data)` on successful writes and
+ * `_emitDeletes(uris)` on successful deletes. The emitter ignores
+ * `data` for INV-style notifications — observers receive only the
+ * uri and read it themselves.
+ */
+export declare class ObserveEmitter {
+    protected _listeners: Set<ObserveListener>;
+    /**
+     * Notify all listeners of a URI change. `data` is accepted for
+     * compatibility with subclasses that may reuse the listener bus,
+     * but it is not surfaced to observe iterators.
+     */
+    protected _emit(uri: string, data: unknown): void;
+    /** Notify all listeners that each URI was deleted. */
+    protected _emitDeletes(uris: readonly string[]): void;
+    /**
+     * Async iterator yielding `readonly string[]` batches of uris that
+     * changed under any input pattern. Runs until `signal` aborts.
+     *
+     * Default emission yields a singleton batch per matching change;
+     * subclasses with cheap batching can override to coalesce.
+     *
+     * The listener stays registered for the lifetime of the iteration;
+     * events fired while the consumer is processing a yielded value are
+     * buffered in a per-iterator queue so nothing is dropped across the
+     * yield boundary.
+     */
+    observe(urls: string[], signal: AbortSignal): AsyncIterable<readonly string[]>;
+}
+//# sourceMappingURL=observe-emitter.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/observe-emitter/observe-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe-emitter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/observe-emitter/observe-emitter.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,KACV,IAAI,CAAC;AAEV;;;;;;;;GAQG;AACH,qBAAa,cAAc;IACzB,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,eAAe,CAAC,CAA8B;IAExE;;;;OAIG;IACH,SAAS,CAAC,KAAK,CACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,GACZ,IAAI;IAUP,sDAAsD;IACtD,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAIrD;;;;;;;;;;;OAWG;IACI,OAAO,CACZ,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,WAAW,GAClB,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC;CA2CpC"}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/observe-emitter/observe-emitter.js

@@ -0,0 +1,106 @@
+/**
+ * @module
+ * ObserveEmitter — the shared listener + async-iterator machinery
+ * `ProtocolInterfaceNode` implementations use to expose `observe()`.
+ *
+ * Observe is INV-style notification: each successful write or delete
+ * yields a `readonly string[]` — the batch of concrete uris that
+ * fired. The default emitter sends one uri per yield; backends with
+ * cheap batching can send several. A single change matching several
+ * input patterns yields once (not once per matching pattern); callers
+ * who need to know which of their patterns matched re-run the match
+ * locally, which is cheap and keeps the stream minimal.
+ *
+ * `observe(locators, signal)` accepts locators as opaque strings and
+ * matches them as segment-globs against emitted uris. The shared glob
+ * grammar (`*` for one segment, `**` for the rest) applies. Any
+ * normalization (e.g. stripping request-time directives before matching)
+ * is the executing client's responsibility.
+ */
+import { compilePattern, } from "../match-pattern/match-pattern.js";
+/**
+ * Base class providing a write/delete listener bus and an async iterator
+ * for observing URI-pattern changes.
+ *
+ * Subclasses call `_emit(uri, data)` on successful writes and
+ * `_emitDeletes(uris)` on successful deletes. The emitter ignores
+ * `data` for INV-style notifications — observers receive only the
+ * uri and read it themselves.
+ */
+export class ObserveEmitter {
+    _listeners = new Set();
+    /**
+     * Notify all listeners of a URI change. `data` is accepted for
+     * compatibility with subclasses that may reuse the listener bus,
+     * but it is not surfaced to observe iterators.
+     */
+    _emit(uri, data) {
+        for (const listener of this._listeners) {
+            try {
+                listener(uri, data);
+            }
+            catch {
+                // Listener errors must never break the emitter.
+            }
+        }
+    }
+    /** Notify all listeners that each URI was deleted. */
+    _emitDeletes(uris) {
+        for (const uri of uris)
+            this._emit(uri, null);
+    }
+    /**
+     * Async iterator yielding `readonly string[]` batches of uris that
+     * changed under any input pattern. Runs until `signal` aborts.
+     *
+     * Default emission yields a singleton batch per matching change;
+     * subclasses with cheap batching can override to coalesce.
+     *
+     * The listener stays registered for the lifetime of the iteration;
+     * events fired while the consumer is processing a yielded value are
+     * buffered in a per-iterator queue so nothing is dropped across the
+     * yield boundary.
+     */
+    async *observe(urls, signal) {
+        const matchers = urls.map(compilePattern);
+        const queue = [];
+        let wake = null;
+        const listener = (uri, _data) => {
+            for (let i = 0; i < matchers.length; i++) {
+                if (matchers[i](uri)) {
+                    queue.push([uri]);
+                    const w = wake;
+                    if (w) {
+                        wake = null;
+                        w();
+                    }
+                    return;
+                }
+            }
+        };
+        const onAbort = () => {
+            const w = wake;
+            if (w) {
+                wake = null;
+                w();
+            }
+        };
+        this._listeners.add(listener);
+        signal.addEventListener("abort", onAbort, { once: true });
+        try {
+            while (true) {
+                while (queue.length > 0)
+                    yield queue.shift();
+                if (signal.aborted)
+                    return;
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+            }
+        }
+        finally {
+            this._listeners.delete(listener);
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/connection.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @module
+ * Connection — a client bound to a URI pattern list.
+ *
+ * A `Connection` wraps a `ProtocolInterfaceNode` with a set of URI
+ * filter patterns. Connections are bound into the rig's `routes`
+ * config (`receive`, `read`, `observe`) — each route gets its own
+ * ordered list of connections.
+ *
+ * The same connection value can be referenced from multiple routes
+ * (when one client serves writes, reads, and observes with the same
+ * filter); a different filter for a different op means a separate
+ * `connection(...)` call.
+ *
+ * Pattern syntax (same as observe and reactions):
+ * - `*` matches exactly one non-empty segment
+ * - `**` matches zero or more remaining segments (final segment only)
+ * - Literal segments must match exactly
+ *
+ * @example A single client serving all three ops
+ * ```ts
+ * import { connection, Rig } from "@bandeira-tech/b3nd-core";
+ *
+ * const node = connection(httpClient, ["mutable://**", "hash://**"]);
+ *
+ * const rig = new Rig({
+ *   routes: {
+ *     receive: [node],
+ *     read:    [node],
+ *     observe: [node],
+ *   },
+ * });
+ * ```
+ *
+ * @example Asymmetric topology — write-mirror, read-cache, narrow observe
+ * ```ts
+ * const primary = connection(httpClient,  ["mutable://**", "hash://**"], { id: "primary" });
+ * const mirror  = connection(pgClient,    ["mutable://**", "hash://**"], { id: "mirror"  });
+ * const cache   = connection(redisClient, ["mutable://accounts/**"],   { id: "cache"   });
+ * const obsNarrow = connection(httpClient, ["mutable://**"],            { id: "primary-obs" });
+ *
+ * const rig = new Rig({
+ *   routes: {
+ *     receive: [primary, mirror], // broadcast both
+ *     read:    [cache, primary],  // try cache first, then primary
+ *     observe: [obsNarrow],       // narrow namespace, primary only
+ *   },
+ * });
+ * ```
+ */
+import type { ProtocolInterfaceNode } from "../types/types.js";
+/** Optional configuration for a connection. */
+export interface ConnectionOptions {
+    /**
+     * Stable identifier for this connection. Surfaces in
+     * `route:success`/`route:error` events on the operation handle and
+     * lets operators tell replicas apart in observability data.
+     * Auto-generated as `conn-{N}` (registration order) when omitted.
+     */
+    id?: string;
+}
+/** A connection: a client wrapped with a URI pattern list. */
+export interface Connection {
+    /** Stable identifier (provided or auto-generated). */
+    readonly id: string;
+    /** The underlying client. */
+    readonly client: ProtocolInterfaceNode;
+    /**
+     * The raw patterns — serializable for wire protocols.
+     * Send this to a remote node so it knows what to push.
+     */
+    readonly patterns: readonly string[];
+    /** Check if this connection's pattern list accepts a URI. */
+    accepts(uri: string): boolean;
+}
+/**
+ * Wrap a client with a URI pattern list to create a connection.
+ *
+ * The connection is the gateway control — the rig uses it for
+ * routing within the route arrays it appears in, and the patterns
+ * can be published over the wire for remote filtering.
+ *
+ * Local enforcement is always applied. Remote enforcement is
+ * best-effort: the remote node may or may not honor the patterns,
+ * but the local rig always filters based on them.
+ */
+export declare function connection(client: ProtocolInterfaceNode, patterns: string[], options?: ConnectionOptions): Connection;
+//# sourceMappingURL=connection.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/connection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAQ/D,+CAA+C;AAC/C,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,8DAA8D;AAC9D,MAAM,WAAW,UAAU;IACzB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,6BAA6B;IAC7B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAEvC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAErC,6DAA6D;IAC7D,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC/B;AAgBD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,UAAU,CAcZ"}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/connection.js

@@ -0,0 +1,86 @@
+/**
+ * @module
+ * Connection — a client bound to a URI pattern list.
+ *
+ * A `Connection` wraps a `ProtocolInterfaceNode` with a set of URI
+ * filter patterns. Connections are bound into the rig's `routes`
+ * config (`receive`, `read`, `observe`) — each route gets its own
+ * ordered list of connections.
+ *
+ * The same connection value can be referenced from multiple routes
+ * (when one client serves writes, reads, and observes with the same
+ * filter); a different filter for a different op means a separate
+ * `connection(...)` call.
+ *
+ * Pattern syntax (same as observe and reactions):
+ * - `*` matches exactly one non-empty segment
+ * - `**` matches zero or more remaining segments (final segment only)
+ * - Literal segments must match exactly
+ *
+ * @example A single client serving all three ops
+ * ```ts
+ * import { connection, Rig } from "@bandeira-tech/b3nd-core";
+ *
+ * const node = connection(httpClient, ["mutable://**", "hash://**"]);
+ *
+ * const rig = new Rig({
+ *   routes: {
+ *     receive: [node],
+ *     read:    [node],
+ *     observe: [node],
+ *   },
+ * });
+ * ```
+ *
+ * @example Asymmetric topology — write-mirror, read-cache, narrow observe
+ * ```ts
+ * const primary = connection(httpClient,  ["mutable://**", "hash://**"], { id: "primary" });
+ * const mirror  = connection(pgClient,    ["mutable://**", "hash://**"], { id: "mirror"  });
+ * const cache   = connection(redisClient, ["mutable://accounts/**"],   { id: "cache"   });
+ * const obsNarrow = connection(httpClient, ["mutable://**"],            { id: "primary-obs" });
+ *
+ * const rig = new Rig({
+ *   routes: {
+ *     receive: [primary, mirror], // broadcast both
+ *     read:    [cache, primary],  // try cache first, then primary
+ *     observe: [obsNarrow],       // narrow namespace, primary only
+ *   },
+ * });
+ * ```
+ */
+import { compilePattern, } from "../match-pattern/match-pattern.js";
+// ── Internals ──
+function matchesAny(matchers, uri) {
+    for (let i = 0; i < matchers.length; i++) {
+        if (matchers[i](uri))
+            return true;
+    }
+    return false;
+}
+// ── connection ──
+/** Module-level counter for auto-generated connection IDs. */
+let _autoIdCounter = 0;
+/**
+ * Wrap a client with a URI pattern list to create a connection.
+ *
+ * The connection is the gateway control — the rig uses it for
+ * routing within the route arrays it appears in, and the patterns
+ * can be published over the wire for remote filtering.
+ *
+ * Local enforcement is always applied. Remote enforcement is
+ * best-effort: the remote node may or may not honor the patterns,
+ * but the local rig always filters based on them.
+ */
+export function connection(client, patterns, options) {
+    const matchers = patterns.map(compilePattern);
+    const frozenPatterns = Object.freeze([...patterns]);
+    const id = options?.id ?? `conn-${_autoIdCounter++}`;
+    return {
+        id,
+        client,
+        patterns: frozenPatterns,
+        accepts(uri) {
+            return matchesAny(matchers, uri);
+        },
+    };
+}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/events.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @module
+ * Typed event emitter for the Rig.
+ *
+ * Events are async, fire-and-forget — they run AFTER the operation
+ * completes (after post-hooks). They never block the caller.
+ *
+ * Handler errors are caught (never propagated) and surfaced via
+ * `onHandlerError` listeners. If no listener is registered, they
+ * fall back to `console.warn` so failures are never silent.
+ *
+ * On cleanup, pending event promises are returned to the caller
+ * so they can choose to await them or let them go.
+ *
+ * Pure module — no Rig dependency, testable in isolation.
+ */
+/** All possible rig event names. */
+export type RigEventName = "send:success" | "send:error" | "receive:success" | "receive:error" | "read:success" | "read:error" | "*:success" | "*:error";
+/** Payload delivered to event handlers. */
+export interface RigEvent {
+    /** The operation that triggered this event. */
+    op: string;
+    /** The URI involved, if any. */
+    uri?: string;
+    /** The data involved (e.g., receive payload, send envelope). */
+    data?: unknown;
+    /** The operation result (on success). */
+    result?: unknown;
+    /** The error (on error). */
+    error?: unknown;
+    /** Timestamp when the event was emitted. */
+    ts: number;
+}
+/** Event handler function. */
+export type EventHandler = (event: RigEvent) => void | Promise<void>;
+/** Listener for errors thrown inside event handlers. */
+export type HandlerErrorListener = (error: unknown, event: RigEventName) => void;
+/**
+ * Typed event emitter for Rig operations.
+ *
+ * - Handlers fire asynchronously (via microtask)
+ * - Handler errors are routed to `onHandlerError` listeners; if none are
+ *   registered, they fall back to `console.warn`
+ * - Wildcard events (`*:success`, `*:error`) fire for all operations
+ * - `pending()` returns in-flight handler promises for drain-on-cleanup
+ */
+export declare class RigEventEmitter {
+    private handlers;
+    private errorListeners;
+    private inflight;
+    /** Register a handler. Returns an unsubscribe function. */
+    on(event: RigEventName, handler: EventHandler): () => void;
+    /** Remove a specific handler. */
+    off(event: RigEventName, handler: EventHandler): void;
+    /**
+     * Register a listener for errors thrown inside event handlers.
+     * Returns an unsubscribe function.
+     *
+     * When at least one listener is registered, the `console.warn` fallback
+     * is suppressed — the listener owns reporting. If a listener itself
+     * throws, that secondary error falls back to `console.warn` (no recursion).
+     */
+    onHandlerError(listener: HandlerErrorListener): () => void;
+    /** Return handler counts per event name. */
+    counts(): Record<string, number>;
+    /**
+     * Fire an event. Handlers run asynchronously and never block.
+     * Errors in handlers are routed to `onHandlerError` listeners (or
+     * `console.warn` if none). Promises are tracked so `pending()` can
+     * return them, and self-evict once settled.
+     */
+    emit(event: RigEventName, payload: RigEvent): void;
+    private dispatchHandlerError;
+    /**
+     * Return all in-flight event handler promises and clear the queue.
+     *
+     * The caller decides what to do with them:
+     * - `await Promise.allSettled(pending)` to drain before exit
+     * - Ignore them if you don't care about completion
+     */
+    pending(): Promise<void>[];
+}
+//# sourceMappingURL=events.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,oCAAoC;AACpC,MAAM,MAAM,YAAY,GACpB,cAAc,GACd,YAAY,GACZ,iBAAiB,GACjB,eAAe,GACf,cAAc,GACd,YAAY,GACZ,WAAW,GACX,SAAS,CAAC;AAEd,2CAA2C;AAC3C,MAAM,WAAW,QAAQ;IACvB,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,yCAAyC;IACzC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4BAA4B;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,8BAA8B;AAC9B,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErE,wDAAwD;AACxD,MAAM,MAAM,oBAAoB,GAAG,CACjC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,YAAY,KAChB,IAAI,CAAC;AAIV;;;;;;;;GAQG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAA8C;IAC9D,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,QAAQ,CAA4B;IAE5C,2DAA2D;IAC3D,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,IAAI;IAU1D,iCAAiC;IACjC,GAAG,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI;IAIrD;;;;;;;OAOG;IACH,cAAc,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,IAAI;IAK1D,4CAA4C;IAC5C,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQhC;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,GAAG,IAAI;IAoBlD,OAAO,CAAC,oBAAoB;IAiB5B;;;;;;OAMG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE;CAK3B"}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/events.js

@@ -0,0 +1,115 @@
+/**
+ * @module
+ * Typed event emitter for the Rig.
+ *
+ * Events are async, fire-and-forget — they run AFTER the operation
+ * completes (after post-hooks). They never block the caller.
+ *
+ * Handler errors are caught (never propagated) and surfaced via
+ * `onHandlerError` listeners. If no listener is registered, they
+ * fall back to `console.warn` so failures are never silent.
+ *
+ * On cleanup, pending event promises are returned to the caller
+ * so they can choose to await them or let them go.
+ *
+ * Pure module — no Rig dependency, testable in isolation.
+ */
+// ── Emitter ──
+/**
+ * Typed event emitter for Rig operations.
+ *
+ * - Handlers fire asynchronously (via microtask)
+ * - Handler errors are routed to `onHandlerError` listeners; if none are
+ *   registered, they fall back to `console.warn`
+ * - Wildcard events (`*:success`, `*:error`) fire for all operations
+ * - `pending()` returns in-flight handler promises for drain-on-cleanup
+ */
+export class RigEventEmitter {
+    handlers = new Map();
+    errorListeners = new Set();
+    inflight = new Set();
+    /** Register a handler. Returns an unsubscribe function. */
+    on(event, handler) {
+        let set = this.handlers.get(event);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(event, set);
+        }
+        set.add(handler);
+        return () => set.delete(handler);
+    }
+    /** Remove a specific handler. */
+    off(event, handler) {
+        this.handlers.get(event)?.delete(handler);
+    }
+    /**
+     * Register a listener for errors thrown inside event handlers.
+     * Returns an unsubscribe function.
+     *
+     * When at least one listener is registered, the `console.warn` fallback
+     * is suppressed — the listener owns reporting. If a listener itself
+     * throws, that secondary error falls back to `console.warn` (no recursion).
+     */
+    onHandlerError(listener) {
+        this.errorListeners.add(listener);
+        return () => this.errorListeners.delete(listener);
+    }
+    /** Return handler counts per event name. */
+    counts() {
+        const result = {};
+        for (const [name, set] of this.handlers) {
+            if (set.size > 0)
+                result[name] = set.size;
+        }
+        return result;
+    }
+    /**
+     * Fire an event. Handlers run asynchronously and never block.
+     * Errors in handlers are routed to `onHandlerError` listeners (or
+     * `console.warn` if none). Promises are tracked so `pending()` can
+     * return them, and self-evict once settled.
+     */
+    emit(event, payload) {
+        const specific = this.handlers.get(event);
+        // Determine wildcard: "send:success" → "*:success"
+        const suffix = event.endsWith(":success") ? "*:success" : "*:error";
+        const wildcard = this.handlers.get(suffix);
+        const all = [
+            ...(specific ? specific : []),
+            ...(wildcard && event !== suffix ? wildcard : []),
+        ];
+        for (const handler of all) {
+            const p = Promise.resolve()
+                .then(() => handler(payload))
+                .catch((err) => this.dispatchHandlerError(err, event));
+            this.inflight.add(p);
+            p.finally(() => this.inflight.delete(p));
+        }
+    }
+    dispatchHandlerError(error, event) {
+        if (this.errorListeners.size === 0) {
+            console.warn(`[rig] event handler error on "${event}":`, error);
+            return;
+        }
+        for (const listener of this.errorListeners) {
+            try {
+                listener(error, event);
+            }
+            catch (listenerError) {
+                console.warn(`[rig] onHandlerError listener threw:`, listenerError);
+            }
+        }
+    }
+    /**
+     * Return all in-flight event handler promises and clear the queue.
+     *
+     * The caller decides what to do with them:
+     * - `await Promise.allSettled(pending)` to drain before exit
+     * - Ignore them if you don't care about completion
+     */
+    pending() {
+        const result = [...this.inflight];
+        this.inflight.clear();
+        return result;
+    }
+}