@gwakko/shared-websocket 0.1.0

package/dist/chunk-SMH3X34N.cjs

@@ -0,0 +1,737 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;// src/utils/disposable.ts
+if (typeof Symbol.dispose === "undefined") {
+  Symbol.dispose = /* @__PURE__ */ Symbol("Symbol.dispose");
+}
+
+// src/utils/id.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+
+// src/MessageBus.ts
+var MessageBus = (_class = class {
+  constructor(channelName, tabId) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.tabId = tabId;
+    this.channel = new BroadcastChannel(channelName);
+    this.channel.onmessage = (ev) => {
+      this.handleMessage(ev.data);
+    };
+  }
+  
+  
+  __init() {this.listeners = /* @__PURE__ */ new Map()}
+  __init2() {this.pendingRequests = /* @__PURE__ */ new Map()}
+  subscribe(topic, fn) {
+    const wrapper = (msg) => {
+      if (msg.source !== this.tabId) fn(msg.data);
+    };
+    this.addListener(topic, wrapper);
+    return () => this.removeListener(topic, wrapper);
+  }
+  publish(topic, data) {
+    this.postMessage({ topic, type: "publish", data });
+  }
+  broadcast(topic, data) {
+    const msg = this.createMessage(topic, "broadcast", data);
+    this.channel.postMessage(msg);
+    this.handleMessage(msg);
+  }
+  async request(topic, data, timeout = 5e3) {
+    const msg = this.createMessage(topic, "request", data);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(msg.id);
+        reject(new Error(`MessageBus.request: timeout for topic "${topic}"`));
+      }, timeout);
+      this.pendingRequests.set(msg.id, { resolve, reject, timer });
+      this.channel.postMessage(msg);
+    });
+  }
+  respond(topic, fn) {
+    const wrapper = async (msg) => {
+      if (msg.type !== "request" || msg.source === this.tabId) return;
+      const result = await fn(msg.data);
+      this.postMessage({ topic, type: "response", data: { requestId: msg.id, result } });
+    };
+    this.addListener(topic, wrapper);
+    return () => this.removeListener(topic, wrapper);
+  }
+  handleMessage(msg) {
+    if (msg.type === "response") {
+      const payload = msg.data;
+      const pending = this.pendingRequests.get(payload.requestId);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(payload.requestId);
+        pending.resolve(payload.result);
+        return;
+      }
+    }
+    const listeners = this.listeners.get(msg.topic);
+    if (listeners) {
+      for (const fn of listeners) fn(msg);
+    }
+  }
+  postMessage(partial) {
+    this.channel.postMessage(this.createMessage(partial.topic, partial.type, partial.data));
+  }
+  createMessage(topic, type, data) {
+    return { id: generateId(), source: this.tabId, topic, type, data, timestamp: Date.now() };
+  }
+  addListener(topic, fn) {
+    let set = this.listeners.get(topic);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(topic, set);
+    }
+    set.add(fn);
+  }
+  removeListener(topic, fn) {
+    _optionalChain([this, 'access', _ => _.listeners, 'access', _2 => _2.get, 'call', _3 => _3(topic), 'optionalAccess', _4 => _4.delete, 'call', _5 => _5(fn)]);
+  }
+  [Symbol.dispose]() {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("MessageBus disposed"));
+    }
+    this.pendingRequests.clear();
+    this.listeners.clear();
+    this.channel.close();
+  }
+}, _class);
+
+// src/TabCoordinator.ts
+var TabCoordinator = (_class2 = class {
+  constructor(bus, tabId, options = {}) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+    this.bus = bus;
+    this.tabId = tabId;
+    this.electionTimeout = _nullishCoalesce(options.electionTimeout, () => ( 200));
+    this.heartbeatInterval = _nullishCoalesce(options.heartbeatInterval, () => ( 2e3));
+    this.leaderTimeout = _nullishCoalesce(options.leaderTimeout, () => ( 5e3));
+    this.cleanups.push(
+      this.bus.subscribe("coord:election", () => {
+        if (this._isLeader) {
+          this.bus.publish("coord:reject", { tabId: this.tabId });
+        }
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("coord:heartbeat", () => {
+        this.lastHeartbeat = Date.now();
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("coord:abdicate", () => {
+        if (!this._isLeader && !this.disposed) {
+          this.elect();
+        }
+      })
+    );
+  }
+  
+  
+  __init3() {this._isLeader = false}
+  __init4() {this.heartbeatTimer = null}
+  __init5() {this.leaderCheckTimer = null}
+  __init6() {this.lastHeartbeat = 0}
+  __init7() {this.disposed = false}
+  __init8() {this.onBecomeLeaderFns = /* @__PURE__ */ new Set()}
+  __init9() {this.onLoseLeadershipFns = /* @__PURE__ */ new Set()}
+  __init10() {this.cleanups = []}
+  
+  
+  
+  get isLeader() {
+    return this._isLeader;
+  }
+  async elect() {
+    if (this.disposed) return;
+    return new Promise((resolve) => {
+      let rejected = false;
+      const unsub = this.bus.subscribe("coord:reject", () => {
+        rejected = true;
+        unsub();
+        this.startLeaderCheck();
+        resolve();
+      });
+      this.bus.publish("coord:election", { tabId: this.tabId });
+      setTimeout(() => {
+        unsub();
+        if (!rejected && !this.disposed) {
+          this.becomeLeader();
+        }
+        resolve();
+      }, this.electionTimeout);
+    });
+  }
+  abdicate() {
+    if (!this._isLeader) return;
+    this._isLeader = false;
+    this.stopHeartbeat();
+    this.bus.publish("coord:abdicate", { tabId: this.tabId });
+    for (const fn of this.onLoseLeadershipFns) fn();
+  }
+  onBecomeLeader(fn) {
+    this.onBecomeLeaderFns.add(fn);
+    return () => this.onBecomeLeaderFns.delete(fn);
+  }
+  onLoseLeadership(fn) {
+    this.onLoseLeadershipFns.add(fn);
+    return () => this.onLoseLeadershipFns.delete(fn);
+  }
+  becomeLeader() {
+    this._isLeader = true;
+    this.stopLeaderCheck();
+    this.startHeartbeat();
+    for (const fn of this.onBecomeLeaderFns) fn();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.bus.publish("coord:heartbeat", { tabId: this.tabId });
+    }, this.heartbeatInterval);
+    this.bus.publish("coord:heartbeat", { tabId: this.tabId });
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  startLeaderCheck() {
+    this.stopLeaderCheck();
+    this.lastHeartbeat = Date.now();
+    this.leaderCheckTimer = setInterval(() => {
+      if (Date.now() - this.lastHeartbeat > this.leaderTimeout && !this.disposed) {
+        this.stopLeaderCheck();
+        this.elect();
+      }
+    }, 1e3);
+  }
+  stopLeaderCheck() {
+    if (this.leaderCheckTimer) {
+      clearInterval(this.leaderCheckTimer);
+      this.leaderCheckTimer = null;
+    }
+  }
+  [Symbol.dispose]() {
+    this.disposed = true;
+    if (this._isLeader) {
+      this.abdicate();
+    }
+    this.stopHeartbeat();
+    this.stopLeaderCheck();
+    for (const unsub of this.cleanups) unsub();
+    this.cleanups = [];
+    this.onBecomeLeaderFns.clear();
+    this.onLoseLeadershipFns.clear();
+  }
+}, _class2);
+
+// src/utils/backoff.ts
+function* backoff(base = 1e3, max = 3e4) {
+  let delay = base;
+  while (true) {
+    const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+    yield Math.min(delay + jitter, max);
+    delay = Math.min(delay * 2, max);
+  }
+}
+
+// src/SharedSocket.ts
+var SharedSocket = (_class3 = class {
+  constructor(url, options = {}) {;_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);
+    this.url = url;
+    this.opts = {
+      protocols: _nullishCoalesce(options.protocols, () => ( [])),
+      reconnect: _nullishCoalesce(options.reconnect, () => ( true)),
+      reconnectMaxDelay: _nullishCoalesce(options.reconnectMaxDelay, () => ( 3e4)),
+      heartbeatInterval: _nullishCoalesce(options.heartbeatInterval, () => ( 3e4)),
+      sendBuffer: _nullishCoalesce(options.sendBuffer, () => ( 100)),
+      auth: options.auth
+    };
+  }
+  
+  __init11() {this.ws = null}
+  __init12() {this._state = "closed"}
+  __init13() {this.buffer = []}
+  __init14() {this.disposed = false}
+  __init15() {this.heartbeatTimer = null}
+  __init16() {this.reconnectTimer = null}
+  __init17() {this.onMessageFns = /* @__PURE__ */ new Set()}
+  __init18() {this.onStateChangeFns = /* @__PURE__ */ new Set()}
+  
+  get state() {
+    return this._state;
+  }
+  async connect() {
+    if (this.disposed) return;
+    this.setState("connecting");
+    let connectUrl = this.url;
+    if (this.opts.auth) {
+      const token = await this.opts.auth();
+      const sep = connectUrl.includes("?") ? "&" : "?";
+      connectUrl = `${connectUrl}${sep}token=${encodeURIComponent(token)}`;
+    }
+    this.ws = new WebSocket(connectUrl, this.opts.protocols);
+    this.ws.onopen = () => {
+      this.setState("connected");
+      this.flushBuffer();
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (ev) => {
+      let data;
+      try {
+        data = JSON.parse(ev.data);
+      } catch (e) {
+        data = ev.data;
+      }
+      for (const fn of this.onMessageFns) fn(data);
+    };
+    this.ws.onclose = () => {
+      this.stopHeartbeat();
+      if (!this.disposed && this.opts.reconnect) {
+        this.reconnect();
+      } else {
+        this.setState("closed");
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  disconnect() {
+    this.disposed = true;
+    this.stopHeartbeat();
+    this.clearReconnect();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onmessage = null;
+      this.ws.onerror = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close(1e3, "client disconnect");
+      }
+      this.ws = null;
+    }
+    this.setState("closed");
+  }
+  send(data) {
+    if (this._state === "connected" && _optionalChain([this, 'access', _6 => _6.ws, 'optionalAccess', _7 => _7.readyState]) === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    } else if (this._state === "reconnecting" || this._state === "connecting") {
+      if (this.buffer.length < this.opts.sendBuffer) {
+        this.buffer.push(data);
+      }
+    }
+  }
+  onMessage(fn) {
+    this.onMessageFns.add(fn);
+    return () => this.onMessageFns.delete(fn);
+  }
+  onStateChange(fn) {
+    this.onStateChangeFns.add(fn);
+    return () => this.onStateChangeFns.delete(fn);
+  }
+  reconnect() {
+    this.setState("reconnecting");
+    const gen = backoff(1e3, this.opts.reconnectMaxDelay);
+    const attempt = () => {
+      if (this.disposed) return;
+      const delay = gen.next().value;
+      this.reconnectTimer = setTimeout(() => {
+        if (!this.disposed) this.connect();
+      }, delay);
+    };
+    attempt();
+  }
+  flushBuffer() {
+    const pending = this.buffer.splice(0);
+    for (const item of pending) {
+      this.send(item);
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (_optionalChain([this, 'access', _8 => _8.ws, 'optionalAccess', _9 => _9.readyState]) === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, this.opts.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  clearReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  setState(state) {
+    this._state = state;
+    for (const fn of this.onStateChangeFns) fn(state);
+  }
+  [Symbol.dispose]() {
+    this.disconnect();
+    this.onMessageFns.clear();
+    this.onStateChangeFns.clear();
+    this.buffer = [];
+  }
+}, _class3);
+
+// src/WorkerSocket.ts
+var WorkerSocket = (_class4 = class {
+  constructor(url, options = {}) {;_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);
+    this.url = url;
+    this.options = options;
+  }
+  
+  
+  __init19() {this.worker = null}
+  __init20() {this._state = "closed"}
+  __init21() {this.onMessageFns = /* @__PURE__ */ new Set()}
+  __init22() {this.onStateChangeFns = /* @__PURE__ */ new Set()}
+  get state() {
+    return this._state;
+  }
+  connect() {
+    const workerUrl = _nullishCoalesce(this.options.workerUrl, () => ( this.createWorkerBlob()));
+    this.worker = new Worker(workerUrl, { type: "module" });
+    this.worker.onmessage = (ev) => {
+      const msg = ev.data;
+      switch (msg.type) {
+        case "state":
+          this._state = msg.state;
+          for (const fn of this.onStateChangeFns) fn(msg.state);
+          break;
+        case "message":
+          for (const fn of this.onMessageFns) fn(msg.data);
+          break;
+        case "open":
+          break;
+        case "close":
+          break;
+        case "error":
+          console.error("WorkerSocket error:", msg.message);
+          break;
+      }
+    };
+    this.worker.postMessage({
+      type: "connect",
+      url: this.url,
+      protocols: _nullishCoalesce(this.options.protocols, () => ( [])),
+      reconnect: _nullishCoalesce(this.options.reconnect, () => ( true)),
+      reconnectMaxDelay: _nullishCoalesce(this.options.reconnectMaxDelay, () => ( 3e4)),
+      heartbeatInterval: _nullishCoalesce(this.options.heartbeatInterval, () => ( 3e4)),
+      bufferSize: _nullishCoalesce(this.options.sendBuffer, () => ( 100))
+    });
+  }
+  send(data) {
+    _optionalChain([this, 'access', _10 => _10.worker, 'optionalAccess', _11 => _11.postMessage, 'call', _12 => _12({ type: "send", data })]);
+  }
+  disconnect() {
+    _optionalChain([this, 'access', _13 => _13.worker, 'optionalAccess', _14 => _14.postMessage, 'call', _15 => _15({ type: "disconnect" })]);
+    setTimeout(() => {
+      _optionalChain([this, 'access', _16 => _16.worker, 'optionalAccess', _17 => _17.terminate, 'call', _18 => _18()]);
+      this.worker = null;
+    }, 100);
+    this._state = "closed";
+  }
+  onMessage(fn) {
+    this.onMessageFns.add(fn);
+    return () => this.onMessageFns.delete(fn);
+  }
+  onStateChange(fn) {
+    this.onStateChangeFns.add(fn);
+    return () => this.onStateChangeFns.delete(fn);
+  }
+  createWorkerBlob() {
+    const code = `
+      let ws = null, state = 'closed', buffer = [], disposed = false;
+      let heartbeatTimer = null, reconnectTimer = null;
+      let url = '', protocols = [], shouldReconnect = true;
+      let maxDelay = 30000, hbInterval = 30000, maxBuf = 100, delay = 1000;
+
+      function setState(s) { state = s; self.postMessage({ type: 'state', state: s }); }
+      function connect() {
+        if (disposed) return;
+        setState('connecting');
+        ws = new WebSocket(url, protocols);
+        ws.onopen = () => { setState('connected'); delay = 1000; self.postMessage({ type: 'open' }); flush(); startHB(); };
+        ws.onmessage = (e) => { let d; try { d = JSON.parse(e.data); } catch { d = e.data; } self.postMessage({ type: 'message', data: d }); };
+        ws.onclose = (e) => { stopHB(); self.postMessage({ type: 'close', code: e.code, reason: e.reason }); if (!disposed && shouldReconnect && e.code !== 1000) reconnect(); else setState('closed'); };
+        ws.onerror = () => { self.postMessage({ type: 'error', message: 'error' }); };
+      }
+      function send(d) { if (state === 'connected' && ws?.readyState === 1) ws.send(JSON.stringify(d)); else if (buffer.length < maxBuf) buffer.push(d); }
+      function flush() { const p = buffer.splice(0); p.forEach(send); }
+      function startHB() { stopHB(); heartbeatTimer = setInterval(() => { if (ws?.readyState === 1) ws.send('{"type":"ping"}'); }, hbInterval); }
+      function stopHB() { if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; } }
+      function reconnect() { setState('reconnecting'); const j = delay * 0.25 * (Math.random() * 2 - 1); reconnectTimer = setTimeout(() => { if (!disposed) connect(); }, Math.min(delay + j, maxDelay)); delay = Math.min(delay * 2, maxDelay); }
+      self.onmessage = (e) => {
+        const c = e.data;
+        if (c.type === 'connect') { url = c.url; protocols = c.protocols || []; shouldReconnect = c.reconnect ?? true; maxDelay = c.reconnectMaxDelay || 30000; hbInterval = c.heartbeatInterval || 30000; maxBuf = c.bufferSize || 100; connect(); }
+        if (c.type === 'send') send(c.data);
+        if (c.type === 'disconnect') { disposed = true; stopHB(); if (reconnectTimer) clearTimeout(reconnectTimer); if (ws) { ws.onclose = null; if (ws.readyState < 2) ws.close(1000); ws = null; } buffer = []; setState('closed'); }
+      };
+    `;
+    const blob = new Blob([code], { type: "application/javascript" });
+    return new URL(URL.createObjectURL(blob));
+  }
+  [Symbol.dispose]() {
+    this.disconnect();
+    this.onMessageFns.clear();
+    this.onStateChangeFns.clear();
+  }
+}, _class4);
+
+// src/SubscriptionManager.ts
+var SubscriptionManager = (_class5 = class {constructor() { _class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this); }
+  __init23() {this.handlers = /* @__PURE__ */ new Map()}
+  __init24() {this.lastMessages = /* @__PURE__ */ new Map()}
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => set.delete(handler);
+  }
+  once(event, handler) {
+    const wrapper = (data) => {
+      unsub();
+      handler(data);
+    };
+    const unsub = this.on(event, wrapper);
+    return unsub;
+  }
+  off(event, handler) {
+    if (handler) {
+      _optionalChain([this, 'access', _19 => _19.handlers, 'access', _20 => _20.get, 'call', _21 => _21(event), 'optionalAccess', _22 => _22.delete, 'call', _23 => _23(handler)]);
+    } else {
+      this.handlers.delete(event);
+    }
+  }
+  emit(event, data) {
+    this.lastMessages.set(event, data);
+    const set = this.handlers.get(event);
+    if (set) {
+      for (const fn of set) fn(data);
+    }
+  }
+  getLastMessage(event) {
+    return this.lastMessages.get(event);
+  }
+  async *stream(event, signal) {
+    const queue = [];
+    let resolve = null;
+    let done = false;
+    const unsub = this.on(event, (data) => {
+      queue.push(data);
+      _optionalChain([resolve, 'optionalCall', _24 => _24()]);
+    });
+    const onAbort = () => {
+      done = true;
+      _optionalChain([resolve, 'optionalCall', _25 => _25()]);
+    };
+    _optionalChain([signal, 'optionalAccess', _26 => _26.addEventListener, 'call', _27 => _27("abort", onAbort)]);
+    try {
+      while (!done) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else {
+          await new Promise((r) => {
+            resolve = r;
+          });
+          resolve = null;
+        }
+      }
+    } finally {
+      unsub();
+      _optionalChain([signal, 'optionalAccess', _28 => _28.removeEventListener, 'call', _29 => _29("abort", onAbort)]);
+    }
+  }
+  offAll() {
+    this.handlers.clear();
+    this.lastMessages.clear();
+  }
+  [Symbol.dispose]() {
+    this.offAll();
+  }
+}, _class5);
+
+// src/SharedWebSocket.ts
+var SharedWebSocket = (_class6 = class {
+  constructor(url, options = {}) {;_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);_class6.prototype.__init27.call(this);_class6.prototype.__init28.call(this);_class6.prototype.__init29.call(this);
+    this.url = url;
+    this.options = options;
+    this.tabId = generateId();
+    this.bus = new MessageBus("shared-ws", this.tabId);
+    this.coordinator = new TabCoordinator(this.bus, this.tabId, {
+      electionTimeout: options.electionTimeout,
+      heartbeatInterval: options.leaderHeartbeat,
+      leaderTimeout: options.leaderTimeout
+    });
+    this.cleanups.push(
+      this.bus.subscribe("ws:message", (msg) => {
+        this.subs.emit(msg.event, msg.data);
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("ws:send", (msg) => {
+        if (this.coordinator.isLeader && this.socket) {
+          this.socket.send({ event: msg.event, data: msg.data });
+        }
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("ws:sync", (msg) => {
+        this.syncStore.set(msg.key, msg.value);
+        this.subs.emit(`sync:${msg.key}`, msg.value);
+      })
+    );
+    this.coordinator.onBecomeLeader(() => this.onBecomeLeader());
+    this.coordinator.onLoseLeadership(() => this.onLoseLeadership());
+    if (typeof window !== "undefined") {
+      const onBeforeUnload = () => this[Symbol.dispose]();
+      window.addEventListener("beforeunload", onBeforeUnload);
+      this.cleanups.push(() => window.removeEventListener("beforeunload", onBeforeUnload));
+    }
+  }
+  
+  
+  
+  
+  __init25() {this.socket = null}
+  __init26() {this.subs = new SubscriptionManager()}
+  __init27() {this.syncStore = /* @__PURE__ */ new Map()}
+  
+  __init28() {this.cleanups = []}
+  __init29() {this.disposed = false}
+  get connected() {
+    return _optionalChain([this, 'access', _30 => _30.socket, 'optionalAccess', _31 => _31.state]) === "connected" || !this.coordinator.isLeader;
+  }
+  get tabRole() {
+    return this.coordinator.isLeader ? "leader" : "follower";
+  }
+  /** Start leader election and connect. */
+  async connect() {
+    await this.coordinator.elect();
+  }
+  /** Subscribe to server events (works in ALL tabs). */
+  on(event, handler) {
+    return this.subs.on(event, handler);
+  }
+  once(event, handler) {
+    return this.subs.once(event, handler);
+  }
+  off(event, handler) {
+    this.subs.off(event, handler);
+  }
+  /** Async generator for consuming events. */
+  stream(event, signal) {
+    return this.subs.stream(event, signal);
+  }
+  /** Send message to server (auto-routed through leader). */
+  send(event, data) {
+    if (this.coordinator.isLeader && this.socket) {
+      this.socket.send({ event, data });
+    } else {
+      this.bus.publish("ws:send", { event, data });
+    }
+  }
+  /** Request/response through server via leader. */
+  async request(event, data, timeout = 5e3) {
+    return this.bus.request("ws:request", { event, data }, timeout);
+  }
+  /** Sync state across tabs (no server roundtrip). */
+  sync(key, value) {
+    this.syncStore.set(key, value);
+    this.bus.broadcast("ws:sync", { key, value });
+  }
+  getSync(key) {
+    return this.syncStore.get(key);
+  }
+  onSync(key, fn) {
+    return this.subs.on(`sync:${key}`, fn);
+  }
+  disconnect() {
+    this[Symbol.dispose]();
+  }
+  createSocket() {
+    const socketOptions = {
+      protocols: this.options.protocols,
+      reconnect: this.options.reconnect,
+      reconnectMaxDelay: this.options.reconnectMaxDelay,
+      heartbeatInterval: this.options.heartbeatInterval,
+      sendBuffer: this.options.sendBuffer
+    };
+    if (this.options.useWorker) {
+      return new WorkerSocket(this.url, {
+        ...socketOptions,
+        workerUrl: this.options.workerUrl
+      });
+    }
+    return new SharedSocket(this.url, {
+      ...socketOptions,
+      auth: this.options.auth
+    });
+  }
+  onBecomeLeader() {
+    this.socket = this.createSocket();
+    this.socket.onMessage((data) => {
+      const event = _nullishCoalesce(_optionalChain([data, 'optionalAccess', _32 => _32.event]), () => ( "message"));
+      const payload = _nullishCoalesce(_optionalChain([data, 'optionalAccess', _33 => _33.data]), () => ( data));
+      this.bus.broadcast("ws:message", { event, data: payload });
+    });
+    this.cleanups.push(
+      this.bus.respond("ws:request", async (req) => {
+        return new Promise((resolve) => {
+          const unsub = this.socket.onMessage((response) => {
+            if (_optionalChain([response, 'optionalAccess', _34 => _34.event]) === req.event || _optionalChain([response, 'optionalAccess', _35 => _35.requestId])) {
+              unsub();
+              resolve(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _36 => _36.data]), () => ( response)));
+            }
+          });
+          this.socket.send({ event: req.event, data: req.data });
+        });
+      })
+    );
+    this.socket.connect();
+  }
+  onLoseLeadership() {
+    if (this.socket) {
+      this.socket[Symbol.dispose]();
+      this.socket = null;
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.coordinator[Symbol.dispose]();
+    if (this.socket) {
+      this.socket[Symbol.dispose]();
+      this.socket = null;
+    }
+    for (const unsub of this.cleanups) unsub();
+    this.cleanups = [];
+    this.subs[Symbol.dispose]();
+    this.bus[Symbol.dispose]();
+    this.syncStore.clear();
+  }
+}, _class6);
+
+
+
+
+
+
+
+
+exports.MessageBus = MessageBus; exports.TabCoordinator = TabCoordinator; exports.SharedSocket = SharedSocket; exports.WorkerSocket = WorkerSocket; exports.SubscriptionManager = SubscriptionManager; exports.SharedWebSocket = SharedWebSocket;
+//# sourceMappingURL=chunk-SMH3X34N.cjs.map