cross-tab-worker-databus 0.20.85 → 0.20.86

package/CHANGELOG.md

@@ -1,9 +1,21 @@
-## [Unreleased]
+## [0.20.86] - 2026-09-16
 
 ### Added
 - The configuration reference now documents the full public option surface: `replay.pruneStrategy` (previously absent entirely) and the replay options table (`maxPerTopic`, `persistence`, `retentionMs`, `pruneStrategy`, `retentionSweepMs`, `persistenceRetry`), plus a deduplication options table (`maxEntries`, `ttlMs`, `sweepMs`, `now`, `adaptiveTtl`) — in both languages. A guard derives the field list from the built declarations and fails when a `DataBusReplayOptions`/`DataBusDedupOptions` field is undocumented in either configuration reference. The `pruneStrategy` JSDoc no longer claims a default of `'both'` (the actual default is `'count'`).
 - Property invariants for `selectActiveWorkers` / `selectRebalanceTarget`: the returned worker set is always a subset of the input, active selection stays within `maxActiveWorkers` and non-empty for a non-empty input, and neither helper throws on arbitrary corrupt worker records.
 
+### Fixed
+- `ready()` no longer reports readiness for a restart that a later `stop()` canceled. The queued `start()` promise retains its documented resolve-on-cancellation behavior, but readiness now rejects with a clear lifecycle error instead of resolving against a stopped bus.
+- A failed restart queued behind an in-flight `stop()` now remains observable through `ready()`. Previously the failure cleared `started`, so a later `ready()` without `initialConfig` was masked by the generic "requires initialConfig" error; it now resurfaces the actual transport startup failure and preserves the explicit manual-retry path.
+- `publish()` and non-empty `publishBatch()` calls issued while `stop()` is in flight now report through `onError` instead of silently returning once `runTransport()` refuses to touch the stopping transport. Empty batches remain no-ops, publications already queued behind an in-flight open are still canceled by the stop (latest lifecycle intent wins), and page-hide suspension keeps its documented drop-without-defer behavior.
+- `subscribe()` and `ready()` now honor the explicit-stop barrier. A subscription requested while `stop()` is settling reports through `onError` and returns a no-op cleanup instead of being erased by teardown or leaking into a later restart; `ready()` rejects rather than resolving against the stopping transport. A `start()` already queued behind that stop remains the newest lifecycle intent, so `ready()` continues to follow its restart promise.
+- A `stop()` that arrives before a restart queued behind an earlier in-flight `stop()` could run now cancels that queued restart instead of being swallowed by the in-flight stop gate. The queued continuation is invalidated with a monotonic token, so the latest lifecycle intent always wins: `stop → start → stop` ends stopped with no extra transport open, while a later `start()` still queues a fresh restart with a higher token.
+- Superseded asynchronous transport opens can no longer tear down or detach a newer page-hide/pageshow reopen. Each open now carries a lifecycle epoch, so callbacks, failures, success telemetry, and cleanup from an older open are ignored once a newer suspend/resume/stop transition owns the lifecycle; `stop()` also waits for any pending open or reopen even when `started` has already been cleared. Previously an initial open failing after a queued resume reset `started` to false and nulled `startPromise`, making `stop()` resolve immediately while the queued transport could still start afterwards.
+- `start()` now serialises correctly with both page-hide suspension and an in-flight explicit stop. A hidden bus whose asynchronous `transport.stop()` was still settling returned that cleanup promise from `start()` and never reopened the transport; an in-flight `stop()` likewise allowed `start()` to observe the old ready state and resolve as a no-op before the bus finished stopping. Both paths now queue one fresh start after cleanup, share concurrent start/stop promises, and preserve the existing degraded manual-recovery behavior.
+- Explicit `start()` now performs a manual transport recovery when the bus has already started but its automatic recovery budget is exhausted; it preserves the cluster, subscriptions, and replay state while resetting the failure/recovery ledger before reopening. Previously `start()` returned a resolved no-op in the degraded state even though the public health contract documents it as the manual retry path. Covered by a regression that exhausts automatic recovery, succeeds through `start()`, and verifies the health summary returns to healthy.
+- IndexedDB replay persistence now settles every mutation when a transaction aborts, including connection-loss aborts that fire `onabort` without a preceding request error. Previously the serialized mutation queue could remain blocked forever, preventing later appends and clears from running. Loads now resolve only after `transaction.oncomplete`, so a request that succeeds before a later abort cannot be reported as a successful read. Request/transaction failures without an `error` object use operation-specific fallback messages.
+- Replay age pruning is now position-independent and uses one shared policy for the in-memory rings and IndexedDB adapter. Previously an expired timestamped entry after a timestamp-less legacy entry (or after a non-expired entry) was never removed, and hydrated history was always truncated to `maxPerTopic` even when `pruneStrategy: 'age'` was configured. Timestamp-less entries are still preserved for compatibility, but are now capped by `maxPerTopic` under AGE so they cannot grow without bound; timestamped entries remain bounded by the retention window. Covered across live recording, hydration without a `clearBefore` adapter, and durable append paths.
+
 ## [0.20.85] - 2026-09-13
 
 ### Added

