@kuindji/reactive 1.0.23 → 1.1.0

package/dist/react/ErrorBoundary.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorBoundaryContext = void 0;
-exports.ErrorBoundary = ErrorBoundary;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-exports.ErrorBoundaryContext = (0, react_1.createContext)(null);
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useRef } from "react";
+export const ErrorBoundaryContext = createContext(null);
 function ErrorBoundary({ children, listener }) {
-    const boundaryErrorListener = (0, react_1.useContext)(exports.ErrorBoundaryContext);
-    const thisRef = (0, react_1.useRef)(listener);
-    const outerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const boundaryErrorListener = useContext(ErrorBoundaryContext);
+    const thisRef = useRef(listener);
+    const outerRef = useRef(boundaryErrorListener);
     // Keep refs in sync with props
     thisRef.current = listener;
     outerRef.current = boundaryErrorListener;
-    const thisErrorListener = (0, react_1.useCallback)((errorResponse) => {
+    const thisErrorListener = useCallback((errorResponse) => {
         if (thisRef.current) {
             thisRef.current(errorResponse);
         }
@@ -23,6 +19,7 @@ function ErrorBoundary({ children, listener }) {
             throw errorResponse.error;
         }
     }, []);
-    return ((0, jsx_runtime_1.jsx)(exports.ErrorBoundaryContext.Provider, { value: thisErrorListener, children: children }));
+    return (_jsx(ErrorBoundaryContext.Provider, { value: thisErrorListener, children: children }));
 }
-exports.default = ErrorBoundary;
+export default ErrorBoundary;
+export { ErrorBoundary };

package/dist/react/listenerOptionsEqual.d.ts

@@ -0,0 +1,27 @@
+import type { EventOptions, ListenerOptions } from "../event.js";
+import type { BaseEventMap, EventBusOptions } from "../eventBus.js";
+import type { BaseHandler } from "../lib/types.js";
+/**
+ * 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 declare function areTagsEqual(a?: string[], b?: string[]): boolean;
+/**
+ * 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 declare function areListenerOptionsEqual(a?: ListenerOptions | null, b?: ListenerOptions | null): boolean;
+/**
+ * Domain-specific comparator for {@link EventOptions}. Primitives compare after
+ * default semantics; `filter`/`filterContext` compare by reference.
+ */
+export declare function areEventOptionsEqual(a?: EventOptions<BaseHandler> | null, b?: EventOptions<BaseHandler> | null): boolean;
+/**
+ * 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 declare function areEventBusOptionsEqual(a?: EventBusOptions<BaseEventMap> | null, b?: EventBusOptions<BaseEventMap> | null): boolean;

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,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useAction = useAction;
-const react_1 = require("react");
-const action_1 = require("../action");
-const ErrorBoundary_1 = require("./ErrorBoundary");
-function useAction(actionSignature, listener, errorListener, beforeActionListener) {
-    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
-    const updateRef = (0, react_1.useRef)(0);
-    const listenerRef = (0, react_1.useRef)(listener);
-    const errorListenerRef = (0, react_1.useRef)(errorListener);
-    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
-    const beforeActionListenerRef = (0, react_1.useRef)(beforeActionListener);
-    const action = (0, react_1.useMemo)(() => {
-        const action = (0, action_1.createAction)(actionSignature);
+import { useContext, useEffect, useMemo, useRef } from "react";
+import { createAction } from "../action.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
+export function useAction(actionSignature, listener, errorListener, beforeActionListener) {
+    const boundaryErrorListener = useContext(ErrorBoundaryContext);
+    const actionSignatureRef = useRef(actionSignature);
+    const listenerRef = useRef(listener);
+    const errorListenerRef = useRef(errorListener);
+    const boundaryErrorListenerRef = useRef(boundaryErrorListener);
+    const beforeActionListenerRef = useRef(beforeActionListener);
+    const action = useMemo(() => {
+        const action = createAction(actionSignature);
         if (listenerRef.current) {
             action.addListener(listenerRef.current);
         }
@@ -27,13 +24,17 @@ function useAction(actionSignature, listener, errorListener, beforeActionListene
         }
         return action;
     }, []);
-    (0, react_1.useEffect)(() => {
-        if (updateRef.current > 0) {
-            throw new Error("Action cannot be updated");
+    // 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 (actionSignatureRef.current !== actionSignature) {
+            action.setAction(actionSignature);
+            actionSignatureRef.current = actionSignature;
         }
-        updateRef.current++;
     }, [actionSignature]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (listenerRef.current !== listener) {
             if (listenerRef.current) {
                 action.removeListener(listenerRef.current);
@@ -44,7 +45,7 @@ function useAction(actionSignature, listener, errorListener, beforeActionListene
             }
         }
     }, [listener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (errorListenerRef.current !== errorListener) {
             if (errorListenerRef.current) {
                 action.removeErrorListener(errorListenerRef.current);
@@ -55,7 +56,7 @@ function useAction(actionSignature, listener, errorListener, beforeActionListene
             }
         }
     }, [errorListener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
             if (boundaryErrorListenerRef.current) {
                 action.removeErrorListener(boundaryErrorListenerRef.current);
@@ -66,7 +67,7 @@ function useAction(actionSignature, listener, errorListener, beforeActionListene
             }
         }
     }, [boundaryErrorListener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (beforeActionListenerRef.current !== beforeActionListener) {
             if (beforeActionListenerRef.current) {
                 action.removeBeforeActionListener(beforeActionListenerRef.current);
@@ -77,7 +78,7 @@ function useAction(actionSignature, listener, errorListener, beforeActionListene
             }
         }
     }, [beforeActionListener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         return () => {
             if (listenerRef.current) {
                 listenerRef.current = null;
@@ -94,7 +95,6 @@ function useAction(actionSignature, listener, errorListener, beforeActionListene
             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,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useActionBus = useActionBus;
-const react_1 = require("react");
-const actionBus_1 = require("../actionBus");
-const ErrorBoundary_1 = require("./ErrorBoundary");
-function useActionBus(initialActions, errorListener) {
-    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
-    const errorListenerRef = (0, react_1.useRef)(errorListener);
-    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
-    const actionBus = (0, react_1.useMemo)(() => {
-        const actionBus = (0, actionBus_1.createActionBus)(initialActions);
+import { useContext, useEffect, useMemo, useRef } from "react";
+import { createActionBus } from "../actionBus.js";
+import { ErrorBoundaryContext } from "./ErrorBoundary.js";
+export function useActionBus(initialActions, errorListener) {
+    const boundaryErrorListener = useContext(ErrorBoundaryContext);
+    const errorListenerRef = useRef(errorListener);
+    const boundaryErrorListenerRef = useRef(boundaryErrorListener);
+    const actionBus = useMemo(() => {
+        const actionBus = createActionBus(initialActions);
         if (errorListener) {
             actionBus.addErrorListener(errorListener);
         }
@@ -18,7 +15,37 @@ function useActionBus(initialActions, errorListener) {
         }
         return actionBus;
     }, []);
-    (0, react_1.useEffect)(() => {
+    // 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) {
                 actionBus.removeErrorListener(errorListenerRef.current);
@@ -29,7 +56,7 @@ function useActionBus(initialActions, errorListener) {
             }
         }
     }, [errorListener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
             if (boundaryErrorListenerRef.current) {
                 actionBus.removeErrorListener(boundaryErrorListenerRef.current);

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,25 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useActionMap = useActionMap;
-const react_1 = require("react");
-const actionMap_1 = require("../actionMap");
-const ErrorBoundary_1 = require("./ErrorBoundary");
-function useActionMap(actions, errorListener) {
-    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
-    const changeRef = (0, react_1.useRef)(0);
-    const actionMap = (0, react_1.useMemo)(() => {
+import { useContext, useEffect, useMemo, useRef } from "react";
+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 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] : []),
             ...(boundaryErrorListener ? [boundaryErrorListener] : []),
         ].filter(l => l !== undefined);
-        const actionMap = (0, actionMap_1.createActionMap)(actions, errorListeners);
+        const actionMap = createActionMap(actions, errorListeners);
         return actionMap;
     }, []);
-    (0, react_1.useEffect)(() => {
-        if (changeRef.current > 0) {
-            throw new Error("useActionMap() does not support changing actions or errorListener");
+    // 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(() => {
+        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/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,16 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useEvent = useEvent;
-const react_1 = require("react");
-const event_1 = require("../event");
-const ErrorBoundary_1 = require("./ErrorBoundary");
-function useEvent(eventOptions = {}, listener, errorListener) {
-    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
-    const listenerRef = (0, react_1.useRef)(listener);
-    const errorListenerRef = (0, react_1.useRef)(errorListener);
-    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
-    const event = (0, react_1.useMemo)(() => {
-        const event = (0, event_1.createEvent)(eventOptions);
+import { useContext, useEffect, useMemo, useRef } from "react";
+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);
+    const errorListenerRef = useRef(errorListener);
+    const boundaryErrorListenerRef = useRef(boundaryErrorListener);
+    const event = useMemo(() => {
+        const event = createEvent(eventOptions);
         if (listenerRef.current) {
             event.addListener(listenerRef.current);
         }
@@ -22,7 +21,21 @@ function useEvent(eventOptions = {}, listener, errorListener) {
         }
         return event;
     }, []);
-    (0, react_1.useEffect)(() => {
+    // 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) {
                 event.removeListener(listenerRef.current);
@@ -33,7 +46,7 @@ function useEvent(eventOptions = {}, listener, errorListener) {
             }
         }
     }, [listener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (errorListenerRef.current !== errorListener) {
             if (errorListenerRef.current) {
                 event.removeErrorListener(errorListenerRef.current);
@@ -44,7 +57,7 @@ function useEvent(eventOptions = {}, listener, errorListener) {
             }
         }
     }, [errorListener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
             if (boundaryErrorListenerRef.current) {
                 event.removeErrorListener(boundaryErrorListenerRef.current);
@@ -55,7 +68,7 @@ function useEvent(eventOptions = {}, listener, errorListener) {
             }
         }
     }, [boundaryErrorListener]);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         return () => {
             if (listenerRef.current) {
                 event.removeListener(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>>;