@stream-io/video-client 1.61.2 → 1.62.0

package/dist/src/Call.d.ts

@@ -124,6 +124,9 @@ export declare class Call {
     private lastOfflineTimestamp;
     private networkAvailableTask;
     private readonly rejoinRateLimiter;
+    private rejoinLongWindowRateLimiter?;
+    private readonly joinTasks;
+    private noLocalCandidatesCheckScheduled;
     private maxIceFailuresWithoutConnect;
     private iceFailuresWithoutConnect;
     private maxConsecutiveNegotiationFailures;
@@ -321,6 +324,7 @@ export declare class Call {
      * @returns a promise which resolves once the call join-flow has finished.
      */
     private doJoin;
+    private performJoin;
     /**
      * Prepares Reconnect Details object.
      * @internal
@@ -354,6 +358,21 @@ export declare class Call {
      * @internal
      */
     private initPublisherAndSubscriber;
+    /**
+     * 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.
+     */
+    private checkNoLocalCandidates;
+    /**
+     * Resolves once no `doJoin` run and no reconnect is in flight.
+     */
+    private waitForJoinsAndReconnects;
     /**
      * Retrieves credentials for joining the call.
      *
@@ -996,7 +1015,8 @@ export declare 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: number, windowSeconds: number) => void;
     /**

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

@@ -9,6 +9,7 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
     protected rootMediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
     protected selectedDeviceSubject: BehaviorSubject<string | undefined>;
     protected defaultConstraintsSubject: BehaviorSubject<C | undefined>;
+    protected errorSubject: BehaviorSubject<Error | undefined>;
     /**
      * @internal
      */
@@ -39,6 +40,13 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      * The default constraints for the device.
      */
     defaultConstraints$: Observable<C | undefined>;
+    /**
+     * 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$: Observable<Error | undefined>;
     /**
      * An observable that will emit `true` if browser/system permission
      * is granted (or at least hasn't been denied), `false` otherwise.
@@ -85,6 +93,15 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      * same as `mediaStream`.
      */
     get rootMediaStream(): MediaStream | undefined;
+    /**
+     * The error of the last failed attempt to start the device, or `undefined`.
+     */
+    get error(): Error | undefined;
+    /**
+     * @internal
+     * @param error the error to set.
+     */
+    setError(error: Error | undefined): void;
     /**
      * @internal
      * @param status

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

@@ -74,6 +74,17 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     apply(settings: AudioSettingsResponse, publish: boolean, forceDisabled?: boolean): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
+    /**
+     * 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.
+     */
+    protected muteStream(stopTracks?: boolean): Promise<void>;
+    /**
+     * Whether a mute can hand the mic over to the speaking while muted detection.
+     */
+    private canHandOffMic;
     protected doSetAudioBitrateProfile(profile: AudioBitrateProfile): void;
     private startSpeakingWhileMutedDetection;
     private stopSpeakingWhileMutedDetection;

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

@@ -3,6 +3,11 @@ import { Tracer } from '../stats';
 /**
  * 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.
  */
 export declare const checkIfAudioOutputChangeSupported: () => boolean;
 /**

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

@@ -24,10 +24,12 @@ export declare abstract class BasePeerConnection {
     protected sfuClient: StreamSfuClient;
     protected onReconnectionNeeded?: OnReconnectionNeeded;
     private onIceConnected?;
+    private onNoLocalCandidates?;
     private onPeerConnectionStateChange?;
     protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
     private readonly iceRestartDelay;
     private iceHasEverConnected;
+    private localCandidatesGathered;
     private iceRestartTimeout?;
     private preConnectStuckTimeout?;
     protected isIceRestarting: boolean;
@@ -41,7 +43,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onNoLocalCandidates, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
     private createPeerConnection;
     /**
      * Disposes the `RTCPeerConnection` instance.
@@ -90,6 +92,16 @@ export declare abstract class BasePeerConnection {
      * Maps the given track ID to the corresponding track type.
      */
     getTrackType: (trackId: string) => TrackType | undefined;
+    /**
+     * Returns `true` once ICE has reached `connected`/`completed` at least
+     * once during the lifetime of this peer connection.
+     */
+    hasIceEverConnected: () => boolean;
+    /**
+     * Returns `true` when the latest ICE gathering round completed without
+     * producing a single local candidate.
+     */
+    hasNoLocalCandidates: () => boolean;
     /**
      * Checks if the `RTCPeerConnection` is healthy.
      * It checks the ICE connection state and the peer connection state.

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

@@ -40,6 +40,12 @@ export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: Re
  * recovered, not merely when the SFU join handshake succeeded.
  */
 export type OnIceConnected = (peerType: PeerType) => void;
+/**
+ * Fires when an ICE gathering round completes without producing a single
+ * local candidate on a peer connection that never connected. Used by `Call`
+ * to detect devices whose WebRTC networking is blocked.
+ */
+export type OnNoLocalCandidates = (peerType: PeerType) => void;
 /**
  * Snapshot of the peer connection's ICE and DTLS state surfaced to telemetry
  * consumers (e.g. `ClientEventReporter`). Fired on every transition of
@@ -75,6 +81,7 @@ export type BasePeerConnectionOpts = {
     dispatcher: Dispatcher;
     onReconnectionNeeded?: OnReconnectionNeeded;
     onIceConnected?: OnIceConnected;
+    onNoLocalCandidates?: OnNoLocalCandidates;
     onPeerConnectionStateChange?: OnPeerConnectionStateChange;
     onRemoteTrackUnmute?: OnRemoteTrackUnmute;
     tag: string;

package/package.json

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

package/src/Call.ts

@@ -183,6 +183,7 @@ import {
 import { normalize } from './devices/devicePersistence';
 import {
   hasPending,
+  settled,
   singleFlight,
   withoutConcurrency,
 } from './helpers/concurrency';
@@ -325,6 +326,15 @@ export class Call {
 
   // (10 attempts per rolling 120 s window).
   private readonly 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`.
+  private rejoinLongWindowRateLimiter?: SlidingWindowRateLimiter =
+    new SlidingWindowRateLimiter(20, 30 * 60 * 1000);
+  // In-flight `doJoin` runs, awaited before acting on peer connections that
+  // gathered no local ICE candidates.
+  private readonly joinTasks = new Set<Promise<void>>();
+  private noLocalCandidatesCheckScheduled = false;
   // "Network doesn't support WebRTC" detector: counts peer-connection
   // failures where ICE never reached `connected`/`completed`.
   private maxIceFailuresWithoutConnect = 2;
@@ -810,6 +820,7 @@ export 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;
@@ -1313,6 +1324,16 @@ export class Call {
    * @returns a promise which resolves once the call join-flow has finished.
    */
   private doJoin = async (data?: JoinCallData): Promise<void> => {
+    const task = this.performJoin(data);
+    this.joinTasks.add(task);
+    try {
+      await task;
+    } finally {
+      this.joinTasks.delete(task);
+    }
+  };
+
+  private performJoin = async (data?: JoinCallData): Promise<void> => {
     const connectStartTime = Date.now();
     const callingState = this.state.callingState;
     const joinLeaveGeneration = this.leaveGeneration;
@@ -1761,6 +1782,9 @@ export class Call {
         // "ICE never connected" failure budget can be cleared.
         this.iceFailuresWithoutConnect = 0;
       },
+      onNoLocalCandidates: () => {
+        this.checkNoLocalCandidates();
+      },
       onPeerConnectionStateChange: (event) => {
         this.clientEventReporter.onPeerConnectionStateChange(this.cid, event);
       },
@@ -1819,6 +1843,62 @@ export class Call {
     }
   };
 
+  /**
+   * 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.
+   */
+  private 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 !== 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.
+   */
+  private 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.
    *
@@ -2060,6 +2140,16 @@ export 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) {
@@ -2340,7 +2430,12 @@ export class Call {
     });
 
     // 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;
@@ -2360,10 +2455,17 @@ export class Call {
           this.logger.warn(`Can't leave call after disconnect request`, err);
         });
       } 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);
         });
       }
