tab-bridge 0.1.0

package/dist/chunk-BQCNBNBT.cjs

@@ -0,0 +1,1332 @@
+'use strict';
+
+// src/types.ts
+var PROTOCOL_VERSION = 1;
+
+// src/utils/id.ts
+function generateTabId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/utils/env.ts
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var hasDocument = typeof document !== "undefined";
+var hasLocalStorage = (() => {
+  try {
+    return typeof localStorage !== "undefined" && localStorage !== null;
+  } catch {
+    return false;
+  }
+})();
+var hasBroadcastChannel = typeof BroadcastChannel !== "undefined";
+var hasCrypto = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function";
+
+// src/channels/broadcast.ts
+var BroadcastChannelTransport = class {
+  constructor(channelName) {
+    this.closed = false;
+    this.bc = new BroadcastChannel(channelName);
+  }
+  postMessage(message) {
+    if (this.closed) return;
+    this.bc.postMessage(message);
+  }
+  onMessage(callback) {
+    const handler = (event) => {
+      callback(event.data);
+    };
+    this.bc.addEventListener("message", handler);
+    return () => this.bc.removeEventListener("message", handler);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.bc.close();
+  }
+};
+
+// src/channels/storage.ts
+var KEY_PREFIX = "__tab_sync__";
+var StorageChannel = class {
+  constructor(channelName) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.closed = false;
+    this.seq = 0;
+    this.key = `${KEY_PREFIX}${channelName}`;
+  }
+  postMessage(message) {
+    if (this.closed || !hasLocalStorage) return;
+    try {
+      const wrapped = JSON.stringify({ m: message, s: this.seq++ });
+      localStorage.setItem(this.key, wrapped);
+    } catch {
+    }
+  }
+  onMessage(callback) {
+    if (!isBrowser) return () => {
+    };
+    const handler = (event) => {
+      if (event.key !== this.key || !event.newValue) return;
+      try {
+        const { m } = JSON.parse(event.newValue);
+        callback(m);
+      } catch {
+      }
+    };
+    this.listeners.add(handler);
+    window.addEventListener("storage", handler);
+    return () => {
+      this.listeners.delete(handler);
+      window.removeEventListener("storage", handler);
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (isBrowser) {
+      for (const handler of this.listeners) {
+        window.removeEventListener("storage", handler);
+      }
+    }
+    this.listeners.clear();
+    if (hasLocalStorage) {
+      try {
+        localStorage.removeItem(this.key);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/channels/channel.ts
+function createChannel(channelName, transport) {
+  if (transport === "local-storage") {
+    return new StorageChannel(channelName);
+  }
+  if (transport === "broadcast-channel") {
+    return new BroadcastChannelTransport(channelName);
+  }
+  if (typeof BroadcastChannel !== "undefined") {
+    return new BroadcastChannelTransport(channelName);
+  }
+  return new StorageChannel(channelName);
+}
+
+// src/utils/timestamp.ts
+var lastTimestamp = 0;
+function monotonic() {
+  const now = Date.now();
+  lastTimestamp = now > lastTimestamp ? now : lastTimestamp + 1;
+  return lastTimestamp;
+}
+
+// src/utils/batch.ts
+function createBatcher(onFlush, delay = 16) {
+  const pending = /* @__PURE__ */ new Map();
+  let timer = null;
+  function flush() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (pending.size > 0) {
+      const snapshot = new Map(pending);
+      pending.clear();
+      onFlush(snapshot);
+    }
+  }
+  return {
+    add(key, value) {
+      pending.set(key, value);
+      if (!timer) {
+        timer = setTimeout(flush, delay);
+      }
+    },
+    flush,
+    destroy() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      pending.clear();
+    }
+  };
+}
+
+// src/core/state-manager.ts
+var StateManager = class {
+  constructor(options) {
+    this.state = /* @__PURE__ */ new Map();
+    this.keyListeners = /* @__PURE__ */ new Map();
+    this.changeListeners = /* @__PURE__ */ new Set();
+    this.snapshotCache = null;
+    this.send = options.send;
+    this.tabId = options.tabId;
+    this.mergeFn = options.merge;
+    this.interceptRemote = options.interceptRemote;
+    this.afterRemoteChange = options.afterRemoteChange;
+    if (options.initial) {
+      for (const [key, value] of Object.entries(options.initial)) {
+        this.state.set(key, { value, timestamp: 0 });
+      }
+    }
+    this.batcher = createBatcher((entries) => {
+      const payload = { entries: {} };
+      for (const [key, entry] of entries) {
+        payload.entries[key] = { value: entry.value, timestamp: entry.timestamp };
+      }
+      this.send({
+        type: "STATE_UPDATE",
+        senderId: this.tabId,
+        timestamp: monotonic(),
+        payload
+      });
+    });
+  }
+  // ── Read ──
+  get(key) {
+    return this.state.get(key)?.value;
+  }
+  /**
+   * Returns a cached snapshot. The same reference is returned until state
+   * changes, making this safe for React's `useSyncExternalStore`.
+   */
+  getAll() {
+    if (!this.snapshotCache) {
+      const result = {};
+      for (const [key, entry] of this.state) {
+        result[key] = entry.value;
+      }
+      this.snapshotCache = result;
+    }
+    return this.snapshotCache;
+  }
+  // ── Write ──
+  set(key, value) {
+    const timestamp = monotonic();
+    const k = key;
+    this.state.set(k, { value, timestamp });
+    this.snapshotCache = null;
+    const meta = { sourceTabId: this.tabId, isLocal: true, timestamp };
+    this.notifyKey(k, value, meta);
+    this.notifyChange([key], meta);
+    this.batcher.add(k, { value, timestamp });
+  }
+  patch(partial) {
+    const entries = Object.entries(partial);
+    if (entries.length === 0) return;
+    const timestamp = monotonic();
+    const changedKeys = [];
+    for (const [key, value] of entries) {
+      this.state.set(key, { value, timestamp });
+      changedKeys.push(key);
+      this.batcher.add(key, { value, timestamp });
+    }
+    this.snapshotCache = null;
+    const meta = { sourceTabId: this.tabId, isLocal: true, timestamp };
+    for (const key of changedKeys) {
+      this.notifyKey(key, this.state.get(key).value, meta);
+    }
+    this.notifyChange(changedKeys, meta);
+  }
+  // ── Subscriptions ──
+  on(key, callback) {
+    const k = key;
+    let set = this.keyListeners.get(k);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.keyListeners.set(k, set);
+    }
+    set.add(callback);
+    return () => {
+      set.delete(callback);
+    };
+  }
+  onChange(callback) {
+    this.changeListeners.add(callback);
+    return () => {
+      this.changeListeners.delete(callback);
+    };
+  }
+  // ── Incoming messages ──
+  handleMessage(message) {
+    switch (message.type) {
+      case "STATE_UPDATE":
+        this.applyRemoteUpdate(message);
+        break;
+      case "STATE_SYNC_RESPONSE":
+        if (!message.targetId || message.targetId === this.tabId) {
+          this.applySyncResponse(message);
+        }
+        break;
+    }
+  }
+  // ── Sync protocol ──
+  requestSync() {
+    this.send({
+      type: "STATE_SYNC_REQUEST",
+      senderId: this.tabId,
+      timestamp: monotonic(),
+      payload: null
+    });
+  }
+  respondToSync(targetId) {
+    const state = {};
+    for (const [key, entry] of this.state) {
+      state[key] = { value: entry.value, timestamp: entry.timestamp };
+    }
+    this.send({
+      type: "STATE_SYNC_RESPONSE",
+      senderId: this.tabId,
+      targetId,
+      timestamp: monotonic(),
+      payload: { state }
+    });
+  }
+  flush() {
+    this.batcher.flush();
+  }
+  destroy() {
+    this.batcher.destroy();
+    this.keyListeners.clear();
+    this.changeListeners.clear();
+  }
+  // ── Private ──
+  applyRemoteUpdate(message) {
+    const { entries } = message.payload;
+    const changedKeys = [];
+    const meta = {
+      sourceTabId: message.senderId,
+      isLocal: false,
+      timestamp: message.timestamp
+    };
+    for (const [key, remote] of Object.entries(entries)) {
+      const local = this.state.get(key);
+      let finalValue;
+      if (this.mergeFn) {
+        finalValue = this.mergeFn(local?.value, remote.value, key);
+      } else if (this.shouldAcceptRemote(local, remote, message.senderId)) {
+        finalValue = remote.value;
+      } else {
+        continue;
+      }
+      if (this.interceptRemote) {
+        const result = this.interceptRemote(
+          key,
+          finalValue,
+          local?.value,
+          meta
+        );
+        if (result === false) continue;
+        if (result && "value" in result) finalValue = result.value;
+      }
+      this.state.set(key, { value: finalValue, timestamp: remote.timestamp });
+      changedKeys.push(key);
+    }
+    if (changedKeys.length > 0) {
+      this.snapshotCache = null;
+      for (const key of changedKeys) {
+        const val = this.state.get(key).value;
+        this.notifyKey(key, val, meta);
+        this.afterRemoteChange?.(key, val, meta);
+      }
+      this.notifyChange(changedKeys, meta);
+    }
+  }
+  /** LWW: accept remote if newer timestamp, or same timestamp with higher senderId. */
+  shouldAcceptRemote(local, remote, remoteSenderId) {
+    if (!local) return true;
+    if (remote.timestamp > local.timestamp) return true;
+    if (remote.timestamp === local.timestamp) return remoteSenderId > this.tabId;
+    return false;
+  }
+  applySyncResponse(message) {
+    const { state } = message.payload;
+    const changedKeys = [];
+    const meta = {
+      sourceTabId: message.senderId,
+      isLocal: false,
+      timestamp: message.timestamp
+    };
+    for (const [key, remote] of Object.entries(state)) {
+      const local = this.state.get(key);
+      if (!local || remote.timestamp > local.timestamp) {
+        this.state.set(key, { value: remote.value, timestamp: remote.timestamp });
+        changedKeys.push(key);
+      }
+    }
+    if (changedKeys.length > 0) {
+      this.snapshotCache = null;
+      for (const key of changedKeys) {
+        const val = this.state.get(key).value;
+        this.notifyKey(key, val, meta);
+        this.afterRemoteChange?.(key, val, meta);
+      }
+      this.notifyChange(changedKeys, meta);
+    }
+  }
+  notifyKey(key, value, meta) {
+    const listeners = this.keyListeners.get(key);
+    if (!listeners) return;
+    for (const cb of listeners) {
+      cb(value, meta);
+    }
+  }
+  notifyChange(changedKeys, meta) {
+    if (this.changeListeners.size === 0) return;
+    const snapshot = this.getAll();
+    for (const cb of this.changeListeners) {
+      cb(snapshot, changedKeys, meta);
+    }
+  }
+};
+
+// src/core/tab-registry.ts
+var TabRegistry = class {
+  constructor(options) {
+    this.tabs = /* @__PURE__ */ new Map();
+    this.tabChangeListeners = /* @__PURE__ */ new Set();
+    this.heartbeatTimer = null;
+    this.pruneTimer = null;
+    this.visibilityHandler = null;
+    this.unloadHandler = null;
+    this.send = options.send;
+    this.tabId = options.tabId;
+    this.tabCreatedAt = options.tabCreatedAt;
+    this.heartbeatInterval = options.heartbeatInterval ?? 2e3;
+    this.tabTimeout = options.tabTimeout ?? 6e3;
+    this.registerSelf();
+    this.startHeartbeat();
+    this.startPruning();
+    this.listenVisibility();
+    this.listenUnload();
+  }
+  // ── Public API ──
+  getTabs() {
+    return Array.from(this.tabs.values());
+  }
+  getTabCount() {
+    return this.tabs.size;
+  }
+  getTab(id) {
+    return this.tabs.get(id);
+  }
+  onTabChange(callback) {
+    this.tabChangeListeners.add(callback);
+    return () => {
+      this.tabChangeListeners.delete(callback);
+    };
+  }
+  announce() {
+    this.send({
+      type: "TAB_ANNOUNCE",
+      senderId: this.tabId,
+      timestamp: monotonic(),
+      payload: this.buildAnnouncePayload()
+    });
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "TAB_ANNOUNCE":
+        this.handleAnnounce(message.senderId, message.payload);
+        break;
+      case "TAB_GOODBYE":
+        this.handleGoodbye(message.senderId);
+        break;
+      case "LEADER_HEARTBEAT":
+      case "STATE_UPDATE":
+      case "LEADER_CLAIM":
+      case "LEADER_ACK":
+        this.touchTab(message.senderId);
+        break;
+    }
+  }
+  setLeader(tabId) {
+    let changed = false;
+    for (const [id, info] of this.tabs) {
+      const wasLeader = info.isLeader;
+      const isNowLeader = id === tabId;
+      if (wasLeader !== isNowLeader) {
+        this.tabs.set(id, { ...info, isLeader: isNowLeader });
+        changed = true;
+      }
+    }
+    if (changed) this.notifyChange();
+  }
+  destroy() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.pruneTimer) clearInterval(this.pruneTimer);
+    if (this.visibilityHandler && hasDocument) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+    }
+    if (this.unloadHandler && isBrowser) {
+      window.removeEventListener("beforeunload", this.unloadHandler);
+    }
+    this.sendGoodbye();
+    this.tabs.clear();
+    this.tabChangeListeners.clear();
+  }
+  // ── Private ──
+  registerSelf() {
+    this.tabs.set(this.tabId, {
+      id: this.tabId,
+      createdAt: this.tabCreatedAt,
+      lastSeen: Date.now(),
+      isLeader: false,
+      isActive: hasDocument ? document.visibilityState === "visible" : true,
+      url: isBrowser ? location.href : "",
+      title: hasDocument ? document.title : void 0
+    });
+  }
+  buildAnnouncePayload() {
+    return {
+      createdAt: this.tabCreatedAt,
+      isActive: hasDocument ? document.visibilityState === "visible" : true,
+      url: isBrowser ? location.href : "",
+      title: hasDocument ? document.title : void 0
+    };
+  }
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      this.touchSelf();
+      this.announce();
+    }, this.heartbeatInterval);
+  }
+  startPruning() {
+    this.pruneTimer = setInterval(() => {
+      this.pruneDeadTabs();
+    }, this.heartbeatInterval);
+  }
+  listenVisibility() {
+    if (!hasDocument) return;
+    this.visibilityHandler = () => {
+      const self = this.tabs.get(this.tabId);
+      if (self) {
+        const isActive = document.visibilityState === "visible";
+        this.tabs.set(this.tabId, { ...self, isActive, lastSeen: Date.now() });
+        this.announce();
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  listenUnload() {
+    if (!isBrowser) return;
+    this.unloadHandler = () => this.sendGoodbye();
+    window.addEventListener("beforeunload", this.unloadHandler);
+  }
+  sendGoodbye() {
+    this.send({
+      type: "TAB_GOODBYE",
+      senderId: this.tabId,
+      timestamp: monotonic(),
+      payload: null
+    });
+  }
+  handleAnnounce(senderId, payload) {
+    const existing = this.tabs.get(senderId);
+    this.tabs.set(senderId, {
+      id: senderId,
+      createdAt: payload.createdAt,
+      lastSeen: Date.now(),
+      isLeader: existing?.isLeader ?? false,
+      isActive: payload.isActive,
+      url: payload.url,
+      title: payload.title
+    });
+    this.notifyChange();
+  }
+  handleGoodbye(senderId) {
+    if (this.tabs.delete(senderId)) {
+      this.notifyChange();
+    }
+  }
+  touchTab(tabId) {
+    const tab = this.tabs.get(tabId);
+    if (tab) {
+      this.tabs.set(tabId, { ...tab, lastSeen: Date.now() });
+    }
+  }
+  touchSelf() {
+    const self = this.tabs.get(this.tabId);
+    if (self) {
+      this.tabs.set(this.tabId, { ...self, lastSeen: Date.now() });
+    }
+  }
+  pruneDeadTabs() {
+    const now = Date.now();
+    let changed = false;
+    for (const [id, info] of this.tabs) {
+      if (id === this.tabId) continue;
+      if (now - info.lastSeen > this.tabTimeout) {
+        this.tabs.delete(id);
+        changed = true;
+      }
+    }
+    if (changed) this.notifyChange();
+  }
+  notifyChange() {
+    if (this.tabChangeListeners.size === 0) return;
+    const tabs = this.getTabs();
+    for (const cb of this.tabChangeListeners) {
+      cb(tabs);
+    }
+  }
+};
+
+// src/core/leader-election.ts
+var LeaderElection = class {
+  constructor(options) {
+    this.leaderId = null;
+    this.electionTimer = null;
+    this.heartbeatTimer = null;
+    this.leaderWatchTimer = null;
+    this.lastLeaderHeartbeat = 0;
+    this.electing = false;
+    this.leaderCallbacks = /* @__PURE__ */ new Set();
+    this.leaderCleanups = /* @__PURE__ */ new Map();
+    this.send = options.send;
+    this.tabId = options.tabId;
+    this.tabCreatedAt = options.tabCreatedAt;
+    this.electionTimeout = options.electionTimeout ?? 300;
+    this.heartbeatInterval = options.heartbeatInterval ?? 2e3;
+    const missedLimit = options.missedHeartbeatsLimit ?? 3;
+    this.leaderTimeout = this.heartbeatInterval * missedLimit;
+  }
+  // ── Public API ──
+  isLeader() {
+    return this.leaderId === this.tabId;
+  }
+  getLeaderId() {
+    return this.leaderId;
+  }
+  onLeader(callback) {
+    this.leaderCallbacks.add(callback);
+    if (this.isLeader()) {
+      const cleanup = callback();
+      if (typeof cleanup === "function") {
+        this.leaderCleanups.set(callback, cleanup);
+      }
+    }
+    return () => {
+      this.leaderCallbacks.delete(callback);
+      const cleanup = this.leaderCleanups.get(callback);
+      if (cleanup) {
+        cleanup();
+        this.leaderCleanups.delete(callback);
+      }
+    };
+  }
+  start() {
+    this.startElection();
+    this.startLeaderWatch();
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "LEADER_CLAIM":
+        this.handleClaim(message.payload, message.senderId);
+        break;
+      case "LEADER_ACK":
+        this.handleAck(message.senderId);
+        break;
+      case "LEADER_HEARTBEAT":
+        this.handleHeartbeat(message.senderId);
+        break;
+      case "LEADER_RESIGN":
+        this.handleResign(message.senderId);
+        break;
+    }
+  }
+  destroy() {
+    if (this.isLeader()) {
+      this.send({
+        type: "LEADER_RESIGN",
+        senderId: this.tabId,
+        timestamp: monotonic(),
+        payload: null
+      });
+    }
+    this.clearElectionTimer();
+    this.clearHeartbeat();
+    this.clearLeaderWatch();
+    this.runCleanups();
+    this.leaderCallbacks.clear();
+    this.leaderId = null;
+  }
+  // ── Election ──
+  startElection() {
+    if (this.electing) return;
+    this.electing = true;
+    this.send({
+      type: "LEADER_CLAIM",
+      senderId: this.tabId,
+      timestamp: monotonic(),
+      payload: { createdAt: this.tabCreatedAt }
+    });
+    this.electionTimer = setTimeout(() => {
+      this.electionTimer = null;
+      this.electing = false;
+      this.becomeLeader();
+    }, this.electionTimeout);
+  }
+  handleClaim(payload, senderId) {
+    if (this.hasPriority(payload.createdAt, senderId)) {
+      if (!this.electing) this.startElection();
+    } else {
+      this.clearElectionTimer();
+      this.electing = false;
+    }
+  }
+  handleAck(senderId) {
+    this.clearElectionTimer();
+    this.electing = false;
+    this.setLeader(senderId);
+  }
+  handleHeartbeat(senderId) {
+    if (senderId === this.leaderId || !this.leaderId) {
+      this.setLeader(senderId);
+    }
+    this.lastLeaderHeartbeat = Date.now();
+  }
+  handleResign(senderId) {
+    if (senderId === this.leaderId) {
+      this.leaderId = null;
+      this.runCleanups();
+      this.startElection();
+    }
+  }
+  becomeLeader() {
+    this.setLeader(this.tabId);
+    this.send({
+      type: "LEADER_ACK",
+      senderId: this.tabId,
+      timestamp: monotonic(),
+      payload: null
+    });
+    this.startHeartbeat();
+  }
+  setLeader(id) {
+    const wasLeader = this.isLeader();
+    this.leaderId = id;
+    this.lastLeaderHeartbeat = Date.now();
+    if (this.isLeader() && !wasLeader) {
+      this.startHeartbeat();
+      for (const cb of this.leaderCallbacks) {
+        const cleanup = cb();
+        if (typeof cleanup === "function") {
+          this.leaderCleanups.set(cb, cleanup);
+        }
+      }
+    } else if (!this.isLeader() && wasLeader) {
+      this.clearHeartbeat();
+      this.runCleanups();
+    }
+  }
+  /**
+   * Priority: oldest tab (smaller `createdAt`) wins.
+   * Tiebreak: lower `tabId` wins (deterministic).
+   */
+  hasPriority(remoteCreatedAt, remoteTabId) {
+    if (this.tabCreatedAt < remoteCreatedAt) return true;
+    if (this.tabCreatedAt > remoteCreatedAt) return false;
+    return this.tabId < remoteTabId;
+  }
+  // ── Heartbeat ──
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isLeader()) return;
+      this.send({
+        type: "LEADER_HEARTBEAT",
+        senderId: this.tabId,
+        timestamp: monotonic(),
+        payload: null
+      });
+    }, this.heartbeatInterval);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ── Leader Watch ──
+  startLeaderWatch() {
+    this.lastLeaderHeartbeat = Date.now();
+    this.leaderWatchTimer = setInterval(() => {
+      if (this.isLeader()) return;
+      if (this.leaderId && Date.now() - this.lastLeaderHeartbeat > this.leaderTimeout) {
+        this.leaderId = null;
+        this.runCleanups();
+        this.startElection();
+      }
+    }, this.heartbeatInterval);
+  }
+  clearLeaderWatch() {
+    if (this.leaderWatchTimer) {
+      clearInterval(this.leaderWatchTimer);
+      this.leaderWatchTimer = null;
+    }
+  }
+  clearElectionTimer() {
+    if (this.electionTimer) {
+      clearTimeout(this.electionTimer);
+      this.electionTimer = null;
+    }
+  }
+  runCleanups() {
+    for (const cleanup of this.leaderCleanups.values()) {
+      cleanup();
+    }
+    this.leaderCleanups.clear();
+  }
+};
+
+// src/utils/errors.ts
+var ErrorCode = {
+  CHANNEL_CLOSED: "CHANNEL_CLOSED",
+  CHANNEL_SEND_FAILED: "CHANNEL_SEND_FAILED",
+  RPC_TIMEOUT: "RPC_TIMEOUT",
+  RPC_NO_HANDLER: "RPC_NO_HANDLER",
+  RPC_NO_LEADER: "RPC_NO_LEADER",
+  RPC_HANDLER_ERROR: "RPC_HANDLER_ERROR",
+  RPC_DESTROYED: "RPC_DESTROYED",
+  STORAGE_QUOTA_EXCEEDED: "STORAGE_QUOTA_EXCEEDED",
+  MIDDLEWARE_REJECTED: "MIDDLEWARE_REJECTED",
+  ALREADY_DESTROYED: "ALREADY_DESTROYED"
+};
+var TabSyncError = class _TabSyncError extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.name = "TabSyncError";
+    this.cause = cause;
+  }
+  static timeout(method, ms) {
+    return new _TabSyncError(
+      `RPC "${method}" timed out after ${ms}ms`,
+      ErrorCode.RPC_TIMEOUT
+    );
+  }
+  static noLeader() {
+    return new _TabSyncError("No leader available", ErrorCode.RPC_NO_LEADER);
+  }
+  static noHandler(method) {
+    return new _TabSyncError(
+      `No handler registered for "${method}"`,
+      ErrorCode.RPC_NO_HANDLER
+    );
+  }
+  static destroyed() {
+    return new _TabSyncError("Instance has been destroyed", ErrorCode.ALREADY_DESTROYED);
+  }
+};
+
+// src/core/rpc.ts
+var DEFAULT_TIMEOUT = 5e3;
+var RPCHandler = class {
+  constructor(options) {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.send = options.send;
+    this.tabId = options.tabId;
+    this.resolveLeaderId = options.resolveLeaderId ?? (() => null);
+    this.onError = options.onError ?? (() => {
+    });
+  }
+  call(targetTabId, method, args, timeout = DEFAULT_TIMEOUT) {
+    const resolvedTarget = targetTabId === "leader" ? this.resolveLeaderId() : targetTabId;
+    if (!resolvedTarget) {
+      return Promise.reject(TabSyncError.noLeader());
+    }
+    const callId = generateTabId();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(callId);
+        reject(TabSyncError.timeout(method, timeout));
+      }, timeout);
+      this.pending.set(callId, {
+        resolve,
+        reject,
+        timer
+      });
+      this.send({
+        type: "RPC_REQUEST",
+        senderId: this.tabId,
+        targetId: resolvedTarget,
+        timestamp: monotonic(),
+        payload: { callId, method, args }
+      });
+    });
+  }
+  handle(method, handler) {
+    this.handlers.set(
+      method,
+      handler
+    );
+    return () => {
+      this.handlers.delete(method);
+    };
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "RPC_REQUEST":
+        if (!message.targetId || message.targetId === this.tabId) {
+          this.handleRequest(message);
+        }
+        break;
+      case "RPC_RESPONSE":
+        if (!message.targetId || message.targetId === this.tabId) {
+          this.handleResponse(message);
+        }
+        break;
+    }
+  }
+  destroy() {
+    const error = TabSyncError.destroyed();
+    for (const [, call] of this.pending) {
+      clearTimeout(call.timer);
+      call.reject(error);
+    }
+    this.pending.clear();
+    this.handlers.clear();
+  }
+  // ── Private ──
+  async handleRequest(message) {
+    const { callId, method, args } = message.payload;
+    const handler = this.handlers.get(method);
+    if (!handler) {
+      const err = TabSyncError.noHandler(method);
+      this.onError(err);
+      this.sendResponse(message.senderId, callId, void 0, err.message);
+      return;
+    }
+    try {
+      const result = await handler(args, message.senderId);
+      this.sendResponse(message.senderId, callId, result);
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.onError(
+        new TabSyncError(errorMsg, ErrorCode.RPC_HANDLER_ERROR, err)
+      );
+      this.sendResponse(message.senderId, callId, void 0, errorMsg);
+    }
+  }
+  handleResponse(message) {
+    const { callId, result, error } = message.payload;
+    const call = this.pending.get(callId);
+    if (!call) return;
+    clearTimeout(call.timer);
+    this.pending.delete(callId);
+    if (error) {
+      call.reject(
+        new TabSyncError(error, ErrorCode.RPC_HANDLER_ERROR)
+      );
+    } else {
+      call.resolve(result);
+    }
+  }
+  sendResponse(targetId, callId, result, error) {
+    this.send({
+      type: "RPC_RESPONSE",
+      senderId: this.tabId,
+      targetId,
+      timestamp: monotonic(),
+      payload: { callId, result, error }
+    });
+  }
+};
+
+// src/core/middleware.ts
+function runMiddleware(middlewares, ctx) {
+  let currentValue = ctx.value;
+  for (const mw of middlewares) {
+    const fn = mw.onSet;
+    if (!fn) continue;
+    const result = fn({ ...ctx, value: currentValue });
+    if (result === false) {
+      return { value: currentValue, rejected: true };
+    }
+    if (result && "value" in result) {
+      currentValue = result.value;
+    }
+  }
+  return { value: currentValue, rejected: false };
+}
+function notifyMiddleware(middlewares, key, value, meta) {
+  for (const mw of middlewares) {
+    mw.afterChange?.(key, value, meta);
+  }
+}
+function destroyMiddleware(middlewares) {
+  for (const mw of middlewares) {
+    mw.onDestroy?.();
+  }
+}
+
+// src/core/tab-sync.ts
+function resolvePersistOptions(opt) {
+  if (!opt) return null;
+  if (opt === true) return {};
+  return opt;
+}
+function loadPersistedState(opts) {
+  const storage = opts.storage ?? (hasLocalStorage ? localStorage : null);
+  if (!storage) return {};
+  const key = opts.key ?? "tab-sync:state";
+  const deserialize = opts.deserialize ?? JSON.parse;
+  try {
+    const raw = storage.getItem(key);
+    if (!raw) return {};
+    const parsed = deserialize(raw);
+    return filterPersistKeys(parsed, opts);
+  } catch {
+    return {};
+  }
+}
+function filterPersistKeys(state, opts) {
+  const include = opts.include ? new Set(opts.include) : null;
+  const exclude = opts.exclude ? new Set(opts.exclude) : null;
+  const result = {};
+  for (const [key, value] of Object.entries(state)) {
+    const k = key;
+    if (exclude?.has(k)) continue;
+    if (include && !include.has(k)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+function createPersistSaver(opts, onError) {
+  const storage = opts.storage ?? (hasLocalStorage ? localStorage : null);
+  if (!storage) return { save() {
+  }, flush() {
+  }, destroy() {
+  } };
+  const key = opts.key ?? "tab-sync:state";
+  const serialize = opts.serialize ?? JSON.stringify;
+  const debounce = opts.debounce ?? 100;
+  let timer = null;
+  let latestState = null;
+  function doSave() {
+    if (!latestState) return;
+    try {
+      const filtered = filterPersistKeys({ ...latestState }, opts);
+      storage.setItem(key, serialize(filtered));
+    } catch (e) {
+      onError(e instanceof Error ? e : new Error(String(e)));
+    }
+    latestState = null;
+  }
+  return {
+    save(state) {
+      latestState = state;
+      if (!timer) {
+        timer = setTimeout(() => {
+          timer = null;
+          doSave();
+        }, debounce);
+      }
+    },
+    flush() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      doSave();
+    },
+    destroy() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      doSave();
+    }
+  };
+}
+function createLogger(enabled, tabId) {
+  if (!enabled) return { log: (() => {
+  }) };
+  const prefix = `%c[tab-sync:${tabId.slice(0, 8)}]`;
+  const style = "color:#818cf8;font-weight:600";
+  return {
+    log: (label, ...args) => console.log(prefix, style, label, ...args)
+  };
+}
+function createTabSync(options) {
+  const opts = options ?? {};
+  const tabId = generateTabId();
+  const tabCreatedAt = Date.now();
+  const channelName = opts.channel ?? "tab-sync";
+  const debug = opts.debug ?? false;
+  const onError = opts.onError ?? (() => {
+  });
+  const leaderEnabled = opts.leader !== false;
+  const leaderOpts = typeof opts.leader === "object" ? opts.leader : {};
+  const heartbeatInterval = opts.heartbeatInterval ?? leaderOpts.heartbeatInterval ?? 2e3;
+  const leaderTimeout = opts.leaderTimeout ?? leaderOpts.leaderTimeout ?? 6e3;
+  const missedHeartbeatsLimit = Math.max(
+    1,
+    Math.round(leaderTimeout / heartbeatInterval)
+  );
+  const middlewares = [...opts.middlewares ?? []];
+  const persistOpts = resolvePersistOptions(opts.persist);
+  const persister = persistOpts ? createPersistSaver(persistOpts, onError) : null;
+  let initialState = opts.initial ?? {};
+  if (persistOpts) {
+    const restored = loadPersistedState(persistOpts);
+    if (Object.keys(restored).length > 0) {
+      initialState = { ...initialState, ...restored };
+    }
+  }
+  const channel = createChannel(channelName, opts.transport);
+  const { log } = createLogger(debug, tabId);
+  const send = (message) => {
+    log("\u2192", message.type, message.payload);
+    channel.postMessage(message);
+  };
+  const stateManager = new StateManager({
+    send,
+    tabId,
+    initial: initialState,
+    merge: opts.merge,
+    afterRemoteChange(key, value, meta) {
+      notifyMiddleware(middlewares, key, value, meta);
+      if (persister) persister.save(stateManager.getAll());
+    }
+  });
+  const registry = new TabRegistry({
+    send,
+    tabId,
+    tabCreatedAt,
+    heartbeatInterval,
+    tabTimeout: leaderTimeout
+  });
+  let election = null;
+  if (leaderEnabled) {
+    election = new LeaderElection({
+      send,
+      tabId,
+      tabCreatedAt,
+      heartbeatInterval,
+      missedHeartbeatsLimit
+    });
+  }
+  const rpc = new RPCHandler({
+    send,
+    tabId,
+    resolveLeaderId: () => election?.getLeaderId() ?? null,
+    onError
+  });
+  const unsubChannel = channel.onMessage((message) => {
+    log("\u2190", message.type, `from=${message.senderId}`);
+    if (message.senderId === tabId) return;
+    if (message.version && message.version > PROTOCOL_VERSION) {
+      log("\u26A0\uFE0F", `Unknown protocol v${message.version}, ignoring`);
+      return;
+    }
+    registry.handleMessage(message);
+    switch (message.type) {
+      case "STATE_UPDATE":
+      case "STATE_SYNC_RESPONSE":
+        stateManager.handleMessage(message);
+        break;
+      case "STATE_SYNC_REQUEST":
+        if (election?.isLeader() ?? true) {
+          stateManager.respondToSync(message.senderId);
+        }
+        break;
+      case "LEADER_CLAIM":
+      case "LEADER_ACK":
+      case "LEADER_HEARTBEAT":
+      case "LEADER_RESIGN":
+        election?.handleMessage(message);
+        if (election) {
+          registry.setLeader(election.getLeaderId());
+        }
+        break;
+      case "RPC_REQUEST":
+      case "RPC_RESPONSE":
+        rpc.handleMessage(message);
+        break;
+    }
+  });
+  registry.announce();
+  stateManager.requestSync();
+  election?.start();
+  let ready = true;
+  let destroyed = false;
+  function middlewareSet(key, value) {
+    if (middlewares.length === 0) {
+      stateManager.set(key, value);
+      if (persister) persister.save(stateManager.getAll());
+      return;
+    }
+    const meta = { sourceTabId: tabId, isLocal: true, timestamp: Date.now() };
+    const { value: finalValue, rejected } = runMiddleware(middlewares, {
+      key,
+      value,
+      previousValue: stateManager.get(key),
+      meta
+    });
+    if (rejected) {
+      log("\u{1F6AB}", `Middleware rejected set("${String(key)}")`);
+      return;
+    }
+    stateManager.set(key, finalValue);
+    notifyMiddleware(middlewares, key, finalValue, meta);
+    if (persister) persister.save(stateManager.getAll());
+  }
+  function middlewarePatch(partial) {
+    if (middlewares.length === 0) {
+      stateManager.patch(partial);
+      if (persister) persister.save(stateManager.getAll());
+      return;
+    }
+    const meta = { sourceTabId: tabId, isLocal: true, timestamp: Date.now() };
+    const filtered = {};
+    const appliedKeys = [];
+    for (const [key, value] of Object.entries(partial)) {
+      const k = key;
+      const { value: finalValue, rejected } = runMiddleware(middlewares, {
+        key: k,
+        value,
+        previousValue: stateManager.get(k),
+        meta
+      });
+      if (!rejected) {
+        filtered[key] = finalValue;
+        appliedKeys.push(k);
+      }
+    }
+    if (Object.keys(filtered).length > 0) {
+      stateManager.patch(filtered);
+      for (const k of appliedKeys) {
+        notifyMiddleware(middlewares, k, stateManager.get(k), meta);
+      }
+      if (persister) persister.save(stateManager.getAll());
+    }
+  }
+  const instance = {
+    // State
+    get: (key) => stateManager.get(key),
+    getAll: () => stateManager.getAll(),
+    set: middlewareSet,
+    patch: middlewarePatch,
+    // Subscriptions
+    on: (key, callback) => stateManager.on(key, callback),
+    once: (key, callback) => {
+      const unsub = stateManager.on(key, ((value, meta) => {
+        unsub();
+        callback(value, meta);
+      }));
+      return unsub;
+    },
+    onChange: (callback) => stateManager.onChange(callback),
+    select: (selector, callback, isEqual = Object.is) => {
+      let prev = selector(stateManager.getAll());
+      return stateManager.onChange((state, _keys, meta) => {
+        const next = selector(state);
+        if (!isEqual(prev, next)) {
+          prev = next;
+          callback(next, meta);
+        }
+      });
+    },
+    // Leader
+    isLeader: () => election?.isLeader() ?? true,
+    onLeader: (callback) => {
+      if (!election) {
+        const cleanup = callback();
+        return () => {
+          if (typeof cleanup === "function") cleanup();
+        };
+      }
+      return election.onLeader(callback);
+    },
+    getLeader: () => {
+      const leaderId = election?.getLeaderId();
+      if (!leaderId) return null;
+      return registry.getTab(leaderId) ?? null;
+    },
+    waitForLeader: () => {
+      const leader = instance.getLeader();
+      if (leader) return Promise.resolve(leader);
+      return new Promise((resolve) => {
+        const unsubs = [];
+        const check = () => {
+          const l = instance.getLeader();
+          if (l) {
+            for (const u of unsubs) u();
+            resolve(l);
+          }
+        };
+        unsubs.push(registry.onTabChange(check));
+        if (election) {
+          unsubs.push(election.onLeader(() => {
+            check();
+            return () => {
+            };
+          }));
+        }
+      });
+    },
+    // Tabs
+    id: tabId,
+    getTabs: () => registry.getTabs(),
+    getTabCount: () => registry.getTabCount(),
+    onTabChange: (callback) => registry.onTabChange(callback),
+    // RPC
+    call: ((target, method, args, timeout) => rpc.call(target, method, args, timeout)),
+    handle: ((method, handler) => rpc.handle(method, handler)),
+    // Lifecycle
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      ready = false;
+      stateManager.flush();
+      persister?.destroy();
+      destroyMiddleware(middlewares);
+      election?.destroy();
+      registry.destroy();
+      rpc.destroy();
+      stateManager.destroy();
+      unsubChannel();
+      channel.close();
+      log("\u{1F480}", "Instance destroyed");
+    },
+    get ready() {
+      return ready;
+    }
+  };
+  log("\u{1F680}", "Instance created", { channel: channelName, leader: leaderEnabled });
+  return instance;
+}
+
+exports.BroadcastChannelTransport = BroadcastChannelTransport;
+exports.ErrorCode = ErrorCode;
+exports.LeaderElection = LeaderElection;
+exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+exports.RPCHandler = RPCHandler;
+exports.StateManager = StateManager;
+exports.StorageChannel = StorageChannel;
+exports.TabRegistry = TabRegistry;
+exports.TabSyncError = TabSyncError;
+exports.createBatcher = createBatcher;
+exports.createChannel = createChannel;
+exports.createTabSync = createTabSync;
+exports.destroyMiddleware = destroyMiddleware;
+exports.generateTabId = generateTabId;
+exports.hasBroadcastChannel = hasBroadcastChannel;
+exports.hasCrypto = hasCrypto;
+exports.hasDocument = hasDocument;
+exports.hasLocalStorage = hasLocalStorage;
+exports.isBrowser = isBrowser;
+exports.monotonic = monotonic;
+exports.notifyMiddleware = notifyMiddleware;
+exports.runMiddleware = runMiddleware;