cross-tab-worker-databus 0.20.87 → 0.20.88

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.20.88] - 2026-09-16
+
+### Fixed
+- A transport that reports `error` synchronously during startup now lets `start()` retry from either the startup-failure `onStatus` callback or the startup-failure `onError` callback. The internal status is updated immediately, but the user-facing `onStatus('error')` notification is deferred until the failed open has cleared `transportReady`, torn down the initial cluster, installed the transport stop gate, recorded the failure, and cleared `startPromise`. The retry therefore opens a fresh lifecycle after cleanup and resets the failure ledger; the superseded opening's rejection is consumed by that lifecycle path and cannot repopulate the ledger after the retry succeeds.
+- A synchronous `start()` retry issued from the startup-failure `onError` callback now opens a fresh lifecycle instead of returning the same rejecting open. `openTransport()` previously notified error handlers before clearing `startPromise`, so the retry shared the failed promise and never called `transport.start()` again. The failed open is now fully torn down and its lifecycle gate cleared before failure notification, and the retry is chained after the failed transport's stop cleanup.
+- A bus whose initial transport open is still pending now recovers from repeated BFCache `pagehide`/`pageshow` cycles. Each suspend used to return early whenever a `pendingStop` gate existed, but a queued resume opening could already sit behind an older stop gate, so `startPromise` and `pendingStop` stopped being the same promise; the next `pageshow` then reused that superseded opening and the bus stayed suspended forever. `suspendTransport()` now reuses the gate only when it still represents this suspend, and otherwise chains a fresh serial `transport.stop()` that restores the `startPromise === pendingStop` invariant, so the following reopen actually restarts the transport.
+- An explicit `start()` that resumes a BFCache-suspended bus now also resumes cross-tab coordination. `pagehide` pauses the bus *and* the `WorkerClusterRuntime` (closing the channel, stopping the heartbeat, releasing route assignments), but the started `start()` fast path only cleared `suspended` and reopened the transport, leaving `cluster.suspended` true. The bus then reported a healthy transport while every publication arriving from a peer tab was discarded by `isAssigned()` against the cleared assignment map, until a later `pageshow` happened to fire. `start()` now resumes the cluster whenever it is taking the bus out of suspension, so an explicit resume restores the full coordination plane.
+- An explicit `start()` that resumes a BFCache-suspended bus now restarts every resource paused by `pagehide`, not only the transport and cluster. Trace metrics, the dedup expiry sweep, and replay retention cleanup were stopped by `onSuspend()`, while the native `pageshow` path restarted them through `onResume()`; the explicit resume bypassed that callback and could leave all three timers permanently off for the rest of a `healthy` session. Both resume paths now share one lifecycle helper.
+
 ## [0.20.87] - 2026-09-16
 
 ### Fixed

package/dist/centrifuge.js

