use-everywhere 0.2.0 → 0.3.0

package/dist/chunk-Y67BCTU6.js

@@ -0,0 +1,90 @@
+// src/registry.ts
+import {
+  createChannel,
+  createLeader,
+  createPresence,
+  createSharedStore,
+  DEFAULT_NAME,
+  NoopTransport
+} from "@use-everywhere/core";
+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 scopeOptions = {
+  everywhere: {},
+  tabs: { accept: (meta) => meta.kind !== "worker" },
+  tab: { transport: () => new NoopTransport() }
+};
+function getSharedStore(name = DEFAULT_NAME, scope = "everywhere") {
+  return getStore(name, scope);
+}
+function configureStore(name, scope, options) {
+  const key = `${scope} ${name}`;
+  if (stores.has(key)) {
+    throw new Error(
+      `defineStore('${name}') ran after that store was already created. Move it to module scope \u2014 configuring a live store would silently hand you one without persistence.`
+    );
+  }
+  storeConfig.set(key, options);
+}
+function getStore(name, scope = "everywhere") {
+  const key = `${scope} ${name}`;
+  let store = stores.get(key);
+  if (!store) {
+    store = createSharedStore(name, {}, { ...scopeOptions[scope], ...storeConfig.get(key) });
+    stores.set(key, store);
+  }
+  return store;
+}
+function getPresence(name) {
+  let presence = presences.get(name);
+  if (!presence) {
+    presence = createPresence(name);
+    presences.set(name, presence);
+  }
+  return presence;
+}
+function getLeader(name, options) {
+  let leader = leaders.get(name);
+  if (!leader) {
+    leader = createLeader(name, options);
+    leaders.set(name, leader);
+  }
+  return leader;
+}
+function getChannel(name) {
+  let channel = channels.get(name);
+  if (!channel) {
+    channel = createChannel(name);
+    channels.set(name, channel);
+  }
+  return channel;
+}
+
+// src/use-peers.ts
+import { useCallback, useSyncExternalStore } from "react";
+var NO_PEERS = Object.freeze([]);
+function usePeers(options) {
+  const presence = getPresence(options?.name ?? DEFAULT_NAME);
+  return useSyncExternalStore(
+    useCallback((onChange) => presence.subscribe(onChange), [presence]),
+    () => presence.getPeers(),
+    () => NO_PEERS
+  );
+}
+function useClientId(options) {
+  return getPresence(options?.name ?? DEFAULT_NAME).clientId;
+}
+
+export {
+  DEFAULT_NAME,
+  getSharedStore,
+  configureStore,
+  getStore,
+  getLeader,
+  getChannel,
+  usePeers,
+  useClientId
+};

package/dist/devtools/index.d.ts

@@ -0,0 +1,35 @@
+import * as react from 'react';
+
+interface InspectorProps {
+    /** Which bus to watch. Defaults to the shared default name. */
+    name?: string;
+    /** Corner to dock in. Default 'bottom-right'. */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** How many wires to keep in the log. Default 50. */
+    limit?: number;
+    /** Start expanded. Default false. */
+    defaultOpen?: boolean;
+    /**
+     * How long a leader wire keeps the crown before it is treated as stale.
+     * Should match the Leader's leaseMs. Default 3000.
+     */
+    leaseMs?: number;
+}
+
+/**
+ * A floating panel showing what this tab is saying and hearing on the bus:
+ * peers, the leader, store keys with their version clocks, and a live wire log
+ * in both directions.
+ *
+ * It deliberately does **not** create a Leader. Under dynamic eligibility,
+ * mounting one with `eligible: false` would disable candidacy for the whole
+ * tab, and mounting a plain one would enrol a tab that never asked to be a
+ * candidate — a devtool must not change what it measures. Instead it reads the
+ * crown out of the wire log, which it already sees in both directions.
+ *
+ * Presence is fine to use: the bus heartbeats regardless of whether anything
+ * created a Presence, so usePeers observes rather than perturbs.
+ */
+declare function Inspector({ name, position, limit, defaultOpen, leaseMs, }?: InspectorProps): react.JSX.Element;
+
+export { Inspector, type InspectorProps };

