@stream-io/video-client 1.48.0 → 1.49.0

package/dist/index.browser.es.js

@@ -4006,8 +4006,6 @@ const retryable = async (rpc, signal, maxRetries = Number.POSITIVE_INFINITY) =>
     do {
         if (attempt > 0)
             await sleep(retryInterval(attempt));
-        if (signal?.aborted)
-            throw new Error(signal.reason);
         try {
             result = await rpc({ attempt });
         }
@@ -4405,6 +4403,21 @@ class Dispatcher {
     }
 }
 
+/**
+ * NegotiationError is thrown when there is an error during the negotiation process.
+ * It extends the built-in Error class and includes an SfuError object for more details.
+ */
+class NegotiationError extends Error {
+    /**
+     * Creates an instance of NegotiationError.
+     */
+    constructor(error) {
+        super(error.message);
+        this.name = 'NegotiationError';
+        this.error = error;
+    }
+}
+
 /**
  * A buffer for ICE Candidates. Used for ICE Trickle:
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
@@ -6222,21 +6235,6 @@ class CallState {
     }
 }
 
-/**
- * NegotiationError is thrown when there is an error during the negotiation process.
- * It extends the built-in Error class and includes an SfuError object for more details.
- */
-class NegotiationError extends Error {
-    /**
-     * Creates an instance of NegotiationError.
-     */
-    constructor(error) {
-        super(error.message);
-        this.name = 'NegotiationError';
-        this.error = error;
-    }
-}
-
 /**
  * Flatten the stats report into an array of stats objects.
  *
@@ -6284,7 +6282,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.48.0";
+const version = "1.49.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7306,6 +7304,30 @@ class Tracer {
     }
 }
 
+/**
+ * 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.
+ */
+const ReconnectReason = {
+    /** ICE never reached `connected`/`completed`, escalate to REJOIN. */
+    ICE_NEVER_CONNECTED: 'ice_never_connected',
+    /** RTCPeerConnection.connectionState became `failed`. */
+    CONNECTION_FAILED: 'connection_failed',
+    /** `restartIce()` rejected. */
+    RESTART_ICE_FAILED: 'restart_ice_failed',
+    /** SFU `goAway` event, migrate to a new SFU. */
+    GO_AWAY: 'go_away',
+    /** Network came back online after going offline. */
+    NETWORK_BACK_ONLINE: 'network_back_online',
+    /** SFU error event with no descriptive message. */
+    SFU_ERROR: 'sfu_error',
+};
+
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
  * @internal
