@kuindji/reactive 1.0.24 → 1.2.0

package/dist/react/listenerOptionsEqual.js

@@ -0,0 +1,121 @@
+function normalizeAsync(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (value === true) {
+        return 1;
+    }
+    return value;
+}
+/**
+ * Order-insensitive set comparison for listener tags.
+ * `undefined`, `[]` and missing all compare equal. Order and duplicates do
+ * not matter because the core only ever uses tags via membership and
+ * intersection checks.
+ */
+export function areTagsEqual(a, b) {
+    const aa = a !== null && a !== void 0 ? a : [];
+    const bb = b !== null && b !== void 0 ? b : [];
+    if (aa.length === 0 && bb.length === 0) {
+        return true;
+    }
+    const sa = new Set(aa);
+    const sb = new Set(bb);
+    if (sa.size !== sb.size) {
+        return false;
+    }
+    for (const tag of sa) {
+        if (!sb.has(tag)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Domain-specific comparator for {@link ListenerOptions}. Avoids generic deep
+ * equality: primitives compare after default semantics, `context`/`extraData`
+ * compare by reference, and `tags` use order-insensitive set comparison.
+ */
+export function areListenerOptionsEqual(a, b) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const aa = a !== null && a !== void 0 ? a : {};
+    const bb = b !== null && b !== void 0 ? b : {};
+    if (((_a = aa.limit) !== null && _a !== void 0 ? _a : 0) !== ((_b = bb.limit) !== null && _b !== void 0 ? _b : 0)) {
+        return false;
+    }
+    if (((_c = aa.start) !== null && _c !== void 0 ? _c : 1) !== ((_d = bb.start) !== null && _d !== void 0 ? _d : 1)) {
+        return false;
+    }
+    if (((_e = aa.first) !== null && _e !== void 0 ? _e : false) !== ((_f = bb.first) !== null && _f !== void 0 ? _f : false)) {
+        return false;
+    }
+    if (((_g = aa.alwaysFirst) !== null && _g !== void 0 ? _g : false) !== ((_h = bb.alwaysFirst) !== null && _h !== void 0 ? _h : false)) {
+        return false;
+    }
+    if (((_j = aa.alwaysLast) !== null && _j !== void 0 ? _j : false) !== ((_k = bb.alwaysLast) !== null && _k !== void 0 ? _k : false)) {
+        return false;
+    }
+    if (normalizeAsync(aa.async) !== normalizeAsync(bb.async)) {
+        return false;
+    }
+    if (((_l = aa.context) !== null && _l !== void 0 ? _l : null) !== ((_m = bb.context) !== null && _m !== void 0 ? _m : null)) {
+        return false;
+    }
+    // reference equality only; do not deep compare arbitrary values
+    if (aa.extraData !== bb.extraData) {
+        return false;
+    }
+    if (!areTagsEqual(aa.tags, bb.tags)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Domain-specific comparator for {@link EventOptions}. Primitives compare after
+ * default semantics; `filter`/`filterContext` compare by reference.
+ */
+export function areEventOptionsEqual(a, b) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const aa = a !== null && a !== void 0 ? a : {};
+    const bb = b !== null && b !== void 0 ? b : {};
+    if (normalizeAsync(aa.async) !== normalizeAsync(bb.async)) {
+        return false;
+    }
+    if (((_a = aa.limit) !== null && _a !== void 0 ? _a : null) !== ((_b = bb.limit) !== null && _b !== void 0 ? _b : null)) {
+        return false;
+    }
+    if (((_c = aa.autoTrigger) !== null && _c !== void 0 ? _c : null) !== ((_d = bb.autoTrigger) !== null && _d !== void 0 ? _d : null)) {
+        return false;
+    }
+    if (((_e = aa.maxListeners) !== null && _e !== void 0 ? _e : 0) !== ((_f = bb.maxListeners) !== null && _f !== void 0 ? _f : 0)) {
+        return false;
+    }
+    // reference equality
+    if (((_g = aa.filter) !== null && _g !== void 0 ? _g : null) !== ((_h = bb.filter) !== null && _h !== void 0 ? _h : null)) {
+        return false;
+    }
+    if (((_j = aa.filterContext) !== null && _j !== void 0 ? _j : null) !== ((_k = bb.filterContext) !== null && _k !== void 0 ? _k : null)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Compares the per-event `eventOptions` maps of two {@link EventBusOptions}.
+ * Equal when every event name present in either map has semantically equal
+ * {@link EventOptions} (missing entries compare as default options).
+ */
+export function areEventBusOptionsEqual(a, b) {
+    var _a, _b;
+    const aMap = (_a = a === null || a === void 0 ? void 0 : a.eventOptions) !== null && _a !== void 0 ? _a : {};
+    const bMap = (_b = b === null || b === void 0 ? void 0 : b.eventOptions) !== null && _b !== void 0 ? _b : {};
+    const names = new Set([
+        ...Object.keys(aMap),
+        ...Object.keys(bMap),
+    ]);
+    for (const name of names) {
+        if (!areEventOptionsEqual(aMap[name], bMap[name])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/react/useAction.d.ts

@@ -1,5 +1,5 @@
-import { createAction } from "../action";
-import type { ActionResponse, BeforeActionSignature, ListenerSignature } from "../action";
-import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
+import { createAction } from "../action.js";
+import type { ActionResponse, BeforeActionSignature, ListenerSignature } from "../action.js";
+import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types.js";
 export type { ActionResponse, BaseHandler, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
 export declare function useAction<ActionSignature extends BaseHandler, Listener extends ListenerSignature<ActionSignature>, ErrorListener extends ErrorListenerSignature<Parameters<ActionSignature>>, BeforeActionListener extends BeforeActionSignature<ActionSignature>>(actionSignature: ActionSignature, listener?: Listener | null, errorListener?: ErrorListener | null, beforeActionListener?: BeforeActionListener | null): ReturnType<typeof createAction<ActionSignature>>;

package/dist/react/useAction.js

@@ -1,9 +1,9 @@
 import { useContext, useEffect, useMemo, useRef } from "react";
-import { createAction } from "../action";
-import { ErrorBoundaryContext } from "./ErrorBoundary";
+import { createAction } from "../action.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
 export function useAction(actionSignature, listener, errorListener, beforeActionListener) {
     const boundaryErrorListener = useContext(ErrorBoundaryContext);
-    const updateRef = useRef(0);
+    const actionSignatureRef = useRef(actionSignature);
     const listenerRef = useRef(listener);
     const errorListenerRef = useRef(errorListener);
     const boundaryErrorListenerRef = useRef(boundaryErrorListener);
@@ -24,11 +24,15 @@ export function useAction(actionSignature, listener, errorListener, beforeAction
         }
         return action;
     }, []);
+    // Replace the action function in place when its reference changes,
+    // preserving all listeners and the action identity. A changed function
+    // must keep a compatible signature (TypeScript fixes the generic from the
+    // initial render).
     useEffect(() => {
-        if (updateRef.current > 0) {
-            throw new Error("Action cannot be updated");
+        if (actionSignatureRef.current !== actionSignature) {
+            action.setAction(actionSignature);
+            actionSignatureRef.current = actionSignature;
         }
-        updateRef.current++;
     }, [actionSignature]);
     useEffect(() => {
         if (listenerRef.current !== listener) {
@@ -91,7 +95,6 @@ export function useAction(actionSignature, listener, errorListener, beforeAction
             action.removeAllListeners();
             action.removeAllBeforeActionListeners();
             action.removeAllErrorListeners();
-            updateRef.current = 0;
         };
     }, []);
     return action;

package/dist/react/useActionBus.d.ts

@@ -1,6 +1,6 @@
-import type { ActionResponse, ListenerSignature } from "../action";
-import type { BaseActionsMap } from "../actionBus";
-import { createActionBus } from "../actionBus";
-import type { ErrorListenerSignature, ErrorResponse } from "../lib/types";
+import type { ActionResponse, ListenerSignature } from "../action.js";
+import type { BaseActionsMap } from "../actionBus.js";
+import { createActionBus } from "../actionBus.js";
+import type { ErrorListenerSignature, ErrorResponse } from "../lib/types.js";
 export type { ActionResponse, BaseActionsMap, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
 export declare function useActionBus<ActionsMap extends BaseActionsMap = BaseActionsMap>(initialActions?: ActionsMap, errorListener?: ErrorListenerSignature<any[]>): ReturnType<typeof createActionBus<ActionsMap>>;

package/dist/react/useActionBus.js

@@ -1,6 +1,6 @@
 import { useContext, useEffect, useMemo, useRef } from "react";
-import { createActionBus } from "../actionBus";
-import { ErrorBoundaryContext } from "./ErrorBoundary";
+import { createActionBus } from "../actionBus.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
 export function useActionBus(initialActions, errorListener) {
     const boundaryErrorListener = useContext(ErrorBoundaryContext);
     const errorListenerRef = useRef(errorListener);
@@ -15,6 +15,36 @@ export function useActionBus(initialActions, errorListener) {
         }
         return actionBus;
     }, []);
+    // Reconcile the actions map every render. Functions are compared by
+    // reference and never invoked.
+    const appliedActionsRef = useRef(Object.assign({}, initialActions));
+    const nextActions = (initialActions !== null && initialActions !== void 0 ? initialActions : {});
+    // Add newly-introduced actions during render (not in an effect): React runs
+    // child passive effects BEFORE parent passive effects, so a child rendered
+    // in the same pass that subscribes to a new action would otherwise throw
+    // "Action <name> not found". Parent render precedes child render, and
+    // add() is idempotent (a no-op if the action already exists).
+    for (const key in nextActions) {
+        actionBus.add(key, nextActions[key]);
+    }
+    // Replacements and removals can be deferred to a passive effect: a replaced
+    // action keeps its identity/listeners (so subscriptions are unaffected by
+    // timing), and removing late is harmless.
+    useEffect(() => {
+        const next = (initialActions !== null && initialActions !== void 0 ? initialActions : {});
+        const prev = appliedActionsRef.current;
+        for (const key in prev) {
+            if (!(key in next)) {
+                actionBus.removeAction(key);
+            }
+        }
+        for (const key in next) {
+            if (key in prev && next[key] !== prev[key]) {
+                actionBus.replace(key, next[key]);
+            }
+        }
+        appliedActionsRef.current = Object.assign({}, next);
+    });
     useEffect(() => {
         if (errorListenerRef.current !== errorListener) {
             if (errorListenerRef.current) {

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"]>;

package/dist/react/useActionBusStatus.js

@@ -0,0 +1,26 @@
+import { useCallback, useSyncExternalStore } from "react";
+/**
+ * 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 function useActionBusStatus(bus, name) {
+    const subscribe = useCallback((onChange) => {
+        const listener = () => {
+            onChange();
+        };
+        bus.onStatusChange(name, listener);
+        return () => {
+            bus.removeStatusListener(name, listener);
+        };
+    }, [bus, name]);
+    const getSnapshot = useCallback(() => bus.getStatus(name), [bus, name]);
+    const status = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return {
+        loading: status.pending,
+        error: status.error,
+        response: status.response,
+    };
+}

package/dist/react/useActionMap.d.ts

@@ -1,6 +1,6 @@
-import type { ActionResponse, ListenerSignature } from "../action";
-import type { BaseActionsMap } from "../actionBus";
-import { createActionMap } from "../actionMap";
-import type { ErrorListenerSignature, ErrorResponse } from "../lib/types";
+import type { ActionResponse, ListenerSignature } from "../action.js";
+import type { BaseActionsMap } from "../actionBus.js";
+import { createActionMap } from "../actionMap.js";
+import type { ErrorListenerSignature, ErrorResponse } from "../lib/types.js";
 export type { ActionResponse, BaseActionsMap, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
 export declare function useActionMap<M extends BaseActionsMap>(actions: M, errorListener?: ErrorListenerSignature<any[]>): ReturnType<typeof createActionMap<M>>;

package/dist/react/useActionMap.js

@@ -1,9 +1,12 @@
 import { useContext, useEffect, useMemo, useRef } from "react";
-import { createActionMap } from "../actionMap";
-import { ErrorBoundaryContext } from "./ErrorBoundary";
+import { createActionMap } from "../actionMap.js";
+import { ActionMapSetErrorListeners } from "../lib/actionMapInternal.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
 export function useActionMap(actions, errorListener) {
     const boundaryErrorListener = useContext(ErrorBoundaryContext);
-    const changeRef = useRef(0);
+    const committedActionsRef = useRef(actions);
+    const committedErrorListenerRef = useRef(errorListener !== null && errorListener !== void 0 ? errorListener : null);
+    const committedBoundaryErrorListenerRef = useRef(boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null);
     const actionMap = useMemo(() => {
         const errorListeners = [
             ...(errorListener ? [errorListener] : []),
@@ -12,11 +15,41 @@ export function useActionMap(actions, errorListener) {
         const actionMap = createActionMap(actions, errorListeners);
         return actionMap;
     }, []);
+    // The action map TYPE fixes the available keys, so the key set is static:
+    // reconcile values only (in-place setAction) and the forwarded error
+    // listeners. A runtime key-set change is a type-contract violation and
+    // keeps a defensive throw.
     useEffect(() => {
-        if (changeRef.current > 0) {
-            throw new Error("useActionMap() does not support changing actions or errorListener");
+        const next = actions;
+        const prev = committedActionsRef.current;
+        const prevKeys = Object.keys(prev);
+        const nextKeys = Object.keys(next);
+        if (prevKeys.length !== nextKeys.length
+            || nextKeys.some((key) => !(key in prev))) {
+            throw new Error("useActionMap() does not support changing the set of action keys");
         }
-        changeRef.current++;
-    }, [actions, errorListener !== null && errorListener !== void 0 ? errorListener : null, boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null]);
+        for (const key of nextKeys) {
+            if (next[key] !== prev[key]) {
+                actionMap[key].setAction(next[key]);
+            }
+        }
+        committedActionsRef.current = next;
+        const nextErrorListener = errorListener !== null && errorListener !== void 0 ? errorListener : null;
+        const nextBoundaryErrorListener = boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null;
+        if (committedErrorListenerRef.current !== nextErrorListener
+            || committedBoundaryErrorListenerRef.current
+                !== nextBoundaryErrorListener) {
+            const errorListeners = [
+                ...(nextErrorListener ? [nextErrorListener] : []),
+                ...(nextBoundaryErrorListener
+                    ? [nextBoundaryErrorListener]
+                    : []),
+            ];
+            actionMap[ActionMapSetErrorListeners](errorListeners);
+            committedErrorListenerRef.current = nextErrorListener;
+            committedBoundaryErrorListenerRef.current =
+                nextBoundaryErrorListener;
+        }
+    });
     return actionMap;
 }

package/dist/react/useAsyncAction.d.ts

@@ -0,0 +1,20 @@
+import type { ActionResponse, ActionStatus } from "../action.js";
+import type { BaseHandler } from "../lib/types.js";
+export type { ActionResponse, ActionStatus };
+export type AsyncActionState<Response = any> = {
+    loading: boolean;
+    error: Error | null;
+    response: Response | null;
+};
+/**
+ * Wraps a function in an action and exposes its in-flight status, so a
+ * component can drive `loading`/`disabled` without a hand-rolled
+ * `useState(false)`. Returns `[invoke, { loading, error, response }]`.
+ *
+ * For the common app pattern (one shared ActionBus) prefer
+ * `useActionBusStatus`. This hook is for a standalone, component-local action.
+ */
+export declare function useAsyncAction<Fn extends BaseHandler>(fn: Fn): readonly [
+    (...args: Parameters<Fn>) => Promise<ActionResponse<Awaited<ReturnType<Fn>>, Parameters<Fn>>>,
+    AsyncActionState<Awaited<ReturnType<Fn>>>
+];

package/dist/react/useAsyncAction.js

@@ -0,0 +1,53 @@
+import { useCallback, useLayoutEffect, useMemo, useRef, useSyncExternalStore, } from "react";
+import { createAction } from "../action.js";
+/**
+ * Wraps a function in an action and exposes its in-flight status, so a
+ * component can drive `loading`/`disabled` without a hand-rolled
+ * `useState(false)`. Returns `[invoke, { loading, error, response }]`.
+ *
+ * For the common app pattern (one shared ActionBus) prefer
+ * `useActionBusStatus`. This hook is for a standalone, component-local action.
+ */
+export function useAsyncAction(fn) {
+    // Keep the latest fn in a ref. The action wraps a stable indirection that
+    // always calls fnRef.current, so it invokes the current fn even from a
+    // consumer layout effect that runs after a rerender but before this hook's
+    // passive effects — which a useEffect+setAction swap would miss, invoking
+    // the previous fn. The ref is updated in a layout effect (commit phase),
+    // not during render: a render-phase mutation would leak a fn from a
+    // suspended or abandoned concurrent render that never commits into the
+    // currently committed UI. Layout effects run only for committed renders,
+    // and this one runs before any consumer layout effect declared after the
+    // hook call, so consumers still observe the latest fn.
+    const fnRef = useRef(fn);
+    useLayoutEffect(() => {
+        fnRef.current = fn;
+    });
+    const action = useMemo(() => {
+        const action = createAction(((...args) => fnRef.current(...args)));
+        // Without an error listener a throwing fn re-throws out of invoke
+        // (an unhandled rejection) instead of surfacing through status.
+        action.addErrorListener(() => { });
+        return action;
+    }, []);
+    const subscribe = useCallback((onChange) => {
+        const listener = () => {
+            onChange();
+        };
+        action.onStatusChange(listener);
+        return () => {
+            action.removeStatusListener(listener);
+        };
+    }, [action]);
+    const getSnapshot = useCallback(() => action.getStatus(), [action]);
+    const status = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const invoke = useCallback((...args) => action.invoke(...args), [action]);
+    return [
+        invoke,
+        {
+            loading: status.pending,
+            error: status.error,
+            response: status.response,
+        },
+    ];
+}

package/dist/react/useEvent.d.ts

@@ -1,4 +1,4 @@
-import { createEvent, type EventOptions } from "../event";
-import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
+import { createEvent, type EventOptions } from "../event.js";
+import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types.js";
 export type { BaseHandler, ErrorListenerSignature, ErrorResponse, EventOptions, };
 export declare function useEvent<Listener extends BaseHandler = BaseHandler, ErrorListener extends ErrorListenerSignature<Parameters<Listener>> = ErrorListenerSignature<Parameters<Listener>>>(eventOptions?: EventOptions<Listener>, listener?: Listener | null, errorListener?: ErrorListener | null): ReturnType<typeof createEvent<Listener>>;

package/dist/react/useEvent.js

@@ -1,6 +1,8 @@
 import { useContext, useEffect, useMemo, useRef } from "react";
-import { createEvent } from "../event";
-import { ErrorBoundaryContext } from "./ErrorBoundary";
+import { createEvent } from "../event.js";
+import { normalizeEventOptions } from "../lib/normalizeEventOptions.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
+import { areEventOptionsEqual } from "./listenerOptionsEqual.js";
 export function useEvent(eventOptions = {}, listener, errorListener) {
     const boundaryErrorListener = useContext(ErrorBoundaryContext);
     const listenerRef = useRef(listener);
@@ -19,6 +21,20 @@ export function useEvent(eventOptions = {}, listener, errorListener) {
         }
         return event;
     }, []);
+    // Reconcile event options across renders without relying on object
+    // identity. Applied in place via setOptions; triggered count is preserved.
+    const committedEventOptionsRef = useRef(eventOptions);
+    useEffect(() => {
+        if (committedEventOptionsRef.current === eventOptions) {
+            return;
+        }
+        if (!areEventOptionsEqual(committedEventOptionsRef.current, eventOptions)) {
+            // Normalize so fields removed since the last render reset to their
+            // defaults (event.setOptions merges, it does not reset).
+            event.setOptions(normalizeEventOptions(eventOptions));
+        }
+        committedEventOptionsRef.current = eventOptions;
+    });
     useEffect(() => {
         if (listenerRef.current !== listener) {
             if (listenerRef.current) {

package/dist/react/useEventBus.d.ts

@@ -1,4 +1,4 @@
-import { BaseEventMap, createEventBus, DefaultEventMap, EventBusOptions } from "../eventBus";
-import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
+import { BaseEventMap, createEventBus, DefaultEventMap, EventBusOptions } from "../eventBus.js";
+import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types.js";
 export type { BaseEventMap, BaseHandler, ErrorListenerSignature, ErrorResponse, EventBusOptions, };
 export declare function useEventBus<EventsMap extends BaseEventMap = DefaultEventMap>(eventBusOptions?: EventBusOptions<EventsMap>, allEventsListener?: BaseHandler, errorListener?: ErrorListenerSignature<any[]>): ReturnType<typeof createEventBus<EventsMap>>;

package/dist/react/useEventBus.js

@@ -1,9 +1,10 @@
 import { useContext, useEffect, useMemo, useRef } from "react";
-import { createEventBus, } from "../eventBus";
-import { ErrorBoundaryContext } from "./ErrorBoundary";
+import { createEventBus, } from "../eventBus.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
+import { areEventBusOptionsEqual } from "./listenerOptionsEqual.js";
 export function useEventBus(eventBusOptions, allEventsListener, errorListener) {
     const boundaryErrorListener = useContext(ErrorBoundaryContext);
-    const updateRef = useRef(0);
+    const committedOptionsRef = useRef(eventBusOptions);
     const errorListenerRef = useRef(errorListener || null);
     const allEventsListenerRef = useRef(allEventsListener || null);
     const boundaryErrorListenerRef = useRef(boundaryErrorListener || null);
@@ -20,14 +21,18 @@ export function useEventBus(eventBusOptions, allEventsListener, errorListener) {
         }
         return eventBus;
     }, []);
+    // Reconcile event bus options across renders instead of throwing. Present
+    // entries are applied via event.setOptions; a removed event-name entry
+    // leaves the existing event unchanged.
     useEffect(() => {
-        if (eventBusOptions) {
-            if (updateRef.current > 0) {
-                throw new Error("EventBus options can't be updated");
-            }
-            updateRef.current++;
+        if (committedOptionsRef.current === eventBusOptions) {
+            return;
+        }
+        if (!areEventBusOptionsEqual(committedOptionsRef.current, eventBusOptions)) {
+            eventBus.setOptions(eventBusOptions);
         }
-    }, [eventBusOptions]);
+        committedOptionsRef.current = eventBusOptions;
+    });
     useEffect(() => {
         if (allEventsListenerRef.current !== allEventsListener) {
             if (allEventsListenerRef.current) {
@@ -76,7 +81,6 @@ export function useEventBus(eventBusOptions, allEventsListener, errorListener) {
                 eventBus.removeErrorListener(boundaryErrorListenerRef.current);
                 boundaryErrorListenerRef.current = null;
             }
-            updateRef.current = 0;
         };
     }, []);
     return eventBus;

package/dist/react/useListenToAction.d.ts

@@ -1,3 +1,3 @@
-import type { BaseAction } from "../action";
+import type { BaseAction } from "../action.js";
 export type { BaseAction };
 export declare function useListenToAction<TAction extends BaseAction, TListenerSignature extends TAction["__type"]["listenerSignature"] = TAction["__type"]["listenerSignature"], TErrorListenerSignature extends TAction["__type"]["errorListenerSignature"] = TAction["__type"]["errorListenerSignature"], TBeforeActionListenerSignature extends TAction["__type"]["beforeActionSignature"] = TAction["__type"]["beforeActionSignature"]>(action: TAction, listener: TListenerSignature | null, errorListener?: TErrorListenerSignature | null, beforeActionListener?: TBeforeActionListenerSignature | null): void;

package/dist/react/useListenToAction.js

@@ -1,52 +1,31 @@
 import { useCallback, useEffect, useRef } from "react";
 export function useListenToAction(action, listener, errorListener, beforeActionListener) {
     const listenerRef = useRef(listener);
-    const actionRef = useRef(action);
-    const errorListenerRef = useRef(null);
-    const beforeActionListenerRef = useRef(null);
     listenerRef.current = listener;
     const genericHandler = useCallback((arg) => {
         var _a;
         (_a = listenerRef.current) === null || _a === void 0 ? void 0 : _a.call(listenerRef, arg);
     }, []);
     useEffect(() => {
-        actionRef.current.removeListener(genericHandler);
-        actionRef.current = action;
-        actionRef.current.addListener(genericHandler);
-    }, [action]);
+        action.addListener(genericHandler);
+        return () => {
+            action.removeListener(genericHandler);
+        };
+    }, [action, genericHandler]);
     useEffect(() => {
-        if (errorListenerRef.current !== errorListener) {
-            if (errorListenerRef.current) {
-                actionRef.current.removeErrorListener(errorListenerRef.current);
-            }
-            errorListenerRef.current = errorListener || null;
-            if (errorListener) {
-                actionRef.current.addErrorListener(errorListener);
-            }
+        if (errorListener) {
+            action.addErrorListener(errorListener);
+            return () => {
+                action.removeErrorListener(errorListener);
+            };
         }
-    }, [errorListener]);
+    }, [action, errorListener]);
     useEffect(() => {
-        if (beforeActionListenerRef.current !== beforeActionListener) {
-            if (beforeActionListenerRef.current) {
-                actionRef.current.removeBeforeActionListener(beforeActionListenerRef.current);
-            }
-            beforeActionListenerRef.current = beforeActionListener || null;
-            if (beforeActionListener) {
-                actionRef.current.addBeforeActionListener(beforeActionListener);
-            }
+        if (beforeActionListener) {
+            action.addBeforeActionListener(beforeActionListener);
+            return () => {
+                action.removeBeforeActionListener(beforeActionListener);
+            };
         }
-    }, [beforeActionListener]);
-    useEffect(() => {
-        return () => {
-            actionRef.current.removeListener(genericHandler);
-            if (errorListenerRef.current) {
-                actionRef.current.removeErrorListener(errorListenerRef.current);
-                errorListenerRef.current = null;
-            }
-            if (beforeActionListenerRef.current) {
-                actionRef.current.removeBeforeActionListener(beforeActionListenerRef.current);
-                beforeActionListenerRef.current = null;
-            }
-        };
-    }, []);
+    }, [action, beforeActionListener]);
 }

package/dist/react/useListenToActionBus.d.ts

@@ -1,6 +1,6 @@
-import type { BaseActionBus } from "../actionBus";
-import type { ListenerOptions } from "../event";
-import type { ErrorListenerSignature, KeyOf } from "../lib/types";
+import type { BaseActionBus } from "../actionBus.js";
+import type { ListenerOptions } from "../event.js";
+import type { ErrorListenerSignature, KeyOf } from "../lib/types.js";
 export type { BaseActionBus, ErrorListenerSignature, ListenerOptions };
 export declare function useListenToActionBus<TActionBus extends BaseActionBus, TKey extends KeyOf<TActionBus["__type"]["actions"]>, TListener extends TActionBus["__type"]["actions"][TKey]["listenerSignature"], TBeforeActionListener extends TActionBus["__type"]["actions"][TKey]["beforeActionSignature"]>(actionBus: TActionBus, actionName: TKey, listener?: TListener | null | {
     listener?: TListener;

package/dist/react/useListenToActionBus.js

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef } from "react";
+import { useReconciledListener } from "./useReconciledListener.js";
 export function useListenToActionBus(actionBus, actionName, listener, options, errorListener, beforeActionListener) {
     if (listener && typeof listener !== "function") {
         options = listener.options;
@@ -16,17 +17,22 @@ export function useListenToActionBus(actionBus, actionName, listener, options, e
     }, []);
     const genericBeforeActionHandler = useCallback((...args) => {
         var _a;
-        return ((_a = beforeActionListenerRef.current) === null || _a === void 0 ? void 0 : _a.call(beforeActionListenerRef, ...args)) || undefined;
+        return (_a = beforeActionListenerRef.current) === null || _a === void 0 ? void 0 : _a.call(beforeActionListenerRef, ...args);
     }, []);
-    // Main listener + beforeAction listener - tied to actionName
-    useEffect(() => {
-        actionBus.addListener(actionName, genericHandler, options || undefined);
-        actionBus.get(actionName).addBeforeActionListener(genericBeforeActionHandler);
-        return () => {
-            actionBus.removeListener(actionName, genericHandler);
+    // Main listener + beforeAction listener - reconciled across changes
+    useReconciledListener({
+        keyDeps: [actionBus, actionName],
+        options: options !== null && options !== void 0 ? options : undefined,
+        subscribe: (opts) => {
+            actionBus.addListener(actionName, genericHandler, opts !== null && opts !== void 0 ? opts : undefined);
+            actionBus.get(actionName).addBeforeActionListener(genericBeforeActionHandler);
+        },
+        unsubscribe: (ctx) => {
+            actionBus.removeListener(actionName, genericHandler, ctx);
             actionBus.get(actionName).removeBeforeActionListener(genericBeforeActionHandler);
-        };
-    }, [actionBus, actionName, genericHandler, genericBeforeActionHandler]);
+        },
+        update: (ctx, opts) => actionBus.updateListenerOptions(actionName, genericHandler, ctx, opts !== null && opts !== void 0 ? opts : undefined),
+    });
     // Error listener - bus level
     useEffect(() => {
         if (errorListener) {