cross-tab-worker-databus 0.20.71 → 0.20.86

package/dist/index.js

@@ -2,33 +2,44 @@ import {
   CrossTabDataBus,
   DEFAULT_MAX_ACTIVE_WORKERS,
   WorkerClusterRuntime,
+  approximatePayloadBytes,
+  assertPositiveFiniteNumber,
+  assertPositiveSafeInteger,
+  assertPruneStrategy,
   createBrowserEnvironment,
   createOpaqueKey,
+  createStorageEventChannel,
+  effectiveWorkerLoad,
   getOrCreateTabId,
   hasActiveOwner,
   isWildcardTopic,
   parseDataBusPublication,
+  pruneReplayHistory,
   selectActiveWorkers,
   selectLeastLoadedWorker,
   selectRebalanceTarget,
   selectWorkerBackend,
   topicMatchesPattern
-} from "./chunk-D2SIT473.js";
+} from "./chunk-SDOV3UHG.js";
+import {
+  DEFAULT_STORAGE_PREFIX,
+  PRUNE_STRATEGY,
+  WORKER_STATUS,
+  WS_OP
+} from "./chunk-TZ7ZP7YD.js";
 
 // src/core/replay-persistence.ts
 function createIndexedDbReplayPersistence(options) {
   const indexedDb = globalThis.indexedDB;
   if (!indexedDb) throw new Error("IndexedDB is unavailable in this environment.");
-  const dbName = options.dbName ?? "cross-tab-worker-databus";
+  const dbName = options.dbName ?? DEFAULT_STORAGE_PREFIX;
   const storeName = "replay";
   const maxPerTopic = options.maxPerTopic;
-  const pruneStrategy = options.pruneStrategy ?? "count";
+  const pruneStrategy = options.pruneStrategy ?? PRUNE_STRATEGY.COUNT;
   const retentionMs = options.retentionMs;
-  if (!["count", "age", "both"].includes(pruneStrategy)) throw new TypeError("pruneStrategy must be count, age, or both.");
-  if (retentionMs !== void 0 && (!Number.isFinite(retentionMs) || retentionMs <= 0)) throw new TypeError("retentionMs must be a positive finite number.");
-  if (!Number.isSafeInteger(maxPerTopic) || maxPerTopic <= 0) {
-    throw new TypeError(`maxPerTopic must be a positive safe integer, got ${String(maxPerTopic)}.`);
-  }
+  assertPruneStrategy(pruneStrategy);
+  if (retentionMs !== void 0) assertPositiveFiniteNumber(retentionMs, "retentionMs");
+  assertPositiveSafeInteger(maxPerTopic, "maxPerTopic");
   let dbPromise = null;
   const invalidate = (db) => {
     if (dbPromise) {
@@ -40,15 +51,94 @@ function createIndexedDbReplayPersistence(options) {
       }, () => void 0);
     }
   };
