use-everywhere 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { SharedStore, LeaderOptions, Leader, MessageMap, ReplyMap, Channel, MessageMeta, ChannelOptions, PersistAdapter, RestoreError, Peer, LeaderSnapshot, Namespace, OpenedWindow, WindowClosedError } from '@use-everywhere/core';
-export { AskOptions, BroadcastChannelTransport, BusEvent, BusObserver, BusWire, CID_PARAM, Channel, ChannelOptions, CommonOptions, ConnectToOpenerOptions, DEFAULT_NAME, DebugOptions, HandshakeTimeoutError, IndexedDbAdapterOptions, InvalidPayload, Leader, LeaderOptions, LeaderSnapshot, LeaderStrategy, LockManagerLike, MessageEventLike, MessageMap, MessageMeta, MessagePortLike, Namespace, NoopTransport, OnInvalid, OnOptions, OpenWindowOptions, OpenedWindow, OpenerConnection, Peer, PeerKind, PersistAdapter, PersistOptions, Persisted, PostOptions, Presence, PresenceOptions, ReplyMap, RestoreError, SchemaMap, SchemaOptions, Serializer, SharedReducer, SharedReducerOptions, SharedStore, SharedStoreOptions, SharedWorkerLike, SharedWorkerTransport, SharedWorkerTransportOptions, StandardSchemaV1, StorageLike, StorageTransport, Transport, TransportKind, Version, WIRE_VERSION, WebStorageAdapterOptions, WindowClosedError, WindowEventTarget, WindowLike, connectToOpener, createChannel, createLeader, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isSharedWorkerAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter } from '@use-everywhere/core';
 
