use-everywhere 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -1,644 +1,688 @@
 'use client';
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BroadcastChannelTransport: () => import_core4.BroadcastChannelTransport,
-  CID_PARAM: () => import_core4.CID_PARAM,
-  DEFAULT_NAME: () => import_core.DEFAULT_NAME,
-  HandshakeTimeoutError: () => import_core4.HandshakeTimeoutError,
-  NoopTransport: () => import_core4.NoopTransport,
-  SharedWorkerTransport: () => import_core4.SharedWorkerTransport,
-  StorageTransport: () => import_core4.StorageTransport,
-  WIRE_VERSION: () => import_core4.WIRE_VERSION,
-  WindowClosedError: () => import_core4.WindowClosedError,
-  connectToOpener: () => import_core4.connectToOpener,
-  createChannel: () => import_core4.createChannel,
-  createLeader: () => import_core4.createLeader,
-  createNamespace: () => createNamespace,
-  createPresence: () => import_core4.createPresence,
-  createSharedReducer: () => import_core4.createSharedReducer,
-  createSharedStore: () => import_core4.createSharedStore,
-  createStoreHooks: () => createStoreHooks,
-  defaultTransport: () => import_core4.defaultTransport,
-  defineChannel: () => defineChannel,
-  enableDebug: () => import_core4.enableDebug,
-  getBusNames: () => import_core4.getBusNames,
-  getLeader: () => getLeader,
-  getSharedStore: () => getSharedStore,
-  getTransportKind: () => import_core4.getTransportKind,
-  getWireSkew: () => import_core4.getWireSkew,
-  indexedDbAdapter: () => import_core4.indexedDbAdapter,
-  isBroadcastChannelAvailable: () => import_core4.isBroadcastChannelAvailable,
-  isSharedWorkerAvailable: () => import_core4.isSharedWorkerAvailable,
-  isStorageEventAvailable: () => import_core4.isStorageEventAvailable,
-  jsonSerializer: () => import_core4.jsonSerializer,
-  localStorageAdapter: () => import_core4.localStorageAdapter,
-  newer: () => import_core4.newer,
-  observeBus: () => import_core4.observeBus,
-  openWindow: () => import_core4.openWindow,
-  sessionStorageAdapter: () => import_core4.sessionStorageAdapter,
-  shallowEqual: () => shallowEqual,
-  useAnswer: () => useAnswer,
-  useAsk: () => useAsk,
-  useChannel: () => useChannel,
-  useClientId: () => useClientId,
-  useHydrated: () => useHydrated,
-  useIsLeader: () => useIsLeader,
-  useLeader: () => useLeader,
-  useLeaderEffect: () => useLeaderEffect,
-  useOnMessage: () => useOnMessage,
-  usePeers: () => usePeers,
-  usePresenceMetadata: () => usePresenceMetadata,
-  useSend: () => useSend,
-  useSharedReducer: () => useSharedReducer,
-  useSharedSelector: () => useSharedSelector,
-  useSharedState: () => useSharedState,
-  useWindowResult: () => useWindowResult,
-  webStorageAdapter: () => import_core4.webStorageAdapter
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/use-shared-state.ts
-var import_react = require("react");
-
-// src/dev.ts
-var inDev = false;
-try {
-  inDev = process.env.NODE_ENV !== "production";
-} catch {
-}
-var warned = /* @__PURE__ */ new Set();
-var DOCS = "https://rxova.org/packages/use-everywhere/errors";
-function diagnostic(code, message) {
-  return `[use-everywhere] ${code}: ${message}
-  \u2192 ${DOCS}/#${code.toLowerCase()}`;
-}
-function devWarn(code, message) {
-  if (!inDev) return;
-  const line = diagnostic(code, message);
-  if (warned.has(line)) return;
-  warned.add(line);
-  console.warn(line);
-}
-var seenInitials = /* @__PURE__ */ new Map();
-function warnOnInitialMismatch(storeName, key, initial) {
-  if (!inDev) return;
-  const id = `${storeName} ${key}`;
-  if (!seenInitials.has(id)) {
-    seenInitials.set(id, initial);
-    return;
-  }
-  const first = seenInitials.get(id);
-  const comparable = (v) => v === null || typeof v !== "object";
-  if (comparable(first) && comparable(initial) && !Object.is(first, initial)) {
-    devWarn(
-      "UE2001",
-      `useSharedState('${key}') was called with different initial values (${String(first)} and ${String(initial)}). The first registration wins, so the second is ignored. Define the default once \u2014 createStoreHooks, or a shared constant.`
-    );
-  }
-}
-
-// src/registry.ts
-var import_core = require("@use-everywhere/core");
-
-// src/server-stubs.ts
-var SERVER_CLIENT_ID = "";
-var EMPTY = Object.freeze({});
-var NO_PEERS = Object.freeze([]);
-var noop = () => {
-};
-var unsubscribe = () => noop;
-var INERT = Object.freeze({
-  clientId: SERVER_CLIENT_ID,
-  // store
-  //
-  // Resolved, unlike the leader's `waitForLeadership` below. A server render
-  // has nothing to restore and is documented to render defaults, so `await
-  // store.hydrated` must proceed — a never-settling promise would hang the
-  // render rather than describe it honestly.
-  hydrated: Promise.resolve(),
-  state: EMPTY,
-  getVersions: () => EMPTY,
-  set: noop,
-  subscribeKey: unsubscribe,
-  registerKey: noop,
-  // store + leader share getSnapshot; presence has getPeers
-  getSnapshot: () => EMPTY,
-  getPeers: () => NO_PEERS,
-  // presence
-  setMetadata: noop,
-  // leader
-  resign: noop,
-  setEligible: noop,
-  // common
-  subscribe: unsubscribe,
-  close: noop
-});
-var createServerStore = () => INERT;
-var createServerPresence = () => INERT;
-var NO_LEADER = Object.freeze({ leaderId: null, isLeader: false });
-var NEVER = () => new Promise(() => {
-});
-var createServerLeader = () => ({
-  ...INERT,
-  strategy: "heartbeat",
-  getSnapshot: () => NO_LEADER,
-  waitForLeadership: NEVER
-});
-var createServerReducer = (initial) => ({
-  ...INERT,
-  getSnapshot: () => initial,
-  dispatch: noop,
-  pendingCount: () => 0
-});
-var createServerChannel = (name) => ({ ...INERT, name, post: noop, on: unsubscribe });
-
-// src/registry.ts
-var stores = /* @__PURE__ */ new Map();
-var presences = /* @__PURE__ */ new Map();
-var channels = /* @__PURE__ */ new Map();
-var leaders = /* @__PURE__ */ new Map();
-var storeConfig = /* @__PURE__ */ new Map();
-var isServer = () => typeof window === "undefined";
-var scopeOptions = {
-  everywhere: {},
-  tabs: { accept: (meta) => meta.kind !== "worker" },
-  tab: { transport: () => new import_core.NoopTransport() }
-};
-function getSharedStore(name = import_core.DEFAULT_NAME, scope = "everywhere") {
-  return getStore(name, scope);
-}
-function configSignature(options) {
-  const persist = options?.persist;
-  if (!persist) return "none";
-  return `persist:${persist.keys?.join(",") ?? "*"}:${persist.debounceMs ?? "default"}:v${persist.version ?? 0}`;
-}
-function configureStore(name, scope, options) {
-  const key = `${scope} ${name}`;
-  if (stores.has(key)) {
-    if (configSignature(storeConfig.get(key)) === configSignature(options)) return;
-    if (process.env.NODE_ENV !== "production") {
-      devWarn(
-        "UE2002",
-        `createStoreHooks('${name}') ran after that store was already created, with different options. The live store keeps the configuration it was built with. Move createStoreHooks to module scope, before any component reads the store.`
-      );
-    }
-    return;
-  }
-  storeConfig.set(key, options);
-}
-function getStore(name, scope = "everywhere") {
-  const key = `${scope} ${name}`;
-  let store = stores.get(key);
-  if (!store) {
-    store = isServer() ? createServerStore() : (0, import_core.createSharedStore)(name, {}, { ...scopeOptions[scope], ...storeConfig.get(key) });
-    stores.set(key, store);
-  }
-  return store;
-}
-function getPresence(name, includeSelf = false) {
-  const key = includeSelf ? `self ${name}` : name;
-  let presence = presences.get(key);
-  if (!presence) {
-    presence = isServer() ? createServerPresence() : (0, import_core.createPresence)(name, { includeSelf });
-    presences.set(key, presence);
-  }
-  return presence;
-}
-function getLeader(name, options) {
-  let leader = leaders.get(name);
-  if (!leader) {
-    leader = isServer() ? createServerLeader() : (0, import_core.createLeader)(name, options);
-    leaders.set(name, leader);
-    if (options) leaderOptions.set(name, options);
-  } else if (options) {
-    warnOnLeaderOptionConflict(name, options);
-  }
-  return leader;
-}
-var leaderOptions = /* @__PURE__ */ new Map();
-function warnOnLeaderOptionConflict(name, options) {
-  const first = leaderOptions.get(name);
-  for (const key of ["heartbeatMs", "leaseMs"]) {
-    const requested = options[key];
-    if (requested !== void 0 && requested !== first?.[key]) {
-      if (process.env.NODE_ENV !== "production") {
-        devWarn(
-          "UE2003",
-          `leader "${name}": ${key} ignored \u2014 the first useLeader/getLeader call fixes the election timings for this tab.`
-        );
-      }
-    }
-  }
-}
-var channelConfig = /* @__PURE__ */ new Map();
-function configureChannel(name, options) {
-  if (channels.has(name)) {
-    const before = Object.keys(channelConfig.get(name)?.schema ?? {}).sort();
-    const after = Object.keys(options.schema ?? {}).sort();
-    if (before.join() === after.join()) return;
-    if (process.env.NODE_ENV !== "production") {
-      devWarn(
-        "UE2004",
-        `defineChannel('${name}') ran after that channel was already created, with different options. The live channel keeps the configuration it was built with. Move defineChannel to module scope, before any component sends or receives on it.`
-      );
-    }
-    return;
-  }
-  channelConfig.set(name, options);
-}
-var reducers = /* @__PURE__ */ new Map();
-function getReducer(name, key, reducer, initial) {
-  const id = `${name} ${key}`;
-  let existing = reducers.get(id);
-  if (!existing) {
-    existing = isServer() ? createServerReducer(initial) : (0, import_core.createSharedReducer)(name, reducer, initial, { key, leader: getLeader(name) });
-    reducers.set(id, existing);
-  }
-  return existing;
-}
-function getChannel(name) {
-  let channel = channels.get(name);
-  if (!channel) {
-    channel = isServer() ? createServerChannel(name) : (0, import_core.createChannel)(name, channelConfig.get(name));
-    channels.set(name, channel);
-  }
-  return channel;
-}
-
-// src/use-shared-state.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_use_peers = require("./use-peers-RhIB77TV.cjs");
+let react = require("react");
+let _use_everywhere_core = require("@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 ?? import_core.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 = (0, import_react.useSyncExternalStore)(
-    (0, import_react.useCallback)((onChange) => store.subscribeKey(key, onChange), [store, key]),
-    () => store.getSnapshot()[key],
-    () => initial
-  );
-  const setValue = (0, import_react.useCallback)(
-    (next) => store.set(key, next),
-    [store, key]
-  );
-  return [value, setValue];
-}
-
-// src/use-shared-reducer.ts
-var import_react2 = require("react");
+	const storeName = options?.store ?? _use_everywhere_core.DEFAULT_NAME;
+	const store = require_use_peers.getStore(storeName, options?.scope ?? "everywhere");
+	store.registerKey(key, initial);
+	if (process.env.NODE_ENV !== "production") require_use_peers.warnOnInitialMismatch(storeName, key, initial);
+	return [(0, react.useSyncExternalStore)((0, react.useCallback)((onChange) => store.subscribeKey(key, onChange), [store, key]), () => store.getSnapshot()[key], () => initial), (0, react.useCallback)((next) => store.set(key, next), [store, key])];
+}
+//#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 ?? import_core.DEFAULT_NAME,
-    options?.key ?? "default",
-    reducer,
-    initial
-  );
-  const value = (0, import_react2.useSyncExternalStore)(
-    (0, import_react2.useCallback)((onChange) => engine.subscribe(onChange), [engine]),
-    () => engine.getSnapshot(),
-    () => initial
-  );
-  const dispatch = (0, import_react2.useCallback)((action) => engine.dispatch(action), [engine]);
-  return [value, dispatch];
-}
-
-// src/use-shared-selector.ts
-var import_react3 = require("react");
+	const engine = require_use_peers.getReducer(options?.name ?? _use_everywhere_core.DEFAULT_NAME, options?.key ?? "default", reducer, initial);
+	return [(0, react.useSyncExternalStore)((0, react.useCallback)((onChange) => engine.subscribe(onChange), [engine]), () => engine.getSnapshot(), () => initial), (0, react.useCallback)((action) => engine.dispatch(action), [engine])];
+}
+//#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 ?? import_core.DEFAULT_NAME, options?.scope ?? "everywhere");
-  const equal = options?.equal ?? Object.is;
-  const selectorRef = (0, import_react3.useRef)(selector);
-  selectorRef.current = selector;
-  const equalRef = (0, import_react3.useRef)(equal);
-  equalRef.current = equal;
-  const cache = (0, import_react3.useRef)(null);
-  const getSelection = (0, import_react3.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 (0, import_react3.useSyncExternalStore)(
-    (0, import_react3.useCallback)((onChange) => store.subscribe(onChange), [store]),
-    getSelection,
-    getSelection
-  );
-}
+	const store = require_use_peers.getStore(options?.store ?? _use_everywhere_core.DEFAULT_NAME, options?.scope ?? "everywhere");
+	const equal = options?.equal ?? Object.is;
+	const selectorRef = (0, react.useRef)(selector);
+	selectorRef.current = selector;
+	const equalRef = (0, react.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 = (0, react.useRef)(null);
+	const getSelection = (0, react.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 (0, react.useSyncExternalStore)((0, react.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]));
-}
-
-// src/use-on-message.ts
-var import_react4 = require("react");
+	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]));
+}
+//#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 require_use_peers.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 = (0, import_react4.useRef)(handler);
-  (0, import_react4.useEffect)(() => {
-    handlerRef.current = handler;
-  });
-  const enabled = options?.enabled ?? true;
-  const once = options?.once ?? false;
-  (0, import_react4.useEffect)(() => {
-    if (!enabled) return;
-    return channel.on(type, (payload, meta) => handlerRef.current(payload, meta), { once });
-  }, [channel, type, enabled, once]);
-}
+	const handlerRef = (0, react.useRef)(handler);
+	(0, react.useEffect)(() => {
+		handlerRef.current = handler;
+	});
+	const enabled = options?.enabled ?? true;
+	const once = options?.once ?? false;
+	(0, react.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 = (0, import_react4.useRef)(responder);
-  (0, import_react4.useEffect)(() => {
-    responderRef.current = responder;
-  });
-  const enabled = options?.enabled ?? true;
-  (0, import_react4.useEffect)(() => {
-    if (!enabled) return;
-    return channel.answer(type, (payload, meta) => responderRef.current(payload, meta));
-  }, [channel, type, enabled]);
-}
+	const responderRef = (0, react.useRef)(responder);
+	(0, react.useEffect)(() => {
+		responderRef.current = responder;
+	});
+	const enabled = options?.enabled ?? true;
+	(0, react.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;
-}
-
-// src/define-channel.ts
+	return channel.ask;
+}
+//#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
-  };
-}
-
-// src/create-store-hooks.ts
+	if (options) require_use_peers.configureChannel(name, options);
+	const useBoundSend = () => useSend(useChannel(name));
+	const useBoundMessage = (type, handler) => useOnMessage(useChannel(name), type, handler);
+	return {
+		get: () => require_use_peers.getChannel(name),
+		useSend: useBoundSend,
+		useOnMessage: useBoundMessage
+	};
+}
+//#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),
-    useSharedState: (key, initial) => useSharedState(key, initial, { store: name, scope })
-  };
-}
-
-// src/use-peers.ts
-var import_react5 = require("react");
-var NO_PEERS2 = Object.freeze([]);
-function usePeers(options) {
-  const presence = getPresence(options?.name ?? import_core.DEFAULT_NAME, options?.includeSelf ?? false);
-  return (0, import_react5.useSyncExternalStore)(
-    (0, import_react5.useCallback)((onChange) => presence.subscribe(onChange), [presence]),
-    () => presence.getPeers(),
-    () => NO_PEERS2
-  );
-}
-function useClientId(options) {
-  const presence = getPresence(options?.name ?? import_core.DEFAULT_NAME);
-  return (0, import_react5.useSyncExternalStore)(
-    // The id never changes for the life of a presence engine, so there is
-    // nothing to subscribe to — but uSES still needs the post-hydration read,
-    // which it performs when it attaches this subscription.
-    (0, import_react5.useCallback)(() => () => {
-    }, [presence]),
-    () => presence.clientId,
-    () => SERVER_CLIENT_ID
-  );
-}
-function usePresenceMetadata(metadata, options) {
-  const presence = getPresence(options?.name ?? import_core.DEFAULT_NAME, options?.includeSelf ?? false);
-  (0, import_react5.useEffect)(() => {
-    presence.setMetadata(metadata);
-  }, [presence, metadata]);
-}
-
-// src/use-hydrated.ts
-var import_react6 = require("react");
+	const scope = options.scope ?? "everywhere";
+	if (options.persist) require_use_peers.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: () => require_use_peers.getStore(name, scope),
+		useSharedState: (key, initial) => useSharedState(key, initial, {
+			store: name,
+			scope
+		})
+	};
+}
+//#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 ?? import_core.DEFAULT_NAME, options?.scope ?? "everywhere");
-  const [ready, setReady] = (0, import_react6.useState)(false);
-  (0, import_react6.useEffect)(() => {
-    let cancelled = false;
-    void store.hydrated.then(() => {
-      if (!cancelled) setReady(true);
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [store]);
-  return ready;
-}
-
-// src/use-leader.ts
-var import_react7 = require("react");
-var NO_LEADER2 = Object.freeze({ leaderId: null, isLeader: false });
+	const store = require_use_peers.getStore(options?.store ?? _use_everywhere_core.DEFAULT_NAME, options?.scope ?? "everywhere");
+	const [ready, setReady] = (0, react.useState)(false);
+	(0, react.useEffect)(() => {
+		let cancelled = false;
+		store.hydrated.then(() => {
+			if (!cancelled) setReady(true);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [store]);
+	return ready;
+}
+//#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 ?? import_core.DEFAULT_NAME, options);
-  const eligible = options?.eligible;
-  (0, import_react7.useEffect)(() => {
-    if (eligible === void 0) return;
-    leader.setEligible(eligible);
-  }, [leader, eligible]);
-  return (0, import_react7.useSyncExternalStore)(
-    (0, import_react7.useCallback)((onChange) => leader.subscribe(onChange), [leader]),
-    () => leader.getSnapshot(),
-    () => NO_LEADER2
-  );
-}
+	const leader = require_use_peers.getLeader(options?.name ?? _use_everywhere_core.DEFAULT_NAME, options);
+	const eligible = options?.eligible;
+	(0, react.useEffect)(() => {
+		if (eligible === void 0) return;
+		leader.setEligible(eligible);
+	}, [leader, eligible]);
+	return (0, react.useSyncExternalStore)((0, react.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 = (0, import_react7.useRef)(effect);
-  (0, import_react7.useEffect)(() => {
-    effectRef.current = effect;
-  });
-  (0, import_react7.useEffect)(() => {
-    if (!isLeader) return;
-    return effectRef.current();
-  }, [isLeader]);
-}
-
-// src/namespace.ts
-var import_core2 = require("@use-everywhere/core");
+	const { isLeader } = useLeader(options);
+	const effectRef = (0, react.useRef)(effect);
+	(0, react.useEffect)(() => {
+		effectRef.current = effect;
+	});
+	(0, react.useEffect)(() => {
+		if (!isLeader) return;
+		return effectRef.current();
+	}, [isLeader]);
+}
+//#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 = (0, import_core2.createNamespace)(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
-var import_react8 = require("react");
-var import_core3 = require("@use-everywhere/core");
-var IDLE = Object.freeze({
-  status: "idle",
-  result: void 0,
-  error: void 0
+	const core = (0, _use_everywhere_core.createNamespace)(namespace);
+	const { busName } = core;
+	return {
+		...core,
+		createStoreHooks: (name, options) => createStoreHooks(busName(name), options),
+		defineChannel: (name, options) => defineChannel(busName(name), options),
+		getSharedStore: (name, scope) => require_use_peers.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) => require_use_peers.usePeers({
+			...options,
+			name: busName(options?.name)
+		}),
+		usePresenceMetadata: (metadata, options) => require_use_peers.usePresenceMetadata(metadata, {
+			...options,
+			name: busName(options?.name)
+		}),
+		useHydrated: (options) => useHydrated({
+			...options,
+			store: busName(options?.store)
+		}),
+		useClientId: (options) => require_use_peers.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)
+		})
+	};
+}
+//#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] = (0, import_react8.useState)(IDLE);
-  const current = (0, import_react8.useRef)(null);
-  const factoryRef = (0, import_react8.useRef)(factory);
-  (0, import_react8.useEffect)(() => {
-    factoryRef.current = factory;
-  });
-  const open = (0, import_react8.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
-        );
-      },
-      () => {
-      }
-      // 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 import_core3.WindowClosedError ? { status: "closed-early", result: void 0, error: err } : { status: "error", result: void 0, error: err }
-        );
-      }
-    );
-  }, []);
-  const post = (0, import_react8.useCallback)((type, payload) => {
-    current.current?.post(type, payload);
-  }, []);
-  const close = (0, import_react8.useCallback)(() => current.current?.close(), []);
-  return { ...state, open, post, close };
-}
-
-// src/index.ts
-var import_core4 = require("@use-everywhere/core");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  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
+	const [state, setState] = (0, react.useState)(IDLE);
+	const current = (0, react.useRef)(null);
+	const factoryRef = (0, react.useRef)(factory);
+	(0, react.useEffect)(() => {
+		factoryRef.current = factory;
+	});
+	const open = (0, react.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 _use_everywhere_core.WindowClosedError ? {
+				status: "closed-early",
+				result: void 0,
+				error: err
+			} : {
+				status: "error",
+				result: void 0,
+				error: err
+			});
+		});
+	}, []);
+	const post = (0, react.useCallback)((type, payload) => {
+		current.current?.post(type, payload);
+	}, []);
+	const close = (0, react.useCallback)(() => current.current?.close(), []);
+	return {
+		...state,
+		open,
+		post,
+		close
+	};
+}
+//#endregion
+Object.defineProperty(exports, "BroadcastChannelTransport", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.BroadcastChannelTransport;
+	}
+});
+Object.defineProperty(exports, "CID_PARAM", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.CID_PARAM;
+	}
+});
+exports.DEFAULT_NAME = _use_everywhere_core.DEFAULT_NAME;
+Object.defineProperty(exports, "HandshakeTimeoutError", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.HandshakeTimeoutError;
+	}
+});
+Object.defineProperty(exports, "NoopTransport", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.NoopTransport;
+	}
+});
+Object.defineProperty(exports, "SharedWorkerTransport", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.SharedWorkerTransport;
+	}
+});
+Object.defineProperty(exports, "StorageTransport", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.StorageTransport;
+	}
+});
+Object.defineProperty(exports, "WIRE_VERSION", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.WIRE_VERSION;
+	}
+});
+Object.defineProperty(exports, "WindowClosedError", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.WindowClosedError;
+	}
+});
+Object.defineProperty(exports, "connectToOpener", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.connectToOpener;
+	}
+});
+Object.defineProperty(exports, "createChannel", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.createChannel;
+	}
+});
+Object.defineProperty(exports, "createLeader", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.createLeader;
+	}
+});
+exports.createNamespace = createNamespace;
+Object.defineProperty(exports, "createPresence", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.createPresence;
+	}
+});
+Object.defineProperty(exports, "createSharedReducer", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.createSharedReducer;
+	}
+});
+Object.defineProperty(exports, "createSharedStore", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.createSharedStore;
+	}
+});
+exports.createStoreHooks = createStoreHooks;
+Object.defineProperty(exports, "defaultTransport", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.defaultTransport;
+	}
+});
+exports.defineChannel = defineChannel;
+Object.defineProperty(exports, "enableDebug", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.enableDebug;
+	}
+});
+Object.defineProperty(exports, "getBusNames", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.getBusNames;
+	}
+});
+exports.getLeader = require_use_peers.getLeader;
+exports.getSharedStore = require_use_peers.getSharedStore;
+Object.defineProperty(exports, "getTransportKind", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.getTransportKind;
+	}
+});
+Object.defineProperty(exports, "getWireSkew", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.getWireSkew;
+	}
+});
+Object.defineProperty(exports, "indexedDbAdapter", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.indexedDbAdapter;
+	}
+});
+Object.defineProperty(exports, "isBroadcastChannelAvailable", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.isBroadcastChannelAvailable;
+	}
+});
+Object.defineProperty(exports, "isSharedWorkerAvailable", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.isSharedWorkerAvailable;
+	}
+});
+Object.defineProperty(exports, "isStorageEventAvailable", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.isStorageEventAvailable;
+	}
+});
+Object.defineProperty(exports, "jsonSerializer", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.jsonSerializer;
+	}
+});
+Object.defineProperty(exports, "localStorageAdapter", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.localStorageAdapter;
+	}
+});
+Object.defineProperty(exports, "newer", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.newer;
+	}
+});
+Object.defineProperty(exports, "observeBus", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.observeBus;
+	}
+});
+Object.defineProperty(exports, "openWindow", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.openWindow;
+	}
+});
+Object.defineProperty(exports, "sessionStorageAdapter", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.sessionStorageAdapter;
+	}
+});
+exports.shallowEqual = shallowEqual;
+exports.useAnswer = useAnswer;
+exports.useAsk = useAsk;
+exports.useChannel = useChannel;
+exports.useClientId = require_use_peers.useClientId;
+exports.useHydrated = useHydrated;
+exports.useIsLeader = useIsLeader;
+exports.useLeader = useLeader;
+exports.useLeaderEffect = useLeaderEffect;
+exports.useOnMessage = useOnMessage;
+exports.usePeers = require_use_peers.usePeers;
+exports.usePresenceMetadata = require_use_peers.usePresenceMetadata;
+exports.useSend = useSend;
+exports.useSharedReducer = useSharedReducer;
+exports.useSharedSelector = useSharedSelector;
+exports.useSharedState = useSharedState;
+exports.useWindowResult = useWindowResult;
+Object.defineProperty(exports, "webStorageAdapter", {
+	enumerable: true,
+	get: function() {
+		return _use_everywhere_core.webStorageAdapter;
+	}
 });