cross-tab-worker-databus 0.21.42 → 0.21.44

package/dist/cjs/index.cjs

@@ -740,6 +740,10 @@ var WorkerClusterRuntime = class {
   channelName;
   /** Adaptive load weighting options; undefined keeps legacy topic-count routing. */
   loadWeighting;
+  /** The most recent finite reading of the environment's clock, and the fallback for
+   * a broken one — see {@link nowMs}. Seeded to 0 because a clock that has never
+   * produced a finite reading leaves nothing to hold. */
+  lastFiniteNow = 0;
   /** Rolling traffic accumulator folded into the worker record on writeRecord. */
   throughputWindow = {
     startedAt: 0,
@@ -801,7 +805,7 @@ var WorkerClusterRuntime = class {
     this.storage = canUseStorage(this.environment.storage, `${baseKey}:probe`) ? new BatchingStorageWriter(this.environment.storage) : null;
     this.tabId = options.tabId ?? getOrCreateTabId(this.environment, `${prefix}:tab-id`);
     this.workerId = options.workerId ?? `worker-${this.tabId}-${this.environment.randomId()}`;
-    const now = this.environment.now();
+    const now = this.nowMs();
     this.currentRecord = {
       protocolVersion: CLUSTER_PROTOCOL_VERSION,
       workerId: this.workerId,
@@ -814,6 +818,33 @@ var WorkerClusterRuntime = class {
       registeredAt: now
     };
   }
+  /**
+   * The environment's clock, normalized.
+   *
+   * `ClusterEnvironment.now` is a required field, and the documented hazard is a
+   * *backwards* step rather than a missing reading — the library's own subtraction
+   * sites tolerate one, since every `now - stamped > ttl` reads a backwards clock as
+   * "not yet expired". A non-finite reading is outside that contract, and it does not
+   * degrade one field: measured before this guard, a `NaN` clock was written straight
+   * into durable state — the worker, route and subscriber records all carried
+   * `"updatedAt": null`, because `JSON.stringify(NaN)` is `null` — and that is worse
+   * than a wrong number rather than merely different, because `null` coerces to `0`
+   * in the TTL arithmetic, so the first tick after the clock recovered would read
+   * every record as ancient and prune the whole cluster at once.
+   *
+   * Holding the last finite reading is the same treatment `data-bus.ts` applies to
+   * `dedup.now` and `DedupManager` applies to its own boundary: a paused clock, not a
+   * poisoned one. It is a helper rather than nine conditions because the broken input
+   * is the clock, not any particular comparison.
+   */
+  nowMs() {
+    const reading = this.environment.now();
+    if (Number.isFinite(reading)) {
+      this.lastFiniteNow = reading;
+      return reading;
+    }
+    return this.lastFiniteNow;
+  }
   /** Start the cluster: register, listen for lifecycle events, and begin heartbeats. */
   start() {
     if (this.started) return;
@@ -870,7 +901,7 @@ var WorkerClusterRuntime = class {
       return;
     }
     this.channel?.addEventListener("message", this.handleMessage);
-    const now = this.environment.now();
+    const now = this.nowMs();
     this.currentRecord = {
       ...this.currentRecord,
       heartbeatAt: now,
@@ -1356,7 +1387,7 @@ var WorkerClusterRuntime = class {
    * will never complete — while a fresh unconfirmed route may simply be
    * waiting out its confirmation flush and must be left alone. */
   isStaleHandoff(route) {
-    return this.environment.now() - route.updatedAt > this.workerTtlMs;
+    return this.nowMs() - route.updatedAt > this.workerTtlMs;
   }
   /** Full reconciliation cycle: workers, subscriptions, and assigned topics. */
   reconcile() {
@@ -1541,7 +1572,7 @@ var WorkerClusterRuntime = class {
   /** Read all live worker records from storage, pruning stale entries past the TTL. */
   readWorkers() {
     if (!this.storage) return [this.currentRecord];
-    const now = this.environment.now();
+    const now = this.nowMs();
     const workers = [];
     for (const { key, value: worker } of readAllByPrefix(this.storage, this.workerPrefix)) {
       if (worker.workerId !== this.workerId && now - worker.heartbeatAt > this.workerTtlMs) {
@@ -1593,7 +1624,7 @@ var WorkerClusterRuntime = class {
       topicKey,
       workerId: this.workerId,
       tabId: this.tabId,
-      updatedAt: this.environment.now(),
+      updatedAt: this.nowMs(),
       generation: 1
     };
   }
@@ -1610,7 +1641,7 @@ var WorkerClusterRuntime = class {
       topicKey,
       workerId: owner.workerId,
       tabId: owner.tabId,
-      updatedAt: this.environment.now(),
+      updatedAt: this.nowMs(),
       generation,
       ...handoffFromWorkerId ? { handoffFromWorkerId } : {}
     };
@@ -1622,7 +1653,7 @@ var WorkerClusterRuntime = class {
     if (!route || route.workerId !== this.workerId || route.confirmedAt !== void 0) return;
     writeJson(this.storage, this.routeStorageKey(topicKey), {
       ...route,
-      confirmedAt: this.environment.now()
+      confirmedAt: this.nowMs()
     });
     const topic = this.knownTopics.get(topicKey);
     if (topic) this.handlers.onDiagnostic?.({ operation: RELIABILITY_OPERATION.ROUTE_ACK, topic });
@@ -1630,7 +1661,7 @@ var WorkerClusterRuntime = class {
   /** Remove routes whose topic has no subscribers and whose TTL has expired. */
   cleanupOrphanedRoutes(workers) {
     if (!this.storage) return;
-    const now = this.environment.now();
+    const now = this.nowMs();
     for (const { key, value: route } of readAllByPrefix(this.storage, this.routePrefix)) {
       if (now - route.updatedAt <= this.workerTtlMs) continue;
       if (this.readSubscriberTabIds(route.topicKey, workers).length > 0) continue;
@@ -1650,7 +1681,7 @@ var WorkerClusterRuntime = class {
     if (!this.storage) return;
     writeJson(this.storage, this.subscriberStorageKey(topicKey, this.tabId), {
       tabId: this.tabId,
-      updatedAt: this.environment.now()
+      updatedAt: this.nowMs()
     });
   }
   /** Persist the current worker record with an updated heartbeat timestamp.
@@ -1661,7 +1692,7 @@ var WorkerClusterRuntime = class {
    *   status, visibility and load changes pass true; the heartbeat tick and a
    *   role change pass false. */
   writeRecord(notify) {
-    const now = this.environment.now();
+    const now = this.nowMs();
     const sample = this.loadWeighting !== void 0 ? this.sampleThroughput(now) : void 0;
     this.currentRecord = {
       ...this.currentRecord,
@@ -2461,6 +2492,8 @@ var DedupManager = class {
   seenMessageIds = /* @__PURE__ */ new Map();
   sweepTimer = null;
   windowStartedAt = 0;
+  /** The most recent finite reading of `now`, and the fallback for a broken one. */
+  lastFiniteNow = 0;
   windowAccepted = 0;
   suppressed = 0;
   accepted = 0;
@@ -2472,14 +2505,46 @@ var DedupManager = class {
     this.sweepMs = options.sweepMs;
     this.now = options.now;
     this.trace = options.trace;
-    this.windowStartedAt = this.now();
+    this.lastFiniteNow = Number.isFinite(this.now()) ? this.now() : 0;
+    this.windowStartedAt = this.lastFiniteNow;
+  }
+  /**
+   * The injected clock, normalized.
+   *
+   * `dedup.now` is a public option and a non-wall-clock host is exactly the case it
+   * exists for — one whose reading can be *missing* rather than merely unusual. Every
+   * comparison this class makes is arithmetic on a timestamp, so a single non-finite
+   * reading does not degrade one field: `now - timestamp > ttlMs` becomes
+   * `NaN > ttlMs` (false, so nothing expires), the adaptive window's
+   * `elapsed >= ADAPTIVE_WINDOW_MS` never fires, and `getStats().ttlMs` reports
+   * `NaN` — which `JSON.stringify` turns into `null`, so a health summary or a
+   * diagnostics log would carry a null where a duration belongs. Measured on the
+   * pre-fix class: `getStats().ttlMs` → `NaN`, serialized → `null`, and an id
+   * stayed suppressed for as long as it stayed in the map.
+   *
+   * Holding the last finite reading is the degradation that changes least: time
+   * stands still, expiry pauses, and the adaptive window keeps the value it last
+   * computed. Substituting `Date.now()` would be worse — it silently mixes two
+   * clocks — and zeroing would expire the whole map on the next call. This is the
+   * same class of guard `trace.ts` carries on its own public clock, and that
+   * `websocket.ts` and `replay-manager.ts` apply to their numeric options; it is one
+   * helper rather than a condition per site because the broken input is the *clock*,
+   * not any particular comparison.
+   */
+  nowMs() {
+    const reading = this.now();
+    if (Number.isFinite(reading)) {
+      this.lastFiniteNow = reading;
+      return reading;
+    }
+    return this.lastFiniteNow;
   }
   /** True when a publication carrying `messageId` was already seen. Records the
    * ID and updates counters/trace on acceptance. Disabled or ID-less messages
    * always pass through. */
   isDuplicate(messageId, topic) {
     if (!this.enabled || !messageId) return false;
-    const now = this.now();
+    const now = this.nowMs();
     const ttlMs = this.currentTtl();
     for (const [id, timestamp] of this.seenMessageIds) {
       if (now - timestamp > ttlMs) this.seenMessageIds.delete(id);
@@ -2530,12 +2595,12 @@ var DedupManager = class {
     this.seenMessageIds.clear();
     this.suppressed = 0;
     this.accepted = 0;
-    this.windowStartedAt = this.now();
+    this.windowStartedAt = this.nowMs();
     this.windowAccepted = 0;
   }
   /** Remove IDs whose timestamp predates the effective TTL cutoff. */
   pruneExpired() {
-    const cutoff = this.now() - this.currentTtl();
+    const cutoff = this.nowMs() - this.currentTtl();
     for (const [id, timestamp] of this.seenMessageIds) {
       if (timestamp < cutoff) this.seenMessageIds.delete(id);
     }
@@ -2546,7 +2611,7 @@ var DedupManager = class {
    * every ADAPTIVE_WINDOW_MS. */
   currentTtl() {
     if (!this.adaptiveBounds) return this.ttlMs;
-    const now = this.now();
+    const now = this.nowMs();
     const elapsed = now - this.windowStartedAt;
     if (elapsed >= ADAPTIVE_WINDOW_MS) {
       this.windowStartedAt = now;
@@ -2570,7 +2635,7 @@ var SDK_VERSION = (
   // declaration's type is `string | undefined` and the export's is `string`
   // (dropping the conditional is TS2322, measured). Recorded here so the leg reads
   // as a shape the harness cannot reach rather than as a case nobody exercised.
-  true ? "0.21.42" : ""
+  true ? "0.21.44" : ""
 );
 
 // src/core/data-bus.ts
@@ -2690,7 +2755,7 @@ var CrossTabDataBus = class {
     assertRecoveryOptions(recovery);
     this.recoveryCooldownMs = recovery?.cooldownMs ?? 1e3;
     this.recoveryMaxAttempts = recovery?.maxAttempts ?? Number.POSITIVE_INFINITY;
-    this.now = dedup?.now ?? Date.now;
+    this.now = holdLastFinite(dedup?.now ?? Date.now);
     this.transport = transport;
     this.initialConfig = initialConfig;
     this.hasInitialConfig = "initialConfig" in options;
@@ -3749,6 +3814,19 @@ function formatWorkerTrace(worker) {
 function formatRouteTrace(route) {
   return `${route.topicKey}@${route.workerId}|confirmed=${route.confirmedAt !== void 0}`;
 }
+function holdLastFinite(source) {
+  let last = 0;
+  let primed = false;
+  return () => {
+    const reading = source();
+    if (Number.isFinite(reading)) {
+      last = reading;
+      primed = true;
+      return reading;
+    }
+    return primed ? last : 0;
+  };
+}
 
 // src/core/replay-persistence.ts
 function createIndexedDbReplayPersistence(options) {