+import { AskOptions, BroadcastChannelTransport, BusEvent, BusObserver, BusWire, CID_PARAM, Channel, Channel as Channel$1, ChannelOptions, ChannelOptions as ChannelOptions$1, CommonOptions, ConnectToOpenerOptions, DEFAULT_NAME, DebugOptions, HandshakeTimeoutError, IndexedDbAdapterOptions, InvalidPayload, Leader, Leader as Leader$1, LeaderOptions, LeaderOptions as LeaderOptions$1, LeaderSnapshot, LeaderSnapshot as LeaderSnapshot$1, LeaderStrategy, LockManagerLike, MessageEventLike, MessageMap, MessageMap as MessageMap$1, MessageMeta, MessageMeta as MessageMeta$1, MessagePortLike, Namespace, Namespace as Namespace$1, NoopTransport, OnInvalid, OnOptions, OpenWindowOptions, OpenedWindow, OpenedWindow as OpenedWindow$1, OpenerConnection, Peer, Peer as Peer$1, PeerKind, PersistAdapter, PersistAdapter as PersistAdapter$1, PersistOptions, Persisted, PostOptions, Presence, PresenceOptions, ReplyMap, ReplyMap as ReplyMap$1, RestoreError, RestoreError as RestoreError$1, SchemaMap, SchemaOptions, Serializer, SharedReducer, SharedReducerOptions, SharedStore, SharedStore as SharedStore$1, SharedStoreOptions, SharedWorkerLike, SharedWorkerTransport, SharedWorkerTransportOptions, StandardSchemaV1, StorageLike, StorageTransport, Transport, TransportKind, Version, WIRE_VERSION, WebStorageAdapterOptions, WindowClosedError, WindowClosedError as WindowClosedError$1, WindowEventTarget, WindowLike, connectToOpener, createChannel, createLeader, 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.types.d.ts
 /**
  * How far a shared value travels:
  * - 'everywhere' — every tab, window, and worker on this origin (default)
@@ -9,12 +9,13 @@ export { AskOptions, BroadcastChannelTransport, BusEvent, BusObserver, BusWire,
  */
 type ShareScope = 'everywhere' | 'tabs' | 'tab';
 interface UseSharedStateOptions {
-    /** Store name; keys live in a namespace per store. Default 'use-everywhere'. */
-    store?: string;
-    /** How much to share. Default 'everywhere'. */
-    scope?: ShareScope;
+  /** Store name; keys live in a namespace per store. Default 'use-everywhere'. */
+  store?: string;
+  /** How much to share. Default 'everywhere'. */
+  scope?: ShareScope;
 }
-
+//#endregion
+//#region src/use-shared-state.d.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
@@ -27,13 +28,14 @@ interface UseSharedStateOptions {
  * writes, drive them from a single tab (useLeaderEffect) until an op-based
  * primitive lands.
  */
-declare function useSharedState<T>(key: string, initial: T, options?: UseSharedStateOptions): [T, (next: T | ((prev: T) => T)) => void];
-
+export declare function useSharedState<T>(key: string, initial: T, options?: UseSharedStateOptions): [T, (next: T | ((prev: T) => T)) => void];
+//#endregion
+//#region src/use-shared-reducer.d.ts
 interface UseSharedReducerOptions {
-    /** Bus name. Default 'use-everywhere'. */
-    name?: string;
-    /** Which reducer this is, when several share a bus. Default 'default'. */
-    key?: string;
+  /** Bus name. Default 'use-everywhere'. */
+  name?: string;
+  /** Which reducer this is, when several share a bus. Default 'default'. */
+  key?: string;
 }
 /**
  * Like `useReducer`, but every tab, window, and worker on this origin applies
@@ -70,17 +72,18 @@ interface UseSharedReducerOptions {
  * moments of the first tab — dispatches are held locally and ordered once it
  * is. They are never lost, only pending.
  */
-declare function useSharedReducer<S, A>(reducer: (state: S, action: A) => S, initial: S, options?: UseSharedReducerOptions): [S, (action: A) => void];
-
+export declare function useSharedReducer<S, A>(reducer: (state: S, action: A) => S, initial: S, options?: UseSharedReducerOptions): [S, (action: A) => void];
+//#endregion
+//#region src/use-shared-selector.d.ts
 interface UseSharedSelectorOptions extends UseSharedStateOptions {
-    /**
-     * Whether two selected values count as the same. Default `Object.is`.
-     *
-     * A selector returning an object or array builds a new one every time it
-     * runs, so `Object.is` never matches and the component re-renders on every
-     * write to the store. Pass a shallow comparison for those.
-     */
-    equal?: (a: unknown, b: unknown) => boolean;
+  /**
+   * Whether two selected values count as the same. Default `Object.is`.
+   *
+   * A selector returning an object or array builds a new one every time it
+   * runs, so `Object.is` never matches and the component re-renders on every
+   * write to the store. Pass a shallow comparison for those.
+   */
+  equal?: (a: unknown, b: unknown) => boolean;
 }
 /**
  * Read a derived value from a shared store, re-rendering only when it changes.
@@ -111,42 +114,45 @@ interface UseSharedSelectorOptions extends UseSharedStateOptions {
  * selector runs against `{}`, and its result is what the server-rendered markup
  * shows.
  */
-declare function useSharedSelector<S extends Record<string, unknown>, T>(selector: (state: S) => T, options?: UseSharedSelectorOptions): T;
+export declare function useSharedSelector<S extends Record<string, unknown>, T>(selector: (state: S) => T, options?: UseSharedSelectorOptions): T;
 /** Shallow equality over an object or array, for selectors that build one. */
-declare function shallowEqual(a: unknown, b: unknown): boolean;
-
+export declare function shallowEqual(a: unknown, b: unknown): boolean;
+//#endregion
+//#region src/registry.types.d.ts
 /** Registry stores hold arbitrary keys — shape is decided by the hooks using them. */
-type AnyStore = SharedStore<Record<string, unknown>>;
-
+type AnyStore = SharedStore$1<Record<string, unknown>>;
+//#endregion
+//#region src/registry.d.ts
 /** Imperative access to the store behind useSharedState (patch logs, non-React code). */
-declare function getSharedStore(name?: string, scope?: ShareScope): AnyStore;
+export declare function getSharedStore(name?: string, scope?: ShareScope): AnyStore;
 /**
  * One Leader per name per tab. Eligibility is deliberately *not* part of the
  * key: two Leaders on one name would share a bus and a clientId, and since a
  * post never loops back locally, neither would ever see the other's claims.
  * Timing options are first-wins, like every other engine here.
  */
-declare function getLeader(name: string, options?: LeaderOptions): Leader;
-
+export declare function getLeader(name: string, options?: LeaderOptions$1): Leader$1;
+//#endregion
+//#region src/use-on-message.d.ts
 /** Get the page-wide typed channel for `name` (one instance per name). */
-declare function useChannel<M extends MessageMap, R extends ReplyMap<M> = Record<never, never>>(name: string): Channel<M, R>;
+export declare function useChannel<M extends MessageMap$1, R extends ReplyMap$1<M> = Record<never, never>>(name: string): Channel$1<M, R>;
 interface UseOnMessageOptions {
-    /**
-     * Subscribe at all. Default true.
-     *
-     * `false` unsubscribes rather than filtering inside the handler, so a
-     * component that is not interested costs nothing — and the alternative,
-     * calling the hook conditionally, is not allowed.
-     */
-    enabled?: boolean;
-    /** Unsubscribe after the first message. */
-    once?: boolean;
+  /**
+   * Subscribe at all. Default true.
+   *
+   * `false` unsubscribes rather than filtering inside the handler, so a
+   * component that is not interested costs nothing — and the alternative,
+   * calling the hook conditionally, is not allowed.
+   */
+  enabled?: boolean;
+  /** Unsubscribe after the first message. */
+  once?: boolean;
 }
 /**
  * Subscribe to one message type. The handler is kept fresh without
  * resubscribing, so it may close over render state.
  */
-declare function useOnMessage<M extends MessageMap, R extends ReplyMap<M>, K extends keyof M & string>(channel: Channel<M, R>, type: K, handler: (payload: M[K], meta: MessageMeta) => void, options?: UseOnMessageOptions): void;
+export declare function useOnMessage<M extends MessageMap$1, R extends ReplyMap$1<M>, K extends keyof M & string>(channel: Channel$1<M, R>, type: K, handler: (payload: M[K], meta: MessageMeta$1) => void, options?: UseOnMessageOptions): void;
 /**
  * Answer `ask`s of one type for as long as this component is mounted.
  *
@@ -157,27 +163,29 @@ declare function useOnMessage<M extends MessageMap, R extends ReplyMap<M>, K ext
  * 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.
  */
-declare function useAnswer<M extends MessageMap, R extends ReplyMap<M>, K extends keyof M & keyof R & string>(channel: Channel<M, R>, type: K, responder: (payload: M[K], meta: MessageMeta) => R[K], options?: {
-    enabled?: boolean;
+export declare function useAnswer<M extends MessageMap$1, R extends ReplyMap$1<M>, K extends keyof M & keyof R & string>(channel: Channel$1<M, R>, type: K, responder: (payload: M[K], meta: MessageMeta$1) => R[K], options?: {
+  enabled?: boolean;
 }): void;
 /** The channel's post function (stable identity per channel). */
-declare function useSend<M extends MessageMap, R extends ReplyMap<M>>(channel: Channel<M, R>): Channel<M, R>['post'];
+export declare function useSend<M extends MessageMap$1, R extends ReplyMap$1<M>>(channel: Channel$1<M, R>): Channel$1<M, R>['post'];
 /** The channel's ask function (stable identity per channel). */
-declare function useAsk<M extends MessageMap, R extends ReplyMap<M>>(channel: Channel<M, R>): Channel<M, R>['ask'];
-
+export declare function useAsk<M extends MessageMap$1, R extends ReplyMap$1<M>>(channel: Channel$1<M, R>): Channel$1<M, R>['ask'];
+//#endregion
+//#region src/define-channel.types.d.ts
 /** A channel bound to a name and message map: typed hooks with no per-call generics. */
-interface ChannelHooks<M extends MessageMap> {
-    /** The underlying channel instance (the same one the hooks use) — for non-React code. */
-    get: () => Channel<M>;
-    /** The channel's post function (stable identity). */
-    useSend: () => Channel<M>['post'];
-    /**
-     * Subscribe to one message type. Same contract as the standalone
-     * `useOnMessage`: the handler is kept fresh without resubscribing.
-     */
-    useOnMessage: <K extends keyof M & string>(type: K, handler: (payload: M[K], meta: MessageMeta) => void) => void;
+interface ChannelHooks<M extends MessageMap$1> {
+  /** The underlying channel instance (the same one the hooks use) — for non-React code. */
+  get: () => Channel$1<M>;
+  /** The channel's post function (stable identity). */
+  useSend: () => Channel$1<M>['post'];
+  /**
+   * Subscribe to one message type. Same contract as the standalone
+   * `useOnMessage`: the handler is kept fresh without resubscribing.
+   */
+  useOnMessage: <K extends keyof M & string>(type: K, handler: (payload: M[K], meta: MessageMeta$1) => void) => void;
 }
-
+//#endregion
+//#region src/define-channel.d.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
@@ -187,35 +195,37 @@ interface ChannelHooks<M extends MessageMap> {
  * Options are registered here and applied when the channel is first needed, so
  * declaring a `schema` at module scope still constructs nothing on import.
  */
-declare function defineChannel<M extends MessageMap>(name: string, options?: ChannelOptions<M>): ChannelHooks<M>;
-
+export declare function defineChannel<M extends MessageMap$1>(name: string, options?: ChannelOptions$1<M>): ChannelHooks<M>;
+//#endregion
+//#region src/create-store-hooks.types.d.ts
 interface CreateStoreHooksOptions {
-    /** Restore this store from disk on first use, and write it back as it changes. */
-    persist?: PersistAdapter;
-    /** Persist only these keys. Default: every key that has been written. */
-    persistKeys?: string[];
-    /** Coalesce disk writes for this long. Default 100. */
-    persistDebounceMs?: number;
-    /**
-     * The version of your persisted state's shape. Bump it whenever a key changes
-     * meaning or type, and supply `migrate` to carry old data forward. Default 0,
-     * which is also what anything written before this existed reads as.
-     */
-    persistVersion?: number;
-    /** Bring persisted state written at an older `persistVersion` up to the current one. */
-    migrate?: (state: Record<string, unknown>, from: number) => Record<string, unknown>;
-    /** Called when persisted state is refused instead of restored. Defaults to a development warning. */
-    onRestoreError?: (error: RestoreError) => void;
-    /** How far this store is shared. Default 'everywhere'. */
-    scope?: ShareScope;
+  /** Restore this store from disk on first use, and write it back as it changes. */
+  persist?: PersistAdapter$1;
+  /** Persist only these keys. Default: every key that has been written. */
+  persistKeys?: string[];
+  /** Coalesce disk writes for this long. Default 100. */
+  persistDebounceMs?: number;
+  /**
+   * The version of your persisted state's shape. Bump it whenever a key changes
+   * meaning or type, and supply `migrate` to carry old data forward. Default 0,
+   * which is also what anything written before this existed reads as.
+   */
+  persistVersion?: number;
+  /** Bring persisted state written at an older `persistVersion` up to the current one. */
+  migrate?: (state: Record<string, unknown>, from: number) => Record<string, unknown>;
+  /** Called when persisted state is refused instead of restored. Defaults to a development warning. */
+  onRestoreError?: (error: RestoreError$1) => void;
+  /** How far this store is shared. Default 'everywhere'. */
+  scope?: ShareScope;
 }
 /** A store bound to a name and a shape: typed hooks with no per-call generics. */
 interface StoreHooks<S extends Record<string, unknown>> {
-    /** The underlying store instance (the same one the hooks use) — for non-React code. */
-    store: () => AnyStore;
-    useSharedState: <K extends keyof S & string>(key: K, initial: S[K]) => [S[K], (next: S[K] | ((prev: S[K]) => S[K])) => void];
+  /** The underlying store instance (the same one the hooks use) — for non-React code. */
+  store: () => AnyStore;
+  useSharedState: <K extends keyof S & string>(key: K, initial: S[K]) => [S[K], (next: S[K] | ((prev: S[K]) => S[K])) => void];
 }
-
+//#endregion
+//#region src/create-store-hooks.d.ts
 /**
  * Bind a store name — and optionally persistence — once, at module level.
  *
@@ -230,19 +240,20 @@ interface StoreHooks<S extends Record<string, unknown>> {
  * so intended usage is automatic; if it does run late it throws rather than
  * quietly handing back a store with no persistence.
  */
-declare function createStoreHooks<S extends Record<string, unknown> = Record<string, unknown>>(name: string, options?: CreateStoreHooksOptions): StoreHooks<S>;
-
+export declare function createStoreHooks<S extends Record<string, unknown> = Record<string, unknown>>(name: string, options?: CreateStoreHooksOptions): StoreHooks<S>;
+//#endregion
+//#region src/use-peers.d.ts
 interface UsePeersOptions {
-    /** Bus name. Default 'use-everywhere'. */
-    name?: string;
-    /**
-     * Include this client in the list. Default false.
-     *
-     * The default answers "who *else* is here", which is what a presence strip
-     * asks. Turn it on for an avatar list, where leaving yourself out means every
-     * tab renders a different list of the same room.
-     */
-    includeSelf?: boolean;
+  /** Bus name. Default 'use-everywhere'. */
+  name?: string;
+  /**
+   * Include this client in the list. Default false.
+   *
+   * The default answers "who *else* is here", which is what a presence strip
+   * asks. Turn it on for an avatar list, where leaving yourself out means every
+   * tab renders a different list of the same room.
+   */
+  includeSelf?: boolean;
 }
 /**
  * The tabs/windows/workers currently alive on this origin.
@@ -250,7 +261,7 @@ interface UsePeersOptions {
  * Each peer carries whatever it published about itself as `metadata` — see
  * {@link usePresenceMetadata} for publishing this client's.
  */
-declare function usePeers(options?: UsePeersOptions): readonly Peer[];
+export declare function usePeers(options?: UsePeersOptions): readonly Peer$1[];
 /**
  * This client's own id on the presence bus (matches patch origin ids).
  *
@@ -261,8 +272,8 @@ declare function usePeers(options?: UsePeersOptions): readonly Peer[];
  * React also uses for the client's hydrating render, so markup matches; the
  * real id arrives in the commit straight after. Treat `''` as "not known yet".
  */
-declare function useClientId(options?: {
-    name?: string;
+export declare function useClientId(options?: {
+  name?: string;
 }): string;
 /**
  * Publish what this client wants peers to know about it — a display name, a tab
@@ -279,8 +290,9 @@ declare function useClientId(options?: {
  * side effect on every other tab — and a render that React throws away must not
  * be one other tabs already saw.
  */
-declare function usePresenceMetadata(metadata: unknown, options?: UsePeersOptions): void;
-
+export declare function usePresenceMetadata(metadata: unknown, options?: UsePeersOptions): void;
+//#endregion
+//#region src/use-hydrated.d.ts
 /**
  * Whether a persisted store has finished restoring.
  *
@@ -308,27 +320,30 @@ declare function usePresenceMetadata(metadata: unknown, options?: UsePeersOption
  * 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.
  */
-declare function useHydrated(options?: UseSharedStateOptions): boolean;
-
-interface UseLeaderOptions extends LeaderOptions {
-    /** Which bus to elect on. Defaults to the shared default name. */
-    name?: string;
+export declare function useHydrated(options?: UseSharedStateOptions): boolean;
+//#endregion
+//#region src/use-leader.types.d.ts
+interface UseLeaderOptions extends LeaderOptions$1 {
+  /** Which bus to elect on. Defaults to the shared default name. */
+  name?: string;
 }
-
+//#endregion
+//#region src/use-leader.d.ts
 /**
  * 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.
  */
-declare function useLeader(options?: UseLeaderOptions): LeaderSnapshot;
+export declare function useLeader(options?: UseLeaderOptions): LeaderSnapshot$1;
 /** Is this tab the leader? */
-declare function useIsLeader(options?: UseLeaderOptions): boolean;
+export declare function useIsLeader(options?: UseLeaderOptions): boolean;
 /**
  * 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".
  */
-declare function useLeaderEffect(effect: () => void | (() => void), options?: UseLeaderOptions): void;
-
+export declare function useLeaderEffect(effect: () => void | (() => void), options?: UseLeaderOptions): void;
+//#endregion
+//#region src/namespace.d.ts
 /**
  * The React half of a namespace: the same hooks, with every bus name prefixed.
  *
@@ -336,21 +351,21 @@ declare function useLeaderEffect(effect: () => void | (() => void), options?: Us
  * `scope` still says how far a value travels, which is a different axis from
  * which namespace it lives in.
  */
-interface ReactNamespace extends Namespace {
-    createStoreHooks<S extends Record<string, unknown> = Record<string, unknown>>(name: string, options?: CreateStoreHooksOptions): StoreHooks<S>;
-    defineChannel<M extends MessageMap>(name?: string, options?: ChannelOptions<M>): ChannelHooks<M>;
-    getSharedStore(name?: string, scope?: UseSharedStateOptions['scope']): AnyStore;
-    useSharedState<T>(key: string, initial: T, options?: UseSharedStateOptions): [T, (next: T | ((prev: T) => T)) => void];
-    useSharedSelector<S extends Record<string, unknown>, T>(selector: (state: S) => T, options?: UseSharedSelectorOptions): T;
-    usePeers(options?: UsePeersOptions): readonly Peer[];
-    usePresenceMetadata(metadata: unknown, options?: UsePeersOptions): void;
-    useHydrated(options?: UseSharedStateOptions): boolean;
-    useClientId(options?: {
-        name?: string;
-    }): string;
-    useLeader(options?: UseLeaderOptions): LeaderSnapshot;
-    useIsLeader(options?: UseLeaderOptions): boolean;
-    useLeaderEffect(effect: () => void | (() => void), options?: UseLeaderOptions): void;
+interface ReactNamespace extends Namespace$1 {
+  createStoreHooks<S extends Record<string, unknown> = Record<string, unknown>>(name: string, options?: CreateStoreHooksOptions): StoreHooks<S>;
+  defineChannel<M extends MessageMap$1>(name?: string, options?: ChannelOptions$1<M>): ChannelHooks<M>;
+  getSharedStore(name?: string, scope?: UseSharedStateOptions['scope']): AnyStore;
+  useSharedState<T>(key: string, initial: T, options?: UseSharedStateOptions): [T, (next: T | ((prev: T) => T)) => void];
+  useSharedSelector<S extends Record<string, unknown>, T>(selector: (state: S) => T, options?: UseSharedSelectorOptions): T;
+  usePeers(options?: UsePeersOptions): readonly Peer$1[];
+  usePresenceMetadata(metadata: unknown, options?: UsePeersOptions): void;
+  useHydrated(options?: UseSharedStateOptions): boolean;
+  useClientId(options?: {
+    name?: string;
+  }): string;
+  useLeader(options?: UseLeaderOptions): LeaderSnapshot$1;
+  useIsLeader(options?: UseLeaderOptions): boolean;
+  useLeaderEffect(effect: () => void | (() => void), options?: UseLeaderOptions): void;
 }
 /**
  * Namespaced hooks and factories, so two independently deployed apps on one
@@ -373,8 +388,9 @@ interface ReactNamespace extends Namespace {
  * See the core `createNamespace` for what a namespace does and does not
  * guarantee. In short: it prevents collision, not access.
  */
-declare function createNamespace(namespace: string): ReactNamespace;
-
+export declare function createNamespace(namespace: string): ReactNamespace;
+//#endregion
+//#region src/use-window-result.types.d.ts
 type OpenedWindowStatus = 'idle' | 'opening' | 'connected' | 'done' | 'closed-early' | 'error';
 /**
  * The flow's state as a discriminated union, so `status` narrows `result` and
@@ -383,43 +399,44 @@ type OpenedWindowStatus = 'idle' | 'opening' | 'connected' | 'done' | 'closed-ea
  * non-null assertion at every call site.
  */
 type OpenedWindowState<R> = {
-    status: 'idle';
-    result: undefined;
-    error: undefined;
+  status: 'idle';
+  result: undefined;
+  error: undefined;
 } | {
-    status: 'opening';
-    result: undefined;
-    error: undefined;
+  status: 'opening';
+  result: undefined;
+  error: undefined;
 } | {
-    status: 'connected';
-    result: undefined;
-    error: undefined;
+  status: 'connected';
+  result: undefined;
+  error: undefined;
 } | {
-    status: 'done';
-    result: R;
-    error: undefined;
-}
+  status: 'done';
+  result: R;
+  error: undefined;
+} |
 /** The child window went away before calling finish(). */
- | {
-    status: 'closed-early';
-    result: undefined;
-    error: WindowClosedError;
-}
+{
+  status: 'closed-early';
+  result: undefined;
+  error: WindowClosedError$1;
+} |
 /** The handshake timed out, the popup was blocked, or the factory threw. */
- | {
-    status: 'error';
-    result: undefined;
-    error: unknown;
+{
+  status: 'error';
+  result: undefined;
+  error: unknown;
 };
-interface OpenedWindowControls<Out extends MessageMap, In extends MessageMap, R> {
-    /** Call from a click handler (popup blockers require a user gesture). */
-    open: () => void;
-    /** Post to the child; no-op while nothing is open. */
-    post: OpenedWindow<Out, In, R>['post'];
-    close: () => void;
+interface OpenedWindowControls<Out extends MessageMap$1, In extends MessageMap$1, R> {
+  /** Call from a click handler (popup blockers require a user gesture). */
+  open: () => void;
+  /** Post to the child; no-op while nothing is open. */
+  post: OpenedWindow$1<Out, In, R>['post'];
+  close: () => void;
 }
-type UseWindowResult<Out extends MessageMap, In extends MessageMap, R> = OpenedWindowState<R> & OpenedWindowControls<Out, In, R>;
-
+type UseWindowResult<Out extends MessageMap$1, In extends MessageMap$1, R> = OpenedWindowState<R> & OpenedWindowControls<Out, In, R>;
+//#endregion
+//#region src/use-window-result.d.ts
 /**
  * Drive an openWindow() flow from a component: the factory is called on
  * open(), and the child window's lifecycle is folded into render state.
@@ -429,6 +446,6 @@ type UseWindowResult<Out extends MessageMap, In extends MessageMap, R> = OpenedW
  * because a route changed would lose the user's in-flight transaction. Call
  * close() if the component owns the window's lifetime.
  */
-declare function useWindowResult<Out extends MessageMap, In extends MessageMap, R = unknown>(factory: () => OpenedWindow<Out, In, R>): UseWindowResult<Out, In, R>;
-
-export { type AnyStore, type ChannelHooks, type CreateStoreHooksOptions, type OpenedWindowControls, type OpenedWindowState, type OpenedWindowStatus, type ReactNamespace, type ShareScope, type StoreHooks, type UseLeaderOptions, type UseOnMessageOptions, type UsePeersOptions, type UseSharedReducerOptions, type UseSharedSelectorOptions, type UseSharedStateOptions, type UseWindowResult, createNamespace, createStoreHooks, defineChannel, getLeader, getSharedStore, shallowEqual, useAnswer, useAsk, useChannel, useClientId, useHydrated, useIsLeader, useLeader, useLeaderEffect, useOnMessage, usePeers, usePresenceMetadata, useSend, useSharedReducer, useSharedSelector, useSharedState, useWindowResult };
+export declare function useWindowResult<Out extends MessageMap$1, In extends MessageMap$1, R = unknown>(factory: () => OpenedWindow$1<Out, In, R>): UseWindowResult<Out, In, R>;
+//#endregion
+export { type AnyStore, type AskOptions, BroadcastChannelTransport, type BusEvent, type BusObserver, type BusWire, CID_PARAM, type Channel, type ChannelHooks, type ChannelOptions, type CommonOptions, type ConnectToOpenerOptions, type CreateStoreHooksOptions, DEFAULT_NAME, type DebugOptions, HandshakeTimeoutError, type IndexedDbAdapterOptions, type InvalidPayload, type Leader, type LeaderOptions, type LeaderSnapshot, type LeaderStrategy, type LockManagerLike, type MessageEventLike, type MessageMap, type MessageMeta, type MessagePortLike, type Namespace, NoopTransport, type OnInvalid, type OnOptions, type OpenWindowOptions, type OpenedWindow, type OpenedWindowControls, type OpenedWindowState, type OpenedWindowStatus, type OpenerConnection, type Peer, type PeerKind, type PersistAdapter, type PersistOptions, type Persisted, type PostOptions, type Presence, type PresenceOptions, type ReactNamespace, type ReplyMap, type RestoreError, type SchemaMap, type SchemaOptions, type Serializer, type ShareScope, type SharedReducer, type SharedReducerOptions, type SharedStore, type SharedStoreOptions, type SharedWorkerLike, SharedWorkerTransport, type SharedWorkerTransportOptions, type StandardSchemaV1, type StorageLike, StorageTransport, type StoreHooks, type Transport, type TransportKind, type UseLeaderOptions, type UseOnMessageOptions, type UsePeersOptions, type UseSharedReducerOptions, type UseSharedSelectorOptions, type UseSharedStateOptions, type UseWindowResult, type Version, WIRE_VERSION, type WebStorageAdapterOptions, WindowClosedError, type WindowEventTarget, type WindowLike, connectToOpener, createChannel, createLeader, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isSharedWorkerAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter };