@use-everywhere/core 0.9.0 → 0.10.1

package/dist/index.cjs

@@ -25,6 +25,7 @@ __export(src_exports, {
   DEFAULT_NAME: () => DEFAULT_NAME,
   HandshakeTimeoutError: () => HandshakeTimeoutError,
   NoopTransport: () => NoopTransport,
+  SharedWorkerTransport: () => SharedWorkerTransport,
   StorageTransport: () => StorageTransport,
   WIRE_VERSION: () => WIRE_VERSION,
   WindowClosedError: () => WindowClosedError,
@@ -42,6 +43,7 @@ __export(src_exports, {
   getWireSkew: () => getWireSkew,
   indexedDbAdapter: () => indexedDbAdapter,
   isBroadcastChannelAvailable: () => isBroadcastChannelAvailable,
+  isSharedWorkerAvailable: () => isSharedWorkerAvailable,
   isStorageEventAvailable: () => isStorageEventAvailable,
   jsonSerializer: () => jsonSerializer,
   localStorageAdapter: () => localStorageAdapter,
@@ -1049,12 +1051,14 @@ function createWebLocksLeader(name, options, locks) {
     if (closed || !eligible || releaseHeld || pending) return;
     const controller = new AbortController();
     pending = controller;
+    let grant;
     const held = new Promise((resolve) => {
-      releaseHeld = resolve;
+      grant = resolve;
     });
     void locks.request(name, { signal: controller.signal }, async () => {
       pending = null;
       if (closed || !eligible) return;
+      releaseHeld = grant;
       setLeader(clientId);
       announce2();
       await held;
@@ -1890,6 +1894,42 @@ function createNamespace(namespace) {
     createLeader: (name, options) => createLeader(busName(name), options)
   };
 }
+
+// src/transport/shared-worker-transport.ts
+var SharedWorkerTransport = class {
+  constructor(options) {
+    this.kind = "shared-worker";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.closed = false;
+    const name = options.name ?? "use-everywhere";
+    const factory = options.factory ?? ((url, workerName) => new SharedWorker(url, { name: workerName }));
+    const worker = factory(String(options.url), name);
+    this.port = worker.port;
+    this.onMessage = (event) => {
+      for (const listener of this.listeners) listener(event.data);
+    };
+    this.port.addEventListener("message", this.onMessage);
+    this.port.start?.();
+  }
+  post(data) {
+    if (this.closed) return;
+    this.port.postMessage(data);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.listeners.clear();
+    this.port.removeEventListener("message", this.onMessage);
+    this.port.close();
+  }
+};
+function isSharedWorkerAvailable() {
+  return typeof SharedWorker !== "undefined";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BroadcastChannelTransport,
@@ -1897,6 +1937,7 @@ function createNamespace(namespace) {
   DEFAULT_NAME,
   HandshakeTimeoutError,
   NoopTransport,
+  SharedWorkerTransport,
   StorageTransport,
   WIRE_VERSION,
   WindowClosedError,
@@ -1914,6 +1955,7 @@ function createNamespace(namespace) {
   getWireSkew,
   indexedDbAdapter,
   isBroadcastChannelAvailable,
+  isSharedWorkerAvailable,
   isStorageEventAvailable,
   jsonSerializer,
   localStorageAdapter,

package/dist/index.d.cts

@@ -1090,6 +1090,98 @@ declare class StorageTransport implements Transport {
     close(): void;
 }
 
+/**
+ * The subset of `SharedWorker` this transport uses. Narrower than the DOM type
+ * on purpose: tests supply a fake, and a fake that has to implement
+ * `EventTarget` to be accepted is a fake nobody writes.
+ */
+interface SharedWorkerLike {
+    readonly port: MessagePortLike;
+}
+interface MessagePortLike {
+    postMessage(data: unknown): void;
+    start?: () => void;
+    close(): void;
+    addEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+    removeEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+}
+interface SharedWorkerTransportOptions {
+    /**
+     * The relay script. A `URL` rather than a string in the common case, because
+     * `new URL('./relay.js', import.meta.url)` is what survives a bundler.
+     *
+     * It must be a *stable* URL, and that is the whole reason this option exists
+     * rather than the library inlining a worker from a Blob the way it could for
+     * a dedicated one: a SharedWorker's identity is its script URL plus its name,
+     * and every tab that builds its own Blob URL gets its own worker. Inlining
+     * would produce N private workers that share nothing — the failure this
+     * transport exists to prevent, wearing the costume of a fix.
+     */
+    url: string | URL;
+    /**
+     * Distinguishes workers loaded from the same script. Defaults to the bus
+     * name, which is what makes two buses on one origin independent.
+     */
+    name?: string;
+    /**
+     * Constructs the worker. Only tests should pass this; the default is
+     * `globalThis.SharedWorker`.
+     */
+    factory?: (url: string, name: string) => SharedWorkerLike;
+}
+/**
+ * Cross-tab delivery through one SharedWorker per origin.
+ *
+ * BroadcastChannel is the better default for pure fan-out and stays the
+ * default. This transport buys something else: a single place that is not a
+ * tab. The relay outlives any individual tab, so the thing every "the leader
+ * owns the socket" design actually wants — one connection, held somewhere no
+ * user can close mid-flight — becomes possible without electing a leader at
+ * all.
+ *
+ * What it does not buy: durability. The worker is torn down when the last port
+ * closes, exactly like a BroadcastChannel with no listeners. State still lives
+ * in the tabs; this moves the *wire*, not the source of truth.
+ *
+ * The relay script is three lines and ships with the library:
+ *
+ * ```js
+ * // sw-relay.js — your app hosts this file
+ * import 'use-everywhere/shared-worker';
+ * ```
+ *
+ * ```ts
+ * createSharedStore('cart', {
+ *   transport: new SharedWorkerTransport({
+ *     url: new URL('./sw-relay.js', import.meta.url),
+ *   }),
+ * });
+ * ```
+ */
+declare class SharedWorkerTransport implements Transport {
+    readonly kind: TransportKind;
+    private port;
+    private listeners;
+    private onMessage;
+    private closed;
+    constructor(options: SharedWorkerTransportOptions);
+    post(data: unknown): void;
+    subscribe(listener: (data: unknown) => void): () => void;
+    close(): void;
+}
+/**
+ * Whether this context can construct a SharedWorker at all.
+ *
+ * Notably false in every dedicated worker (they cannot nest a SharedWorker) and
+ * in Chrome on Android. Worth checking before choosing this transport, since
+ * the constructor throws rather than degrading.
+ */
+declare function isSharedWorkerAvailable(): boolean;
+
 declare function isBroadcastChannelAvailable(): boolean;
 /**
  * Can we hear other tabs through the `storage` event?
@@ -1111,4 +1203,4 @@ declare function isStorageEventAvailable(): boolean;
  */
 declare function defaultTransport(name: string): Transport;
 
-export { type AskOptions, BroadcastChannelTransport, type BusEvent, type BusObserver, type BusWire, CID_PARAM, type Channel, type ChannelOptions, type CommonOptions, type ConnectToOpenerOptions, DEFAULT_NAME, type DebugOptions, HandshakeTimeoutError, type IndexedDbAdapterOptions, type InvalidPayload, type Leader, type LeaderOptions, type LeaderSnapshot, type LeaderStrategy, type LockManagerLike, type MessageEventLike, type MessageMap, type MessageMeta, type Namespace, NoopTransport, type OnInvalid, type OnOptions, type OpenWindowOptions, type OpenedWindow, type OpenerConnection, type Peer, type PeerKind, type PersistAdapter, type PersistOptions, type Persisted, type PostOptions, type Presence, type PresenceOptions, type ReplyMap, type RestoreError, type SchemaMap, type SchemaOptions, type Serializer, type SharedReducer, type SharedReducerOptions, type SharedStore, type SharedStoreOptions, type StandardSchemaV1, type StorageLike, StorageTransport, Transport, TransportKind, type Version, WIRE_VERSION, type WebStorageAdapterOptions, WindowClosedError, type WindowEventTarget, type WindowLike, connectToOpener, createChannel, createLeader, createNamespace, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter };
+export { type AskOptions, BroadcastChannelTransport, type BusEvent, type BusObserver, type BusWire, CID_PARAM, type Channel, type ChannelOptions, type CommonOptions, type ConnectToOpenerOptions, DEFAULT_NAME, type DebugOptions, HandshakeTimeoutError, type IndexedDbAdapterOptions, type InvalidPayload, type Leader, type LeaderOptions, type LeaderSnapshot, type LeaderStrategy, type LockManagerLike, type MessageEventLike, type MessageMap, type MessageMeta, type MessagePortLike, type Namespace, NoopTransport, type OnInvalid, type OnOptions, type OpenWindowOptions, type OpenedWindow, type OpenerConnection, type Peer, type PeerKind, type PersistAdapter, type PersistOptions, type Persisted, type PostOptions, type Presence, type PresenceOptions, type ReplyMap, type RestoreError, type SchemaMap, type SchemaOptions, type Serializer, type SharedReducer, type SharedReducerOptions, type SharedStore, type SharedStoreOptions, type SharedWorkerLike, SharedWorkerTransport, type SharedWorkerTransportOptions, type StandardSchemaV1, type StorageLike, StorageTransport, Transport, TransportKind, type Version, WIRE_VERSION, type WebStorageAdapterOptions, WindowClosedError, type WindowEventTarget, type WindowLike, connectToOpener, createChannel, createLeader, createNamespace, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isSharedWorkerAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter };

package/dist/index.d.ts

@@ -1090,6 +1090,98 @@ declare class StorageTransport implements Transport {
     close(): void;
 }
 
+/**
+ * The subset of `SharedWorker` this transport uses. Narrower than the DOM type
+ * on purpose: tests supply a fake, and a fake that has to implement
+ * `EventTarget` to be accepted is a fake nobody writes.
+ */
+interface SharedWorkerLike {
+    readonly port: MessagePortLike;
+}
+interface MessagePortLike {
+    postMessage(data: unknown): void;
+    start?: () => void;
+    close(): void;
+    addEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+    removeEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+}
+interface SharedWorkerTransportOptions {
+    /**
+     * The relay script. A `URL` rather than a string in the common case, because
+     * `new URL('./relay.js', import.meta.url)` is what survives a bundler.
+     *
+     * It must be a *stable* URL, and that is the whole reason this option exists
+     * rather than the library inlining a worker from a Blob the way it could for
+     * a dedicated one: a SharedWorker's identity is its script URL plus its name,
+     * and every tab that builds its own Blob URL gets its own worker. Inlining
+     * would produce N private workers that share nothing — the failure this
+     * transport exists to prevent, wearing the costume of a fix.
+     */
+    url: string | URL;
+    /**
+     * Distinguishes workers loaded from the same script. Defaults to the bus
+     * name, which is what makes two buses on one origin independent.
+     */
+    name?: string;
+    /**
+     * Constructs the worker. Only tests should pass this; the default is
+     * `globalThis.SharedWorker`.
+     */
+    factory?: (url: string, name: string) => SharedWorkerLike;
+}
+/**
+ * Cross-tab delivery through one SharedWorker per origin.
+ *
+ * BroadcastChannel is the better default for pure fan-out and stays the
+ * default. This transport buys something else: a single place that is not a
+ * tab. The relay outlives any individual tab, so the thing every "the leader
+ * owns the socket" design actually wants — one connection, held somewhere no
+ * user can close mid-flight — becomes possible without electing a leader at
+ * all.
+ *
+ * What it does not buy: durability. The worker is torn down when the last port
+ * closes, exactly like a BroadcastChannel with no listeners. State still lives
+ * in the tabs; this moves the *wire*, not the source of truth.
+ *
+ * The relay script is three lines and ships with the library:
+ *
+ * ```js
+ * // sw-relay.js — your app hosts this file
+ * import 'use-everywhere/shared-worker';
+ * ```
+ *
+ * ```ts
+ * createSharedStore('cart', {
+ *   transport: new SharedWorkerTransport({
+ *     url: new URL('./sw-relay.js', import.meta.url),
+ *   }),
+ * });
+ * ```
+ */
+declare class SharedWorkerTransport implements Transport {
+    readonly kind: TransportKind;
+    private port;
+    private listeners;
+    private onMessage;
+    private closed;
+    constructor(options: SharedWorkerTransportOptions);
+    post(data: unknown): void;
+    subscribe(listener: (data: unknown) => void): () => void;
+    close(): void;
+}
+/**
+ * Whether this context can construct a SharedWorker at all.
+ *
+ * Notably false in every dedicated worker (they cannot nest a SharedWorker) and
+ * in Chrome on Android. Worth checking before choosing this transport, since
+ * the constructor throws rather than degrading.
+ */
+declare function isSharedWorkerAvailable(): boolean;
+
 declare function isBroadcastChannelAvailable(): boolean;
 /**
  * Can we hear other tabs through the `storage` event?
@@ -1111,4 +1203,4 @@ declare function isStorageEventAvailable(): boolean;
  */
 declare function defaultTransport(name: string): Transport;
 
-export { type AskOptions, BroadcastChannelTransport, type BusEvent, type BusObserver, type BusWire, CID_PARAM, type Channel, type ChannelOptions, type CommonOptions, type ConnectToOpenerOptions, DEFAULT_NAME, type DebugOptions, HandshakeTimeoutError, type IndexedDbAdapterOptions, type InvalidPayload, type Leader, type LeaderOptions, type LeaderSnapshot, type LeaderStrategy, type LockManagerLike, type MessageEventLike, type MessageMap, type MessageMeta, type Namespace, NoopTransport, type OnInvalid, type OnOptions, type OpenWindowOptions, type OpenedWindow, type OpenerConnection, type Peer, type PeerKind, type PersistAdapter, type PersistOptions, type Persisted, type PostOptions, type Presence, type PresenceOptions, type ReplyMap, type RestoreError, type SchemaMap, type SchemaOptions, type Serializer, type SharedReducer, type SharedReducerOptions, type SharedStore, type SharedStoreOptions, type StandardSchemaV1, type StorageLike, StorageTransport, Transport, TransportKind, type Version, WIRE_VERSION, type WebStorageAdapterOptions, WindowClosedError, type WindowEventTarget, type WindowLike, connectToOpener, createChannel, createLeader, createNamespace, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter };
+export { type AskOptions, BroadcastChannelTransport, type BusEvent, type BusObserver, type BusWire, CID_PARAM, type Channel, type ChannelOptions, type CommonOptions, type ConnectToOpenerOptions, DEFAULT_NAME, type DebugOptions, HandshakeTimeoutError, type IndexedDbAdapterOptions, type InvalidPayload, type Leader, type LeaderOptions, type LeaderSnapshot, type LeaderStrategy, type LockManagerLike, type MessageEventLike, type MessageMap, type MessageMeta, type MessagePortLike, type Namespace, NoopTransport, type OnInvalid, type OnOptions, type OpenWindowOptions, type OpenedWindow, type OpenerConnection, type Peer, type PeerKind, type PersistAdapter, type PersistOptions, type Persisted, type PostOptions, type Presence, type PresenceOptions, type ReplyMap, type RestoreError, type SchemaMap, type SchemaOptions, type Serializer, type SharedReducer, type SharedReducerOptions, type SharedStore, type SharedStoreOptions, type SharedWorkerLike, SharedWorkerTransport, type SharedWorkerTransportOptions, type StandardSchemaV1, type StorageLike, StorageTransport, Transport, TransportKind, type Version, WIRE_VERSION, type WebStorageAdapterOptions, WindowClosedError, type WindowEventTarget, type WindowLike, connectToOpener, createChannel, createLeader, createNamespace, createPresence, createSharedReducer, createSharedStore, defaultTransport, enableDebug, getBusNames, getTransportKind, getWireSkew, indexedDbAdapter, isBroadcastChannelAvailable, isSharedWorkerAvailable, isStorageEventAvailable, jsonSerializer, localStorageAdapter, newer, observeBus, openWindow, sessionStorageAdapter, webStorageAdapter };

package/dist/index.js

@@ -994,12 +994,14 @@ function createWebLocksLeader(name, options, locks) {
     if (closed || !eligible || releaseHeld || pending) return;
     const controller = new AbortController();
     pending = controller;
+    let grant;
     const held = new Promise((resolve) => {
-      releaseHeld = resolve;
+      grant = resolve;
     });
     void locks.request(name, { signal: controller.signal }, async () => {
       pending = null;
       if (closed || !eligible) return;
+      releaseHeld = grant;
       setLeader(clientId);
       announce2();
       await held;
@@ -1835,12 +1837,49 @@ function createNamespace(namespace) {
     createLeader: (name, options) => createLeader(busName(name), options)
   };
 }
+
+// src/transport/shared-worker-transport.ts
+var SharedWorkerTransport = class {
+  constructor(options) {
+    this.kind = "shared-worker";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.closed = false;
+    const name = options.name ?? "use-everywhere";
+    const factory = options.factory ?? ((url, workerName) => new SharedWorker(url, { name: workerName }));
+    const worker = factory(String(options.url), name);
+    this.port = worker.port;
+    this.onMessage = (event) => {
+      for (const listener of this.listeners) listener(event.data);
+    };
+    this.port.addEventListener("message", this.onMessage);
+    this.port.start?.();
+  }
+  post(data) {
+    if (this.closed) return;
+    this.port.postMessage(data);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.listeners.clear();
+    this.port.removeEventListener("message", this.onMessage);
+    this.port.close();
+  }
+};
+function isSharedWorkerAvailable() {
+  return typeof SharedWorker !== "undefined";
+}
 export {
   BroadcastChannelTransport,
   CID_PARAM,
   DEFAULT_NAME,
   HandshakeTimeoutError,
   NoopTransport,
+  SharedWorkerTransport,
   StorageTransport,
   WIRE_VERSION,
   WindowClosedError,
@@ -1858,6 +1897,7 @@ export {
   getWireSkew,
   indexedDbAdapter,
   isBroadcastChannelAvailable,
+  isSharedWorkerAvailable,
   isStorageEventAvailable,
   jsonSerializer,
   localStorageAdapter,

package/dist/shared-worker.cjs

@@ -0,0 +1,53 @@
+"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/shared-worker.ts
+var shared_worker_exports = {};
+__export(shared_worker_exports, {
+  startRelay: () => startRelay
+});
+module.exports = __toCommonJS(shared_worker_exports);
+function startRelay(scope) {
+  const ports = /* @__PURE__ */ new Set();
+  scope.onconnect = (event) => {
+    const port = event.ports[0];
+    if (!port) return;
+    ports.add(port);
+    port.addEventListener("message", (message) => {
+      const dead = [];
+      for (const peer of ports) {
+        if (peer === port) continue;
+        try {
+          peer.postMessage(message.data);
+        } catch {
+          dead.push(peer);
+        }
+      }
+      for (const corpse of dead) ports.delete(corpse);
+    });
+    port.start?.();
+  };
+}
+if (typeof self !== "undefined" && "onconnect" in self) {
+  startRelay(self);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startRelay
+});

package/dist/shared-worker.d.cts

@@ -0,0 +1,46 @@
+/**
+ * The relay that runs *inside* a SharedWorker. Host a one-line module and point
+ * `SharedWorkerTransport` at it:
+ *
+ * ```js
+ * // sw-relay.js
+ * import '@use-everywhere/core/shared-worker';
+ * ```
+ *
+ * Importing this module installs the `connect` handler, which is why the entry
+ * point is a side effect rather than a function you call: a SharedWorker script
+ * has one job, and making the caller remember to invoke it adds a way to get a
+ * worker that accepts connections and forwards nothing.
+ *
+ * `startRelay` is exported anyway, for a worker that also does other work — an
+ * app whose relay owns the WebSocket, say — and for tests, which cannot install
+ * a global `onconnect`.
+ */
+interface RelayPort {
+    postMessage(data: unknown): void;
+    start?: () => void;
+    addEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+}
+interface RelayScope {
+    onconnect: ((event: {
+        ports: readonly RelayPort[];
+    }) => void) | null;
+}
+/**
+ * Fan every message out to the other connected ports.
+ *
+ * Two properties the buses above this depend on:
+ *
+ * 1. **No self-echo.** A sender never receives its own message, matching
+ *    BroadcastChannel exactly. Without it every store would apply its own
+ *    writes twice and every presence roster would count each tab as two.
+ * 2. **A dead port is dropped, not thrown over.** A tab that goes away without
+ *    closing its port leaves an entangled port whose `postMessage` throws; one
+ *    of those must not stop delivery to the tabs still listening, so the send
+ *    loop is individually guarded and the corpse is pruned.
+ */
+declare function startRelay(scope: RelayScope): void;
+
+export { type RelayPort, type RelayScope, startRelay };

package/dist/shared-worker.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The relay that runs *inside* a SharedWorker. Host a one-line module and point
+ * `SharedWorkerTransport` at it:
+ *
+ * ```js
+ * // sw-relay.js
+ * import '@use-everywhere/core/shared-worker';
+ * ```
+ *
+ * Importing this module installs the `connect` handler, which is why the entry
+ * point is a side effect rather than a function you call: a SharedWorker script
+ * has one job, and making the caller remember to invoke it adds a way to get a
+ * worker that accepts connections and forwards nothing.
+ *
+ * `startRelay` is exported anyway, for a worker that also does other work — an
+ * app whose relay owns the WebSocket, say — and for tests, which cannot install
+ * a global `onconnect`.
+ */
+interface RelayPort {
+    postMessage(data: unknown): void;
+    start?: () => void;
+    addEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+}
+interface RelayScope {
+    onconnect: ((event: {
+        ports: readonly RelayPort[];
+    }) => void) | null;
+}
+/**
+ * Fan every message out to the other connected ports.
+ *
+ * Two properties the buses above this depend on:
+ *
+ * 1. **No self-echo.** A sender never receives its own message, matching
+ *    BroadcastChannel exactly. Without it every store would apply its own
+ *    writes twice and every presence roster would count each tab as two.
+ * 2. **A dead port is dropped, not thrown over.** A tab that goes away without
+ *    closing its port leaves an entangled port whose `postMessage` throws; one
+ *    of those must not stop delivery to the tabs still listening, so the send
+ *    loop is individually guarded and the corpse is pruned.
+ */
+declare function startRelay(scope: RelayScope): void;
+
+export { type RelayPort, type RelayScope, startRelay };

package/dist/shared-worker.js

@@ -0,0 +1,28 @@
+// src/shared-worker.ts
+function startRelay(scope) {
+  const ports = /* @__PURE__ */ new Set();
+  scope.onconnect = (event) => {
+    const port = event.ports[0];
+    if (!port) return;
+    ports.add(port);
+    port.addEventListener("message", (message) => {
+      const dead = [];
+      for (const peer of ports) {
+        if (peer === port) continue;
+        try {
+          peer.postMessage(message.data);
+        } catch {
+          dead.push(peer);
+        }
+      }
+      for (const corpse of dead) ports.delete(corpse);
+    });
+    port.start?.();
+  };
+}
+if (typeof self !== "undefined" && "onconnect" in self) {
+  startRelay(self);
+}
+export {
+  startRelay
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@use-everywhere/core",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Cross-tab shared state, events, presence, and cross-origin window channels",
   "license": "MIT",
   "author": "Jonatan Kruszewski <jonakrusze@gmail.com>",
@@ -24,7 +24,10 @@
     "access": "public"
   },
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/shared-worker.js",
+    "./dist/shared-worker.cjs"
+  ],
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -39,6 +42,16 @@
         "default": "./dist/index.cjs"
       }
     },
+    "./shared-worker": {
+      "import": {
+        "types": "./dist/shared-worker.d.ts",
+        "default": "./dist/shared-worker.js"
+      },
+      "require": {
+        "types": "./dist/shared-worker.d.cts",
+        "default": "./dist/shared-worker.cjs"
+      }
+    },
     "./testing": {
       "import": {
         "types": "./dist/testing.d.ts",
@@ -120,6 +133,18 @@
       "import": "{ indexedDbAdapter }",
       "limit": "447 B"
     },
+    {
+      "name": "SharedWorkerTransport",
+      "path": "dist/index.js",
+      "import": "{ SharedWorkerTransport }",
+      "limit": "380 B"
+    },
+    {
+      "name": "SharedWorker relay (shared-worker subpath)",
+      "path": "dist/shared-worker.js",
+      "import": "*",
+      "limit": "280 B"
+    },
     {
       "name": "MemoryHub (testing subpath)",
       "path": "dist/testing.js",
@@ -145,6 +170,9 @@
   },
   "typesVersions": {
     "*": {
+      "shared-worker": [
+        "./dist/shared-worker.d.ts"
+      ],
       "testing": [
         "./dist/testing.d.ts"
       ]