@wow-two-beta/ui-vue 0.0.4 → 0.0.6

package/dist/foundation/channels/index.js

@@ -0,0 +1,493 @@
+import { G as Guid } from "../../chunks/Guid-CflnxKPZ.js";
+import { l as localStorageStorageBroker } from "../../chunks/StorageBroker-COC81ZGB.js";
+import { onMounted, watch, toValue, onScopeDispose, shallowRef, computed } from "vue";
+const DefaultKeyPrefix = "wow-two.sync";
+function isEnvelope(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.sender === "string" && typeof candidate.seq === "number" && typeof candidate.timestamp === "number" && "message" in candidate;
+}
+function readEventKey(event) {
+  const candidate = event.key;
+  return typeof candidate === "string" ? candidate : null;
+}
+function resolveWindow() {
+  if (typeof window === "undefined") return null;
+  try {
+    return typeof window.addEventListener === "function" ? window : null;
+  } catch {
+    return null;
+  }
+}
+function bindBroadcast(name, onEnvelope) {
+  if (typeof BroadcastChannel === "undefined") return null;
+  let channel;
+  try {
+    channel = new BroadcastChannel(name);
+  } catch {
+    return null;
+  }
+  const onMessage = (event) => onEnvelope(event.data);
+  channel.addEventListener("message", onMessage);
+  return {
+    kind: "broadcast",
+    send(envelope) {
+      try {
+        channel.postMessage(envelope);
+      } catch {
+      }
+    },
+    dispose() {
+      try {
+        channel.removeEventListener("message", onMessage);
+        channel.close();
+      } catch {
+      }
+    }
+  };
+}
+function bindStorage(key, broker, onEnvelope) {
+  const view = resolveWindow();
+  if (view === null) return null;
+  const onStorage = (event) => {
+    if (readEventKey(event) !== key) return;
+    onEnvelope(broker.read(key));
+  };
+  view.addEventListener("storage", onStorage);
+  return {
+    kind: "storage",
+    send(envelope) {
+      broker.write(key, envelope);
+    },
+    dispose() {
+      view.removeEventListener("storage", onStorage);
+    }
+  };
+}
+const inertBinding = {
+  kind: "inert",
+  send() {
+  },
+  dispose() {
+  }
+};
+function bind(requested, name, key, broker, onEnvelope) {
+  if (requested === "inert") return inertBinding;
+  if (requested === "storage") return bindStorage(key, broker, onEnvelope) ?? inertBinding;
+  if (requested === "broadcast") return bindBroadcast(name, onEnvelope) ?? inertBinding;
+  return bindBroadcast(name, onEnvelope) ?? bindStorage(key, broker, onEnvelope) ?? inertBinding;
+}
+function createSyncChannel(name, options) {
+  const id = options?.id ?? Guid.createV7();
+  const now = options?.now ?? Date.now;
+  const broker = options?.broker ?? localStorageStorageBroker;
+  const key = `${options?.keyPrefix ?? DefaultKeyPrefix}.${name}`;
+  const listeners = /* @__PURE__ */ new Set();
+  let seq = 0;
+  let closed = false;
+  let lastStamp = null;
+  function deliver(raw) {
+    if (closed) return;
+    if (!isEnvelope(raw)) return;
+    if (raw.sender === id) return;
+    const stamp = `${raw.sender}:${raw.seq}`;
+    if (stamp === lastStamp) return;
+    lastStamp = stamp;
+    const envelope = raw;
+    for (const listener of [...listeners]) {
+      try {
+        listener(envelope.message, envelope);
+      } catch {
+      }
+    }
+  }
+  const binding = bind(options?.transport ?? "auto", name, key, broker, deliver);
+  return {
+    name,
+    id,
+    transport: binding.kind,
+    get closed() {
+      return closed;
+    },
+    post(message) {
+      if (closed) return;
+      const envelope = { sender: id, seq: seq++, timestamp: now(), message };
+      binding.send(envelope);
+    },
+    subscribe(listener) {
+      if (closed) return () => void 0;
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      listeners.clear();
+      binding.dispose();
+    }
+  };
+}
+function memorySyncHub() {
+  const endpoints = /* @__PURE__ */ new Set();
+  return {
+    channel(name, id) {
+      const endpointId = id ?? Guid.createV7();
+      const listeners = /* @__PURE__ */ new Set();
+      let seq = 0;
+      let closed = false;
+      function receive(envelope) {
+        if (closed) return;
+        const typed = envelope;
+        for (const listener of [...listeners]) {
+          try {
+            listener(typed.message, typed);
+          } catch {
+          }
+        }
+      }
+      const endpoint = {
+        id: endpointId,
+        name,
+        receive,
+        isClosed: () => closed
+      };
+      endpoints.add(endpoint);
+      return {
+        name,
+        id: endpointId,
+        transport: "broadcast",
+        get closed() {
+          return closed;
+        },
+        post(message) {
+          if (closed) return;
+          const envelope = {
+            sender: endpointId,
+            seq: seq++,
+            timestamp: Date.now(),
+            message
+          };
+          for (const peer of [...endpoints]) {
+            if (peer === endpoint) continue;
+            if (peer.name !== name) continue;
+            if (peer.isClosed()) continue;
+            peer.receive(envelope);
+          }
+        },
+        subscribe(listener) {
+          if (closed) return () => void 0;
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        },
+        close() {
+          if (closed) return;
+          closed = true;
+          listeners.clear();
+          endpoints.delete(endpoint);
+        }
+      };
+    },
+    get openCount() {
+      let open = 0;
+      for (const endpoint of endpoints) if (!endpoint.isClosed()) open += 1;
+      return open;
+    },
+    reset() {
+      endpoints.clear();
+    }
+  };
+}
+const ChannelPrefix$1 = "leader.";
+const DefaultHeartbeatInterval = 1e3;
+const DefaultTimeout = 3500;
+const DefaultClaimWindow = 150;
+const LeaderRole = {
+  /** Watches a live leader's heartbeat and re-elects when the lease expires. The state every tab starts in. */
+  Follower: "follower",
+  /** Has bid for the empty throne and is waiting out the claim window for a rival or a live leader. */
+  Candidate: "candidate",
+  /** Holds the lease and does the work; heartbeats until it resigns, closes, or crashes. */
+  Leader: "leader"
+};
+function createLeaderElection(name, options) {
+  const heartbeatInterval = options?.heartbeatInterval ?? DefaultHeartbeatInterval;
+  const timeout = options?.timeout ?? DefaultTimeout;
+  const claimWindow = options?.claimWindow ?? DefaultClaimWindow;
+  const ownsChannel = options?.channel === void 0;
+  const channel = options?.channel ?? createSyncChannel(`${ChannelPrefix$1}${name}`, options?.channelOptions);
+  const id = channel.id;
+  const becomeListeners = /* @__PURE__ */ new Set();
+  const loseListeners = /* @__PURE__ */ new Set();
+  let role = LeaderRole.Follower;
+  let closed = false;
+  let claimTimer;
+  let watchTimer;
+  let heartbeatTimer;
+  let lowestRival = null;
+  let leaderSeenDuringClaim = false;
+  function safeInvoke(listener) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+  function emit(listeners) {
+    for (const listener of [...listeners]) safeInvoke(listener);
+  }
+  function clearWatch() {
+    if (watchTimer !== void 0) clearTimeout(watchTimer);
+    watchTimer = void 0;
+  }
+  function clearClaim() {
+    if (claimTimer !== void 0) clearTimeout(claimTimer);
+    claimTimer = void 0;
+  }
+  function clearHeartbeat() {
+    if (heartbeatTimer !== void 0) clearInterval(heartbeatTimer);
+    heartbeatTimer = void 0;
+  }
+  function armWatch() {
+    clearWatch();
+    if (closed) return;
+    watchTimer = setTimeout(beginClaim, timeout);
+  }
+  function toFollower() {
+    role = LeaderRole.Follower;
+    armWatch();
+  }
+  function beginClaim() {
+    if (closed || role === LeaderRole.Leader) return;
+    clearWatch();
+    clearClaim();
+    role = LeaderRole.Candidate;
+    lowestRival = null;
+    leaderSeenDuringClaim = false;
+    channel.post({ kind: "claim", id });
+    claimTimer = setTimeout(resolveClaim, claimWindow);
+  }
+  function resolveClaim() {
+    claimTimer = void 0;
+    if (closed || role !== LeaderRole.Candidate) return;
+    if (leaderSeenDuringClaim) {
+      toFollower();
+      return;
+    }
+    if (lowestRival !== null && Guid.compare(lowestRival, id) < 0) {
+      toFollower();
+      return;
+    }
+    becomeLeader();
+  }
+  function becomeLeader() {
+    if (closed) return;
+    role = LeaderRole.Leader;
+    clearWatch();
+    clearClaim();
+    channel.post({ kind: "heartbeat", id });
+    heartbeatTimer = setInterval(() => channel.post({ kind: "heartbeat", id }), heartbeatInterval);
+    emit(becomeListeners);
+  }
+  function stepDown() {
+    clearHeartbeat();
+    role = LeaderRole.Follower;
+    armWatch();
+    emit(loseListeners);
+  }
+  const unsubscribe = channel.subscribe((signal) => {
+    if (closed) return;
+    if (typeof signal !== "object" || signal === null) return;
+    switch (signal.kind) {
+      case "heartbeat": {
+        if (role === LeaderRole.Leader) {
+          if (Guid.compare(signal.id, id) < 0) stepDown();
+          else channel.post({ kind: "heartbeat", id });
+          return;
+        }
+        leaderSeenDuringClaim = true;
+        if (role === LeaderRole.Candidate) {
+          clearClaim();
+          role = LeaderRole.Follower;
+        }
+        armWatch();
+        return;
+      }
+      case "claim": {
+        if (role === LeaderRole.Leader) {
+          channel.post({ kind: "heartbeat", id });
+          return;
+        }
+        if (role === LeaderRole.Candidate && (lowestRival === null || Guid.compare(signal.id, lowestRival) < 0)) {
+          lowestRival = signal.id;
+        }
+        return;
+      }
+      case "resign": {
+        if (role !== LeaderRole.Leader) beginClaim();
+        return;
+      }
+    }
+  });
+  beginClaim();
+  return {
+    id,
+    get isLeader() {
+      return role === LeaderRole.Leader;
+    },
+    get role() {
+      return role;
+    },
+    onBecomeLeader(listener) {
+      if (closed) return () => void 0;
+      becomeListeners.add(listener);
+      if (role === LeaderRole.Leader) safeInvoke(listener);
+      return () => {
+        becomeListeners.delete(listener);
+      };
+    },
+    onLoseLeader(listener) {
+      if (closed) return () => void 0;
+      loseListeners.add(listener);
+      return () => {
+        loseListeners.delete(listener);
+      };
+    },
+    release() {
+      if (closed) return;
+      if (role === LeaderRole.Leader) {
+        stepDown();
+        channel.post({ kind: "resign", id });
+        return;
+      }
+      clearClaim();
+      toFollower();
+    },
+    close() {
+      if (closed) return;
+      if (role === LeaderRole.Leader) channel.post({ kind: "resign", id });
+      closed = true;
+      role = LeaderRole.Follower;
+      clearWatch();
+      clearClaim();
+      clearHeartbeat();
+      unsubscribe();
+      becomeListeners.clear();
+      loseListeners.clear();
+      if (ownsChannel) channel.close();
+    }
+  };
+}
+function useSyncChannel(name, onMessage, options) {
+  let channel = null;
+  let unsubscribe;
+  function teardown() {
+    unsubscribe?.();
+    unsubscribe = void 0;
+    channel?.close();
+    channel = null;
+  }
+  function open() {
+    teardown();
+    const next = createSyncChannel(toValue(name), options);
+    channel = next;
+    unsubscribe = next.subscribe((message, envelope) => {
+      onMessage?.(message, envelope);
+    });
+  }
+  onMounted(open);
+  watch(() => toValue(name), open);
+  onScopeDispose(teardown);
+  return (message) => {
+    channel?.post(message);
+  };
+}
+function useLeaderElection(name, options) {
+  const isLeader = shallowRef(false);
+  const id = shallowRef(null);
+  let election = null;
+  let offBecome;
+  let offLose;
+  function teardown() {
+    offBecome?.();
+    offLose?.();
+    offBecome = void 0;
+    offLose = void 0;
+    election?.close();
+    election = null;
+    isLeader.value = false;
+    id.value = null;
+  }
+  function join() {
+    teardown();
+    const next = createLeaderElection(toValue(name), options);
+    election = next;
+    isLeader.value = next.isLeader;
+    id.value = next.id;
+    offBecome = next.onBecomeLeader(() => {
+      isLeader.value = true;
+      id.value = next.id;
+    });
+    offLose = next.onLoseLeader(() => {
+      isLeader.value = false;
+      id.value = next.id;
+    });
+  }
+  onMounted(join);
+  watch(() => toValue(name), join);
+  onScopeDispose(teardown);
+  const release = () => {
+    election?.release();
+  };
+  return { isLeader, id, release };
+}
+const ChannelPrefix = "broadcast-state.";
+function useBroadcastState(key, initial, options) {
+  const current = shallowRef(initial);
+  let channel = null;
+  let unsubscribe;
+  function teardown() {
+    unsubscribe?.();
+    unsubscribe = void 0;
+    channel?.close();
+    channel = null;
+  }
+  function open() {
+    teardown();
+    const next = createSyncChannel(`${ChannelPrefix}${toValue(key)}`, options);
+    channel = next;
+    unsubscribe = next.subscribe((signal) => {
+      if (typeof signal !== "object" || signal === null) return;
+      if (signal.kind === "announce") {
+        current.value = signal.value;
+        return;
+      }
+      next.post({ kind: "announce", value: current.value });
+    });
+    next.post({ kind: "request" });
+  }
+  onMounted(open);
+  watch(() => toValue(key), open);
+  onScopeDispose(teardown);
+  const setValue = (next) => {
+    const resolved = typeof next === "function" ? next(current.value) : next;
+    current.value = resolved;
+    channel?.post({ kind: "announce", value: resolved });
+  };
+  const value = computed({
+    get: () => current.value,
+    set: setValue
+  });
+  return { value, setValue };
+}
+export {
+  createLeaderElection,
+  createSyncChannel,
+  memorySyncHub,
+  useBroadcastState,
+  useLeaderElection,
+  useSyncChannel
+};
+//# sourceMappingURL=index.js.map

package/dist/foundation/channels/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/foundation/channels/CreateSyncChannel.ts","../../../src/foundation/channels/MemorySyncHub.ts","../../../src/foundation/channels/LeaderElection.ts","../../../src/foundation/channels/hooks/UseSyncChannel.ts","../../../src/foundation/channels/hooks/UseLeaderElection.ts","../../../src/foundation/channels/hooks/UseBroadcastState.ts"],"sourcesContent":["// The channel factory and its three transports. One dispatch path serves all of them, which is the whole point:\n// the receiving RULES (drop your own message, drop a duplicate, never let a listener's throw escape) live here\n// once, and a transport only has to move bytes.\n//\n// TRANSPORT LADDER (`auto`): `BroadcastChannel` → `storage` event → inert. Each rung is strictly weaker than the\n// one above, and a rung that is unavailable falls through instead of throwing — an explicit `transport:\n// 'broadcast'` in a browser without it still yields a working channel, just a lesser one.\n//\n// THE `storage` FALLBACK IS A GENUINE DOWNGRADE, not a polyfill. Its known weaknesses, all inherent:\n//   - JSON only. The envelope round-trips through `StorageBroker`, so a `Map`, `Set`, `Date`, `undefined`,\n//     cyclic object, or `ArrayBuffer` does not survive — `BroadcastChannel` structured-clones all of those.\n//   - Same-origin only, like `localStorage` itself. (`BroadcastChannel` is also same-origin, so this one is a\n//     wash — stated because consumers ask.)\n//   - One key, last write wins. Two posts inside a single task collapse: the second overwrites the first before\n//     any peer's `storage` handler has run, and the first is simply lost. Bursty publishers should batch.\n//   - Delivery is best-effort and unordered across senders; there is no ack and no queue.\n//   - The last envelope is left in storage on purpose. Removing it would fire a second `storage` event in every\n//     peer for no payload, and nothing reads the key on join.\n//   - Blocked storage (Safari private mode, a sandboxed iframe, quota) degrades the write to a silent no-op —\n//     the broker already swallows it, so the channel simply delivers nothing.\n//\n// WHY `post` HAS A `try`: `BroadcastChannel.postMessage` throws `DataCloneError` for a payload the structured\n// clone algorithm rejects — a function, a DOM node, a class instance with a live handle. That is the one place\n// a caller could otherwise be surprised by a throw from this slice, and the contract says nothing here throws.\n\nimport { Guid } from '../identifiers';\nimport { localStorageStorageBroker, type StorageBroker } from '../storage';\n\nimport type { ResolvedSyncTransport, SyncChannel, SyncChannelOptions, SyncEnvelope, SyncListener } from './SyncChannel';\n\n/** Namespaces the `storage` fallback's keys so one app's channels never collide with another's on a shared origin. */\nconst DefaultKeyPrefix = 'wow-two.sync';\n\n/** Moves envelopes for one channel; the strategy behind a `SyncChannel`, chosen once at construction. */\ninterface TransportBinding {\n  /** Names the mechanism, surfaced as `channel.transport`. */\n  readonly kind: ResolvedSyncTransport;\n\n  /** Puts one envelope on the wire; swallows every failure. */\n  send(envelope: SyncEnvelope<unknown>): void;\n\n  /** Releases listeners and handles; idempotent. */\n  dispose(): void;\n}\n\n/** Confirms a value carries the envelope's metadata; the payload inside is NOT validated (see `SyncChannel.ts`). */\nfunction isEnvelope(value: unknown): value is SyncEnvelope<unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n\n  const candidate = value as { sender?: unknown; seq?: unknown; timestamp?: unknown };\n  return (\n    typeof candidate.sender === 'string' &&\n    typeof candidate.seq === 'number' &&\n    typeof candidate.timestamp === 'number' &&\n    'message' in candidate\n  );\n}\n\n/**\n * Reads the `key` off a `storage` event without assuming a complete `StorageEvent` — a partial fake is a\n * realistic input.\n */\nfunction readEventKey(event: Event): string | null {\n  const candidate = (event as Event & { readonly key?: unknown }).key;\n  return typeof candidate === 'string' ? candidate : null;\n}\n\n/** Resolves `window`, or null under SSR — mirrors `StorageBroker`'s guard, including the throwing-getter case. */\nfunction resolveWindow(): Window | null {\n  if (typeof window === 'undefined') return null;\n\n  try {\n    return typeof window.addEventListener === 'function' ? window : null;\n  } catch {\n    return null;\n  }\n}\n\n/** Binds a real `BroadcastChannel`, or null when the API is absent (SSR, older Safari). */\nfunction bindBroadcast(name: string, onEnvelope: (raw: unknown) => void): TransportBinding | null {\n  if (typeof BroadcastChannel === 'undefined') return null;\n\n  let channel: BroadcastChannel;\n  try {\n    channel = new BroadcastChannel(name);\n  } catch {\n    // A hostile or partial implementation — fall through to the next rung rather than fail construction.\n    return null;\n  }\n\n  const onMessage = (event: MessageEvent): void => onEnvelope(event.data);\n  channel.addEventListener('message', onMessage);\n\n  return {\n    kind: 'broadcast',\n    send(envelope) {\n      try {\n        channel.postMessage(envelope);\n      } catch {\n        // `DataCloneError` for a non-cloneable payload, or a closed channel — see this file's header.\n      }\n    },\n    dispose() {\n      try {\n        channel.removeEventListener('message', onMessage);\n        channel.close();\n      } catch {\n        // Already torn down by a navigation — nothing to recover.\n      }\n    },\n  };\n}\n\n/** Binds the `storage`-event fallback over a `StorageBroker`, or null under SSR. */\nfunction bindStorage(key: string, broker: StorageBroker, onEnvelope: (raw: unknown) => void): TransportBinding | null {\n  const view = resolveWindow();\n  if (view === null) return null;\n\n  // The event says only THAT the key changed; the value is read back through the broker rather than off\n  // `event.newValue`, so a broker with its own encoding (namespaced, versioned) stays the single source of\n  // truth for what a stored value means. The cost is a race — a second write landing before this read wins,\n  // and the first envelope is dropped, which the `seq` de-dupe turns into a loss rather than a duplicate.\n  const onStorage = (event: Event): void => {\n    if (readEventKey(event) !== key) return;\n    onEnvelope(broker.read<unknown>(key));\n  };\n\n  view.addEventListener('storage', onStorage);\n\n  return {\n    kind: 'storage',\n    send(envelope) {\n      broker.write(key, envelope);\n    },\n    dispose() {\n      view.removeEventListener('storage', onStorage);\n    },\n  };\n}\n\n/** The no-peer binding — SSR, or a browser with neither mechanism. Sends nowhere and receives nothing. */\nconst inertBinding: TransportBinding = {\n  kind: 'inert',\n  send() {\n    // No peers exist; a single-tab app behaves correctly with every message dropped.\n  },\n  dispose() {\n    // Nothing was ever attached.\n  },\n};\n\n/** Walks the transport ladder from the requested rung down, returning the first binding that attaches. */\nfunction bind(\n  requested: SyncChannelOptions['transport'],\n  name: string,\n  key: string,\n  broker: StorageBroker,\n  onEnvelope: (raw: unknown) => void,\n): TransportBinding {\n  if (requested === 'inert') return inertBinding;\n  if (requested === 'storage') return bindStorage(key, broker, onEnvelope) ?? inertBinding;\n  if (requested === 'broadcast') return bindBroadcast(name, onEnvelope) ?? inertBinding;\n\n  return bindBroadcast(name, onEnvelope) ?? bindStorage(key, broker, onEnvelope) ?? inertBinding;\n}\n\n/**\n * Opens this tab's endpoint on the named cross-tab channel. Messages posted here reach every other tab on the\n * same origin with a channel of the same name — and never this tab, on either transport.\n *\n * Prefers `BroadcastChannel`, falls back to a `storage`-event channel written through a `StorageBroker`, and\n * degrades to an inert no-op under SSR or when neither exists. Nothing throws: an unavailable API, a\n * non-cloneable payload, blocked storage, and a listener that throws are all absorbed, so a single-tab app and\n * a server render both behave as if the channel simply has no peers.\n *\n * @typeParam TMessage - The payload shape agreed between tabs; a compile-time contract, not a runtime guarantee.\n * @param name - Channel name; peers are every endpoint sharing it on the origin.\n * @param options - Transport selection, storage seam, key prefix, pinned id, and clock.\n * @returns The endpoint: `post`, `subscribe`, `close`, plus its resolved identity and transport.\n */\nexport function createSyncChannel<TMessage>(name: string, options?: SyncChannelOptions): SyncChannel<TMessage> {\n  // v7 rather than v4: it is time-ordered, so a lexicographic compare of two tab ids is a compare of their\n  // creation times. The leader election's tie-break rides on exactly that (`LeaderElection.ts`).\n  const id = options?.id ?? Guid.createV7();\n  const now = options?.now ?? Date.now;\n  const broker = options?.broker ?? localStorageStorageBroker;\n  const key = `${options?.keyPrefix ?? DefaultKeyPrefix}.${name}`;\n\n  const listeners = new Set<SyncListener<TMessage>>();\n  let seq = 0;\n  let closed = false;\n\n  // The stamp of the last envelope handed to listeners. The fallback can dispatch the same write twice (a\n  // re-entrant handler, a browser that fires for the writer too); `sender:seq` is unique per post, so one slot\n  // is enough to suppress a repeat without growing a set that never shrinks.\n  let lastStamp: string | null = null;\n\n  /** Applies every receiving rule once, for every transport: shape, self, duplicate, then fan out safely. */\n  function deliver(raw: unknown): void {\n    if (closed) return;\n    if (!isEnvelope(raw)) return;\n\n    // The rule `BroadcastChannel` gives for free and the `storage` fallback does not — normalized here so both\n    // transports behave identically, which is what consumers actually depend on.\n    if (raw.sender === id) return;\n\n    const stamp = `${raw.sender}:${raw.seq}`;\n    if (stamp === lastStamp) return;\n    lastStamp = stamp;\n\n    // The payload cannot be validated against `TMessage` at runtime; this cast is the documented seam where a\n    // peer's word is taken for it.\n    const envelope = raw as SyncEnvelope<TMessage>;\n\n    // A copy, so a listener that unsubscribes (or subscribes) during dispatch cannot mutate the set being walked.\n    for (const listener of [...listeners]) {\n      try {\n        listener(envelope.message, envelope);\n      } catch {\n        // One bad listener must not strand the others, and must not surface inside a browser event dispatch.\n      }\n    }\n  }\n\n  const binding = bind(options?.transport ?? 'auto', name, key, broker, deliver);\n\n  return {\n    name,\n    id,\n    transport: binding.kind,\n\n    get closed(): boolean {\n      return closed;\n    },\n\n    post(message: TMessage): void {\n      if (closed) return;\n\n      const envelope: SyncEnvelope<TMessage> = { sender: id, seq: seq++, timestamp: now(), message };\n      binding.send(envelope);\n    },\n\n    subscribe(listener: SyncListener<TMessage>): () => void {\n      if (closed) return () => undefined;\n\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n\n    close(): void {\n      if (closed) return;\n\n      closed = true;\n      listeners.clear();\n      binding.dispose();\n    },\n  };\n}\n","// The in-process channel double — `memoryStorageBroker`'s parallel for this slice, and for the same reason: a\n// consumer testing cross-tab behaviour needs two endpoints that can talk without a browser, a second tab, or a\n// real transport.\n//\n// WHY IT EXISTS RATHER THAN \"just use the real thing in tests\": Node has `BroadcastChannel`, but it delivers\n// through the event loop. Under `vi.useFakeTimers` the loop is no longer the test's to drive, so a leader\n// election — whose entire logic is timers reacting to messages — becomes a race between faked timers and real\n// async delivery. This hub delivers SYNCHRONOUSLY, inside `post`, which collapses that race: post, and every\n// peer has already reacted before the next line runs. That makes heartbeat, expiry, and hand-over assertions\n// deterministic instead of flaky.\n//\n// It keeps every rule the real transports keep — sender exclusion, safe fan-out, closed endpoints going quiet —\n// because a double that is more forgiving than production is a double that hides bugs.\n//\n// WHAT IT DELIBERATELY DOES NOT MODEL: structured-clone or JSON round-tripping. Payloads are passed by\n// reference, so a test can pass a `Map` the `storage` fallback would have destroyed, and a mutation after\n// `post` is visible to the receiver. Serialization limits belong to the transports; assert those against the\n// transport that has them.\n\nimport { Guid } from '../identifiers';\n\nimport type { SyncChannel, SyncEnvelope, SyncListener } from './SyncChannel';\n\n/** One endpoint's private state inside a hub, kept as the erased shape the hub can store uniformly. */\ninterface HubEndpoint {\n  /** Identifies the endpoint, mirroring the channel's own id. */\n  readonly id: Guid;\n\n  /** Names the channel this endpoint is joined to; delivery is scoped to a matching name. */\n  readonly name: string;\n\n  /** Hands one envelope to this endpoint's listeners. */\n  receive(envelope: SyncEnvelope<unknown>): void;\n\n  /** Reports whether the endpoint has closed and should be skipped. */\n  isClosed(): boolean;\n}\n\n/** Represents an isolated in-process message bus standing in for one origin's set of browser tabs. */\nexport interface MemorySyncHub {\n  /**\n   * Opens a new endpoint on `name` — the test's equivalent of opening another tab. Two calls with the same\n   * name yield two peers that can talk to each other but not to themselves.\n   *\n   * @typeParam TMessage - The payload shape shared by the endpoints on this channel.\n   * @param name - Channel name; only endpoints sharing it exchange messages.\n   * @param id - Pins the endpoint's id, for deterministic leader tie-breaks; minted as a v7 GUID when omitted.\n   * @returns A `SyncChannel` backed by this hub.\n   */\n  channel<TMessage>(name: string, id?: Guid): SyncChannel<TMessage>;\n\n  /** Counts the endpoints that are still open, across every channel name — the leak check after a teardown. */\n  readonly openCount: number;\n\n  /** Closes every endpoint and empties the hub, so one test cannot leak peers into the next. */\n  reset(): void;\n}\n\n/**\n * Builds an isolated in-memory hub whose channels deliver synchronously and never touch a browser API.\n *\n * Use it to test cross-tab logic — including this slice's own leader election — under `vi.useFakeTimers`, where\n * the real `BroadcastChannel`'s event-loop delivery would otherwise race the faked clock. Each hub is a closed\n * world: two hubs never see each other's traffic.\n *\n * @returns A hub that mints `SyncChannel` endpoints and can be reset between tests.\n */\nexport function memorySyncHub(): MemorySyncHub {\n  const endpoints = new Set<HubEndpoint>();\n\n  return {\n    channel<TMessage>(name: string, id?: Guid): SyncChannel<TMessage> {\n      const endpointId = id ?? Guid.createV7();\n      const listeners = new Set<SyncListener<TMessage>>();\n      let seq = 0;\n      let closed = false;\n\n      /** Fans an envelope out to this endpoint's listeners, isolating a throwing one exactly as production does. */\n      function receive(envelope: SyncEnvelope<unknown>): void {\n        if (closed) return;\n\n        const typed = envelope as SyncEnvelope<TMessage>;\n        for (const listener of [...listeners]) {\n          try {\n            listener(typed.message, typed);\n          } catch {\n            // Matches `createSyncChannel`: one listener's failure never strands the rest.\n          }\n        }\n      }\n\n      const endpoint: HubEndpoint = {\n        id: endpointId,\n        name,\n        receive,\n        isClosed: () => closed,\n      };\n      endpoints.add(endpoint);\n\n      return {\n        name,\n        id: endpointId,\n        transport: 'broadcast',\n\n        get closed(): boolean {\n          return closed;\n        },\n\n        post(message: TMessage): void {\n          if (closed) return;\n\n          const envelope: SyncEnvelope<TMessage> = {\n            sender: endpointId,\n            seq: seq++,\n            timestamp: Date.now(),\n            message,\n          };\n\n          // Snapshot first: a listener may open or close an endpoint while reacting, and the live set must not\n          // be mutated mid-walk. The `!== endpoint` test is the sender-exclusion rule, enforced here rather\n          // than left to the receiver so the double cannot be laxer than production.\n          for (const peer of [...endpoints]) {\n            if (peer === endpoint) continue;\n            if (peer.name !== name) continue;\n            if (peer.isClosed()) continue;\n            peer.receive(envelope);\n          }\n        },\n\n        subscribe(listener: SyncListener<TMessage>): () => void {\n          if (closed) return () => undefined;\n\n          listeners.add(listener);\n          return () => {\n            listeners.delete(listener);\n          };\n        },\n\n        close(): void {\n          if (closed) return;\n\n          closed = true;\n          listeners.clear();\n          endpoints.delete(endpoint);\n        },\n      };\n    },\n\n    get openCount(): number {\n      let open = 0;\n      for (const endpoint of endpoints) if (!endpoint.isClosed()) open += 1;\n      return open;\n    },\n\n    reset(): void {\n      endpoints.clear();\n    },\n  };\n}\n","// Exactly one tab does the work. The recurring cross-tab problem this solves: five open tabs each opening a\n// WebSocket, each running the same poll, each firing the same notification. Electing a leader lets four of them\n// stand down, and — the part that is easy to get wrong — lets one of them take over when the leader dies.\n//\n// WHY NOT `navigator.locks`: `LockManager.request` is the browser's own answer and is genuinely better where it\n// exists — the lock is released by the browser itself when the tab dies, with no timeout and no heartbeat. It is\n// also absent from every Safari before 15.4 and from every non-secure context, and it cannot express \"tell me\n// when I've LOST leadership\" without holding a promise open. This implementation needs neither, rides on the\n// same channel as the rest of the slice, and works wherever a message can be delivered.\n//\n// THE ALGORITHM, and why it is shaped this way:\n//   - CLAIM WINDOW. A starting tab does not wait out the full timeout to discover whether a leader exists; it\n//     posts a `claim` and listens for `claimWindow` ms. A live leader answers with a heartbeat and the claimant\n//     stands down. Silence means the throne is empty. Startup therefore costs ~150ms, not ~3.5s.\n//   - TIE-BREAK: LOWEST ID WINS. Two tabs claiming in the same window each see the other's claim, and both\n//     apply the same total order, so exactly one concludes it won — no extra round-trip, no coin flip. Ids are\n//     UUIDv7 (`createSyncChannel`), which is TIME-ORDERED: lowest id = earliest-created tab. So the rule is not\n//     arbitrary, it is \"the tab that has been open longest leads\", which is also the tab most likely to hold\n//     warm state.\n//   - HEARTBEAT + EXPIRY IS THE WHOLE POINT. A tab that is killed — process crash, force-quit, OOM, laptop lid,\n//     `pagehide` never firing — cannot announce anything. So leadership is a LEASE, not a grant: the leader\n//     re-asserts every `heartbeatInterval`, and any follower that sees nothing for `timeout` presumes it dead\n//     and claims. Without this the whole slice would deadlock on its first crash, which is the failure mode\n//     leader election exists to prevent.\n//   - SPLIT BRAIN HEALS. Two leaders can coexist briefly (a channel partition, a suspended-then-resumed tab\n//     whose lease expired elsewhere). On hearing a rival heartbeat the higher id steps down; the lower re-asserts.\n//\n// INVARIANT ON THE TIMINGS: `timeout` must exceed `heartbeatInterval` by a comfortable multiple — the default\n// 3500 / 1000 tolerates two dropped or delayed heartbeats. Set them too close and a merely busy main thread\n// (a long task, a background-throttled timer) reads as a crash and leadership flaps. Not clamped, because a\n// test legitimately wants tight values; stated because a consumer legitimately gets it wrong.\n//\n// SAFETY, NOT LIVENESS-AT-ANY-COST: during a partition each side may elect its own leader. This is a UI\n// coordination tool — use it to suppress duplicate work, never as a distributed lock over something that must\n// not happen twice.\n\nimport { Guid } from '../identifiers';\n\nimport { createSyncChannel } from './CreateSyncChannel';\nimport type { SyncChannel, SyncChannelOptions } from './SyncChannel';\n\n/** Prefixes the election's channel name so it cannot collide with a consumer's own channel of the same name. */\nconst ChannelPrefix = 'leader.';\n\n/** Re-asserts leadership this often, in milliseconds. */\nconst DefaultHeartbeatInterval = 1_000;\n\n/** Presumes the leader dead after this long without a heartbeat, in milliseconds — ~3 missed beats. */\nconst DefaultTimeout = 3_500;\n\n/** Collects rival claims for this long before concluding an election, in milliseconds. */\nconst DefaultClaimWindow = 150;\n\n/**\n * Carries the election's traffic. Each signal repeats its sender's id in the payload rather than relying on the\n * envelope, so the messages stay self-describing when read in devtools or replayed through another transport.\n */\nexport type LeaderSignal =\n  /** Asserts live leadership; resets every follower's expiry watchdog. */\n  | { readonly kind: 'heartbeat'; readonly id: Guid }\n  /** Announces a bid for the empty throne; a live leader answers it with a heartbeat. */\n  | { readonly kind: 'claim'; readonly id: Guid }\n  /** Surrenders leadership deliberately, so peers re-elect at once instead of waiting out the expiry. */\n  | { readonly kind: 'resign'; readonly id: Guid };\n\n/** Names a participant's position in the election. */\nexport const LeaderRole = {\n  /** Watches a live leader's heartbeat and re-elects when the lease expires. The state every tab starts in. */\n  Follower: 'follower',\n\n  /** Has bid for the empty throne and is waiting out the claim window for a rival or a live leader. */\n  Candidate: 'candidate',\n\n  /** Holds the lease and does the work; heartbeats until it resigns, closes, or crashes. */\n  Leader: 'leader',\n} as const;\n\n/** Names a participant's position in the election. */\nexport type LeaderRole = (typeof LeaderRole)[keyof typeof LeaderRole];\n\n/** Defines the options that tune an election's timing and transport. */\nexport interface LeaderElectionOptions {\n  /** Sets how often the leader re-asserts, in milliseconds; defaults to 1000. */\n  readonly heartbeatInterval?: number;\n\n  /** Sets how long a follower tolerates silence before claiming, in milliseconds; defaults to 3500. */\n  readonly timeout?: number;\n\n  /** Sets how long a candidate collects rival claims, in milliseconds; defaults to 150. */\n  readonly claimWindow?: number;\n\n  /**\n   * Supplies the channel to run on instead of opening one — the seam tests use to join a `memorySyncHub`. An\n   * injected channel is NOT closed by `close`; its owner keeps that duty.\n   */\n  readonly channel?: SyncChannel<LeaderSignal>;\n\n  /** Tunes the channel opened when `channel` is omitted; ignored when one is supplied. */\n  readonly channelOptions?: SyncChannelOptions;\n}\n\n/** Represents this tab's participation in a named election. */\nexport interface LeaderElection {\n  /** Identifies this participant — the same id as the underlying channel's endpoint. */\n  readonly id: Guid;\n\n  /** Reports whether this tab currently holds the lease. */\n  readonly isLeader: boolean;\n\n  /** Reports this tab's position — `candidate` is the transient state inside a claim window. */\n  readonly role: LeaderRole;\n\n  /**\n   * Registers `listener` for the moment this tab takes leadership. Fires IMMEDIATELY and synchronously if it is\n   * already the leader when subscribing, so a late subscriber cannot miss the transition it was waiting for.\n   *\n   * @param listener - Invoked on becoming leader; a throw is swallowed.\n   * @returns An idempotent disposer.\n   */\n  onBecomeLeader(listener: () => void): () => void;\n\n  /**\n   * Registers `listener` for the moment this tab loses leadership — superseded by a lower id, or after\n   * `release`. Not fired by `close`, which is a teardown rather than a state change.\n   *\n   * @param listener - Invoked on losing leadership; a throw is swallowed.\n   * @returns An idempotent disposer.\n   */\n  onLoseLeader(listener: () => void): () => void;\n\n  /**\n   * Surrenders leadership deliberately and tells peers to re-elect at once. This tab stays in the election and\n   * may win again later — typically after `timeout`, by which point a peer has long since taken over.\n   */\n  release(): void;\n\n  /**\n   * Leaves the election entirely: resigns first if leading, then drops every timer and listener. Idempotent.\n   * Does not fire `onLoseLeader`. Closes the underlying channel only when this election opened it.\n   */\n  close(): void;\n}\n\n/**\n * Joins the named election, in which exactly one participating tab holds leadership at a time.\n *\n * Leadership is a lease kept alive by a heartbeat, so a tab that dies without resigning is superseded once its\n * lease expires — the reclaim path is the reason this exists. Ties are broken by lowest id, which for the\n * time-ordered v7 ids minted here means the longest-open tab wins. Starts campaigning immediately; nothing\n * throws, and under SSR or with no cross-tab transport the sole participant simply becomes leader.\n *\n * @param name - Election name; tabs sharing it on the origin compete for one leadership.\n * @param options - Timing, and the channel to run on.\n * @returns The participant handle: state, transition events, `release`, and `close`.\n */\nexport function createLeaderElection(name: string, options?: LeaderElectionOptions): LeaderElection {\n  const heartbeatInterval = options?.heartbeatInterval ?? DefaultHeartbeatInterval;\n  const timeout = options?.timeout ?? DefaultTimeout;\n  const claimWindow = options?.claimWindow ?? DefaultClaimWindow;\n\n  const ownsChannel = options?.channel === undefined;\n  const channel =\n    options?.channel ?? createSyncChannel<LeaderSignal>(`${ChannelPrefix}${name}`, options?.channelOptions);\n\n  // One identity per tab: the election reuses the channel endpoint's id rather than minting a second one, so a\n  // consumer correlating a message's sender with a leader's id sees the same value.\n  const id = channel.id;\n\n  const becomeListeners = new Set<() => void>();\n  const loseListeners = new Set<() => void>();\n\n  let role: LeaderRole = LeaderRole.Follower;\n  let closed = false;\n\n  let claimTimer: ReturnType<typeof setTimeout> | undefined;\n  let watchTimer: ReturnType<typeof setTimeout> | undefined;\n  let heartbeatTimer: ReturnType<typeof setInterval> | undefined;\n\n  // Per-campaign scratch, reset at the start of every claim window.\n  let lowestRival: Guid | null = null;\n  let leaderSeenDuringClaim = false;\n\n  /** Runs a listener without letting its failure escape into a timer or an event dispatch. */\n  function safeInvoke(listener: () => void): void {\n    try {\n      listener();\n    } catch {\n      // A consumer's callback must not break the election's own state machine.\n    }\n  }\n\n  /** Fans a transition out over a snapshot, so a listener that unsubscribes mid-emit cannot corrupt the walk. */\n  function emit(listeners: ReadonlySet<() => void>): void {\n    for (const listener of [...listeners]) safeInvoke(listener);\n  }\n\n  /** Stops the follower's expiry watchdog. */\n  function clearWatch(): void {\n    if (watchTimer !== undefined) clearTimeout(watchTimer);\n    watchTimer = undefined;\n  }\n\n  /** Stops the pending claim resolution. */\n  function clearClaim(): void {\n    if (claimTimer !== undefined) clearTimeout(claimTimer);\n    claimTimer = undefined;\n  }\n\n  /** Stops the leader's heartbeat. */\n  function clearHeartbeat(): void {\n    if (heartbeatTimer !== undefined) clearInterval(heartbeatTimer);\n    heartbeatTimer = undefined;\n  }\n\n  /** (Re)arms the expiry watchdog — every heartbeat heard pushes the presumed-dead deadline out. */\n  function armWatch(): void {\n    clearWatch();\n    if (closed) return;\n    watchTimer = setTimeout(beginClaim, timeout);\n  }\n\n  /** Drops to follower and resumes watching for a leader. */\n  function toFollower(): void {\n    role = LeaderRole.Follower;\n    armWatch();\n  }\n\n  /** Opens a campaign: announce the bid, then judge the responses once the window closes. */\n  function beginClaim(): void {\n    if (closed || role === LeaderRole.Leader) return;\n\n    clearWatch();\n    clearClaim();\n\n    role = LeaderRole.Candidate;\n    lowestRival = null;\n    leaderSeenDuringClaim = false;\n\n    channel.post({ kind: 'claim', id });\n    claimTimer = setTimeout(resolveClaim, claimWindow);\n  }\n\n  /** Closes the campaign: a live leader or a lower-id rival beats this tab; otherwise it takes the lease. */\n  function resolveClaim(): void {\n    claimTimer = undefined;\n    if (closed || role !== LeaderRole.Candidate) return;\n\n    if (leaderSeenDuringClaim) {\n      toFollower();\n      return;\n    }\n\n    // The total order every candidate applies identically — so exactly one of them concludes it won.\n    if (lowestRival !== null && Guid.compare(lowestRival, id) < 0) {\n      toFollower();\n      return;\n    }\n\n    becomeLeader();\n  }\n\n  /** Takes the lease: assert it at once, then keep it alive. */\n  function becomeLeader(): void {\n    if (closed) return;\n\n    role = LeaderRole.Leader;\n    clearWatch();\n    clearClaim();\n\n    channel.post({ kind: 'heartbeat', id });\n    heartbeatTimer = setInterval(() => channel.post({ kind: 'heartbeat', id }), heartbeatInterval);\n\n    emit(becomeListeners);\n  }\n\n  /** Gives up the lease and returns to watching, announcing the transition. */\n  function stepDown(): void {\n    clearHeartbeat();\n    role = LeaderRole.Follower;\n    armWatch();\n    emit(loseListeners);\n  }\n\n  const unsubscribe = channel.subscribe((signal) => {\n    if (closed) return;\n\n    // A peer on an older bundle could send anything; the union is a compile-time contract only.\n    if (typeof signal !== 'object' || signal === null) return;\n\n    switch (signal.kind) {\n      case 'heartbeat': {\n        if (role === LeaderRole.Leader) {\n          // Split brain. Both sides apply the same rule, so it resolves in one exchange: the higher id yields,\n          // the lower re-asserts to the tab that has just stood down.\n          if (Guid.compare(signal.id, id) < 0) stepDown();\n          else channel.post({ kind: 'heartbeat', id });\n          return;\n        }\n\n        leaderSeenDuringClaim = true;\n        if (role === LeaderRole.Candidate) {\n          clearClaim();\n          role = LeaderRole.Follower;\n        }\n        armWatch();\n        return;\n      }\n\n      case 'claim': {\n        // Answering a claim is what makes a live leader discoverable in `claimWindow` instead of `timeout`.\n        if (role === LeaderRole.Leader) {\n          channel.post({ kind: 'heartbeat', id });\n          return;\n        }\n\n        if (role === LeaderRole.Candidate && (lowestRival === null || Guid.compare(signal.id, lowestRival) < 0)) {\n          lowestRival = signal.id;\n        }\n        return;\n      }\n\n      case 'resign': {\n        // The graceful path: re-elect now rather than waiting out a lease nobody is holding.\n        if (role !== LeaderRole.Leader) beginClaim();\n        return;\n      }\n    }\n  });\n\n  beginClaim();\n\n  return {\n    id,\n\n    get isLeader(): boolean {\n      return role === LeaderRole.Leader;\n    },\n\n    get role(): LeaderRole {\n      return role;\n    },\n\n    onBecomeLeader(listener: () => void): () => void {\n      if (closed) return () => undefined;\n\n      becomeListeners.add(listener);\n      // Replay the current state: a subscriber attaching after the campaign resolved would otherwise wait for a\n      // transition that has already happened.\n      if (role === LeaderRole.Leader) safeInvoke(listener);\n\n      return () => {\n        becomeListeners.delete(listener);\n      };\n    },\n\n    onLoseLeader(listener: () => void): () => void {\n      if (closed) return () => undefined;\n\n      loseListeners.add(listener);\n      return () => {\n        loseListeners.delete(listener);\n      };\n    },\n\n    release(): void {\n      if (closed) return;\n\n      if (role === LeaderRole.Leader) {\n        // Step down BEFORE announcing. A peer that hears `resign` claims immediately, and with a synchronous\n        // transport that claim arrives while this tab is still on the wire — a leader would answer it with a\n        // heartbeat, the claimant would abort, and the handover would be lost until the lease expired.\n        stepDown();\n        channel.post({ kind: 'resign', id });\n        return;\n      }\n\n      clearClaim();\n      toFollower();\n    },\n\n    close(): void {\n      if (closed) return;\n\n      // Resign before going quiet, so peers re-elect immediately instead of waiting out this tab's lease. A tab\n      // that is KILLED cannot do this — that case is the expiry path's job.\n      if (role === LeaderRole.Leader) channel.post({ kind: 'resign', id });\n\n      closed = true;\n      role = LeaderRole.Follower;\n      clearWatch();\n      clearClaim();\n      clearHeartbeat();\n      unsubscribe();\n      becomeListeners.clear();\n      loseListeners.clear();\n\n      if (ownsChannel) channel.close();\n    },\n  };\n}\n","// Vue binding for `createSyncChannel` — one channel per scope, torn down when the scope is disposed.\n//\n// THE LIFETIME RULE THIS ENFORCES: a channel holds a real `BroadcastChannel` (or a window listener), so a\n// component that opens one and forgets it leaks a handle that keeps receiving after the tree is gone. Binding\n// the channel to `onMounted` / `onScopeDispose` makes the disposal automatic.\n//\n// OPENED FROM `onMounted`, NEVER FROM AN IMMEDIATE WATCHER. `createSyncChannel` reaches for `BroadcastChannel`\n// and, on the fallback path, `window`; an immediate watcher also runs during a server render, where neither\n// exists. The channel is a client-only object, so `onMounted` is exactly the right seam.\n//\n// `onMessage` IS CALLED THROUGH THE CLOSURE, not captured into the subscription. A component's `setup` runs\n// once, so the original's callback-in-a-ref indirection is unnecessary here — but the indirection is preserved\n// in spirit: the subscription forwards to whatever `onMessage` is bound now, so the channel stays put.\n//\n// SAME REASONING FOR `options`, WITH A CAVEAT: they are read ONCE, when the channel opens. Changing `transport`,\n// `broker`, or `keyPrefix` afterwards does NOT rebuild the channel — only `name` does. Options are\n// configuration, not state; a consumer that genuinely needs to swap transports at runtime should remount with a\n// `key`. This mirrors how `usePersistentState` pins its broker.\n\nimport { onMounted, onScopeDispose, toValue, watch, type MaybeRefOrGetter } from 'vue';\n\nimport { createSyncChannel } from '../CreateSyncChannel';\nimport type { SyncChannel, SyncChannelOptions, SyncListener } from '../SyncChannel';\n\n/**\n * Opens a cross-tab channel for the lifetime of the scope and subscribes `onMessage` to it.\n *\n * The returned `post` sends to every OTHER tab on the channel, never back into this one. Before mount and after\n * disposal — and under SSR, where no channel is ever opened — `post` is a silent no-op, so a handler firing at\n * an awkward moment needs no guard.\n *\n * @typeParam TMessage - The payload shape agreed between tabs.\n * @param name - Channel name; every tab using it on this origin is a peer. A ref or getter re-opens on change.\n * @param onMessage - Invoked for each message from another tab.\n * @param options - Transport and storage configuration, read once when the channel opens.\n * @returns The `post` function.\n */\nexport function useSyncChannel<TMessage>(\n  name: MaybeRefOrGetter<string>,\n  onMessage?: SyncListener<TMessage>,\n  options?: SyncChannelOptions,\n): (message: TMessage) => void {\n  let channel: SyncChannel<TMessage> | null = null;\n  let unsubscribe: (() => void) | undefined;\n\n  function teardown(): void {\n    unsubscribe?.();\n    unsubscribe = undefined;\n    channel?.close();\n    channel = null;\n  }\n\n  function open(): void {\n    teardown();\n\n    const next = createSyncChannel<TMessage>(toValue(name), options);\n    channel = next;\n\n    // The subscription forwards rather than capturing, which is what lets the watcher depend on `name` alone.\n    unsubscribe = next.subscribe((message, envelope) => {\n      onMessage?.(message, envelope);\n    });\n  }\n\n  onMounted(open);\n  // Non-immediate on purpose: an immediate watcher runs on the server, where `BroadcastChannel` is absent.\n  watch(() => toValue(name), open);\n  onScopeDispose(teardown);\n\n  return (message: TMessage): void => {\n    channel?.post(message);\n  };\n}\n","// Vue binding for `createLeaderElection` — joins on mount, resigns and leaves when the scope is disposed.\n//\n// WHY THE TEARDOWN PATH MATTERS MORE THAN USUAL: `close` resigns first, so a departing leader hands over in a\n// claim window (~150ms) instead of leaving its peers to wait out the full lease (~3.5s) for a tab that is\n// perfectly alive and simply navigating. The expiry path stays as the backstop for the tab that dies without\n// ever running this cleanup.\n//\n// `isLeader` STARTS FALSE, ALWAYS. There is no election on the server, and no synchronous answer on the client\n// either — a fresh participant is a candidate until its claim window closes. So the first paint is always a\n// follower, and leadership arrives later. That makes the composable SSR-safe by construction (server and client\n// agree on the first paint), and it is why the election is joined in `onMounted` rather than at setup:\n// `createLeaderElection` opens a channel, which reaches for `BroadcastChannel` and `window`.\n//\n// Leader-only work therefore belongs in a `watch` on `isLeader`, never in a render branch that assumes the\n// answer is settled.\n\nimport { onMounted, onScopeDispose, shallowRef, toValue, watch, type MaybeRefOrGetter, type ShallowRef } from 'vue';\n\nimport type { Guid } from '../../identifiers';\n\nimport { createLeaderElection, type LeaderElection, type LeaderElectionOptions } from '../LeaderElection';\n\n/** Reports this tab's standing in an election, as reactive state. */\nexport interface LeaderElectionState {\n  /** Reports whether this tab currently holds leadership; false before mount and under SSR. */\n  readonly isLeader: Readonly<ShallowRef<boolean>>;\n\n  /** Identifies this participant, or null before the election is joined (pre-mount, SSR). */\n  readonly id: Readonly<ShallowRef<Guid | null>>;\n\n  /** Surrenders leadership deliberately, handing over to a peer; a no-op when not leading. */\n  readonly release: () => void;\n}\n\n/**\n * Joins the named leader election for the lifetime of the scope, updating when this tab gains or loses\n * leadership.\n *\n * Exactly one participating tab leads at a time; a tab that dies is superseded once its lease expires. Use it to\n * elect the single tab that opens the socket, runs the poll, or shows the notification.\n *\n * @param name - Election name; tabs sharing it on this origin compete for one leadership. A ref or getter\n *   re-joins on change.\n * @param options - Timing and channel configuration, read once when the election is joined.\n * @returns The current standing plus `release`.\n */\nexport function useLeaderElection(\n  name: MaybeRefOrGetter<string>,\n  options?: LeaderElectionOptions,\n): LeaderElectionState {\n  const isLeader = shallowRef(false);\n  const id = shallowRef<Guid | null>(null);\n\n  let election: LeaderElection | null = null;\n  let offBecome: (() => void) | undefined;\n  let offLose: (() => void) | undefined;\n\n  function teardown(): void {\n    offBecome?.();\n    offLose?.();\n    offBecome = undefined;\n    offLose = undefined;\n    election?.close();\n    election = null;\n    isLeader.value = false;\n    id.value = null;\n  }\n\n  function join(): void {\n    teardown();\n\n    const next = createLeaderElection(toValue(name), options);\n    election = next;\n\n    // Publish the id immediately; leadership itself is decided later, by the transition callbacks.\n    isLeader.value = next.isLeader;\n    id.value = next.id;\n\n    offBecome = next.onBecomeLeader(() => {\n      isLeader.value = true;\n      id.value = next.id;\n    });\n    offLose = next.onLoseLeader(() => {\n      isLeader.value = false;\n      id.value = next.id;\n    });\n  }\n\n  onMounted(join);\n  // Non-immediate on purpose: an immediate watcher runs on the server, where the channel's globals are absent.\n  watch(() => toValue(name), join);\n  onScopeDispose(teardown);\n\n  const release = (): void => {\n    election?.release();\n  };\n\n  return { isLeader, id, release };\n}\n","// State that is LIVE-SHARED between open tabs and dies with the last one.\n//\n// PICKING BETWEEN THIS AND `usePersistentState` (`foundation/storage`) — they overlap by one line in a table and\n// differ everywhere else:\n//\n//   | | `usePersistentState` | `useBroadcastState` |\n//   |---|---|---|\n//   | Where the value lives | `localStorage` (durable) | memory, in each tab (ephemeral) |\n//   | Survives a reload / restart | yes | no — last tab closes, value is gone |\n//   | Cross-tab sync | yes, as a side effect of the `storage` event | yes, deliberately, over the channel |\n//   | Sync when `BroadcastChannel` exists | still the `storage` event | `BroadcastChannel` |\n//   | Cost per update | a storage write | a message |\n//   | Reaches a tab opened later | yes, it reads storage | yes, via the mount-time request/announce below |\n//\n// USE `usePersistentState` for anything the user would expect to still be there tomorrow — theme, collapsed\n// sidebar, draft text, consent. USE THIS for state that is only meaningful while the tabs are open: which tab is\n// playing audio, a live cursor position, \"a sync is running\", a wizard step mirrored across windows. Writing\n// ephemeral state through `localStorage` leaves litter that outlives its meaning and re-appears, stale, on the\n// next visit; persisting it is the actual bug that this composable exists to avoid.\n//\n// THE LATE-JOINER PROBLEM, AND THE FIX: a message-only mirror leaves a tab opened later holding `initial` while\n// everyone else has moved on — it hears only FUTURE changes. So on mount this composable posts a `request`, and\n// every tab already holding the value answers with an `announce`. With several peers, several answers arrive;\n// they agree, so last-write-wins is harmless. A tab that opens when NO other tab is open keeps `initial`, which\n// is correct — there is no shared value to inherit.\n//\n// NOT A CONFLICT-FREE TYPE. Two tabs writing in the same instant both broadcast, and each ends on whichever\n// message it received last — the values can diverge. Fine for state with one natural writer at a time; wrong\n// for a shared editable document, which needs a CRDT or a server, not a broadcast.\n//\n// THE CHANNEL OPENS IN `onMounted`, never at setup: `createSyncChannel` reaches for `BroadcastChannel` and\n// `window`. Under SSR the value is simply `initial` and the setter is local, exactly as the original.\n\nimport {\n  computed,\n  onMounted,\n  onScopeDispose,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n  type WritableComputedRef,\n} from 'vue';\n\nimport { createSyncChannel } from '../CreateSyncChannel';\nimport type { SyncChannel, SyncChannelOptions } from '../SyncChannel';\n\n/** Prefixes the channel name so this composable's traffic cannot collide with a consumer's own channel. */\nconst ChannelPrefix = 'broadcast-state.';\n\n/** Carries the mirror's traffic: a value announcement, or a late joiner asking to be caught up. */\ntype BroadcastStateSignal<T> =\n  /** Publishes the sender's current value; every receiver adopts it. */\n  | { readonly kind: 'announce'; readonly value: T }\n  /** Asks peers to announce, so a tab that just opened can catch up. */\n  | { readonly kind: 'request' };\n\n/** A setter accepting a next value or an updater fn. */\nexport type SetBroadcastState<T> = (next: T | ((previous: T) => T)) => void;\n\n/** The mirrored-state handle — a writable value plus the explicit setter it delegates to. */\nexport interface BroadcastStateControls<T> {\n  /**\n   * The mirrored value. Writable: `value.value = next` runs the same path as `setValue(next)`, so it drops\n   * straight into `v-model`. The updater-fn form is `setValue`'s alone — a `v-model` write is always a value.\n   */\n  readonly value: WritableComputedRef<T>;\n\n  /** Sets the next value locally and announces it to every peer. Accepts a value or an updater fn. */\n  readonly setValue: SetBroadcastState<T>;\n}\n\n/**\n * Manages a piece of reactive state mirrored live across every open tab, without persisting it anywhere.\n *\n * Setting the value here sets it in every other tab holding the same `key`; a tab that opens later asks its\n * peers for the current value on mount. Nothing is written to storage, so the value vanishes when the last tab\n * closes — read this file's header for the split with `usePersistentState`, which is the durable counterpart.\n *\n * SSR-safe: no channel is opened on the server, so the value is simply `initial` and the setter is local.\n *\n * @typeParam T - The mirrored value; must survive the transport (JSON-only on the `storage` fallback).\n * @param key - Identifies the shared value; tabs sharing it on this origin mirror each other. A ref or getter\n *   re-opens the channel on change.\n * @param initial - The value before any peer answers, and the value when no other tab is open. Read once.\n * @param options - Channel configuration, read once when the channel opens.\n * @returns The writable value and its setter.\n */\nexport function useBroadcastState<T>(\n  key: MaybeRefOrGetter<string>,\n  initial: T,\n  options?: SyncChannelOptions,\n): BroadcastStateControls<T> {\n  // Cast: `shallowRef`'s return type is a conditional over an unresolved `T`, which leaves `.value`\n  // unassignable until `T` is known. The cast pins it to the shape it always has here — same as `useControlled`.\n  const current = shallowRef(initial) as ShallowRef<T>;\n\n  let channel: SyncChannel<BroadcastStateSignal<T>> | null = null;\n  let unsubscribe: (() => void) | undefined;\n\n  function teardown(): void {\n    unsubscribe?.();\n    unsubscribe = undefined;\n    channel?.close();\n    channel = null;\n  }\n\n  function open(): void {\n    teardown();\n\n    const next = createSyncChannel<BroadcastStateSignal<T>>(`${ChannelPrefix}${toValue(key)}`, options);\n    channel = next;\n\n    unsubscribe = next.subscribe((signal) => {\n      if (typeof signal !== 'object' || signal === null) return;\n\n      if (signal.kind === 'announce') {\n        current.value = signal.value;\n        return;\n      }\n\n      // A peer just opened and is asking to be caught up; answer with what this tab holds.\n      next.post({ kind: 'announce', value: current.value });\n    });\n\n    next.post({ kind: 'request' });\n  }\n\n  onMounted(open);\n  // Non-immediate on purpose: an immediate watcher runs on the server, where `BroadcastChannel` is absent.\n  watch(() => toValue(key), open);\n  onScopeDispose(teardown);\n\n  const setValue: SetBroadcastState<T> = (next) => {\n    // Resolved against the current value before the write, so the broadcast is never a side effect inside a\n    // reactive setter that something else might re-run.\n    const resolved = typeof next === 'function' ? (next as (previous: T) => T)(current.value) : next;\n\n    current.value = resolved;\n    channel?.post({ kind: 'announce', value: resolved });\n  };\n\n  const value = computed<T>({\n    get: () => current.value,\n    set: setValue,\n  });\n\n  return { value, setValue };\n}\n"],"names":["ChannelPrefix"],"mappings":"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"}

