cross-tab-worker-databus 0.21.12 → 0.21.14

package/dist/centrifuge.shared.worker.js

@@ -5251,9 +5251,16 @@ var CentrifugeSession = class {
    * same emptiness before calling, and the subscription-level caller reads the
    * topic out of a key this session only ever populates from a SUBSCRIBE frame.
    * Measured — deleting this line leaves all 37 test files green, and the frame
-   * it withholds could not be delivered anyway, because `topicMatchesPattern`
-   * answers false for an empty topic against both `*` and `prefix.*` (so no
-   * wildcard handler sees it either) and `subscribe('')` throws. Kept as the
+   * it withholds has nowhere to land anyway: the only handler registry is the
+   * DataBus's `topicHandlers`, and every write to it sits behind
+   * `assertPublicTopic` (`data-bus.ts:929`, `:1009`, `:1033`), so no `''` key can
+   * exist — while `topicMatchesPattern` answers false for an empty topic against
+   * both `*` and `prefix.*`, so a wildcard handler cannot see it either. Neither
+   * of those is a reason to delete this guard: it is the only one *at this layer*,
+   * because neither the session nor the transport calls `assertPublicTopic` — a
+   * SUBSCRIBE frame naming `''` creates a real Centrifuge subscription
+   * (`newSubscription` does not validate a channel), so the undeliverable
+   * publication would otherwise be posted back to the main thread. Kept as the
    * boundary statement, not counted as a closed leg. */
   postPublication(topic, data) {
     if (!topic) return;
@@ -5384,12 +5391,19 @@ var PortReaper = class {
    * `Infinity` is the documented way to disable the PING heartbeat, and it means
    * this port can never be judged silent: `startHeartbeat()` sends nothing at all
    * once configured that way, so a timeout would be a death sentence with no
-   * possible appeal. A non-finite-or-non-positive *other* value falls back to the
-   * default so a bad payload cannot degenerate the reaper into a busy loop or
-   * silence it — those three (NaN, 0, negative) are rejected by
-   * `assertHeartbeatInterval` at the transport constructor and so can only arrive
-   * from a main thread that is not this library. No-op for untracked ports (e.g.
-   * setTimeout arrives after remove/STOP). */
+   * possible appeal. A non-finite-or-non-positive *other* value falls back to
+   * the default, which keeps the timeout comparison from degenerating into
+   * "always expired" — a NaN timeout reaps every port on the first tick. Read
+   * that narrowly, because it is not a busy-loop guard: the busy-loop vector is
+   * a tiny *positive* interval, which the ternary passes through untouched
+   * (0.0001 → a 0.0003 ms timeout → every tick reaps everything), and the
+   * reaper's own cadence is bounded elsewhere — `computeMinHeartbeat` starts
+   * from DEFAULT_HEARTBEAT_INTERVAL_MS and only takes a minimum, so a payload
+   * can shorten the sweep but never stretch it past 10 s. The three values
+   * rejected here (NaN, 0, negative) are also rejected by
+   * `assertHeartbeatInterval` at the transport constructor and so can only
+   * arrive from a main thread that is not this library. No-op for untracked
+   * ports (e.g. setTimeout arrives after remove/STOP). */
   setTimeout(port, heartbeatIntervalMs) {
     if (!this.targets.has(port)) return;
     const safe = heartbeatIntervalMs === Infinity ? Infinity : Number.isFinite(heartbeatIntervalMs) && heartbeatIntervalMs > 0 ? heartbeatIntervalMs : DEFAULT_HEARTBEAT_INTERVAL_MS;
@@ -5439,8 +5453,11 @@ var PortReaper = class {
     this.handle = this.setTimer(() => this.reap(), minHeartbeat);
   }
   /** Smallest heartbeat interval among active ports, derived from each port's
-   * configured session timeout. Exposed as a method so the cadence logic can
-   * be unit-tested in isolation from the timer plumbing. */
+   * configured session timeout. Extracted because `schedule()` derives its delay
+   * from it on every re-arm. Not a test seam: nothing in `tests/` calls it
+   * (grep: zero hits), and the cadence is asserted through the injected
+   * `setTimer` — i.e. through the same plumbing this note used to claim it was
+   * isolated from. */
   computeMinHeartbeat() {
     let minHeartbeat = DEFAULT_HEARTBEAT_INTERVAL_MS;
     for (const timeout of this.sessionTimeoutMs.values()) {