cross-tab-worker-databus 0.21.57 → 0.21.59

package/dist/centrifuge.worker.js

@@ -1,4 +1,4 @@
-// node_modules/.pnpm/centrifuge@5.7.4/node_modules/centrifuge/build/index.mjs
+// node_modules/.pnpm/centrifuge@5.8.0/node_modules/centrifuge/build/index.mjs
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -504,6 +504,23 @@ function localStorageItem(key) {
     return null;
   }
 }
+function hasOffset(offset) {
+  return offset !== void 0 && offset !== null && Number(offset) > 0;
+}
+function toOffset(offset) {
+  if (offset === void 0 || offset === null) {
+    return 0;
+  }
+  if (typeof offset === "object") {
+    const low = offset.low;
+    const high = offset.high;
+    if (typeof low === "number" && typeof high === "number") {
+      return (high >>> 0) * 4294967296 + (low >>> 0);
+    }
+  }
+  const value = Number(offset);
+  return isNaN(value) ? 0 : value;
+}
 var MapPhase;
 (function(MapPhase2) {
   MapPhase2[MapPhase2["Live"] = 0] = "Live";
@@ -516,6 +533,8 @@ var BaseSubscription = class extends EventEmitter {
     super();
     this._resubscribeTimeout = null;
     this._refreshTimeout = null;
+    this._pendingOffset = null;
+    this._removed = false;
     this._getState = null;
     this._map = false;
     this._mapPresenceType = 1;
@@ -525,6 +544,18 @@ var BaseSubscription = class extends EventEmitter {
     this._mapCursor = "";
     this._mapPageSize = 0;
     this._mapUnrecoverableStrategy = "from_scratch";
+    this._mapPositionResets = 0;
+    this._subscribeFlow = 0;
+    this._refreshGeneration = 0;
+    this._sharedPollReplayPending = false;
+    this._stateTransitions = 0;
+    this._sharedPollQueue = Promise.resolve();
+    this._subscribeCallFlow = null;
+    this._deferredUnsubscribe = null;
+    this._mapFlowRecovering = false;
+    this._mapFlowOffset = 0;
+    this._mapFlowEpoch = null;
+    this._mapFlowPositionResets = 0;
     this._debounceMs = 0;
     this._debouncePending = /* @__PURE__ */ new Map();
     this._sharedPoll = false;
@@ -540,6 +571,8 @@ var BaseSubscription = class extends EventEmitter {
     this._sharedPollSignatures = [];
     this._sharedPollSignatureRefreshTargetMs = null;
     this._sharedPollSignatureRefreshInFlight = false;
+    this._sharedPollSignatureRefreshAgain = false;
+    this._sharedPollSignatureRefreshKeys = /* @__PURE__ */ new Set();
     this.channel = channel;
     this.state = SubscriptionState.Unsubscribed;
     this._centrifuge = centrifuge;
@@ -598,29 +631,36 @@ var BaseSubscription = class extends EventEmitter {
       return Promise.resolve();
     }
     return new Promise((res, rej) => {
+      const id = this._nextPromiseId();
       const ctx = {
         resolve: res,
         reject: rej
       };
       if (timeout) {
-        ctx.timeout = setTimeout(function() {
+        ctx.timeout = setTimeout(() => {
+          delete this._promises[id];
           rej({ code: errorCodes.timeout, message: "timeout" });
         }, timeout);
       }
-      this._promises[this._nextPromiseId()] = ctx;
+      this._promises[id] = ctx;
     });
   }
   /** subscribe to a channel.*/
   subscribe() {
+    if (this._removed) {
+      throw new Error("Subscription to the channel " + this.channel + " was removed from the client");
+    }
     if (this._isSubscribed()) {
       return;
     }
-    this._resubscribeAttempts = 0;
+    if (this._isUnsubscribed()) {
+      this._resubscribeAttempts = 0;
+    }
     this._setSubscribing(subscribingCodes.subscribeCalled, "subscribe called");
   }
   /** unsubscribe from a channel, keeping position state.*/
   unsubscribe() {
-    this._unsubPromise = this._setUnsubscribed(unsubscribedCodes.unsubscribeCalled, "unsubscribe called", true);
+    this._setUnsubscribed(unsubscribedCodes.unsubscribeCalled, "unsubscribe called", true);
   }
   _debouncedPublish(key, data, isMap) {
     const existing = this._debouncePending.get(key);
@@ -648,7 +688,8 @@ var BaseSubscription = class extends EventEmitter {
           return;
         }
         this._debouncePending.delete(key);
-        this._debouncedPublish(key, p.data, isMap);
+        this._debouncedPublish(key, p.data, isMap).catch(() => {
+        });
       }, this._debounceMs);
     }, this._debounceMs);
     this._debouncePending.set(key, entry);
@@ -731,6 +772,7 @@ var BaseSubscription = class extends EventEmitter {
       this._recover = false;
       this._offset = null;
       this._epoch = null;
+      this._mapPositionResets++;
     }
   }
   /** setData allows setting subscription data. This only applied on the next subscription attempt,
@@ -763,10 +805,12 @@ var BaseSubscription = class extends EventEmitter {
     }
     return new Promise((resolve, reject) => {
       const timeoutDuration = this._centrifuge._config.timeout;
+      const id = this._nextPromiseId();
       const timeout = setTimeout(() => {
+        delete this._promises[id];
         reject({ code: errorCodes.timeout, message: "timeout" });
       }, timeoutDuration);
-      this._promises[this._nextPromiseId()] = {
+      this._promises[id] = {
         timeout,
         resolve,
         reject
@@ -792,6 +836,7 @@ var BaseSubscription = class extends EventEmitter {
     if (this.state !== newState) {
       const oldState = this.state;
       this.state = newState;
+      this._stateTransitions++;
       this.emit("state", { newState, oldState, channel: this.channel });
       return true;
     }
@@ -806,18 +851,24 @@ var BaseSubscription = class extends EventEmitter {
   }
   _clearSubscribedState() {
     this._clearRefreshTimeout();
+    this._refreshGeneration++;
     this._cancelAllDebounce();
     this._clearSharedPollSignatureRefresh();
     this._clearSharedPollTrackRetry();
     this._clearSharedPollReplayRetry();
     this._sharedPollSignatureRefreshTargetMs = null;
     this._sharedPollSignatureRefreshInFlight = false;
+    this._sharedPollSignatureRefreshAgain = false;
   }
   /** Called on "state invalidated" — unsubscribe code 2502 for this channel,
-   *  or connection disconnect code 3014. Clears the token (next subscribe
-   *  fetches a fresh one) and the fossil delta base (every subscription type
-   *  uses _prevValueMap; a stale base would corrupt decoding of the first
-   *  publication after re-subscribe).
+   *  or connection disconnect code 3014. Clears the token when getToken is set
+   *  (next subscribe fetches a fresh one) and the fossil delta base (every
+   *  subscription type uses _prevValueMap; a stale base would corrupt decoding
+   *  of the first publication after re-subscribe).
+   *
+   *  Without getToken there is no new token to get: the subscription keeps the
+   *  token it has (or none) and resubscribes with it. The server rejects it if
+   *  it's no longer valid.
    *
    *  Map subscriptions restart from scratch: their recovery position and
    *  materialized-state buffers are dropped so the next subscribe does a full
@@ -831,17 +882,20 @@ var BaseSubscription = class extends EventEmitter {
    *  subscribe), while a non-recoverable one simply resubscribes. The real
    *  epoch/offset are adopted from the subscribe reply. */
   _invalidateState() {
-    this._token = "";
+    if (this._getToken !== null) {
+      this._token = "";
+    }
     this._prevValueMap = /* @__PURE__ */ new Map();
     if (this._map) {
       this._offset = null;
       this._epoch = null;
       this._recover = false;
+      this._mapPositionResets++;
       this._mapStateBuffer = [];
       this._mapStreamBuffer = [];
       this._mapCursor = "";
       this._mapPhase = null;
-    } else {
+    } else if (this._offset !== null) {
       this._offset = 0;
       this._epoch = "_";
     }
@@ -856,8 +910,10 @@ var BaseSubscription = class extends EventEmitter {
     }
     if (result.recoverable) {
       this._recover = true;
-      this._offset = result.offset || 0;
+      this._offset = toOffset(result.offset);
       this._epoch = result.epoch || "";
+    } else {
+      this._recover = false;
     }
     if (result.delta) {
       this._delta_negotiated = true;
@@ -877,19 +933,20 @@ var BaseSubscription = class extends EventEmitter {
       this._sharedPollEpoch = newEpoch;
     }
     this._setState(SubscriptionState.Subscribed);
+    if (!this._isSubscribed()) {
+      return;
+    }
     const ctx = this._centrifuge._getSubscribeContext(this.channel, result);
     this.emit("subscribed", ctx);
+    if (!this._isSubscribed()) {
+      return;
+    }
     this._resolvePromises();
-    const pubs = result.publications;
-    if (pubs && pubs.length > 0) {
-      for (const i in pubs) {
-        if (!pubs.hasOwnProperty(i)) {
-          continue;
-        }
-        this._handlePublication(pubs[i]);
-      }
+    const pubs = result.publications || [];
+    for (let i = 0; i < pubs.length && this._isSubscribed(); i++) {
+      this._handlePublication(pubs[i]);
     }
-    if (result.expires === true) {
+    if (result.expires === true && this._isSubscribed()) {
       this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));
     }
   }
@@ -902,11 +959,14 @@ var BaseSubscription = class extends EventEmitter {
         this._clearSubscribedState();
       }
       this._id = 0;
-      if (this._setState(SubscriptionState.Subscribing)) {
+      const transition = this._stateTransitions + 1;
+      if (this._setState(SubscriptionState.Subscribing) && this._stateTransitions === transition) {
         this.emit("subscribing", { channel: this.channel, code, reason });
       }
       if (this._centrifuge._transport && this._centrifuge._transport.emulation()) {
         yield this._unsubPromise;
+        yield this._centrifuge._removedSubscriptionUnsubscribed(this.channel);
+        yield this._sharedPollQueue;
       }
       if (!this._isSubscribing()) {
         return;
@@ -928,25 +988,60 @@ var BaseSubscription = class extends EventEmitter {
       this._mapSubscribe();
       return null;
     }
+    const flow = this._subscribeFlow;
     if (this._getState && this._offset === null) {
-      this._loadStreamState();
+      this._loadStreamState(flow);
       return null;
     }
     if (this._canSubscribeWithoutGettingToken()) {
-      return this._subscribeWithoutToken();
+      return this._subscribeWithoutToken(flow);
     }
-    this._getSubscriptionToken().then((token) => this._handleTokenResponse(token)).catch((e) => this._handleTokenError(e));
+    this._getSubscriptionToken().then((token) => this._handleTokenResponse(token, flow)).catch((e) => this._handleTokenError(e, flow));
     return null;
   }
+  _flowOutdated(flow) {
+    return flow !== this._subscribeFlow;
+  }
+  // Over emulation commands go in separate requests the server may handle in any
+  // order: an unsubscribe of a subscribe in flight could overtake it, and the
+  // server would keep the subscription. The unsubscribe waits for the
+  // subscribe's reply then.
+  _mustDeferUnsubscribe() {
+    const transport = this._centrifuge._transport;
+    return this._subscribeCallFlow === this._subscribeFlow && !!transport && transport.emulation();
+  }
+  // Called first by the reply handlers of a subscribe command or map page. True
+  // when the reply belongs to a subscribe whose unsubscribe was deferred, which is
+  // handled here: the unsubscribe goes out if the subscribe succeeded. A timeout
+  // leaves unknown whether the server subscribed: the client reconnects.
+  _settleSubscribeCall(flow, ok, error) {
+    if (this._subscribeCallFlow === flow) {
+      this._subscribeCallFlow = null;
+    }
+    const deferred = this._deferredUnsubscribe;
+    if (deferred === null || deferred.flow !== flow) {
+      return false;
+    }
+    this._deferredUnsubscribe = null;
+    if (ok) {
+      this._centrifuge._unsubscribe(this).then(deferred.resolve);
+      return true;
+    }
+    deferred.resolve();
+    if (error && error.code === errorCodes.timeout) {
+      this._centrifuge._disconnect(connectingCodes.subscribeTimeout, "subscribe timeout", true);
+    }
+    return true;
+  }
   _isTransportOpen() {
     return this._centrifuge._transportIsOpen;
   }
   _canSubscribeWithoutGettingToken() {
     return !this._usesToken() || !!this._token;
   }
-  _subscribeWithoutToken() {
+  _subscribeWithoutToken(flow) {
     if (this._getData) {
-      this._getDataAndSubscribe(this._token);
+      this._getDataAndSubscribe(this._token, flow);
       return null;
     } else {
       return this._sendSubscribe(this._token);
@@ -969,25 +1064,31 @@ var BaseSubscription = class extends EventEmitter {
    * This order is critical: reading position first ensures it's a lower bound.
    * Recovered publications may overlap with data the app already loaded — this
    * requires idempotent updates or offset-based dedup. */
-  _loadStreamState() {
+  _loadStreamState(flow) {
     if (!this._isSubscribing()) {
       this._inflight = false;
       return;
     }
-    this._getState().then((result) => {
+    this._callAsync(() => this._getState()).then((result) => {
+      if (this._flowOutdated(flow)) {
+        return;
+      }
       if (!this._isSubscribing()) {
         this._inflight = false;
         return;
       }
-      this._offset = result.offset;
+      this._offset = toOffset(result.offset);
       this._epoch = result.epoch;
       this._recover = true;
       if (this._canSubscribeWithoutGettingToken()) {
-        this._subscribeWithoutToken();
+        this._subscribeWithoutToken(flow);
       } else {
-        this._getSubscriptionToken().then((token) => this._handleTokenResponse(token)).catch((e) => this._handleTokenError(e));
+        this._getSubscriptionToken().then((token) => this._handleTokenResponse(token, flow)).catch((e) => this._handleTokenError(e, flow));
       }
     }).catch((e) => {
+      if (this._flowOutdated(flow)) {
+        return;
+      }
       if (!this._isSubscribing()) {
         this._inflight = false;
         return;
@@ -1000,21 +1101,27 @@ var BaseSubscription = class extends EventEmitter {
       });
     });
   }
-  _getDataAndSubscribe(token) {
+  _getDataAndSubscribe(token, flow) {
     if (!this._getData) {
       this._inflight = false;
       return;
     }
-    this._getData({ channel: this.channel }).then((data) => {
+    this._callAsync(() => this._getData({ channel: this.channel })).then((data) => {
+      if (this._flowOutdated(flow)) {
+        return;
+      }
       if (!this._isSubscribing()) {
         this._inflight = false;
         return;
       }
       this._data = data;
       this._sendSubscribe(token);
-    }).catch((e) => this._handleGetDataError(e));
+    }).catch((e) => this._handleGetDataError(e, flow));
   }
-  _handleGetDataError(error) {
+  _handleGetDataError(error, flow) {
+    if (this._flowOutdated(flow)) {
+      return;
+    }
     if (!this._isSubscribing()) {
       this._inflight = false;
       return;
@@ -1024,18 +1131,22 @@ var BaseSubscription = class extends EventEmitter {
       this._failUnauthorized();
       return;
     }
-    this.emit("error", {
+    this._emitError({
       type: "subscribeData",
       channel: this.channel,
       error: {
         code: errorCodes.badConfiguration,
         message: (error === null || error === void 0 ? void 0 : error.toString()) || ""
       }
+    }, () => {
+      this._inflight = false;
+      this._scheduleResubscribe();
     });
-    this._inflight = false;
-    this._scheduleResubscribe();
   }
-  _handleTokenResponse(token) {
+  _handleTokenResponse(token, flow) {
+    if (this._flowOutdated(flow)) {
+      return;
+    }
     if (!this._isSubscribing()) {
       this._inflight = false;
       return;
@@ -1047,12 +1158,15 @@ var BaseSubscription = class extends EventEmitter {
     }
     this._token = token;
     if (this._getData) {
-      this._getDataAndSubscribe(token);
+      this._getDataAndSubscribe(token, flow);
     } else {
       this._sendSubscribe(token);
     }
   }
-  _handleTokenError(error) {
+  _handleTokenError(error, flow) {
+    if (this._flowOutdated(flow)) {
+      return;
+    }
     if (!this._isSubscribing()) {
       this._inflight = false;
       return;
@@ -1062,16 +1176,17 @@ var BaseSubscription = class extends EventEmitter {
       this._failUnauthorized();
       return;
     }
-    this.emit("error", {
+    this._emitError({
       type: "subscribeToken",
       channel: this.channel,
       error: {
         code: errorCodes.subscriptionSubscribeToken,
         message: (error === null || error === void 0 ? void 0 : error.toString()) || ""
       }
+    }, () => {
+      this._inflight = false;
+      this._scheduleResubscribe();
     });
-    this._inflight = false;
-    this._scheduleResubscribe();
   }
   _sendSubscribe(token) {
     if (!this._isTransportOpen()) {
@@ -1079,18 +1194,41 @@ var BaseSubscription = class extends EventEmitter {
       return null;
     }
     const cmd = this._buildSubscribeCommand(token);
+    const flow = this._subscribeFlow;
+    this._subscribeCallFlow = flow;
     this._centrifuge._call(cmd).then((resolveCtx) => {
-      this._inflight = false;
-      const result = resolveCtx.reply.subscribe;
-      this._handleSubscribeResponse(result);
-      if (resolveCtx.next) {
-        resolveCtx.next();
+      try {
+        if (this._settleSubscribeCall(flow, true)) {
+          return;
+        }
+        if (flow !== this._subscribeFlow) {
+          return;
+        }
+        this._inflight = false;
+        this._handleSubscribeResponse(resolveCtx.reply.subscribe);
+      } catch (err) {
+        this._centrifuge._dispatchFailed(err);
+      } finally {
+        if (resolveCtx.next) {
+          resolveCtx.next();
+        }
       }
     }, (rejectCtx) => {
-      this._inflight = false;
-      this._handleSubscribeError(rejectCtx.error);
-      if (rejectCtx.next) {
-        rejectCtx.next();
+      try {
+        if (this._settleSubscribeCall(flow, false, rejectCtx.error)) {
+          return;
+        }
+        if (flow !== this._subscribeFlow) {
+          return;
+        }
+        this._inflight = false;
+        this._handleSubscribeError(rejectCtx.error);
+      } catch (err) {
+        this._centrifuge._rejectionFailed(err, rejectCtx);
+      } finally {
+        if (rejectCtx.next) {
+          rejectCtx.next();
+        }
       }
     });
     return cmd;
@@ -1135,10 +1273,22 @@ var BaseSubscription = class extends EventEmitter {
   _debug(...args) {
     this._centrifuge._debug(...args);
   }
+  /** @internal An exception escaping a handler stops the client: see Centrifuge._handlerFailed. */
+  emit(event, ...args) {
+    try {
+      return EventEmitter.prototype.emit.call(this, event, ...args);
+    } catch (e) {
+      this._centrifuge._handlerFailed(e);
+      return true;
+    }
+  }
   _handleSubscribeError(error) {
     if (!this._isSubscribing()) {
       return;
     }
+    if (error.code === errorCodes.connectionClosed) {
+      return;
+    }
     if (error.code === errorCodes.timeout) {
       this._centrifuge._disconnect(connectingCodes.subscribeTimeout, "subscribe timeout", true);
       return;
@@ -1157,7 +1307,12 @@ var BaseSubscription = class extends EventEmitter {
     if (!this._isSubscribing()) {
       return;
     }
-    this._setSubscribed(result);
+    this._sharedPollReplayPending = this._sharedPoll;
+    try {
+      this._setSubscribed(result);
+    } finally {
+      this._sharedPollReplayPending = false;
+    }
     if (this._sharedPoll) {
       this._sharedPollReplayTrack();
     }
@@ -1169,45 +1324,61 @@ var BaseSubscription = class extends EventEmitter {
     let promise = Promise.resolve();
     if (this._isSubscribed()) {
       if (sendUnsubscribe) {
-        promise = this._centrifuge._unsubscribe(this);
+        promise = this._unsubPromise = this._centrifuge._unsubscribe(this);
       }
       this._clearSubscribedState();
     } else if (this._isSubscribing()) {
       if (this._inflight && sendUnsubscribe) {
-        promise = this._centrifuge._unsubscribe(this);
+        if (this._mustDeferUnsubscribe()) {
+          const flow = this._subscribeFlow;
+          promise = this._unsubPromise = new Promise((resolve) => {
+            this._deferredUnsubscribe = { flow, resolve };
+          });
+        } else {
+          promise = this._unsubPromise = this._centrifuge._unsubscribe(this);
+        }
       }
       this._clearSubscribingState();
     }
     this._inflight = false;
+    this._subscribeFlow++;
     this._id = 0;
     this._sharedPollEpoch = "";
     this._sharedPollSignatures = [];
     this._sharedPollTrackedItems.clear();
     this._sharedPollSignatureRefreshInFlight = false;
+    this._sharedPollSignatureRefreshAgain = false;
     this._sharedPollSignatureRefreshTargetMs = null;
     this._cancelAllDebounce();
-    if (this._setState(SubscriptionState.Unsubscribed)) {
+    this._rejectPromises({ code: errorCodes.subscriptionUnsubscribed, message: SubscriptionState.Unsubscribed });
+    const transition = this._stateTransitions + 1;
+    if (this._setState(SubscriptionState.Unsubscribed) && this._stateTransitions === transition) {
       this.emit("unsubscribed", { channel: this.channel, code, reason });
     }
-    this._rejectPromises({ code: errorCodes.subscriptionUnsubscribed, message: this.state });
     return promise;
   }
   _handlePublication(pub) {
+    if (this._sharedPoll && pub.key && !pub.removed && hasOffset(pub.version)) {
+      const known = this._sharedPollTrackedItems.get(pub.key);
+      if (known !== void 0 && known > 0 && toOffset(pub.version) <= known) {
+        return;
+      }
+    }
     if (this._delta && this._delta_negotiated) {
       const deltaKey = this._map || this._sharedPoll ? pub.key || "" : "";
-      const { newData, newPrevValue, isDelta, wireBytes, fullBytes } = this._centrifuge._codec.applyDeltaIfNeeded(pub, this._prevValueMap.get(deltaKey));
-      pub.data = newData;
-      this._deltaNumPubs++;
-      this._deltaBytesReceived += wireBytes;
-      this._deltaBytesDecoded += fullBytes;
-      if (isDelta) {
-        this._deltaNumDelta++;
-      } else {
-        this._deltaNumFull++;
-      }
       if (pub.removed) {
         this._prevValueMap.delete(deltaKey);
       } else {
+        const { newData, newPrevValue, isDelta, wireBytes, fullBytes } = this._centrifuge._codec.applyDeltaIfNeeded(pub, this._prevValueMap.get(deltaKey));
+        pub.data = newData;
+        this._deltaNumPubs++;
+        this._deltaBytesReceived += wireBytes;
+        this._deltaBytesDecoded += fullBytes;
+        if (isDelta) {
+          this._deltaNumDelta++;
+        } else {
+          this._deltaNumFull++;
+        }
         this._prevValueMap.set(deltaKey, newPrevValue);
       }
     }
@@ -1216,25 +1387,43 @@ var BaseSubscription = class extends EventEmitter {
       if (pub.key && !this._sharedPollTrackedItems.has(pub.key)) {
         return;
       }
-      if (pub.key) {
-        if (pub.removed) {
-          this._sharedPollTrackedItems.delete(pub.key);
-        } else if (pub.version) {
-          this._sharedPollTrackedItems.set(pub.key, pub.version);
-        }
-      }
       ctx = this._getSharedPollUpdateContext(pub);
     } else if (this._map) {
       ctx = this._getMapUpdateContext(pub);
     } else {
       ctx = this._centrifuge._getPublicationContext(this.channel, pub);
     }
-    this.emit("publication", ctx);
     if (this._map || this._sharedPoll) {
+      this.emit("publication", ctx);
+      if (!this._isSubscribed()) {
+        return;
+      }
+      this._setPublicationPosition(pub);
       this.emit("update", ctx);
+    } else {
+      this._pendingOffset = hasOffset(pub.offset) ? toOffset(pub.offset) : null;
+      const failures = this._centrifuge._handlerFailures;
+      try {
+        this.emit("publication", ctx);
+      } finally {
+        this._pendingOffset = null;
+      }
+      if (this._centrifuge._handlerFailures !== failures) {
+        return;
+      }
+      this._setPublicationPosition(pub);
     }
-    if (pub.offset) {
-      this._offset = pub.offset;
+  }
+  _setPublicationPosition(pub) {
+    if (this._sharedPoll && pub.key && this._sharedPollTrackedItems.has(pub.key)) {
+      if (pub.removed) {
+        this._sharedPollTrackedItems.delete(pub.key);
+      } else if (pub.version) {
+        this._sharedPollTrackedItems.set(pub.key, toOffset(pub.version));
+      }
+    }
+    if (hasOffset(pub.offset)) {
+      this._offset = toOffset(pub.offset);
     }
     if (pub.epoch) {
       this._epoch = pub.epoch;
@@ -1242,18 +1431,24 @@ var BaseSubscription = class extends EventEmitter {
   }
   /** Seed per-key delta tracking from state/stream entries.
    * Handles JSON-escaped data (server-side delta escaping) and protobuf data.
-   * Decodes escaped data back to original format for user consumption. */
-  _seedDeltaTracking(pub) {
+   * Decodes escaped data back to original format for user consumption.
+   * Values are escaped only when delta is negotiated: otherwise they come as
+   * they are, and a string value must not be parsed. */
+  _seedDeltaTracking(pub, deltaNegotiated) {
     if (!this._delta || !pub.key)
       return;
+    if (pub.removed) {
+      this._prevValueMap.delete(pub.key);
+      return;
+    }
+    if (!deltaNegotiated) {
+      this._prevValueMap.set(pub.key, pub.data);
+      return;
+    }
     if (typeof pub.data === "string") {
       const rawBytes = pub.data;
       const encoded = new TextEncoder().encode(rawBytes);
-      if (!pub.removed) {
-        this._prevValueMap.set(pub.key, encoded);
-      } else {
-        this._prevValueMap.delete(pub.key);
-      }
+      this._prevValueMap.set(pub.key, encoded);
       const byteLen = encoded.length;
       this._deltaNumPubs++;
       this._deltaNumFull++;
@@ -1261,11 +1456,7 @@ var BaseSubscription = class extends EventEmitter {
       this._deltaBytesDecoded += byteLen;
       pub.data = JSON.parse(rawBytes);
     } else if (pub.data instanceof Uint8Array) {
-      if (!pub.removed) {
-        this._prevValueMap.set(pub.key, pub.data);
-      } else {
-        this._prevValueMap.delete(pub.key);
-      }
+      this._prevValueMap.set(pub.key, pub.data);
       const byteLen = pub.data.length;
       this._deltaNumPubs++;
       this._deltaNumFull++;
@@ -1312,17 +1503,47 @@ var BaseSubscription = class extends EventEmitter {
     }
     const self2 = this;
     const delay = this._getResubscribeDelay();
+    this._clearResubscribeTimeout();
     this._resubscribeTimeout = setTimeout(function() {
+      self2._resubscribeTimeout = null;
       if (self2._isSubscribing()) {
         self2._subscribe();
       }
     }, delay);
     this._debug("resubscribe scheduled after " + delay, this.channel);
   }
+  // Emits an error event, then runs the continuation: not when a handler unsubscribed,
+  // maybe to subscribe again, whose new subscribe the continuation must not touch.
+  _emitError(ctx, continuation) {
+    const flow = this._subscribeFlow;
+    try {
+      this.emit("error", ctx);
+    } finally {
+      if (flow === this._subscribeFlow) {
+        continuation();
+      }
+    }
+  }
   _subscribeError(err) {
     if (!this._isSubscribing()) {
       return;
     }
+    if (err.code === 109 && this._getToken === null) {
+      try {
+        this.emit("error", {
+          type: "configuration",
+          channel: this.channel,
+          error: {
+            code: errorCodes.badConfiguration,
+            message: "subscription token expired but no getToken function set"
+          }
+        });
+      } catch (e) {
+        this._centrifuge._reportDispatchError(e);
+      }
+      this._setUnsubscribed(unsubscribedCodes.unauthorized, "unauthorized", false);
+      return;
+    }
     if (err.code < 100 || err.code === 109 || err.temporary === true) {
       if (err.code === 109) {
         this._token = "";
@@ -1333,9 +1554,10 @@ var BaseSubscription = class extends EventEmitter {
         error: err
       };
       if (this._centrifuge.state === State.Connected) {
-        this.emit("error", errContext);
+        this._emitError(errContext, () => this._scheduleResubscribe());
+      } else {
+        this._scheduleResubscribe();
       }
-      this._scheduleResubscribe();
     } else {
       this._setUnsubscribed(err.code, err.message, false);
     }
@@ -1350,7 +1572,7 @@ var BaseSubscription = class extends EventEmitter {
       return;
     }
     if (options.since) {
-      this._offset = options.since.offset || 0;
+      this._offset = toOffset(options.since.offset);
       this._epoch = options.since.epoch || "";
       this._recover = true;
     }
@@ -1418,6 +1640,9 @@ var BaseSubscription = class extends EventEmitter {
     }
   }
   _getOffset() {
+    if (this._pendingOffset !== null) {
+      return this._pendingOffset;
+    }
     const offset = this._offset;
     if (offset !== null) {
       return offset;
@@ -1450,23 +1675,28 @@ var BaseSubscription = class extends EventEmitter {
     };
     const getToken = this._getToken;
     if (getToken === null) {
-      this.emit("error", {
-        type: "configuration",
-        channel: this.channel,
-        error: {
-          code: errorCodes.badConfiguration,
-          message: "provide a function to get channel subscription token"
-        }
-      });
+      try {
+        this.emit("error", {
+          type: "configuration",
+          channel: this.channel,
+          error: {
+            code: errorCodes.badConfiguration,
+            message: "provide a function to get channel subscription token"
+          }
+        });
+      } catch (e) {
+        this._centrifuge._reportDispatchError(e);
+      }
       return Promise.reject(new UnauthorizedError(""));
     }
-    return getToken(ctx);
+    return this._callAsync(() => getToken(ctx));
   }
   _refresh() {
     this._clearRefreshTimeout();
     const self2 = this;
+    const generation = this._refreshGeneration;
     this._getSubscriptionToken().then(function(token) {
-      if (!self2._isSubscribed()) {
+      if (generation !== self2._refreshGeneration || !self2._isSubscribed()) {
         return;
       }
       if (!token) {
@@ -1482,31 +1712,47 @@ var BaseSubscription = class extends EventEmitter {
         "sub_refresh": req
       };
       self2._centrifuge._call(msg).then((resolveCtx) => {
-        const result = resolveCtx.reply.sub_refresh;
-        self2._refreshResponse(result);
-        if (resolveCtx.next) {
-          resolveCtx.next();
+        try {
+          self2._refreshResponse(resolveCtx.reply.sub_refresh);
+        } catch (err) {
+          self2._centrifuge._dispatchFailed(err);
+        } finally {
+          if (resolveCtx.next) {
+            resolveCtx.next();
+          }
         }
       }, (rejectCtx) => {
-        self2._refreshError(rejectCtx.error);
-        if (rejectCtx.next) {
-          rejectCtx.next();
+        try {
+          self2._refreshError(rejectCtx.error);
+        } catch (err) {
+          self2._centrifuge._rejectionFailed(err, rejectCtx);
+        } finally {
+          if (rejectCtx.next) {
+            rejectCtx.next();
+          }
         }
       });
     }).catch(function(e) {
+      if (generation !== self2._refreshGeneration || !self2._isSubscribed()) {
+        return;
+      }
       if (e instanceof UnauthorizedError) {
         self2._failUnauthorized();
         return;
       }
-      self2.emit("error", {
+      self2._emitError({
         type: "refreshToken",
         channel: self2.channel,
         error: {
           code: errorCodes.subscriptionRefreshToken,
           message: e !== void 0 ? e.toString() : ""
         }
+      }, () => {
+        if (generation !== self2._refreshGeneration || !self2._isSubscribed()) {
+          return;
+        }
+        self2._refreshTimeout = setTimeout(() => self2._refresh(), self2._getRefreshRetryDelay());
       });
-      self2._refreshTimeout = setTimeout(() => self2._refresh(), self2._getRefreshRetryDelay());
     });
   }
   _refreshResponse(result) {
@@ -1524,12 +1770,16 @@ var BaseSubscription = class extends EventEmitter {
       return;
     }
     if (err.code < 100 || err.temporary === true) {
-      this.emit("error", {
+      this._emitError({
         type: "refresh",
         channel: this.channel,
         error: err
+      }, () => {
+        if (!this._isSubscribed()) {
+          return;
+        }
+        this._refreshTimeout = setTimeout(() => this._refresh(), this._getRefreshRetryDelay());
       });
-      this._refreshTimeout = setTimeout(() => this._refresh(), this._getRefreshRetryDelay());
     } else {
       this._setUnsubscribed(err.code, err.message, true);
     }
@@ -1537,6 +1787,16 @@ var BaseSubscription = class extends EventEmitter {
   _getRefreshRetryDelay() {
     return backoff(0, 1e4, 2e4);
   }
+  // Calls an app callback expected to return a promise: one throwing instead of
+  // returning a rejected promise fails the same way, not by throwing out of the
+  // subscribe or refresh in progress.
+  _callAsync(callback) {
+    try {
+      return Promise.resolve(callback());
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
   _failUnauthorized() {
     this._setUnsubscribed(unsubscribedCodes.unauthorized, "unauthorized", true);
   }
@@ -1569,7 +1829,8 @@ var BaseSubscription = class extends EventEmitter {
     }
     if (current.length > 0)
       frames.push(current);
-    const send = (frame, frameUntrackKeys) => new Promise((resolve, reject) => {
+    const keysFrom = (idx) => frames.slice(idx).flatMap((f) => f.flatMap((b) => b.items.map((i) => i.key)));
+    const send = (frame, idx, frameUntrackKeys) => new Promise((resolve, reject) => {
       const req = {
         channel: this.channel,
         type: 1,
@@ -1583,20 +1844,55 @@ var BaseSubscription = class extends EventEmitter {
       }
       const msg = { "sub_refresh": req };
       this._centrifuge._call(msg).then((resolveCtx) => {
-        this._handleTrackResponse(resolveCtx.reply.sub_refresh);
-        if (resolveCtx.next)
-          resolveCtx.next();
+        try {
+          this._handleTrackResponse(resolveCtx.reply.sub_refresh, frame.flatMap((b) => b.items.map((i) => i.key)), frameUntrackKeys);
+        } catch (err) {
+          this._centrifuge._dispatchFailed(err);
+        } finally {
+          if (resolveCtx.next)
+            resolveCtx.next();
+        }
         resolve();
       }, (rejectCtx) => {
         if (rejectCtx.next)
           rejectCtx.next();
-        reject(rejectCtx.error);
+        this._sharedPollRequestFailed(rejectCtx.error);
+        reject({ error: rejectCtx.error, keys: keysFrom(idx) });
       });
     });
-    return frames.reduce((chain, frame, idx) => chain.then(() => send(frame, idx === 0 ? untrackKeys : void 0)), Promise.resolve());
+    return this._sharedPollSerial(() => frames.reduce((chain, frame, idx) => chain.then(() => send(frame, idx, idx === 0 ? untrackKeys : void 0)), Promise.resolve()));
+  }
+  _isEmulation() {
+    const transport = this._centrifuge._transport;
+    return !!transport && transport.emulation();
+  }
+  // Over emulation each request is a separate HTTP request the server may handle
+  // in any order: a track and an untrack of a key could overtake each other. The
+  // channel's requests go one at a time then, in the order made; one made for a
+  // subscription that has ended by its turn is dropped.
+  _sharedPollSerial(send) {
+    if (!this._isEmulation()) {
+      return send();
+    }
+    const generation = this._refreshGeneration;
+    const run = this._sharedPollQueue.then(() => {
+      if (generation !== this._refreshGeneration || !this._isSubscribed()) {
+        return;
+      }
+      return send();
+    });
+    this._sharedPollQueue = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  // A timed-out request over emulation may still reach the server after later
+  // ones: whether the keys are tracked is unknown, the client reconnects.
+  _sharedPollRequestFailed(error) {
+    if (error && error.code === errorCodes.timeout && this._isEmulation()) {
+      this._centrifuge._disconnect(connectingCodes.subscribeTimeout, "shared poll request timeout", true);
+    }
   }
   _sendUntrackRequest(keys) {
-    return new Promise((resolve, reject) => {
+    return this._sharedPollSerial(() => new Promise((resolve, reject) => {
       const req = {
         channel: this.channel,
         type: 2,
@@ -1612,19 +1908,36 @@ var BaseSubscription = class extends EventEmitter {
         if (rejectCtx.next) {
           rejectCtx.next();
         }
+        this._sharedPollRequestFailed(rejectCtx.error);
         reject(rejectCtx.error);
       });
-    });
+    }));
   }
-  _handleTrackResponse(result) {
+  _handleTrackResponse(result, keys, untrackKeys) {
+    if (!this._isSubscribed()) {
+      return;
+    }
     this._clearSharedPollTrackRetry();
     if (result && result.items && result.items.length > 0) {
       for (const pub of result.items) {
+        if (!this._isSubscribed()) {
+          return;
+        }
         this._handlePublication(pub);
       }
     }
-    if (result && result.expires === true && result.ttl > 0) {
-      const targetMs = Date.now() + result.ttl * 1e3;
+    if (!this._isSubscribed()) {
+      return;
+    }
+    const untracked = new Set(untrackKeys || []);
+    const stale = keys.filter((key) => !untracked.has(key) && !this._sharedPollTrackedItems.has(key));
+    if (stale.length > 0) {
+      this._sendUntrackRequest(stale).catch((err) => {
+        this.emit("error", { type: "untrack", channel: this.channel, error: err });
+      });
+    }
+    if (result && result.expires === true) {
+      const targetMs = Date.now() + (result.ttl > 0 ? result.ttl * 1e3 : 1e3);
       this._maybeScheduleSharedPollSignatureRefresh(targetMs);
     }
   }
@@ -1660,6 +1973,12 @@ var BaseSubscription = class extends EventEmitter {
     }
     this._sharedPollTrackRetryAttempts = 0;
   }
+  _scheduleSharedPollReplayRetry() {
+    if (this._sharedPollReplayRetryTimeout !== null) {
+      clearTimeout(this._sharedPollReplayRetryTimeout);
+    }
+    this._sharedPollReplayRetryTimeout = setTimeout(() => this._sharedPollReplayTrack(), backoff(this._sharedPollReplayRetryAttempts++, 5e3, 3e4));
+  }
   _clearSharedPollReplayRetry() {
     if (this._sharedPollReplayRetryTimeout !== null) {
       clearTimeout(this._sharedPollReplayRetryTimeout);
@@ -1667,21 +1986,59 @@ var BaseSubscription = class extends EventEmitter {
     }
     this._sharedPollReplayRetryAttempts = 0;
   }
-  _handleTrackError(err) {
+  // Adds a signature to the library, dropping the entries whose keys it covers
+  // entirely: they may have expired, and a replay sends every entry in one request,
+  // which a single expired signature fails as a whole.
+  _addSharedPollSignature(keys, signature) {
+    const covered = new Set(keys);
+    this._sharedPollSignatures = this._sharedPollSignatures.filter((entry) => !entry.keys.every((key) => covered.has(key)));
+    this._sharedPollSignatures.push({ keys, signature });
+  }
+  _handleTrackError(err, keys) {
     if (!this._isSubscribed()) {
       return;
     }
-    this.emit("error", {
+    this._emitError({
       type: "track",
       channel: this.channel,
       error: err
+    }, () => {
+      if (!this._isSubscribed()) {
+        return;
+      }
+      if (err.code === 109) {
+        this._sharedPollRefreshSignature();
+        return;
+      }
+      if (err.code < 100 || err.temporary === true) {
+        this._sharedPollTrackRetryTimeout = setTimeout(() => this._sharedPollReplayTrack(), backoff(this._sharedPollTrackRetryAttempts++, 1e3, 15e3));
+        return;
+      }
+      this._untrackFailedKeys(keys);
     });
-    if (err.code === 109) {
-      this._sharedPollRefreshSignature();
+  }
+  _untrackFailedKeys(keys) {
+    const failed = keys.filter((key) => this._sharedPollTrackedItems.has(key));
+    if (failed.length === 0) {
       return;
     }
-    if (err.code < 100 || err.temporary === true) {
-      this._sharedPollTrackRetryTimeout = setTimeout(() => this._sharedPollReplayTrack(), backoff(this._sharedPollTrackRetryAttempts++, 1e3, 15e3));
+    for (const key of failed) {
+      this._sharedPollTrackedItems.delete(key);
+    }
+    this._sharedPollSignatures = this._sharedPollSignatures.filter((entry) => entry.keys.some((k) => this._sharedPollTrackedItems.has(k)));
+    this._sendUntrackRequest(failed).catch((err) => {
+      this.emit("error", { type: "untrack", channel: this.channel, error: err });
+    });
+    for (const key of failed) {
+      if (!this._isSubscribed()) {
+        return;
+      }
+      this.emit("update", {
+        channel: this.channel,
+        key,
+        data: null,
+        removed: true
+      });
     }
   }
   // _sharedPollRefreshSignature obtains a fresh consolidated signature
@@ -1697,23 +2054,41 @@ var BaseSubscription = class extends EventEmitter {
       return;
     if (this._sharedPollTrackedItems.size === 0)
       return;
-    if (this._sharedPollSignatureRefreshInFlight)
+    if (this._sharedPollSignatureRefreshInFlight) {
+      for (const key of this._sharedPollTrackedItems.keys()) {
+        if (!this._sharedPollSignatureRefreshKeys.has(key)) {
+          this._sharedPollSignatureRefreshAgain = true;
+          break;
+        }
+      }
       return;
+    }
     this._sharedPollSignatureRefreshTargetMs = null;
     this._sharedPollSignatureRefreshInFlight = true;
     const keys = Array.from(this._sharedPollTrackedItems.keys());
+    this._sharedPollSignatureRefreshKeys = new Set(keys);
     const self2 = this;
-    this._sharedPollGetSignature({ keys }).then((result) => {
+    const generation = this._refreshGeneration;
+    this._callAsync(() => this._sharedPollGetSignature({ keys })).then((result) => {
+      if (generation !== self2._refreshGeneration)
+        return;
       self2._sharedPollSignatureRefreshInFlight = false;
       if (!self2._isSubscribed())
         return;
       self2._sharedPollSignatureRefreshAttempts = 0;
+      if (self2._sharedPollSignatureRefreshAgain) {
+        self2._sharedPollSignatureRefreshAgain = false;
+        Promise.resolve().then(() => self2._sharedPollRefreshSignature());
+      }
       const returnedKeys = new Set(result.keys);
       const revokedKeys = [];
       for (const key of keys) {
-        if (!returnedKeys.has(key)) {
+        if (!returnedKeys.has(key) && this._sharedPollTrackedItems.has(key)) {
           self2._sharedPollTrackedItems.delete(key);
           revokedKeys.push(key);
+          if (!self2._isSubscribed()) {
+            continue;
+          }
           self2.emit("update", {
             channel: self2.channel,
             key,
@@ -1739,20 +2114,27 @@ var BaseSubscription = class extends EventEmitter {
       self2._sharedPollSignatures = items.length > 0 ? [{ keys: result.keys, signature: result.signature }, ...uncovered] : uncovered;
       if (items.length === 0)
         return;
-      self2._sendTrackRequest([{ items, signature: result.signature }]).catch((err) => {
-        self2._handleTrackError(err);
+      self2._sendTrackRequest([{ items, signature: result.signature }]).catch((e) => {
+        self2._handleTrackError(e.error, e.keys);
       });
     }).catch((e) => {
+      if (generation !== self2._refreshGeneration)
+        return;
       self2._sharedPollSignatureRefreshInFlight = false;
-      self2.emit("error", {
+      self2._sharedPollSignatureRefreshAgain = false;
+      self2._emitError({
         type: "signatureRefresh",
         channel: self2.channel,
         error: {
           code: errorCodes.sharedPollGetSignature,
           message: e !== void 0 ? e.toString() : ""
         }
+      }, () => {
+        if (generation !== self2._refreshGeneration || !self2._isSubscribed()) {
+          return;
+        }
+        self2._sharedPollSignatureRefreshTimeout = setTimeout(() => self2._sharedPollRefreshSignature(), backoff(self2._sharedPollSignatureRefreshAttempts++, 5e3, 3e4));
       });
-      self2._sharedPollSignatureRefreshTimeout = setTimeout(() => self2._sharedPollRefreshSignature(), backoff(self2._sharedPollSignatureRefreshAttempts++, 5e3, 3e4));
     });
   }
   // _sharedPollReplayTrack runs after subscribe completes — on initial
@@ -1801,8 +2183,8 @@ var BaseSubscription = class extends EventEmitter {
       }
     }
     if (replayBatches.length > 0) {
-      this._sendTrackRequest(replayBatches, allUntrackedInReplay).catch((err) => {
-        this._handleTrackError(err);
+      this._sendTrackRequest(replayBatches, allUntrackedInReplay).catch((e) => {
+        this._handleTrackError(e.error, e.keys);
       });
     }
     const uncoveredKeys = [];
@@ -1821,16 +2203,20 @@ var BaseSubscription = class extends EventEmitter {
       return;
     }
     const self2 = this;
-    this._sharedPollGetSignature({ keys: uncoveredKeys }).then((result) => {
-      if (!self2._isSubscribed())
+    const generation = this._refreshGeneration;
+    this._callAsync(() => this._sharedPollGetSignature({ keys: uncoveredKeys })).then((result) => {
+      if (generation !== self2._refreshGeneration || !self2._isSubscribed())
         return;
       self2._clearSharedPollReplayRetry();
       const returnedKeys = new Set(result.keys);
       const revokedKeys = [];
       for (const key of uncoveredKeys) {
-        if (!returnedKeys.has(key)) {
+        if (!returnedKeys.has(key) && this._sharedPollTrackedItems.has(key)) {
           self2._sharedPollTrackedItems.delete(key);
           revokedKeys.push(key);
+          if (!self2._isSubscribed()) {
+            continue;
+          }
           self2.emit("update", {
             channel: self2.channel,
             key,
@@ -1853,46 +2239,60 @@ var BaseSubscription = class extends EventEmitter {
       }
       if (items.length === 0)
         return;
-      self2._sharedPollSignatures.push({
-        keys: result.keys,
-        signature: result.signature
-      });
-      self2._sendTrackRequest([{ items, signature: result.signature }]).catch((err) => {
-        self2._handleTrackError(err);
+      self2._addSharedPollSignature(result.keys, result.signature);
+      self2._sendTrackRequest([{ items, signature: result.signature }]).catch((e) => {
+        self2._handleTrackError(e.error, e.keys);
       });
     }).catch((e) => {
-      self2.emit("error", {
+      if (generation !== self2._refreshGeneration || !self2._isSubscribed())
+        return;
+      self2._emitError({
         type: "signatureRefresh",
         channel: self2.channel,
         error: {
           code: errorCodes.sharedPollGetSignature,
           message: e !== void 0 ? e.toString() : ""
         }
+      }, () => {
+        if (generation !== self2._refreshGeneration || !self2._isSubscribed())
+          return;
+        self2._sharedPollReplayRetryTimeout = setTimeout(() => self2._sharedPollReplayTrack(), backoff(self2._sharedPollReplayRetryAttempts++, 5e3, 3e4));
       });
-      self2._sharedPollReplayRetryTimeout = setTimeout(() => self2._sharedPollReplayTrack(), backoff(self2._sharedPollReplayRetryAttempts++, 5e3, 3e4));
     });
   }
   // ============ Keyed Subscription Methods ============
   /** Entry point for map subscriptions */
   _mapSubscribe() {
     this._debug("starting map subscribe on", this.channel);
-    this._mapStateBuffer = [];
-    this._mapStreamBuffer = [];
-    this._mapCursor = "";
-    if (!(this._recover && this._offset !== null && this._epoch !== null)) {
-      this._prevValueMap = /* @__PURE__ */ new Map();
-    }
-    this._mapPhase = MapPhase.State;
-    if (this._recover && this._offset !== null && this._epoch !== null) {
-      this._debug("map subscribe: recovering from position, skipping to stream phase");
-      this._mapPhase = MapPhase.Stream;
-      this._fetchStream();
-      return;
-    }
+    const flow = ++this._subscribeFlow;
+    const start = () => {
+      this._mapStateBuffer = [];
+      this._mapStreamBuffer = [];
+      this._mapCursor = "";
+      const recovering = this._recover && this._offset !== null && this._epoch !== null;
+      if (!recovering) {
+        this._prevValueMap = /* @__PURE__ */ new Map();
+      }
+      this._mapFlowRecovering = recovering;
+      this._mapFlowOffset = recovering ? this._offset : 0;
+      this._mapFlowEpoch = recovering ? this._epoch : null;
+      this._mapFlowPositionResets = this._mapPositionResets;
+      this._mapPhase = MapPhase.State;
+      if (recovering) {
+        this._debug("map subscribe: recovering from position, skipping to stream phase");
+        this._mapPhase = MapPhase.Stream;
+        this._fetchStream(flow);
+      } else {
+        this._fetchSnapshot(flow);
+      }
+    };
     if (this._canSubscribeWithoutGettingToken()) {
-      this._fetchSnapshot();
+      start();
     } else {
       this._getSubscriptionToken().then((token) => {
+        if (flow !== this._subscribeFlow) {
+          return;
+        }
         if (!this._isSubscribing()) {
           this._inflight = false;
           return;
@@ -1903,171 +2303,212 @@ var BaseSubscription = class extends EventEmitter {
           return;
         }
         this._token = token;
-        this._fetchSnapshot();
-      }).catch((e) => this._handleTokenError(e));
+        start();
+      }).catch((e) => {
+        this._handleTokenError(e, flow);
+      });
     }
   }
   /** Fetch a page of snapshot data */
-  _fetchSnapshot(cursor) {
+  _fetchSnapshot(flow, cursor) {
     if (!this._isSubscribing() || !this._isTransportOpen()) {
       this._inflight = false;
       return;
     }
     const cmd = this._buildMapSubscribeCommand(MapPhase.State, cursor);
     this._debug("map subscribe: fetching snapshot page", cursor ? `cursor=${cursor}` : "initial");
+    this._subscribeCallFlow = flow;
     this._centrifuge._call(cmd).then((resolveCtx) => {
-      const result = resolveCtx.reply.subscribe;
-      this._handleMapStateResponse(result);
-      if (resolveCtx.next) {
-        resolveCtx.next();
+      try {
+        if (this._settleSubscribeCall(flow, true)) {
+          return;
+        }
+        if (flow === this._subscribeFlow) {
+          this._handleMapStateResponse(flow, resolveCtx.reply.subscribe);
+        }
+      } catch (err) {
+        this._centrifuge._dispatchFailed(err);
+      } finally {
+        if (resolveCtx.next) {
+          resolveCtx.next();
+        }
       }
     }, (rejectCtx) => {
-      this._handleMapSubscribeError(rejectCtx.error);
-      if (rejectCtx.next) {
-        rejectCtx.next();
-      }
-    });
-  }
-  /** Process snapshot response */
-  _handleMapStateResponse(result) {
-    if (!this._isSubscribing()) {
-      this._inflight = false;
+      try {
+        if (this._settleSubscribeCall(flow, false, rejectCtx.error)) {
+          return;
+        }
+        if (flow === this._subscribeFlow) {
+          this._handleMapSubscribeError(rejectCtx.error);
+        }
+      } catch (err) {
+        this._centrifuge._rejectionFailed(err, rejectCtx);
+      } finally {
+        if (rejectCtx.next) {
+          rejectCtx.next();
+        }
+      }
+    });
+  }
+  /** Process snapshot response */
+  _handleMapStateResponse(flow, result) {
+    if (!this._isSubscribing()) {
+      this._inflight = false;
       return;
     }
     if (!result.phase) {
       this._debug("map subscribe: server forced LIVE transition during state pagination");
-      this._handleMapLiveResponse(result);
+      this._handleMapLiveResponse(flow, result);
       return;
     }
-    if (!this._epoch && result.epoch) {
-      this._epoch = result.epoch;
-      this._offset = result.offset || 0;
+    if (!this._mapFlowEpoch && result.epoch) {
+      this._mapFlowEpoch = result.epoch;
+      this._mapFlowOffset = toOffset(result.offset);
     }
-    if (this._epoch && result.epoch && this._epoch !== result.epoch) {
+    if (this._mapFlowEpoch && result.epoch && this._mapFlowEpoch !== result.epoch) {
       this._debug("map subscribe: epoch changed during snapshot pagination, restarting");
-      this._mapStateBuffer = [];
-      this._mapCursor = "";
-      this._epoch = null;
-      this._offset = null;
-      this._prevValueMap = /* @__PURE__ */ new Map();
-      this._fetchSnapshot();
+      this._restartMapFlow();
+      this._fetchSnapshot(flow);
       return;
     }
     if (result.state && result.state.length > 0) {
-      for (const pub of result.state) {
-        this._seedDeltaTracking(pub);
-        this._mapStateBuffer.push(this._getMapUpdateContext(pub));
-      }
+      this._mapStateBuffer.push(...result.state);
     }
     if (result.cursor) {
       this._mapCursor = result.cursor;
-      this._fetchSnapshot(this._mapCursor);
+      this._fetchSnapshot(flow, this._mapCursor);
       return;
     }
-    this._transitionFromSnapshot();
+    this._transitionFromSnapshot(flow);
+  }
+  // The stream epoch changed during the flow: what it collected and the stored
+  // position are outdated. The flow continues from a snapshot.
+  _restartMapFlow() {
+    this._mapStateBuffer = [];
+    this._mapStreamBuffer = [];
+    this._mapCursor = "";
+    this._mapFlowRecovering = false;
+    this._mapFlowOffset = 0;
+    this._mapFlowEpoch = null;
+    this._epoch = null;
+    this._offset = null;
+    this._recover = false;
+    this._prevValueMap = /* @__PURE__ */ new Map();
+    this._mapPhase = MapPhase.State;
   }
   /** Transition from STATE to STREAM phase after snapshot pagination completes */
-  _transitionFromSnapshot() {
+  _transitionFromSnapshot(flow) {
     this._debug("map subscribe: snapshot complete, transitioning to stream phase");
     this._mapPhase = MapPhase.Stream;
-    this._fetchStream();
+    this._fetchStream(flow);
   }
   /** Fetch stream data (offset-based catch-up) */
-  _fetchStream() {
+  _fetchStream(flow) {
     if (!this._isSubscribing() || !this._isTransportOpen()) {
       this._inflight = false;
       return;
     }
     const cmd = this._buildMapSubscribeCommand(MapPhase.Stream);
-    this._debug("map subscribe: fetching stream from offset", this._offset);
+    this._debug("map subscribe: fetching stream from offset", this._mapFlowOffset);
+    this._subscribeCallFlow = flow;
     this._centrifuge._call(cmd).then((resolveCtx) => {
-      const result = resolveCtx.reply.subscribe;
-      this._handleMapStreamResponse(result);
-      if (resolveCtx.next) {
-        resolveCtx.next();
+      try {
+        if (this._settleSubscribeCall(flow, true)) {
+          return;
+        }
+        if (flow === this._subscribeFlow) {
+          this._handleMapStreamResponse(flow, resolveCtx.reply.subscribe);
+        }
+      } catch (err) {
+        this._centrifuge._dispatchFailed(err);
+      } finally {
+        if (resolveCtx.next) {
+          resolveCtx.next();
+        }
       }
     }, (rejectCtx) => {
-      this._handleMapSubscribeError(rejectCtx.error);
-      if (rejectCtx.next) {
-        rejectCtx.next();
+      try {
+        if (this._settleSubscribeCall(flow, false, rejectCtx.error)) {
+          return;
+        }
+        if (flow === this._subscribeFlow) {
+          this._handleMapSubscribeError(rejectCtx.error);
+        }
+      } catch (err) {
+        this._centrifuge._rejectionFailed(err, rejectCtx);
+      } finally {
+        if (rejectCtx.next) {
+          rejectCtx.next();
+        }
       }
     });
   }
   /** Process stream response */
-  _handleMapStreamResponse(result) {
+  _handleMapStreamResponse(flow, result) {
     if (!this._isSubscribing()) {
       this._inflight = false;
       return;
     }
     if (!result.phase) {
       this._debug("map subscribe: server forced LIVE transition during stream");
-      this._handleMapLiveResponse(result);
+      this._handleMapLiveResponse(flow, result);
       return;
     }
-    if (this._epoch && result.epoch && this._epoch !== result.epoch) {
+    if (this._mapFlowEpoch && result.epoch && this._mapFlowEpoch !== result.epoch) {
       this._debug("map subscribe: epoch changed during stream, restarting");
-      this._mapStateBuffer = [];
-      this._mapStreamBuffer = [];
-      this._epoch = null;
-      this._offset = null;
-      this._prevValueMap = /* @__PURE__ */ new Map();
-      this._mapPhase = MapPhase.State;
-      this._fetchSnapshot();
+      this._restartMapFlow();
+      this._fetchSnapshot(flow);
       return;
     }
     if (result.publications && result.publications.length > 0) {
-      for (const pub of result.publications) {
-        this._seedDeltaTracking(pub);
-        this._mapStreamBuffer.push(this._getMapUpdateContext(pub));
-      }
+      this._mapStreamBuffer.push(...result.publications);
     }
     if (result.offset !== void 0) {
-      this._offset = result.offset;
+      this._mapFlowOffset = toOffset(result.offset);
     }
-    this._fetchStream();
+    this._fetchStream(flow);
   }
   /** Process live response - complete the map subscription */
-  _handleMapLiveResponse(result) {
+  _handleMapLiveResponse(flow, result) {
     if (!this._isSubscribing()) {
       this._inflight = false;
       return;
     }
     this._inflight = false;
-    if (this._epoch && result.epoch && this._epoch !== result.epoch) {
+    if (this._mapFlowEpoch && result.epoch && this._mapFlowEpoch !== result.epoch) {
       this._debug("map subscribe: epoch changed during live transition, restarting");
-      this._mapStateBuffer = [];
-      this._mapStreamBuffer = [];
-      this._epoch = null;
-      this._offset = null;
-      this._prevValueMap = /* @__PURE__ */ new Map();
+      this._restartMapFlow();
       this._inflight = true;
-      this._mapPhase = MapPhase.State;
-      this._fetchSnapshot();
+      this._fetchSnapshot(flow);
       return;
     }
-    if (result.state && result.state.length > 0) {
-      for (const pub of result.state) {
-        this._seedDeltaTracking(pub);
-        this._mapStateBuffer.push(this._getMapUpdateContext(pub));
-      }
-    }
+    const deltaNegotiated = !!(this._delta && result.delta);
+    const statePubs = result.state && result.state.length > 0 ? this._mapStateBuffer.concat(result.state) : this._mapStateBuffer;
+    this._mapStateBuffer = statePubs.map((pub) => {
+      this._seedDeltaTracking(pub, deltaNegotiated);
+      return this._getMapUpdateContext(pub);
+    });
+    this._mapStreamBuffer = this._mapStreamBuffer.map((pub) => {
+      this._seedDeltaTracking(pub, deltaNegotiated);
+      return this._getMapUpdateContext(pub);
+    });
     if (result.publications && result.publications.length > 0) {
       for (const pub of result.publications) {
-        if (this._delta && result.delta) {
+        if (deltaNegotiated) {
           const deltaKey = pub.key || "";
-          const { newData, newPrevValue, isDelta, wireBytes, fullBytes } = this._centrifuge._codec.applyDeltaIfNeeded(pub, this._prevValueMap.get(deltaKey));
-          pub.data = newData;
-          this._deltaNumPubs++;
-          this._deltaBytesReceived += wireBytes;
-          this._deltaBytesDecoded += fullBytes;
-          if (isDelta) {
-            this._deltaNumDelta++;
-          } else {
-            this._deltaNumFull++;
-          }
           if (pub.removed) {
             this._prevValueMap.delete(deltaKey);
           } else {
+            const { newData, newPrevValue, isDelta, wireBytes, fullBytes } = this._centrifuge._codec.applyDeltaIfNeeded(pub, this._prevValueMap.get(deltaKey));
+            pub.data = newData;
+            this._deltaNumPubs++;
+            this._deltaBytesReceived += wireBytes;
+            this._deltaBytesDecoded += fullBytes;
+            if (isDelta) {
+              this._deltaNumDelta++;
+            } else {
+              this._deltaNumFull++;
+            }
             this._prevValueMap.set(deltaKey, newPrevValue);
           }
         } else if (this._delta && pub.key) {
@@ -2080,13 +2521,13 @@ var BaseSubscription = class extends EventEmitter {
         this._mapStreamBuffer.push(this._getMapUpdateContext(pub));
       }
     }
-    this._offset = result.offset || 0;
-    this._epoch = result.epoch || "";
+    const offset = toOffset(result.offset);
+    const epoch = result.epoch || "";
     this._clearSubscribingState();
     if (result.id) {
       this._id = result.id;
     }
-    this._recover = result.recoverable === true;
+    const recover = result.recoverable === true;
     if (result.delta) {
       this._delta_negotiated = true;
     } else {
@@ -2095,36 +2536,78 @@ var BaseSubscription = class extends EventEmitter {
     if (result.publish_debounce) {
       this._debounceMs = result.publish_debounce;
     }
-    this._setState(SubscriptionState.Subscribed);
+    let stateEntries = this._mapStateBuffer;
+    let streamEntries = this._mapStreamBuffer;
+    this._mapStateBuffer = [];
+    this._mapStreamBuffer = [];
+    this._mapPhase = null;
     const ctx = this._centrifuge._getSubscribeContext(this.channel, result);
-    ctx.state = this._mapStateBuffer;
+    ctx.state = stateEntries;
+    const positionResets = this._mapFlowPositionResets;
+    if (this._mapPositionResets === positionResets) {
+      this._recover = recover;
+      this._epoch = epoch;
+      if (!ctx.recovered) {
+        this._recover = false;
+        this._offset = null;
+        this._epoch = null;
+      } else if (streamEntries.length > 0 && streamEntries[0].offset !== void 0) {
+        this._offset = streamEntries[0].offset - 1;
+      } else {
+        this._offset = offset;
+      }
+    }
+    this._setState(SubscriptionState.Subscribed);
+    if (!this._isSubscribed()) {
+      return;
+    }
     this.emit("subscribed", ctx);
+    if (!this._isSubscribed()) {
+      return;
+    }
     this._resolvePromises();
     if (!ctx.recovered) {
-      if (this._mapStreamBuffer.length > 0) {
+      if (streamEntries.length > 0) {
         const stateMap = /* @__PURE__ */ new Map();
-        for (const entry of this._mapStateBuffer) {
+        for (const entry of stateEntries) {
           stateMap.set(entry.key, entry);
         }
-        for (const entry of this._mapStreamBuffer) {
+        for (const entry of streamEntries) {
           if (entry.removed) {
             stateMap.delete(entry.key);
           } else {
             stateMap.set(entry.key, entry);
           }
         }
-        this._mapStateBuffer = Array.from(stateMap.values());
-        this._mapStreamBuffer = [];
+        stateEntries = Array.from(stateMap.values());
+        streamEntries = [];
       }
-      this.emit("sync", { entries: this._mapStateBuffer });
+      if (this._mapPositionResets === positionResets) {
+        this._recover = recover;
+        this._offset = offset;
+        this._epoch = epoch;
+      }
+      this.emit("sync", { entries: stateEntries });
     }
-    for (const pub of this._mapStreamBuffer) {
-      this.emit("publication", pub);
-      this.emit("update", pub);
+    for (const entry of streamEntries) {
+      if (!this._isSubscribed()) {
+        return;
+      }
+      this.emit("publication", entry);
+      if (!this._isSubscribed()) {
+        return;
+      }
+      if (entry.offset !== void 0 && this._mapPositionResets === positionResets) {
+        this._offset = entry.offset;
+      }
+      this.emit("update", entry);
+    }
+    if (!this._isSubscribed()) {
+      return;
+    }
+    if (this._mapPositionResets === positionResets) {
+      this._offset = offset;
     }
-    this._mapStateBuffer = [];
-    this._mapStreamBuffer = [];
-    this._mapPhase = null;
     if (result.expires === true) {
       this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));
     }
@@ -2135,6 +2618,9 @@ var BaseSubscription = class extends EventEmitter {
     if (!this._isSubscribing()) {
       return;
     }
+    if (error.code === errorCodes.connectionClosed) {
+      return;
+    }
     if (error.code === errorCodes.timeout) {
       this._centrifuge._disconnect(connectingCodes.subscribeTimeout, "subscribe timeout", true);
       return;
@@ -2142,10 +2628,10 @@ var BaseSubscription = class extends EventEmitter {
     this._mapStateBuffer = [];
     this._mapStreamBuffer = [];
     this._mapPhase = null;
-    this._prevValueMap = /* @__PURE__ */ new Map();
     if (error.code === 112) {
       if (this._mapUnrecoverableStrategy === "from_scratch") {
         this._debug("map subscribe: unrecoverable position, restarting from scratch");
+        this._prevValueMap = /* @__PURE__ */ new Map();
         this._offset = null;
         this._epoch = null;
         this._recover = false;
@@ -2175,9 +2661,9 @@ var BaseSubscription = class extends EventEmitter {
         req.limit = this._mapPageSize;
       if (cursor)
         req.cursor = cursor;
-      if (this._epoch) {
-        req.offset = this._offset;
-        req.epoch = this._epoch;
+      if (this._mapFlowEpoch) {
+        req.offset = this._mapFlowOffset;
+        req.epoch = this._mapFlowEpoch;
       } else {
         if (this._data)
           req.data = this._data;
@@ -2186,9 +2672,9 @@ var BaseSubscription = class extends EventEmitter {
     if (phase === MapPhase.Stream) {
       if (this._mapPageSize > 0)
         req.limit = this._mapPageSize;
-      req.offset = this._offset;
-      req.epoch = this._epoch;
-      if (this._recover) {
+      req.offset = this._mapFlowOffset;
+      req.epoch = this._mapFlowEpoch;
+      if (this._mapFlowRecovering) {
         req.recover = true;
         if (this._mapStreamBuffer.length === 0) {
           if (this._data)
@@ -2209,7 +2695,7 @@ var BaseSubscription = class extends EventEmitter {
       ctx.removed = true;
     }
     if (pub.offset !== void 0) {
-      ctx.offset = pub.offset;
+      ctx.offset = toOffset(pub.offset);
     }
     if (pub.info) {
       ctx.info = this._centrifuge._getJoinLeaveContext(pub.info);
@@ -2230,7 +2716,7 @@ var BaseSubscription = class extends EventEmitter {
       ctx.removed = true;
     }
     if (pub.version !== void 0) {
-      ctx.version = pub.version;
+      ctx.version = toOffset(pub.version);
     }
     return ctx;
   }
@@ -2307,19 +2793,17 @@ var SharedPollSubscription = class extends BaseSubscription {
       items = keysOrItems;
     }
     for (const item of items) {
+      const version = toOffset(item.version);
       const existing = this._sharedPollTrackedItems.get(item.key);
-      if (existing === void 0 || item.version > existing) {
-        this._sharedPollTrackedItems.set(item.key, item.version);
+      if (existing === void 0 || version > existing) {
+        this._sharedPollTrackedItems.set(item.key, version);
       }
     }
     if (sig !== void 0) {
-      this._sharedPollSignatures.push({
-        keys: items.map((i) => i.key),
-        signature: sig
-      });
-      if (this._isSubscribed()) {
-        this._sendTrackRequest([{ items, signature: sig }]).catch((err) => {
-          this._handleTrackError(err);
+      this._addSharedPollSignature(items.map((i) => i.key), sig);
+      if (this._isSubscribed() && !this._sharedPollReplayPending) {
+        this._sendTrackRequest([{ items, signature: sig }]).catch((e) => {
+          this._handleTrackError(e.error, e.keys);
         });
       }
       return;
@@ -2332,19 +2816,23 @@ var SharedPollSubscription = class extends BaseSubscription {
       });
       return;
     }
-    if (!this._isSubscribed()) {
+    if (!this._isSubscribed() || this._sharedPollReplayPending) {
       return;
     }
     const keys = items.map((i) => i.key);
-    this._sharedPollGetSignature({ keys }).then((result) => {
-      if (!this._isSubscribed())
+    const generation = this._refreshGeneration;
+    this._callAsync(() => this._sharedPollGetSignature({ keys })).then((result) => {
+      if (generation !== this._refreshGeneration || !this._isSubscribed())
         return;
       const returnedKeys = new Set(result.keys);
       const revokedKeys = [];
       for (const key of keys) {
-        if (!returnedKeys.has(key)) {
+        if (!returnedKeys.has(key) && this._sharedPollTrackedItems.has(key)) {
           this._sharedPollTrackedItems.delete(key);
           revokedKeys.push(key);
+          if (!this._isSubscribed()) {
+            continue;
+          }
           this.emit("update", {
             channel: this.channel,
             key,
@@ -2358,6 +2846,7 @@ var SharedPollSubscription = class extends BaseSubscription {
           this.emit("error", { type: "untrack", channel: this.channel, error: err });
         });
       }
+      this._sharedPollReplayRetryAttempts = 0;
       const authorizedItems = [];
       for (const key of result.keys) {
         const version = this._sharedPollTrackedItems.get(key);
@@ -2367,18 +2856,21 @@ var SharedPollSubscription = class extends BaseSubscription {
       }
       if (authorizedItems.length === 0)
         return;
-      this._sharedPollSignatures.push({
-        keys: result.keys,
-        signature: result.signature
-      });
-      this._sendTrackRequest([{ items: authorizedItems, signature: result.signature }]).catch((err) => {
-        this._handleTrackError(err);
+      this._addSharedPollSignature(result.keys, result.signature);
+      this._sendTrackRequest([{ items: authorizedItems, signature: result.signature }]).catch((e) => {
+        this._handleTrackError(e.error, e.keys);
       });
     }).catch((e) => {
-      this.emit("error", {
+      if (generation !== this._refreshGeneration || !this._isSubscribed())
+        return;
+      this._emitError({
         type: "track",
         channel: this.channel,
         error: { code: errorCodes.sharedPollGetSignature, message: e !== void 0 ? e.toString() : "getSignature failed" }
+      }, () => {
+        if (generation !== this._refreshGeneration || !this._isSubscribed())
+          return;
+        this._scheduleSharedPollReplayRetry();
       });
     });
   }
@@ -2444,7 +2936,9 @@ var SockjsTransport = class {
     };
   }
   close() {
-    this._transport.close();
+    if (this._transport !== null) {
+      this._transport.close();
+    }
   }
   send(data) {
     this._transport.send(data);
@@ -2495,18 +2989,89 @@ var WebsocketTransport = class {
     };
   }
   close() {
-    this._transport.close();
+    if (this._transport !== null) {
+      this._transport.close();
+    }
   }
   send(data) {
     this._transport.send(data);
   }
 };
+var maxRetainedSize = 64 * 1024;
+var ReplyStreamBuffer = class {
+  constructor() {
+    this._buf = new Uint8Array(0);
+    this._start = 0;
+    this._end = 0;
+  }
+  push(chunk) {
+    const size = this._end - this._start;
+    if (this._end + chunk.length > this._buf.length) {
+      if (size + chunk.length <= this._buf.length / 2) {
+        this._buf.copyWithin(0, this._start, this._end);
+      } else {
+        const buf = new Uint8Array(Math.max(this._buf.length * 2, size + chunk.length));
+        buf.set(this._buf.subarray(this._start, this._end));
+        this._buf = buf;
+      }
+      this._start = 0;
+      this._end = size;
+    }
+    this._buf.set(chunk, this._end);
+    this._end += chunk.length;
+  }
+  // Calls onReply with a copy of each complete reply buffered, in order.
+  // decodeReply tells whether the data starts with a complete reply, and where it ends.
+  drain(decodeReply, onReply) {
+    while (this._start < this._end) {
+      const result = decodeReply(this._buf.subarray(this._start, this._end));
+      if (!result.ok) {
+        break;
+      }
+      const end = this._start + result.pos;
+      const reply = this._buf.slice(this._start, end);
+      this._start = end;
+      onReply(reply);
+    }
+    const size = this._end - this._start;
+    if (this._buf.length > maxRetainedSize && size <= this._buf.length / 4) {
+      this._buf = this._buf.slice(this._start, this._end);
+      this._start = 0;
+      this._end = size;
+    } else if (size === 0) {
+      this._start = 0;
+      this._end = 0;
+    }
+  }
+};
+var LineStreamBuffer = class {
+  constructor() {
+    this._decoder = new TextDecoder();
+    this._parts = [];
+  }
+  // Calls onLine with each complete line, in order, without its '\n'.
+  push(chunk, onLine) {
+    const text = this._decoder.decode(chunk, { stream: true });
+    let start = 0;
+    let end = text.indexOf("\n");
+    while (end !== -1) {
+      this._parts.push(text.substring(start, end));
+      const line = this._parts.join("");
+      this._parts = [];
+      start = end + 1;
+      onLine(line);
+      end = text.indexOf("\n", start);
+    }
+    if (start < text.length) {
+      this._parts.push(text.substring(start));
+    }
+  }
+};
 var HttpStreamTransport = class {
   constructor(endpoint, options) {
     this.endpoint = endpoint;
     this.options = options;
     this._abortController = null;
-    this._utf8decoder = new TextDecoder();
     this._protocol = "json";
   }
   name() {
@@ -2528,9 +3093,8 @@ var HttpStreamTransport = class {
     const fetchFunc = self2.options.fetch;
     fetchFunc(endpoint, options).then(self2._handleErrors).then((response) => {
       eventTarget.dispatchEvent(new Event("open"));
-      let jsonStreamBuf = "";
-      let jsonStreamPos = 0;
-      let protoStreamBuf = new Uint8Array();
+      const jsonStreamBuf = new LineStreamBuffer();
+      const protoStreamBuf = new ReplyStreamBuffer();
       const reader = response.body.getReader();
       return new self2.options.readableStream({
         start(controller) {
@@ -2543,32 +3107,10 @@ var HttpStreamTransport = class {
               }
               try {
                 if (self2._protocol === "json") {
-                  jsonStreamBuf += self2._utf8decoder.decode(value, { stream: true });
-                  while (jsonStreamPos < jsonStreamBuf.length) {
-                    if (jsonStreamBuf[jsonStreamPos] === "\n") {
-                      const line = jsonStreamBuf.substring(0, jsonStreamPos);
-                      eventTarget.dispatchEvent(new MessageEvent("message", { data: line }));
-                      jsonStreamBuf = jsonStreamBuf.substring(jsonStreamPos + 1);
-                      jsonStreamPos = 0;
-                    } else {
-                      ++jsonStreamPos;
-                    }
-                  }
+                  jsonStreamBuf.push(value, (line) => eventTarget.dispatchEvent(new MessageEvent("message", { data: line })));
                 } else {
-                  const mergedArray = new Uint8Array(protoStreamBuf.length + value.length);
-                  mergedArray.set(protoStreamBuf);
-                  mergedArray.set(value, protoStreamBuf.length);
-                  protoStreamBuf = mergedArray;
-                  while (true) {
-                    const result = self2.options.decoder.decodeReply(protoStreamBuf);
-                    if (result.ok) {
-                      const data = protoStreamBuf.slice(0, result.pos);
-                      eventTarget.dispatchEvent(new MessageEvent("message", { data }));
-                      protoStreamBuf = protoStreamBuf.slice(result.pos);
-                      continue;
-                    }
-                    break;
-                  }
+                  protoStreamBuf.push(value);
+                  protoStreamBuf.drain((data) => self2.options.decoder.decodeReply(data), (reply) => eventTarget.dispatchEvent(new MessageEvent("message", { data: reply })));
                 }
               } catch (error) {
                 eventTarget.dispatchEvent(new Event("error", { detail: error }));
@@ -2642,7 +3184,9 @@ var HttpStreamTransport = class {
     });
   }
   close() {
-    this._abortController.abort();
+    if (this._abortController !== null) {
+      this._abortController.abort();
+    }
   }
   send(data, session2, node) {
     let headers;
@@ -2669,9 +3213,18 @@ var HttpStreamTransport = class {
       headers,
       body,
       mode: "cors",
-      credentials: "same-origin"
+      credentials: "same-origin",
+      // Closing the transport aborts requests still pending, e.g. hung in an
+      // intermediary, which would otherwise keep connections of the per-host pool.
+      signal: this._abortController.signal
     };
-    fetchFunc(this.options.emulationEndpoint, fetchOptions);
+    fetchFunc(this.options.emulationEndpoint, fetchOptions).then((response) => {
+      if (response && (response.status === 404 || response.status >= 500)) {
+        this.close();
+      }
+    }, () => {
+      this.close();
+    });
   }
 };
 var SseTransport = class {
@@ -2681,6 +3234,7 @@ var SseTransport = class {
     this._protocol = "json";
     this._transport = null;
     this._onClose = null;
+    this._abortController = null;
   }
   name() {
     return "sse";
@@ -2695,6 +3249,9 @@ var SseTransport = class {
     return this.options.eventsource !== null && this.options.fetch !== null;
   }
   initialize(_protocol, callbacks, initialData) {
+    if (typeof AbortController !== "undefined") {
+      this._abortController = new AbortController();
+    }
     let url;
     if (globalThis && globalThis.document && globalThis.document.baseURI) {
       url = new URL(this.endpoint, globalThis.document.baseURI);
@@ -2728,7 +3285,12 @@ var SseTransport = class {
     };
   }
   close() {
-    this._transport.close();
+    if (this._abortController !== null) {
+      this._abortController.abort();
+    }
+    if (this._transport !== null) {
+      this._transport.close();
+    }
     if (this._onClose !== null) {
       this._onClose();
     }
@@ -2744,14 +3306,25 @@ var SseTransport = class {
     };
     const body = JSON.stringify(req);
     const fetchFunc = this.options.fetch;
+    const signal = this._abortController !== null ? this._abortController.signal : void 0;
     const fetchOptions = {
       method: "POST",
       headers,
       body,
       mode: "cors",
-      credentials: "same-origin"
+      credentials: "same-origin",
+      signal
     };
-    fetchFunc(this.options.emulationEndpoint, fetchOptions);
+    fetchFunc(this.options.emulationEndpoint, fetchOptions).then((response) => {
+      if (response && (response.status === 404 || response.status >= 500)) {
+        this.close();
+      }
+    }, () => {
+      if (signal && signal.aborted) {
+        return;
+      }
+      this.close();
+    });
   }
 };
 var WebtransportTransport = class {
@@ -2761,7 +3334,6 @@ var WebtransportTransport = class {
     this._transport = null;
     this._stream = null;
     this._writer = null;
-    this._utf8decoder = new TextDecoder();
     this._protocol = "json";
   }
   name() {
@@ -2832,40 +3404,17 @@ var WebtransportTransport = class {
   _startReading(eventTarget) {
     return __awaiter(this, void 0, void 0, function* () {
       const reader = this._stream.readable.getReader();
-      let jsonStreamBuf = "";
-      let jsonStreamPos = 0;
-      let protoStreamBuf = new Uint8Array();
+      const jsonStreamBuf = new LineStreamBuffer();
+      const protoStreamBuf = new ReplyStreamBuffer();
       try {
         while (true) {
           const { done, value } = yield reader.read();
           if (value && value.length > 0) {
             if (this._protocol === "json") {
-              jsonStreamBuf += this._utf8decoder.decode(value, { stream: true });
-              while (jsonStreamPos < jsonStreamBuf.length) {
-                if (jsonStreamBuf[jsonStreamPos] === "\n") {
-                  const line = jsonStreamBuf.substring(0, jsonStreamPos);
-                  eventTarget.dispatchEvent(new MessageEvent("message", { data: line }));
-                  jsonStreamBuf = jsonStreamBuf.substring(jsonStreamPos + 1);
-                  jsonStreamPos = 0;
-                } else {
-                  ++jsonStreamPos;
-                }
-              }
+              jsonStreamBuf.push(value, (line) => eventTarget.dispatchEvent(new MessageEvent("message", { data: line })));
             } else {
-              const mergedArray = new Uint8Array(protoStreamBuf.length + value.length);
-              mergedArray.set(protoStreamBuf);
-              mergedArray.set(value, protoStreamBuf.length);
-              protoStreamBuf = mergedArray;
-              while (true) {
-                const result = this.options.decoder.decodeReply(protoStreamBuf);
-                if (result.ok) {
-                  const data = protoStreamBuf.slice(0, result.pos);
-                  eventTarget.dispatchEvent(new MessageEvent("message", { data }));
-                  protoStreamBuf = protoStreamBuf.slice(result.pos);
-                  continue;
-                }
-                break;
-              }
+              protoStreamBuf.push(value);
+              protoStreamBuf.drain((data) => this.options.decoder.decodeReply(data), (reply) => eventTarget.dispatchEvent(new MessageEvent("message", { data: reply })));
             }
           }
           if (done) {
@@ -3179,7 +3728,7 @@ var JsonCodec = class {
     return commands.map((c) => JSON.stringify(c)).join("\n");
   }
   decodeReplies(data) {
-    return data.trim().split("\n").map((r) => JSON.parse(r));
+    return data.split("\n").filter((r) => r.trim() !== "").map((r) => JSON.parse(r));
   }
   applyDeltaIfNeeded(pub, prevValue) {
     let newData, newPrevValue, wireBytes;
@@ -3220,8 +3769,19 @@ var defaults = {
   maxReconnectDelay: 2e4,
   timeout: 5e3,
   maxServerPingDelay: 1e4,
-  networkEventTarget: null
+  networkEventTarget: null,
+  pageEventTarget: null
 };
+var websocketNotFound = "WebSocket constructor not found, make sure it is available globally or passed as a dependency in Centrifuge options";
+var lateCallTimer = 1e3;
+var lateCallGrace = 1e3;
+function errorMessage(err) {
+  try {
+    return err instanceof Error ? err.message : String(err);
+  } catch (e) {
+    return "value without a string form";
+  }
+}
 var UnauthorizedError = class extends Error {
   constructor(message) {
     super(message);
@@ -3233,8 +3793,12 @@ var Centrifuge = class extends EventEmitter {
   constructor(endpoint, options) {
     super();
     this._reconnectTimeout = null;
+    this._connectTimeout = null;
+    this._removedUnsubscribes = {};
+    this._pendingServerSubOffsets = {};
     this._refreshTimeout = null;
     this._serverPingTimeout = null;
+    this._handlerFailures = 0;
     this.state = State.Disconnected;
     this._transportIsOpen = false;
     this._endpoint = endpoint;
@@ -3250,6 +3814,7 @@ var Centrifuge = class extends EventEmitter {
     this._codec = new JsonCodec();
     this._reconnecting = false;
     this._reconnectTimeout = null;
+    this._connectTimeout = null;
     this._reconnectAttempts = 0;
     this._client = null;
     this._session = "";
@@ -3271,7 +3836,13 @@ var Centrifuge = class extends EventEmitter {
     this._promises = {};
     this._promiseId = 0;
     this._debugEnabled = false;
-    this._networkEventsSet = false;
+    this._networkEvents = null;
+    this._pageEvents = null;
+    this._pageCached = false;
+    this._stateTransitions = 0;
+    this._disconnects = 0;
+    this._abortedTransportId = 0;
+    this._reconnectAttemptsResetPending = false;
     this._config = Object.assign(Object.assign({}, defaults), options);
     this._configure();
     if (this._debugEnabled) {
@@ -3422,10 +3993,15 @@ var Centrifuge = class extends EventEmitter {
     if (!sub) {
       return;
     }
+    if (this._subs[sub.channel] !== sub) {
+      return;
+    }
+    delete this._subs[sub.channel];
+    sub._removed = true;
     if (sub.state !== SubscriptionState.Unsubscribed) {
       sub.unsubscribe();
     }
-    this._removeSubscription(sub);
+    this._recordRemovedUnsubscribe(sub);
   }
   /** Remove a map subscription. */
   removeMapSubscription(sub) {
@@ -3469,13 +4045,15 @@ var Centrifuge = class extends EventEmitter {
           return;
         default:
           return new Promise((resolve, reject) => {
+            const id = this._nextPromiseId();
             const ctx = { resolve, reject };
             if (timeout) {
               ctx.timeout = setTimeout(() => {
+                delete this._promises[id];
                 reject({ code: errorCodes.timeout, message: "timeout" });
               }, timeout);
             }
-            this._promises[this._nextPromiseId()] = ctx;
+            this._promises[id] = ctx;
           });
       }
     });
@@ -3491,6 +4069,7 @@ var Centrifuge = class extends EventEmitter {
       return;
     }
     this._debug("connect called");
+    this._validateTransportConfig();
     this._reconnectAttempts = 0;
     this._startConnecting();
   }
@@ -3501,6 +4080,9 @@ var Centrifuge = class extends EventEmitter {
   /** setToken allows setting connection token. Or resetting used token to be empty.  */
   setToken(token) {
     this._token = token;
+    if (this._config.getToken === null) {
+      this._refreshRequired = false;
+    }
   }
   /** setData allows setting connection data. This only affects the next connection attempt,
    * not the current one. Note that if getData callback is configured, it will override
@@ -3605,7 +4187,7 @@ var Centrifuge = class extends EventEmitter {
       return {
         publications,
         epoch: result.epoch || "",
-        offset: result.offset || 0
+        offset: toOffset(result.offset)
       };
     });
   }
@@ -3721,15 +4303,29 @@ var Centrifuge = class extends EventEmitter {
       throw new Error("unsupported url configuration type: only string or array of objects are supported");
     }
   }
+  // Returns the number of the transition made, or 0 if the client already was in newState.
   _setState(newState) {
     if (this.state !== newState) {
       this._reconnecting = false;
       const oldState = this.state;
       this.state = newState;
+      const transition = ++this._stateTransitions;
+      if (newState === State.Connecting) {
+        this._setNetworkEvents();
+        this._setPageEvents();
+      } else if (newState === State.Disconnected) {
+        this._clearNetworkEvents();
+        this._clearPageEvents();
+      }
       this.emit("state", { newState, oldState });
-      return true;
+      return transition;
     }
-    return false;
+    return 0;
+  }
+  // Whether an event handler made another state transition after the given one
+  // (as returned by _setState), so that the given one is outdated.
+  _transitionSuperseded(transition) {
+    return transition !== 0 && this._stateTransitions !== transition;
   }
   _isDisconnected() {
     return this.state === State.Disconnected;
@@ -3744,7 +4340,7 @@ var Centrifuge = class extends EventEmitter {
     return ++this._commandId;
   }
   _setNetworkEvents() {
-    if (this._networkEventsSet) {
+    if (this._networkEvents !== null) {
       return;
     }
     let eventTarget = null;
@@ -3754,33 +4350,120 @@ var Centrifuge = class extends EventEmitter {
       eventTarget = globalThis;
     }
     if (eventTarget) {
-      eventTarget.addEventListener("offline", () => {
+      const onOffline = () => {
         this._debug("offline event triggered");
         if (this.state === State.Connected || this.state === State.Connecting) {
-          this._disconnect(connectingCodes.transportClosed, "transport closed", true);
           this._deviceWentOffline = true;
+          this._disconnect(connectingCodes.transportClosed, "transport closed", true);
         }
-      });
-      eventTarget.addEventListener("online", () => {
+      };
+      const onOnline = () => {
         this._debug("online event triggered");
+        const wentOffline = this._deviceWentOffline;
+        this._deviceWentOffline = false;
         if (this.state !== State.Connecting) {
           return;
         }
-        if (this._deviceWentOffline && !this._transportClosed) {
-          this._deviceWentOffline = false;
-          this._transportClosed = true;
+        if (wentOffline && !this._transportClosed) {
+          this._abortedTransportId = this._transportId;
+          this._disconnect(connectingCodes.transportClosed, "transport closed", true);
         }
         this._clearReconnectTimeout();
         this._startReconnecting();
-      });
-      this._networkEventsSet = true;
+      };
+      eventTarget.addEventListener("offline", onOffline);
+      eventTarget.addEventListener("online", onOnline);
+      this._networkEvents = { target: eventTarget, onOffline, onOnline };
     }
   }
+  // The online listener drives reconnect, so listeners stay until the client is
+  // disconnected; removing them then lets a disconnected client be garbage-collected.
+  _clearNetworkEvents() {
+    if (this._networkEvents === null) {
+      return;
+    }
+    const { target, onOffline, onOnline } = this._networkEvents;
+    if (!isFunction(target.removeEventListener)) {
+      this._debug("network event target has no removeEventListener, listeners kept");
+      return;
+    }
+    target.removeEventListener("offline", onOffline);
+    target.removeEventListener("online", onOnline);
+    this._networkEvents = null;
+  }
+  // A page entering the back/forward cache is frozen, but the browser may keep its
+  // socket open: the server then sees a client that stopped answering pings. So the
+  // transport is closed when the page is hidden into the cache, and the client
+  // reconnects as soon as the page is restored from it. The reconnect is scheduled
+  // as usual too: its timer does not run in a frozen page, and it still reconnects
+  // a page which was not frozen, or was restored without a pageshow event.
+  _setPageEvents() {
+    if (this._pageEvents !== null) {
+      return;
+    }
+    let eventTarget = null;
+    if (this._config.pageEventTarget !== null) {
+      eventTarget = this._config.pageEventTarget;
+    } else if (typeof globalThis.addEventListener !== "undefined") {
+      eventTarget = globalThis;
+    }
+    if (!eventTarget) {
+      return;
+    }
+    const onPageHide = (e) => {
+      if (!e.persisted) {
+        return;
+      }
+      this._debug("page entered back/forward cache");
+      if (this.state === State.Connected || this.state === State.Connecting) {
+        this._pageCached = true;
+        this._disconnect(connectingCodes.transportClosed, "page entered back/forward cache", true);
+      }
+    };
+    const onPageShow = (e) => {
+      if (!e.persisted) {
+        return;
+      }
+      this._debug("page restored from back/forward cache");
+      const cached = this._pageCached;
+      this._pageCached = false;
+      if (!cached || this.state !== State.Connecting) {
+        return;
+      }
+      this._clearReconnectTimeout();
+      this._startReconnecting();
+    };
+    eventTarget.addEventListener("pagehide", onPageHide);
+    eventTarget.addEventListener("pageshow", onPageShow);
+    this._pageEvents = { target: eventTarget, onPageHide, onPageShow };
+  }
+  // Removed once the client is disconnected, like the network listeners.
+  _clearPageEvents() {
+    if (this._pageEvents === null) {
+      return;
+    }
+    const { target, onPageHide, onPageShow } = this._pageEvents;
+    if (!isFunction(target.removeEventListener)) {
+      this._debug("page event target has no removeEventListener, listeners kept");
+      return;
+    }
+    target.removeEventListener("pagehide", onPageHide);
+    target.removeEventListener("pageshow", onPageShow);
+    this._pageEvents = null;
+  }
   _getReconnectDelay() {
     const delay = backoff(this._reconnectAttempts, this._config.minReconnectDelay, this._config.maxReconnectDelay);
     this._reconnectAttempts += 1;
     return delay;
   }
+  // See _connectResponse: an emulation connection resets the backoff once it
+  // proved usable.
+  _resetReconnectAttemptsIfPending() {
+    if (this._reconnectAttemptsResetPending) {
+      this._reconnectAttemptsResetPending = false;
+      this._reconnectAttempts = 0;
+    }
+  }
   _clearOutgoingRequests() {
     for (const id in this._callbacks) {
       if (this._callbacks.hasOwnProperty(id)) {
@@ -3809,7 +4492,8 @@ var Centrifuge = class extends EventEmitter {
       }
     }
     for (const channel in this._serverSubs) {
-      if (this._serverSubs.hasOwnProperty(channel)) {
+      if (this._serverSubs.hasOwnProperty(channel) && this._serverSubs[channel].subscribed) {
+        this._serverSubs[channel].subscribed = false;
         this.emit("subscribing", { channel });
       }
     }
@@ -3850,7 +4534,10 @@ var Centrifuge = class extends EventEmitter {
       this._currentTransportIndex = 0;
     }
   }
-  _initializeTransport() {
+  // Transport dependencies from the config, or else from globals. An absent one
+  // stays null, not undefined: supported() of sockjs, sse and http_stream only
+  // checks `!== null`.
+  _resolveTransportDeps() {
     let websocket;
     if (this._config.websocket !== null) {
       websocket = this._config.websocket;
@@ -3891,101 +4578,105 @@ var Centrifuge = class extends EventEmitter {
         readableStream = globalThis.ReadableStream;
       }
     }
+    return { websocket, sockjs, eventsource, fetchFunc, readableStream };
+  }
+  // Constructs a transport, without checking that it is supported.
+  _createTransport(transportName, endpoint, deps) {
+    switch (transportName) {
+      case "websocket":
+        return new WebsocketTransport(endpoint, {
+          websocket: deps.websocket
+        });
+      case "webtransport":
+        return new WebtransportTransport(endpoint, {
+          webtransport: globalThis.WebTransport,
+          decoder: this._codec,
+          encoder: this._codec
+        });
+      case "http_stream":
+        return new HttpStreamTransport(endpoint, {
+          fetch: deps.fetchFunc,
+          readableStream: deps.readableStream,
+          emulationEndpoint: this._config.emulationEndpoint,
+          decoder: this._codec,
+          encoder: this._codec
+        });
+      case "sse":
+        return new SseTransport(endpoint, {
+          eventsource: deps.eventsource,
+          fetch: deps.fetchFunc,
+          emulationEndpoint: this._config.emulationEndpoint
+        });
+      case "sockjs":
+        return new SockjsTransport(endpoint, {
+          sockjs: deps.sockjs,
+          sockjsOptions: this._config.sockjsOptions
+        });
+      default:
+        throw new Error("unknown transport " + transportName);
+    }
+  }
+  // Throws for a configuration no retry can fix. Called from connect() before
+  // the state changes, so the client stays disconnected, and before a token or
+  // data is loaded, so it fails the same way with getToken or getData.
+  _validateTransportConfig() {
+    const deps = this._resolveTransportDeps();
     if (!this._emulation) {
       if (startsWith(this._endpoint, "http")) {
         throw new Error("Provide explicit transport endpoints configuration in case of using HTTP (i.e. using array of TransportEndpoint instead of a single string), or use ws(s):// scheme in an endpoint if you aimed using WebSocket transport");
-      } else {
-        this._debug("client will use websocket");
-        this._transport = new WebsocketTransport(this._endpoint, {
-          websocket
-        });
-        if (!this._transport.supported()) {
-          throw new Error("WebSocket constructor not found, make sure it is available globally or passed as a dependency in Centrifuge options");
-        }
+      }
+      if (!this._createTransport("websocket", this._endpoint, deps).supported()) {
+        throw new Error(websocketNotFound);
+      }
+      return;
+    }
+    for (const transportConfig of this._transports) {
+      if (this._createTransport(transportConfig.transport, transportConfig.endpoint, deps).supported()) {
+        return;
+      }
+    }
+    throw new Error("no supported transport found");
+  }
+  _initializeTransport() {
+    const deps = this._resolveTransportDeps();
+    let selected = null;
+    if (!this._emulation) {
+      this._debug("client will use websocket");
+      const candidate = this._createTransport("websocket", this._endpoint, deps);
+      if (candidate.supported()) {
+        selected = candidate;
       }
     } else {
       if (this._currentTransportIndex >= this._transports.length) {
         this._triedAllTransports = true;
         this._currentTransportIndex = 0;
       }
-      let count = 0;
-      while (true) {
-        if (count >= this._transports.length) {
-          throw new Error("no supported transport found");
-        }
+      for (let count = 0; count < this._transports.length; count++) {
         const transportConfig = this._transports[this._currentTransportIndex];
-        const transportName = transportConfig.transport;
-        const transportEndpoint = transportConfig.endpoint;
-        if (transportName === "websocket") {
-          this._debug("trying websocket transport");
-          this._transport = new WebsocketTransport(transportEndpoint, {
-            websocket
-          });
-          if (!this._transport.supported()) {
-            this._debug("websocket transport not available");
-            this._advanceTransportIndex();
-            count++;
-            continue;
-          }
-        } else if (transportName === "webtransport") {
-          this._debug("trying webtransport transport");
-          this._transport = new WebtransportTransport(transportEndpoint, {
-            webtransport: globalThis.WebTransport,
-            decoder: this._codec,
-            encoder: this._codec
-          });
-          if (!this._transport.supported()) {
-            this._debug("webtransport transport not available");
-            this._advanceTransportIndex();
-            count++;
-            continue;
-          }
-        } else if (transportName === "http_stream") {
-          this._debug("trying http_stream transport");
-          this._transport = new HttpStreamTransport(transportEndpoint, {
-            fetch: fetchFunc,
-            readableStream,
-            emulationEndpoint: this._config.emulationEndpoint,
-            decoder: this._codec,
-            encoder: this._codec
-          });
-          if (!this._transport.supported()) {
-            this._debug("http_stream transport not available");
-            this._advanceTransportIndex();
-            count++;
-            continue;
-          }
-        } else if (transportName === "sse") {
-          this._debug("trying sse transport");
-          this._transport = new SseTransport(transportEndpoint, {
-            eventsource,
-            fetch: fetchFunc,
-            emulationEndpoint: this._config.emulationEndpoint
-          });
-          if (!this._transport.supported()) {
-            this._debug("sse transport not available");
-            this._advanceTransportIndex();
-            count++;
-            continue;
-          }
-        } else if (transportName === "sockjs") {
-          this._debug("trying sockjs");
-          this._transport = new SockjsTransport(transportEndpoint, {
-            sockjs,
-            sockjsOptions: this._config.sockjsOptions
-          });
-          if (!this._transport.supported()) {
-            this._debug("sockjs transport not available");
-            this._advanceTransportIndex();
-            count++;
-            continue;
-          }
-        } else {
-          throw new Error("unknown transport " + transportName);
+        this._debug("trying " + transportConfig.transport + " transport");
+        const candidate = this._createTransport(transportConfig.transport, transportConfig.endpoint, deps);
+        if (candidate.supported()) {
+          selected = candidate;
+          break;
         }
-        break;
+        this._debug(transportConfig.transport + " transport not available");
+        this._advanceTransportIndex();
       }
     }
+    if (selected === null) {
+      const message = this._emulation ? "no supported transport found" : websocketNotFound;
+      this._debug(message);
+      this._disconnect(connectingCodes.transportClosed, "transport closed", true);
+      this.emit("error", {
+        type: "transport",
+        error: {
+          code: errorCodes.transportClosed,
+          message
+        }
+      });
+      return;
+    }
+    this._transport = selected;
     const self2 = this;
     const transport = this._transport;
     const transportId = this._nextTransportId();
@@ -3996,24 +4687,48 @@ var Centrifuge = class extends EventEmitter {
       const connectCommand = self2._sendConnect(true);
       initialCommands.push(connectCommand);
     }
-    this._setNetworkEvents();
-    const initialData = this._codec.encodeCommands(initialCommands);
     this._transportClosed = false;
-    let connectTimeout;
-    connectTimeout = setTimeout(function() {
-      transport.close();
+    const failTransport = function(reason) {
+      if (self2._transportId != transportId) {
+        self2._debug("failure of non-actual transport", reason);
+        return;
+      }
+      self2._debug(transport.name(), "transport failed:", reason);
+      if (self2._emulation && !self2._transportWasOpen) {
+        self2._advanceTransportIndex();
+      }
+      self2._abortedTransportId = transportId;
+      self2._disconnect(connectingCodes.transportClosed, "transport closed", true);
+      self2.emit("error", {
+        type: "transport",
+        error: {
+          code: errorCodes.transportClosed,
+          message: reason
+        },
+        transport: transport.name()
+      });
+    };
+    this._clearConnectTimeout();
+    const connectDue = Date.now() + this._config.timeout;
+    this._connectTimeout = setTimeout(function() {
+      const late = Date.now() - connectDue >= lateCallTimer;
+      self2._connectTimeout = setTimeout(function() {
+        self2._connectTimeout = null;
+        failTransport("connect timeout");
+      }, late ? lateCallGrace : 0);
     }, this._config.timeout);
-    this._transport.initialize(this._codecName(), {
+    const callbacks = {
       onOpen: function() {
-        if (connectTimeout) {
-          clearTimeout(connectTimeout);
-          connectTimeout = null;
-        }
         if (self2._transportId != transportId) {
           self2._debug("open callback from non-actual transport");
-          transport.close();
+          try {
+            transport.close();
+          } catch (e) {
+            self2._debug("error closing transport", e);
+          }
           return;
         }
+        self2._clearConnectTimeout();
         wasOpen = true;
         self2._debug(transport.subName(), "transport open");
         if (transport.emulation()) {
@@ -4022,9 +4737,14 @@ var Centrifuge = class extends EventEmitter {
         self2._transportIsOpen = true;
         self2._transportWasOpen = true;
         self2.startBatching();
-        self2._sendConnect(false);
-        self2._sendSubscribeCommands();
-        self2.stopBatching();
+        try {
+          self2._sendConnect(false);
+          self2._sendSubscribeCommands();
+        } catch (e) {
+          self2._reportDispatchError(e);
+        } finally {
+          self2.stopBatching();
+        }
         self2.emit("__centrifuge_debug:connect_frame_sent", {});
       },
       onError: function(e) {
@@ -4034,15 +4754,16 @@ var Centrifuge = class extends EventEmitter {
         }
         self2._debug("transport level error", e);
       },
-      onClose: function(closeEvent) {
-        if (connectTimeout) {
-          clearTimeout(connectTimeout);
-          connectTimeout = null;
-        }
+      onClose: function handleClose(closeEvent, dispatched) {
         if (self2._transportId != transportId) {
           self2._debug("close callback from non-actual transport");
           return;
         }
+        if (!dispatched && (transport.emulation() || transport.name() === "webtransport")) {
+          self2._dispatchPromise.then(() => handleClose(closeEvent, true));
+          return;
+        }
+        self2._clearConnectTimeout();
         self2._debug(transport.subName(), "transport closed");
         self2._transportClosed = true;
         self2._transportIsOpen = false;
@@ -4079,38 +4800,76 @@ var Centrifuge = class extends EventEmitter {
         } else {
           self2._transportWasOpen = true;
         }
+        const teardown = function() {
+          self2._reconnecting = false;
+          self2._disconnect(code, reason, needReconnect);
+        };
         if (self2._isConnecting() && !wasOpen) {
-          self2.emit("error", {
+          self2._abortedTransportId = transportId;
+          self2._emitError({
             type: "transport",
             error: {
               code: errorCodes.transportClosed,
               message: "transport closed"
             },
             transport: transport.name()
-          });
+          }, teardown);
+        } else {
+          teardown();
         }
-        self2._reconnecting = false;
-        self2._disconnect(code, reason, needReconnect);
       },
       onMessage: function(data) {
-        self2._dataReceived(data);
+        if (self2._transportId != transportId) {
+          self2._debug("message from non-actual transport");
+          return;
+        }
+        self2._dataReceived(data, transportId);
       }
-    }, initialData);
+    };
+    const onInitializeError = function(e) {
+      self2._debug("error initializing transport", e);
+      failTransport(e instanceof Error ? e.message : String(e));
+    };
+    let initialized;
+    try {
+      initialized = transport.initialize(this._codecName(), callbacks, this._codec.encodeCommands(initialCommands));
+    } catch (e) {
+      onInitializeError(e);
+      return;
+    }
+    if (initialized && isFunction(initialized.then)) {
+      initialized.then(null, onInitializeError);
+    }
     self2.emit("__centrifuge_debug:transport_initialized", {});
   }
   _sendConnect(skipSending) {
     const connectCommand = this._constructConnectCommand();
     const self2 = this;
+    const transportId = this._transportId;
+    const token = this._token;
     this._call(connectCommand, skipSending).then((resolveCtx) => {
-      const result = resolveCtx.reply.connect;
-      self2._connectResponse(result);
-      if (resolveCtx.next) {
-        resolveCtx.next();
+      try {
+        self2._connectResponse(resolveCtx.reply.connect);
+      } catch (err) {
+        self2._dispatchFailed(err);
+      } finally {
+        if (resolveCtx.next) {
+          resolveCtx.next();
+        }
       }
     }, (rejectCtx) => {
-      self2._connectError(rejectCtx.error);
-      if (rejectCtx.next) {
-        rejectCtx.next();
+      try {
+        if (transportId === self2._abortedTransportId) {
+          self2._debug("connect command of a transport aborted by the client rejected");
+        } else {
+          self2._connectError(rejectCtx.error, self2._transportId !== transportId, rejectCtx.next !== void 0, token);
+        }
+      } catch (err) {
+        self2._rejectionFailed(err, rejectCtx);
+      } finally {
+        if (rejectCtx.next) {
+          rejectCtx.next();
+        }
       }
     });
     return connectCommand;
@@ -4130,17 +4889,21 @@ var Centrifuge = class extends EventEmitter {
       return;
     }
     this._reconnecting = true;
+    const disconnects = this._disconnects;
     const emptyToken = this._token === "";
     const needTokenRefresh = this._refreshRequired || emptyToken && this._config.getToken !== null;
+    let tokenResolved = false;
+    let dataResolved = false;
     if (!needTokenRefresh) {
       if (this._config.getData) {
-        this._config.getData().then((data) => {
-          if (!this._isConnecting()) {
+        this._getData().then((data) => {
+          dataResolved = true;
+          if (this._attemptAborted(disconnects)) {
             return;
           }
           this._data = data;
           this._initializeTransport();
-        }).catch((e) => this._handleGetDataError(e));
+        }).catch((e) => this._handleGetDataError(e, disconnects, dataResolved));
       } else {
         this._initializeTransport();
       }
@@ -4148,7 +4911,8 @@ var Centrifuge = class extends EventEmitter {
     }
     const self2 = this;
     this._getToken().then(function(token) {
-      if (!self2._isConnecting()) {
+      tokenResolved = true;
+      if (self2._attemptAborted(disconnects)) {
         return;
       }
       if (token == null || token == void 0) {
@@ -4158,73 +4922,116 @@ var Centrifuge = class extends EventEmitter {
       self2._token = token;
       self2._debug("connection token refreshed");
       if (self2._config.getData) {
-        self2._config.getData().then(function(data) {
-          if (!self2._isConnecting()) {
+        self2._getData().then(function(data) {
+          dataResolved = true;
+          if (self2._attemptAborted(disconnects)) {
             return;
           }
           self2._data = data;
           self2._initializeTransport();
-        }).catch((e) => self2._handleGetDataError(e));
+        }).catch((e) => self2._handleGetDataError(e, disconnects, dataResolved));
       } else {
         self2._initializeTransport();
       }
     }).catch(function(e) {
-      if (!self2._isConnecting()) {
+      if (self2._attemptAborted(disconnects)) {
+        if (tokenResolved) {
+          self2._reportDispatchError(e);
+        }
         return;
       }
       if (e instanceof UnauthorizedError) {
         self2._failUnauthorized();
         return;
       }
-      self2.emit("error", {
+      self2._emitError({
         "type": "connectToken",
         "error": {
           code: errorCodes.clientConnectToken,
           message: e !== void 0 ? e.toString() : ""
         }
+      }, () => {
+        const delay = self2._getReconnectDelay();
+        self2._debug("error on getting connection token, reconnect after " + delay + " milliseconds", e);
+        self2._reconnecting = false;
+        self2._reconnectTimeout = setTimeout(() => {
+          self2._startReconnecting();
+        }, delay);
       });
-      const delay = self2._getReconnectDelay();
-      self2._debug("error on getting connection token, reconnect after " + delay + " milliseconds", e);
-      self2._reconnecting = false;
-      self2._reconnectTimeout = setTimeout(() => {
-        self2._startReconnecting();
-      }, delay);
     });
   }
-  _handleGetDataError(e) {
+  // Emits an error event, then runs the continuation: not when a handler disconnected
+  // the client (or threw, which disconnects it), maybe to connect again, whose new
+  // attempt the continuation must not touch.
+  _emitError(ctx, continuation) {
+    const disconnects = this._disconnects;
+    try {
+      this.emit("error", ctx);
+    } finally {
+      if (this._disconnects === disconnects) {
+        continuation();
+      }
+    }
+  }
+  _attemptAborted(disconnects) {
+    return !this._isConnecting() || this._disconnects !== disconnects;
+  }
+  // resolved: the data promise resolved, so the error was thrown by its continuation.
+  _handleGetDataError(e, disconnects, resolved) {
+    if (this._attemptAborted(disconnects)) {
+      if (resolved) {
+        this._reportDispatchError(e);
+      }
+      return;
+    }
     if (e instanceof UnauthorizedError) {
       this._failUnauthorized();
       return;
     }
-    this.emit("error", {
+    this._emitError({
       type: "connectData",
       error: {
         code: errorCodes.badConfiguration,
         message: (e === null || e === void 0 ? void 0 : e.toString()) || ""
       }
+    }, () => {
+      const delay = this._getReconnectDelay();
+      this._debug("error on getting connect data, reconnect after " + delay + " milliseconds", e);
+      this._reconnecting = false;
+      this._reconnectTimeout = setTimeout(() => {
+        this._startReconnecting();
+      }, delay);
     });
-    const delay = this._getReconnectDelay();
-    this._debug("error on getting connect data, reconnect after " + delay + " milliseconds", e);
-    this._reconnecting = false;
-    this._reconnectTimeout = setTimeout(() => {
-      this._startReconnecting();
-    }, delay);
   }
-  _connectError(err) {
+  // stale: the error belongs to a transport that was already closed. It is still
+  // reported, but must not tear down the current connection attempt.
+  // replied: the server returned the error in a reply, so the transport works.
+  // token: the token the connect command carried.
+  _connectError(err, stale, replied, token) {
     if (this.state !== State.Connecting) {
       return;
     }
-    if (err.code === 109) {
+    if (err.code === 109 && token === this._token) {
       this._refreshRequired = true;
     }
     if (err.code < 100 || err.temporary === true || err.code === 109) {
-      this.emit("error", {
+      this._emitError({
         "type": "connect",
         "error": err
+      }, () => {
+        if (stale) {
+          return;
+        }
+        if (replied) {
+          this._transportWasOpen = true;
+        }
+        if (!replied && this._emulation && !this._transportWasOpen) {
+          this._advanceTransportIndex();
+        }
+        this._debug("closing transport due to connect error");
+        this._disconnect(err.code, err.message, true);
       });
-      this._debug("closing transport due to connect error");
-      this._disconnect(err.code, err.message, true);
-    } else {
+    } else if (!stale) {
       this._disconnect(err.code, err.message, false);
     }
   }
@@ -4236,10 +5043,7 @@ var Centrifuge = class extends EventEmitter {
     if (this._emulation && !this._transportWasOpen && !this._triedAllTransports) {
       isInitialHandshake = true;
     }
-    let delay = this._getReconnectDelay();
-    if (isInitialHandshake) {
-      delay = 0;
-    }
+    const delay = isInitialHandshake ? 0 : this._getReconnectDelay();
     this._debug("reconnect after " + delay + " milliseconds");
     this._clearReconnectTimeout();
     this._reconnectTimeout = setTimeout(() => {
@@ -4271,8 +5075,10 @@ var Centrifuge = class extends EventEmitter {
         const sub = {
           "recover": true
         };
-        if (this._serverSubs[channel].offset) {
-          sub["offset"] = this._serverSubs[channel].offset;
+        const pending = this._pendingServerSubOffsets[channel];
+        const offset = pending !== void 0 && pending !== null ? pending : this._serverSubs[channel].offset;
+        if (offset) {
+          sub["offset"] = offset;
         }
         if (this._serverSubs[channel].epoch) {
           sub["epoch"] = this._serverSubs[channel].epoch;
@@ -4314,10 +5120,12 @@ var Centrifuge = class extends EventEmitter {
       return Promise.resolve();
     }
     return new Promise((res, rej) => {
-      const timeout = setTimeout(function() {
+      const id = this._nextPromiseId();
+      const timeout = setTimeout(() => {
+        delete this._promises[id];
         rej({ code: errorCodes.timeout, message: "timeout" });
       }, this._config.timeout);
-      this._promises[this._nextPromiseId()] = {
+      this._promises[id] = {
         timeout,
         resolve: res,
         reject: rej
@@ -4328,9 +5136,13 @@ var Centrifuge = class extends EventEmitter {
     return new Promise((resolve, reject) => {
       this._call(cmd, false).then((resolveCtx) => {
         var _a;
-        const result = resultCB(resolveCtx.reply);
-        resolve(result);
-        (_a = resolveCtx.next) === null || _a === void 0 ? void 0 : _a.call(resolveCtx);
+        try {
+          resolve(resultCB(resolveCtx.reply));
+        } catch (e) {
+          reject(e);
+        } finally {
+          (_a = resolveCtx.next) === null || _a === void 0 ? void 0 : _a.call(resolveCtx);
+        }
       }, (rejectCtx) => {
         var _a;
         reject(rejectCtx.error);
@@ -4338,25 +5150,36 @@ var Centrifuge = class extends EventEmitter {
       });
     });
   }
-  _dataReceived(data) {
-    if (this._serverPing > 0) {
+  _dataReceived(data, transportId = this._transportId) {
+    let replies;
+    try {
+      replies = this._codec.decodeReplies(data);
+    } catch (e) {
+      this._debug("error decoding received data", e);
+      if (this._emulation && !this._transportWasOpen) {
+        this._advanceTransportIndex();
+      }
+      this._disconnect(connectingCodes.transportClosed, "transport closed", true);
+      return;
+    }
+    if (this._serverPing > 0 && replies.length > 0) {
       this._waitServerPing();
     }
-    const replies = this._codec.decodeReplies(data);
-    this._dispatchPromise = this._dispatchPromise.then(() => {
-      let finishDispatch;
-      this._dispatchPromise = new Promise((resolve) => {
-        finishDispatch = resolve;
-      });
-      this._dispatchSynchronized(replies, finishDispatch);
-    });
+    this._dispatchPromise = this._dispatchPromise.then(() => new Promise((resolve) => {
+      this._dispatchSynchronized(replies, resolve, transportId);
+    }));
   }
-  _dispatchSynchronized(replies, finishDispatch) {
+  _dispatchSynchronized(replies, finishDispatch, transportId) {
     let p = Promise.resolve();
     for (const i in replies) {
       if (replies.hasOwnProperty(i)) {
         p = p.then(() => {
+          if (this._transportId !== transportId) {
+            return;
+          }
           return this._dispatchReply(replies[i]);
+        }).catch((err) => {
+          this._dispatchFailed(err);
         });
       }
     }
@@ -4364,6 +5187,52 @@ var Centrifuge = class extends EventEmitter {
       finishDispatch();
     });
   }
+  /** @internal Every event reaches the application's handlers through here. */
+  emit(event, ...args) {
+    try {
+      return EventEmitter.prototype.emit.call(this, event, ...args);
+    } catch (e) {
+      this._handlerFailed(e);
+      return true;
+    }
+  }
+  // An exception escaping an application event handler. The SDK can't know what the
+  // handler left undone, so it fails loudly instead of going on as if nothing
+  // happened: the client disconnects without reconnecting, and the exception is
+  // re-raised as an unhandled rejection. The SDK's own work continues as if the
+  // handler had returned, as for a handler calling disconnect(), so no state change
+  // is left half done.
+  /** @internal */
+  _handlerFailed(err) {
+    this._handlerFailures++;
+    this._reportDispatchError(err);
+    this._disconnect(disconnectedCodes.badProtocol, `exception in event handler: ${errorMessage(err)}`, false);
+  }
+  // An exception while handling a reply, other than one of an event handler (see
+  // _handlerFailed), may have left the client's state inconsistent. The client stops
+  // in a state the application can see: it disconnects without reconnecting, so no
+  // later reply is processed.
+  _dispatchFailed(err) {
+    this._reportDispatchError(err);
+    this._disconnect(disconnectedCodes.badProtocol, `exception during message handling: ${errorMessage(err)}`, false);
+  }
+  // The exception is surfaced as an unhandled rejection, as before.
+  _reportDispatchError(err) {
+    this._debug("error dispatching reply", err);
+    Promise.reject(err);
+  }
+  // An exception, other than one of an event handler, while handling a rejected
+  // command. A rejection with next() carries a reply, and is handled as any reply
+  // (see _dispatchFailed). A timeout or a teardown doesn't: stopping the client would
+  // cancel the reconnect or retry the handling scheduled, so the exception is only
+  // reported.
+  _rejectionFailed(err, rejectCtx) {
+    if (rejectCtx.next !== void 0) {
+      this._dispatchFailed(err);
+    } else {
+      this._reportDispatchError(err);
+    }
+  }
   _dispatchReply(reply) {
     let next;
     const p = new Promise((resolve) => {
@@ -4397,16 +5266,25 @@ var Centrifuge = class extends EventEmitter {
   }
   _startConnecting() {
     this._debug("start connecting");
-    if (this._setState(State.Connecting)) {
-      this.emit("connecting", { code: connectingCodes.connectCalled, reason: "connect called" });
+    const transition = this.state !== State.Connecting ? this._stateTransitions + 1 : 0;
+    try {
+      this._setState(State.Connecting);
+      if (transition && !this._transitionSuperseded(transition)) {
+        this.emit("connecting", { code: connectingCodes.connectCalled, reason: "connect called" });
+      }
+    } finally {
+      if (!this._transitionSuperseded(transition)) {
+        this._client = null;
+        this._startReconnecting();
+      }
     }
-    this._client = null;
-    this._startReconnecting();
   }
   _disconnect(code, reason, reconnect) {
     if (code === disconnectedCodes.stateInvalidated) {
-      this._token = "";
-      this._refreshRequired = true;
+      if (this._config.getToken !== null) {
+        this._token = "";
+        this._refreshRequired = true;
+      }
       for (const channel in this._subs) {
         if (this._subs.hasOwnProperty(channel)) {
           this._subs[channel]._invalidateState();
@@ -4420,47 +5298,70 @@ var Centrifuge = class extends EventEmitter {
       }
     }
     if (this._isDisconnected()) {
+      if (!reconnect) {
+        this._rejectPromises({ code: errorCodes.clientDisconnected, message: "disconnected" });
+      }
       return;
     }
-    this._transportIsOpen = false;
     const previousState = this.state;
+    const newState = reconnect ? State.Connecting : State.Disconnected;
+    this._transportIsOpen = false;
     this._reconnecting = false;
-    const ctx = {
-      code,
-      reason
-    };
-    let needEvent;
-    if (reconnect) {
-      needEvent = this._setState(State.Connecting);
-    } else {
-      needEvent = this._setState(State.Disconnected);
-      this._rejectPromises({ code: errorCodes.clientDisconnected, message: "disconnected" });
-    }
-    this._clearOutgoingRequests();
     if (previousState === State.Connecting) {
       this._clearReconnectTimeout();
     }
-    if (previousState === State.Connected) {
-      this._clearConnectedState();
-    }
-    if (needEvent) {
-      if (this._isConnecting()) {
-        this.emit("connecting", ctx);
-      } else {
-        this.emit("disconnected", ctx);
-      }
-    }
+    this._clearConnectTimeout();
+    this._nextTransportId();
+    this._disconnects++;
     if (this._transport) {
       this._debug("closing existing transport");
       const transport = this._transport;
       this._transport = null;
-      transport.close();
+      try {
+        transport.close();
+      } catch (e) {
+        this._debug("error closing transport", e);
+      }
       this._transportClosed = true;
-      this._nextTransportId();
     } else {
       this._debug("no transport to close");
     }
-    this._scheduleReconnect();
+    this._reconnectAttemptsResetPending = false;
+    this._commands = [];
+    this._clearOutgoingRequests();
+    if (!reconnect) {
+      this._rejectPromises({ code: errorCodes.clientDisconnected, message: "disconnected" });
+      this._deviceWentOffline = false;
+      this._pageCached = false;
+    }
+    const ctx = {
+      code,
+      reason
+    };
+    const transition = this.state !== newState ? this._stateTransitions + 1 : 0;
+    try {
+      try {
+        this._setState(newState);
+      } finally {
+        if (!reconnect && !this._transitionSuperseded(transition)) {
+          this._rejectPromises({ code: errorCodes.clientDisconnected, message: "disconnected" });
+        }
+        if (previousState === State.Connected) {
+          this._clearConnectedState();
+        }
+      }
+      if (transition && !this._transitionSuperseded(transition)) {
+        if (reconnect) {
+          this.emit("connecting", ctx);
+        } else {
+          this.emit("disconnected", ctx);
+        }
+      }
+    } finally {
+      if (reconnect && !this._transitionSuperseded(transition)) {
+        this._scheduleReconnect();
+      }
+    }
   }
   _failUnauthorized() {
     this._disconnect(disconnectedCodes.unauthorized, "unauthorized", false);
@@ -4468,21 +5369,39 @@ var Centrifuge = class extends EventEmitter {
   _getToken() {
     this._debug("get connection token");
     if (!this._config.getToken) {
-      this.emit("error", {
-        type: "configuration",
-        error: {
-          code: errorCodes.badConfiguration,
-          message: "token expired but no getToken function set in the configuration"
-        }
-      });
+      try {
+        this.emit("error", {
+          type: "configuration",
+          error: {
+            code: errorCodes.badConfiguration,
+            message: "token expired but no getToken function set in the configuration"
+          }
+        });
+      } catch (e) {
+        this._reportDispatchError(e);
+      }
       return Promise.reject(new UnauthorizedError(""));
     }
-    return this._config.getToken({});
+    try {
+      return Promise.resolve(this._config.getToken({}));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  // See _getToken.
+  _getData() {
+    try {
+      return Promise.resolve(this._config.getData());
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
   _refresh() {
     const clientId = this._client;
     const self2 = this;
+    let tokenResolved = false;
     this._getToken().then(function(token) {
+      tokenResolved = true;
       if (clientId !== self2._client) {
         return;
       }
@@ -4499,42 +5418,58 @@ var Centrifuge = class extends EventEmitter {
         refresh: { token: self2._token }
       };
       self2._call(cmd, false).then((resolveCtx) => {
-        const result = resolveCtx.reply.refresh;
-        self2._refreshResponse(result);
-        if (resolveCtx.next) {
-          resolveCtx.next();
+        try {
+          self2._refreshResponse(resolveCtx.reply.refresh);
+        } catch (err) {
+          self2._dispatchFailed(err);
+        } finally {
+          if (resolveCtx.next) {
+            resolveCtx.next();
+          }
         }
       }, (rejectCtx) => {
-        self2._refreshError(rejectCtx.error);
-        if (rejectCtx.next) {
-          rejectCtx.next();
+        try {
+          if (clientId === self2._client) {
+            self2._refreshError(rejectCtx.error);
+          }
+        } catch (err) {
+          self2._rejectionFailed(err, rejectCtx);
+        } finally {
+          if (rejectCtx.next) {
+            rejectCtx.next();
+          }
         }
       });
     }).catch(function(e) {
-      if (!self2._isConnected()) {
+      if (clientId !== self2._client || !self2._isConnected()) {
+        if (tokenResolved) {
+          self2._reportDispatchError(e);
+        }
         return;
       }
       if (e instanceof UnauthorizedError) {
         self2._failUnauthorized();
         return;
       }
-      self2.emit("error", {
+      self2._emitError({
         type: "refreshToken",
         error: {
           code: errorCodes.clientRefreshToken,
           message: e !== void 0 ? e.toString() : ""
         }
+      }, () => {
+        self2._refreshTimeout = setTimeout(() => self2._refresh(), self2._getRefreshRetryDelay());
       });
-      self2._refreshTimeout = setTimeout(() => self2._refresh(), self2._getRefreshRetryDelay());
     });
   }
   _refreshError(err) {
     if (err.code < 100 || err.temporary === true) {
-      this.emit("error", {
+      this._emitError({
         type: "refresh",
         error: err
+      }, () => {
+        this._refreshTimeout = setTimeout(() => this._refresh(), this._getRefreshRetryDelay());
       });
-      this._refreshTimeout = setTimeout(() => this._refresh(), this._getRefreshRetryDelay());
     } else {
       this._disconnect(err.code, err.message, false);
     }
@@ -4548,15 +5483,33 @@ var Centrifuge = class extends EventEmitter {
       this._refreshTimeout = null;
     }
     if (result.expires) {
-      this._client = result.client;
+      if (result.client) {
+        this._client = result.client;
+      }
       this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));
     }
   }
-  _removeSubscription(sub) {
-    if (sub === null) {
-      return;
-    }
-    delete this._subs[sub.channel];
+  // A new subscription of the channel waits for the unsubscribe of a removed one, and
+  // of those removed before it still unsubscribing (see _setSubscribing of a
+  // subscription): a subscription removed without sending an unsubscribe doesn't
+  // drop one still pending.
+  _recordRemovedUnsubscribe(sub) {
+    const channel = sub.channel;
+    const previous = this._removedUnsubscribes[channel];
+    const own = sub._unsubPromise;
+    const unsubscribed = previous ? Promise.all([previous, own]).then(() => void 0) : own;
+    this._removedUnsubscribes[channel] = unsubscribed;
+    unsubscribed.then(() => {
+      if (this._removedUnsubscribes[channel] === unsubscribed) {
+        delete this._removedUnsubscribes[channel];
+      }
+    });
+  }
+  // Resolves once a subscription of the channel removed from the client has
+  // unsubscribed (see BaseSubscription._setSubscribing).
+  // @ts-ignore – this is used by a subscription in subscription.ts.
+  _removedSubscriptionUnsubscribed(channel) {
+    return this._removedUnsubscribes[channel] || Promise.resolve();
   }
   _unsubscribe(sub) {
     if (!this._transportIsOpen) {
@@ -4567,6 +5520,7 @@ var Centrifuge = class extends EventEmitter {
     };
     const cmd = { unsubscribe: req };
     const self2 = this;
+    const transportId = this._transportId;
     const unsubscribePromise = new Promise((resolve, _) => {
       this._call(cmd, false).then((resolveCtx) => {
         resolve();
@@ -4578,7 +5532,15 @@ var Centrifuge = class extends EventEmitter {
         if (rejectCtx.next) {
           rejectCtx.next();
         }
-        self2._disconnect(connectingCodes.unsubscribeError, "unsubscribe error", true);
+        if (self2._transportId !== transportId) {
+          self2._debug("unsubscribe command of a closed transport rejected");
+          return;
+        }
+        try {
+          self2._disconnect(connectingCodes.unsubscribeError, "unsubscribe error", true);
+        } catch (err) {
+          self2._rejectionFailed(err, rejectCtx);
+        }
       });
     });
     return unsubscribePromise;
@@ -4604,6 +5566,17 @@ var Centrifuge = class extends EventEmitter {
   _isServerSub(channel) {
     return this._serverSubs[channel] !== void 0;
   }
+  // The client-side subscription a push is for. The server allows one subscription
+  // per channel: while a server-side subscription has the channel, its pushes
+  // belong to it unless the client-side subscription is subscribed, e.g. when the
+  // app kept an unsubscribed subscription object of that channel.
+  _getSubForPush(channel, id) {
+    const sub = this._getSub(channel, id);
+    if (sub && channel && this._isServerSub(channel) && !sub._isSubscribed()) {
+      return null;
+    }
+    return sub;
+  }
   _sendSubscribeCommands() {
     const commands = [];
     for (const channel in this._subs) {
@@ -4614,6 +5587,9 @@ var Centrifuge = class extends EventEmitter {
       if (sub._inflight === true) {
         continue;
       }
+      if (sub._resubscribeTimeout !== null) {
+        continue;
+      }
       if (sub.state === SubscriptionState.Subscribing) {
         const cmd = sub._subscribe();
         if (cmd) {
@@ -4626,13 +5602,22 @@ var Centrifuge = class extends EventEmitter {
   _connectResponse(result) {
     this._transportIsOpen = true;
     this._transportWasOpen = true;
-    this._reconnectAttempts = 0;
+    if (this._transport !== null && this._transport.emulation()) {
+      this._reconnectAttemptsResetPending = true;
+    } else {
+      this._reconnectAttempts = 0;
+    }
     this._refreshRequired = false;
+    this._deviceWentOffline = false;
+    this._pageCached = false;
     if (this._isConnected()) {
       return;
     }
     this._client = result.client;
-    this._setState(State.Connected);
+    const transition = this._setState(State.Connected);
+    if (this._transitionSuperseded(transition)) {
+      return;
+    }
     if (this._refreshTimeout) {
       clearTimeout(this._refreshTimeout);
     }
@@ -4652,8 +5637,11 @@ var Centrifuge = class extends EventEmitter {
       ctx.data = result.data;
     }
     this.emit("connected", ctx);
+    if (this._transitionSuperseded(transition)) {
+      return;
+    }
     this._resolvePromises();
-    this._processServerSubs(result.subs || {});
+    this._processServerSubs(result.subs || {}, transition);
     if (result.ping && result.ping > 0) {
       this._serverPing = result.ping * 1e3;
       this._sendPong = result.pong === true;
@@ -4662,16 +5650,20 @@ var Centrifuge = class extends EventEmitter {
       this._serverPing = 0;
     }
   }
-  _processServerSubs(subs) {
+  _processServerSubs(subs, transition) {
     for (const channel in subs) {
       if (!subs.hasOwnProperty(channel)) {
         continue;
       }
+      if (this._transitionSuperseded(transition)) {
+        continue;
+      }
       const sub = subs[channel];
       this._serverSubs[channel] = {
-        "offset": sub.offset,
+        "offset": toOffset(sub.offset),
         "epoch": sub.epoch,
-        "recoverable": sub.recoverable || false
+        "recoverable": sub.recoverable || false,
+        "subscribed": true
       };
       const subCtx = this._getSubscribeContext(channel, sub);
       this.emit("subscribed", subCtx);
@@ -4682,13 +5674,9 @@ var Centrifuge = class extends EventEmitter {
       }
       const sub = subs[channel];
       if (sub.recovered) {
-        const pubs = sub.publications;
-        if (pubs && pubs.length > 0) {
-          for (const i in pubs) {
-            if (pubs.hasOwnProperty(i)) {
-              this._handlePublication(channel, pubs[i]);
-            }
-          }
+        const pubs = sub.publications || [];
+        for (let i = 0; i < pubs.length && !this._transitionSuperseded(transition); i++) {
+          this._handlePublication(channel, pubs[i]);
         }
       }
     }
@@ -4714,6 +5702,12 @@ var Centrifuge = class extends EventEmitter {
       this._reconnectTimeout = null;
     }
   }
+  _clearConnectTimeout() {
+    if (this._connectTimeout !== null) {
+      clearTimeout(this._connectTimeout);
+      this._connectTimeout = null;
+    }
+  }
   _clearServerPingTimeout() {
     if (this._serverPingTimeout !== null) {
       clearTimeout(this._serverPingTimeout);
@@ -4728,12 +5722,20 @@ var Centrifuge = class extends EventEmitter {
       return;
     }
     this._clearServerPingTimeout();
+    const delay = this._serverPing + this._config.maxServerPingDelay;
+    const due = Date.now() + delay;
     this._serverPingTimeout = setTimeout(() => {
       if (!this._isConnected()) {
         return;
       }
-      this._disconnect(connectingCodes.noPing, "no ping", true);
-    }, this._serverPing + this._config.maxServerPingDelay);
+      const late = Date.now() - due >= lateCallTimer;
+      this._serverPingTimeout = setTimeout(() => {
+        if (!this._isConnected()) {
+          return;
+        }
+        this._disconnect(connectingCodes.noPing, "no ping", true);
+      }, late ? lateCallGrace : 0);
+    }, delay);
   }
   _getSubscribeContext(channel, result) {
     const ctx = {
@@ -4762,7 +5764,7 @@ var Centrifuge = class extends EventEmitter {
     }
     let offset = 0;
     if ("offset" in result) {
-      offset = result.offset;
+      offset = toOffset(result.offset);
     }
     if (ctx.positioned || ctx.recoverable) {
       ctx.streamPosition = {
@@ -4779,6 +5781,7 @@ var Centrifuge = class extends EventEmitter {
     return ctx;
   }
   _handleReply(reply, next) {
+    this._resetReconnectAttemptsIfPending();
     const id = reply.id;
     if (!(id in this._callbacks)) {
       next();
@@ -4804,7 +5807,7 @@ var Centrifuge = class extends EventEmitter {
     }
   }
   _handleJoin(channel, join, id) {
-    const sub = this._getSub(channel, id);
+    const sub = this._getSubForPush(channel, id);
     if (!sub) {
       if (channel && this._isServerSub(channel)) {
         const ctx = { channel, info: this._getJoinLeaveContext(join.info) };
@@ -4812,10 +5815,14 @@ var Centrifuge = class extends EventEmitter {
       }
       return;
     }
+    if (!sub._isSubscribed()) {
+      this._debug("join for a subscription that is not subscribed", channel);
+      return;
+    }
     sub._handleJoin(join);
   }
   _handleLeave(channel, leave, id) {
-    const sub = this._getSub(channel, id);
+    const sub = this._getSubForPush(channel, id);
     if (!sub) {
       if (channel && this._isServerSub(channel)) {
         const ctx = { channel, info: this._getJoinLeaveContext(leave.info) };
@@ -4823,17 +5830,25 @@ var Centrifuge = class extends EventEmitter {
       }
       return;
     }
+    if (!sub._isSubscribed()) {
+      this._debug("leave for a subscription that is not subscribed", channel);
+      return;
+    }
     sub._handleLeave(leave);
   }
   _handleUnsubscribe(channel, unsubscribe) {
-    const sub = this._getSub(channel, 0);
-    if (!sub && channel) {
-      if (this._isServerSub(channel)) {
+    const sub = this._getSubForPush(channel, 0);
+    if (!sub) {
+      if (channel && this._isServerSub(channel)) {
         delete this._serverSubs[channel];
         this.emit("unsubscribed", { channel });
       }
       return;
     }
+    if (!sub._isSubscribed()) {
+      this._debug("unsubscribe push for a previous subscription", channel);
+      return;
+    }
     if (unsubscribe.code < 2500) {
       sub._setUnsubscribed(unsubscribe.code, unsubscribe.reason, false);
     } else {
@@ -4845,13 +5860,15 @@ var Centrifuge = class extends EventEmitter {
   }
   _handleSubscribe(channel, sub) {
     this._serverSubs[channel] = {
-      "offset": sub.offset,
+      "offset": toOffset(sub.offset),
       "epoch": sub.epoch,
-      "recoverable": sub.recoverable || false
+      "recoverable": sub.recoverable || false,
+      "subscribed": true
     };
     this.emit("subscribed", this._getSubscribeContext(channel, sub));
   }
   _handleDisconnect(disconnect) {
+    this._transportWasOpen = true;
     const code = disconnect.code;
     let reconnect = true;
     if (code >= 3500 && code < 4e3 || code >= 4500 && code < 5e3) {
@@ -4864,8 +5881,8 @@ var Centrifuge = class extends EventEmitter {
       channel,
       data: pub.data
     };
-    if (pub.offset) {
-      ctx.offset = pub.offset;
+    if (hasOffset(pub.offset)) {
+      ctx.offset = toOffset(pub.offset);
     }
     if (pub.info) {
       ctx.info = this._getJoinLeaveContext(pub.info);
@@ -4891,23 +5908,40 @@ var Centrifuge = class extends EventEmitter {
     return info;
   }
   _handlePublication(channel, pub, id) {
-    const sub = this._getSub(channel, id);
+    const sub = this._getSubForPush(channel, id);
     if (!sub) {
       if (channel && this._isServerSub(channel)) {
         const ctx = this._getPublicationContext(channel, pub);
-        this.emit("publication", ctx);
-        if (pub.offset !== void 0) {
-          this._serverSubs[channel].offset = pub.offset;
+        this._pendingServerSubOffsets[channel] = hasOffset(pub.offset) ? toOffset(pub.offset) : null;
+        const failures = this._handlerFailures;
+        try {
+          this.emit("publication", ctx);
+        } finally {
+          delete this._pendingServerSubOffsets[channel];
+        }
+        if (this._handlerFailures !== failures) {
+          return;
+        }
+        if (hasOffset(pub.offset)) {
+          this._serverSubs[channel].offset = toOffset(pub.offset);
+        }
+        if (pub.epoch) {
+          this._serverSubs[channel].epoch = pub.epoch;
         }
       }
       return;
     }
+    if (!sub._isSubscribed()) {
+      this._debug("publication for a subscription that is not subscribed", channel);
+      return;
+    }
     sub._handlePublication(pub);
   }
   _handleMessage(message) {
     this.emit("message", { data: message.data });
   }
   _handleServerPing(next) {
+    this._resetReconnectAttemptsIfPending();
     if (this._sendPong) {
       const cmd = {};
       this._transportSendCommands([cmd]);
@@ -4955,11 +5989,15 @@ var Centrifuge = class extends EventEmitter {
       errback,
       timeout: null
     };
+    const due = Date.now() + this._config.timeout;
     this._callbacks[id].timeout = setTimeout(() => {
-      delete this._callbacks[id];
-      if (isFunction(errback)) {
-        errback({ error: this._createErrorObject(errorCodes.timeout, "timeout") });
-      }
+      const late = Date.now() - due >= lateCallTimer;
+      this._callbacks[id].timeout = setTimeout(() => {
+        delete this._callbacks[id];
+        if (isFunction(errback)) {
+          errback({ error: this._createErrorObject(errorCodes.timeout, "timeout") });
+        }
+      }, late ? lateCallGrace : 0);
     }, this._config.timeout);
   }
   _addCommand(command) {