use-everywhere 0.13.0 → 1.0.1

package/dist/index.js

@@ -1,418 +1,485 @@
 'use client';
-import {
-  DEFAULT_NAME,
-  configureChannel,
-  configureStore,
-  getChannel,
-  getLeader,
-  getReducer,
-  getSharedStore,
-  getStore,
-  useClientId,
-  usePeers,
-  usePresenceMetadata,
-  warnOnInitialMismatch,
-  warnRenamed
-} from "./chunk-HZ5EI66W.js";
-
-// src/use-shared-state.ts
-import { useCallback, useSyncExternalStore } from "react";
+import { a as configureChannel, c as getLeader, d as getStore, f as warnOnInitialMismatch, i as DEFAULT_NAME, l as getReducer, n as usePeers, o as configureStore, r as usePresenceMetadata, s as getChannel, t as useClientId, u as getSharedStore } from "./use-peers-DtpHGzXE.js";
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { BroadcastChannelTransport, CID_PARAM, HandshakeTimeoutError, NoopTransport, SharedWorkerTransport, StorageTransport, WIRE_VERSION, WindowClosedError, WindowClosedError as WindowClosedError$1, connectToOpener, createChannel, createLeader, createNamespace as createNamespace$1, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isSharedWorkerAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter } from "@use-everywhere/core";
+//#region src/use-shared-state.ts
+/**
+* Like useState, but the value exists in every tab, window, and worker on
+* this origin. Late-joining tabs hydrate to the current value; concurrent
+* writes converge last-writer-wins. Pass options.scope to delimit how much
+* is shared ('everywhere' | 'tabs' | 'tab').
+*
+* Note the convergence rule is last-writer-wins per key, not per operation:
+* two tabs running `set(n => n + 1)` at the same moment agree on one value,
+* and one of the increments is lost. For counters and other accumulating
+* writes, drive them from a single tab (useLeaderEffect) until an op-based
+* primitive lands.
+*/
 function useSharedState(key, initial, options) {
-  const storeName = options?.store ?? DEFAULT_NAME;
-  const store = getStore(storeName, options?.scope ?? "everywhere");
-  store.registerKey(key, initial);
-  if (process.env.NODE_ENV !== "production") {
-    warnOnInitialMismatch(storeName, key, initial);
-  }
-  const value = useSyncExternalStore(
-    useCallback((onChange) => store.subscribeKey(key, onChange), [store, key]),
-    () => store.getSnapshot()[key],
-    () => initial
-  );
-  const setValue = useCallback(
-    (next) => store.set(key, next),
-    [store, key]
-  );
-  return [value, setValue];
+	const storeName = options?.store ?? DEFAULT_NAME;
+	const store = getStore(storeName, options?.scope ?? "everywhere");
+	store.registerKey(key, initial);
+	if (process.env.NODE_ENV !== "production") warnOnInitialMismatch(storeName, key, initial);
+	return [useSyncExternalStore(useCallback((onChange) => store.subscribeKey(key, onChange), [store, key]), () => store.getSnapshot()[key], () => initial), useCallback((next) => store.set(key, next), [store, key])];
 }
