cross-tab-worker-databus 0.21.15 → 0.21.17

package/dist/cjs/index.cjs

@@ -1379,6 +1379,7 @@ var WorkerClusterRuntime = class {
   reconcile() {
     if (!this.started) return;
     const workers = this.reconcileWorkers();
+    this.reconcileStrandedSelfRoutes();
     const activeWorkers = selectActiveWorkers(workers, this.maxActiveWorkers);
     this.reconcileSubscriptions(workers, activeWorkers);
     this.reconcileAssignedTopics();
@@ -1443,6 +1444,52 @@ var WorkerClusterRuntime = class {
       }
     }
   }
+  /**
+   * Repair a confirmed route that names this Worker while its assignment is gone.
+   *
+   * Every write that settles ownership stamps the new owner's assignment in the
+   * same task as the confirmation (`confirmRoute()` has exactly three call sites,
+   * each directly after an `assignedTopics.set`), so a route carrying
+   * `confirmedAt` while this map has no entry can only mean the assignment was
+   * taken *after* the route settled. That is what `pause()` does: it clears the
+   * map unconditionally but rewrites only the routes it can hand off, so a
+   * handoff whose final flush is cut short by a storage failure — and the
+   * `discardPending()` that ends the teardown throws the rest away — leaves a
+   * durable route naming this worker. If the same worker id registers again (a
+   * BFCache restore, or a runtime rebuilt with an explicit `workerId`), every
+   * peer reads that route as a live, confirmed owner and stands down, while no
+   * worker holds a transport subscription for the topic any more. Both reconcile
+   * passes miss it by construction: one walks `subscribedTopics`, the other
+   * `assignedTopics`, and the phantom is in neither.
+   *
+   * Acting here is this worker's alone — a peer that elected it is still waiting
+   * for its own CONTROL/SUBSCRIBE to be accepted, and the single-writer rule
+   * recorded in `reconcileSubscriptions()` forbids anyone else rewriting the
+   * record. Reclaim when the local subscription is still live, which restores the
+   * assignment and the transport subscription without touching the route, so the
+   * owner and its generation stay exactly as peers recorded them; release
+   * otherwise, since an owner that has no handler for the topic and never will is
+   * a record nothing can act on.
+   */
+  reconcileStrandedSelfRoutes() {
+    if (!this.storage) return;
+    let released = false;
+    for (const { key, value: route } of readAllByPrefix(this.storage, this.routePrefix)) {
+      if (route.confirmedAt === void 0 || route.workerId !== this.workerId) continue;
+      if (this.assignedTopics.has(route.topicKey)) continue;
+      const topic = this.knownTopics.get(route.topicKey);
+      if (topic !== void 0 && this.subscribedTopics.has(topic)) {
+        this.sendControl(this.workerId, CONTROL_ACTION.SUBSCRIBE, topic, route.topicKey);
+        continue;
+      }
+      this.removeStorage(key);
+      released = true;
+    }
+    if (released) {
+      this.flushStorage();
+      this.notifyRegistry();
+    }
+  }
   /** Drop assignments where the route no longer points to this worker. */
   reconcileAssignedTopics() {
     for (const [topicKey, topic] of [...this.assignedTopics]) {
@@ -2505,7 +2552,7 @@ var DedupManager = class {
 };
 
 // src/core/version.ts
-var SDK_VERSION = true ? "0.21.15" : "";
+var SDK_VERSION = true ? "0.21.17" : "";
 
 // src/core/data-bus.ts
 var DEFAULT_REPLAY_MAX_PER_TOPIC = 100;
@@ -3456,12 +3503,18 @@ var CrossTabDataBus = class {
   subscribeTransport(topic) {
     if (this.transportSubscribedTopics.has(topic)) return false;
     this.transportSubscribedTopics.add(topic);
-    this.runTransport(() => this.transport.subscribe(topic));
+    this.runTransport(
+      () => this.transport.subscribe(topic),
+      () => this.transportSubscribedTopics.has(topic)
+    );
     return true;
   }
   unsubscribeTransport(topic) {
     if (!this.transportSubscribedTopics.delete(topic)) return false;
-    this.runTransport(() => this.transport.unsubscribe(topic));
+    this.runTransport(
+      () => this.transport.unsubscribe(topic),
+      () => !this.transportSubscribedTopics.has(topic)
+    );
     return true;
   }
   /** Invoke `callback` for each item in `handlers`, isolating a throwing
@@ -3579,8 +3632,15 @@ var CrossTabDataBus = class {
    * Run a transport operation now if the transport is ready, otherwise queue
    * it behind the start promise. This ensures subscribe/unsubscribe calls made
    * during startup are not lost.
+   *
+   * `stillWanted` expresses the deferred work as the *current* desired state
+   * rather than a captured call, and is checked at each place that resumes on a
+   * later task — the recovery gate and the opening flush. The immediate branch
+   * carries no check because every path into it evaluates the desired state in
+   * the same task: a caller that just mutated `transportSubscribedTopics`, or
+   * the gate re-entry one line above.
    */
-  runTransport(operation) {
+  runTransport(operation, stillWanted) {
     if (this.suspended) return;
     if (this.recoveryGate && !this.stopping) {
       const gate = this.recoveryGate;
@@ -3590,7 +3650,8 @@ var CrossTabDataBus = class {
       void gate.then(() => {
         this.recoveryWaiters -= 1;
         if (this.stopping || this.suspended || cancellationToken !== this.recoveryCancellationToken) return;
-        this.runTransport(operation);
+        if (stillWanted && !stillWanted()) return;
+        this.runTransport(operation, stillWanted);
       });
       return;
     }
@@ -3611,6 +3672,7 @@ var CrossTabDataBus = class {
     void ready.then(
       () => {
         if (!this.started || this.stopping || this.suspended) return;
+        if (stillWanted && !stillWanted()) return;
         return operation();
       },
       // The opening promise reports its own lifecycle failure through