package/dist/foundation/clipboard/ClipboardFailureCode.d.ts

@@ -0,0 +1,7 @@
+/** Closed failure vocabulary for ClipboardFailure. */
+export declare const ClipboardFailureCode: {
+    readonly Denied: "denied";
+    readonly Unsupported: "unsupported";
+    readonly Failed: "failed";
+};
+export type ClipboardFailureCode = (typeof ClipboardFailureCode)[keyof typeof ClipboardFailureCode];

package/dist/foundation/clipboard/ClipboardPermission.d.ts

@@ -1,12 +1,18 @@
 import { PermissionQueryState } from '../notifications/QueryPermission';
 /** Which half of the clipboard a permission query is about. */
-export type ClipboardPermissionMode = 'read' | 'write';
+export declare const ClipboardPermissionMode: {
+    /** Asks about reading the clipboard — the `clipboard-read` permission name. */
+    readonly Read: "read";
+    /** Asks about writing the clipboard — the `clipboard-write` permission name. */
+    readonly Write: "write";
+};
+/** Which half of the clipboard a permission query is about. */
+export type ClipboardPermissionMode = (typeof ClipboardPermissionMode)[keyof typeof ClipboardPermissionMode];
 /**
  * Reads the browser's recorded permission for clipboard reading or writing.
  *
- * Returns `unsupported` wherever the Permissions API is absent or does not implement the name — which is most
- * browsers, including all of Firefox and Safari. Read that as "unknown", never as "denied": the capability is
- * frequently available where the QUERY is not.
+ * Returns `unsupported` when the Permissions API cannot query the name. Treat this as unknown,
+ * not denied: clipboard operations may remain available without a supported permission query.
  *
  * A one-shot snapshot; the browser fires no event on this promise.
  *