@use-everywhere/core 0.3.0 → 0.4.1

package/dist/index.cjs

@@ -0,0 +1,973 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BroadcastChannelTransport: () => BroadcastChannelTransport,
+  CID_PARAM: () => CID_PARAM,
+  DEFAULT_NAME: () => DEFAULT_NAME,
+  HandshakeTimeoutError: () => HandshakeTimeoutError,
+  MemoryHub: () => MemoryHub,
+  MemoryTransport: () => MemoryTransport,
+  NoopTransport: () => NoopTransport,
+  WindowClosedError: () => WindowClosedError,
+  connectToOpener: () => connectToOpener,
+  createChannel: () => createChannel,
+  createLeader: () => createLeader,
+  createPresence: () => createPresence,
+  createSharedStore: () => createSharedStore,
+  defaultTransport: () => defaultTransport,
+  enableDebug: () => enableDebug,
+  getBusNames: () => getBusNames,
+  isBroadcastChannelAvailable: () => isBroadcastChannelAvailable,
+  localStorageAdapter: () => localStorageAdapter,
+  newer: () => newer,
+  observeBus: () => observeBus,
+  openWindow: () => openWindow,
+  sessionStorageAdapter: () => sessionStorageAdapter,
+  webStorageAdapter: () => webStorageAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/defaults.ts
+var DEFAULT_NAME = "use-everywhere";
+
+// src/debug.ts
+var observers = /* @__PURE__ */ new Map();
+function emitBusEvent(name, direction, wire) {
+  const set = observers.get(name);
+  if (!set) return;
+  const event = { name, direction, wire };
+  for (const fn of set) fn(event);
+}
+function observeBus(name, fn) {
+  let set = observers.get(name);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    observers.set(name, set);
+  }
+  set.add(fn);
+  return () => {
+    const current = observers.get(name);
+    if (!current) return;
+    current.delete(fn);
+    if (current.size === 0) observers.delete(name);
+  };
+}
+function enableDebug(options = {}) {
+  const name = options.name ?? DEFAULT_NAME;
+  const log = options.log ?? ((...args) => console.log(...args));
+  return observeBus(name, ({ direction, wire }) => {
+    const arrow = direction === "out" ? "\u2192" : "\u2190";
+    log(`[use-everywhere:${name}] ${arrow} ${wire.scope}/${wire.type}`, wire);
+  });
+}
+
+// src/ids.ts
+function newClientId() {
+  return Math.random().toString(36).slice(2, 8);
+}
+function newMsgId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+// src/transport/broadcast-channel-transport.ts
+var BroadcastChannelTransport = class {
+  constructor(name) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.bc = new BroadcastChannel(name);
+    this.bc.onmessage = (event) => {
+      for (const listener of this.listeners) listener(event.data);
+    };
+  }
+  post(data) {
+    this.bc.postMessage(data);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  close() {
+    this.listeners.clear();
+    this.bc.close();
+  }
+};
+
+// src/transport/noop-transport.ts
+var NoopTransport = class {
+  post() {
+  }
+  subscribe() {
+    return () => {
+    };
+  }
+  close() {
+  }
+};
+
+// src/transport/default-transport.ts
+function isBroadcastChannelAvailable() {
+  return typeof BroadcastChannel !== "undefined";
+}
+function defaultTransport(name) {
+  return isBroadcastChannelAvailable() ? new BroadcastChannelTransport(name) : new NoopTransport();
+}
+
+// src/bus.ts
+function isBusWire(data) {
+  return typeof data === "object" && data !== null && data.v === 1;
+}
+function defaultKind() {
+  return typeof document === "undefined" ? "worker" : "tab";
+}
+var registry = /* @__PURE__ */ new Map();
+function createBus(name, options, onShutdown) {
+  const transport = (options.transport ?? defaultTransport)(name);
+  const clientId = newClientId();
+  const kind = options.kind ?? defaultKind();
+  const listeners = /* @__PURE__ */ new Set();
+  let refs = 0;
+  let closed = false;
+  const post = (wire) => {
+    if (closed) return;
+    emitBusEvent(name, "out", wire);
+    transport.post(wire);
+  };
+  const unsubscribe = transport.subscribe((data) => {
+    if (!isBusWire(data)) return;
+    if (data.clientId === clientId) return;
+    emitBusEvent(name, "in", data);
+    if (data.scope === "presence" && data.type === "hello") {
+      post({ v: 1, scope: "presence", type: "ping", clientId, kind });
+    }
+    for (const fn of listeners) fn(data);
+  });
+  post({ v: 1, scope: "presence", type: "hello", clientId, kind });
+  const heartbeat = setInterval(
+    () => post({ v: 1, scope: "presence", type: "ping", clientId, kind }),
+    options.heartbeatMs ?? 2e3
+  );
+  const sayBye = () => post({ v: 1, scope: "presence", type: "bye", clientId, kind });
+  const hasWindow = typeof document !== "undefined" && typeof addEventListener === "function";
+  if (hasWindow) addEventListener("pagehide", sayBye);
+  return {
+    name,
+    clientId,
+    kind,
+    post,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    acquire() {
+      refs++;
+    },
+    release() {
+      refs--;
+      if (refs > 0) return;
+      sayBye();
+      closed = true;
+      clearInterval(heartbeat);
+      if (hasWindow) removeEventListener("pagehide", sayBye);
+      unsubscribe();
+      transport.close();
+      listeners.clear();
+      onShutdown();
+    }
+  };
+}
+function getBusNames() {
+  return [...registry.keys()];
+}
+function getBus(name, options = {}) {
+  if (options.transport) {
+    const bus2 = createBus(name, options, () => {
+    });
+    bus2.acquire();
+    return bus2;
+  }
+  let bus = registry.get(name);
+  if (!bus) {
+    bus = createBus(name, options, () => registry.delete(name));
+    registry.set(name, bus);
+  }
+  bus.acquire();
+  return bus;
+}
+
+// src/channel.ts
+function createChannel(name, options = {}) {
+  const bus = getBus(name, options);
+  const handlers = /* @__PURE__ */ new Map();
+  const unsubscribe = bus.subscribe((wire) => {
+    if (wire.scope !== "event") return;
+    const set = handlers.get(wire.type);
+    if (!set) return;
+    const meta = { clientId: wire.clientId, kind: wire.kind, self: false };
+    for (const fn of set) fn(wire.payload, meta);
+  });
+  return {
+    name,
+    clientId: bus.clientId,
+    post(type, payload) {
+      bus.post({
+        v: 1,
+        scope: "event",
+        type,
+        payload,
+        clientId: bus.clientId,
+        kind: bus.kind,
+        msgId: newMsgId()
+      });
+    },
+    on(type, handler) {
+      let set = handlers.get(type);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(type, set);
+      }
+      set.add(handler);
+      return () => set.delete(handler);
+    },
+    close() {
+      unsubscribe();
+      handlers.clear();
+      bus.release();
+    }
+  };
+}
+
+// src/clock.ts
+function newer(a, b) {
+  return !b || a[0] > b[0] || a[0] === b[0] && a[1] > b[1];
+}
+
+// src/dev-freeze.ts
+var inDev = false;
+try {
+  inDev = process.env.NODE_ENV !== "production";
+} catch {
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    deepFreeze(value[key]);
+  }
+}
+function freezeShared(value) {
+  if (inDev) deepFreeze(value);
+  return value;
+}
+
+// src/shared-store.ts
+function createSharedStore(name, initial, options = {}) {
+  const bus = getBus(name, options);
+  const clientId = bus.clientId;
+  const accept = options.accept;
+  const state = { ...initial };
+  const versions = {};
+  for (const k in state) {
+    versions[k] = [0, clientId];
+    freezeShared(state[k]);
+  }
+  let snapshot = Object.freeze({ ...state });
+  let versionsSnapshot = Object.freeze({ ...versions });
+  const listeners = /* @__PURE__ */ new Set();
+  const keyListeners = /* @__PURE__ */ new Map();
+  function notify(key, value, meta) {
+    snapshot = Object.freeze({ ...state });
+    versionsSnapshot = Object.freeze({ ...versions });
+    for (const fn of listeners) fn(key, value, meta);
+    const set = keyListeners.get(key);
+    if (set) for (const fn of set) fn();
+  }
+  function applyRemote(key, value, version, meta) {
+    if (!newer(version, versions[key])) return;
+    versions[key] = version;
+    state[key] = freezeShared(value);
+    notify(key, value, meta);
+  }
+  const unsubscribe = bus.subscribe((wire) => {
+    if (wire.scope !== "state") return;
+    const meta = { clientId: wire.clientId, kind: wire.kind, self: false };
+    if (wire.type === "hello") {
+      bus.post({
+        v: 1,
+        scope: "state",
+        type: "snapshot",
+        clientId,
+        kind: bus.kind,
+        state: { ...state },
+        versions: { ...versions }
+      });
+      return;
+    }
+    if (accept && !accept(meta)) return;
+    if (wire.type === "patch") {
+      applyRemote(wire.key, wire.value, wire.version, meta);
+    } else {
+      for (const k in wire.state) {
+        const version = wire.versions[k];
+        if (version) applyRemote(k, wire.state[k], version, meta);
+      }
+    }
+  });
+  function setKey(key, value) {
+    const version = [(versions[key]?.[0] ?? 0) + 1, clientId];
+    versions[key] = version;
+    state[key] = freezeShared(value);
+    bus.post({
+      v: 1,
+      scope: "state",
+      type: "patch",
+      key,
+      value,
+      version,
+      clientId,
+      kind: bus.kind
+    });
+    notify(key, value, { clientId, kind: bus.kind, self: true });
+  }
+  const proxy = new Proxy(state, {
+    set(_target, key, value) {
+      if (typeof key !== "string") return false;
+      setKey(key, value);
+      return true;
+    }
+  });
+  const persist = options.persist;
+  let flushPersist;
+  if (persist) {
+    const { adapter, keys, debounceMs = 100 } = persist;
+    const shouldPersist = (key) => !keys || keys.includes(key);
+    const hydrate = (saved2) => {
+      if (!saved2) return;
+      for (const key in saved2.state) {
+        const version = saved2.versions[key];
+        if (!version || !shouldPersist(key)) continue;
+        applyRemote(key, saved2.state[key], version, { clientId, kind: bus.kind, self: true });
+        bus.post({
+          v: 1,
+          scope: "state",
+          type: "patch",
+          key,
+          value: saved2.state[key],
+          version,
+          clientId,
+          kind: bus.kind
+        });
+      }
+    };
+    const collect = () => {
+      const out = { v: 1, state: {}, versions: {} };
+      for (const key in versions) {
+        const version = versions[key];
+        if (!version || version[0] === 0 || !shouldPersist(key)) continue;
+        out.state[key] = state[key];
+        out.versions[key] = version;
+      }
+      return out;
+    };
+    let timer;
+    flushPersist = () => {
+      clearTimeout(timer);
+      timer = void 0;
+      void adapter.write(collect());
+    };
+    const saved = adapter.read();
+    if (saved instanceof Promise) {
+      void saved.then(hydrate);
+    } else {
+      hydrate(saved);
+    }
+    listeners.add(() => {
+      if (timer !== void 0) return;
+      timer = setTimeout(flushPersist, debounceMs);
+    });
+    if (typeof document !== "undefined" && typeof addEventListener === "function") {
+      addEventListener("pagehide", flushPersist);
+    }
+  }
+  bus.post({ v: 1, scope: "state", type: "hello", clientId, kind: bus.kind });
+  return {
+    clientId,
+    state: proxy,
+    getSnapshot: () => snapshot,
+    getVersions: () => versionsSnapshot,
+    set(key, value) {
+      const next = typeof value === "function" ? value(state[key]) : value;
+      setKey(key, next);
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    subscribeKey(key, fn) {
+      let set = keyListeners.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        keyListeners.set(key, set);
+      }
+      set.add(fn);
+      return () => set.delete(fn);
+    },
+    registerKey(key, initialValue) {
+      if (key in versions) return;
+      versions[key] = [0, clientId];
+      state[key] = initialValue;
+      snapshot = Object.freeze({ ...state });
+      versionsSnapshot = Object.freeze({ ...versions });
+    },
+    close() {
+      if (flushPersist) {
+        flushPersist();
+        if (typeof document !== "undefined" && typeof removeEventListener === "function") {
+          removeEventListener("pagehide", flushPersist);
+        }
+      }
+      unsubscribe();
+      listeners.clear();
+      keyListeners.clear();
+      bus.release();
+    }
+  };
+}
+
+// src/presence.ts
+function createPresence(name, options = {}) {
+  const pruneAfterMs = options.pruneAfterMs ?? 5e3;
+  const bus = getBus(name, options);
+  const peers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = [];
+  function notify() {
+    snapshot = Object.freeze([...peers.values()]);
+    for (const fn of listeners) fn();
+  }
+  const unsubscribe = bus.subscribe((wire) => {
+    if (wire.scope === "presence" && wire.type === "bye") {
+      if (peers.delete(wire.clientId)) notify();
+      return;
+    }
+    const existing = peers.get(wire.clientId);
+    peers.set(wire.clientId, { id: wire.clientId, kind: wire.kind, lastSeen: Date.now() });
+    if (!existing) notify();
+  });
+  const prune = setInterval(
+    () => {
+      const cutoff = Date.now() - pruneAfterMs;
+      let changed = false;
+      for (const [id, peer] of peers) {
+        if (peer.lastSeen < cutoff) {
+          peers.delete(id);
+          changed = true;
+        }
+      }
+      if (changed) notify();
+    },
+    Math.max(500, Math.floor(pruneAfterMs / 2))
+  );
+  return {
+    clientId: bus.clientId,
+    getPeers: () => snapshot,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    close() {
+      clearInterval(prune);
+      unsubscribe();
+      listeners.clear();
+      bus.release();
+    }
+  };
+}
+
+// src/leader.ts
+var NO_LEADER = Object.freeze({ leaderId: null, isLeader: false });
+function createLeader(name, options = {}) {
+  const heartbeatMs = options.heartbeatMs ?? 1e3;
+  const leaseMs = options.leaseMs ?? 3e3;
+  const busOptions = {
+    ...options.transport ? { transport: options.transport } : {},
+    ...options.kind ? { kind: options.kind } : {}
+  };
+  const bus = getBus(name, busOptions);
+  const clientId = bus.clientId;
+  let eligible = options.eligible ?? true;
+  let leaderId = null;
+  let term = [0, clientId];
+  let snapshot = NO_LEADER;
+  let beat;
+  let lease;
+  let closed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  function setLeader(id) {
+    if (id === leaderId) return;
+    leaderId = id;
+    snapshot = Object.freeze({ leaderId: id, isLeader: id === clientId });
+    for (const fn of listeners) fn();
+  }
+  function armLease(delay) {
+    clearTimeout(lease);
+    lease = setTimeout(onLeaseExpired, delay);
+  }
+  function onLeaseExpired() {
+    if (closed) return;
+    setLeader(null);
+    if (eligible) claim();
+  }
+  function heartbeat() {
+    bus.post({ v: 1, scope: "leader", type: "heartbeat", term, clientId, kind: bus.kind });
+  }
+  function claim() {
+    term = [term[0] + 1, clientId];
+    setLeader(clientId);
+    bus.post({ v: 1, scope: "leader", type: "claim", term, clientId, kind: bus.kind });
+    clearInterval(beat);
+    beat = setInterval(heartbeat, heartbeatMs);
+  }
+  function stepDown(next) {
+    clearInterval(beat);
+    beat = void 0;
+    setLeader(next);
+  }
+  const unsubscribe = bus.subscribe((wire) => {
+    if (wire.scope !== "leader") return;
+    if (wire.type === "hello") {
+      if (leaderId === clientId) heartbeat();
+      return;
+    }
+    if (wire.type === "resign") {
+      if (wire.clientId !== leaderId) return;
+      setLeader(null);
+      armLease(0);
+      return;
+    }
+    if (newer(wire.term, term)) {
+      term = wire.term;
+      stepDown(wire.clientId);
+      armLease(leaseMs);
+      return;
+    }
+    if (leaderId === clientId) {
+      heartbeat();
+      return;
+    }
+    if (wire.clientId === leaderId) armLease(leaseMs);
+  });
+  function resign() {
+    if (leaderId !== clientId) return;
+    const resigning = term;
+    stepDown(null);
+    bus.post({ v: 1, scope: "leader", type: "resign", term: resigning, clientId, kind: bus.kind });
+    armLease(leaseMs);
+  }
+  const hasWindow = typeof document !== "undefined" && typeof addEventListener === "function";
+  const onPageHide = () => resign();
+  if (hasWindow) addEventListener("pagehide", onPageHide);
+  bus.post({ v: 1, scope: "leader", type: "hello", clientId, kind: bus.kind });
+  armLease(heartbeatMs);
+  return {
+    clientId,
+    getSnapshot: () => snapshot,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    resign,
+    setEligible(next) {
+      if (next === eligible) return;
+      eligible = next;
+      if (!next) {
+        if (leaderId === clientId) resign();
+        return;
+      }
+      if (leaderId === null) armLease(0);
+    },
+    close() {
+      closed = true;
+      resign();
+      clearInterval(beat);
+      clearTimeout(lease);
+      if (hasWindow) removeEventListener("pagehide", onPageHide);
+      unsubscribe();
+      listeners.clear();
+      bus.release();
+    }
+  };
+}
+
+// src/persist-web-storage.ts
+function isPersisted(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.v === 1 && typeof candidate.state === "object" && typeof candidate.versions === "object";
+}
+function webStorageAdapter(storage, key) {
+  const resolve = () => {
+    try {
+      return typeof storage === "function" ? storage() : storage;
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    read() {
+      try {
+        const raw = resolve()?.getItem(key);
+        if (!raw) return void 0;
+        const parsed = JSON.parse(raw);
+        return isPersisted(parsed) ? parsed : void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    write(snapshot) {
+      try {
+        resolve()?.setItem(key, JSON.stringify(snapshot));
+      } catch {
+      }
+    },
+    remove() {
+      try {
+        resolve()?.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+function localStorageAdapter(key) {
+  return webStorageAdapter(() => globalThis.localStorage, key);
+}
+function sessionStorageAdapter(key) {
+  return webStorageAdapter(() => globalThis.sessionStorage, key);
+}
+
+// src/errors/handshake-timeout-error.ts
+var HandshakeTimeoutError = class extends Error {
+  constructor(message = "handshake with the other window timed out") {
+    super(message);
+    this.name = "HandshakeTimeoutError";
+  }
+};
+
+// src/errors/window-closed-error.ts
+var WindowClosedError = class extends Error {
+  constructor(message = "window closed before a result was delivered") {
+    super(message);
+    this.name = "WindowClosedError";
+  }
+};
+
+// src/window-channel.ts
+var CID_PARAM = "ue-cid";
+function isWindowWire(data, cid) {
+  return typeof data === "object" && data !== null && data.__ue === 1 && data.cid === cid;
+}
+function validatePeerOrigin(peerOrigin, allowAnyOrigin) {
+  if (peerOrigin === "*" && !allowAnyOrigin) {
+    throw new Error(
+      "peerOrigin '*' is unsafe: any page could read your messages. Pass the exact origin, or set allowAnyOrigin: true (dev only)."
+    );
+  }
+}
+function markHandled(promise) {
+  promise.catch(() => {
+  });
+}
+function openWindow(url, options) {
+  const { peerOrigin, allowAnyOrigin } = options;
+  validatePeerOrigin(peerOrigin, allowAnyOrigin);
+  const base = typeof location !== "undefined" ? location.href : void 0;
+  const resolved = new URL(url, base);
+  if (!allowAnyOrigin && resolved.origin !== peerOrigin) {
+    throw new Error(`url origin ${resolved.origin} does not match peerOrigin ${peerOrigin}`);
+  }
+  const cid = newMsgId();
+  resolved.searchParams.set(CID_PARAM, cid);
+  const localWindow = options.localWindow ?? window;
+  const openFn = options.openFn ?? ((u, target, features) => window.open(u, target, features));
+  const targetOrigin = allowAnyOrigin ? "*" : peerOrigin;
+  const handlers = /* @__PURE__ */ new Map();
+  const outQueue = [];
+  let isReady = false;
+  let resultSettled = false;
+  let closedSettled = false;
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((res, rej) => (resolveReady = res, rejectReady = rej));
+  let resolveResult;
+  let rejectResult;
+  const result = new Promise((res, rej) => (resolveResult = res, rejectResult = rej));
+  let resolveClosed;
+  const closed = new Promise((res) => resolveClosed = res);
+  markHandled(ready);
+  markHandled(result);
+  const onMessage = (event) => {
+    if (!allowAnyOrigin && event.origin !== peerOrigin) return;
+    if (!isWindowWire(event.data, cid)) return;
+    if (childWindow && event.source !== childWindow) return;
+    const wire = event.data;
+    if (wire.t === "ready") {
+      childWindow?.postMessage({ __ue: 1, cid, t: "ready-ack" }, targetOrigin);
+      if (!isReady) {
+        isReady = true;
+        clearTimeout(readyTimer);
+        for (const queued of outQueue.splice(0)) childWindow?.postMessage(queued, targetOrigin);
+        resolveReady();
+      }
+    } else if (wire.t === "msg") {
+      const set = handlers.get(wire.type);
+      if (set) for (const fn of set) fn(wire.payload);
+    } else if (wire.t === "result") {
+      if (!resultSettled) {
+        resultSettled = true;
+        resolveResult(wire.payload);
+      }
+    } else if (wire.t === "close") {
+      settleClosed();
+    }
+  };
+  localWindow.addEventListener("message", onMessage);
+  function settleClosed() {
+    if (closedSettled) return;
+    closedSettled = true;
+    clearInterval(closePoller);
+    clearTimeout(readyTimer);
+    localWindow.removeEventListener("message", onMessage);
+    if (!resultSettled) {
+      resultSettled = true;
+      rejectResult(new WindowClosedError());
+    }
+    if (!isReady) rejectReady(new WindowClosedError());
+    resolveClosed();
+  }
+  const childWindow = openFn(resolved.toString(), "_blank", options.features);
+  if (!childWindow) {
+    const err = new Error("popup blocked: window.open returned null");
+    localWindow.removeEventListener("message", onMessage);
+    rejectReady(err);
+    resultSettled = true;
+    rejectResult(err);
+    return {
+      window: null,
+      ready,
+      post: () => {
+      },
+      on: () => () => {
+      },
+      result,
+      closed,
+      close: () => {
+      }
+    };
+  }
+  const closePoller = setInterval(() => {
+    if (childWindow.closed) settleClosed();
+  }, 400);
+  const readyTimer = setTimeout(() => {
+    if (isReady || closedSettled) return;
+    const err = new HandshakeTimeoutError();
+    rejectReady(err);
+    if (!resultSettled) {
+      resultSettled = true;
+      rejectResult(err);
+    }
+  }, options.readyTimeoutMs ?? 15e3);
+  return {
+    window: childWindow,
+    ready,
+    result,
+    closed,
+    post(type, payload) {
+      const wire = { __ue: 1, cid, t: "msg", type, payload, msgId: newMsgId() };
+      if (isReady) childWindow.postMessage(wire, targetOrigin);
+      else outQueue.push(wire);
+    },
+    on(type, handler) {
+      let set = handlers.get(type);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(type, set);
+      }
+      set.add(handler);
+      return () => set.delete(handler);
+    },
+    close() {
+      childWindow.close?.();
+    }
+  };
+}
+function connectToOpener(options) {
+  const { peerOrigin, allowAnyOrigin } = options;
+  validatePeerOrigin(peerOrigin, allowAnyOrigin);
+  const opener = options.opener !== void 0 ? options.opener : window.opener ?? null;
+  if (!opener) {
+    throw new Error("no window.opener \u2014 this page was not opened via openWindow()");
+  }
+  const cid = options.cid ?? (typeof location !== "undefined" ? new URLSearchParams(location.search).get(CID_PARAM) : null);
+  if (!cid) {
+    throw new Error(`missing ${CID_PARAM} parameter \u2014 this page was not opened via openWindow()`);
+  }
+  const localWindow = options.localWindow ?? window;
+  const targetOrigin = allowAnyOrigin ? "*" : peerOrigin;
+  const handlers = /* @__PURE__ */ new Map();
+  const outQueue = [];
+  let isReady = false;
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((res, rej) => (resolveReady = res, rejectReady = rej));
+  markHandled(ready);
+  const onMessage = (event) => {
+    if (!allowAnyOrigin && event.origin !== peerOrigin) return;
+    if (!isWindowWire(event.data, cid)) return;
+    const wire = event.data;
+    if (wire.t === "ready-ack") {
+      if (!isReady) {
+        isReady = true;
+        clearInterval(retryTimer);
+        clearTimeout(giveUpTimer);
+        for (const queued of outQueue.splice(0)) opener.postMessage(queued, targetOrigin);
+        resolveReady();
+      }
+    } else if (wire.t === "msg") {
+      const set = handlers.get(wire.type);
+      if (set) for (const fn of set) fn(wire.payload);
+    }
+  };
+  localWindow.addEventListener("message", onMessage);
+  const sayReady = () => opener.postMessage({ __ue: 1, cid, t: "ready" }, targetOrigin);
+  sayReady();
+  const retryTimer = setInterval(sayReady, 250);
+  const giveUpTimer = setTimeout(() => {
+    clearInterval(retryTimer);
+    localWindow.removeEventListener("message", onMessage);
+    rejectReady(new HandshakeTimeoutError());
+  }, options.readyTimeoutMs ?? 15e3);
+  const sendOrQueue = (wire) => {
+    if (isReady) opener.postMessage(wire, targetOrigin);
+    else outQueue.push(wire);
+  };
+  const sayClose = () => opener.postMessage({ __ue: 1, cid, t: "close" }, targetOrigin);
+  localWindow.addEventListener("pagehide", sayClose);
+  return {
+    ready,
+    post(type, payload) {
+      sendOrQueue({ __ue: 1, cid, t: "msg", type, payload, msgId: newMsgId() });
+    },
+    on(type, handler) {
+      let set = handlers.get(type);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(type, set);
+      }
+      set.add(handler);
+      return () => set.delete(handler);
+    },
+    finish(value) {
+      sendOrQueue({ __ue: 1, cid, t: "result", payload: value });
+    },
+    close() {
+      sayClose();
+      localWindow.removeEventListener("message", onMessage);
+      localWindow.removeEventListener("pagehide", sayClose);
+      if (typeof window !== "undefined" && options.localWindow === void 0) window.close();
+    }
+  };
+}
+
+// src/transport/memory-transport.ts
+var MemoryTransport = class {
+  constructor(hub) {
+    this.hub = hub;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.closed = false;
+  }
+  post(data) {
+    if (this.closed) return;
+    this.hub.broadcast(this, data);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  close() {
+    this.closed = true;
+    this.listeners.clear();
+    this.hub.disconnect(this);
+  }
+  /** @internal */
+  deliver(data) {
+    if (this.closed) return;
+    for (const listener of this.listeners) listener(data);
+  }
+};
+
+// src/transport/memory-hub.ts
+var MemoryHub = class {
+  constructor() {
+    this.transports = /* @__PURE__ */ new Set();
+  }
+  connect() {
+    const transport = new MemoryTransport(this);
+    this.transports.add(transport);
+    return transport;
+  }
+  /** @internal */
+  broadcast(from, data) {
+    for (const transport of this.transports) {
+      if (transport !== from) {
+        queueMicrotask(() => transport.deliver(data));
+      }
+    }
+  }
+  /** @internal */
+  disconnect(transport) {
+    this.transports.delete(transport);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BroadcastChannelTransport,
+  CID_PARAM,
+  DEFAULT_NAME,
+  HandshakeTimeoutError,
+  MemoryHub,
+  MemoryTransport,
+  NoopTransport,
+  WindowClosedError,
+  connectToOpener,
+  createChannel,
+  createLeader,
+  createPresence,
+  createSharedStore,
+  defaultTransport,
+  enableDebug,
+  getBusNames,
+  isBroadcastChannelAvailable,
+  localStorageAdapter,
+  newer,
+  observeBus,
+  openWindow,
+  sessionStorageAdapter,
+  webStorageAdapter
+});