tab-bridge 0.1.0 → 0.2.0

package/dist/{types-BtK4ixKz.d.cts → instance-5LIItazN.d.cts}

@@ -1,81 +1,3 @@
-declare const PROTOCOL_VERSION = 1;
-interface StateUpdatePayload {
-    entries: Record<string, {
-        value: unknown;
-        timestamp: number;
-    }>;
-}
-interface StateSyncResponsePayload {
-    state: Record<string, {
-        value: unknown;
-        timestamp: number;
-    }>;
-}
-interface LeaderClaimPayload {
-    createdAt: number;
-}
-interface TabAnnouncePayload {
-    createdAt: number;
-    isActive: boolean;
-    url: string;
-    title?: string;
-}
-interface RpcRequestPayload {
-    callId: string;
-    method: string;
-    args: unknown;
-}
-interface RpcResponsePayload {
-    callId: string;
-    result?: unknown;
-    error?: string;
-}
-/**
- * Maps every message type to its exact payload shape.
- * Adding a new message only requires extending this interface.
- */
-interface MessagePayloadMap {
-    STATE_UPDATE: StateUpdatePayload;
-    STATE_SYNC_REQUEST: null;
-    STATE_SYNC_RESPONSE: StateSyncResponsePayload;
-    LEADER_CLAIM: LeaderClaimPayload;
-    LEADER_ACK: null;
-    LEADER_HEARTBEAT: null;
-    LEADER_RESIGN: null;
-    TAB_ANNOUNCE: TabAnnouncePayload;
-    TAB_GOODBYE: null;
-    RPC_REQUEST: RpcRequestPayload;
-    RPC_RESPONSE: RpcResponsePayload;
-}
-type MessageType = keyof MessagePayloadMap;
-/**
- * Discriminated union of all inter-tab messages.
- *
- * Checking `msg.type` narrows `msg.payload` to the exact payload type,
- * eliminating the need for runtime casts:
- *
- * ```ts
- * if (msg.type === 'STATE_UPDATE') {
- *   msg.payload.entries; // ← StateUpdatePayload, fully typed
- * }
- * ```
- */
-type TabMessage = {
-    [K in MessageType]: {
-        readonly type: K;
-        readonly senderId: string;
-        readonly targetId?: string;
-        readonly timestamp: number;
-        readonly version?: number;
-        readonly payload: MessagePayloadMap[K];
-    };
-}[MessageType];
-/** Extract a single message variant by its type discriminant. */
-type MessageOf<T extends MessageType> = Extract<TabMessage, {
-    type: T;
-}>;
-/** Function that sends a message through the transport channel. */
-type SendFn = (message: TabMessage) => void;
 interface TabInfo {
     id: string;
     createdAt: number;
@@ -90,6 +12,7 @@ interface ChangeMeta {
     readonly isLocal: boolean;
     readonly timestamp: number;
 }
+
 interface MiddlewareContext<TState extends Record<string, unknown>> {
     readonly key: keyof TState;
     readonly value: unknown;
@@ -112,6 +35,7 @@ interface Middleware<TState extends Record<string, unknown> = Record<string, unk
     /** Cleanup when the instance is destroyed. */
     onDestroy?: () => void;
 }
+
 interface PersistOptions<TState extends Record<string, unknown> = Record<string, unknown>> {
     /** Storage key. Default: `'tab-sync:state'` */
     key?: string;
@@ -127,7 +51,27 @@ interface PersistOptions<TState extends Record<string, unknown> = Record<string,
     debounce?: number;
     /** Custom storage backend. Default: `localStorage` */
     storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+    /**
+     * Schema version for state migration. When the persisted version
+     * differs from this value, `migrate` is called.
+     */
+    version?: number;
+    /**
+     * Migration function called when persisted version differs from current.
+     *
+     * ```ts
+     * persist: {
+     *   version: 2,
+     *   migrate: (oldState, oldVersion) => ({
+     *     ...oldState,
+     *     newField: oldVersion < 2 ? 'default' : oldState.newField,
+     *   }),
+     * }
+     * ```
+     */
+    migrate?: (oldState: Partial<TState>, oldVersion: number) => Partial<TState>;
 }
+
 /**
  * Define your RPC contract for full type inference:
  *
@@ -145,10 +89,16 @@ type RPCMap = Record<string, {
     args: unknown;
     result: unknown;
 }>;
+interface RPCCallAllResult<T = unknown> {
+    tabId: string;
+    result?: T;
+    error?: string;
+}
 /** Resolve args type for a method. Falls back to `unknown` for unregistered methods. */
 type RPCArgs<TMap extends RPCMap, M extends string> = M extends keyof TMap ? TMap[M]['args'] : unknown;
 /** Resolve result type for a method. Falls back to `unknown` for unregistered methods. */
 type RPCResult<TMap extends RPCMap, M extends string> = M extends keyof TMap ? TMap[M]['result'] : unknown;
+
 interface LeaderOptions {
     /** Heartbeat interval in ms. Default: `2000` */
     heartbeatInterval?: number;
@@ -179,6 +129,7 @@ interface TabSyncOptions<TState extends Record<string, unknown> = Record<string,
     /** Error callback for non-fatal errors (storage, channel, etc.). */
     onError?: (error: Error) => void;
 }
+
 interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extends RPCMap = RPCMap> {
     /** Read a single value by key. */
     get<K extends keyof TState>(key: K): TState[K];
@@ -191,6 +142,20 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
     set<K extends keyof TState>(key: K, value: TState[K]): void;
     /** Update multiple keys in a single broadcast. */
     patch(partial: Partial<TState>): void;
+    /**
+     * Atomically update multiple keys based on the current state.
+     * Return `null` to abort the transaction.
+     *
+     * ```ts
+     * sync.transaction((state) => {
+     *   if (state.balance >= amount) {
+     *     return { balance: state.balance - amount, history: [...state.history, tx] };
+     *   }
+     *   return null; // abort
+     * });
+     * ```
+     */
+    transaction(fn: (state: Readonly<TState>) => Partial<TState> | null): void;
     /**
      * Subscribe to changes for a specific key.
      * @returns Unsubscribe function.
@@ -230,7 +195,10 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
      *
      * @returns Unsubscribe function.
      */
-    select<TResult>(selector: (state: Readonly<TState>) => TResult, callback: (result: TResult, meta: ChangeMeta) => void, isEqual?: (a: TResult, b: TResult) => boolean): () => void;
+    select<TResult>(selector: (state: Readonly<TState>) => TResult, callback: (result: TResult, meta: ChangeMeta) => void, options?: {
+        isEqual?: (a: TResult, b: TResult) => boolean;
+        debounce?: number;
+    }): () => void;
     /** Whether this tab is currently the leader. */
     isLeader(): boolean;
     /**
@@ -283,6 +251,16 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
      * @param timeout - Timeout in ms. Default: `5000`.
      */
     call<M extends string>(target: string | 'leader', method: M, args?: RPCArgs<TRPCMap, M>, timeout?: number): Promise<RPCResult<TRPCMap, M>>;
+    /**
+     * Call a method on **all other tabs** (fan-out).
+     * Returns an array of per-tab results, including errors.
+     *
+     * ```ts
+     * const results = await sync.callAll('getStatus');
+     * for (const { tabId, result, error } of results) { ... }
+     * ```
+     */
+    callAll<M extends string>(method: M, args?: RPCArgs<TRPCMap, M>, timeout?: number): Promise<RPCCallAllResult<RPCResult<TRPCMap, M>>[]>;
     /**
      * Register an RPC handler that other tabs can call.
      *
@@ -303,4 +281,4 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
     readonly ready: boolean;
 }
 
-export { type ChangeMeta as C, type LeaderClaimPayload as L, type Middleware as M, PROTOCOL_VERSION as P, type RPCMap as R, type SendFn as S, type TabSyncOptions as T, type TabSyncInstance as a, type TabMessage as b, type TabInfo as c, type MiddlewareContext as d, type MessageType as e, type MessagePayloadMap as f, type MessageOf as g, type LeaderOptions as h, type MiddlewareResult as i, type PersistOptions as j, type RPCArgs as k, type RPCResult as l, type RpcRequestPayload as m, type RpcResponsePayload as n, type StateSyncResponsePayload as o, type StateUpdatePayload as p, type TabAnnouncePayload as q };
+export type { ChangeMeta as C, LeaderOptions as L, Middleware as M, PersistOptions as P, RPCMap as R, TabSyncOptions as T, TabSyncInstance as a, TabInfo as b, RPCCallAllResult as c, MiddlewareContext as d, MiddlewareResult as e, RPCArgs as f, RPCResult as g };

package/dist/{types-BtK4ixKz.d.ts → instance-5LIItazN.d.ts}

@@ -1,81 +1,3 @@
-declare const PROTOCOL_VERSION = 1;
-interface StateUpdatePayload {
-    entries: Record<string, {
-        value: unknown;
-        timestamp: number;
-    }>;
-}
-interface StateSyncResponsePayload {
-    state: Record<string, {
-        value: unknown;
-        timestamp: number;
-    }>;
-}
-interface LeaderClaimPayload {
-    createdAt: number;
-}
-interface TabAnnouncePayload {
-    createdAt: number;
-    isActive: boolean;
-    url: string;
-    title?: string;
-}
-interface RpcRequestPayload {
-    callId: string;
-    method: string;
-    args: unknown;
-}
-interface RpcResponsePayload {
-    callId: string;
-    result?: unknown;
-    error?: string;
-}
-/**
- * Maps every message type to its exact payload shape.
- * Adding a new message only requires extending this interface.
- */
-interface MessagePayloadMap {
-    STATE_UPDATE: StateUpdatePayload;
-    STATE_SYNC_REQUEST: null;
-    STATE_SYNC_RESPONSE: StateSyncResponsePayload;
-    LEADER_CLAIM: LeaderClaimPayload;
-    LEADER_ACK: null;
-    LEADER_HEARTBEAT: null;
-    LEADER_RESIGN: null;
-    TAB_ANNOUNCE: TabAnnouncePayload;
-    TAB_GOODBYE: null;
-    RPC_REQUEST: RpcRequestPayload;
-    RPC_RESPONSE: RpcResponsePayload;
-}
-type MessageType = keyof MessagePayloadMap;
-/**
- * Discriminated union of all inter-tab messages.
- *
- * Checking `msg.type` narrows `msg.payload` to the exact payload type,
- * eliminating the need for runtime casts:
- *
- * ```ts
- * if (msg.type === 'STATE_UPDATE') {
- *   msg.payload.entries; // ← StateUpdatePayload, fully typed
- * }
- * ```
- */
-type TabMessage = {
-    [K in MessageType]: {
-        readonly type: K;
-        readonly senderId: string;
-        readonly targetId?: string;
-        readonly timestamp: number;
-        readonly version?: number;
-        readonly payload: MessagePayloadMap[K];
-    };
-}[MessageType];
-/** Extract a single message variant by its type discriminant. */
-type MessageOf<T extends MessageType> = Extract<TabMessage, {
-    type: T;
-}>;
-/** Function that sends a message through the transport channel. */
-type SendFn = (message: TabMessage) => void;
 interface TabInfo {
     id: string;
     createdAt: number;
@@ -90,6 +12,7 @@ interface ChangeMeta {
     readonly isLocal: boolean;
     readonly timestamp: number;
 }
+
 interface MiddlewareContext<TState extends Record<string, unknown>> {
     readonly key: keyof TState;
     readonly value: unknown;
@@ -112,6 +35,7 @@ interface Middleware<TState extends Record<string, unknown> = Record<string, unk
     /** Cleanup when the instance is destroyed. */
     onDestroy?: () => void;
 }
+
 interface PersistOptions<TState extends Record<string, unknown> = Record<string, unknown>> {
     /** Storage key. Default: `'tab-sync:state'` */
     key?: string;
@@ -127,7 +51,27 @@ interface PersistOptions<TState extends Record<string, unknown> = Record<string,
     debounce?: number;
     /** Custom storage backend. Default: `localStorage` */
     storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+    /**
+     * Schema version for state migration. When the persisted version
+     * differs from this value, `migrate` is called.
+     */
+    version?: number;
+    /**
+     * Migration function called when persisted version differs from current.
+     *
+     * ```ts
+     * persist: {
+     *   version: 2,
+     *   migrate: (oldState, oldVersion) => ({
+     *     ...oldState,
+     *     newField: oldVersion < 2 ? 'default' : oldState.newField,
+     *   }),
+     * }
+     * ```
+     */
+    migrate?: (oldState: Partial<TState>, oldVersion: number) => Partial<TState>;
 }
+
 /**
  * Define your RPC contract for full type inference:
  *
@@ -145,10 +89,16 @@ type RPCMap = Record<string, {
     args: unknown;
     result: unknown;
 }>;
+interface RPCCallAllResult<T = unknown> {
+    tabId: string;
+    result?: T;
+    error?: string;
+}
 /** Resolve args type for a method. Falls back to `unknown` for unregistered methods. */
 type RPCArgs<TMap extends RPCMap, M extends string> = M extends keyof TMap ? TMap[M]['args'] : unknown;
 /** Resolve result type for a method. Falls back to `unknown` for unregistered methods. */
 type RPCResult<TMap extends RPCMap, M extends string> = M extends keyof TMap ? TMap[M]['result'] : unknown;
+
 interface LeaderOptions {
     /** Heartbeat interval in ms. Default: `2000` */
     heartbeatInterval?: number;
@@ -179,6 +129,7 @@ interface TabSyncOptions<TState extends Record<string, unknown> = Record<string,
     /** Error callback for non-fatal errors (storage, channel, etc.). */
     onError?: (error: Error) => void;
 }
+
 interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extends RPCMap = RPCMap> {
     /** Read a single value by key. */
     get<K extends keyof TState>(key: K): TState[K];
@@ -191,6 +142,20 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
     set<K extends keyof TState>(key: K, value: TState[K]): void;
     /** Update multiple keys in a single broadcast. */
     patch(partial: Partial<TState>): void;
+    /**
+     * Atomically update multiple keys based on the current state.
+     * Return `null` to abort the transaction.
+     *
+     * ```ts
+     * sync.transaction((state) => {
+     *   if (state.balance >= amount) {
+     *     return { balance: state.balance - amount, history: [...state.history, tx] };
+     *   }
+     *   return null; // abort
+     * });
+     * ```
+     */
+    transaction(fn: (state: Readonly<TState>) => Partial<TState> | null): void;
     /**
      * Subscribe to changes for a specific key.
      * @returns Unsubscribe function.
@@ -230,7 +195,10 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
      *
      * @returns Unsubscribe function.
      */
-    select<TResult>(selector: (state: Readonly<TState>) => TResult, callback: (result: TResult, meta: ChangeMeta) => void, isEqual?: (a: TResult, b: TResult) => boolean): () => void;
+    select<TResult>(selector: (state: Readonly<TState>) => TResult, callback: (result: TResult, meta: ChangeMeta) => void, options?: {
+        isEqual?: (a: TResult, b: TResult) => boolean;
+        debounce?: number;
+    }): () => void;
     /** Whether this tab is currently the leader. */
     isLeader(): boolean;
     /**
@@ -283,6 +251,16 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
      * @param timeout - Timeout in ms. Default: `5000`.
      */
     call<M extends string>(target: string | 'leader', method: M, args?: RPCArgs<TRPCMap, M>, timeout?: number): Promise<RPCResult<TRPCMap, M>>;
+    /**
+     * Call a method on **all other tabs** (fan-out).
+     * Returns an array of per-tab results, including errors.
+     *
+     * ```ts
+     * const results = await sync.callAll('getStatus');
+     * for (const { tabId, result, error } of results) { ... }
+     * ```
+     */
+    callAll<M extends string>(method: M, args?: RPCArgs<TRPCMap, M>, timeout?: number): Promise<RPCCallAllResult<RPCResult<TRPCMap, M>>[]>;
     /**
      * Register an RPC handler that other tabs can call.
      *
@@ -303,4 +281,4 @@ interface TabSyncInstance<TState extends Record<string, unknown>, TRPCMap extend
     readonly ready: boolean;
 }
 
-export { type ChangeMeta as C, type LeaderClaimPayload as L, type Middleware as M, PROTOCOL_VERSION as P, type RPCMap as R, type SendFn as S, type TabSyncOptions as T, type TabSyncInstance as a, type TabMessage as b, type TabInfo as c, type MiddlewareContext as d, type MessageType as e, type MessagePayloadMap as f, type MessageOf as g, type LeaderOptions as h, type MiddlewareResult as i, type PersistOptions as j, type RPCArgs as k, type RPCResult as l, type RpcRequestPayload as m, type RpcResponsePayload as n, type StateSyncResponsePayload as o, type StateUpdatePayload as p, type TabAnnouncePayload as q };
+export type { ChangeMeta as C, LeaderOptions as L, Middleware as M, PersistOptions as P, RPCMap as R, TabSyncOptions as T, TabSyncInstance as a, TabInfo as b, RPCCallAllResult as c, MiddlewareContext as d, MiddlewareResult as e, RPCArgs as f, RPCResult as g };

package/dist/react/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkBQCNBNBT_cjs = require('../chunk-BQCNBNBT.cjs');
+var chunkTGEXRVAL_cjs = require('../chunk-TGEXRVAL.cjs');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
@@ -11,7 +11,7 @@ function TabSyncProvider({
 }) {
   const instanceRef = react.useRef(null);
   if (!instanceRef.current) {
-    instanceRef.current = chunkBQCNBNBT_cjs.createTabSync(options);
+    instanceRef.current = chunkTGEXRVAL_cjs.createTabSync(options);
   }
   react.useEffect(() => {
     return () => {
@@ -26,7 +26,7 @@ function useInstance(options) {
   const contextInstance = react.useContext(TabSyncContext);
   const [ownInstance] = react.useState(() => {
     if (!contextInstance && options) {
-      return chunkBQCNBNBT_cjs.createTabSync(options);
+      return chunkTGEXRVAL_cjs.createTabSync(options);
     }
     return null;
   });
@@ -127,14 +127,14 @@ function useTabSyncSelector(selector, isEqual) {
     initializedRef.current = true;
   }
   const subscribe = react.useCallback(
-    (onStoreChange) => instance.onChange(() => {
-      const next = selectorRef.current(instance.getAll());
-      const equal = isEqualRef.current ?? Object.is;
-      if (!equal(resultRef.current, next)) {
+    (onStoreChange) => instance.select(
+      (state) => selectorRef.current(state),
+      (next) => {
         resultRef.current = next;
         onStoreChange();
-      }
-    }),
+      },
+      { isEqual: isEqualRef.current }
+    ),
     [instance]
   );
   const getSnapshot = react.useCallback(() => resultRef.current, []);
@@ -165,10 +165,83 @@ function useIsLeader() {
   const getServerSnapshot = react.useCallback(() => SERVER_SNAPSHOT, []);
   return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
 }
+var SERVER_SNAPSHOT2 = [];
+function useTabs() {
+  const instance = react.useContext(TabSyncContext);
+  if (!instance) {
+    throw new Error("useTabs must be used within a <TabSyncProvider>");
+  }
+  const tabsRef = react.useRef(instance.getTabs());
+  const subscribe = react.useCallback(
+    (onStoreChange) => instance.onTabChange((tabs) => {
+      tabsRef.current = tabs;
+      onStoreChange();
+    }),
+    [instance]
+  );
+  const getSnapshot = react.useCallback(() => tabsRef.current, []);
+  const getServerSnapshot = react.useCallback(() => SERVER_SNAPSHOT2, []);
+  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function useLeaderInfo() {
+  const instance = react.useContext(TabSyncContext);
+  if (!instance) {
+    throw new Error("useLeaderInfo must be used within a <TabSyncProvider>");
+  }
+  const leaderRef = react.useRef(instance.getLeader());
+  const subscribe = react.useCallback(
+    (onStoreChange) => {
+      const unsubs = [];
+      unsubs.push(
+        instance.onTabChange(() => {
+          const next = instance.getLeader();
+          if (next?.id !== leaderRef.current?.id) {
+            leaderRef.current = next;
+            onStoreChange();
+          }
+        })
+      );
+      unsubs.push(
+        instance.onLeader(() => {
+          leaderRef.current = instance.getLeader();
+          onStoreChange();
+          return () => {
+            leaderRef.current = instance.getLeader();
+            onStoreChange();
+          };
+        })
+      );
+      return () => {
+        for (const u of unsubs) u();
+      };
+    },
+    [instance]
+  );
+  const getSnapshot = react.useCallback(() => leaderRef.current, []);
+  const getServerSnapshot = react.useCallback(() => null, []);
+  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+function useTabSyncActions() {
+  const instance = react.useContext(TabSyncContext);
+  if (!instance) {
+    throw new Error("useTabSyncActions must be used within a <TabSyncProvider>");
+  }
+  return react.useMemo(
+    () => ({
+      set: instance.set.bind(instance),
+      patch: instance.patch.bind(instance),
+      transaction: instance.transaction.bind(instance)
+    }),
+    [instance]
+  );
+}
 
 exports.TabSyncContext = TabSyncContext;
 exports.TabSyncProvider = TabSyncProvider;
 exports.useIsLeader = useIsLeader;
+exports.useLeaderInfo = useLeaderInfo;
 exports.useTabSync = useTabSync;
+exports.useTabSyncActions = useTabSyncActions;
 exports.useTabSyncSelector = useTabSyncSelector;
 exports.useTabSyncValue = useTabSyncValue;
+exports.useTabs = useTabs;

package/dist/react/index.d.cts

@@ -1,7 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { T as TabSyncOptions, a as TabSyncInstance, R as RPCMap, c as TabInfo } from '../types-BtK4ixKz.cjs';
+import { T as TabSyncOptions, a as TabSyncInstance, R as RPCMap, b as TabInfo } from '../instance-5LIItazN.cjs';
 
 interface TabSyncProviderProps<TState extends Record<string, unknown>> {
     options: TabSyncOptions<TState>;
@@ -35,6 +35,9 @@ declare function useTabSyncValue<TState extends Record<string, unknown>, K exten
  * Subscribe to a **derived value** from the synced state.
  * Only re-renders when the selector's output actually changes.
  *
+ * Uses `instance.select()` internally so only changed-key
+ * evaluations trigger the selector, reducing unnecessary work.
+ *
  * ```tsx
  * const doneCount = useTabSyncSelector(
  *   (s) => s.todos.filter(t => t.done).length,
@@ -58,4 +61,46 @@ declare function useTabSyncSelector<TState extends Record<string, unknown>, TRes
  */
 declare function useIsLeader(): boolean;
 
-export { TabSyncContext, TabSyncProvider, type TabSyncProviderProps, useIsLeader, useTabSync, useTabSyncSelector, useTabSyncValue };
+/**
+ * Subscribe to the list of active tabs. Re-renders when tabs join or leave.
+ *
+ * ```tsx
+ * const tabs = useTabs();
+ * // tabs: TabInfo[]
+ * ```
+ *
+ * Must be used within a `<TabSyncProvider>`.
+ */
+declare function useTabs(): TabInfo[];
+
+/**
+ * Subscribe to the current leader's full `TabInfo`.
+ * Returns `null` if no leader has been elected yet.
+ *
+ * ```tsx
+ * const leader = useLeaderInfo();
+ * // leader: TabInfo | null
+ * ```
+ *
+ * Must be used within a `<TabSyncProvider>`.
+ */
+declare function useLeaderInfo(): TabInfo | null;
+
+interface TabSyncActions<TState extends Record<string, unknown>> {
+    set: TabSyncInstance<TState>['set'];
+    patch: TabSyncInstance<TState>['patch'];
+    transaction: TabSyncInstance<TState>['transaction'];
+}
+/**
+ * Returns `set`, `patch`, and `transaction` without subscribing to state.
+ * Components using only this hook never re-render due to state changes.
+ *
+ * ```tsx
+ * const { set, patch, transaction } = useTabSyncActions();
+ * ```
+ *
+ * Must be used within a `<TabSyncProvider>`.
+ */
+declare function useTabSyncActions<TState extends Record<string, unknown> = Record<string, unknown>>(): TabSyncActions<TState>;
+
+export { type TabSyncActions, TabSyncContext, TabSyncProvider, type TabSyncProviderProps, useIsLeader, useLeaderInfo, useTabSync, useTabSyncActions, useTabSyncSelector, useTabSyncValue, useTabs };

package/dist/react/index.d.ts

@@ -1,7 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { T as TabSyncOptions, a as TabSyncInstance, R as RPCMap, c as TabInfo } from '../types-BtK4ixKz.js';
+import { T as TabSyncOptions, a as TabSyncInstance, R as RPCMap, b as TabInfo } from '../instance-5LIItazN.js';
 
 interface TabSyncProviderProps<TState extends Record<string, unknown>> {
     options: TabSyncOptions<TState>;
@@ -35,6 +35,9 @@ declare function useTabSyncValue<TState extends Record<string, unknown>, K exten
  * Subscribe to a **derived value** from the synced state.
  * Only re-renders when the selector's output actually changes.
  *
+ * Uses `instance.select()` internally so only changed-key
+ * evaluations trigger the selector, reducing unnecessary work.
+ *
  * ```tsx
  * const doneCount = useTabSyncSelector(
  *   (s) => s.todos.filter(t => t.done).length,
@@ -58,4 +61,46 @@ declare function useTabSyncSelector<TState extends Record<string, unknown>, TRes
  */
 declare function useIsLeader(): boolean;
 
-export { TabSyncContext, TabSyncProvider, type TabSyncProviderProps, useIsLeader, useTabSync, useTabSyncSelector, useTabSyncValue };
+/**
+ * Subscribe to the list of active tabs. Re-renders when tabs join or leave.
+ *
+ * ```tsx
+ * const tabs = useTabs();
+ * // tabs: TabInfo[]
+ * ```
+ *
+ * Must be used within a `<TabSyncProvider>`.
+ */
+declare function useTabs(): TabInfo[];
+
+/**
+ * Subscribe to the current leader's full `TabInfo`.
+ * Returns `null` if no leader has been elected yet.
+ *
+ * ```tsx
+ * const leader = useLeaderInfo();
+ * // leader: TabInfo | null
+ * ```
+ *
+ * Must be used within a `<TabSyncProvider>`.
+ */
+declare function useLeaderInfo(): TabInfo | null;
+
+interface TabSyncActions<TState extends Record<string, unknown>> {
+    set: TabSyncInstance<TState>['set'];
+    patch: TabSyncInstance<TState>['patch'];
+    transaction: TabSyncInstance<TState>['transaction'];
+}
+/**
+ * Returns `set`, `patch`, and `transaction` without subscribing to state.
+ * Components using only this hook never re-render due to state changes.
+ *
+ * ```tsx
+ * const { set, patch, transaction } = useTabSyncActions();
+ * ```
+ *
+ * Must be used within a `<TabSyncProvider>`.
+ */
+declare function useTabSyncActions<TState extends Record<string, unknown> = Record<string, unknown>>(): TabSyncActions<TState>;
+
+export { type TabSyncActions, TabSyncContext, TabSyncProvider, type TabSyncProviderProps, useIsLeader, useLeaderInfo, useTabSync, useTabSyncActions, useTabSyncSelector, useTabSyncValue, useTabs };