package/dist/devtools/index.js

@@ -0,0 +1,216 @@
+import {
+  getSharedStore,
+  usePeers
+} from "../chunk-Y67BCTU6.js";
+
+// src/devtools/inspector.tsx
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { DEFAULT_NAME, observeBus } from "@use-everywhere/core";
+
+// src/devtools/styles.ts
+var STYLES = `
+.ue-ins {
+  position: fixed;
+  z-index: 2147483000;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace;
+  color: #e6edf3;
+  background: #0d1117;
+  border: 1px solid #30363d;
+  border-radius: 8px;
+  box-shadow: 0 8px 32px rgb(0 0 0 / 0.4);
+  max-width: min(420px, calc(100vw - 24px));
+  overflow: hidden;
+}
+.ue-ins--bottom-right { bottom: 12px; right: 12px; }
+.ue-ins--bottom-left  { bottom: 12px; left: 12px; }
+.ue-ins--top-right    { top: 12px; right: 12px; }
+.ue-ins--top-left     { top: 12px; left: 12px; }
+
+.ue-ins__bar {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  padding: 7px 10px;
+  background: #161b22;
+  border: 0;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  text-align: left;
+}
+.ue-ins__dot { width: 7px; height: 7px; border-radius: 50%; background: #3fb950; flex: none; }
+.ue-ins__title { font-weight: 600; }
+.ue-ins__muted { color: #8b949e; }
+.ue-ins__crown { margin-left: auto; color: #d29922; }
+
+.ue-ins__body { max-height: 60vh; overflow-y: auto; }
+.ue-ins__section { border-top: 1px solid #21262d; padding: 8px 10px; }
+.ue-ins__h {
+  color: #8b949e;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  font-size: 10px;
+  margin-bottom: 5px;
+}
+.ue-ins__row { display: flex; gap: 8px; padding: 1px 0; }
+.ue-ins__k { color: #79c0ff; flex: none; }
+.ue-ins__v { color: #e6edf3; overflow-wrap: anywhere; }
+.ue-ins__ver { color: #6e7681; margin-left: auto; flex: none; }
+.ue-ins__empty { color: #6e7681; }
+
+.ue-ins__log { display: flex; flex-direction: column-reverse; max-height: 190px; overflow-y: auto; }
+.ue-ins__wire { display: flex; gap: 7px; padding: 1px 0; white-space: nowrap; }
+.ue-ins__dir { flex: none; width: 9px; }
+.ue-ins__dir--out { color: #d29922; }
+.ue-ins__dir--in { color: #3fb950; }
+.ue-ins__scope { color: #e6edf3; }
+.ue-ins__from { color: #6e7681; margin-left: auto; }
+`;
+
+// src/devtools/inspector.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var short = (id) => id.slice(0, 6);
+function wireLabel(wire) {
+  return `${wire.scope}/${wire.type}`;
+}
+function Inspector({
+  name = DEFAULT_NAME,
+  position = "bottom-right",
+  limit = 50,
+  defaultOpen = false,
+  leaseMs = 3e3
+} = {}) {
+  const [open, setOpen] = useState(defaultOpen);
+  const [wires, setWires] = useState([]);
+  const [crown, setCrown] = useState(null);
+  const nextId = useRef(0);
+  const crownAt = useRef(0);
+  const peers = usePeers({ name });
+  const store = getSharedStore(name);
+  const subscribe = useCallback((onChange) => store.subscribe(onChange), [store]);
+  const snapshot = useSyncExternalStore(
+    subscribe,
+    () => store.getSnapshot(),
+    () => store.getSnapshot()
+  );
+  const versions = useSyncExternalStore(
+    subscribe,
+    () => store.getVersions(),
+    () => store.getVersions()
+  );
+  useEffect(() => {
+    return observeBus(name, (event) => {
+      const { wire, direction } = event;
+      if (wire.scope === "leader") {
+        if (wire.type === "resign") {
+          setCrown(null);
+          crownAt.current = 0;
+        } else if (wire.type === "claim" || wire.type === "heartbeat") {
+          setCrown(wire.clientId);
+          crownAt.current = Date.now();
+        }
+      }
+      setWires(
+        (prev) => [
+          ...prev.slice(-(limit - 1)),
+          {
+            id: nextId.current++,
+            direction,
+            label: wireLabel(wire),
+            from: short(wire.clientId)
+          }
+        ].slice(-limit)
+      );
+    });
+  }, [name, limit]);
+  useEffect(() => {
+    const timer = setInterval(
+      () => {
+        if (crownAt.current && Date.now() - crownAt.current > leaseMs) {
+          setCrown(null);
+          crownAt.current = 0;
+        }
+      },
+      // Quarter of the lease, so a vacated crown clears well within it. The
+      // floor is low enough that a short lease still works rather than being
+      // silently rounded up to something coarser than the lease itself.
+      Math.max(50, Math.floor(leaseMs / 4))
+    );
+    return () => clearInterval(timer);
+  }, [leaseMs]);
+  const selfId = store.clientId;
+  const entries = Object.entries(versions);
+  return /* @__PURE__ */ jsxs("div", { className: `ue-ins ue-ins--${position}`, "data-testid": "ue-inspector", children: [
+    /* @__PURE__ */ jsx("style", { children: STYLES }),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        className: "ue-ins__bar",
+        onClick: () => setOpen((v) => !v),
+        "aria-expanded": open,
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__dot" }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__title", children: "use-everywhere" }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__muted", children: name }),
+          crown ? /* @__PURE__ */ jsxs("span", { className: "ue-ins__crown", "data-testid": "ue-crown", children: [
+            "\u2654 ",
+            crown === selfId ? "this tab" : short(crown)
+          ] }) : null
+        ]
+      }
+    ),
+    open ? /* @__PURE__ */ jsxs("div", { className: "ue-ins__body", children: [
+      /* @__PURE__ */ jsxs("div", { className: "ue-ins__section", children: [
+        /* @__PURE__ */ jsx("div", { className: "ue-ins__h", children: "This tab" }),
+        /* @__PURE__ */ jsxs("div", { className: "ue-ins__row", children: [
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__k", children: short(selfId) }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__v", children: crown === selfId ? "leader" : crown ? "follower" : "no leader" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "ue-ins__section", children: [
+        /* @__PURE__ */ jsxs("div", { className: "ue-ins__h", children: [
+          "Peers (",
+          peers.length,
+          ")"
+        ] }),
+        peers.length === 0 ? /* @__PURE__ */ jsx("div", { className: "ue-ins__empty", children: "nobody else here" }) : peers.map((peer) => /* @__PURE__ */ jsxs("div", { className: "ue-ins__row", children: [
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__k", children: short(peer.id) }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__v", children: peer.kind })
+        ] }, peer.id))
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "ue-ins__section", children: [
+        /* @__PURE__ */ jsxs("div", { className: "ue-ins__h", children: [
+          "State (",
+          entries.length,
+          ")"
+        ] }),
+        entries.length === 0 ? /* @__PURE__ */ jsx("div", { className: "ue-ins__empty", children: "no keys yet" }) : entries.map(([key, version]) => /* @__PURE__ */ jsxs("div", { className: "ue-ins__row", children: [
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__k", children: key }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__v", children: JSON.stringify(snapshot[key]) }),
+          /* @__PURE__ */ jsxs("span", { className: "ue-ins__ver", children: [
+            version[0],
+            "\xB7",
+            short(version[1])
+          ] })
+        ] }, key))
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "ue-ins__section", children: [
+        /* @__PURE__ */ jsxs("div", { className: "ue-ins__h", children: [
+          "Wires (",
+          wires.length,
+          ")"
+        ] }),
+        wires.length === 0 ? /* @__PURE__ */ jsx("div", { className: "ue-ins__empty", children: "nothing yet" }) : /* @__PURE__ */ jsx("div", { className: "ue-ins__log", children: wires.map((wire) => /* @__PURE__ */ jsxs("div", { className: "ue-ins__wire", children: [
+          /* @__PURE__ */ jsx("span", { className: `ue-ins__dir ue-ins__dir--${wire.direction}`, children: wire.direction === "out" ? "\u2192" : "\u2190" }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__scope", children: wire.label }),
+          /* @__PURE__ */ jsx("span", { className: "ue-ins__from", children: wire.from })
+        ] }, wire.id)) })
+      ] })
+    ] }) : null
+  ] });
+}
+export {
+  Inspector
+};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { SharedStore, MessageMap, Channel, MessageMeta, Peer, OpenedWindow } from '@use-everywhere/core';
+import { SharedStore, LeaderOptions, Leader, MessageMap, Channel, MessageMeta, PersistAdapter, Peer, LeaderSnapshot, OpenedWindow } from '@use-everywhere/core';
 export * from '@use-everywhere/core';
