@stream-io/video-client 1.61.2 → 1.62.0

package/dist/index.cjs.js

@@ -5075,7 +5075,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "1.61.2";
+const version = "1.62.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8470,10 +8470,12 @@ class BasePeerConnection {
     sfuClient;
     onReconnectionNeeded;
     onIceConnected;
+    onNoLocalCandidates;
     onPeerConnectionStateChange;
     onRemoteTrackUnmute;
     iceRestartDelay;
     iceHasEverConnected = false;
+    localCandidatesGathered = 0;
     iceRestartTimeout;
     preConnectStuckTimeout;
     isIceRestarting = false;
@@ -8487,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;
@@ -8498,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] });
@@ -8538,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;
@@ -8641,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.
@@ -8663,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 })
@@ -8727,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;
@@ -8790,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');
@@ -8823,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.
@@ -12339,7 +12369,7 @@ class DynascaleManager {
         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) => {
@@ -12434,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();
@@ -13097,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;
 };
@@ -13606,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;
         }
@@ -13615,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) {
@@ -13910,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) => {
@@ -14148,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
      */
@@ -14182,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.
@@ -14249,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
@@ -14830,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()`
@@ -14847,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);
                     }
@@ -15147,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,
@@ -15166,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;
@@ -15185,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);
                 });
@@ -15469,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);
@@ -15745,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;
@@ -16138,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;
@@ -16533,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;
@@ -16890,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);
             },
@@ -16938,6 +17078,59 @@ class Call {
             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.
      *
@@ -17136,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++;
@@ -17354,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;
@@ -17377,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);
                 });
             }
@@ -18441,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);
     };
     /**
@@ -19781,11 +19999,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "1.61.2";
+        "1.62.0";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "1.61.2", ...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}`),