@kuindji/reactive 1.1.0 → 1.2.0

package/dist/event.js

@@ -9,24 +9,37 @@ export function createEvent(eventOptions = {}) {
     let queue = [];
     let suspended = false;
     let queued = false;
+    let destroyed = false;
     let triggered = 0;
     let lastTrigger = null;
+    // The args replayed to a late autoTrigger listener. Recorded only while
+    // autoTrigger is enabled, so enabling it *after* a trigger does not replay
+    // that earlier (pre-enablement) trigger. Kept separate from `lastTrigger`,
+    // which is recorded on every trigger purely for `lastTriggerArgs`.
+    let autoTriggerArgs = null;
     let sortListeners = false;
     let currentTagsFilter = null;
     const options = Object.assign({ async: null, limit: null, autoTrigger: null, filter: null, filterContext: null, maxListeners: 0 }, eventOptions);
     const addListener = (handler, listenerOptions = {}) => {
-        var _a;
+        var _a, _b;
+        if (destroyed) {
+            throw new Error("Event is destroyed");
+        }
         if (!handler) {
             return;
         }
-        const listenerContext = (_a = listenerOptions.context) !== null && _a !== void 0 ? _a : null;
+        const signal = (_a = listenerOptions.signal) !== null && _a !== void 0 ? _a : null;
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            return;
+        }
+        const listenerContext = (_b = listenerOptions.context) !== null && _b !== void 0 ? _b : null;
         if (listeners.find((l) => l.handler === handler && l.context === listenerContext)) {
             return;
         }
         if (options.maxListeners && listeners.length >= options.maxListeners) {
             throw new Error(`Max listeners (${options.maxListeners}) reached`);
         }
-        const listener = Object.assign({ handler, called: 0, count: 0, index: listeners.length, start: 1, context: null, tags: [], extraData: null, first: false, alwaysFirst: false, alwaysLast: false, limit: 0, async: null }, listenerOptions);
+        const listener = Object.assign(Object.assign({ handler, called: 0, count: 0, index: listeners.length, start: 1, context: null, tags: [], extraData: null, first: false, alwaysFirst: false, alwaysLast: false, limit: 0, async: null }, listenerOptions), { abortCleanup: null });
         if (listener.async === true) {
             listener.async = 1;
         }
@@ -47,25 +60,32 @@ export function createEvent(eventOptions = {}) {
             || (listenerOptions === null || listenerOptions === void 0 ? void 0 : listenerOptions.alwaysLast) === true) {
             sortListeners = true;
         }
+        if (signal) {
+            const onAbort = () => {
+                removeListener(handler, listenerContext);
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            listener.abortCleanup = () => {
+                signal.removeEventListener("abort", onAbort);
+            };
+        }
         if (options.autoTrigger
-            && lastTrigger !== null
+            && autoTriggerArgs !== null
             && !suspended) {
-            const prevFilter = options.filter;
-            options.filter = (args, l) => {
-                if (l && l.handler === handler) {
-                    return prevFilter ? prevFilter(args, l) !== false : true;
-                }
-                return false;
-            };
-            try {
-                _trigger(lastTrigger);
-            }
-            finally {
-                options.filter = prevFilter;
-            }
+            // Replay the last enabled trigger, but only into the listener just
+            // added. The replay target is passed explicitly to `_trigger` (not
+            // via shared closure/`options.filter` state) so that a real trigger
+            // fired synchronously by the replayed handler is an ordinary real
+            // trigger — full bookkeeping, limit enforcement, and delivery to all
+            // listeners — rather than inheriting this replay's suppression.
+            _trigger(autoTriggerArgs, null, null, {
+                handler,
+                context: listenerContext !== null && listenerContext !== void 0 ? listenerContext : null,
+            });
         }
     };
     const removeListener = (handler, context, tag) => {
+        var _a;
         const inx = listeners.findIndex((l) => {
             if (l.handler !== handler) {
                 return false;
@@ -84,11 +104,12 @@ export function createEvent(eventOptions = {}) {
         if (inx === -1) {
             return false;
         }
-        listeners.splice(inx, 1);
+        const [removed] = listeners.splice(inx, 1);
+        (_a = removed === null || removed === void 0 ? void 0 : removed.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(removed);
         return true;
     };
     const updateListenerOptions = (handler, context = null, nextOptions = {}) => {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const listenerContext = context !== null && context !== void 0 ? context : null;
         const listener = listeners.find((l) => l.handler === handler && l.context === listenerContext);
         if (!listener) {
@@ -96,19 +117,35 @@ export function createEvent(eventOptions = {}) {
         }
         const prevAlwaysFirst = listener.alwaysFirst;
         const prevAlwaysLast = listener.alwaysLast;
-        // Soft fields, applying the same defaults as addListener so that a
-        // removed field resets to its default rather than lingering.
-        listener.limit = (_a = nextOptions.limit) !== null && _a !== void 0 ? _a : 0;
-        listener.start = (_b = nextOptions.start) !== null && _b !== void 0 ? _b : 1;
-        listener.tags = (_c = nextOptions.tags) !== null && _c !== void 0 ? _c : [];
-        listener.extraData = (_d = nextOptions.extraData) !== null && _d !== void 0 ? _d : null;
-        listener.alwaysFirst = (_e = nextOptions.alwaysFirst) !== null && _e !== void 0 ? _e : false;
-        listener.alwaysLast = (_f = nextOptions.alwaysLast) !== null && _f !== void 0 ? _f : false;
-        let nextAsync = (_g = nextOptions.async) !== null && _g !== void 0 ? _g : null;
-        if (nextAsync === true) {
-            nextAsync = 1;
-        }
-        listener.async = nextAsync;
+        // Partial update: only fields explicitly present in nextOptions change;
+        // any omitted field keeps its current value (a caller changing one
+        // option does not silently reset the others). Pass a field explicitly
+        // (e.g. limit: 0, signal: null) to clear it.
+        if ("limit" in nextOptions) {
+            listener.limit = (_a = nextOptions.limit) !== null && _a !== void 0 ? _a : 0;
+        }
+        if ("start" in nextOptions) {
+            listener.start = (_b = nextOptions.start) !== null && _b !== void 0 ? _b : 1;
+        }
+        if ("tags" in nextOptions) {
+            listener.tags = (_c = nextOptions.tags) !== null && _c !== void 0 ? _c : [];
+        }
+        if ("extraData" in nextOptions) {
+            listener.extraData = (_d = nextOptions.extraData) !== null && _d !== void 0 ? _d : null;
+        }
+        if ("alwaysFirst" in nextOptions) {
+            listener.alwaysFirst = (_e = nextOptions.alwaysFirst) !== null && _e !== void 0 ? _e : false;
+        }
+        if ("alwaysLast" in nextOptions) {
+            listener.alwaysLast = (_f = nextOptions.alwaysLast) !== null && _f !== void 0 ? _f : false;
+        }
+        if ("async" in nextOptions) {
+            let nextAsync = (_g = nextOptions.async) !== null && _g !== void 0 ? _g : null;
+            if (nextAsync === true) {
+                nextAsync = 1;
+            }
+            listener.async = nextAsync;
+        }
         // Re-sort if ordering hints changed. Unlike addListener we do NOT
         // rewrite each listener's index here: the existing indices hold the
         // original insertion order, and preserving them lets sorting restore
@@ -122,6 +159,31 @@ export function createEvent(eventOptions = {}) {
                 listeners.sort((l1, l2) => listenerSorter(l1, l2));
             }
         }
+        // Rebind the AbortSignal only when `signal` is explicitly present:
+        // detach any previous wiring so the old controller can no longer remove
+        // this listener, then attach the new signal. Omitting the field leaves
+        // the existing binding intact (partial-update convention); pass
+        // signal: null to clear it. An already-aborted new signal removes the
+        // listener now, mirroring addListener's "do not keep an aborted-signal
+        // listener".
+        if ("signal" in nextOptions) {
+            (_h = listener.abortCleanup) === null || _h === void 0 ? void 0 : _h.call(listener);
+            listener.abortCleanup = null;
+            const nextSignal = (_j = nextOptions.signal) !== null && _j !== void 0 ? _j : null;
+            if (nextSignal) {
+                if (nextSignal.aborted) {
+                    removeListener(listener.handler, listenerContext);
+                    return true;
+                }
+                const onAbort = () => {
+                    removeListener(listener.handler, listenerContext);
+                };
+                nextSignal.addEventListener("abort", onAbort, { once: true });
+                listener.abortCleanup = () => {
+                    nextSignal.removeEventListener("abort", onAbort);
+                };
+            }
+        }
         // The core auto-remove check is a strict `called === limit`, so a
         // listener whose `called` already exceeds the new limit would never
         // auto-remove. Remove it immediately in that case.
@@ -155,10 +217,16 @@ export function createEvent(eventOptions = {}) {
     const removeAllListeners = (tag) => {
         if (tag) {
             listeners = listeners.filter((l) => {
-                return !l.tags || l.tags.indexOf(tag) === -1;
+                var _a;
+                const keep = !l.tags || l.tags.indexOf(tag) === -1;
+                if (!keep) {
+                    (_a = l.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(l);
+                }
+                return keep;
             });
         }
         else {
+            listeners.forEach((l) => { var _a; return (_a = l.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(l); });
             listeners = [];
         }
     };
@@ -197,7 +265,98 @@ export function createEvent(eventOptions = {}) {
     };
     const isSuspended = () => suspended;
     const isQueued = () => queued;
+    // One-call teardown: drop all listeners (unwinding their abort handlers via
+    // reset) and mark the event dead. Post-destroy trigger/addListener throw
+    // rather than silently no-op, surfacing use-after-free.
+    const destroy = () => {
+        reset();
+        destroyed = true;
+    };
+    const isDestroyed = () => destroyed;
+    const listenerCount = (tag) => {
+        if (tag) {
+            return listeners.filter((l) => l.tags && l.tags.indexOf(tag) !== -1).length;
+        }
+        return listeners.length;
+    };
+    const triggeredCount = () => triggered;
+    // Return a copy: handing back the internal `lastTrigger` reference would let
+    // a caller mutate it, corrupting both the recorded snapshot and the values
+    // replayed to autoTrigger listeners.
+    const lastTriggerArgs = () => lastTrigger ? lastTrigger.slice() : null;
+    // Deep-copy extraData so the read-only projection cannot mutate internal
+    // listener metadata (which filters can read) at any depth; a shallow copy
+    // still shares nested containers by reference. `seen` carries already-cloned
+    // containers so a cyclic graph reuses its clone instead of recursing forever
+    // (a plain recursive clone throws RangeError on cycles). Arrays, plain
+    // objects, Date, Map and Set are cloned. Truly opaque values (functions,
+    // class instances) are returned as-is — copying their enumerable keys would
+    // not faithfully reproduce them — as are primitives.
+    const projectExtraDataDeep = (value, seen) => {
+        if (value === null || typeof value !== "object") {
+            return value;
+        }
+        const existing = seen.get(value);
+        if (existing !== undefined) {
+            return existing;
+        }
+        if (value instanceof Date) {
+            return new Date(value.getTime());
+        }
+        if (Array.isArray(value)) {
+            const copy = [];
+            seen.set(value, copy);
+            for (const v of value) {
+                copy.push(projectExtraDataDeep(v, seen));
+            }
+            return copy;
+        }
+        if (value instanceof Map) {
+            const copy = new Map();
+            seen.set(value, copy);
+            value.forEach((v, k) => {
+                copy.set(projectExtraDataDeep(k, seen), projectExtraDataDeep(v, seen));
+            });
+            return copy;
+        }
+        if (value instanceof Set) {
+            const copy = new Set();
+            seen.set(value, copy);
+            value.forEach((v) => {
+                copy.add(projectExtraDataDeep(v, seen));
+            });
+            return copy;
+        }
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) {
+            const copy = {};
+            seen.set(value, copy);
+            for (const k of Object.keys(value)) {
+                copy[k] = projectExtraDataDeep(value[k], seen);
+            }
+            return copy;
+        }
+        return value;
+    };
+    const projectExtraData = (value) => projectExtraDataDeep(value, new WeakMap());
+    const getListeners = () => {
+        return listeners.map((l) => ({
+            handler: l.handler,
+            context: l.context,
+            tags: l.tags ? l.tags.slice() : [],
+            limit: l.limit,
+            start: l.start,
+            called: l.called,
+            count: l.count,
+            async: l.async,
+            first: l.first,
+            alwaysFirst: l.alwaysFirst,
+            alwaysLast: l.alwaysLast,
+            extraData: projectExtraData(l.extraData),
+        }));
+    };
     const reset = () => {
+        listeners.forEach((l) => { var _a; return (_a = l.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(l); });
         listeners.length = 0;
         errorListeners.length = 0;
         queue.length = 0;
@@ -205,6 +364,7 @@ export function createEvent(eventOptions = {}) {
         queued = false;
         triggered = 0;
         lastTrigger = null;
+        autoTriggerArgs = null;
         sortListeners = false;
     };
     const _listenerCall = (listener, args, resolve = null) => {
@@ -266,6 +426,12 @@ export function createEvent(eventOptions = {}) {
     };
     const _listenerCallWPrev = (listener, args, prevValue, returnType) => {
         if (returnType === TriggerReturnType.PIPE) {
+            // Copy-on-write: preserve the pre-pipe lastTrigger snapshot before
+            // mutating args[0] in place for the pipe chain (lastTrigger stores
+            // the args reference rather than an eager per-trigger copy).
+            if (lastTrigger === args) {
+                lastTrigger = args.slice();
+            }
             args[0] = prevValue;
             // since we don't user listener's arg transformer,
             // we don't need to prepare args
@@ -287,8 +453,16 @@ export function createEvent(eventOptions = {}) {
         }
         return _listenerCall(listener, args);
     };
-    const _trigger = (args, returnType = null, tags) => {
-        var _a, _b;
+    const _trigger = (args, returnType = null, tags, 
+    // When set, this call is an autoTrigger replay: it must not bump
+    // `triggered`/`lastTrigger` or be gated by the trigger `limit`, and it is
+    // delivered only to the listener identified here.
+    replayTo) => {
+        var _a, _b, _c;
+        const replaying = !!replayTo;
+        if (destroyed) {
+            throw new Error("Event is destroyed");
+        }
         if (queued) {
             queue.push([
                 args,
@@ -300,12 +474,28 @@ export function createEvent(eventOptions = {}) {
         if (suspended) {
             return;
         }
-        if (options.limit && triggered >= options.limit) {
+        // The trigger `limit` bounds real triggers; an autoTrigger replay is an
+        // internal redelivery and must always reach the new listener.
+        if (options.limit && triggered >= options.limit && !replaying) {
             return;
         }
-        triggered++;
-        if (options.autoTrigger) {
-            lastTrigger = args.slice();
+        if (!replaying) {
+            triggered++;
+            // Record the last trigger arguments for introspection
+            // (`lastTriggerArgs`). Store the reference rather than eagerly
+            // copying on every trigger (a hot path even when nothing ever reads
+            // it): `args` is a fresh per-call array the caller cannot reach, and
+            // listeners receive it spread (never the array itself). The snapshot
+            // is copied lazily — when handed out by lastTriggerArgs(), and
+            // copy-on-write before PIPE mode mutates args[0] in place — so the
+            // recorded snapshot stays the pre-pipe arguments.
+            lastTrigger = args;
+            // Record the replay source only while autoTrigger is enabled, so a
+            // late listener added after autoTrigger is turned on replays the
+            // most recent *enabled* trigger, never an earlier disabled one.
+            if (options.autoTrigger) {
+                autoTriggerArgs = args.slice();
+            }
         }
         // in pipe mode if there is no listeners,
         // we just return piped value
@@ -336,6 +526,13 @@ export function createEvent(eventOptions = {}) {
             if (!listener) {
                 continue;
             }
+            // An autoTrigger replay is delivered only to the newly added
+            // listener identified by `replayTo`.
+            if (replayTo
+                && (listener.handler !== replayTo.handler
+                    || ((_c = listener.context) !== null && _c !== void 0 ? _c : null) !== replayTo.context)) {
+                continue;
+            }
             if (options.filter
                 && options.filter.call(options.filterContext, args, listener)
                     === false) {
@@ -357,6 +554,16 @@ export function createEvent(eventOptions = {}) {
                 && listener.count < listener.start) {
                 continue;
             }
+            // Count the call and exhaust the limit BEFORE invoking the handler.
+            // If the handler re-triggers this same event, the nested _trigger
+            // snapshots `listeners` AFTER the removal below, so an exhausted
+            // (e.g. once()) listener is not invoked a second time. Doing this
+            // after the call would let a re-entrant trigger see the still-live
+            // listener and run it again past its limit.
+            listener.called++;
+            if (listener.called === listener.limit) {
+                removeListener(listener.handler, listener.context);
+            }
             if (isConsequent && results.length > 0) {
                 const prev = results[results.length - 1];
                 if (hasPromises) {
@@ -374,10 +581,6 @@ export function createEvent(eventOptions = {}) {
             else {
                 listenerResult = _listenerCall(listener, args);
             }
-            listener.called++;
-            if (listener.called === listener.limit) {
-                removeListener(listener.handler, listener.context);
-            }
             if (returnType === TriggerReturnType.FIRST) {
                 return listenerResult;
             }
@@ -469,6 +672,9 @@ export function createEvent(eventOptions = {}) {
             currentTagsFilter = prevTagsFilter;
         }
     };
+    const once = (handler, listenerOptions = {}) => {
+        return addListener(handler, Object.assign(Object.assign({}, listenerOptions), { limit: 1 }));
+    };
     const promise = (options) => {
         return new Promise((resolve) => {
             options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
@@ -565,6 +771,7 @@ export function createEvent(eventOptions = {}) {
         listen: addListener,
         /** @alias addListener */
         subscribe: addListener,
+        once,
         removeListener,
         updateListenerOptions,
         /** @alias removeListener */
@@ -590,8 +797,14 @@ export function createEvent(eventOptions = {}) {
         resume,
         setOptions,
         reset,
+        destroy,
+        isDestroyed,
         isSuspended,
         isQueued,
+        listenerCount,
+        triggeredCount,
+        lastTriggerArgs,
+        getListeners,
         withTags,
         promise,
         first,

package/dist/eventBus.d.ts

@@ -91,6 +91,8 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly stopIntercepting: () => void;
     readonly isIntercepting: () => boolean;
     readonly reset: () => void;
+    readonly destroy: () => void;
+    readonly isDestroyed: () => boolean;
     readonly suspendAll: (withQueue?: boolean) => void;
     readonly resumeAll: () => void;
     readonly relay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {

package/dist/eventBus.js

@@ -78,6 +78,10 @@ export function createEventBus(eventBusOptions) {
     let interceptor = null;
     const proxyListeners = [];
     const eventSources = [];
+    let destroyed = false;
+    // Registry of active relays so destroy() can unwind the external listeners
+    // they attach (reset()/destroy() otherwise leave them dangling).
+    const relays = [];
     const asterisk = createEvent();
     const errorEvent = createEvent();
     const _getProxyListener = ({ remoteEventName, localEventName, returnType, resolve, localEventNamePrefix, }) => {
@@ -131,6 +135,9 @@ export function createEventBus(eventBusOptions) {
         return listener;
     };
     const add = (name, options) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         if (!events.has(name)) {
             events.set(name, createEvent(options));
         }
@@ -173,9 +180,15 @@ export function createEventBus(eventBusOptions) {
         return interceptor !== null;
     };
     const get = (name) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         return _getOrAddEvent(name);
     };
     const on = (name, handler, options) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         const e = _getOrAddEvent(name);
         eventSources.forEach((evs) => {
             if (evs.eventSource.accepts === false
@@ -199,11 +212,12 @@ export function createEventBus(eventBusOptions) {
         return e.addListener(handler, options);
     };
     const once = (name, handler, options) => {
-        options = options || {};
-        options.limit = 1;
-        return on(name, handler, options);
+        return on(name, handler, Object.assign(Object.assign({}, (options || {})), { limit: 1 }));
     };
     const promise = (name, options) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         const e = _getOrAddEvent(name);
         return e.promise(options);
     };
@@ -239,6 +253,9 @@ export function createEventBus(eventBusOptions) {
         return e.updateListenerOptions(handler, context !== null && context !== void 0 ? context : null, nextOptions);
     };
     const _trigger = (name, args, returnType, resolve) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         if (name === "*") {
             return;
         }
@@ -393,18 +410,70 @@ export function createEventBus(eventBusOptions) {
         }
     };
     const reset = () => {
+        // Detach relays BEFORE clearing proxyListeners: unrelay() resolves the
+        // external listener via _getProxyListener, which depends on the original
+        // entry still being present. Clearing proxyListeners first would lose the
+        // callback identity, leaving the external subscription dangling so a
+        // later destroy() could never remove it.
+        relays.slice().forEach((r) => {
+            unrelay({
+                eventSource: r.eventSource,
+                remoteEventName: r.remoteEventName,
+                localEventName: r.localEventName,
+                proxyType: r.proxyType,
+                localEventNamePrefix: r.localEventNamePrefix,
+            });
+        });
         if (eventSources.length > 0) {
             eventSources.slice().forEach((evs) => {
                 removeEventSource(evs.eventSource);
             });
         }
+        // Reset each owned event before dropping it: clearing the map alone
+        // leaves listener AbortSignal handlers attached to their signals, which
+        // retains the orphaned events (and their listeners) until the signal
+        // aborts. reset() detaches those handlers and clears the listeners.
+        events.forEach((event) => {
+            event.reset();
+        });
         events.clear();
         interceptor = null;
         currentTagsFilter = null;
         asterisk.reset();
         proxyListeners.length = 0;
         eventSources.length = 0;
+        relays.length = 0;
+    };
+    // One-call teardown: unwind external attachments (relays + event sources)
+    // that reset() leaves dangling, destroy every owned event, and mark the bus
+    // dead. Post-destroy trigger/addListener throw rather than silently no-op.
+    const destroy = () => {
+        relays.slice().forEach((r) => {
+            unrelay({
+                eventSource: r.eventSource,
+                remoteEventName: r.remoteEventName,
+                localEventName: r.localEventName,
+                proxyType: r.proxyType,
+                localEventNamePrefix: r.localEventNamePrefix,
+            });
+        });
+        eventSources.slice().forEach((evs) => {
+            removeEventSource(evs.eventSource);
+        });
+        events.forEach((event) => {
+            event.destroy();
+        });
+        events.clear();
+        asterisk.destroy();
+        errorEvent.destroy();
+        proxyListeners.length = 0;
+        eventSources.length = 0;
+        relays.length = 0;
+        interceptor = null;
+        currentTagsFilter = null;
+        destroyed = true;
     };
+    const isDestroyed = () => destroyed;
     const suspendAll = (withQueue = false) => {
         events.forEach((event) => {
             event.suspend(withQueue);
@@ -416,6 +485,12 @@ export function createEventBus(eventBusOptions) {
         });
     };
     const relay = ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }) => {
+        // Like the other registration methods, refuse on a dead bus: attaching
+        // the proxy listener here would leave a dangling subscription that
+        // throws "EventBus is destroyed" the next time the source fires.
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(proxyType || ProxyType.TRIGGER);
         const listener = _getProxyListener({
             localEventName: localEventName || null,
@@ -430,6 +505,18 @@ export function createEventBus(eventBusOptions) {
         else {
             eventSource.on(remoteEventName, listener.listener);
         }
+        relays.push({
+            eventSource,
+            remoteEventName,
+            localEventName: localEventName || null,
+            // Store the resolved proxyType (undefined resolves to TRIGGER) so the
+            // registry key matches how the proxy listener is actually resolved.
+            // Otherwise unrelay({ proxyType: TRIGGER }) for a relay({}) (undefined)
+            // detaches the listener but leaves a stale registry entry, which a
+            // later reset()/destroy() then unrelays a second time.
+            proxyType: proxyType || ProxyType.TRIGGER,
+            localEventNamePrefix: localEventNamePrefix || null,
+        });
     };
     const unrelay = ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }) => {
         const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(proxyType || ProxyType.TRIGGER);
@@ -448,8 +535,22 @@ export function createEventBus(eventBusOptions) {
                 eventSource.un(remoteEventName, listener.listener);
             }
         }
+        const inx = relays.findIndex((r) => r.eventSource === eventSource
+            && r.remoteEventName === remoteEventName
+            && r.localEventName === (localEventName || null)
+            // Compare on the resolved proxyType so an undefined relay matches an
+            // explicit TRIGGER unrelay (and vice versa), mirroring how the proxy
+            // listener itself resolves equivalent types.
+            && r.proxyType === (proxyType || ProxyType.TRIGGER)
+            && r.localEventNamePrefix === (localEventNamePrefix || null));
+        if (inx !== -1) {
+            relays.splice(inx, 1);
+        }
     };
     const addEventSource = (eventSource) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         if (eventSources.find((evs) => evs.eventSource.name === eventSource.name)) {
             return;
         }
@@ -549,6 +650,8 @@ export function createEventBus(eventBusOptions) {
         stopIntercepting,
         isIntercepting,
         reset,
+        destroy,
+        isDestroyed,
         suspendAll,
         resumeAll,
         relay,

package/dist/lib/types.d.ts

@@ -44,6 +44,6 @@ export type ErrorResponse<Arguments extends any[] = any[]> = {
     error: Error;
     args: Arguments;
     name?: MapKey;
-    type: "action" | "event" | "store-change" | "store-pipe" | "store-control";
+    type: "action" | "action-status" | "event" | "store-change" | "store-pipe" | "store-control";
 };
 export type ErrorListenerSignature<Arguments extends any[] = any[]> = (errorResponse: ErrorResponse<Arguments>) => void;

package/dist/react/useActionBusStatus.d.ts

@@ -0,0 +1,13 @@
+import type { ActionStatus } from "../action.js";
+import type { BaseActionBus } from "../actionBus.js";
+import type { KeyOf } from "../lib/types.js";
+import type { AsyncActionState } from "./useAsyncAction.js";
+export type { ActionStatus, AsyncActionState };
+/**
+ * Subscribes to the status of a named action on an ActionBus and returns
+ * `{ loading, error, response }` for driving `loading`/`disabled` UI. This is
+ * the primary path for apps that route mutations through one shared ActionBus.
+ *
+ * An unregistered name reports an idle status and is safe to subscribe to.
+ */
+export declare function useActionBusStatus<TBus extends BaseActionBus, TName extends KeyOf<TBus["__type"]["actions"]>>(bus: TBus, name: TName): AsyncActionState<TBus["__type"]["actions"][TName]["actionReturnType"]>;