+export { DEFAULT_NAME } from '@use-everywhere/core';
 
 /**
  * How far a shared value travels:
@@ -26,14 +27,15 @@ declare function useSharedState<T>(key: string, initial: T, options?: UseSharedS
 /** Registry stores hold arbitrary keys — shape is decided by the hooks using them. */
 type AnyStore = SharedStore<Record<string, unknown>>;
 
-/**
- * A BroadcastChannel is already global to the origin — identity is the name
- * string, not the React tree — so hooks share module-level singletons per
- * name instead of requiring a Provider. Instances live for the page lifetime.
- */
-declare const DEFAULT_NAME = "use-everywhere";
 /** Imperative access to the store behind useSharedState (patch logs, non-React code). */
 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;
 
 /** Get the page-wide typed channel for `name` (one instance per name). */
 declare function useChannel<M extends MessageMap>(name: string): Channel<M>;
@@ -66,6 +68,39 @@ interface ChannelHooks<M extends MessageMap> {
  */
 declare function defineChannel<M extends MessageMap>(name: string): ChannelHooks<M>;
 
+interface DefineStoreOptions {
+    /** 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;
+    /** 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. */
+    get: () => AnyStore;
+    useSharedState: <K extends keyof S & string>(key: K, initial: S[K]) => [S[K], (next: S[K] | ((prev: S[K]) => S[K])) => void];
+}
+
+/**
+ * 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
+ * `defineStore('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.
+ */
+declare function defineStore<S extends Record<string, unknown> = Record<string, unknown>>(name: string, options?: DefineStoreOptions): StoreHooks<S>;
+
 /** The other tabs/windows/workers currently alive on this origin. */
 declare function usePeers(options?: {
     name?: string;
@@ -75,6 +110,25 @@ declare function useClientId(options?: {
     name?: string;
 }): string;
 
+interface UseLeaderOptions extends LeaderOptions {
+    /** Which bus to elect on. Defaults to the shared default name. */
+    name?: string;
+}
+
+/**
+ * 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;
+/** Is this tab the leader? */
+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;
+
 type OpenedWindowStatus = 'idle' | 'opening' | 'connected' | 'done' | 'closed-early' | 'error';
 interface UseOpenedWindow<Out extends MessageMap, In extends MessageMap, R> {
     /** Call from a click handler (popup blockers require a user gesture). */
@@ -95,4 +149,4 @@ interface UseOpenedWindow<Out extends MessageMap, In extends MessageMap, R> {
  */
 declare function useOpenedWindow<Out extends MessageMap, In extends MessageMap, R = unknown>(factory: () => OpenedWindow<Out, In, R>): UseOpenedWindow<Out, In, R>;
 
-export { type AnyStore, type ChannelHooks, DEFAULT_NAME, type OpenedWindowStatus, type ShareScope, type UseOpenedWindow, type UseSharedStateOptions, defineChannel, getSharedStore, useChannel, useClientId, useMessage, useOpenedWindow, usePeers, useSend, useSharedState };
+export { type AnyStore, type ChannelHooks, type DefineStoreOptions, type OpenedWindowStatus, type ShareScope, type StoreHooks, type UseLeaderOptions, type UseOpenedWindow, type UseSharedStateOptions, defineChannel, defineStore, getLeader, getSharedStore, useChannel, useClientId, useIsLeader, useLeader, useLeaderEffect, useMessage, useOpenedWindow, usePeers, useSend, useSharedState };

package/dist/index.js

@@ -1,52 +1,16 @@
-// src/use-shared-state.ts
-import { useCallback, useSyncExternalStore } from "react";
-
-// src/registry.ts
 import {
-  createChannel,
-  createPresence,
-  createSharedStore,
-  NoopTransport
-} from "@use-everywhere/core";
-var DEFAULT_NAME = "use-everywhere";
-var stores = /* @__PURE__ */ new Map();
-var presences = /* @__PURE__ */ new Map();
-var channels = /* @__PURE__ */ new Map();
-var scopeOptions = {
-  everywhere: {},
-  tabs: { accept: (meta) => meta.kind !== "worker" },
-  tab: { transport: () => new NoopTransport() }
-};
-function getSharedStore(name = DEFAULT_NAME, scope = "everywhere") {
-  return getStore(name, scope);
-}
-function getStore(name, scope = "everywhere") {
-  const key = `${scope}\0${name}`;
-  let store = stores.get(key);
-  if (!store) {
-    store = createSharedStore(name, {}, scopeOptions[scope]);
-    stores.set(key, store);
-  }
-  return store;
-}
-function getPresence(name) {
-  let presence = presences.get(name);
-  if (!presence) {
-    presence = createPresence(name);
-    presences.set(name, presence);
-  }
-  return presence;
-}
-function getChannel(name) {
-  let channel = channels.get(name);
-  if (!channel) {
-    channel = createChannel(name);
-    channels.set(name, channel);
-  }
-  return channel;
-}
+  DEFAULT_NAME,
+  configureStore,
+  getChannel,
+  getLeader,
+  getSharedStore,
+  getStore,
+  useClientId,
+  usePeers
+} from "./chunk-Y67BCTU6.js";
 
 // src/use-shared-state.ts
+import { useCallback, useSyncExternalStore } from "react";
 function useSharedState(key, initial, options) {
   const store = getStore(options?.store ?? DEFAULT_NAME, options?.scope ?? "everywhere");
   store.registerKey(key, initial);
@@ -92,30 +56,64 @@ function defineChannel(name) {
   };
 }
 
-// src/use-peers.ts
-import { useCallback as useCallback2, useSyncExternalStore as useSyncExternalStore2 } from "react";
-var NO_PEERS = Object.freeze([]);
-function usePeers(options) {
-  const presence = getPresence(options?.name ?? DEFAULT_NAME);
+// src/define-store.ts
+function defineStore(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 }
+      }
+    });
+  }
+  return {
+    get: () => getStore(name, scope),
+    useSharedState: (key, initial) => useSharedState(key, initial, { store: name, scope })
+  };
+}
+
+// src/use-leader.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+var NO_LEADER = Object.freeze({ leaderId: null, isLeader: false });
+function useLeader(options) {
+  const leader = getLeader(options?.name ?? DEFAULT_NAME, options);
+  const eligible = options?.eligible;
+  useEffect2(() => {
+    if (eligible === void 0) return;
+    leader.setEligible(eligible);
+  }, [leader, eligible]);
   return useSyncExternalStore2(
-    useCallback2((onChange) => presence.subscribe(onChange), [presence]),
-    () => presence.getPeers(),
-    () => NO_PEERS
+    useCallback2((onChange) => leader.subscribe(onChange), [leader]),
+    () => leader.getSnapshot(),
+    () => NO_LEADER
   );
 }