-  let mutationQueue = Promise.resolve();
-  const serializeMutation = (mutation) => {
-    const next = mutationQueue.then(mutation, mutation);
-    mutationQueue = next.catch(() => void 0);
-    return next;
+  const pending = [];
+  let draining = false;
+  const drain = async () => {
+    if (draining) return;
+    draining = true;
+    try {
+      await Promise.resolve();
+      while (pending.length > 0) {
+        const head = pending[0].mutation;
+        if (head.kind === "batch") {
+          const merged = [];
+          const entries = [];
+          while (pending.length > 0) {
+            const next = pending[0].mutation;
+            if (next.kind !== "batch") break;
+            merged.push(...next.messages);
+            entries.push({ resolve: pending[0].resolve, reject: pending[0].reject });
+            pending.shift();
+          }
+          try {
+            await appendTransaction(merged);
+            for (const entry of entries) entry.resolve();
+          } catch (error) {
+            for (const entry of entries) entry.reject(error);
+          }
+        } else {
+          const entry = pending.shift();
+          try {
+            await head.run();
+            entry.resolve();
+          } catch (error) {
+            entry.reject(error);
+          }
+        }
+      }
+    } finally {
+      draining = false;
+    }
   };
+  const enqueue = (mutation) => new Promise((resolve, reject) => {
+    pending.push({ mutation, resolve, reject });
+    void drain();
+  });
+  const appendTransaction = (messages) => (async () => {
+    const db = await open();
+    return new Promise((resolve, reject) => {
+      let transaction;
+      try {
+        transaction = db.transaction(storeName, "readwrite");
+      } catch (error) {
+        invalidate(db);
+        reject(error);
+        return;
+      }
+      const store = transaction.objectStore(storeName);
+      const grouped = /* @__PURE__ */ new Map();
+      for (const message of messages) {
+        grouped.set(message.topic, [...grouped.get(message.topic) ?? [], message]);
+      }
+      let hasError = false;
+      const fail = (error) => {
+        if (hasError) return;
+        hasError = true;
+        invalidate(db);
+        reject(error);
+      };
+      for (const [topic, topicMessages] of grouped) {
+        const request = store.get(topic);
+        request.onsuccess = () => {
+          if (hasError) return;
+          const history = pruneReplayHistory(
+            (request.result?.messages ?? []).concat(topicMessages),
+            { maxPerTopic, pruneStrategy, retentionMs, now: Date.now() }
+          );
+          store.put({ topic, messages: history });
+        };
+        request.onerror = () => fail(request.error ?? new Error("Failed to read replay history."));
+      }
+      transaction.oncomplete = () => {
+        if (!hasError) resolve();
+      };
+      transaction.onerror = () => fail(transaction.error ?? new Error("Failed to persist replay history."));
+      transaction.onabort = () => fail(transaction.error ?? new Error("Failed to persist replay history."));
+    });
+  })();
   const open = () => {
     if (dbPromise) return dbPromise;
-    const pending = new Promise((resolve, reject) => {
+    const pending2 = new Promise((resolve, reject) => {
       const request = indexedDb.open(dbName, 1);
       request.onupgradeneeded = () => request.result.createObjectStore(storeName, { keyPath: "topic" });
       request.onsuccess = () => {
@@ -61,179 +151,156 @@ function createIndexedDbReplayPersistence(options) {
       };
       request.onerror = () => reject(request.error ?? new Error("Failed to open replay database."));
     });
-    dbPromise = pending;
-    void pending.catch(() => {
-      if (dbPromise === pending) dbPromise = null;
+    dbPromise = pending2;
+    void pending2.catch(() => {
+      if (dbPromise === pending2) dbPromise = null;
     });
-    return pending;
+    return pending2;
   };
   return {
     async load() {
       const db = await open();
       return new Promise((resolve, reject) => {
+        let transaction;
         let request;
         try {
-          request = db.transaction(storeName, "readonly").objectStore(storeName).getAll();
+          transaction = db.transaction(storeName, "readonly");
+          request = transaction.objectStore(storeName).getAll();
         } catch (error) {
           invalidate(db);
           reject(error);
           return;
         }
-        request.onsuccess = () => resolve(request.result.flatMap((record) => record.messages));
-        request.onerror = () => {
+        let settled = false;
+        const fail = (error) => {
+          if (settled) return;
+          settled = true;
           invalidate(db);
-          reject(request.error ?? new Error("Failed to load replay history."));
+          reject(error);
         };
+        let records = [];
+        request.onsuccess = () => {
+          records = request.result;
+        };
+        request.onerror = () => fail(request.error ?? new Error("Failed to load replay history."));
+        transaction.oncomplete = () => {
+          if (settled) return;
+          settled = true;
+          resolve(records.flatMap((record) => record.messages));
+        };
+        transaction.onabort = () => fail(transaction.error ?? new Error("Failed to load replay history."));
       });
     },
     append(message) {
-      return serializeMutation(async () => {
-        const db = await open();
-        await new Promise((resolve, reject) => {
-          let transaction;
-          try {
-            transaction = db.transaction(storeName, "readwrite");
-          } catch (error) {
-            invalidate(db);
-            reject(error);
-            return;
-          }
-          const store = transaction.objectStore(storeName);
-          const request = store.get(message.topic);
-          request.onsuccess = () => {
-            let messages = (request.result?.messages ?? []).concat(message);
-            if (pruneStrategy !== "count" && retentionMs !== void 0) {
-              const cutoff = Date.now() - retentionMs;
-              messages = messages.filter((item) => item.timestamp === void 0 || item.timestamp >= cutoff);
-            }
-            if (pruneStrategy !== "age") messages = messages.slice(-maxPerTopic);
-            store.put({ topic: message.topic, messages });
-          };
-          request.onerror = () => {
-            invalidate(db);
-            reject(request.error ?? new Error("Failed to read replay history."));
-          };
-          transaction.oncomplete = () => resolve();
-          transaction.onerror = () => {
-            invalidate(db);
-            reject(transaction.error ?? new Error("Failed to persist replay history."));
-          };
-        });
-      });
+      return enqueue({ kind: "batch", messages: [message] });
     },
     appendBatch(messages) {
       if (messages.length === 0) return Promise.resolve();
-      return serializeMutation(async () => {
-        const db = await open();
-        await new Promise((resolve, reject) => {
-          let transaction;
-          try {
-            transaction = db.transaction(storeName, "readwrite");
-          } catch (error) {
-            invalidate(db);
-            reject(error);
-            return;
-          }
-          const store = transaction.objectStore(storeName);
-          const grouped = /* @__PURE__ */ new Map();
-          for (const message of messages) grouped.set(message.topic, [...grouped.get(message.topic) ?? [], message]);
-          for (const [topic, topicMessages] of grouped) {
-            const request = store.get(topic);
-            request.onsuccess = () => {
-              let history = (request.result?.messages ?? []).concat(topicMessages);
-              if (pruneStrategy !== "count" && retentionMs !== void 0) {
-                const cutoff = Date.now() - retentionMs;
-                history = history.filter((item) => item.timestamp === void 0 || item.timestamp >= cutoff);
-              }
-              if (pruneStrategy !== "age") history = history.slice(-maxPerTopic);
-              store.put({ topic, messages: history });
-            };
-            request.onerror = () => {
-              invalidate(db);
-              reject(request.error ?? new Error("Failed to read replay history."));
-            };
-          }
-          transaction.oncomplete = () => resolve();
-          transaction.onerror = () => {
-            invalidate(db);
-            reject(transaction.error ?? new Error("Failed to persist replay history batch."));
-          };
-        });
-      });
+      return enqueue({ kind: "batch", messages });
     },
     clear() {
-      return serializeMutation(async () => {
-        const db = await open();
-        await new Promise((resolve, reject) => {
-          let transaction;
-          try {
-            transaction = db.transaction(storeName, "readwrite");
-          } catch (error) {
-            invalidate(db);
-            reject(error);
-            return;
-          }
-          transaction.objectStore(storeName).clear();
-          transaction.oncomplete = () => resolve();
-          transaction.onerror = () => {
-            invalidate(db);
-            reject(transaction.error ?? new Error("Failed to clear replay history."));
-          };
-        });
+      return enqueue({
+        kind: "run",
+        run: () => (async () => {
+          const db = await open();
+          return new Promise((resolve, reject) => {
+            let transaction;
+            try {
+              transaction = db.transaction(storeName, "readwrite");
+            } catch (error) {
+              invalidate(db);
+              reject(error);
+              return;
+            }
+            let settled = false;
+            const fail = (error) => {
+              if (settled) return;
+              settled = true;
+              invalidate(db);
+              reject(error);
+            };
+            transaction.objectStore(storeName).clear();
+            transaction.oncomplete = () => {
+              settled = true;
+              resolve();
+            };
+            transaction.onerror = () => fail(transaction.error ?? new Error("Failed to clear replay history."));
+            transaction.onabort = () => fail(transaction.error ?? new Error("Failed to clear replay history."));
+          });
+        })()
       });
     },
     clearTopic(topic) {
-      return serializeMutation(async () => {
-        const db = await open();
-        await new Promise((resolve, reject) => {
-          let transaction;
-          try {
-            transaction = db.transaction(storeName, "readwrite");
-          } catch (error) {
-            invalidate(db);
-            reject(error);
-            return;
-          }
-          transaction.objectStore(storeName).delete(topic);
-          transaction.oncomplete = () => resolve();
-          transaction.onerror = () => {
-            invalidate(db);
-            reject(transaction.error ?? new Error("Failed to clear topic replay history."));
-          };
-        });
+      return enqueue({
+        kind: "run",
+        run: () => (async () => {
+          const db = await open();
+          return new Promise((resolve, reject) => {
+            let transaction;
+            try {
+              transaction = db.transaction(storeName, "readwrite");
+            } catch (error) {
+              invalidate(db);
+              reject(error);
+              return;
+            }
+            let settled = false;
+            const fail = (error) => {
+              if (settled) return;
+              settled = true;
+              invalidate(db);
+              reject(error);
+            };
+            transaction.objectStore(storeName).delete(topic);
+            transaction.oncomplete = () => {
+              settled = true;
+              resolve();
+            };
+            transaction.onerror = () => fail(transaction.error ?? new Error("Failed to clear topic replay history."));
+            transaction.onabort = () => fail(transaction.error ?? new Error("Failed to clear topic replay history."));
+          });
+        })()
       });
     },
     clearBefore(timestamp) {
-      return serializeMutation(async () => {
-        const db = await open();
-        await new Promise((resolve, reject) => {
-          let transaction;
-          try {
-            transaction = db.transaction(storeName, "readwrite");
-          } catch (error) {
-            invalidate(db);
-            reject(error);
-            return;
-          }
-          const store = transaction.objectStore(storeName);
-          const request = store.getAll();
-          request.onsuccess = () => {
-            for (const record of request.result) {
-              const messages = record.messages.filter((message) => message.timestamp === void 0 || message.timestamp >= timestamp);
-              if (messages.length === 0) store.delete(record.topic);
-              else if (messages.length !== record.messages.length) store.put({ topic: record.topic, messages });
+      return enqueue({
+        kind: "run",
+        run: () => (async () => {
+          const db = await open();
+          return new Promise((resolve, reject) => {
+            let transaction;
+            try {
+              transaction = db.transaction(storeName, "readwrite");
+            } catch (error) {
+              invalidate(db);
+              reject(error);
+              return;
             }
-          };
-          request.onerror = () => {
-            invalidate(db);
-            reject(request.error ?? new Error("Failed to read replay history."));
-          };
-          transaction.oncomplete = () => resolve();
-          transaction.onerror = () => {
-            invalidate(db);
-            reject(transaction.error ?? new Error("Failed to prune replay history."));
-          };
-        });
+            let settled = false;
+            const fail = (error) => {
+              if (settled) return;
+              settled = true;
+              invalidate(db);
+              reject(error);
+            };
+            const store = transaction.objectStore(storeName);
+            const request = store.getAll();
+            request.onsuccess = () => {
+              for (const record of request.result) {
+                const messages = record.messages.filter((message) => message.timestamp === void 0 || message.timestamp >= timestamp);
+                if (messages.length === 0) store.delete(record.topic);
+                else if (messages.length !== record.messages.length) store.put({ topic: record.topic, messages });
+              }
+            };
+            request.onerror = () => fail(request.error ?? new Error("Failed to read replay history."));
+            transaction.oncomplete = () => {
+              settled = true;
+              resolve();
+            };
+            transaction.onerror = () => fail(transaction.error ?? new Error("Failed to prune replay history."));
+            transaction.onabort = () => fail(transaction.error ?? new Error("Failed to prune replay history."));
+          });
+        })()
       });
     }
   };
@@ -245,6 +312,7 @@ var WebSocketTransport = class {
   constructor(connection) {
     this.connection = connection;
   }
+  connection;
   diagnosticsName = "websocket";
   diagnosticsBackend = "native-websocket";
   socket = null;
@@ -261,22 +329,22 @@ var WebSocketTransport = class {
     try {
       socket = factory(config.url, protocols);
     } catch (error) {
-      handlers.onStatus("error");
+      handlers.onStatus(WORKER_STATUS.ERROR);
       handlers.onError(error);
       return;
     }
     socket.onopen = () => {
       if (this.socket !== socket || this.handlers !== handlers) return;
       for (const topic of this.subscribedTopics) {
-        this.sendFrame({ op: "subscribe", topic });
+        this.sendFrame({ op: WS_OP.SUBSCRIBE, topic });
       }
-      handlers.onStatus("connected");
+      handlers.onStatus(WORKER_STATUS.CONNECTED);
     };
     socket.onclose = () => {
-      if (this.socket === socket && this.handlers === handlers) handlers.onStatus("disconnected");
+      if (this.socket === socket && this.handlers === handlers) handlers.onStatus(WORKER_STATUS.DISCONNECTED);
     };
     socket.onerror = () => {
-      if (this.socket === socket && this.handlers === handlers) handlers.onStatus("error");
+      if (this.socket === socket && this.handlers === handlers) handlers.onStatus(WORKER_STATUS.ERROR);
     };
     socket.onmessage = (event) => {
       if (this.socket === socket && this.handlers === handlers) void this.handleMessage(event.data);
@@ -287,12 +355,12 @@ var WebSocketTransport = class {
    * not duplicate the local tracking entry. */
   subscribe(topic) {
     this.subscribedTopics.add(topic);
-    this.sendFrame({ op: "subscribe", topic });
+    this.sendFrame({ op: WS_OP.SUBSCRIBE, topic });
   }
   /** Idempotent: unsubscribing an unknown topic is a no-op. */
   unsubscribe(topic) {
     this.subscribedTopics.delete(topic);
-    this.sendFrame({ op: "unsubscribe", topic });
+    this.sendFrame({ op: WS_OP.UNSUBSCRIBE, topic });
   }
   /** Publish `data` to `topic` as a JSON frame. Requires an open socket. */
   publish(topic, data, options) {
@@ -301,13 +369,39 @@ var WebSocketTransport = class {
       return;
     }
     this.sendFrame({
-      op: "publish",
+      op: WS_OP.PUBLISH,
       topic,
       data,
       ...options?.messageId === void 0 ? {} : { messageId: options.messageId },
       ...options?.timestamp === void 0 ? {} : { timestamp: options.timestamp }
     });
   }
+  /** Publish many items for one topic as a single wire frame. One-item
+   * batches delegate to `publish` so the legacy single-publication frame
+   * shape (including binary framing) is preserved. */
+  publishBatch(topic, items) {
+    if (items.length === 0) return;
+    if (items.length === 1) {
+      const single = items[0];
+      return this.publish(topic, single.data, {
+        ...single.messageId === void 0 ? {} : { messageId: single.messageId },
+        ...single.timestamp === void 0 ? {} : { timestamp: single.timestamp }
+      });
+    }
+    if (this.socket?.readyState !== WS_OPEN) {
+      this.handlers?.onError(new Error('WebSocket is not open; dropped "publishBatch" frame.'));
+      return;
+    }
+    this.socket.send(JSON.stringify({
+      op: WS_OP.PUBLISH_BATCH,
+      topic,
+      items: items.map((item) => ({
+        data: item.data instanceof ArrayBuffer ? Array.from(new Uint8Array(item.data)) : item.data,
+        ...item.messageId === void 0 ? {} : { messageId: item.messageId },
+        ...item.timestamp === void 0 ? {} : { timestamp: item.timestamp }
+      }))
+    }));
+  }
   /** Close the socket and drop all state. Safe to call multiple times. */
   stop() {
     const socket = this.socket;
@@ -329,7 +423,7 @@ var WebSocketTransport = class {
   sendBinaryFrame(topic, data, messageId, timestamp) {
     if (messageId !== void 0 || timestamp !== void 0) {
       this.sendFrame({
-        op: "publish",
+        op: WS_OP.PUBLISH,
         topic,
         data: Array.from(new Uint8Array(data)),
         ...messageId === void 0 ? {} : { messageId },
@@ -409,10 +503,13 @@ export {
   DEFAULT_MAX_ACTIVE_WORKERS,
   WebSocketTransport,
   WorkerClusterRuntime,
+  approximatePayloadBytes,
   createBrowserEnvironment,
   createIndexedDbReplayPersistence,
   createOpaqueKey,
+  createStorageEventChannel,
   createWebSocketDataBus,
+  effectiveWorkerLoad,
   getOrCreateTabId,
   hasActiveOwner,
   isWildcardTopic,