@stream-io/video-client 1.61.1 → 1.61.2

package/dist/src/coordinator/connection/types.d.ts

@@ -138,7 +138,7 @@ export type CallEventListener<E extends keyof AllCallEvents> = (event: AllCallEv
 export type Logger = (logLevel: LogLevel, message: string, ...args: unknown[]) => void;
 export type RingStatePollingOptions = {
     /**
-     * Quiet time after the ring starts, before the first poll. Defaults to 15_000.
+     * Quiet time after the ring starts, before the first poll. Defaults to 9_000.
      */
     startAfterMs?: number;
     /**

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

@@ -130,6 +130,12 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;
     private dispatchDeviceDisconnectedEvent;
     private persistPreference;
+    /**
+     * 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.
+     */
+    private getActiveTrackLabel;
     protected applyPersistedPreferences(enabledInCallType: boolean, forceDisabled?: boolean): Promise<boolean>;
     private applyMutedState;
 }

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -8,7 +8,6 @@ import { PerformanceStats } from '../models/models';
 import { RTMPIngress } from '../models/models';
 import { AppleState } from '../models/models';
 import { AndroidState } from '../models/models';
-import { InputDevices } from '../models/models';
 import { RemoteOutboundRtp } from '../models/models';
 import { RemoteInboundRtp } from '../models/models';
 import { OutboundRtp } from '../models/models';
@@ -129,14 +128,6 @@ export interface SendStatsRequest {
      * @generated from protobuf field: string session_id = 1;
      */
     sessionId: string;
-    /**
-     * @generated from protobuf field: string subscriber_stats = 2;
-     */
-    subscriberStats: string;
-    /**
-     * @generated from protobuf field: string publisher_stats = 3;
-     */
-    publisherStats: string;
     /**
      * @generated from protobuf field: string webrtc_version = 4;
      */
@@ -149,14 +140,6 @@ export interface SendStatsRequest {
      * @generated from protobuf field: string sdk_version = 6;
      */
     sdkVersion: string;
-    /**
-     * @generated from protobuf field: stream.video.sfu.models.InputDevices audio_devices = 7;
-     */
-    audioDevices?: InputDevices;
-    /**
-     * @generated from protobuf field: stream.video.sfu.models.InputDevices video_devices = 8;
-     */
-    videoDevices?: InputDevices;
     /**
      * @generated from protobuf oneof: device_state
      */
@@ -183,16 +166,6 @@ export interface SendStatsRequest {
      * @generated from protobuf field: stream.video.sfu.models.RTMPIngress rtmp = 12;
      */
     rtmp?: RTMPIngress;
-    /**
-     * @deprecated
-     * @generated from protobuf field: string subscriber_rtc_stats = 13 [deprecated = true];
-     */
-    subscriberRtcStats: string;
-    /**
-     * @deprecated
-     * @generated from protobuf field: string publisher_rtc_stats = 14 [deprecated = true];
-     */
-    publisherRtcStats: string;
     /**
      * @generated from protobuf field: string rtc_stats = 15;
      */

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

@@ -4,9 +4,12 @@ import { Tracer } from '../stats';
 /**
  * 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.
  */
 export declare class AudioBindingsWatchdog {
     private bindings;
+    private tracedStates;
     private enabled;
     private watchdogInterval?;
     private readonly unsubscribeCallingState;
@@ -24,8 +27,8 @@ export declare class AudioBindingsWatchdog {
      */
     unregister: (sessionId: string, trackType: AudioTrackType) => void;
     /**
-     * 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: boolean) => void;
     /**
@@ -33,5 +36,7 @@ export declare class AudioBindingsWatchdog {
      */
     dispose: () => void;
     private start;
+    private warnAboutDanglingBindings;
+    private traceBindingStates;
     private stop;
 }

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

@@ -17,6 +17,9 @@ export declare class DynascaleManager {
     private readonly tracer;
     private useWebAudio;
     private audioContext;
+    private playbackWatchdogs;
+    private stopWatchingInterruptions;
+    private stopTracingAudioSession;
     private trackSubscriptionManager;
     private blockedAudioTracker;
     /**
@@ -64,6 +67,18 @@ export declare class DynascaleManager {
      * @returns a cleanup function that will unbind the audio element.
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => (() => void) | undefined;
+    /**
+     * Creates a playback watchdog that is re-armed whenever a media
+     * interruption (backgrounding, phone call, Siri) ends.
+     */
+    private createPlaybackWatchdog;
+    private disposePlaybackWatchdog;
+    private rearmPlayback;
+    /**
+     * Traces the WebKit audio session state (initial value and changes) in
+     * both playback modes, as it explains most iOS playback interruptions.
+     */
+    private traceAudioSessionState;
     private getOrCreateAudioContext;
     private resumeAudioContext;
 }

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

@@ -4,7 +4,10 @@ export type MediaPlaybackWatchdogOptions = {
     element: HTMLMediaElement;
     kind: MediaKind;
     tracer: Tracer;
+    sessionId?: string;
+    trackType?: string;
     isBlocked?: () => boolean;
+    onGiveUp?: () => void;
 };
 /**
  * Watches a single audio or video element and attempts to recover playback
@@ -13,7 +16,9 @@ export type MediaPlaybackWatchdogOptions = {
 export declare class MediaPlaybackWatchdog {
     private logger;
     private readonly kind;
+    private readonly traceInfo;
     private readonly isBlocked;
+    private readonly onGiveUp;
     private element;
     private tracer;
     private controller;
@@ -25,9 +30,22 @@ export declare class MediaPlaybackWatchdog {
     constructor(opts: MediaPlaybackWatchdogOptions);
     private attach;
     dispose: () => void;
+    /**
+     * 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: () => void;
     private clearTimers;
     private onPlaying;
     private onSettled;
+    /**
+     * 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.
+     */
     private onPauseOrSuspend;
     private scheduleRecovery;
     private computeSkipReason;

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

@@ -0,0 +1,14 @@
+/**
+ * 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).
+ */
+export declare const isMediaInterrupted: () => boolean;
+/**
+ * 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.
+ */
+export declare const watchMediaInterruptions: (onResumed: () => void) => (() => void);

package/dist/src/reporting/ClientEventReporter.d.ts

@@ -9,7 +9,7 @@ export type JoinReason = 'first-attempt' | 'network-available' | 'migration' | '
 /**
  * What triggered an automatic join, reported as `source` on the call's
  * CoordinatorJoin events. `ring-ws` is a ring WebSocket event, `ring-poll-api`
- * is the ring state poller.
+ * is the ring state poller, or the call refresh after a WS reconnect.
  */
 export type JoinSource = 'ring-ws' | 'ring-poll-api';
 export type ClientEventStandardCode = 'CLIENT_ABORTED' | 'BACKEND_LEAVE' | 'REQUEST_TIMEOUT' | 'NETWORK_ERROR' | 'SFU_ERROR' | 'SFU_GO_AWAY' | 'ICE_CONNECTIVITY_FAILED' | 'DTLS_CONNECTIVITY_FAILED';

package/dist/src/ringing/reconcileRingState.d.ts

@@ -3,15 +3,16 @@ import type { JoinSource } from '../reporting';
 /**
  * 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.
  */

package/dist/src/stats/SfuStatsReporter.d.ts

@@ -3,16 +3,11 @@ import { StatsOptions } from '../gen/coordinator';
 import { Publisher, Subscriber } from '../rtc';
 import { Tracer } from './rtc';
 import { ClientDetails, WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
-import { CameraManager, MicrophoneManager } from '../devices';
-import { CallState } from '../store';
 export type SfuStatsReporterOptions = {
     options: StatsOptions;
     clientDetails: ClientDetails;
     subscriber: Subscriber;
     publisher?: Publisher;
-    microphone: MicrophoneManager;
-    camera: CameraManager;
-    state: CallState;
     tracer: Tracer;
     unifiedSessionId: string;
 };
@@ -22,24 +17,17 @@ export declare class SfuStatsReporter {
     private readonly sfuClient;
     private readonly subscriber;
     private readonly publisher?;
-    private readonly microphone;
-    private readonly camera;
-    private readonly state;
     private readonly tracer;
     private readonly unifiedSessionId;
     private intervalId;
     private timeoutId;
     private reportCount;
-    private unsubscribeDevicePermissionsSubscription?;
-    private unsubscribeListDevicesSubscription?;
     private readonly sdkName;
     private readonly sdkVersion;
     private readonly webRTCVersion;
-    private readonly inputDevices;
     private readonly statsConcurrencyTag;
     private isStopped;
-    constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }: SfuStatsReporterOptions);
-    private observeDevice;
+    constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, tracer, unifiedSessionId, }: SfuStatsReporterOptions);
     sendConnectionTime: (connectionTimeSeconds: number) => void;
     sendReconnectionTime: (strategy: WebsocketReconnectStrategy, timeSeconds: number) => void;
     private sendTelemetryData;

package/dist/src/stats/rtc/StatsTracer.d.ts

@@ -1,5 +1,5 @@
-import { PeerType, TrackType } from '../../gen/video/sfu/models/models';
-import type { ComputedStats, PendingDelta } from './types';
+import { PeerType, PerformanceStats, TrackType } from '../../gen/video/sfu/models/models';
+import type { PendingDelta } from './types';
 /**
  * StatsTracer is a class that collects and processes WebRTC stats.
  * It is used to track the performance of the WebRTC connection
@@ -32,13 +32,13 @@ export declare class StatsTracer {
      */
     constructor(pc: RTCPeerConnection, peerType: PeerType, trackIdToTrackType: Map<string, TrackType>, statsTimestampDriftThresholdMs?: number, maxPendingDeltas?: number);
     /**
-     * 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
      */
-    takeSample: () => Promise<ComputedStats>;
+    takeSample: () => Promise<PerformanceStats[]>;
     /**
      * Returns a stable copy of the un-acked delta chain to transmit, oldest first.
      *

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

@@ -1,4 +1,3 @@
-import type { PerformanceStats } from '../../gen/video/sfu/models/models';
 export type RTCStatsDataType = RTCConfiguration | RTCIceCandidate | RTCSignalingState | RTCIceConnectionState | RTCIceGatheringState | RTCPeerConnectionState | [number | null | string] | string | boolean | RTCOfferOptions | [string | RTCDataChannelInit | undefined] | (RTCOfferOptions | undefined) | RTCSessionDescriptionInit | (RTCIceCandidateInit | RTCIceCandidate) | object | number | null | undefined;
 export type TraceKey = 'device-enumeration' | (string & {});
 export type Trace = (tag: string, data: RTCStatsDataType) => void;
@@ -12,16 +11,6 @@ export type TraceSlice = {
     snapshot: TraceRecord[];
     rollback: () => void;
 };
-export type ComputedStats = {
-    /**
-     * Current stats from the RTCPeerConnection.
-     */
-    stats: RTCStatsReport;
-    /**
-     * The current iteration of the stats.
-     */
-    performanceStats: PerformanceStats[];
-};
 /**
  * A single, not-yet-delivered delta-compressed stats sample.
  * The `delta` is computed against the immediately preceding sample, so a

package/package.json

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

package/src/Call.ts

@@ -1812,9 +1812,6 @@ export class Call {
         options: statsOptions,
         subscriber: this.subscriber,
         publisher: this.publisher,
-        microphone: this.microphone,
-        camera: this.camera,
-        state: this.state,
         tracer: this.tracer,
         unifiedSessionId,
       });

package/src/StreamVideoClient.ts

@@ -42,6 +42,7 @@ import { logToConsole, ScopedLogger, videoLoggerSystem } from './logger';
 import { withoutConcurrency } from './helpers/concurrency';
 import { enableTimerWorker } from './timers';
 import { ClientEventReporter } from './reporting';
+import { reconcileRingState } from './ringing';
 
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
@@ -285,6 +286,13 @@ export class StreamVideoClient {
 
           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,
+              );
+            });
           }
         }
 

package/src/__tests__/StreamVideoClient.rewatch.test.ts

@@ -12,7 +12,9 @@ import type {
   CallResponse,
   ConnectedEvent,
   GetCallResponse,
+  MemberResponse,
   QueryCallsResponse,
+  UserResponse,
 } from '../gen/coordinator';
 
 const apiKey = 'mock-api-key';
@@ -126,6 +128,140 @@ describe('StreamVideoClient re-watching calls on reconnect', () => {
     await vi.waitFor(() => expect(leave).toHaveBeenCalled());
   });
 
+  describe('ring reconciliation after a rewatch', () => {
+    const rewatchWith = async (
+      call: Call,
+      rejected_by: Record<string, string>,
+      extra: {
+        accepted_by?: Record<string, string>;
+        members?: MemberResponse[];
+        ended_at?: string;
+      } = {},
+    ) => {
+      const leave = vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+      const session = CallRingPayload.call.session!;
+      const response = queryCallsResponse({
+        ...CallRingPayload.call,
+        // keep the creator the call was set up with
+        created_by: call.state.createdBy as UserResponse,
+        ended_at: extra.ended_at,
+        session: {
+          ...session,
+          rejected_by,
+          accepted_by: extra.accepted_by ?? session.accepted_by,
+        },
+      });
+      if (extra.members) response.calls[0].members = extra.members;
+      const post = vi
+        .spyOn(client.streamClient, 'doAxiosRequest')
+        .mockResolvedValue(response as never);
+      const updated = vi.spyOn(call, 'updateFromCallStateResponse');
+      reconnect();
+      await vi.waitFor(() => expect(post).toHaveBeenCalled());
+      await vi.waitFor(() => expect(updated).toHaveBeenCalled());
+      for (let i = 0; i < 5; i++) await Promise.resolve();
+      return leave;
+    };
+    const rejectedAt = () => '2025-08-14T14:49:00Z';
+
+    it('callee leaves when the creator cancelled while offline', async () => {
+      const call = await setupRingingCall();
+      const leave = await rewatchWith(call, { oliver_1: rejectedAt() });
+      expect(leave).toHaveBeenCalledWith({
+        reason: 'ended',
+        message: 'ring: creator rejected',
+      });
+    });
+
+    it('callee keeps ringing without a rejection', async () => {
+      const call = await setupRingingCall();
+      const leave = await rewatchWith(call, {});
+      expect(leave).not.toHaveBeenCalled();
+    });
+
+    it('callee keeps ringing when only another member rejected', async () => {
+      const call = await setupRingingCall();
+      const leave = await rewatchWith(call, { someone_else: rejectedAt() });
+      expect(leave).not.toHaveBeenCalled();
+    });
+
+    it('callee leaves when the call ended while offline', async () => {
+      const call = await setupRingingCall();
+      const leave = await rewatchWith(call, {}, { ended_at: rejectedAt() });
+      expect(leave).toHaveBeenCalledWith({
+        reason: 'ended',
+        message: 'ring: call ended',
+      });
+    });
+
+    it('does not reconcile a call that is not in RINGING state', async () => {
+      const call = await setupRingingCall();
+      call.state.setCallingState(CallingState.JOINED);
+      const leave = await rewatchWith(call, { oliver_1: rejectedAt() });
+      expect(leave).not.toHaveBeenCalled();
+    });
+
+    describe('as the caller', () => {
+      const callee = CallRingPayload.members[0];
+      const members = [
+        callee,
+        {
+          ...callee,
+          user_id: 'oliver_1',
+          user: { ...callee.user, id: 'oliver_1' },
+        },
+      ];
+
+      const setupOwnRingingCall = async () => {
+        const payload = {
+          ...CallRingPayload,
+          call: {
+            ...CallRingPayload.call,
+            created_by: { ...CallRingPayload.call.created_by, id: userId },
+          },
+          members,
+        };
+        vi.spyOn(client.streamClient, 'doAxiosRequest').mockResolvedValue({
+          duration: '1ms',
+          call: payload.call,
+          members,
+          own_capabilities: [],
+        } as GetCallResponse as never);
+        client.streamClient.dispatchEvent(payload as StreamVideoEvent);
+        await settled(getCallInitConcurrencyTag(payload.call_cid));
+        const [call] = client.state.calls;
+        expect(call.isCreatedByMe).toBeTruthy();
+        expect(call.state.callingState).toBe(CallingState.RINGING);
+        return call;
+      };
+
+      it('leaves when every other member rejected while offline', async () => {
+        const call = await setupOwnRingingCall();
+        const leave = await rewatchWith(
+          call,
+          { oliver_1: rejectedAt() },
+          { members },
+        );
+        expect(leave).toHaveBeenCalledWith({
+          reject: true,
+          reason: 'cancel',
+          message: 'ring: everyone rejected',
+        });
+      });
+
+      it('joins when another member accepted while offline', async () => {
+        const call = await setupOwnRingingCall();
+        const join = vi.spyOn(call, 'join').mockResolvedValue(undefined);
+        await rewatchWith(
+          call,
+          {},
+          { members, accepted_by: { oliver_1: rejectedAt() } },
+        );
+        expect(join).toHaveBeenCalledWith({ joinSource: 'ring-poll-api' });
+      });
+    });
+  });
+
   it('queryCalls returns an independent instance for registered calls', async () => {
     // e.g. being on a call while watching a dashboard of calls:
     // leaving the joined instance must not silence the dashboard instance

package/src/coordinator/connection/types.ts

@@ -202,7 +202,7 @@ export type Logger = (
 
 export type RingStatePollingOptions = {
   /**
-   * Quiet time after the ring starts, before the first poll. Defaults to 15_000.
+   * Quiet time after the ring starts, before the first poll. Defaults to 9_000.
    */
   startAfterMs?: number;
 

package/src/devices/DeviceManager.ts

@@ -837,11 +837,30 @@ export abstract 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.
+   */
+  private getActiveTrackLabel = (deviceId: string) => {
+    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;
+  };
+
   protected async applyPersistedPreferences(
     enabledInCallType: boolean,
     forceDisabled = false,

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

@@ -17,7 +17,8 @@ import {
 import { createVideoStreamForDevice } from './mediaStreamTestHelpers';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { CameraManager } from '../CameraManager';
-import { of } from 'rxjs';
+import { getVideoDevices } from '../devices';
+import { NEVER, of } from 'rxjs';
 import { PermissionsContext } from '../../permissions';
 import { Tracer } from '../../stats';
 import {
@@ -598,6 +599,54 @@ describe('CameraManager', () => {
         });
       }
     });
+
+    it('persists the label from the active track when the device list is not enumerated yet', async () => {
+      const storageKey = '@test/device-preferences-camera-cold-list';
+      const localStorageMock = createLocalStorageMock();
+      const originalWindow = globalThis.window;
+      Object.defineProperty(globalThis, 'window', {
+        configurable: true,
+        value: { localStorage: localStorageMock },
+      });
+
+      const device = mockVideoDevices[1];
+      vi.mocked(getVideoDevices).mockReturnValue(NEVER);
+      vi.mocked(getVideoStream).mockResolvedValue(
+        createVideoStreamForDevice(device.deviceId, 'user', device.label),
+      );
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
+
+      const coldListManager = new CameraManager(call, {
+        enabled: true,
+        storageKey,
+      });
+
+      try {
+        await coldListManager.enable();
+        await coldListManager.statusChangeSettled();
+
+        expect(coldListManager.state.selectedDevice).toBe(device.deviceId);
+        const [persisted] = toPreferenceList(
+          readPreferences(storageKey).camera,
+        );
+        expect(persisted).toEqual({
+          selectedDeviceId: device.deviceId,
+          selectedDeviceLabel: device.label,
+          muted: false,
+        });
+      } finally {
+        coldListManager.dispose();
+        vi.mocked(getVideoDevices).mockImplementation(() =>
+          of(mockVideoDevices),
+        );
+        Object.defineProperty(globalThis, 'window', {
+          configurable: true,
+          value: originalWindow,
+        });
+      }
+    });
   });
 
   afterEach(() => {

package/src/devices/__tests__/mediaStreamTestHelpers.ts

@@ -43,13 +43,17 @@ export const createAudioStreamForDevice = (
 export const createVideoStreamForDevice = (
   deviceId: string,
   facingMode: 'user' | 'environment' = 'user',
+  label = '',
 ): MediaStream => {
-  const track = createTrack({
-    deviceId,
-    width: 1280,
-    height: 720,
-    facingMode,
-  });
+  const track = createTrack(
+    {
+      deviceId,
+      width: 1280,
+      height: 720,
+      facingMode,
+    },
+    { label },
+  );
 
   return {
     getTracks: () => [track],