-
-// src/use-shared-reducer.ts
-import { useCallback as useCallback2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+//#endregion
+//#region src/use-shared-reducer.ts
+/**
+* Like `useReducer`, but every tab, window, and worker on this origin applies
+* the same actions in the same order.
+*
+* ```tsx
+* const [count, dispatch] = useSharedReducer((n, action) => n + action.by, 0);
+* <button onClick={() => dispatch({ by: 1 })}>{count}</button>;
+* ```
+*
+* Reach for this instead of `useSharedState` whenever a write is *relative to
+* what is already there* — a counter, a total, a list you append to. Shared
+* state converges last-writer-wins on the value, so two tabs incrementing at
+* once both write the same result and one increment vanishes. A reducer sends
+* the action rather than the result, and two increments are two actions.
+*
+* For a plain register — a theme, a selection, a draft — `useSharedState` is
+* still the right tool and the cheaper one.
+*
+* ## The rules
+*
+* **Actions must survive the wire.** They are structured-cloned to every peer,
+* so no functions, no class instances, no DOM nodes.
+*
+* **The reducer must be pure**, and it must be the *same* reducer everywhere.
+* Every client folds the same actions itself; a client whose fold differs gets
+* a different answer, and nothing can detect that. The first caller's function
+* is the one used for the life of the page — a re-render passes a new identity
+* every time, and swapping the fold under a history already applied is exactly
+* the divergence this exists to prevent.
+*
+* **Ordering needs a leader**, which this shares with `useLeader` on the same
+* bus rather than electing a second one. Before a seat is filled — the first
+* moments of the first tab — dispatches are held locally and ordered once it
+* is. They are never lost, only pending.
+*/
 function useSharedReducer(reducer, initial, options) {
-  const engine = getReducer(
-    options?.name ?? DEFAULT_NAME,
-    options?.key ?? "default",
-    reducer,
-    initial
-  );
-  const value = useSyncExternalStore2(
-    useCallback2((onChange) => engine.subscribe(onChange), [engine]),
-    () => engine.getSnapshot(),
-    () => initial
-  );
-  const dispatch = useCallback2((action) => engine.dispatch(action), [engine]);
-  return [value, dispatch];
+	const engine = getReducer(options?.name ?? DEFAULT_NAME, options?.key ?? "default", reducer, initial);
+	return [useSyncExternalStore(useCallback((onChange) => engine.subscribe(onChange), [engine]), () => engine.getSnapshot(), () => initial), useCallback((action) => engine.dispatch(action), [engine])];
 }
-
-// src/use-shared-selector.ts
-import { useCallback as useCallback3, useRef, useSyncExternalStore as useSyncExternalStore3 } from "react";
+//#endregion
+//#region src/use-shared-selector.ts
+/**
+* Read a derived value from a shared store, re-rendering only when it changes.
+*
+* `useSharedState` subscribes to one key, which is the right shape for reading
+* one thing. Reading *across* keys meant either one hook per key or a
+* subscription to the whole store, and the latter re-renders on every write to
+* anything in it.
+*
+* ```tsx
+* const total = useSharedSelector<Cart, number>(
+*   (cart) => cart.items.length + cart.saved.length,
+* );
+* ```
+*
+* The selector runs on every store change; the component only re-renders when
+* its result changes by `equal`.
+*
+* ## It reads, it does not declare
+*
+* `useSharedState(key, initial)` registers `key` with a default. A selector
+* does not — it sees whatever is in the store, so a key nothing has registered
+* or written yet is `undefined`. Write selectors that tolerate that, or declare
+* the defaults with `useSharedState` (or a store initial) somewhere that
+* mounts first.
+*
+* The same applies on a server, where the store is inert and empty: the
+* selector runs against `{}`, and its result is what the server-rendered markup
+* shows.
+*/
 function useSharedSelector(selector, options) {
-  const store = getStore(options?.store ?? DEFAULT_NAME, options?.scope ?? "everywhere");
-  const equal = options?.equal ?? Object.is;
-  const selectorRef = useRef(selector);
-  selectorRef.current = selector;
-  const equalRef = useRef(equal);
-  equalRef.current = equal;
-  const cache = useRef(null);
-  const getSelection = useCallback3(() => {
-    const source = store.getSnapshot();
-    const select = selectorRef.current;
-    const previous = cache.current;
-    if (previous && previous.source === source && previous.select === select) return previous.value;
-    const next = select(source);
-    const value = previous && equalRef.current(previous.value, next) ? previous.value : next;
-    cache.current = { source, select, value };
-    return value;
-  }, [store]);
-  return useSyncExternalStore3(
-    useCallback3((onChange) => store.subscribe(onChange), [store]),
-    getSelection,
-    getSelection
-  );
+	const store = getStore(options?.store ?? DEFAULT_NAME, options?.scope ?? "everywhere");
+	const equal = options?.equal ?? Object.is;
+	const selectorRef = useRef(selector);
+	selectorRef.current = selector;
+	const equalRef = useRef(equal);
+	equalRef.current = equal;
+	/**
+	* The last selection, and what produced it.
+	*
+	* `useSyncExternalStore` re-renders whenever the snapshot getter returns a
+	* value it has not seen, so a selector building a fresh object each call
+	* would loop forever. Caching against the *store* snapshot answers the common
+	* case in one identity check; caching against the selector as well is what
+	* keeps a changed selector from returning last render's answer.
+	*/
+	const cache = useRef(null);
+	const getSelection = useCallback(() => {
+		const source = store.getSnapshot();
+		const select = selectorRef.current;
+		const previous = cache.current;
+		if (previous && previous.source === source && previous.select === select) return previous.value;
+		const next = select(source);
+		const value = previous && equalRef.current(previous.value, next) ? previous.value : next;
+		cache.current = {
+			source,
+			select,
+			value
+		};
+		return value;
+	}, [store]);
+	return useSyncExternalStore(useCallback((onChange) => store.subscribe(onChange), [store]), getSelection, getSelection);
 }
+/** Shallow equality over an object or array, for selectors that build one. */
 function shallowEqual(a, b) {
-  if (Object.is(a, b)) return true;
-  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
-  const left = a;
-  const right = b;
-  const keys = Object.keys(left);
-  if (keys.length !== Object.keys(right).length) return false;
-  return keys.every((key) => Object.is(left[key], right[key]));
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	const left = a;
+	const right = b;
+	const keys = Object.keys(left);
+	if (keys.length !== Object.keys(right).length) return false;
+	return keys.every((key) => Object.is(left[key], right[key]));
 }
-
-// src/use-on-message.ts
-import { useEffect, useRef as useRef2 } from "react";
+//#endregion
+//#region src/use-on-message.ts
+/** Get the page-wide typed channel for `name` (one instance per name). */
 function useChannel(name) {
-  return getChannel(name);
+	return getChannel(name);
 }
+/**
+* Subscribe to one message type. The handler is kept fresh without
+* resubscribing, so it may close over render state.
+*/
 function useOnMessage(channel, type, handler, options) {
-  const handlerRef = useRef2(handler);
-  useEffect(() => {
-    handlerRef.current = handler;
-  });
-  const enabled = options?.enabled ?? true;
-  const once = options?.once ?? false;
-  useEffect(() => {
-    if (!enabled) return;
-    return channel.on(type, (payload, meta) => handlerRef.current(payload, meta), { once });
-  }, [channel, type, enabled, once]);
+	const handlerRef = useRef(handler);
+	useEffect(() => {
+		handlerRef.current = handler;
+	});
+	const enabled = options?.enabled ?? true;
+	const once = options?.once ?? false;
+	useEffect(() => {
+		if (!enabled) return;
+		return channel.on(type, (payload, meta) => handlerRef.current(payload, meta), { once });
+	}, [
+		channel,
+		type,
+		enabled,
+		once
+	]);
 }
+/**
+* Answer `ask`s of one type for as long as this component is mounted.
+*
+* A hook rather than a bare `channel.answer` call because a responder is a
+* subscription: registering one in a render would leave the last unmounted
+* component answering for the page.
+*
+* One responder per type per channel — registering a second replaces the first,
+* which is the same first-wins-then-replace rule `answer` has in core.
+*/
 function useAnswer(channel, type, responder, options) {
-  const responderRef = useRef2(responder);
-  useEffect(() => {
-    responderRef.current = responder;
-  });
-  const enabled = options?.enabled ?? true;
-  useEffect(() => {
-    if (!enabled) return;
-    return channel.answer(type, (payload, meta) => responderRef.current(payload, meta));
-  }, [channel, type, enabled]);
+	const responderRef = useRef(responder);
+	useEffect(() => {
+		responderRef.current = responder;
+	});
+	const enabled = options?.enabled ?? true;
+	useEffect(() => {
+		if (!enabled) return;
+		return channel.answer(type, (payload, meta) => responderRef.current(payload, meta));
+	}, [
+		channel,
+		type,
+		enabled
+	]);
 }
+/** The channel's post function (stable identity per channel). */
 function useSend(channel) {
-  return channel.post;
+	return channel.post;
 }
+/** The channel's ask function (stable identity per channel). */
 function useAsk(channel) {
-  return channel.ask;
+	return channel.ask;
 }
-
-// src/define-channel.ts
+//#endregion
+//#region src/define-channel.ts
+/**
+* Bind a channel name and message map once, at module level, and get fully
+* typed hooks back. Sugar over useChannel/useOnMessage/useSend — the same
+* page-wide channel singleton is shared, so mixing bound and standalone
+* hooks for one name is safe.
+*
+* Options are registered here and applied when the channel is first needed, so
+* declaring a `schema` at module scope still constructs nothing on import.
+*/
 function defineChannel(name, options) {
-  if (options) configureChannel(name, options);
-  const useBoundSend = () => useSend(useChannel(name));
-  const useBoundMessage = (type, handler) => useOnMessage(useChannel(name), type, handler);
-  return {
-    get: () => getChannel(name),
-    useSend: useBoundSend,
-    useOnMessage: useBoundMessage,
-    // Removed in 1.0 along with the standalone renames; see deprecated.ts.
-    useMessage: (type, handler) => {
-      warnRenamed("ChannelHooks.useMessage", "ChannelHooks.useOnMessage");
-      return useBoundMessage(type, handler);
-    }
-  };
+	if (options) configureChannel(name, options);
+	const useBoundSend = () => useSend(useChannel(name));
+	const useBoundMessage = (type, handler) => useOnMessage(useChannel(name), type, handler);
+	return {
+		get: () => getChannel(name),
+		useSend: useBoundSend,
+		useOnMessage: useBoundMessage
+	};
 }
-
-// src/create-store-hooks.ts
+//#endregion
+//#region src/create-store-hooks.ts
+/**
+* Bind a store name — and optionally persistence — once, at module level.
+*
+* Like defineChannel, this does not construct anything: it registers the
+* options the registry will use when the store is first needed, so importing
+* the module has no side effect. The store stays a singleton per name, so
+* `createStoreHooks('settings', { persist })` and a bare
+* `useSharedState('theme', 'dark', { store: 'settings' })` elsewhere resolve to
+* the same store, and both get persistence.
+*
+* Must run before that store exists. Module evaluation always precedes render,
+* so intended usage is automatic; if it does run late it throws rather than
+* quietly handing back a store with no persistence.
+*/
 function createStoreHooks(name, options = {}) {
-  const scope = options.scope ?? "everywhere";
-  if (options.persist) {
-    configureStore(name, scope, {
-      persist: {
-        adapter: options.persist,
-        ...options.persistKeys ? { keys: options.persistKeys } : {},
-        ...options.persistDebounceMs === void 0 ? {} : { debounceMs: options.persistDebounceMs },
-        ...options.persistVersion === void 0 ? {} : { version: options.persistVersion },
-        ...options.migrate ? { migrate: options.migrate } : {},
-        ...options.onRestoreError ? { onRestoreError: options.onRestoreError } : {}
-      }
-    });
-  }
-  return {
-    store: () => getStore(name, scope),
-    // Removed in 1.0 along with the standalone renames; see deprecated.ts.
-    get: () => {
-      warnRenamed("StoreHooks.get()", "StoreHooks.store()");
-      return getStore(name, scope);
-    },
-    useSharedState: (key, initial) => useSharedState(key, initial, { store: name, scope })
-  };
+	const scope = options.scope ?? "everywhere";
+	if (options.persist) configureStore(name, scope, { persist: {
+		adapter: options.persist,
+		...options.persistKeys ? { keys: options.persistKeys } : {},
+		...options.persistDebounceMs === void 0 ? {} : { debounceMs: options.persistDebounceMs },
+		...options.persistVersion === void 0 ? {} : { version: options.persistVersion },
+		...options.migrate ? { migrate: options.migrate } : {},
+		...options.onRestoreError ? { onRestoreError: options.onRestoreError } : {}
+	} });
+	return {
+		store: () => getStore(name, scope),
+		useSharedState: (key, initial) => useSharedState(key, initial, {
+			store: name,
+			scope
+		})
+	};
 }
-
-// src/use-hydrated.ts
-import { useEffect as useEffect2, useState } from "react";
+//#endregion
+//#region src/use-hydrated.ts
+/**
+* Whether a persisted store has finished restoring.
+*
+* `false` on the first render, then `true` once the restore lands — including
+* the cases where there is nothing to restore, which settle immediately.
+*
+* Deliberately `false` first even for a synchronous adapter that has already
+* finished. The alternative is a value that differs between the server render
+* and the browser's hydrating render, which is a hydration mismatch on every
+* app that uses it — the same reason `useClientId` reports `''` until the
+* commit after hydration.
+*
+* The gap this closes only exists for **async** adapters, and it is one
+* last-writer-wins makes invisible: a keystroke landing before the restore
+* writes at counter 1, the restore arrives holding counter 5, and the newer
+* keystroke is correctly discarded. The behaviour is right; the surprise is
+* total. Gate the input and there is no gap:
+*
+* ```tsx
+* const ready = useHydrated({ store: 'settings' });
+* return <input disabled={!ready} value={draft} onChange={…} />;
+* ```
+*
+* A synchronous adapter — `localStorageAdapter` and friends — has already
+* restored by the time the store is handed back, so there is no gap to guard
+* and this simply flips to `true` in the commit after mount.
+*/
 function useHydrated(options) {
-  const store = getStore(options?.store ?? DEFAULT_NAME, options?.scope ?? "everywhere");
-  const [ready, setReady] = useState(false);
-  useEffect2(() => {
-    let cancelled = false;
-    void store.hydrated.then(() => {
-      if (!cancelled) setReady(true);
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [store]);
-  return ready;
+	const store = getStore(options?.store ?? DEFAULT_NAME, options?.scope ?? "everywhere");
+	const [ready, setReady] = useState(false);
+	useEffect(() => {
+		let cancelled = false;
+		store.hydrated.then(() => {
+			if (!cancelled) setReady(true);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [store]);
+	return ready;
 }
-
-// src/use-leader.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef3, useSyncExternalStore as useSyncExternalStore4 } from "react";
-var NO_LEADER = Object.freeze({ leaderId: null, isLeader: false });
+//#endregion
+//#region src/use-leader.ts
+const NO_LEADER = Object.freeze({
+	leaderId: null,
+	isLeader: false
+});
+/**
+* Who currently holds the seat on this bus, and whether it is us. Exactly one
+* tab leads; opening another does not steal it, and closing the leader hands it
+* over at once.
+*/
 function useLeader(options) {
-  const leader = getLeader(options?.name ?? DEFAULT_NAME, options);
-  const eligible = options?.eligible;
-  useEffect3(() => {
-    if (eligible === void 0) return;
-    leader.setEligible(eligible);
-  }, [leader, eligible]);
-  return useSyncExternalStore4(
-    useCallback4((onChange) => leader.subscribe(onChange), [leader]),
-    () => leader.getSnapshot(),
-    () => NO_LEADER
-  );
+	const leader = getLeader(options?.name ?? DEFAULT_NAME, options);
+	const eligible = options?.eligible;
+	useEffect(() => {
+		if (eligible === void 0) return;
+		leader.setEligible(eligible);
+	}, [leader, eligible]);
+	return useSyncExternalStore(useCallback((onChange) => leader.subscribe(onChange), [leader]), () => leader.getSnapshot(), () => NO_LEADER);
 }
+/** Is this tab the leader? */
 function useIsLeader(options) {
-  return useLeader(options).isLeader;
+	return useLeader(options).isLeader;
 }
+/**
+* Run an effect only in the tab that holds the seat, and tear it down when the
+* seat moves. The one place to put "exactly one tab owns the socket".
+*/
 function useLeaderEffect(effect, options) {
-  const { isLeader } = useLeader(options);
-  const effectRef = useRef3(effect);
-  useEffect3(() => {
-    effectRef.current = effect;
-  });
-  useEffect3(() => {
-    if (!isLeader) return;
-    return effectRef.current();
-  }, [isLeader]);
+	const { isLeader } = useLeader(options);
+	const effectRef = useRef(effect);
+	useEffect(() => {
+		effectRef.current = effect;
+	});
+	useEffect(() => {
+		if (!isLeader) return;
+		return effectRef.current();
+	}, [isLeader]);
 }
-
-// src/namespace.ts
-import {
-  createNamespace as createCoreNamespace
-} from "@use-everywhere/core";
+//#endregion
+//#region src/namespace.ts
+/**
+* Namespaced hooks and factories, so two independently deployed apps on one
+* origin cannot collide by both taking the defaults.
+*
+* ```ts
+* // checkout/bus.ts
+* export const checkout = createNamespace('checkout');
+*
+* // anywhere in the checkout app
+* const [items, setItems] = checkout.useSharedState('items', []);
+* ```
+*
+* Call it **at module scope**, like `createStoreHooks` and `defineChannel`. It
+* builds a small object of bound functions, and rebuilding that on every render
+* would hand React a new `useSharedState` identity each time — harmless for the
+* hooks themselves, which key off the bus name, but pointless work and a
+* confusing thing to see in a profile.
+*
+* See the core `createNamespace` for what a namespace does and does not
+* guarantee. In short: it prevents collision, not access.
+*/
 function createNamespace(namespace) {
-  const core = createCoreNamespace(namespace);
-  const { busName } = core;
-  return {
-    ...core,
-    createStoreHooks: (name, options) => createStoreHooks(busName(name), options),
-    defineChannel: (name, options) => defineChannel(busName(name), options),
-    getSharedStore: (name, scope) => getSharedStore(busName(name), scope),
-    useSharedState: (key, initial, options) => useSharedState(key, initial, { ...options, store: busName(options?.store) }),
-    useSharedSelector: (selector, options) => useSharedSelector(selector, { ...options, store: busName(options?.store) }),
-    // Removed in 1.0 along with the standalone renames; see deprecated.ts.
-    defineStore: (name, options) => {
-      warnRenamed("Namespace.defineStore", "Namespace.createStoreHooks");
-      return createStoreHooks(busName(name), options);
-    },
-    useSharedStore: (selector, options) => {
-      warnRenamed("Namespace.useSharedStore", "Namespace.useSharedSelector");
-      return useSharedSelector(selector, { ...options, store: busName(options?.store) });
-    },
-    usePeers: (options) => usePeers({ ...options, name: busName(options?.name) }),
-    usePresenceMetadata: (metadata, options) => usePresenceMetadata(metadata, { ...options, name: busName(options?.name) }),
-    useHydrated: (options) => useHydrated({ ...options, store: busName(options?.store) }),
-    useClientId: (options) => useClientId({ name: busName(options?.name) }),
-    useLeader: (options) => useLeader({ ...options, name: busName(options?.name) }),
-    useIsLeader: (options) => useIsLeader({ ...options, name: busName(options?.name) }),
-    useLeaderEffect: (effect, options) => useLeaderEffect(effect, { ...options, name: busName(options?.name) })
-  };
+	const core = createNamespace$1(namespace);
+	const { busName } = core;
+	return {
+		...core,
+		createStoreHooks: (name, options) => createStoreHooks(busName(name), options),
+		defineChannel: (name, options) => defineChannel(busName(name), options),
+		getSharedStore: (name, scope) => getSharedStore(busName(name), scope),
+		useSharedState: (key, initial, options) => useSharedState(key, initial, {
+			...options,
+			store: busName(options?.store)
+		}),
+		useSharedSelector: (selector, options) => useSharedSelector(selector, {
+			...options,
+			store: busName(options?.store)
+		}),
+		usePeers: (options) => usePeers({
+			...options,
+			name: busName(options?.name)
+		}),
+		usePresenceMetadata: (metadata, options) => usePresenceMetadata(metadata, {
+			...options,
+			name: busName(options?.name)
+		}),
+		useHydrated: (options) => useHydrated({
+			...options,
+			store: busName(options?.store)
+		}),
+		useClientId: (options) => useClientId({ name: busName(options?.name) }),
+		useLeader: (options) => useLeader({
+			...options,
+			name: busName(options?.name)
+		}),
+		useIsLeader: (options) => useIsLeader({
+			...options,
+			name: busName(options?.name)
+		}),
+		useLeaderEffect: (effect, options) => useLeaderEffect(effect, {
+			...options,
+			name: busName(options?.name)
+		})
+	};
 }
-
-// src/use-window-result.ts
-import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef4, useState as useState2 } from "react";
-import { WindowClosedError } from "@use-everywhere/core";
-var IDLE = Object.freeze({
-  status: "idle",
-  result: void 0,
-  error: void 0
+//#endregion
+//#region src/use-window-result.ts
+const IDLE = Object.freeze({
+	status: "idle",
+	result: void 0,
+	error: void 0
 });
+/**
+* Drive an openWindow() flow from a component: the factory is called on
+* open(), and the child window's lifecycle is folded into render state.
+* Reopening replaces the previous window; a stale window's outcome is ignored.
+*
+* The child window deliberately outlives an unmount: closing a payment page
+* because a route changed would lose the user's in-flight transaction. Call
+* close() if the component owns the window's lifetime.
+*/
 function useWindowResult(factory) {
-  const [state, setState] = useState2(IDLE);
-  const current = useRef4(null);
-  const factoryRef = useRef4(factory);
-  useEffect4(() => {
-    factoryRef.current = factory;
-  });
-  const open = useCallback5(() => {
-    current.current?.close();
-    let opened;
-    try {
-      opened = factoryRef.current();
-    } catch (err) {
-      setState({ status: "error", result: void 0, error: err });
-      return;
-    }
-    current.current = opened;
-    setState({ status: "opening", result: void 0, error: void 0 });
-    const fresh = () => current.current === opened;
-    opened.ready.then(
-      () => {
-        if (!fresh()) return;
-        setState(
-          (s) => s.status === "opening" ? { status: "connected", result: void 0, error: void 0 } : s
-        );
-      },
-      () => {
-      }
-      // surfaced through result below
-    );
-    opened.result.then(
-      (value) => {
-        if (fresh()) setState({ status: "done", result: value, error: void 0 });
-      },
-      (err) => {
-        if (!fresh()) return;
-        setState(
-          err instanceof WindowClosedError ? { status: "closed-early", result: void 0, error: err } : { status: "error", result: void 0, error: err }
-        );
-      }
-    );
-  }, []);
-  const post = useCallback5((type, payload) => {
-    current.current?.post(type, payload);
-  }, []);
-  const close = useCallback5(() => current.current?.close(), []);
-  return { ...state, open, post, close };
-}
-
-// src/deprecated.ts
-function useMessage(channel, type, handler, options) {
-  warnRenamed("useMessage", "useOnMessage");
-  useOnMessage(channel, type, handler, options);
-}
-function useOpenedWindow(factory) {
-  warnRenamed("useOpenedWindow", "useWindowResult");
-  return useWindowResult(factory);
-}
-function useSharedStore(selector, options) {
-  warnRenamed("useSharedStore", "useSharedSelector");
-  return useSharedSelector(selector, options);
-}
-function defineStore(name, options = {}) {
-  warnRenamed("defineStore", "createStoreHooks");
-  return createStoreHooks(name, options);
+	const [state, setState] = useState(IDLE);
+	const current = useRef(null);
+	const factoryRef = useRef(factory);
+	useEffect(() => {
+		factoryRef.current = factory;
+	});
+	const open = useCallback(() => {
+		current.current?.close();
+		let opened;
+		try {
+			opened = factoryRef.current();
+		} catch (err) {
+			setState({
+				status: "error",
+				result: void 0,
+				error: err
+			});
+			return;
+		}
+		current.current = opened;
+		setState({
+			status: "opening",
+			result: void 0,
+			error: void 0
+		});
+		const fresh = () => current.current === opened;
+		opened.ready.then(() => {
+			if (!fresh()) return;
+			setState((s) => s.status === "opening" ? {
+				status: "connected",
+				result: void 0,
+				error: void 0
+			} : s);
+		}, () => {});
+		opened.result.then((value) => {
+			if (fresh()) setState({
+				status: "done",
+				result: value,
+				error: void 0
+			});
+		}, (err) => {
+			if (!fresh()) return;
+			setState(err instanceof WindowClosedError$1 ? {
+				status: "closed-early",
+				result: void 0,
+				error: err
+			} : {
+				status: "error",
+				result: void 0,
+				error: err
+			});
+		});
+	}, []);
+	const post = useCallback((type, payload) => {
+		current.current?.post(type, payload);
+	}, []);
+	const close = useCallback(() => current.current?.close(), []);
+	return {
+		...state,
+		open,
+		post,
+		close
+	};
 }
-
-// src/index.ts
-import {
-  createChannel,
-  createSharedStore,
-  createSharedReducer,
-  createPresence,
-  createLeader,
-  webStorageAdapter,
-  localStorageAdapter,
-  sessionStorageAdapter,
-  indexedDbAdapter,
-  jsonSerializer,
-  openWindow,
-  connectToOpener,
-  CID_PARAM,
-  WindowClosedError as WindowClosedError2,
-  HandshakeTimeoutError,
-  newer,
-  observeBus,
-  enableDebug,
-  getBusNames,
-  getTransportKind,
-  getWireSkew,
-  WIRE_VERSION,
-  BroadcastChannelTransport,
-  NoopTransport,
-  StorageTransport,
-  SharedWorkerTransport,
-  defaultTransport,
-  isBroadcastChannelAvailable,
-  isStorageEventAvailable,
-  isSharedWorkerAvailable
-} from "@use-everywhere/core";
-export {
-  BroadcastChannelTransport,
-  CID_PARAM,
-  DEFAULT_NAME,
-  HandshakeTimeoutError,
-  NoopTransport,
-  SharedWorkerTransport,
-  StorageTransport,
-  WIRE_VERSION,
-  WindowClosedError2 as WindowClosedError,
-  connectToOpener,
-  createChannel,
-  createLeader,
-  createNamespace,
-  createPresence,
-  createSharedReducer,
-  createSharedStore,
-  createStoreHooks,
-  defaultTransport,
-  defineChannel,
-  defineStore,
-  enableDebug,
-  getBusNames,
-  getLeader,
-  getSharedStore,
-  getTransportKind,
-  getWireSkew,
-  indexedDbAdapter,
-  isBroadcastChannelAvailable,
-  isSharedWorkerAvailable,
-  isStorageEventAvailable,
-  jsonSerializer,
-  localStorageAdapter,
-  newer,
-  observeBus,
-  openWindow,
-  sessionStorageAdapter,
-  shallowEqual,
-  useAnswer,
-  useAsk,
-  useChannel,
-  useClientId,
-  useHydrated,
-  useIsLeader,
-  useLeader,
-  useLeaderEffect,
-  useMessage,
-  useOnMessage,
-  useOpenedWindow,
-  usePeers,
-  usePresenceMetadata,
-  useSend,
-  useSharedReducer,
-  useSharedSelector,
-  useSharedState,
-  useSharedStore,
-  useWindowResult,
-  webStorageAdapter
-};
+//#endregion
+export { BroadcastChannelTransport, CID_PARAM, DEFAULT_NAME, HandshakeTimeoutError, NoopTransport, SharedWorkerTransport, StorageTransport, WIRE_VERSION, WindowClosedError, connectToOpener, createChannel, createLeader, createNamespace, createPresence, createSharedReducer, createSharedStore, createStoreHooks, defaultTransport, defineChannel, enableDebug, getBusNames, getLeader, getSharedStore, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isSharedWorkerAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, shallowEqual, useAnswer, useAsk, useChannel, useClientId, useHydrated, useIsLeader, useLeader, useLeaderEffect, useOnMessage, usePeers, usePresenceMetadata, useSend, useSharedReducer, useSharedSelector, useSharedState, useWindowResult, webStorageAdapter };