@stream-io/video-client 1.61.1 → 1.62.0

package/dist/index.cjs.js

@@ -2685,18 +2685,6 @@ class SendStatsRequest$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.signal.SendStatsRequest', [
             { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
-            {
-                no: 2,
-                name: 'subscriber_stats',
-                kind: 'scalar',
-                T: 9 /*ScalarType.STRING*/,
-            },
-            {
-                no: 3,
-                name: 'publisher_stats',
-                kind: 'scalar',
-                T: 9 /*ScalarType.STRING*/,
-            },
             {
                 no: 4,
                 name: 'webrtc_version',
@@ -2710,8 +2698,6 @@ class SendStatsRequest$Type extends runtime.MessageType {
                 kind: 'scalar',
                 T: 9 /*ScalarType.STRING*/,
             },
-            { no: 7, name: 'audio_devices', kind: 'message', T: () => InputDevices },
-            { no: 8, name: 'video_devices', kind: 'message', T: () => InputDevices },
             {
                 no: 9,
                 name: 'android',
@@ -2728,18 +2714,6 @@ class SendStatsRequest$Type extends runtime.MessageType {
             },
             { no: 11, name: 'telemetry', kind: 'message', T: () => Telemetry },
             { no: 12, name: 'rtmp', kind: 'message', T: () => RTMPIngress },
-            {
-                no: 13,
-                name: 'subscriber_rtc_stats',
-                kind: 'scalar',
-                T: 9 /*ScalarType.STRING*/,
-            },
-            {
-                no: 14,
-                name: 'publisher_rtc_stats',
-                kind: 'scalar',
-                T: 9 /*ScalarType.STRING*/,
-            },
             { no: 15, name: 'rtc_stats', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
             {
                 no: 16,
@@ -5101,7 +5075,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "1.61.1";
+const version = "1.62.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7829,30 +7803,21 @@ class SfuStatsReporter {
     sfuClient;
     subscriber;
     publisher;
-    microphone;
-    camera;
-    state;
     tracer;
     unifiedSessionId;
     intervalId;
     timeoutId;
     reportCount = 0;
-    unsubscribeDevicePermissionsSubscription;
-    unsubscribeListDevicesSubscription;
     sdkName;
     sdkVersion;
     webRTCVersion;
-    inputDevices = new Map();
     statsConcurrencyTag = Symbol('sfuStatsReporter');
     isStopped = false;
-    constructor(sfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }) {
+    constructor(sfuClient, { options, clientDetails, subscriber, publisher, tracer, unifiedSessionId, }) {
         this.sfuClient = sfuClient;
         this.options = options;
         this.subscriber = subscriber;
         this.publisher = publisher;
-        this.microphone = microphone;
-        this.camera = camera;
-        this.state = state;
         this.tracer = tracer;
         this.unifiedSessionId = unifiedSessionId;
         const { sdk, browser } = clientDetails;
@@ -7866,35 +7831,6 @@ class SfuStatsReporter {
                 `${browser?.name || ''}-${browser?.version || ''}` ||
                 'N/A';
     }
-    observeDevice = (device, kind) => {
-        const { browserPermissionState$ } = device.state;
-        this.unsubscribeDevicePermissionsSubscription?.();
-        this.unsubscribeDevicePermissionsSubscription = createSubscription(rxjs.combineLatest([browserPermissionState$, this.state.ownCapabilities$]), ([browserPermissionState, ownCapabilities]) => {
-            // cleanup the previous listDevices() subscription in case
-            // permissions or capabilities have changed.
-            // we will subscribe again if everything is in order.
-            this.unsubscribeListDevicesSubscription?.();
-            const hasCapability = kind === 'mic'
-                ? ownCapabilities.includes(OwnCapability.SEND_AUDIO)
-                : ownCapabilities.includes(OwnCapability.SEND_VIDEO);
-            if (browserPermissionState !== 'granted' || !hasCapability) {
-                this.inputDevices.set(kind, {
-                    currentDevice: '',
-                    availableDevices: [],
-                    isPermitted: false,
-                });
-                return;
-            }
-            this.unsubscribeListDevicesSubscription = createSubscription(rxjs.combineLatest([device.listDevices(), device.state.selectedDevice$]), ([devices, deviceId]) => {
-                const selected = devices.find((d) => d.deviceId === deviceId);
-                this.inputDevices.set(kind, {
-                    currentDevice: selected?.label || deviceId || '',
-                    availableDevices: devices.map((d) => d.label),
-                    isPermitted: true,
-                });
-            });
-        });
-    };
     sendConnectionTime = (connectionTimeSeconds) => {
         this.sendTelemetryData({
             data: {
@@ -7929,7 +7865,7 @@ class SfuStatsReporter {
         this.subscriber.stats.takeSample(),
         this.publisher?.stats.takeSample(),
     ]);
-    send = (subscriberStats, publisherStats, telemetry) => {
+    send = (subscriberPerfStats, publisherPerfStats, telemetry) => {
         // serialize sends so overlapping ones can't race on the trace buffers or
         // deliver an older delta after a newer one already succeeded. Not gated by
         // `isStopped`: an explicit final flush must still deliver after stop().
@@ -7947,8 +7883,8 @@ class SfuStatsReporter {
                 this.subscriber.stats.clearPendingDeltas();
             }
             let pubPending = [];
-            if (pubTracer && publisherStats) {
-                pubPending = this.publisher?.stats.getPendingDeltas() ?? [];
+            if (pubTracer && this.publisher) {
+                pubPending = this.publisher.stats.getPendingDeltas();
             }
             else {
                 this.publisher?.stats.clearPendingDeltas();
@@ -7970,17 +7906,9 @@ class SfuStatsReporter {
                     sdk: this.sdkName,
                     sdkVersion: this.sdkVersion,
                     webrtcVersion: this.webRTCVersion,
-                    subscriberStats: JSON.stringify(flatten(subscriberStats.stats)),
-                    publisherStats: publisherStats
-                        ? JSON.stringify(flatten(publisherStats.stats))
-                        : '[]',
-                    subscriberRtcStats: '',
-                    publisherRtcStats: '',
                     rtcStats: JSON.stringify(traces),
-                    encodeStats: publisherStats?.performanceStats ?? [],
-                    decodeStats: subscriberStats.performanceStats,
-                    audioDevices: this.inputDevices.get('mic'),
-                    videoDevices: this.inputDevices.get('camera'),
+                    encodeStats: publisherPerfStats ?? [],
+                    decodeStats: subscriberPerfStats,
                     unifiedSessionId: this.unifiedSessionId,
                     deviceState: getDeviceState(),
                     telemetry,
@@ -7994,8 +7922,8 @@ class SfuStatsReporter {
                 // delivery confirmed: advance the delivery baseline for each chain.
                 if (subTracer)
                     this.subscriber.stats.commitDeltas(subPending);
-                if (pubTracer && publisherStats) {
-                    this.publisher?.stats.commitDeltas(pubPending);
+                if (pubTracer && this.publisher) {
+                    this.publisher.stats.commitDeltas(pubPending);
                 }
             }
             catch (err) {
@@ -8017,8 +7945,8 @@ class SfuStatsReporter {
     run = async (telemetry) => {
         if (this.isStopped)
             return;
-        const [subscriberStats, publisherStats] = await this.sample();
-        await this.send(subscriberStats, publisherStats, telemetry);
+        const [subscriberPerfStats, publisherPerfStats] = await this.sample();
+        await this.send(subscriberPerfStats, publisherPerfStats, telemetry);
     };
     scheduleNextReport = () => {
         const intervals = [1500, 3000, 3000, 5000];
@@ -8039,8 +7967,6 @@ class SfuStatsReporter {
     start = () => {
         if (this.options.reporting_interval_ms <= 0)
             return;
-        this.observeDevice(this.microphone, 'mic');
-        this.observeDevice(this.camera, 'camera');
         this.isStopped = false;
         this.reportCount = 0;
         clearInterval(this.intervalId);
@@ -8049,11 +7975,6 @@ class SfuStatsReporter {
     };
     stop = () => {
         this.isStopped = true;
-        this.unsubscribeDevicePermissionsSubscription?.();
-        this.unsubscribeDevicePermissionsSubscription = undefined;
-        this.unsubscribeListDevicesSubscription?.();
-        this.unsubscribeListDevicesSubscription = undefined;
-        this.inputDevices.clear();
         clearInterval(this.intervalId);
         this.intervalId = undefined;
         clearTimeout(this.timeoutId);
@@ -8074,8 +7995,8 @@ class SfuStatsReporter {
             return;
         try {
             const [sample] = await timeboxed([this.sample()], 2000);
-            const [subscriberStats, publisherStats] = sample;
-            this.send(subscriberStats, publisherStats).catch((err) => {
+            const [subscriberPerfStats, publisherPerfStats] = sample;
+            this.send(subscriberPerfStats, publisherPerfStats).catch((err) => {
                 this.logger.warn('Failed to flush report stats', err);
             });
         }
@@ -8202,9 +8123,9 @@ class StatsTracer {
         this.maxPendingDeltas = maxPendingDeltas;
     }
     /**
-     * Samples the RTCPeerConnection: returns the current stats report and the
-     * derived performance stats, and appends the delta-compressed sample to the
-     * un-acked delivery chain (retrieved via `getPendingDeltas`).
+     * Samples the RTCPeerConnection: returns the derived performance stats and
+     * appends the delta-compressed sample to the un-acked delivery chain
+     * (retrieved via `getPendingDeltas`).
      *
      * @internal
      */
@@ -8229,7 +8150,7 @@ class StatsTracer {
             this.pendingDeltas.push({ delta, ts: now });
             this.frameTimeHistory = this.frameTimeHistory.slice(-2);
             this.fpsHistory = this.fpsHistory.slice(-2);
-            return { performanceStats, stats };
+            return performanceStats;
         });
     };
     /**
@@ -8549,10 +8470,12 @@ class BasePeerConnection {
     sfuClient;
     onReconnectionNeeded;
     onIceConnected;
+    onNoLocalCandidates;
     onPeerConnectionStateChange;
     onRemoteTrackUnmute;
     iceRestartDelay;
     iceHasEverConnected = false;
+    localCandidatesGathered = 0;
     iceRestartTimeout;
     preConnectStuckTimeout;
     isIceRestarting = false;
@@ -8566,7 +8489,7 @@ class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay = 2500, statsTimestampDriftThresholdMs = 0, }) {
+    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onNoLocalCandidates, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay = 2500, statsTimestampDriftThresholdMs = 0, }) {
         this.peerType = peerType;
         this.sfuClient = sfuClient;
         this.state = state;
@@ -8577,6 +8500,7 @@ class BasePeerConnection {
         this.tag = tag;
         this.onReconnectionNeeded = onReconnectionNeeded;
         this.onIceConnected = onIceConnected;
+        this.onNoLocalCandidates = onNoLocalCandidates;
         this.onPeerConnectionStateChange = onPeerConnectionStateChange;
         this.onRemoteTrackUnmute = onRemoteTrackUnmute;
         this.logger = videoLoggerSystem.getLogger(peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher', { tags: [tag] });
@@ -8617,6 +8541,7 @@ class BasePeerConnection {
         this.preConnectStuckTimeout = undefined;
         this.onReconnectionNeeded = undefined;
         this.onIceConnected = undefined;
+        this.onNoLocalCandidates = undefined;
         this.onPeerConnectionStateChange = undefined;
         this.onRemoteTrackUnmute = undefined;
         this.isDisposed = true;
@@ -8720,6 +8645,17 @@ class BasePeerConnection {
     getTrackType = (trackId) => {
         return this.trackIdToTrackType.get(trackId);
     };
+    /**
+     * Returns `true` once ICE has reached `connected`/`completed` at least
+     * once during the lifetime of this peer connection.
+     */
+    hasIceEverConnected = () => this.iceHasEverConnected;
+    /**
+     * Returns `true` when the latest ICE gathering round completed without
+     * producing a single local candidate.
+     */
+    hasNoLocalCandidates = () => this.pc.iceGatheringState === 'complete' &&
+        this.localCandidatesGathered === 0;
     /**
      * Checks if the `RTCPeerConnection` is healthy.
      * It checks the ICE connection state and the peer connection state.
@@ -8742,6 +8678,8 @@ class BasePeerConnection {
             this.logger.debug('null ice candidate');
             return;
         }
+        if (candidate.candidate)
+            this.localCandidatesGathered++;
         const iceCandidate = toJSON(candidate);
         this.sfuClient
             .iceTrickle({ peerType: this.peerType, iceCandidate })
@@ -8806,6 +8744,17 @@ class BasePeerConnection {
         }
     };
     handleConnectionStateUpdate = (state) => {
+        // Fire `onIceConnected` exactly once per peer-connection lifetime, the
+        // first time ICE reaches `connected`/`completed` end-to-end. Recorded
+        // ahead of the guards below so a connection established while offline,
+        // reconnecting or restarting ICE is not missed. Used by `Call` to reset
+        // the unsupported-network failure counter only after WebRTC has actually
+        // recovered, not merely on SFU join.
+        if ((state === 'connected' || state === 'completed') &&
+            !this.iceHasEverConnected) {
+            this.iceHasEverConnected = true;
+            this.onIceConnected?.(this.peerType);
+        }
         const { callingState } = this.state;
         if (callingState === exports.CallingState.OFFLINE)
             return;
@@ -8869,14 +8818,6 @@ class BasePeerConnection {
                 break;
             case 'connected':
             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');
@@ -8902,7 +8843,17 @@ class BasePeerConnection {
      * Handles the ICE gathering state change event.
      */
     onIceGatherChange = () => {
-        this.logger.debug(`ICE Gathering State`, this.pc.iceGatheringState);
+        const state = this.pc.iceGatheringState;
+        this.logger.debug(`ICE Gathering State`, state);
+        if (state === 'gathering') {
+            this.localCandidatesGathered = 0;
+        }
+        else if (state === 'complete' &&
+            this.localCandidatesGathered === 0 &&
+            !this.iceHasEverConnected) {
+            this.logger.info('ICE gathering completed without local candidates');
+            this.onNoLocalCandidates?.(this.peerType);
+        }
     };
     /**
      * Handles the signaling state change event.
@@ -10778,15 +10729,16 @@ class StreamSfuClient {
 /**
  * Decides what a ringing call should do next, based on the current call state.
  *
- * The `call.accepted`, `call.rejected` and `call.missed` handlers and the ring
- * state poller both run this. They differ only in how the state got there: the
- * handlers rely on `CallState.updateFromEvent`, which runs before them, and the
- * poller applies the polled ring state itself.
+ * The `call.accepted` and `call.rejected` handlers, the ring state poller and
+ * the rewatch after a WS reconnect all run this. They differ only in how the
+ * state got there: the handlers rely on `CallState.updateFromEvent`, which runs
+ * before them, while the poller applies the polled ring state itself and the
+ * rewatch applies the queried call state.
  *
  * @param call the call to reconcile.
- * @param joinSource which of the two triggered this run, reported on the
- * caller's join: `ring-ws` for the event handlers, `ring-poll-api` for the
- * poller.
+ * @param joinSource what triggered this run, reported on the caller's join:
+ * `ring-ws` for the event handlers, `ring-poll-api` for the poller and the
+ * rewatch (both come from an API response).
  * @returns whether the ring reached a terminal state. A failed join is not
  * terminal: the caller should keep trying while the ring is open.
  */
@@ -10841,10 +10793,16 @@ const reconcileAsCaller = async (call, joinSource) => {
     return false;
 };
 // the current user's own accept or reject, on this or another device, is
-// handled by `resolveOwnRingOutcome`, and `call.ended` by `watchCallEnded`.
+// handled by `resolveOwnRingOutcome`, and a live `call.ended` by
+// `watchCallEnded`. An end missed while offline is handled here.
 const reconcileAsCallee = async (call) => {
-    const createdById = call.state.createdBy?.id;
-    const rejectedBy = call.state.session?.rejected_by ?? {};
+    const { session, endedAt, createdBy } = call.state;
+    if (endedAt || session?.ended_at) {
+        call.logger.info('ring: the call has ended, leaving');
+        return leave(call, { reason: 'ended', message: 'ring: call ended' });
+    }
+    const createdById = createdBy?.id;
+    const rejectedBy = session?.rejected_by ?? {};
     if (createdById && rejectedBy[createdById]) {
         call.logger.info('ring: the caller cancelled, leaving');
         return leave(call, {
@@ -10893,7 +10851,7 @@ class RingStatePoller {
     unsubscribe = [];
     constructor(call, options = {}) {
         this.call = call;
-        this.startAfterMs = options.startAfterMs ?? 15_000;
+        this.startAfterMs = options.startAfterMs ?? 9_000;
         this.intervalMs = options.intervalMs ?? 5_000;
     }
     /**
@@ -11558,12 +11516,33 @@ const registerRingingCallEventHandlers = (call) => {
 };
 
 const toBindingKey = (sessionId, trackType = 'audioTrack') => `${sessionId}/${trackType}`;
+const toElementState = (element) => {
+    const stream = element.srcObject;
+    const [track] = stream?.getAudioTracks?.() ?? [];
+    return {
+        paused: element.paused,
+        muted: element.muted,
+        volume: Math.round(element.volume * 100) / 100,
+        readyState: element.readyState,
+        sinkId: element.sinkId,
+        track: track
+            ? {
+                enabled: track.enabled,
+                muted: track.muted,
+                readyState: track.readyState,
+            }
+            : null,
+    };
+};
 /**
  * Tracks audio element bindings and periodically warns about
  * remote participants whose audio streams have no bound element.
+ * On the same tick, it traces the playback state of the bound elements,
+ * limited to the bindings whose state changed since the previous trace.
  */
 class AudioBindingsWatchdog {
     bindings = new Map();
+    tracedStates = new Map();
     enabled = true;
     watchdogInterval;
     unsubscribeCallingState;
@@ -11574,8 +11553,6 @@ class AudioBindingsWatchdog {
         this.tracer = tracer;
         this.state = state;
         this.unsubscribeCallingState = createSubscription(state.callingState$, (callingState) => {
-            if (!this.enabled)
-                return;
             if (callingState !== exports.CallingState.JOINED) {
                 this.stop();
             }
@@ -11604,15 +11581,15 @@ class AudioBindingsWatchdog {
         this.bindings.delete(toBindingKey(sessionId, trackType));
     };
     /**
-     * Enables or disables the watchdog.
-     * When disabled, the periodic check stops but bindings are still tracked.
+     * Enables or disables the dangling binding warnings.
+     * Bindings are still tracked and their playback state is still traced.
      */
     setEnabled = (enabled) => {
         this.enabled = enabled;
         if (enabled) {
             this.start();
         }
-        else {
+        else if (this.state.callingState !== exports.CallingState.JOINED) {
             this.stop();
         }
     };
@@ -11622,33 +11599,61 @@ class AudioBindingsWatchdog {
     dispose = () => {
         this.stop();
         this.bindings.clear();
+        this.tracedStates.clear();
         this.unsubscribeCallingState();
     };
     start = () => {
         clearInterval(this.watchdogInterval);
         this.watchdogInterval = setInterval(() => {
-            const danglingUserIds = [];
-            for (const p of this.state.participants) {
-                if (p.isLocalParticipant)
-                    continue;
-                const { audioStream, screenShareAudioStream, sessionId, userId, publishedTracks, } = p;
-                if (audioStream &&
-                    publishedTracks.includes(TrackType.AUDIO) &&
-                    !this.bindings.has(toBindingKey(sessionId))) {
-                    danglingUserIds.push(userId);
-                }
-                if (screenShareAudioStream &&
-                    publishedTracks.includes(TrackType.SCREEN_SHARE_AUDIO) &&
-                    !this.bindings.has(toBindingKey(sessionId, 'screenShareAudioTrack'))) {
-                    danglingUserIds.push(userId);
-                }
+            if (this.enabled)
+                this.warnAboutDanglingBindings();
+            this.traceBindingStates();
+        }, 3000);
+    };
+    warnAboutDanglingBindings = () => {
+        const danglingUserIds = [];
+        for (const p of this.state.participants) {
+            if (p.isLocalParticipant)
+                continue;
+            const { audioStream, screenShareAudioStream, sessionId, userId, publishedTracks, } = p;
+            if (audioStream &&
+                publishedTracks.includes(TrackType.AUDIO) &&
+                !this.bindings.has(toBindingKey(sessionId))) {
+                danglingUserIds.push(userId);
             }
-            if (danglingUserIds.length > 0) {
-                const key = 'audioBinding.danglingWarning';
-                this.tracer.traceOnce(key, key, danglingUserIds);
-                this.logger.warn(`Dangling audio bindings detected. Did you forget to bind the audio element? user_ids: ${danglingUserIds}.`);
+            if (screenShareAudioStream &&
+                publishedTracks.includes(TrackType.SCREEN_SHARE_AUDIO) &&
+                !this.bindings.has(toBindingKey(sessionId, 'screenShareAudioTrack'))) {
+                danglingUserIds.push(userId);
             }
-        }, 3000);
+        }
+        if (danglingUserIds.length > 0) {
+            const key = 'audioBinding.danglingWarning';
+            this.tracer.traceOnce(key, key, danglingUserIds);
+            this.logger.warn(`Dangling audio bindings detected. Did you forget to bind the audio element? user_ids: ${danglingUserIds}.`);
+        }
+    };
+    traceBindingStates = () => {
+        const changes = {};
+        let hasChanges = false;
+        for (const [key, element] of this.bindings) {
+            const state = toElementState(element);
+            const serialized = JSON.stringify(state);
+            if (this.tracedStates.get(key) === serialized)
+                continue;
+            this.tracedStates.set(key, serialized);
+            changes[key] = state;
+            hasChanges = true;
+        }
+        for (const key of this.tracedStates.keys()) {
+            if (this.bindings.has(key))
+                continue;
+            this.tracedStates.delete(key);
+            changes[key] = null;
+            hasChanges = true;
+        }
+        if (hasChanges)
+            this.tracer.trace('audioBinding.state', changes);
     };
     stop = () => {
         clearInterval(this.watchdogInterval);
@@ -11927,7 +11932,9 @@ class TrackSubscriptionManager {
 class MediaPlaybackWatchdog {
     logger = videoLoggerSystem.getLogger('MediaPlaybackWatchdog');
     kind;
+    traceInfo;
     isBlocked;
+    onGiveUp;
     element;
     tracer;
     controller = new AbortController();
@@ -11939,8 +11946,14 @@ class MediaPlaybackWatchdog {
     constructor(opts) {
         this.element = opts.element;
         this.kind = opts.kind;
+        this.traceInfo = {
+            kind: opts.kind,
+            sessionId: opts.sessionId,
+            trackType: opts.trackType,
+        };
         this.tracer = opts.tracer;
         this.isBlocked = opts.isBlocked ?? (() => false);
+        this.onGiveUp = opts.onGiveUp ?? (() => { });
         this.attach();
     }
     attach = () => {
@@ -11958,6 +11971,23 @@ class MediaPlaybackWatchdog {
         this.controller.abort();
         this.clearTimers();
     };
+    /**
+     * Starts a fresh recovery cycle, e.g. after a media interruption ended.
+     * Unlike a regular pause-triggered recovery, it also tries elements that
+     * were skipped as blocked or not ready, since those conditions may have
+     * cleared together with the interruption.
+     */
+    rearm = () => {
+        if (this.disposed)
+            return;
+        this.clearTimers();
+        this.attempt = 0;
+        this.stopped = false;
+        const { paused, srcObject, ended } = this.element;
+        if (!paused || !srcObject || ended)
+            return;
+        this.pendingTimer = setTimeout(this.attemptPlay, 0);
+    };
     clearTimers = () => {
         if (this.pendingTimer)
             clearTimeout(this.pendingTimer);
@@ -11979,17 +12009,34 @@ class MediaPlaybackWatchdog {
         if (this.element.paused)
             return;
         this.tracer.trace('mediaPlayback.recover.success', {
-            kind: this.kind,
+            ...this.traceInfo,
             attempts: this.attempt,
         });
         this.attempt = 0;
         this.stopped = false;
     };
+    /**
+     * Media elements backed by a MediaStream fire `suspend` routinely (after
+     * the initial load, on source swaps, on layer switches), so a `suspend`
+     * that needs no recovery is ignored without a trace. An explicit `pause`
+     * is rare and always traced, along with the reason recovery was skipped.
+     */
     onPauseOrSuspend = (event) => {
-        if (this.disposed || this.stopped)
+        if (this.disposed || this.stopped || this.pendingTimer)
+            return;
+        const skipReason = this.computeSkipReason();
+        if (skipReason) {
+            if (event.type === 'pause') {
+                this.tracer.trace('mediaPlayback.paused', {
+                    ...this.traceInfo,
+                    reason: event.type,
+                    skipped: skipReason,
+                });
+            }
             return;
+        }
         this.tracer.trace('mediaPlayback.paused', {
-            kind: this.kind,
+            ...this.traceInfo,
             reason: event.type,
         });
         if (this.settleTimer)
@@ -12003,7 +12050,7 @@ class MediaPlaybackWatchdog {
         const skipReason = this.computeSkipReason();
         if (skipReason) {
             this.tracer.trace('mediaPlayback.recover.skipped', {
-                kind: this.kind,
+                ...this.traceInfo,
                 reason: skipReason,
             });
             return;
@@ -12012,9 +12059,10 @@ class MediaPlaybackWatchdog {
             this.stopped = true;
             this.clearTimers();
             this.tracer.trace('mediaPlayback.recover.giveUp', {
-                kind: this.kind,
+                ...this.traceInfo,
                 attempts: this.attempt,
             });
+            this.onGiveUp();
             return;
         }
         const delay = this.attempt === 0 ? 0 : retryInterval(this.attempt);
@@ -12042,7 +12090,7 @@ class MediaPlaybackWatchdog {
             return;
         this.attempt += 1;
         this.tracer.trace('mediaPlayback.recover.attempt', {
-            kind: this.kind,
+            ...this.traceInfo,
             attempt: this.attempt,
         });
         try {
@@ -12057,6 +12105,41 @@ class MediaPlaybackWatchdog {
     };
 }
 
+/**
+ * Checks whether media playback and capture are likely interrupted: the page
+ * is hidden, or WebKit reports the audio session as interrupted (a phone
+ * call, Siri, or another app taking over audio).
+ */
+const isMediaInterrupted = () => {
+    if (typeof document === 'undefined')
+        return false;
+    return (document.visibilityState === 'hidden' ||
+        navigator.audioSession?.state === 'interrupted');
+};
+/**
+ * Invokes `onResumed` every time the page leaves a media interruption,
+ * as defined by {@link isMediaInterrupted}.
+ *
+ * @param onResumed the callback to invoke.
+ * @returns a function that stops watching.
+ */
+const watchMediaInterruptions = (onResumed) => {
+    if (typeof document === 'undefined')
+        return () => { };
+    let interrupted = isMediaInterrupted();
+    const check = () => {
+        const wasInterrupted = interrupted;
+        interrupted = isMediaInterrupted();
+        if (wasInterrupted && !interrupted)
+            onResumed();
+    };
+    const controller = new AbortController();
+    const { signal } = controller;
+    document.addEventListener('visibilitychange', check, { signal });
+    navigator.audioSession?.addEventListener('statechange', check, { signal });
+    return () => controller.abort();
+};
+
 /**
  * A manager class that handles dynascale related tasks like:
  *
@@ -12070,6 +12153,9 @@ class DynascaleManager {
     tracer;
     useWebAudio = false;
     audioContext;
+    playbackWatchdogs = new Set();
+    stopWatchingInterruptions;
+    stopTracingAudioSession;
     trackSubscriptionManager;
     blockedAudioTracker;
     /**
@@ -12086,6 +12172,10 @@ class DynascaleManager {
      * Closes the audio context if it was created.
      */
     dispose = async () => {
+        this.stopWatchingInterruptions?.();
+        this.stopWatchingInterruptions = undefined;
+        this.stopTracingAudioSession?.();
+        this.stopTracingAudioSession = undefined;
         const context = this.audioContext;
         if (context && context.state !== 'closed') {
             document.removeEventListener('click', this.resumeAudioContext);
@@ -12225,10 +12315,12 @@ class DynascaleManager {
         // without prior user interaction:
         // https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide
         videoElement.muted = true;
-        const playbackWatchdog = new MediaPlaybackWatchdog({
+        const playbackWatchdog = this.createPlaybackWatchdog({
             element: videoElement,
             kind: 'video',
             tracer: this.tracer,
+            sessionId,
+            trackType,
         });
         const trackKey = isVideoTrack ? 'videoStream' : 'screenShareStream';
         const streamSubscription = participant$
@@ -12256,7 +12348,7 @@ class DynascaleManager {
             publishedTracksSubscription?.unsubscribe();
             streamSubscription.unsubscribe();
             resizeObserver?.disconnect();
-            playbackWatchdog.dispose();
+            this.disposePlaybackWatchdog(playbackWatchdog);
         };
     };
     /**
@@ -12274,9 +12366,10 @@ class DynascaleManager {
         const participant = this.callState.findParticipantBySessionId(sessionId);
         if (!participant || participant.isLocalParticipant)
             return;
+        this.traceAudioSessionState();
         const participant$ = this.callState.participants$.pipe(rxjs.map((ps) => ps.find((p) => p.sessionId === sessionId)), rxjs.takeWhile((p) => !!p), rxjs.distinctUntilChanged(), rxjs.shareReplay({ bufferSize: 1, refCount: true }));
         const updateSinkId = (deviceId, audioContext) => {
-            if (!deviceId)
+            if (!deviceId || !this.speaker.state.isDeviceSelectionSupported)
                 return;
             if ('setSinkId' in audioElement) {
                 audioElement.setSinkId(deviceId).catch((e) => {
@@ -12293,7 +12386,9 @@ class DynascaleManager {
         let sourceNode = undefined;
         let gainNode = undefined;
         let audioWatchdog = undefined;
+        let blockedByGiveUp = false;
         const clearBlockedAudio = () => {
+            blockedByGiveUp = false;
             if (!this.blockedAudioTracker.isBlocked(audioElement))
                 return;
             this.blockedAudioTracker.markBlocked(audioElement, false);
@@ -12301,15 +12396,18 @@ class DynascaleManager {
         audioElement.addEventListener('playing', clearBlockedAudio);
         const isAudioTrack = trackType === 'audioTrack';
         const trackKey = isAudioTrack ? 'audioStream' : 'screenShareAudioStream';
+        let sourceChangeTimer;
         const updateMediaStreamSubscription = participant$
             .pipe(rxjs.distinctUntilKeyChanged(trackKey))
             .subscribe((p) => {
             const source = isAudioTrack ? p.audioStream : p.screenShareAudioStream;
             if (audioElement.srcObject === source)
                 return;
-            setTimeout(() => {
+            clearTimeout(sourceChangeTimer);
+            sourceChangeTimer = setTimeout(() => {
+                sourceChangeTimer = undefined;
                 audioElement.srcObject = source ?? null;
-                audioWatchdog?.dispose();
+                this.disposePlaybackWatchdog(audioWatchdog);
                 audioWatchdog = undefined;
                 if (!source) {
                     clearBlockedAudio();
@@ -12340,15 +12438,25 @@ class DynascaleManager {
                         this.tracer.trace('audioPlaybackError', e.message);
                         if (e.name === 'NotAllowedError') {
                             this.tracer.trace('audioPlaybackBlocked', null);
+                            blockedByGiveUp = false;
                             this.blockedAudioTracker.markBlocked(audioElement, true, sessionId);
                         }
                         this.logger.warn(`Failed to play audio stream`, e);
                     });
-                    audioWatchdog = new MediaPlaybackWatchdog({
+                    audioWatchdog = this.createPlaybackWatchdog({
                         element: audioElement,
                         kind: 'audio',
                         tracer: this.tracer,
-                        isBlocked: () => this.blockedAudioTracker.isBlocked(audioElement),
+                        sessionId,
+                        trackType,
+                        // only an autoplay-policy block needs a user gesture; a give-up
+                        // block is for the UI and must not stop a re-armed cycle
+                        isBlocked: () => !blockedByGiveUp &&
+                            this.blockedAudioTracker.isBlocked(audioElement),
+                        onGiveUp: () => {
+                            blockedByGiveUp = true;
+                            this.blockedAudioTracker.markBlocked(audioElement, true, sessionId);
+                        },
                     });
                 }
                 const { selectedDevice } = this.speaker.state;
@@ -12356,7 +12464,7 @@ class DynascaleManager {
                     updateSinkId(selectedDevice, audioContext);
             });
         });
-        const sinkIdSubscription = !('setSinkId' in audioElement)
+        const sinkIdSubscription = !this.speaker.state.isDeviceSelectionSupported
             ? null
             : this.speaker.state.selectedDevice$.subscribe((deviceId) => {
                 const audioContext = this.getOrCreateAudioContext();
@@ -12378,13 +12486,51 @@ class DynascaleManager {
             sinkIdSubscription?.unsubscribe();
             volumeSubscription.unsubscribe();
             updateMediaStreamSubscription.unsubscribe();
+            clearTimeout(sourceChangeTimer);
             audioElement.srcObject = null;
             sourceNode?.disconnect();
             gainNode?.disconnect();
-            audioWatchdog?.dispose();
+            this.disposePlaybackWatchdog(audioWatchdog);
             audioWatchdog = undefined;
         };
     };
+    /**
+     * Creates a playback watchdog that is re-armed whenever a media
+     * interruption (backgrounding, phone call, Siri) ends.
+     */
+    createPlaybackWatchdog = (opts) => {
+        const watchdog = new MediaPlaybackWatchdog(opts);
+        this.playbackWatchdogs.add(watchdog);
+        this.stopWatchingInterruptions ??= watchMediaInterruptions(this.rearmPlayback);
+        return watchdog;
+    };
+    disposePlaybackWatchdog = (watchdog) => {
+        if (!watchdog)
+            return;
+        watchdog.dispose();
+        this.playbackWatchdogs.delete(watchdog);
+    };
+    rearmPlayback = () => {
+        this.tracer.trace('mediaPlayback.rearm', this.playbackWatchdogs.size);
+        this.playbackWatchdogs.forEach((watchdog) => watchdog.rearm());
+    };
+    /**
+     * Traces the WebKit audio session state (initial value and changes) in
+     * both playback modes, as it explains most iOS playback interruptions.
+     */
+    traceAudioSessionState = () => {
+        const audioSession = navigator.audioSession;
+        if (!audioSession || this.stopTracingAudioSession)
+            return;
+        const trace = () => {
+            this.tracer.trace('audioSession.state', audioSession.state);
+        };
+        trace();
+        audioSession.addEventListener('statechange', trace);
+        this.stopTracingAudioSession = () => {
+            audioSession.removeEventListener('statechange', trace);
+        };
+    };
     getOrCreateAudioContext = () => {
         if (!this.useWebAudio)
             return;
@@ -12407,7 +12553,6 @@ class DynascaleManager {
             audioSession.type = 'play-and-record';
             let isSessionInterrupted = false;
             audioSession.addEventListener('statechange', () => {
-                this.tracer.trace('audioSession.state', audioSession.state);
                 if (audioSession.state === 'interrupted') {
                     isSessionInterrupted = true;
                 }
@@ -12982,10 +13127,17 @@ const getDevices = (permission, kind, tracer) => {
 /**
  * Tells if the browser supports audio output change on 'audio' elements,
  * see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId.
+ *
+ * WebKit (Safari, iOS browsers, WKWebView) is reported as unsupported:
+ * setSinkId requires a user gesture, a per-device output can run at a
+ * different sample rate than the remote audio mixer (pitched/slowed audio),
+ * and audio goes silent when the selected device disconnects.
  */
 const checkIfAudioOutputChangeSupported = () => {
     if (typeof document === 'undefined')
         return false;
+    if (isWebKit())
+        return false;
     const element = document.createElement('audio');
     return 'setSinkId' in element;
 };
@@ -13491,6 +13643,7 @@ class DeviceManager {
             ? forceStopOrOptions
             : (forceStopOrOptions?.forceStop ?? false);
         this.state.prevStatus = this.state.optimisticStatus;
+        this.state.setError(undefined);
         if (!forceStop && this.state.optimisticStatus === 'disabled') {
             return;
         }
@@ -13500,6 +13653,7 @@ class DeviceManager {
                 const stopTracks = forceStop || this.state.disableMode === 'stop-tracks';
                 await this.muteStream(stopTracks);
                 this.state.setStatus('disabled');
+                this.state.setError(undefined);
             }
             finally {
                 if (!signal.aborted) {
@@ -13795,7 +13949,11 @@ class DeviceManager {
             };
             // the rootStream represents the stream coming from the actual device
             // e.g. camera or microphone stream
+            this.state.setError(undefined);
             rootStreamPromise = this.getSelectedStream(constraints);
+            rootStreamPromise.catch((error) => {
+                this.state.setError(error);
+            });
             // we publish the last MediaStream of the chain
             stream = await this.filters.reduce((parent, entry) => parent
                 .then((inputStream) => {
@@ -13966,9 +14124,22 @@ class DeviceManager {
         }
         const devices = getCurrentValue(this.listDevices()) || [];
         const currentDevice = this.findDevice(devices, selectedDevice) ??
-            createSyntheticDevice(selectedDevice, deviceKind);
+            createSyntheticDevice(selectedDevice, deviceKind, this.getActiveTrackLabel(selectedDevice));
         writePreferences(currentDevice, deviceKey, muted, storageKey);
     }
+    /**
+     * Returns the label of the active track if it was captured from the given
+     * device. Used as a fallback when the device list hasn't been enumerated yet,
+     * so the persisted preference still carries the device label.
+     */
+    getActiveTrackLabel = (deviceId) => {
+        const stream = this.state.rootMediaStream;
+        const tracks = this.trackType === TrackType.AUDIO
+            ? stream?.getAudioTracks()
+            : stream?.getVideoTracks();
+        const track = tracks?.find((t) => t.getSettings().deviceId === deviceId);
+        return track?.label;
+    };
     async applyPersistedPreferences(enabledInCallType, forceDisabled = false) {
         const deviceKey = this.trackType === TrackType.AUDIO ? 'microphone' : 'camera';
         const preferences = readPreferences(this.devicePersistence.storageKey);
@@ -14020,6 +14191,7 @@ class DeviceManagerState {
     rootMediaStreamSubject = new rxjs.BehaviorSubject(undefined);
     selectedDeviceSubject = new rxjs.BehaviorSubject(undefined);
     defaultConstraintsSubject = new rxjs.BehaviorSubject(undefined);
+    errorSubject = new rxjs.BehaviorSubject(undefined);
     /**
      * @internal
      */
@@ -14054,6 +14226,13 @@ class DeviceManagerState {
      * The default constraints for the device.
      */
     defaultConstraints$ = this.defaultConstraintsSubject.asObservable();
+    /**
+     * An Observable that emits the error of the last failed attempt to start
+     * the device (e.g. the device is in use by another app), or `undefined`.
+     * For screen share, this includes the user dismissing the picker.
+     * Cleared when the device is started again or disabled.
+     */
+    error$ = this.errorSubject.asObservable().pipe(rxjs.distinctUntilChanged());
     /**
      * An observable that will emit `true` if browser/system permission
      * is granted (or at least hasn't been denied), `false` otherwise.
@@ -14121,6 +14300,19 @@ class DeviceManagerState {
     get rootMediaStream() {
         return getCurrentValue(this.rootMediaStream$);
     }
+    /**
+     * The error of the last failed attempt to start the device, or `undefined`.
+     */
+    get error() {
+        return getCurrentValue(this.error$);
+    }
+    /**
+     * @internal
+     * @param error the error to set.
+     */
+    setError(error) {
+        setCurrentValue(this.errorSubject, error);
+    }
     /**
      * @internal
      * @param status
@@ -14702,9 +14894,11 @@ class MicrophoneManager extends AudioDeviceManager {
             this.call.state.callingState$,
             this.call.state.ownCapabilities$,
             this.state.selectedDevice$,
-            this.state.status$,
             this.state.browserPermissionState$,
-        ]), async ([callingState, ownCapabilities, deviceId, status, permissionState,]) => {
+            // only a trigger: queued handlers can run after the status changed
+            // again, so the live status is read below
+            this.state.status$,
+        ]), async ([callingState, ownCapabilities, deviceId, permissionState]) => {
             try {
                 if (callingState === exports.CallingState.LEFT) {
                     // The muted-recording-prepared mode is reset in `callManager.stop()`
@@ -14719,7 +14913,7 @@ class MicrophoneManager extends AudioDeviceManager {
                     return;
                 if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
                     const hasPermission = await this.hasPermission(permissionState);
-                    if (hasPermission && status !== 'enabled') {
+                    if (hasPermission && this.state.status !== 'enabled') {
                         this.setMutedRecordingPrepared(true);
                         await this.startSpeakingWhileMutedDetection(deviceId);
                     }
@@ -15019,6 +15213,52 @@ class MicrophoneManager extends AudioDeviceManager {
         await this.call.ensureMediaFactory();
         return getAudioStream(constraints, this.call.tracer);
     }
+    /**
+     * On mute, hands a clone of the live mic track to the speaking while muted
+     * detection, so the device stays captured after the mic tracks are stopped.
+     * Releasing and re-acquiring the mic flips Bluetooth headsets between audio
+     * profiles.
+     */
+    async muteStream(stopTracks = true) {
+        const [track] = this.state.rootMediaStream?.getAudioTracks() ?? [];
+        const clone = track?.readyState === 'live' &&
+            this.state.optimisticStatus === 'disabled' &&
+            this.canHandOffMic()
+            ? track.clone()
+            : undefined;
+        try {
+            await super.muteStream(stopTracks);
+        }
+        catch (err) {
+            clone?.stop();
+            throw err;
+        }
+        if (!clone)
+            return;
+        // the mic, the call, or the selected device may have changed while
+        // unpublishing
+        const deviceId = resolveDeviceId(clone.getSettings().deviceId, 'audioinput');
+        if (clone.readyState !== 'live' ||
+            !this.canHandOffMic() ||
+            deviceId !== this.state.selectedDevice) {
+            clone.stop();
+            return;
+        }
+        this.startSpeakingWhileMutedDetection(deviceId, clone).catch((err) => {
+            clone.stop();
+            this.logger.warn('Could not hand off mic to speaking while muted', err);
+        });
+    }
+    /**
+     * Whether a mute can hand the mic over to the speaking while muted detection.
+     */
+    canHandOffMic = () => {
+        const { callingState, ownCapabilities } = this.call.state;
+        return (!isReactNative() &&
+            this.speakingWhileMutedNotificationEnabled &&
+            callingState === exports.CallingState.JOINED &&
+            ownCapabilities.includes(OwnCapability.SEND_AUDIO));
+    };
     doSetAudioBitrateProfile(profile) {
         this.setDefaultConstraints({
             ...this.state.defaultConstraints,
@@ -15038,10 +15278,13 @@ class MicrophoneManager extends AudioDeviceManager {
             }
         }
     }
-    async startSpeakingWhileMutedDetection(deviceId) {
+    async startSpeakingWhileMutedDetection(deviceId, track) {
         await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
-            if (this.soundDetectorCleanup && this.soundDetectorDeviceId === deviceId)
+            if (this.soundDetectorCleanup &&
+                this.soundDetectorDeviceId === deviceId) {
+                track?.stop();
                 return;
+            }
             await this.teardownSpeakingWhileMutedDetection();
             if (isReactNative()) {
                 const speechActivity = globalThis.streamRNVideoSDK?.nativeEvents?.speechActivity;
@@ -15057,11 +15300,14 @@ class MicrophoneManager extends AudioDeviceManager {
                 };
             }
             else {
-                // Need to start a new stream that's not connected to publisher
-                const stream = await this.getStream({
-                    ...this.state.defaultConstraints,
-                    deviceId: { exact: deviceId },
-                });
+                // Use the handed-off mic track, or start a new stream that's not
+                // connected to publisher
+                const stream = track
+                    ? new MediaStream([track])
+                    : await this.getStream({
+                        ...this.state.defaultConstraints,
+                        deviceId: { exact: deviceId },
+                    });
                 this.soundDetectorCleanup = createSoundDetector(stream, (event) => {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
@@ -15341,7 +15587,7 @@ class SpeakerManager {
     }
     async applyWeb() {
         const { enabled, storageKey } = this.devicePersistence;
-        if (!enabled)
+        if (!enabled || !this.state.isDeviceSelectionSupported)
             return;
         const preferences = readPreferences(storageKey);
         const preferenceList = toPreferenceList(preferences.speaker);
@@ -15617,6 +15863,14 @@ class Call {
     networkAvailableTask;
     // (10 attempts per rolling 120 s window).
     rejoinRateLimiter = new SlidingWindowRateLimiter(10, 120000);
+    // Backstop for slow REJOIN loops that stay under the short window
+    // (20 attempts per rolling 30 min window). Dropped once the integrator
+    // takes over the budget through `setRejoinAttemptLimit`.
+    rejoinLongWindowRateLimiter = new SlidingWindowRateLimiter(20, 30 * 60 * 1000);
+    // In-flight `doJoin` runs, awaited before acting on peer connections that
+    // gathered no local ICE candidates.
+    joinTasks = new Set();
+    noLocalCandidatesCheckScheduled = false;
     // "Network doesn't support WebRTC" detector: counts peer-connection
     // failures where ICE never reached `connected`/`completed`.
     maxIceFailuresWithoutConnect = 2;
@@ -16010,6 +16264,7 @@ class Call {
             // `joinFlow` never runs, leaving stale values that would make the next
             // fresh `join()` send a stale `ReconnectDetails` to the SFU.
             this.rejoinRateLimiter.reset();
+            this.rejoinLongWindowRateLimiter?.reset();
             this.iceFailuresWithoutConnect = 0;
             this.consecutiveNegotiationFailures = 0;
             this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
@@ -16405,6 +16660,16 @@ class Call {
      * @returns a promise which resolves once the call join-flow has finished.
      */
     doJoin = async (data) => {
+        const task = this.performJoin(data);
+        this.joinTasks.add(task);
+        try {
+            await task;
+        }
+        finally {
+            this.joinTasks.delete(task);
+        }
+    };
+    performJoin = async (data) => {
         const connectStartTime = Date.now();
         const callingState = this.state.callingState;
         const joinLeaveGeneration = this.leaveGeneration;
@@ -16762,6 +17027,9 @@ class Call {
                 // "ICE never connected" failure budget can be cleared.
                 this.iceFailuresWithoutConnect = 0;
             },
+            onNoLocalCandidates: () => {
+                this.checkNoLocalCandidates();
+            },
             onPeerConnectionStateChange: (event) => {
                 this.clientEventReporter.onPeerConnectionStateChange(this.cid, event);
             },
@@ -16804,15 +17072,65 @@ class Call {
                 options: statsOptions,
                 subscriber: this.subscriber,
                 publisher: this.publisher,
-                microphone: this.microphone,
-                camera: this.camera,
-                state: this.state,
                 tracer: this.tracer,
                 unifiedSessionId,
             });
             this.sfuStatsReporter.start();
         }
     };
+    /**
+     * Escalates to REJOIN with `ICE_NEVER_CONNECTED` when the current peer
+     * connections never connected and one of them completed ICE gathering
+     * without a single local candidate, which means WebRTC networking is
+     * blocked on this device.
+     *
+     * `reconnect` ignores requests while a join or another reconnect is in
+     * flight, so the check is postponed until those settle and then re-run
+     * against the peer connections current at that time.
+     */
+    checkNoLocalCandidates = () => {
+        if (this.noLocalCandidatesCheckScheduled)
+            return;
+        if (this.joinTasks.size > 0 || hasPending(this.reconnectConcurrencyTag)) {
+            this.noLocalCandidatesCheckScheduled = true;
+            const leaveGeneration = this.leaveGeneration;
+            this.waitForJoinsAndReconnects()
+                .then(() => {
+                this.noLocalCandidatesCheckScheduled = false;
+                if (this.leaveGeneration !== leaveGeneration)
+                    return;
+                this.checkNoLocalCandidates();
+            })
+                .catch((err) => {
+                this.noLocalCandidatesCheckScheduled = false;
+                this.logger.warn('[Reconnect] No-candidates check failed', err);
+            });
+            return;
+        }
+        if (this.state.callingState !== exports.CallingState.JOINED)
+            return;
+        // without network, gathering legitimately yields no candidates
+        if (typeof navigator !== 'undefined' && navigator.onLine === false)
+            return;
+        const peerConnections = [this.publisher, this.subscriber];
+        if (peerConnections.some((pc) => pc?.hasIceEverConnected()))
+            return;
+        if (!peerConnections.some((pc) => pc?.hasNoLocalCandidates()))
+            return;
+        this.reconnect(WebsocketReconnectStrategy.REJOIN, ReconnectReason.ICE_NEVER_CONNECTED).catch((err) => {
+            this.logger.warn('[Reconnect] Error reconnecting', err);
+        });
+    };
+    /**
+     * Resolves once no `doJoin` run and no reconnect is in flight.
+     */
+    waitForJoinsAndReconnects = async () => {
+        while (this.joinTasks.size > 0 ||
+            hasPending(this.reconnectConcurrencyTag)) {
+            await Promise.allSettled(this.joinTasks);
+            await settled(this.reconnectConcurrencyTag);
+        }
+    };
     /**
      * Retrieves credentials for joining the call.
      *
@@ -17011,6 +17329,14 @@ class Call {
                         return;
                     }
                 }
+                // MIGRATE is server-driven (e.g. SFU drains), so it doesn't count
+                // toward the long-window backstop.
+                if (this.reconnectStrategy === WebsocketReconnectStrategy.REJOIN &&
+                    this.rejoinLongWindowRateLimiter &&
+                    !this.rejoinLongWindowRateLimiter.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++;
@@ -17229,7 +17555,13 @@ class Call {
             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) => {
+        // Only the active SFU client may drive a reconnect: a superseded one can
+        // still report errors about its own (replaced) session, and none may
+        // while `leave()` tears the call down.
+        const activeSfuTag = () => this.sfuClient?.tag ?? '*';
+        const unregisterOnError = this.dispatcher.on('error', activeSfuTag, (e) => {
+            if (!this.sfuClient)
+                return;
             const { reconnectStrategy: strategy, error } = e;
             if (!SfuJoinError.isJoinErrorCode(e)) {
                 const code = error?.code ? ErrorCode[error.code] : undefined;
@@ -17252,7 +17584,16 @@ class Call {
                 });
             }
             else {
-                this.reconnect(strategy, error?.message || ReconnectReason.SFU_ERROR).catch((err) => {
+                // A media transport failure on a session whose peer connections
+                // never connected is an "ICE never connected" failure, and must
+                // count toward the unsupported-network budget.
+                const neverConnected = error?.code === ErrorCode.PARTICIPANT_MEDIA_TRANSPORT_FAILURE &&
+                    !this.publisher?.hasIceEverConnected() &&
+                    !this.subscriber?.hasIceEverConnected();
+                const reason = neverConnected
+                    ? ReconnectReason.ICE_NEVER_CONNECTED
+                    : error?.message || ReconnectReason.SFU_ERROR;
+                this.reconnect(strategy, reason).catch((err) => {
                     this.logger.warn('[Reconnect] Error reconnecting', err);
                 });
             }
@@ -18316,9 +18657,11 @@ class Call {
      * `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.
+     * Both arguments are clamped to a minimum of 1. Unless this method is
+     * called, an additional cap of 20 REJOIN attempts per 30 minutes applies.
      */
     setRejoinAttemptLimit = (maxAttempts, windowSeconds) => {
+        this.rejoinLongWindowRateLimiter = undefined;
         this.rejoinRateLimiter.setLimits(Math.max(1, maxAttempts), Math.max(1, windowSeconds) * 1000);
     };
     /**
@@ -19656,11 +19999,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "1.61.1";
+        "1.62.0";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "1.61.1", ...extras } = clientAppIdentifier;
+            const { sdkName = 'js', sdkVersion = "1.62.0", ...extras } = clientAppIdentifier;
             this.cachedUserAgent = [
                 `stream-video-${sdkName}-v${sdkVersion}`,
                 ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -20600,6 +20943,10 @@ class StreamVideoClient {
                     const call = this.writeableStateStore.findCall(c.call.type, c.call.id);
                     if (call) {
                         call.updateFromCallStateResponse(c);
+                        // ring events missed while the WS was down aren't replayed
+                        reconcileRingState(call, 'ring-poll-api').catch((err) => {
+                            call.logger.error('Failed to reconcile the ring state after rewatch', err);
+                        });
                     }
                 }
                 return;