cross-tab-worker-databus 0.20.94 → 0.20.96

package/dist/cjs/centrifuge.cjs

@@ -542,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();
@@ -747,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);
     }
   }
@@ -2407,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;
@@ -2470,7 +2468,7 @@ var DedupManager = class {
 };
 
 // src/core/version.ts
-var SDK_VERSION = true ? "0.20.94" : "";
+var SDK_VERSION = true ? "0.20.96" : "";
 
 // src/core/data-bus.ts
 var DEFAULT_REPLAY_MAX_PER_TOPIC = 100;
@@ -2561,6 +2559,10 @@ var CrossTabDataBus = class {
   // themselves demand: the failure path starts an on-demand reopen instead of
   // stranding them until some unrelated future operation arrives.
   recoveryWaiters = 0;
+  // Latch for the empty-topic deprecation warning so a hot publish path cannot
+  // fill the console. It is per-bus and never reset: the warning is about the
+  // caller's code, not about a transient runtime condition.
+  emptyTopicWarned = false;
   /** Monotonic generation incremented on every successful transport open.
    * Stays in lockstep with `lastSuccessAt` so callers can detect that the
    * transport has been reopened even if the timestamp window is short. */
@@ -2965,6 +2967,7 @@ var CrossTabDataBus = class {
       };
     }
     this.ensureStarted();
+    if (topic === "") this.warnEmptyTopic("subscribe");
     const handlers = this.topicHandlers.get(topic) ?? /* @__PURE__ */ new Set();
     const wasUnused = handlers.size === 0;
     handlers.add(handler);
@@ -3014,8 +3017,20 @@ var CrossTabDataBus = class {
   resetDedup() {
     this.dedupManager.reset();
   }
+  /** Warn (once per bus) that an empty topic is deprecated, without changing
+   * behavior yet. `''` flows through routing as a literal channel, so the
+   * subscription it creates can never be addressed by a transport: the message
+   * silently goes nowhere. A future minor rejects it at this boundary. */
+  warnEmptyTopic(operation) {
+    if (this.emptyTopicWarned) return;
+    this.emptyTopicWarned = true;
+    console.warn(
+      `cross-tab-worker-databus: ${operation}("") addresses a channel no transport can route. Use a non-empty topic; passing "" is planned to throw in a future minor.`
+    );
+  }
   /** Publish a message to `topic`. The owning Worker delivers it to the transport. */
   publish(topic, data, options) {
+    if (topic === "") this.warnEmptyTopic("publish");
     this.ensureStarted();
     if (this.rejectPublishDuringStop("publish")) return;
     if (!this.cluster.publish(topic, data, options)) {
@@ -3034,6 +3049,7 @@ var CrossTabDataBus = class {
   publishBatch(topic, items) {
     this.ensureStarted();
     if (items.length === 0) return;
+    if (topic === "") this.warnEmptyTopic("publishBatch");
     if (this.rejectPublishDuringStop("publishBatch")) return;
     if (items.length === 1) {
       const first = items[0];
@@ -3926,12 +3942,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";
   }
@@ -4024,7 +4041,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);
@@ -4033,7 +4050,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;
@@ -4103,9 +4120,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);
@@ -4136,15 +4154,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. */