@@ -5,7 +5,7 @@ import {
   parseDataBusPublication,
   publicationMetadata,
   selectWorkerBackend
-} from "./chunk-ZNHJ5OMY.js";
+} from "./chunk-4UOLOWOD.js";
 import {
   CENTRIFUGE_INPUT_TYPE,
   CENTRIFUGE_OUTPUT_TYPE,

package/dist/{chunk-ZNHJ5OMY.js → chunk-4UOLOWOD.js}

@@ -2203,7 +2203,7 @@ var DedupManager = class {
 };
 
 // src/core/version.ts
-var SDK_VERSION = true ? "0.20.87" : "";
+var SDK_VERSION = true ? "0.20.88" : "";
 
 // src/core/data-bus.ts
 var DEFAULT_REPLAY_MAX_PER_TOPIC = 100;
@@ -2397,10 +2397,7 @@ var CrossTabDataBus = class {
           this.suspendTransport();
         },
         onResume: () => {
-          this.trace.event({ type: TRACE_EVENT_TYPE.LIFECYCLE, action: TRACE_LIFECYCLE_ACTION.RESUME });
-          this.trace.start();
-          this.startDedupSweep();
-          this.replayManager.start();
+          this.resumeSuspendedResources();
           this.resumeTransport();
         },
         onDiagnostic: (event) => {
@@ -2430,7 +2427,11 @@ var CrossTabDataBus = class {
       if (!transportDown) return Promise.resolve();
       this.activeConfig = config;
       this.resetFailureState();
-      return this.reopenTransport();
+      const resumingFromSuspend = this.suspended;
+      if (resumingFromSuspend) this.resumeSuspendedResources();
+      const opening2 = this.reopenTransport();
+      if (resumingFromSuspend) this.cluster.start();
+      return opening2;
     }
     this.started = true;
     this.stopping = false;
@@ -2553,6 +2554,7 @@ var CrossTabDataBus = class {
     this.transportReady = false;
     const chainedPendingStop = this.pendingStop;
     const isCurrentLifecycle = () => lifecycleEpoch === this.lifecycleEpoch;
+    let startupInProgress = true;
     return before.catch(() => void 0).then(() => {
       if (!isCurrentLifecycle() || this.stopping || this.suspended) return;
       if (this.pendingStop === chainedPendingStop) this.pendingStop = null;
@@ -2563,13 +2565,16 @@ var CrossTabDataBus = class {
             if (isCurrentLifecycle()) this.handleTransportMessage(message);
           },
           onStatus: (status) => {
-            if (isCurrentLifecycle()) this.updateStatus(status);
+            if (isCurrentLifecycle()) {
+              this.updateStatus(status, status !== WORKER_STATUS.ERROR || !startupInProgress);
+            }
           },
           onError: (error) => {
             if (isCurrentLifecycle()) this.reportError(error);
           }
         })
       ).then(() => {
+        startupInProgress = false;
         if (!isCurrentLifecycle()) return;
         if (this.status === WORKER_STATUS.ERROR) {
           throw new Error("Transport failed during startup.");
@@ -2583,18 +2588,21 @@ var CrossTabDataBus = class {
       });
     }).catch((error) => {
       if (!isCurrentLifecycle()) throw error;
+      startupInProgress = false;
       if (stopClusterOnFailure) this.started = false;
       if (!this.pendingStop) {
         this.pendingStop = this.createStopPromise();
       }
       this.transportReady = false;
-      this.updateStatus(WORKER_STATUS.ERROR);
-      this.reportError(error);
       if (stopClusterOnFailure) {
         this.stopping = true;
         this.cluster.stop();
         this.stopping = false;
       }
+      this.recordError(error);
+      this.startPromise = null;
+      this.updateStatus(WORKER_STATUS.ERROR);
+      this.notifyError(error);
       throw error;
     });
   }
@@ -2958,7 +2966,7 @@ var CrossTabDataBus = class {
    * Propagate a status change to the cluster, trace, and all registered
    * status handlers. On reconnect, re-subscribe any topics assigned to us.
    */
-  updateStatus(status) {
+  updateStatus(status, notifyHandlers = true) {
     const previousStatus = this.status;
     this.status = status;
     if (status === WORKER_STATUS.CONNECTED) this.transportHasConnected = true;
@@ -3010,9 +3018,9 @@ var CrossTabDataBus = class {
     } else if (status === WORKER_STATUS.ERROR) {
       this.releaseRecoveryGate();
     }
-    this.invokeHandlers(this.statusHandlers, (handler) => handler(status));
+    if (notifyHandlers) this.invokeHandlers(this.statusHandlers, (handler) => handler(status));
   }
-  reportError(error, source = FAILURE_SOURCE.TRANSPORT) {
+  recordError(error, source = FAILURE_SOURCE.TRANSPORT) {
     const at = this.now();
     if (source === FAILURE_SOURCE.TRANSPORT) {
       this.lastError = error;
@@ -3032,8 +3040,14 @@ var CrossTabDataBus = class {
       type: TRACE_EVENT_TYPE.ERROR,
       source: source === FAILURE_SOURCE.TRANSPORT ? TRACE_ERROR_SOURCE.TRANSPORT : TRACE_ERROR_SOURCE.OPERATION
     });
+  }
+  notifyError(error) {
     this.invokeHandlers(this.errorHandlers, (handler) => handler(error), INVOKE_LABEL.ERROR_HANDLER);
   }
+  reportError(error, source = FAILURE_SOURCE.TRANSPORT) {
+    this.recordError(error, source);
+    this.notifyError(error);
+  }
   /** Report a persistence failure to the trace and the unified failure ledger,
    * unless it is a {@link PersistenceRetryCancelledError} cancellation from a
    * lifecycle transition (teardown should stay quiet). */
@@ -3096,6 +3110,15 @@ var CrossTabDataBus = class {
       }
     }
   }
+  /** Resume the resources paused by a pagehide suspension. Both the native
+   * pageshow path and explicit start() must run this so an explicit resume
+   * cannot leave trace metrics and periodic cleanup timers permanently off. */
+  resumeSuspendedResources() {
+    this.trace.event({ type: TRACE_EVENT_TYPE.LIFECYCLE, action: TRACE_LIFECYCLE_ACTION.RESUME });
+    this.trace.start();
+    this.startDedupSweep();
+    this.replayManager.start();
+  }
   /**
    * Suspend the transport when the tab goes hidden. Stops the transport and
    * clears subscription state so it will be re-established on resume.
@@ -3108,8 +3131,11 @@ var CrossTabDataBus = class {
     this.transportReady = false;
     this.transportSubscribedTopics.clear();
     this.updateStatus(WORKER_STATUS.DISCONNECTED);
-    if (this.pendingStop) return;
-    const pending = this.startPromise ?? Promise.resolve();
+    if (this.pendingStop && (this.startPromise === null || this.startPromise === this.pendingStop)) {
+      this.startPromise = this.pendingStop;
+      return;
+    }
+    const pending = this.startPromise ?? this.pendingStop ?? Promise.resolve();
     const stopping = pending.catch(() => void 0).then(() => this.transport.stop()).catch((error) => this.reportError(error));
     this.startPromise = stopping;
     this.pendingStop = stopping;
@@ -3204,10 +3230,17 @@ var CrossTabDataBus = class {
       ready = this.reopenTransport();
     }
     if (!ready || this.stopping) return;
-    void ready.then(() => {
-      if (!this.started || this.stopping || this.suspended) return;
-      return operation();
-    }).catch((error) => this.reportError(error));
+    void ready.then(
+      () => {
+        if (!this.started || this.stopping || this.suspended) return;
+        return operation();
+      },
+      // The opening promise reports its own lifecycle failure through
+      // openTransport(). Swallowing it here prevents a stale startup
+      // rejection from being recorded again after an onStatus/onError
+      // callback has already started and reset the ledger for a retry.
+      () => void 0
+    ).catch((error) => this.reportError(error));
   }
   /**
    * Publications started after teardown begins cannot reach any transport.
@@ -3302,4 +3335,4 @@ export {
   parseDataBusPublication,
   selectWorkerBackend
 };
-//# sourceMappingURL=chunk-ZNHJ5OMY.js.map
+//# sourceMappingURL=chunk-4UOLOWOD.js.map