@@ -7314,7 +7336,8 @@ class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, tag, enableTracing, clientPublishOptions, iceRestartDelay = 2500, }) {
+    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, tag, enableTracing, clientPublishOptions, iceRestartDelay = 2500, }) {
+        this.iceHasEverConnected = false;
         this.isIceRestarting = false;
         this.isDisposed = false;
         this.trackIdToTrackType = new Map();
@@ -7337,13 +7360,12 @@ class BasePeerConnection {
          */
         this.tryRestartIce = () => {
             this.restartIce().catch((e) => {
-                const reason = 'restartICE() failed, initiating reconnect';
-                this.logger.error(reason, e);
+                this.logger.error('restartICE() failed, initiating reconnect', e);
                 const strategy = e instanceof NegotiationError &&
                     e.error.code === ErrorCode.PARTICIPANT_SIGNAL_LOST
                     ? WebsocketReconnectStrategy.FAST
                     : WebsocketReconnectStrategy.REJOIN;
-                this.onReconnectionNeeded?.(strategy, reason, this.peerType);
+                this.onReconnectionNeeded?.(strategy, ReconnectReason.RESTART_ICE_FAILED, this.peerType);
             });
         };
         /**
@@ -7412,6 +7434,17 @@ class BasePeerConnection {
             const connectionState = this.pc.connectionState;
             return !failedStates.has(iceState) && !failedStates.has(connectionState);
         };
+        /**
+         * 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.
+         */
+        this.isStable = () => {
+            const iceState = this.pc.iceConnectionState;
+            const connectionState = this.pc.connectionState;
+            return ((iceState === 'connected' || iceState === 'completed') &&
+                connectionState === 'connected');
+        };
         /**
          * Handles the ICECandidate event and
          * Initiates an ICE Trickle process with the SFU.
@@ -7461,7 +7494,7 @@ class BasePeerConnection {
             }
             // we can't recover from a failed connection state (contrary to ICE)
             if (state === 'failed') {
-                this.onReconnectionNeeded?.(WebsocketReconnectStrategy.REJOIN, 'Connection failed', this.peerType);
+                this.onReconnectionNeeded?.(WebsocketReconnectStrategy.REJOIN, ReconnectReason.CONNECTION_FAILED, this.peerType);
                 return;
             }
             this.handleConnectionStateUpdate(state);
@@ -7483,6 +7516,41 @@ class BasePeerConnection {
             // do nothing when ICE is restarting
             if (this.isIceRestarting)
                 return;
+            // Pre-connect handling: ICE has never reached `connected`/`completed`.
+            // Restart is futile here (the data plane was never established), but
+            // these two terminal-ish states need different treatment:
+            // - `failed` is terminal, escalate to REJOIN so a new SFU/credentials
+            //   /PC configuration gets a chance, and let `Call.reconnect` count
+            //   this toward the unsupported-network budget.
+            // - `disconnected` is transient, the browser may yet move back to
+            //   `checking`/`connected`. Don't restart, don't escalate; wait it
+            //   out. If it ultimately fails, ICE will transition to `failed` and
+            //   the branch above will take over.
+            if (!this.iceHasEverConnected) {
+                if (state === 'failed') {
+                    this.logger.info('ICE failed before connected, escalating to REJOIN');
+                    clearTimeout(this.preConnectStuckTimeout);
+                    this.preConnectStuckTimeout = undefined;
+                    this.onReconnectionNeeded?.(WebsocketReconnectStrategy.REJOIN, ReconnectReason.ICE_NEVER_CONNECTED, this.peerType);
+                    return;
+                }
+                if (state === 'disconnected') {
+                    this.logger.info('ICE disconnected before connected, wait to recover');
+                    // Watchdog: if the browser stays in `disconnected` without ever
+                    // reaching `connected` or transitioning to `failed`, escalate to
+                    // REJOIN ourselves so we don't wait silently forever. Rare but
+                    // observed on flaky mobile networks.
+                    clearTimeout(this.preConnectStuckTimeout);
+                    this.preConnectStuckTimeout = setTimeout(() => {
+                        if (!this.iceHasEverConnected &&
+                            this.pc.iceConnectionState === 'disconnected') {
+                            this.logger.info('ICE stuck in pre-connect disconnected, escalating to REJOIN');
+                            this.onReconnectionNeeded?.(WebsocketReconnectStrategy.REJOIN, ReconnectReason.ICE_NEVER_CONNECTED, this.peerType);
+                        }
+                    }, this.iceRestartDelay * 2);
+                    return;
+                }
+            }
             switch (state) {
                 case 'failed':
                     // in the `failed` state, we try to restart ICE immediately
@@ -7502,12 +7570,24 @@ class BasePeerConnection {
                     }, this.iceRestartDelay);
                     break;
                 case 'connected':
-                    // in the `connected` state, we clear the ice restart timeout if it exists
+                case 'completed':
+                    // Fire `onIceConnected` exactly once per peer-connection lifetime —
+                    // the first time ICE reaches `connected`/`completed` end-to-end.
+                    // Used by `Call` to reset the unsupported-network failure counter
+                    // only after WebRTC has actually recovered, not merely on SFU join.
+                    if (!this.iceHasEverConnected) {
+                        this.iceHasEverConnected = true;
+                        this.onIceConnected?.(this.peerType);
+                    }
+                    // clear any scheduled restartICE since the connection is healthy
                     if (this.iceRestartTimeout) {
                         this.logger.info('connected connection, canceling restartICE');
                         clearTimeout(this.iceRestartTimeout);
                         this.iceRestartTimeout = undefined;
                     }
+                    // clear the pre-connect watchdog if it was armed
+                    clearTimeout(this.preConnectStuckTimeout);
+                    this.preConnectStuckTimeout = undefined;
                     break;
             }
         };
@@ -7540,6 +7620,7 @@ class BasePeerConnection {
         this.clientPublishOptions = clientPublishOptions;
         this.tag = tag;
         this.onReconnectionNeeded = onReconnectionNeeded;
+        this.onIceConnected = onIceConnected;
         this.logger = videoLoggerSystem.getLogger(peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher', { tags: [tag] });
         this.pc = this.createPeerConnection(connectionConfig);
         this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
@@ -7558,7 +7639,10 @@ class BasePeerConnection {
     dispose() {
         clearTimeout(this.iceRestartTimeout);
         this.iceRestartTimeout = undefined;
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = undefined;
         this.onReconnectionNeeded = undefined;
+        this.onIceConnected = undefined;
         this.isDisposed = true;
         this.detachEventHandlers();
         this.pc.close();
@@ -8212,7 +8296,8 @@ class Publisher extends BasePeerConnection {
             const trackInfos = [];
             for (const publishOption of this.publishOptions) {
                 const bundle = this.transceiverCache.get(publishOption);
-                if (!bundle || !bundle.transceiver.sender.track)
+                const track = bundle?.transceiver.sender.track;
+                if (!bundle || !track || track.readyState !== 'live')
                     continue;
                 trackInfos.push(this.toTrackInfo(bundle, sdp));
             }
@@ -8557,6 +8642,20 @@ class SfuJoinError extends Error {
     }
 }
 
+/**
+ * Creates a fresh `joinResponseTask` with a no-op rejection handler attached
+ * to the underlying promise. The handler marks the rejection path as handled
+ * so a teardown-time reject (e.g., from `close()` during disposal) does not
+ * surface as an `UnhandledPromiseRejection`. Explicit awaiters of
+ * `StreamSfuClient.joinTask` still observe the rejection through their own
+ * `then`/`catch` chain. `.catch()` returns a new promise; the original is
+ * unchanged.
+ */
+const makeJoinResponseTask = () => {
+    const task = promiseWithResolvers();
+    task.promise.catch(() => { }); // see the comment above
+    return task;
+};
 /**
  * The client used for exchanging information with the SFU.
  */
@@ -8588,9 +8687,10 @@ class StreamSfuClient {
         this.subscriptionsConcurrencyTag = Symbol('subscriptionsConcurrencyTag');
         /**
          * 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.
          */
-        this.joinResponseTask = promiseWithResolvers();
+        this.joinResponseTask = makeJoinResponseTask();
         /**
          * A controller to abort the current requests.
          */
@@ -8660,14 +8760,21 @@ class StreamSfuClient {
         };
         this.close = (code = StreamSfuClient.NORMAL_CLOSURE, reason) => {
             this.isClosingClean = code !== StreamSfuClient.ERROR_CONNECTION_UNHEALTHY;
-            if (this.signalWs.readyState === WebSocket.OPEN) {
+            // Close the WebSocket whether it has fully opened (`OPEN`) or is still
+            // mid-handshake (`CONNECTING`). The WebSocket spec aborts the handshake
+            // when `close()` is called on a CONNECTING socket. Without this, an
+            // SFU socket that opens just after teardown would dispatch events into
+            // a Call instance that has already moved on.
+            const ws = this.signalWs;
+            if (ws.readyState === WebSocket.OPEN ||
+                ws.readyState === WebSocket.CONNECTING) {
                 this.logger.debug(`Closing SFU WS connection: ${code} - ${reason}`);
-                this.signalWs.close(code, `js-client: ${reason}`);
-                this.signalWs.removeEventListener('close', this.handleWebSocketClose);
+                ws.close(code, `js-client: ${reason}`);
+                ws.removeEventListener('close', this.handleWebSocketClose);
             }
-            this.dispose();
+            this.dispose(reason);
         };
-        this.dispose = () => {
+        this.dispose = (reason) => {
             this.logger.debug('Disposing SFU client');
             this.unsubscribeIceTrickle();
             this.unsubscribeNetworkChanged();
@@ -8676,6 +8783,13 @@ class StreamSfuClient {
             clearTimeout(this.migrateAwayTimeout);
             this.abortController.abort();
             this.migrationTask?.resolve();
+            // Settle a pending `joinResponseTask` so `leaveAndClose`, `join()`, and
+            // any other awaiters (`await this.joinTask`) don't hang indefinitely
+            // when the SFU client is torn down before the SFU sent a JoinResponse.
+            if (!this.joinResponseTask.isResolved() &&
+                !this.joinResponseTask.isRejected()) {
+                this.joinResponseTask.reject(new Error(`SFU client disposed before join completed${reason ? `: ${reason}` : ''}`));
+            }
             this.iceTrickleBuffer.dispose();
         };
         this.getTrace = () => {
@@ -8684,8 +8798,24 @@ class StreamSfuClient {
         this.leaveAndClose = async (reason) => {
             try {
                 this.isLeaving = true;
-                await this.joinTask;
-                await this.notifyLeave(reason);
+                // Best-effort: give an in-flight join a short grace period to complete
+                // so we can send a graceful `leaveCallRequest`. Bounded so we never hang
+                // here if the SFU is unresponsive. If the task settles either way during
+                // the wait, the re-check below decides whether to notify.
+                if (!this.joinResponseTask.isResolved() &&
+                    !this.joinResponseTask.isRejected()) {
+                    await Promise.race([
+                        // swallow rejection — we re-check `isResolved()` below to decide
+                        this.joinResponseTask.promise.catch(() => { }),
+                        sleep(StreamSfuClient.LEAVE_NOTIFY_GRACE_MS),
+                    ]);
+                }
+                if (this.joinResponseTask.isResolved()) {
+                    await this.notifyLeave(reason);
+                }
+                else {
+                    this.logger.debug('[leaveAndClose] join not completed within grace period, skipping notifyLeave');
+                }
             }
             catch (err) {
                 this.logger.debug('Error notifying SFU about leaving call', err);
@@ -8754,9 +8884,9 @@ class StreamSfuClient {
                 this.joinResponseTask.isRejected()) {
                 // we need to lock the RPC requests until we receive a JoinResponse.
                 // that's why we have this primitive lock mechanism.
-                // the client starts with already initialized joinResponseTask,
+                // the client starts with an already initialized joinResponseTask,
                 // and this code creates a new one for the next join request.
-                this.joinResponseTask = promiseWithResolvers();
+                this.joinResponseTask = makeJoinResponseTask();
             }
             // capture a reference to the current joinResponseTask as it might
             // be replaced with a new one in case a second join request is made
@@ -8929,6 +9059,12 @@ StreamSfuClient.DISPOSE_OLD_SOCKET = 4100;
  * The close code used when the client fails to join the call (on the SFU).
  */
 StreamSfuClient.JOIN_FAILED = 4101;
+/**
+ * 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.
+ */
+StreamSfuClient.LEAVE_NOTIFY_GRACE_MS = 1000;
 
 /**
  * Event handler that watched the delivery of `call.accepted`.
@@ -10324,6 +10460,50 @@ const CallTypes = new CallTypesRegistry([
     }),
 ]);
 
+/**
+ * A generic sliding-window rate limiter.
+ *
+ * Allows at most `maxAttempts` registrations inside a rolling `windowMs`.
+ * Attempts spaced further apart than `windowMs` are always allowed.
+ */
+class SlidingWindowRateLimiter {
+    constructor(maxAttempts, windowMs) {
+        this.timestamps = [];
+        /**
+         * 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).
+         */
+        this.tryRegister = (now = Date.now()) => {
+            this.prune(now);
+            if (this.timestamps.length >= this.maxAttempts)
+                return false;
+            this.timestamps.push(now);
+            return true;
+        };
+        /**
+         * Clears the attempt history.
+         */
+        this.reset = () => {
+            this.timestamps = [];
+        };
+        /**
+         * Updates the budget and window size. Existing timestamps are kept; they
+         * will be pruned by the next `tryRegister` call.
+         */
+        this.setLimits = (maxAttempts, windowMs) => {
+            this.maxAttempts = maxAttempts;
+            this.windowMs = windowMs;
+        };
+        this.prune = (now) => {
+            const cutoff = now - this.windowMs;
+            this.timestamps = this.timestamps.filter((t) => t >= cutoff);
+        };
+        this.maxAttempts = maxAttempts;
+        this.windowMs = windowMs;
+    }
+}
+
 /**
  * Deactivates MediaStream (stops and removes tracks) to be later garbage collected
  *
@@ -10705,7 +10885,6 @@ const getScreenShareStream = async (options, tracer) => {
     const tag = `navigator.mediaDevices.getDisplayMedia.${getDisplayMediaExecId++}.`;
     try {
         const constraints = {
-            // @ts-expect-error - not present in types yet
             systemAudio: 'include',
             ...options,
             video: typeof options?.video === 'boolean'
@@ -10720,6 +10899,8 @@ const getScreenShareStream = async (options, tracer) => {
                 ? options.audio
                 : {
                     channelCount: { ideal: 2 },
+                    // @ts-expect-error not yet present in the types
+                    restrictOwnAudio: true,
                     echoCancellation: false,
                     autoGainControl: false,
                     noiseSuppression: false,
@@ -11364,6 +11545,7 @@ class DeviceManagerState {
         this.statusSubject = new BehaviorSubject(undefined);
         this.optimisticStatusSubject = new BehaviorSubject(undefined);
         this.mediaStreamSubject = new BehaviorSubject(undefined);
+        this.rootMediaStreamSubject = new BehaviorSubject(undefined);
         this.selectedDeviceSubject = new BehaviorSubject(undefined);
         this.defaultConstraintsSubject = new BehaviorSubject(undefined);
         /**
@@ -11371,6 +11553,12 @@ class DeviceManagerState {
          *
          */
         this.mediaStream$ = this.mediaStreamSubject.asObservable();
+        /**
+         * 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$`.
+         */
+        this.rootMediaStream$ = this.rootMediaStreamSubject.asObservable();
         /**
          * An Observable that emits the currently selected device
          */
@@ -11426,6 +11614,14 @@ class DeviceManagerState {
     get mediaStream() {
         return getCurrentValue(this.mediaStream$);
     }
+    /**
+     * 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() {
+        return getCurrentValue(this.rootMediaStream$);
+    }
     /**
      * @internal
      * @param status
@@ -11450,6 +11646,7 @@ class DeviceManagerState {
      */
     setMediaStream(stream, rootStream) {
         setCurrentValue(this.mediaStreamSubject, stream);
+        setCurrentValue(this.rootMediaStreamSubject, rootStream);
         if (rootStream) {
             this.setDevice(this.getDeviceIdFromStream(rootStream));
         }
@@ -12701,6 +12898,16 @@ class Call {
         this.fastReconnectDeadlineSeconds = 0;
         this.disconnectionTimeoutSeconds = 0;
         this.lastOfflineTimestamp = 0;
+        // (10 attempts per rolling 120 s window).
+        this.rejoinRateLimiter = new SlidingWindowRateLimiter(10, 120000);
+        // "Network doesn't support WebRTC" detector: counts peer-connection
+        // failures where ICE never reached `connected`/`completed`.
+        this.maxIceFailuresWithoutConnect = 2;
+        this.iceFailuresWithoutConnect = 0;
+        // Consecutive-negotiation-failure detector: stops the reconnect loop when
+        // the SFU keeps failing to negotiate SDP for us.
+        this.maxConsecutiveNegotiationFailures = 3;
+        this.consecutiveNegotiationFailures = 0;
         // maintain the order of publishing tracks to restore them after a reconnection
         // it shouldn't contain duplicates
         this.trackPublishOrder = [];
@@ -13003,6 +13210,19 @@ class Call {
                 this.state.setCallingState(CallingState.LEFT);
                 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;
@@ -13353,9 +13573,20 @@ 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);
@@ -13398,6 +13629,15 @@ 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}`);
         };
         /**
@@ -13515,6 +13755,12 @@ 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);
             // anonymous users can't publish anything hence, there is no need
@@ -13620,7 +13866,9 @@ 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).
          */
         this.reconnect = async (strategy, reason) => {
             if (this.state.callingState === CallingState.RECONNECTING ||
@@ -13641,6 +13889,30 @@ class Call {
                         this.state.setCallingState(CallingState.RECONNECTING_FAILED);
                     }
                 };
+                const giveUpAndLeave = async (message) => {
+                    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;
@@ -13651,6 +13923,16 @@ class Call {
                         await markAsReconnectingFailed();
                         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++;
@@ -13678,6 +13960,8 @@ class Call {
                                 ensureExhausted(this.reconnectStrategy, 'Unknown reconnection strategy');
                                 break;
                         }
+                        // reconnection worked — reset the negotiation-failure streak.
+                        this.consecutiveNegotiationFailures = 0;
                         break; // do-while loop, reconnection worked, exit the loop
                     }
                     catch (error) {
@@ -13692,7 +13976,16 @@ class Call {
                             await markAsReconnectingFailed();
                             return;
                         }
-                        await sleep(500);
+                        if (error instanceof NegotiationError) {
+                            this.consecutiveNegotiationFailures++;
+                            if (this.consecutiveNegotiationFailures >=
+                                this.maxConsecutiveNegotiationFailures) {
+                                await giveUpAndLeave('repeated_negotiation_failures');
+                                return;
+                            }
+                        }
+                        // exponential backoff with jitter, capped at 5 s
+                        await sleep(retryInterval(attempt));
                         const wasMigrating = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
                         const mustPerformRejoin = (Date.now() - reconnectStartTime) / 1000 >
                             this.fastReconnectDeadlineSeconds;
@@ -13801,7 +14094,7 @@ class Call {
         this.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
             const unregisterOnError = this.on('error', (e) => {
@@ -13820,7 +14113,7 @@ class Call {
                     });
                 }
                 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);
                     });
                 }
@@ -13844,7 +14137,7 @@ class Call {
                                 strategy = WebsocketReconnectStrategy.REJOIN;
                             }
                         }
-                        this.reconnect(strategy, 'Going online').catch((err) => {
+                        this.reconnect(strategy, ReconnectReason.NETWORK_BACK_ONLINE).catch((err) => {
                             this.logger.warn('[Reconnect] Error reconnecting after going online', err);
                         });
                     });
@@ -13987,10 +14280,12 @@ class Call {
          * @param trackTypes the track types to update the call state with.
          */
         this.updateLocalStreamState = async (mediaStream, ...trackTypes) => {
-            if (!this.sfuClient || !this.sfuClient.sessionId)
+            const sessionId = this.sfuClient?.sessionId;
+            if (!sessionId)
                 return;
             await this.notifyTrackMuteState(!mediaStream, ...trackTypes);
-            const { sessionId } = this.sfuClient;
+            if (this.sfuClient?.sessionId !== sessionId)
+                return;
             for (const trackType of trackTypes) {
                 const streamStateProp = trackTypeToParticipantStreamKey(trackType);
                 if (!streamStateProp)
@@ -14786,6 +15081,39 @@ class Call {
         this.setDisconnectionTimeout = (timeoutSeconds) => {
             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.
+         */
+        this.setRejoinAttemptLimit = (maxAttempts, windowSeconds) => {
+            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.
+         */
+        this.setMaxIceFailuresWithoutConnect = (n) => {
+            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.
+         */
+        this.setMaxConsecutiveNegotiationFailures = (n) => {
+            this.maxConsecutiveNegotiationFailures = Math.max(1, n);
+        };
         /**
          * Enables the provided client capabilities.
          */
@@ -15968,7 +16296,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.48.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.49.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),