package/dist/centrifuge.js

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

package/dist/{chunk-PW63EWIK.js → chunk-SDOV3UHG.js}

@@ -1729,6 +1729,36 @@ function roundMs(value) {
   return Math.round(value * 10) / 10;
 }
 
+// src/core/replay-pruning.ts
+function pruneReplayHistory(messages, options) {
+  const { maxPerTopic, pruneStrategy, retentionMs, now } = options;
+  const ageEnabled = pruneStrategy !== PRUNE_STRATEGY.COUNT && retentionMs !== void 0;
+  if (!ageEnabled) {
+    return messages.length > maxPerTopic ? messages.slice(-maxPerTopic) : messages;
+  }
+  const cutoff = now - retentionMs;
+  let hasExpired = false;
+  let timestamplessCount = 0;
+  for (const message of messages) {
+    if (message.timestamp === void 0) timestamplessCount += 1;
+    else if (message.timestamp < cutoff) hasExpired = true;
+  }
+  let pruned = hasExpired ? messages.filter((message) => message.timestamp === void 0 || message.timestamp >= cutoff) : messages;
+  if (pruneStrategy === PRUNE_STRATEGY.BOTH) {
+    return pruned.length > maxPerTopic ? pruned.slice(-maxPerTopic) : pruned;
+  }
+  if (timestamplessCount <= maxPerTopic) return pruned;
+  let timestamplessToDrop = timestamplessCount - maxPerTopic;
+  pruned = pruned.filter((message) => {
+    if (message.timestamp === void 0 && timestamplessToDrop > 0) {
+      timestamplessToDrop -= 1;
+      return false;
+    }
+    return true;
+  });
+  return pruned;
+}
+
 // src/core/replay-manager.ts
 var PersistenceRetryCancelledError = class extends Error {
   constructor() {
@@ -1790,17 +1820,15 @@ var ReplayManager = class {
       this.buffers.set(message.topic, buffer);
     }
     buffer.push(message);
-    const ageBounded = this.pruneStrategy !== PRUNE_STRATEGY.COUNT && this.retentionMs !== void 0;
-    if (this.pruneStrategy !== PRUNE_STRATEGY.AGE || !ageBounded) {
-      while (buffer.length > this.maxPerTopic) buffer.shift();
-    }
-    if (ageBounded) {
-      const cutoff = this.now() - this.retentionMs;
-      while (buffer.length > 0) {
-        const first = buffer[0];
-        if (!first || first.timestamp === void 0 || first.timestamp >= cutoff) break;
-        buffer.shift();
-      }
+    const pruned = pruneReplayHistory(buffer, {
+      maxPerTopic: this.maxPerTopic,
+      pruneStrategy: this.pruneStrategy,
+      retentionMs: this.retentionMs,
+      now: this.now()
+    });
+    if (pruned !== buffer) {
+      buffer = pruned;
+      this.buffers.set(message.topic, buffer);
     }
     if (!this.persistence) return;
     if (this.persistence.appendBatch) {
@@ -1981,14 +2009,24 @@ var ReplayManager = class {
       if (this.retentionMs !== void 0 && this.persistence.clearBefore) {
         await this.withPersistenceRetry(PERSISTENCE_OPERATION.CLEAR_BEFORE, () => this.persistence.clearBefore(this.now() - this.retentionMs));
       }
-      for (const message of await this.withPersistenceRetry(PERSISTENCE_OPERATION.LOAD, () => this.persistence.load())) {
+      const loaded = await this.withPersistenceRetry(PERSISTENCE_OPERATION.LOAD, () => this.persistence.load());
+      for (const message of loaded) {
         let buffer = this.buffers.get(message.topic);
         if (!buffer) {
           buffer = [];
           this.buffers.set(message.topic, buffer);
         }
         buffer.push(message);
-        if (buffer.length > this.maxPerTopic) buffer.shift();
+      }
+      const hydrationNow = this.now();
+      for (const [topic, buffer] of this.buffers) {
+        const pruned = pruneReplayHistory(buffer, {
+          maxPerTopic: this.maxPerTopic,
+          pruneStrategy: this.pruneStrategy,
+          retentionMs: this.retentionMs,
+          now: hydrationNow
+        });
+        if (pruned !== buffer) this.buffers.set(topic, pruned);
       }
     } catch (error) {
       this.onPersistenceError(error);
@@ -2165,7 +2203,7 @@ var DedupManager = class {
 };
 
 // src/core/version.ts
-var SDK_VERSION = true ? "0.20.85" : "";
+var SDK_VERSION = true ? "0.20.86" : "";
 
 // src/core/data-bus.ts
 var DEFAULT_REPLAY_MAX_PER_TOPIC = 100;
@@ -2203,6 +2241,24 @@ var CrossTabDataBus = class {
   // Gate that serialises start/stop/suspend/resume — only one lifecycle
   // transition at a time. Resets to null once the operation settles.
   startPromise = null;
+  // Gate for an explicit stop(). Concurrent stop() calls share it, and a
+  // start() received while stopping chains a fresh start after it.
+  stopPromise = null;
+  // A start() requested while an explicit stop() is still settling. Kept
+  // separate from startPromise because stop()'s finally block clears the
+  // ordinary lifecycle gate before the queued start is allowed to run.
+  queuedStart = null;
+  // Lazy readiness view of queuedStart. start() keeps its documented
+  // resolve-on-cancellation contract, while ready() must reject when the
+  // queued intent was superseded by a later stop().
+  queuedStartReady = null;
+  queuedStartReadyToken = 0;
+  // The queued continuation is chained to the stop promise and cannot be
+  // un-scheduled once scheduled. A later stop() therefore invalidates the
+  // current intent by recording its token; a subsequent start() issues a
+  // higher token so the latest lifecycle request still wins.
+  queuedStartToken = 0;
+  canceledQueuedStartToken = 0;
   // Timestamp of the last automatic transport recovery attempt.
   // Used to avoid a tight retry loop when the transport fails repeatedly.
   lastRecoveryAt = 0;
@@ -2225,6 +2281,9 @@ var CrossTabDataBus = class {
   // surfaces a failure while later opens and automatic recovery wait for the
   // stop to settle.
   pendingStop = null;
+  // Ownership token for asynchronous transport opens. Every lifecycle
+  // transition invalidates callbacks and failure cleanup from older opens.
+  lifecycleEpoch = 0;
   // Minimum interval in ms between automatic recovery attempts.
   recoveryCooldownMs;
   recoveryMaxAttempts;
@@ -2337,37 +2396,51 @@ var CrossTabDataBus = class {
    * Start the DataBus with the given transport config.
    *
    * The first call starts the cluster and opens the transport. Concurrent calls
-   * during an in-flight start return the same promise. Once the operation
-   * settles (success or failure) the promise gate is cleared so a subsequent
-   * start() or resumeTransport() can open a fresh lifecycle.
+   * during an in-flight open return the same promise. A call received while an
+   * explicit stop() is settling queues one fresh start after cleanup; a later
+   * stop() before that queued start runs cancels it, so the latest lifecycle
+   * intent wins. Once an operation settles (success or failure) its promise
+   * gate is cleared so a subsequent start() or resumeTransport() can open a
+   * fresh lifecycle.
    */
   start(config) {
-    if (this.startPromise) return this.startPromise;
-    if (this.started) return Promise.resolve();
+    if (this.queuedStart) return this.queuedStart;
+    if (this.stopping) return this.queueStartAfterStop(config);
+    if (this.startPromise && this.startPromise !== this.pendingStop) return this.startPromise;
+    if (this.started) {
+      const transportDown = !this.transportReady || this.status === WORKER_STATUS.ERROR || this.status === WORKER_STATUS.DISCONNECTED;
+      if (!transportDown) return Promise.resolve();
+      this.activeConfig = config;
+      this.resetFailureState();
+      return this.reopenTransport();
+    }
     this.started = true;
     this.stopping = false;
     this.suspended = false;
     this.activeConfig = config;
-    this.lastError = null;
-    this.lastFailure = null;
-    this.persistenceFailureCount = 0;
-    this.persistenceLastFailureAt = null;
-    this.persistenceLastErrorMessage = null;
+    this.resetFailureState();
     this.trace.event({ type: TRACE_EVENT_TYPE.LIFECYCLE, action: TRACE_LIFECYCLE_ACTION.START });
     this.trace.start();
     this.startDedupSweep();
     this.replayManager.start();
     this.updateStatus(WORKER_STATUS.CONNECTING);
     this.cluster.start();
-    const opening = this.openTransport(config, this.pendingStop ?? Promise.resolve(), true);
+    const lifecycleEpoch = ++this.lifecycleEpoch;
+    const opening = this.openTransport(
+      config,
+      this.pendingStop ?? Promise.resolve(),
+      true,
+      lifecycleEpoch
+    );
     this.startPromise = opening;
     for (const topic of this.topicHandlers.keys()) {
       this.cluster.subscribe(topic);
     }
     void opening.then(
       () => {
+        if (this.startPromise !== opening) return;
         this.emitCoordinationTrace();
-        if (this.startPromise === opening) this.startPromise = null;
+        this.startPromise = null;
       },
       () => {
         if (this.startPromise === opening) this.startPromise = null;
@@ -2375,24 +2448,80 @@ var CrossTabDataBus = class {
     );
     return opening;
   }
+  /** Return a cancellation-aware readiness view of the current queued start. */
+  getQueuedStartReady() {
+    const queued = this.queuedStart;
+    if (!queued) {
+      return Promise.reject(new Error("No queued start is in flight."));
+    }
+    const token = this.queuedStartToken;
+    if (this.queuedStartReady && this.queuedStartReadyToken === token) {
+      return this.queuedStartReady;
+    }
+    this.queuedStartReadyToken = token;
+    this.queuedStartReady = queued.then(() => {
+      if (token <= this.canceledQueuedStartToken) {
+        throw new Error(
+          "CrossTabDataBus start was canceled by a later stop(); ready() cannot report readiness. Call start() again after stop() resolves."
+        );
+      }
+      if (!this.started || !this.transportReady) {
+        throw new Error("CrossTabDataBus restart completed without a ready transport.");
+      }
+    });
+    return this.queuedStartReady;
+  }
+  /** Queue exactly one fresh start after an in-flight explicit stop settles. */
+  queueStartAfterStop(config) {
+    if (this.queuedStart) return this.queuedStart;
+    const stop = this.stopPromise ?? Promise.resolve();
+    const token = ++this.queuedStartToken;
+    const queued = stop.catch(() => void 0).then(() => {
+      if (this.queuedStart === queued) this.queuedStart = null;
+      if (token <= this.canceledQueuedStartToken) return;
+      return this.start(config);
+    });
+    this.queuedStart = queued;
+    return queued;
+  }
+  /** Reset failure and recovery diagnostics for a new explicit start session. */
+  resetFailureState() {
+    this.lastError = null;
+    this.lastErrorAt = null;
+    this.lastFailure = null;
+    this.persistenceFailureCount = 0;
+    this.persistenceLastFailureAt = null;
+    this.persistenceLastErrorMessage = null;
+    this.recoveryAttempt = 0;
+    this.recoveryExhausted = false;
+    this.lastRecoveryAt = 0;
+  }
   /**
    * Open the transport, chained after `before` to ensure lifecycle ordering.
    * When `stopClusterOnFailure` is true (initial start), a transport failure
    * tears down the cluster as well.
    */
-  openTransport(config, before, stopClusterOnFailure) {
+  openTransport(config, before, stopClusterOnFailure, lifecycleEpoch) {
     this.transportReady = false;
     const chainedPendingStop = this.pendingStop;
+    const isCurrentLifecycle = () => lifecycleEpoch === this.lifecycleEpoch;
     return before.catch(() => void 0).then(() => {
-      if (this.stopping || this.suspended) return;
+      if (!isCurrentLifecycle() || this.stopping || this.suspended) return;
       if (this.pendingStop === chainedPendingStop) this.pendingStop = null;
       return Promise.resolve(
         this.transport.start(config, {
-          onMessage: (message) => this.handleTransportMessage(message),
-          onStatus: (status) => this.updateStatus(status),
-          onError: (error) => this.reportError(error)
+          onMessage: (message) => {
+            if (isCurrentLifecycle()) this.handleTransportMessage(message);
+          },
+          onStatus: (status) => {
+            if (isCurrentLifecycle()) this.updateStatus(status);
+          },
+          onError: (error) => {
+            if (isCurrentLifecycle()) this.reportError(error);
+          }
         })
       ).then(() => {
+        if (!isCurrentLifecycle()) return;
         if (this.status === WORKER_STATUS.ERROR) {
           throw new Error("Transport failed during startup.");
         }
@@ -2403,6 +2532,7 @@ var CrossTabDataBus = class {
         }
       });
     }).catch((error) => {
+      if (!isCurrentLifecycle()) throw error;
       if (stopClusterOnFailure) this.started = false;
       if (!this.pendingStop) {
         this.pendingStop = this.createStopPromise();
@@ -2417,16 +2547,26 @@ var CrossTabDataBus = class {
         this.cluster.stop();
         this.stopping = false;
       }
-      this.startPromise = null;
       throw error;
     });
   }
   /**
    * Await the DataBus to be fully started (lazy init when using initialConfig).
    * Returns a rejected promise when the transport has failed and no start is in
-   * flight — the caller can retry by calling start() or ready() again.
+   * flight — the caller can retry by calling start() or ready() again. While an
+   * explicit stop() is settling, this rejects unless a restart is queued behind
+   * it; false readiness during teardown is never reported.
    */
   ready() {
+    if (this.queuedStart) return this.getQueuedStartReady();
+    if (this.stopping) {
+      return Promise.reject(new Error(
+        "CrossTabDataBus is stopping; ready() cannot report readiness until stop() resolves. Wait for stop() to resolve, then call start() before awaiting ready()."
+      ));
+    }
+    if (!this.started && !this.hasInitialConfig && this.lastError !== null) {
+      return Promise.reject(this.lastError);
+    }
     try {
       this.ensureStarted();
     } catch (error) {
@@ -2442,9 +2582,18 @@ var CrossTabDataBus = class {
   /**
    * Register a handler for `topic`. The handler fires on every publication
    * delivered to this tab, regardless of which tab published it. Returns an
-   * unsubscribe function for convenience.
+   * unsubscribe function for convenience. During an explicit stop() the
+   * registration is rejected through onError and a no-op cleanup is returned,
+   * so a late subscriber cannot leak into a future restart.
    */
   subscribe(topic, handler, options) {
+    if (this.stopping) {
+      this.reportError(new Error(
+        "CrossTabDataBus is stopping; subscribe() was not registered. Wait for stop() to resolve, then call start() before subscribing again."
+      ));
+      return () => {
+      };
+    }
     this.ensureStarted();
     const handlers = this.topicHandlers.get(topic) ?? /* @__PURE__ */ new Set();
     const wasUnused = handlers.size === 0;
@@ -2498,6 +2647,7 @@ var CrossTabDataBus = class {
   /** Publish a message to `topic`. The owning Worker delivers it to the transport. */
   publish(topic, data, options) {
     this.ensureStarted();
+    if (this.rejectPublishDuringStop("publish")) return;
     if (!this.cluster.publish(topic, data, options)) {
       this.reportError(
         new Error("Failed to send the publish control message to the owning worker.")
@@ -2514,6 +2664,7 @@ var CrossTabDataBus = class {
   publishBatch(topic, items) {
     this.ensureStarted();
     if (items.length === 0) return;
+    if (this.rejectPublishDuringStop("publishBatch")) return;
     if (items.length === 1) {
       const first = items[0];
       this.publish(topic, first.data, first.options);
@@ -2642,10 +2793,33 @@ var CrossTabDataBus = class {
   }
   /**
    * Gracefully stop the DataBus: unsubscribe all topics, stop the cluster,
-   * and close the transport. Idempotent.
+   * and close the transport. Concurrent and repeated calls share the in-flight
+   * stop promise. A start() received while stopping runs after this completes,
+   * unless another stop() arrives first and cancels that queued restart.
    */
-  async stop() {
-    if (!this.started) return;
+  stop() {
+    if (this.queuedStart) {
+      this.canceledQueuedStartToken = this.queuedStartToken;
+      this.queuedStart = null;
+    }
+    if (this.stopPromise) return this.stopPromise;
+    if (!this.started && !this.startPromise && !this.pendingStop && !this.transportReady) {
+      return Promise.resolve();
+    }
+    const stopPromise = this.performStop();
+    this.stopPromise = stopPromise;
+    void stopPromise.then(
+      () => {
+        if (this.stopPromise === stopPromise) this.stopPromise = null;
+      },
+      () => {
+        if (this.stopPromise === stopPromise) this.stopPromise = null;
+      }
+    );
+    return stopPromise;
+  }
+  async performStop() {
+    this.lifecycleEpoch += 1;
     this.stopping = true;
     this.replayManager.suspend();
     this.trace.event({ type: TRACE_EVENT_TYPE.LIFECYCLE, action: TRACE_LIFECYCLE_ACTION.STOP });
@@ -2837,6 +3011,7 @@ var CrossTabDataBus = class {
    */
   suspendTransport() {
     if (this.stopping) return;
+    this.lifecycleEpoch += 1;
     this.suspended = true;
     this.transportReady = false;
     this.transportSubscribedTopics.clear();
@@ -2875,19 +3050,23 @@ var CrossTabDataBus = class {
     this.started = true;
     this.suspended = false;
     this.updateStatus(WORKER_STATUS.CONNECTING);
+    const lifecycleEpoch = ++this.lifecycleEpoch;
     const pending = this.startPromise ?? this.pendingStop ?? Promise.resolve();
-    const opening = pending.catch(() => void 0).then(() => this.openTransport(config, Promise.resolve(), false));
+    const opening = pending.catch(() => void 0).then(() => this.openTransport(config, Promise.resolve(), false, lifecycleEpoch));
     this.startPromise = opening;
     void opening.then(
       () => {
+        if (this.startPromise === opening) this.startPromise = null;
+        if (lifecycleEpoch !== this.lifecycleEpoch) return;
         if (traceAttempt !== void 0) {
           this.trace.event({ type: TRACE_EVENT_TYPE.RELIABILITY, operation: RELIABILITY_OPERATION.TRANSPORT_RECOVERY, attempt: traceAttempt, outcome: RECOVERY_OUTCOME.SUCCEEDED });
           this.recoveryAttempt = 0;
           this.recoveryExhausted = false;
         }
-        if (this.startPromise === opening) this.startPromise = null;
       },
       () => {
+        if (this.startPromise === opening) this.startPromise = null;
+        if (lifecycleEpoch !== this.lifecycleEpoch) return;
         if (traceAttempt !== void 0) {
           this.trace.event({ type: TRACE_EVENT_TYPE.RELIABILITY, operation: RELIABILITY_OPERATION.TRANSPORT_RECOVERY, attempt: traceAttempt, outcome: RECOVERY_OUTCOME.FAILED });
         }
@@ -2921,6 +3100,19 @@ var CrossTabDataBus = class {
       return operation();
     }).catch((error) => this.reportError(error));
   }
+  /**
+   * Publications started after teardown begins cannot reach any transport.
+   * Surface that as a normal asynchronous API failure instead of letting
+   * runTransport() return silently. Empty publishBatch() calls remain a no-op
+   * and are filtered by the caller before this check.
+   */
+  rejectPublishDuringStop(operation) {
+    if (!this.stopping) return false;
+    this.reportError(new Error(
+      `CrossTabDataBus is stopping; ${operation}() was not sent. Wait for stop() to resolve, then call start() before publishing again.`
+    ));
+    return true;
+  }
   /**
    * Ensure the DataBus is started, throwing if no initialConfig was provided.
    * Called automatically by subscribe/publish/ready when autoStart is true.
@@ -2996,8 +3188,9 @@ export {
   assertHeartbeatInterval,
   assertStructuredCloneable,
   WorkerClusterRuntime,
+  pruneReplayHistory,
   CrossTabDataBus,
   parseDataBusPublication,
   selectWorkerBackend
 };
-//# sourceMappingURL=chunk-PW63EWIK.js.map
+//# sourceMappingURL=chunk-SDOV3UHG.js.map