-function useClientId(options) {
-  return getPresence(options?.name ?? DEFAULT_NAME).clientId;
+function useIsLeader(options) {
+  return useLeader(options).isLeader;
+}
+function useLeaderEffect(effect, options) {
+  const { isLeader } = useLeader(options);
+  const effectRef = useRef2(effect);
+  useEffect2(() => {
+    effectRef.current = effect;
+  });
+  useEffect2(() => {
+    if (!isLeader) return;
+    return effectRef.current();
+  }, [isLeader]);
 }
 
 // src/use-opened-window.ts
-import { useCallback as useCallback3, useRef as useRef2, useState } from "react";
+import { useCallback as useCallback3, useRef as useRef3, useState } from "react";
 import { WindowClosedError } from "@use-everywhere/core";
 function useOpenedWindow(factory) {
   const [status, setStatus] = useState("idle");
   const [result, setResult] = useState(void 0);
   const [error, setError] = useState(void 0);
-  const current = useRef2(null);
-  const factoryRef = useRef2(factory);
+  const current = useRef3(null);
+  const factoryRef = useRef3(factory);
   factoryRef.current = factory;
   const open = useCallback3(() => {
     current.current?.close();
@@ -165,9 +163,14 @@ export * from "@use-everywhere/core";
 export {
   DEFAULT_NAME,
   defineChannel,
+  defineStore,
+  getLeader,
   getSharedStore,
   useChannel,
   useClientId,
+  useIsLeader,
+  useLeader,
+  useLeaderEffect,
   useMessage,
   useOpenedWindow,
   usePeers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "use-everywhere",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "React hooks for state and messages shared across tabs, windows, and workers",
   "license": "MIT",
   "author": "Jonatan Kruszewski <jonakrusze@gmail.com>",
@@ -32,6 +32,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./devtools": {
+      "types": "./dist/devtools/index.d.ts",
+      "import": "./dist/devtools/index.js"
     }
   },
   "files": [
@@ -42,13 +46,13 @@
       "name": "everything (import *)",
       "path": "dist/index.js",
       "import": "*",
-      "limit": "4.2 kB"
+      "limit": "5.4 kB"
     },
     {
       "name": "useSharedState",
       "path": "dist/index.js",
       "import": "{ useSharedState }",
-      "limit": "1.5 kB"
+      "limit": "1.8 kB"
     },
     {
       "name": "useChannel + useMessage + useSend",
@@ -67,10 +71,28 @@
       "path": "dist/index.js",
       "import": "{ useOpenedWindow, openWindow }",
       "limit": "1.4 kB"
+    },
+    {
+      "name": "useLeader + useLeaderEffect",
+      "path": "dist/index.js",
+      "import": "{ useLeader, useLeaderEffect }",
+      "limit": "1.8 kB"
+    },
+    {
+      "name": "defineStore (persisted)",
+      "path": "dist/index.js",
+      "import": "{ defineStore, localStorageAdapter }",
+      "limit": "2.3 kB"
+    },
+    {
+      "name": "Inspector (devtools subpath)",
+      "path": "dist/devtools/index.js",
+      "import": "{ Inspector }",
+      "limit": "5 kB"
     }
   ],
   "dependencies": {
-    "@use-everywhere/core": "0.2.0"
+    "@use-everywhere/core": "0.3.0"
   },
   "peerDependencies": {
     "react": ">=18"
@@ -89,6 +111,13 @@
     "typescript": "^5.8.3",
     "vitest": "^4.1.10"
   },
+  "typesVersions": {
+    "*": {
+      "devtools": [
+        "./dist/devtools/index.d.ts"
+      ]
+    }
+  },
   "scripts": {
     "build": "tsup",
     "test": "vitest run --coverage",