@@ -3801,9 +3903,11 @@ export 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: number, windowSeconds: number) => {
+    this.rejoinLongWindowRateLimiter = undefined;
     this.rejoinRateLimiter.setLimits(
       Math.max(1, maxAttempts),
       Math.max(1, windowSeconds) * 1000,

package/src/devices/DeviceManager.ts

@@ -298,6 +298,7 @@ export abstract class DeviceManager<
         : (forceStopOrOptions?.forceStop ?? false);
 
     this.state.prevStatus = this.state.optimisticStatus;
+    this.state.setError(undefined);
     if (!forceStop && this.state.optimisticStatus === 'disabled') {
       return;
     }
@@ -310,6 +311,7 @@ export abstract class DeviceManager<
           forceStop || this.state.disableMode === 'stop-tracks';
         await this.muteStream(stopTracks);
         this.state.setStatus('disabled');
+        this.state.setError(undefined);
       } finally {
         if (!signal.aborted) {
           this.state.setPendingStatus(this.state.status);
@@ -638,7 +640,11 @@ export abstract 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 as C);
+      rootStreamPromise.catch((error) => {
+        this.state.setError(error);
+      });
       // we publish the last MediaStream of the chain
       stream = await this.filters.reduce(
         (parent, entry) =>

package/src/devices/DeviceManagerState.ts

@@ -28,6 +28,7 @@ export abstract class DeviceManagerState<C = MediaTrackConstraints> {
   protected defaultConstraintsSubject = new BehaviorSubject<C | undefined>(
     undefined,
   );
+  protected errorSubject = new BehaviorSubject<Error | undefined>(undefined);
 
   /**
    * @internal
@@ -70,6 +71,14 @@ export abstract class DeviceManagerState<C = MediaTrackConstraints> {
    */
   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(distinctUntilChanged());
+
   /**
    * An observable that will emit `true` if browser/system permission
    * is granted (or at least hasn't been denied), `false` otherwise.
@@ -152,6 +161,21 @@ export abstract class DeviceManagerState<C = MediaTrackConstraints> {
     return RxUtils.getCurrentValue(this.rootMediaStream$);
   }
 
+  /**
+   * The error of the last failed attempt to start the device, or `undefined`.
+   */
+  get error() {
+    return RxUtils.getCurrentValue(this.error$);
+  }
+
+  /**
+   * @internal
+   * @param error the error to set.
+   */
+  setError(error: Error | undefined) {
+    RxUtils.setCurrentValue(this.errorSubject, error);
+  }
+
   /**
    * @internal
    * @param status

package/src/devices/MicrophoneManager.ts

@@ -8,7 +8,7 @@ import {
 import { type BrowserPermissionState } from './BrowserPermission';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
 import { TrackDisableMode } from './DeviceManagerState';
-import { getAudioDevices, getAudioStream } from './devices';
+import { getAudioDevices, getAudioStream, resolveDeviceId } from './devices';
 import { AudioBitrateProfile, TrackType } from '../gen/video/sfu/models/models';
 import { createSoundDetector } from '../helpers/sound-detector';
 import { createNoAudioDetector } from '../helpers/no-audio-detector';
@@ -64,16 +64,12 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
           this.call.state.callingState$,
           this.call.state.ownCapabilities$,
           this.state.selectedDevice$,
-          this.state.status$,
           this.state.browserPermissionState$,
+          // 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,
-          status,
-          permissionState,
-        ]) => {
+        async ([callingState, ownCapabilities, deviceId, permissionState]) => {
           try {
             if (callingState === CallingState.LEFT) {
               // The muted-recording-prepared mode is reset in `callManager.stop()`
@@ -87,7 +83,7 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
 
             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);
               } else {
@@ -450,6 +446,61 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
     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.
+   */
+  protected override async muteStream(stopTracks: boolean = 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.
+   */
+  private canHandOffMic = () => {
+    const { callingState, ownCapabilities } = this.call.state;
+    return (
+      !isReactNative() &&
+      this.speakingWhileMutedNotificationEnabled &&
+      callingState === CallingState.JOINED &&
+      ownCapabilities.includes(OwnCapability.SEND_AUDIO)
+    );
+  };
+
   protected override doSetAudioBitrateProfile(profile: AudioBitrateProfile) {
     this.setDefaultConstraints({
       ...this.state.defaultConstraints,
@@ -474,10 +525,18 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
     }
   }
 
-  private async startSpeakingWhileMutedDetection(deviceId?: string) {
+  private async startSpeakingWhileMutedDetection(
+    deviceId?: string,
+    track?: MediaStreamTrack,
+  ) {
     await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
-      if (this.soundDetectorCleanup && this.soundDetectorDeviceId === deviceId)
+      if (
+        this.soundDetectorCleanup &&
+        this.soundDetectorDeviceId === deviceId
+      ) {
+        track?.stop();
         return;
+      }
 
       await this.teardownSpeakingWhileMutedDetection();
 
@@ -497,11 +556,14 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
           unsubscribe();
         };
       } 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);
         });

package/src/devices/SpeakerManager.ts

@@ -49,7 +49,7 @@ export class SpeakerManager {
 
   private async applyWeb() {
     const { enabled, storageKey } = this.devicePersistence;
-    if (!enabled) return;
+    if (!enabled || !this.state.isDeviceSelectionSupported) return;
 
     const preferences = readPreferences(storageKey);
     const preferenceList = toPreferenceList(preferences.speaker);

package/src/devices/__tests__/DeviceManager.test.ts

@@ -22,6 +22,7 @@ import { firstValueFrom, of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { PermissionsContext } from '../../permissions';
 import { defaultDeviceId, readPreferences } from '../devicePersistence';
+import { promiseWithResolvers } from '../../helpers/promise';
 
 vi.mock('../../reporting/ClientEventReporter', () => ({
   ClientEventReporter: vi.fn(function () {
@@ -172,6 +173,34 @@ describe('Device Manager', () => {
     expect(manager.state.status).toBe('disabled');
   });
 
+  it('clears a startup error when disabling an already disabled device', async () => {
+    await manager.disable();
+    const error = new Error('Camera failed to start');
+    manager.getStream.mockRejectedValueOnce(error);
+
+    await expect(manager.enable()).rejects.toThrow(error);
+    expect(manager.state.status).toBe('disabled');
+    expect(manager.state.error).toBe(error);
+
+    await manager.disable();
+
+    expect(manager.state.error).toBeUndefined();
+  });
+
+  it('clears a pending startup error when the queued disable completes', async () => {
+    const { promise, reject } = promiseWithResolvers<MediaStream>();
+    const error = new Error('Camera failed to start');
+    manager.getStream.mockReturnValueOnce(promise);
+
+    const enabling = expect(manager.enable()).rejects.toThrow(error);
+    const disabling = manager.disable();
+    reject(error);
+    await Promise.all([enabling, disabling]);
+
+    expect(manager.state.status).toBe('disabled');
+    expect(manager.state.error).toBeUndefined();
+  });
+
   it('toggle device', async () => {
     vi.spyOn(manager, 'disable');
     vi.spyOn(manager, 'enable');