cross-tab-worker-databus 0.20.93 → 0.20.95

package/dist/cjs/centrifuge.cjs

@@ -184,6 +184,7 @@ function createStorageEventChannel(options) {
   if (!storage || !win) return null;
   const key = `${STORAGE_CHANNEL_PREFIX}${name}`;
   const listeners = /* @__PURE__ */ new Set();
+  const senderId = randomId();
   let sequence = 0;
   const onStorage = (event) => {
     if (event.key !== key || event.newValue === null) return;
@@ -196,7 +197,12 @@ function createStorageEventChannel(options) {
       return;
     }
     const event_ = { data: message };
-    for (const listener of [...listeners]) listener(event_);
+    for (const listener of [...listeners]) {
+      try {
+        listener(event_);
+      } catch {
+      }
+    }
   };
   win.addEventListener("storage", onStorage);
   let closed = false;
@@ -210,7 +216,7 @@ function createStorageEventChannel(options) {
     postMessage(message) {
       if (closed) return;
       sequence += 1;
-      storage.setItem(key, JSON.stringify({ seq: sequence, message }));
+      storage.setItem(key, JSON.stringify({ senderId, seq: sequence, message }));
     },
     close() {
       closed = true;
@@ -536,11 +542,11 @@ var BatchingStorageWriter = class {
     if (typeof queueMicrotask === "function") queueMicrotask(flush);
     else setTimeout(flush, 0);
   }
-  // Schedule a single retry timer. The guard ensures only one retry is in
-  // flight at a time; subsequent scheduleRetry calls during the wait are
-  // no-ops because the first retry will re-flush all pending keys together.
+  // Arm the single backoff timer for the pass that just failed. Exactly one
+  // retry can be in flight because flush() — the only caller — cancels any
+  // armed retry on entry and stops at the first failing key, so this always
+  // runs with `retryHandle` cleared.
   scheduleRetry() {
-    if (this.retryHandle !== null) return;
     this.retryHandle = setTimeout(() => {
       this.retryHandle = null;
       this.flush();
@@ -741,9 +747,8 @@ var WorkerClusterRuntime = class {
   touchRouteOwnerCache(topicKey, value) {
     if (this.routeOwnerCache.has(topicKey)) this.routeOwnerCache.delete(topicKey);
     this.routeOwnerCache.set(topicKey, value);
-    while (this.routeOwnerCache.size > this.routeOwnerCacheMax) {
-      const oldest = this.routeOwnerCache.keys().next().value;
-      if (oldest === void 0) break;
+    for (const oldest of this.routeOwnerCache.keys()) {
+      if (this.routeOwnerCache.size <= this.routeOwnerCacheMax) break;
       this.routeOwnerCache.delete(oldest);
     }
   }
@@ -2401,9 +2406,8 @@ var DedupManager = class {
     this.accepted += 1;
     this.windowAccepted += 1;
     this.trace.recordDedupAccepted();
-    while (this.seenMessageIds.size > this.maxEntries) {
-      const oldest = this.seenMessageIds.keys().next().value;
-      if (oldest === void 0) break;
+    for (const oldest of this.seenMessageIds.keys()) {
+      if (this.seenMessageIds.size <= this.maxEntries) break;
       this.seenMessageIds.delete(oldest);
     }
     return false;
@@ -2464,7 +2468,7 @@ var DedupManager = class {
 };
 
 // src/core/version.ts
-var SDK_VERSION = true ? "0.20.93" : "";
+var SDK_VERSION = true ? "0.20.95" : "";
 
 // src/core/data-bus.ts
 var DEFAULT_REPLAY_MAX_PER_TOPIC = 100;
@@ -3920,12 +3924,13 @@ var CentrifugeWorkerTransport = class {
   heartbeatHandle = null;
   localSession = null;
   handlers = null;
-  // Monotonically increasing counter, bumped each time a backend is created.
-  // Used to ignore late error events from a superseded Worker.
+  // Monotonically increasing counter, bumped each time a backend is created or
+  // the transport stops. Only the asynchronous credential bridge compares it:
+  // a provider may settle after the Worker it was answering is gone. Worker
+  // error events need no such check — stop() and onWorkerFailed() remove those
+  // listeners before the generation moves on, so a superseded backend can no
+  // longer reach this object at all.
   generation = 0;
-  // Generation captured when the current backend was created. Error handlers
-  // only act when the backend that registered them is still current.
-  backendGeneration = 0;
   get diagnosticsBackend() {
     return this.backend ?? "uninitialized";
   }
@@ -4018,7 +4023,7 @@ var CentrifugeWorkerTransport = class {
   }
   /** Create and initialise a dedicated Worker, then send the INIT message. */
   startDedicatedWorker(input) {
-    this.backendGeneration = ++this.generation;
+    this.generation += 1;
     const worker = (this.workerFactory ?? createDefaultWorker)();
     this.worker = worker;
     worker.addEventListener("message", this.handleMessage);
@@ -4027,7 +4032,7 @@ var CentrifugeWorkerTransport = class {
   }
   /** Create and initialise a SharedWorker, open the MessagePort, and send the INIT message. */
   startSharedWorker(input) {
-    this.backendGeneration = ++this.generation;
+    this.generation += 1;
     const shared = (this.sharedWorkerFactory ?? createDefaultSharedWorker)();
     this.sharedWorker = shared;
     const port = shared.port;
@@ -4097,9 +4102,10 @@ var CentrifugeWorkerTransport = class {
   }
   /** Handle a Worker-level failure (crash, message decode error). Discards the
    * dead backend so a later start()/reopen can rebuild from scratch, and
-   * signals an error status so the DataBus can trigger recovery.
-   * Only invoked when the generation guard confirms the failing backend is
-   * still current — late errors from a superseded Worker are silently dropped. */
+   * signals an error status so the DataBus can trigger recovery. A superseded
+   * backend cannot reach this: its listeners are removed before the transport
+   * moves on, which is what keeps late Worker errors from tearing down a fresh
+   * session (pinned by 'ignores error events from a superseded worker'). */
   onWorkerFailed(message) {
     this.worker?.removeEventListener("message", this.handleMessage);
     this.worker?.removeEventListener("error", this.handleWorkerError);
@@ -4130,15 +4136,12 @@ var CentrifugeWorkerTransport = class {
     this.heartbeatHandle = null;
   }
   handleWorkerError = () => {
-    if (this.generation !== this.backendGeneration) return;
     this.onWorkerFailed("Centrifuge worker failed.");
   };
   handlePortError = () => {
-    if (this.generation !== this.backendGeneration) return;
     this.onWorkerFailed("Centrifuge shared worker message decoding failed.");
   };
   handleSharedWorkerError = () => {
-    if (this.generation !== this.backendGeneration) return;
     this.onWorkerFailed("Centrifuge shared worker failed.");
   };
   /** Clear the Worker/port/backend references after a failure or stop. */