@stream-io/video-client 1.48.0 → 1.49.0

package/dist/src/Call.d.ts

@@ -92,6 +92,11 @@ export declare class Call {
     private disconnectionTimeoutSeconds;
     private lastOfflineTimestamp;
     private networkAvailableTask;
+    private readonly rejoinRateLimiter;
+    private maxIceFailuresWithoutConnect;
+    private iceFailuresWithoutConnect;
+    private maxConsecutiveNegotiationFailures;
+    private consecutiveNegotiationFailures;
     private trackPublishOrder;
     private joinResponseTimeout?;
     private rpcRequestTimeout?;
@@ -298,7 +303,9 @@ export declare class Call {
      * @internal
      *
      * @param strategy the reconnection strategy to use.
-     * @param reason the reason for the reconnection.
+     * @param reason the reason for the reconnection. Pass a `ReconnectReason.*`
+     *   constant when the SDK should react to it (e.g.
+     *   `ICE_NEVER_CONNECTED` increments the unsupported-network counter).
      */
     private reconnect;
     /**
@@ -839,6 +846,33 @@ export declare class Call {
      * @param timeoutSeconds Timeout in seconds, or 0 to keep reconnecting indefinetely
      */
     setDisconnectionTimeout: (timeoutSeconds: number) => void;
+    /**
+     * Configures the rolling-window limit for REJOIN/MIGRATE attempts. Once
+     * `maxAttempts` rejoins have been registered inside `windowSeconds`, the
+     * SDK stops retrying and transitions the call to `LEFT` with the
+     * `rejoin_attempt_limit_exceeded` leave message.
+     *
+     * Defaults: 10 attempts per 120 seconds (aligned with the Swift SDK).
+     * Both arguments are clamped to a minimum of 1.
+     */
+    setRejoinAttemptLimit: (maxAttempts: number, windowSeconds: number) => void;
+    /**
+     * Configures how many peer-connection failures where ICE never reached
+     * `connected`/`completed` are tolerated before the SDK concludes that the
+     * current network cannot support WebRTC and transitions the call to
+     * `LEFT` with the `webrtc_unsupported_network` leave message.
+     *
+     * Default: 2. Clamped to a minimum of 1.
+     */
+    setMaxIceFailuresWithoutConnect: (n: number) => void;
+    /**
+     * Configures how many consecutive SDP `NegotiationError`s are tolerated
+     * before the SDK stops retrying and transitions the call to `LEFT` with
+     * the `repeated_negotiation_failures` leave message.
+     *
+     * Default: 3. Clamped to a minimum of 1.
+     */
+    setMaxConsecutiveNegotiationFailures: (n: number) => void;
     /**
      * Enables the provided client capabilities.
      */

package/dist/src/StreamSfuClient.d.ts

@@ -107,7 +107,8 @@ export declare class StreamSfuClient {
     private networkAvailableTask;
     /**
      * Promise that resolves when the JoinResponse is received.
-     * Rejects after a certain threshold if the response is not received.
+     * Rejects after a certain threshold if the response is not received,
+     * or when the SFU client is disposed before a join completes.
      */
     private joinResponseTask;
     /**
@@ -140,6 +141,12 @@ export declare class StreamSfuClient {
      * The close code used when the client fails to join the call (on the SFU).
      */
     static JOIN_FAILED: number;
+    /**
+     * Best-effort grace period in `leaveAndClose` for an in-flight join to
+     * complete before we give up and close without sending `leaveCallRequest`.
+     * Bounded so a stuck join can never hang the leave path.
+     */
+    static LEAVE_NOTIFY_GRACE_MS: number;
     /**
      * Constructs a new SFU client.
      */

package/dist/src/devices/DeviceManagerState.d.ts

@@ -6,6 +6,7 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
     protected statusSubject: BehaviorSubject<InputDeviceStatus>;
     protected optimisticStatusSubject: BehaviorSubject<InputDeviceStatus>;
     protected mediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
+    protected rootMediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
     protected selectedDeviceSubject: BehaviorSubject<string | undefined>;
     protected defaultConstraintsSubject: BehaviorSubject<C | undefined>;
     /**
@@ -17,6 +18,12 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      *
      */
     mediaStream$: Observable<MediaStream | undefined>;
+    /**
+     * An Observable that emits the raw device media stream (before any filters are applied),
+     * or `undefined` if the device is currently disabled. When no filters are active, this
+     * emits the same stream as `mediaStream$`.
+     */
+    rootMediaStream$: Observable<MediaStream | undefined>;
     /**
      * An Observable that emits the currently selected device
      */
@@ -73,6 +80,12 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      * The current media stream, or `undefined` if the device is currently disabled.
      */
     get mediaStream(): MediaStream | undefined;
+    /**
+     * The raw device media stream (before any filters are applied), or `undefined`
+     * if the device is currently disabled. When no filters are active, this is the
+     * same as `mediaStream`.
+     */
+    get rootMediaStream(): MediaStream | undefined;
     /**
      * @internal
      * @param status

package/dist/src/helpers/SlidingWindowRateLimiter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A generic sliding-window rate limiter.
+ *
+ * Allows at most `maxAttempts` registrations inside a rolling `windowMs`.
+ * Attempts spaced further apart than `windowMs` are always allowed.
+ */
+export declare class SlidingWindowRateLimiter {
+    private maxAttempts;
+    private windowMs;
+    private timestamps;
+    constructor(maxAttempts: number, windowMs: number);
+    /**
+     * Attempts to register a new event at `now`. Returns `true` if the attempt
+     * fits inside the budget (and records it), or `false` if the budget is
+     * exhausted (in which case no timestamp is recorded).
+     */
+    tryRegister: (now?: number) => boolean;
+    /**
+     * Clears the attempt history.
+     */
+    reset: () => void;
+    /**
+     * Updates the budget and window size. Existing timestamps are kept; they
+     * will be pruned by the next `tryRegister` call.
+     */
+    setLimits: (maxAttempts: number, windowMs: number) => void;
+    private prune;
+}

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -5,7 +5,7 @@ import { PeerType, TrackType } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { StatsTracer, Tracer } from '../stats';
-import type { BasePeerConnectionOpts } from './types';
+import { BasePeerConnectionOpts } from './types';
 import type { ClientPublishOptions } from '../types';
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -21,8 +21,11 @@ export declare abstract class BasePeerConnection {
     protected tag: string;
     protected sfuClient: StreamSfuClient;
     private onReconnectionNeeded?;
+    private onIceConnected?;
     private readonly iceRestartDelay;
+    private iceHasEverConnected;
     private iceRestartTimeout?;
+    private preConnectStuckTimeout?;
     protected isIceRestarting: boolean;
     private isDisposed;
     protected trackIdToTrackType: Map<string, TrackType>;
@@ -34,7 +37,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, tag, enableTracing, clientPublishOptions, iceRestartDelay, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, tag, enableTracing, clientPublishOptions, iceRestartDelay, }: BasePeerConnectionOpts);
     private createPeerConnection;
     /**
      * Disposes the `RTCPeerConnection` instance.
@@ -85,6 +88,12 @@ export declare abstract class BasePeerConnection {
      * it returns `false`, otherwise it returns `true`.
      */
     isHealthy: () => boolean;
+    /**
+     * Returns true only when the peer connection is currently fully established
+     * (ICE `connected`/`completed` AND connection state `connected`).
+     * Transient states like `disconnected`, `checking`, or `new` return false.
+     */
+    isStable: () => boolean;
     /**
      * Handles the ICECandidate event and
      * Initiates an ICE Trickle process with the SFU.

package/dist/src/rtc/index.d.ts

@@ -1,5 +1,6 @@
 export * from './codecs';
 export * from './Dispatcher';
+export * from './NegotiationError';
 export * from './IceTrickleBuffer';
 export * from './Publisher';
 export * from './Subscriber';

package/dist/src/rtc/types.d.ts

@@ -4,13 +4,45 @@ import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
-export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: string, peerType: PeerType) => void;
+/**
+ * Canonical reasons the SDK uses to trigger a reconnection. Free-form strings
+ * are still accepted at the callback boundary (e.g. when forwarding an SFU
+ * error message), but only the members below influence reconnect-loop
+ * behavior. In particular, `Call.reconnect` programmatically inspects
+ * `ICE_NEVER_CONNECTED` to drive the unsupported-network detector — pass a
+ * canonical member when you want the SDK to react to the reason; pass a
+ * free-form string when the value is purely diagnostic.
+ */
+export declare const ReconnectReason: {
+    /** ICE never reached `connected`/`completed`, escalate to REJOIN. */
+    readonly ICE_NEVER_CONNECTED: "ice_never_connected";
+    /** RTCPeerConnection.connectionState became `failed`. */
+    readonly CONNECTION_FAILED: "connection_failed";
+    /** `restartIce()` rejected. */
+    readonly RESTART_ICE_FAILED: "restart_ice_failed";
+    /** SFU `goAway` event, migrate to a new SFU. */
+    readonly GO_AWAY: "go_away";
+    /** Network came back online after going offline. */
+    readonly NETWORK_BACK_ONLINE: "network_back_online";
+    /** SFU error event with no descriptive message. */
+    readonly SFU_ERROR: "sfu_error";
+};
+export type ReconnectReason = (typeof ReconnectReason)[keyof typeof ReconnectReason] | (string & {});
+export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: ReconnectReason, peerType: PeerType) => void;
+/**
+ * Fires the first time a peer connection's ICE transport reaches
+ * `connected` or `completed` during its lifetime. Used by `Call` to reset
+ * the "ICE never connected" failure counter only when WebRTC has actually
+ * recovered, not merely when the SFU join handshake succeeded.
+ */
+export type OnIceConnected = (peerType: PeerType) => void;
 export type BasePeerConnectionOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
     connectionConfig?: RTCConfiguration;
     dispatcher: Dispatcher;
     onReconnectionNeeded?: OnReconnectionNeeded;
+    onIceConnected?: OnIceConnected;
     tag: string;
     enableTracing: boolean;
     iceRestartDelay?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.48.0",
+  "version": "1.49.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -7,7 +7,9 @@ import {
   isAudioTrackType,
   isSfuEvent,
   muteTypeToTrackType,
+  NegotiationError,
   Publisher,
+  ReconnectReason,
   Subscriber,
   toRtcConfiguration,
   TrackPublishOptions,
@@ -148,6 +150,7 @@ import { PermissionsContext } from './permissions';
 import { CallTypes } from './CallType';
 import { StreamClient } from './coordinator/connection/client';
 import { retryInterval, sleep } from './coordinator/connection/utils';
+import { SlidingWindowRateLimiter } from './helpers/SlidingWindowRateLimiter';
 import {
   AllCallEvents,
   CallEventListener,
@@ -271,6 +274,17 @@ export class Call {
   private disconnectionTimeoutSeconds: number = 0;
   private lastOfflineTimestamp: number = 0;
   private networkAvailableTask: PromiseWithResolvers<void> | undefined;
+
+  // (10 attempts per rolling 120 s window).
+  private readonly rejoinRateLimiter = new SlidingWindowRateLimiter(10, 120000);
+  // "Network doesn't support WebRTC" detector: counts peer-connection
+  // failures where ICE never reached `connected`/`completed`.
+  private maxIceFailuresWithoutConnect = 2;
+  private iceFailuresWithoutConnect = 0;
+  // Consecutive-negotiation-failure detector: stops the reconnect loop when
+  // the SFU keeps failing to negotiate SDP for us.
+  private maxConsecutiveNegotiationFailures = 3;
+  private consecutiveNegotiationFailures = 0;
   // maintain the order of publishing tracks to restore them after a reconnection
   // it shouldn't contain duplicates
   private trackPublishOrder: TrackType[] = [];
@@ -694,6 +708,20 @@ export class Call {
       this.state.setParticipants([]);
       this.state.dispose();
 
+      // Reset reconnect-related accumulators so a future `call.join()` on the
+      // same instance starts with a fresh budget. The `Call` may be reused
+      // (see `Call.test.ts` "can reuse call instance") so this is required.
+      // Strategy/reason/attempts must also be cleared: when `leave()` is
+      // reached via `giveUpAndLeave()` the success-path reset at the end of
+      // `joinFlow` never runs, leaving stale values that would make the next
+      // fresh `join()` send a stale `ReconnectDetails` to the SFU.
+      this.rejoinRateLimiter.reset();
+      this.iceFailuresWithoutConnect = 0;
+      this.consecutiveNegotiationFailures = 0;
+      this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
+      this.reconnectReason = '';
+      this.reconnectAttempts = 0;
+
       // Call all leave call hooks, e.g. to clean up global event handlers
       this.leaveCallHooks.forEach((hook) => hook());
       this.initialized = false;
@@ -1169,9 +1197,23 @@ export class Call {
     // when performing fast reconnect, or when we reuse the same SFU client,
     // (ws remained healthy), we just need to restore the ICE connection
     if (performingFastReconnect) {
-      // the SFU automatically issues an ICE restart on the subscriber
-      // we don't have to do it ourselves
-      await this.restoreICE(sfuClient, { includeSubscriber: false });
+      // The SFU automatically issues an ICE restart on the subscriber,
+      // so we only need to decide about the publisher. If the publisher's
+      // peer connection is still stable (ICE still connected end-to-end),
+      // the signal WebSocket drop was the only problem — the new WS alone
+      // is enough, and restarting ICE would add unnecessary SDP/ICE churn.
+      const publisherIsStable = this.publisher?.isStable() ?? true;
+      const includePublisher =
+        !!this.publisher?.isPublishing() && !publisherIsStable;
+      if (!includePublisher && this.publisher?.isPublishing()) {
+        this.logger.info(
+          '[Reconnect] FAST: skipping publisher ICE restart, publisher PC is stable',
+        );
+      }
+      await this.restoreICE(sfuClient, {
+        includeSubscriber: false,
+        includePublisher,
+      });
     } else {
       const connectionConfig = toRtcConfiguration(this.credentials.ice_servers);
       this.initPublisherAndSubscriber({
@@ -1223,6 +1265,15 @@ export class Call {
     // reset the reconnect strategy to unspecified after a successful reconnection
     this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
     this.reconnectReason = '';
+    // A successful SFU join handshake resets the consecutive-negotiation
+    // counter (negotiation just succeeded). It does NOT reset
+    // `iceFailuresWithoutConnect` or the rolling `rejoinRateLimiter`;
+    // those track WebRTC-level health and rejoin frequency, which are not
+    // proven by the SFU handshake alone. ICE-failures-without-connect is
+    // cleared via the `onIceConnected` callback when the peer connection
+    // actually reaches `connected`/`completed` end-to-end. The rejoin
+    // rolling window decays naturally as old timestamps age out.
+    this.consecutiveNegotiationFailures = 0;
 
     this.logger.info(`Joined call ${this.cid}`);
   };
@@ -1375,6 +1426,12 @@ export class Call {
           this.logger.warn(message, err);
         });
       },
+      onIceConnected: () => {
+        // ICE has reached `connected`/`completed` end-to-end on at least
+        // one peer connection, WebRTC is actually working, so the
+        // "ICE never connected" failure budget can be cleared.
+        this.iceFailuresWithoutConnect = 0;
+      },
     };
 
     this.subscriber = new Subscriber(basePeerConnectionOptions);
@@ -1501,11 +1558,13 @@ export class Call {
    * @internal
    *
    * @param strategy the reconnection strategy to use.
-   * @param reason the reason for the reconnection.
+   * @param reason the reason for the reconnection. Pass a `ReconnectReason.*`
+   *   constant when the SDK should react to it (e.g.
+   *   `ICE_NEVER_CONNECTED` increments the unsupported-network counter).
    */
   private reconnect = async (
     strategy: WebsocketReconnectStrategy,
-    reason: string,
+    reason: ReconnectReason,
   ): Promise<void> => {
     if (
       this.state.callingState === CallingState.RECONNECTING ||
@@ -1529,6 +1588,35 @@ export class Call {
         }
       };
 
+      const giveUpAndLeave = async (message: string) => {
+        this.logger.warn(
+          `[Reconnect] Giving up: ${message}. Leaving the call.`,
+        );
+        // If we're mid-iteration, the state can be JOINING; `Call.leave` would
+        // then wait for JOINED before proceeding, but no more attempts will run
+        // so JOINED never comes. Transition to RECONNECTING so `leave()` proceeds.
+        if (this.state.callingState === CallingState.JOINING) {
+          this.state.setCallingState(CallingState.RECONNECTING);
+        }
+        try {
+          await this.leave({ message });
+        } catch (err) {
+          this.logger.warn(`[Reconnect] leave() failed after ${message}`, err);
+        }
+      };
+
+      // Count this entry into reconnect if it was triggered by a peer
+      // connection that never reached `connected`/`completed`.
+      if (reason === ReconnectReason.ICE_NEVER_CONNECTED) {
+        this.iceFailuresWithoutConnect++;
+        if (
+          this.iceFailuresWithoutConnect >= this.maxIceFailuresWithoutConnect
+        ) {
+          await giveUpAndLeave('webrtc_unsupported_network');
+          return;
+        }
+      }
+
       let attempt = 0;
       do {
         const reconnectingTime = Date.now() - reconnectStartTime;
@@ -1544,6 +1632,19 @@ export class Call {
           return;
         }
 
+        // Rejoin rate limit: bound the number of REJOIN (and MIGRATE)
+        // transitions inside a rolling window. FAST is not counted because
+        // it does not issue a new backend `joinCall`.
+        if (
+          this.reconnectStrategy === WebsocketReconnectStrategy.REJOIN ||
+          this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE
+        ) {
+          if (!this.rejoinRateLimiter.tryRegister()) {
+            await giveUpAndLeave('rejoin_attempt_limit_exceeded');
+            return;
+          }
+        }
+
         // we don't increment reconnect attempts for the FAST strategy.
         if (this.reconnectStrategy !== WebsocketReconnectStrategy.FAST) {
           this.reconnectAttempts++;
@@ -1581,6 +1682,8 @@ export class Call {
               );
               break;
           }
+          // reconnection worked — reset the negotiation-failure streak.
+          this.consecutiveNegotiationFailures = 0;
           break; // do-while loop, reconnection worked, exit the loop
         } catch (error) {
           if (this.state.callingState === CallingState.OFFLINE) {
@@ -1599,8 +1702,19 @@ export class Call {
             await markAsReconnectingFailed();
             return;
           }
+          if (error instanceof NegotiationError) {
+            this.consecutiveNegotiationFailures++;
+            if (
+              this.consecutiveNegotiationFailures >=
+              this.maxConsecutiveNegotiationFailures
+            ) {
+              await giveUpAndLeave('repeated_negotiation_failures');
+              return;
+            }
+          }
 
-          await sleep(500);
+          // exponential backoff with jitter, capped at 5 s
+          await sleep(retryInterval(attempt));
 
           const wasMigrating =
             this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
@@ -1741,9 +1855,10 @@ export class Call {
   private registerReconnectHandlers = () => {
     // handles the legacy "goAway" event
     const unregisterGoAway = this.on('goAway', () => {
-      this.reconnect(WebsocketReconnectStrategy.MIGRATE, 'goAway').catch(
-        (err) => this.logger.warn('[Reconnect] Error reconnecting', err),
-      );
+      this.reconnect(
+        WebsocketReconnectStrategy.MIGRATE,
+        ReconnectReason.GO_AWAY,
+      ).catch((err) => this.logger.warn('[Reconnect] Error reconnecting', err));
     });
 
     // handles the "error" event, through which the SFU can request a reconnect
@@ -1760,7 +1875,10 @@ export class Call {
           this.logger.warn(`Can't leave call after disconnect request`, err);
         });
       } else {
-        this.reconnect(strategy, error?.message || 'SFU Error').catch((err) => {
+        this.reconnect(
+          strategy,
+          error?.message || ReconnectReason.SFU_ERROR,
+        ).catch((err) => {
           this.logger.warn('[Reconnect] Error reconnecting', err);
         });
       }
@@ -1787,12 +1905,14 @@ export class Call {
               }
             }
 
-            this.reconnect(strategy, 'Going online').catch((err) => {
-              this.logger.warn(
-                '[Reconnect] Error reconnecting after going online',
-                err,
-              );
-            });
+            this.reconnect(strategy, ReconnectReason.NETWORK_BACK_ONLINE).catch(
+              (err) => {
+                this.logger.warn(
+                  '[Reconnect] Error reconnecting after going online',
+                  err,
+                );
+              },
+            );
           });
           this.networkAvailableTask = networkAvailableTask;
           this.sfuStatsReporter?.stop();
@@ -1958,10 +2078,12 @@ export class Call {
     mediaStream: MediaStream | undefined,
     ...trackTypes: TrackType[]
   ) => {
-    if (!this.sfuClient || !this.sfuClient.sessionId) return;
+    const sessionId = this.sfuClient?.sessionId;
+    if (!sessionId) return;
+
     await this.notifyTrackMuteState(!mediaStream, ...trackTypes);
+    if (this.sfuClient?.sessionId !== sessionId) return;
 
-    const { sessionId } = this.sfuClient;
     for (const trackType of trackTypes) {
       const streamStateProp = trackTypeToParticipantStreamKey(trackType);
       if (!streamStateProp) continue;
@@ -3058,6 +3180,45 @@ export class Call {
     this.disconnectionTimeoutSeconds = timeoutSeconds;
   };
 
+  /**
+   * Configures the rolling-window limit for REJOIN/MIGRATE attempts. Once
+   * `maxAttempts` rejoins have been registered inside `windowSeconds`, the
+   * SDK stops retrying and transitions the call to `LEFT` with the
+   * `rejoin_attempt_limit_exceeded` leave message.
+   *
+   * Defaults: 10 attempts per 120 seconds (aligned with the Swift SDK).
+   * Both arguments are clamped to a minimum of 1.
+   */
+  setRejoinAttemptLimit = (maxAttempts: number, windowSeconds: number) => {
+    this.rejoinRateLimiter.setLimits(
+      Math.max(1, maxAttempts),
+      Math.max(1, windowSeconds) * 1000,
+    );
+  };
+
+  /**
+   * Configures how many peer-connection failures where ICE never reached
+   * `connected`/`completed` are tolerated before the SDK concludes that the
+   * current network cannot support WebRTC and transitions the call to
+   * `LEFT` with the `webrtc_unsupported_network` leave message.
+   *
+   * Default: 2. Clamped to a minimum of 1.
+   */
+  setMaxIceFailuresWithoutConnect = (n: number) => {
+    this.maxIceFailuresWithoutConnect = Math.max(1, n);
+  };
+
+  /**
+   * Configures how many consecutive SDP `NegotiationError`s are tolerated
+   * before the SDK stops retrying and transitions the call to `LEFT` with
+   * the `repeated_negotiation_failures` leave message.
+   *
+   * Default: 3. Clamped to a minimum of 1.
+   */
+  setMaxConsecutiveNegotiationFailures = (n: number) => {
+    this.maxConsecutiveNegotiationFailures = Math.max(1, n);
+  };
+
   /**
    * Enables the provided client capabilities.
    */