@stream-io/video-client 1.21.0 → 1.22.1

package/dist/src/Call.d.ts

@@ -3,6 +3,7 @@ import { CallState } from './store';
 import type { AcceptCallResponse, BlockUserResponse, CallRingEvent, CallSettingsResponse, CollectUserFeedbackRequest, CollectUserFeedbackResponse, DeleteCallRequest, DeleteCallResponse, EndCallResponse, GetCallReportResponse, GetCallResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, JoinCallResponse, ListRecordingsResponse, ListTranscriptionsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryCallMembersRequest, QueryCallMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendCallEventResponse, SendReactionRequest, SendReactionResponse, StartClosedCaptionsRequest, StartClosedCaptionsResponse, StartFrameRecordingRequest, StartFrameRecordingResponse, StartHLSBroadcastingResponse, StartRecordingRequest, StartRecordingResponse, StartRTMPBroadcastsRequest, StartRTMPBroadcastsResponse, StartTranscriptionRequest, StartTranscriptionResponse, StopAllRTMPBroadcastsResponse, StopClosedCaptionsRequest, StopClosedCaptionsResponse, StopFrameRecordingResponse, StopHLSBroadcastingResponse, StopLiveRequest, StopLiveResponse, StopRecordingResponse, StopRTMPBroadcastsResponse, StopTranscriptionResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse, VideoDimension } from './gen/coordinator';
 import { AudioTrackType, CallConstructor, CallLeaveOptions, ClientPublishOptions, ClosedCaptionsSettings, JoinCallData, TrackMuteType, VideoTrackType } from './types';
 import { TrackType } from './gen/video/sfu/models/models';
+import { Tracer } from './stats';
 import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
 import { StreamClient } from './coordinator/connection/client';
@@ -64,6 +65,7 @@ export declare class Call {
      * The permissions context of this call.
      */
     readonly permissionsContext: PermissionsContext;
+    readonly tracer: Tracer;
     readonly logger: Logger;
     /**
      * The event dispatcher instance dedicated to this Call instance.

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

@@ -5,14 +5,14 @@ import { Logger } from '../coordinator/connection/types';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { MediaStreamFilter, MediaStreamFilterRegistrationResult } from './filters';
 export declare abstract class InputMediaDeviceManager<T extends InputMediaDeviceManagerState<C>, C = MediaTrackConstraints> {
-    protected readonly call: Call;
-    readonly state: T;
-    protected readonly trackType: TrackType;
     /**
      * if true, stops the media stream when call is left
      */
     stopOnLeave: boolean;
     logger: Logger;
+    state: T;
+    protected readonly call: Call;
+    protected readonly trackType: TrackType;
     protected subscriptions: Function[];
     private isTrackStoppedDueToTrackEnd;
     private filters;

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

@@ -1,4 +1,5 @@
 import { BehaviorSubject, Observable } from 'rxjs';
+import { Tracer } from '../stats';
 export declare class SpeakerState {
     protected selectedDeviceSubject: BehaviorSubject<string>;
     protected volumeSubject: BehaviorSubject<number>;
@@ -18,7 +19,8 @@ export declare class SpeakerState {
      * Note: this feature is not supported in React Native
      */
     volume$: Observable<number>;
-    constructor();
+    private tracer;
+    constructor(tracer: Tracer);
     /**
      * The currently selected device
      *

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

@@ -1,4 +1,5 @@
 import { BrowserPermission } from './BrowserPermission';
+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.
@@ -39,31 +40,30 @@ export declare const getAudioOutputDevices: () => import("rxjs").Observable<Medi
  * Returns an audio media stream that fulfills the given constraints.
  * If no constraints are provided, it uses the browser's default ones.
  *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
  * @param trackConstraints the constraints to use when requesting the stream.
- * @returns the new `MediaStream` fulfilling the given constraints.
+ * @param tracer the tracer to use for tracing the stream creation.
+ * @returns a new `MediaStream` fulfilling the given constraints.
  */
-export declare const getAudioStream: (trackConstraints?: MediaTrackConstraints) => Promise<MediaStream>;
+export declare const getAudioStream: (trackConstraints?: MediaTrackConstraints, tracer?: Tracer) => Promise<MediaStream>;
 /**
  * Returns a video media stream that fulfills the given constraints.
  * If no constraints are provided, it uses the browser's default ones.
  *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
  * @param trackConstraints the constraints to use when requesting the stream.
+ * @param tracer the tracer to use for tracing the stream creation.
  * @returns a new `MediaStream` fulfilling the given constraints.
  */
-export declare const getVideoStream: (trackConstraints?: MediaTrackConstraints) => Promise<MediaStream>;
+export declare const getVideoStream: (trackConstraints?: MediaTrackConstraints, tracer?: Tracer) => Promise<MediaStream>;
 /**
  * Prompts the user for a permission to share a screen.
  * If the user grants the permission, a screen sharing stream is returned. Throws otherwise.
  *
  * The callers of this API are responsible to handle the possible errors.
  *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- *
  * @param options any additional options to pass to the [`getDisplayMedia`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia) API.
+ * @param tracer the tracer to use for tracing the stream creation.
  */
-export declare const getScreenShareStream: (options?: DisplayMediaStreamOptions) => Promise<MediaStream>;
+export declare const getScreenShareStream: (options?: DisplayMediaStreamOptions, tracer?: Tracer | undefined) => Promise<MediaStream>;
 export declare const deviceIds$: import("rxjs").Observable<MediaDeviceInfo[]> | undefined;
 /**
  * Deactivates MediaStream (stops and removes tracks) to be later garbage collected

package/dist/src/events/call.d.ts

@@ -1,5 +1,5 @@
 import { Call } from '../Call';
-import type { CallAcceptedEvent, CallRejectedEvent } from '../gen/coordinator';
+import { CallAcceptedEvent, CallRejectedEvent } from '../gen/coordinator';
 /**
  * Event handler that watched the delivery of `call.accepted`.
  * Once the event is received, the call is joined.

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -285,6 +285,14 @@ export interface PublishOption {
      * @generated from protobuf field: int32 id = 8;
      */
     id: number;
+    /**
+     * If true, instructs the publisher to send only the highest available simulcast layer,
+     * disabling all lower layers. This applies to simulcast encodings.
+     * For SVC codecs, prefer using the L1T3 (single spatial, 3 temporal layers) mode instead.
+     *
+     * @generated from protobuf field: bool use_single_layer = 9;
+     */
+    useSingleLayer: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Codec

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

@@ -32,6 +32,7 @@ export declare abstract class BasePeerConnection {
     readonly stats: StatsTracer;
     private readonly subscriptions;
     private unsubscribeIceTrickle?;
+    protected readonly lock: string;
     /**
      * Constructs a new `BasePeerConnection` instance.
      */

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

@@ -1,6 +1,7 @@
 import { StreamSfuClient } from '../StreamSfuClient';
 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';
@@ -12,6 +13,7 @@ export type SfuStatsReporterOptions = {
     microphone: MicrophoneManager;
     camera: CameraManager;
     state: CallState;
+    tracer: Tracer;
     unifiedSessionId: string;
 };
 export declare class SfuStatsReporter {
@@ -23,6 +25,7 @@ export declare class SfuStatsReporter {
     private readonly microphone;
     private readonly camera;
     private readonly state;
+    private readonly tracer;
     private readonly unifiedSessionId;
     private intervalId;
     private timeoutId;
@@ -32,7 +35,7 @@ export declare class SfuStatsReporter {
     private readonly sdkVersion;
     private readonly webRTCVersion;
     private readonly inputDevices;
-    constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, unifiedSessionId, }: SfuStatsReporterOptions);
+    constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }: SfuStatsReporterOptions);
     private observeDevice;
     sendConnectionTime: (connectionTimeSeconds: number) => void;
     sendReconnectionTime: (strategy: WebsocketReconnectStrategy, timeSeconds: number) => void;
@@ -40,5 +43,6 @@ export declare class SfuStatsReporter {
     private run;
     start: () => void;
     stop: () => void;
+    flush: () => void;
     scheduleOne: (timeout: number) => void;
 }

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

@@ -5,6 +5,20 @@ import { ClientDetails, Sdk } from '../gen/video/sfu/models/models';
  * @param report the report to flatten.
  */
 export declare const flatten: (report: RTCStatsReport) => RTCStats[];
+/**
+ * Dump the provided MediaStream into a JSON object.
+ */
+export declare const dumpStream: (stream: MediaStream) => {
+    id: string;
+    tracks: {
+        id: string;
+        kind: string;
+        label: string;
+        enabled: boolean;
+        muted: boolean;
+        readyState: MediaStreamTrackState;
+    }[];
+};
 export declare const getSdkSignature: (clientDetails: ClientDetails) => {
     os?: import("../gen/video/sfu/models/models").OS;
     browser?: import("../gen/video/sfu/models/models").Browser;

package/index.ts

@@ -1,9 +1,5 @@
 import 'webrtc-adapter';
 
-// side effect: we patch the mediaDevices APIs here
-// so we can intercept invocations and collect statistics
-import './src/stats/rtc/mediaDevices';
-
 export * from './src/gen/coordinator';
 export * from './src/coordinator/connection/types';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.21.0",
+  "version": "1.22.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -40,19 +40,19 @@
     "@openapitools/openapi-generator-cli": "^2.13.4",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@stream-io/audio-filters-web": "^0.2.3",
-    "@stream-io/node-sdk": "^0.4.19",
+    "@stream-io/audio-filters-web": "^0.3.0",
+    "@stream-io/node-sdk": "^0.4.24",
     "@types/sdp-transform": "^2.4.9",
     "@types/ua-parser-js": "^0.7.39",
-    "@vitest/coverage-v8": "^3.0.9",
-    "dotenv": "^16.4.7",
+    "@vitest/coverage-v8": "^3.1.3",
+    "dotenv": "^16.5.0",
     "happy-dom": "^11.0.2",
     "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
-    "rollup": "^4.36.0",
-    "typescript": "^5.8.2",
-    "vite": "^6.2.2",
-    "vitest": "^3.0.9",
-    "vitest-mock-extended": "^3.0.1"
+    "rollup": "^4.40.2",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vitest": "^3.1.3",
+    "vitest-mock-extended": "^3.1.0"
   }
 }

package/src/Call.ts

@@ -120,8 +120,8 @@ import {
   getSdkSignature,
   SfuStatsReporter,
   StatsReporter,
+  Tracer,
 } from './stats';
-import { tracer as mediaStatsTracer } from './stats/rtc/mediaDevices';
 import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
 import { CallTypes } from './CallType';
@@ -220,6 +220,7 @@ export class Call {
    * The permissions context of this call.
    */
   readonly permissionsContext = new PermissionsContext();
+  readonly tracer = new Tracer(null);
   readonly logger: Logger;
 
   /**
@@ -590,6 +591,7 @@ export class Call {
       this.statsReporter?.stop();
       this.statsReporter = undefined;
 
+      this.sfuStatsReporter?.flush();
       this.sfuStatsReporter?.stop();
       this.sfuStatsReporter = undefined;
 
@@ -1012,7 +1014,7 @@ export class Call {
       );
     }
 
-    if (performingRejoin) {
+    if (performingRejoin && isWsHealthy) {
       const strategy = WebsocketReconnectStrategy[this.reconnectStrategy];
       await previousSfuClient?.leaveAndClose(
         `Closing previous WS after reconnect with strategy: ${strategy}`,
@@ -1225,7 +1227,6 @@ export class Call {
       });
     }
 
-    mediaStatsTracer.setEnabled(enableTracing);
     this.statsReporter?.stop();
     this.statsReporter = createStatsReporter({
       subscriber: this.subscriber,
@@ -1234,6 +1235,7 @@ export class Call {
       datacenter: sfuClient.edgeName,
     });
 
+    this.tracer.setEnabled(enableTracing);
     this.sfuStatsReporter?.stop();
     if (statsOptions?.reporting_interval_ms > 0) {
       this.unifiedSessionId ??= sfuClient.sessionId;
@@ -1245,6 +1247,7 @@ export class Call {
         microphone: this.microphone,
         camera: this.camera,
         state: this.state,
+        tracer: this.tracer,
         unifiedSessionId: this.unifiedSessionId,
       });
       this.sfuStatsReporter.start();
@@ -1336,16 +1339,12 @@ export class Call {
   ): Promise<void> => {
     if (
       this.state.callingState === CallingState.RECONNECTING ||
+      this.state.callingState === CallingState.MIGRATING ||
       this.state.callingState === CallingState.RECONNECTING_FAILED
     )
       return;
 
     return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
-      this.logger(
-        'info',
-        `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[strategy]}`,
-      );
-
       const reconnectStartTime = Date.now();
       this.reconnectStrategy = strategy;
       this.reconnectReason = reason;
@@ -1372,6 +1371,12 @@ export class Call {
         try {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
+
+          this.logger(
+            'info',
+            `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`,
+          );
+
           switch (this.reconnectStrategy) {
             case WebsocketReconnectStrategy.UNSPECIFIED:
             case WebsocketReconnectStrategy.DISCONNECT:
@@ -1426,6 +1431,7 @@ export class Call {
         this.state.callingState !== CallingState.RECONNECTING_FAILED &&
         this.state.callingState !== CallingState.LEFT
       );
+      this.logger('info', '[Reconnect] Reconnection flow finished');
     });
   };
 
@@ -1548,6 +1554,7 @@ export class Call {
     const unregisterNetworkChanged = this.streamClient.on(
       'network.changed',
       (e) => {
+        this.tracer.trace('network.changed', e);
         if (!e.online) {
           this.logger('debug', '[Reconnect] Going offline');
           if (!this.hasJoinedOnce) return;

package/src/devices/CameraManager.ts

@@ -33,30 +33,34 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
    * @param direction the direction of the camera to select.
    */
   async selectDirection(direction: Exclude<CameraDirection, undefined>) {
-    if (this.isDirectionSupportedByDevice()) {
-      if (isReactNative()) {
-        const videoTrack = this.getTracks()[0];
-        if (!videoTrack) {
-          this.logger('warn', 'No video track found to do direction selection');
-          return;
-        }
-        await videoTrack.applyConstraints({
-          facingMode: direction === 'front' ? 'user' : 'environment',
-        });
-        this.state.setDirection(direction);
-        this.state.setDevice(undefined);
-      } else {
-        // web mobile
-        this.state.setDirection(direction);
-        // Providing both device id and direction doesn't work, so we deselect the device
-        this.state.setDevice(undefined);
-        this.getTracks().forEach((track) => {
-          track.stop();
-        });
+    if (!this.isDirectionSupportedByDevice()) {
+      this.logger('warn', 'Setting direction is not supported on this device');
+      return;
+    }
+
+    // providing both device id and direction doesn't work, so we deselect the device
+    this.state.setDirection(direction);
+    this.state.setDevice(undefined);
+
+    if (isReactNative()) {
+      const videoTrack = this.getTracks()[0] as MediaStreamTrack | undefined;
+      await videoTrack?.applyConstraints({
+        facingMode: direction === 'front' ? 'user' : 'environment',
+      });
+      return;
+    }
+
+    this.getTracks().forEach((track) => track.stop());
+    try {
+      await this.unmuteStream();
+    } catch (error) {
+      if (error instanceof Error && error.name === 'NotReadableError') {
+        // the camera is already in use, and the device can't use it unless it's released.
+        // in that case, we need to stop the stream and start it again.
+        await this.muteStream();
         await this.unmuteStream();
       }
-    } else {
-      this.logger('warn', 'Camera direction ignored for desktop devices');
+      throw error;
     }
   }
 
@@ -158,6 +162,6 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
       constraints.facingMode =
         this.state.direction === 'front' ? 'user' : 'environment';
     }
-    return getVideoStream(constraints);
+    return getVideoStream(constraints, this.call.tracer);
   }
 }

package/src/devices/InputMediaDeviceManager.ts

@@ -30,6 +30,10 @@ export abstract class InputMediaDeviceManager<
   stopOnLeave = true;
   logger: Logger;
 
+  state: T;
+
+  protected readonly call: Call;
+  protected readonly trackType: TrackType;
   protected subscriptions: Function[] = [];
   private isTrackStoppedDueToTrackEnd = false;
   private filters: MediaStreamFilterEntry[] = [];
@@ -38,11 +42,10 @@ export abstract class InputMediaDeviceManager<
     'filterRegistrationConcurrencyTag',
   );
 
-  protected constructor(
-    protected readonly call: Call,
-    public readonly state: T,
-    protected readonly trackType: TrackType,
-  ) {
+  protected constructor(call: Call, state: T, trackType: TrackType) {
+    this.call = call;
+    this.state = state;
+    this.trackType = trackType;
     this.logger = getLogger([`${TrackType[trackType].toLowerCase()} manager`]);
     if (
       deviceIds$ &&

package/src/devices/MicrophoneManager.ts

@@ -235,7 +235,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   protected getStream(
     constraints: MediaTrackConstraints,
   ): Promise<MediaStream> {
-    return getAudioStream(constraints);
+    return getAudioStream(constraints, this.call.tracer);
   }
 
   private async startSpeakingWhileMutedDetection(deviceId?: string) {

package/src/devices/ScreenShareManager.ts

@@ -76,7 +76,7 @@ export class ScreenShareManager extends InputMediaDeviceManager<
     if (!this.state.audioEnabled) {
       constraints.audio = false;
     }
-    return getScreenShareStream(constraints);
+    return getScreenShareStream(constraints, this.call.tracer);
   }
 
   protected async stopPublishStream(): Promise<void> {
@@ -90,6 +90,6 @@ export class ScreenShareManager extends InputMediaDeviceManager<
    * Overrides the default `select` method to throw an error.
    */
   async select(): Promise<void> {
-    throw new Error('This method is not supported in for Screen Share');
+    throw new Error('Not supported');
   }
 }

package/src/devices/SpeakerManager.ts

@@ -5,12 +5,13 @@ import { SpeakerState } from './SpeakerState';
 import { deviceIds$, getAudioOutputDevices } from './devices';
 
 export class SpeakerManager {
-  public readonly state = new SpeakerState();
+  readonly state: SpeakerState;
   private subscriptions: Subscription[] = [];
   private readonly call: Call;
 
   constructor(call: Call) {
     this.call = call;
+    this.state = new SpeakerState(call.tracer);
     if (deviceIds$ && !isReactNative()) {
       this.subscriptions.push(
         combineLatest([deviceIds$!, this.state.selectedDevice$]).subscribe(

package/src/devices/SpeakerState.ts

@@ -1,7 +1,7 @@
 import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
 import { RxUtils } from '../store';
 import { checkIfAudioOutputChangeSupported } from './devices';
-import { tracer as mediaStatsTracer } from '../stats/rtc/mediaDevices';
+import { Tracer } from '../stats';
 
 export class SpeakerState {
   protected selectedDeviceSubject = new BehaviorSubject<string>('');
@@ -25,7 +25,10 @@ export class SpeakerState {
    */
   volume$: Observable<number>;
 
-  constructor() {
+  private tracer: Tracer;
+
+  constructor(tracer: Tracer) {
+    this.tracer = tracer;
     this.selectedDevice$ = this.selectedDeviceSubject
       .asObservable()
       .pipe(distinctUntilChanged());
@@ -58,7 +61,7 @@ export class SpeakerState {
    */
   setDevice(deviceId: string) {
     RxUtils.setCurrentValue(this.selectedDeviceSubject, deviceId);
-    mediaStatsTracer.trace('navigator.mediaDevices.setSinkId', deviceId);
+    this.tracer.trace('navigator.mediaDevices.setSinkId', deviceId);
   }
 
   /**

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

@@ -14,6 +14,7 @@ import { TrackType } from '../../gen/video/sfu/models/models';
 import { CameraManager } from '../CameraManager';
 import { of } from 'rxjs';
 import { PermissionsContext } from '../../permissions';
+import { Tracer } from '../../stats';
 
 const getVideoStream = vi.hoisted(() =>
   vi.fn(() => Promise.resolve(mockVideoStream())),
@@ -78,11 +79,14 @@ describe('CameraManager', () => {
   it('get stream', async () => {
     await manager.enable();
 
-    expect(getVideoStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-      width: 1280,
-      height: 720,
-    });
+    expect(getVideoStream).toHaveBeenCalledWith(
+      {
+        deviceId: undefined,
+        width: 1280,
+        height: 720,
+      },
+      expect.any(Tracer),
+    );
   });
 
   it('should get device id from stream', async () => {
@@ -133,29 +137,38 @@ describe('CameraManager', () => {
 
     await manager.enable();
 
-    expect(getVideoStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-      width: 1280,
-      height: 720,
-    });
+    expect(getVideoStream).toHaveBeenCalledWith(
+      {
+        deviceId: undefined,
+        width: 1280,
+        height: 720,
+      },
+      expect.any(Tracer),
+    );
 
     await manager.selectDirection('front');
 
-    expect(getVideoStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-      width: 1280,
-      height: 720,
-      facingMode: 'user',
-    });
+    expect(getVideoStream).toHaveBeenCalledWith(
+      {
+        deviceId: undefined,
+        width: 1280,
+        height: 720,
+        facingMode: 'user',
+      },
+      expect.any(Tracer),
+    );
 
     await manager.selectDirection('back');
 
-    expect(getVideoStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-      facingMode: 'environment',
-      width: 1280,
-      height: 720,
-    });
+    expect(getVideoStream).toHaveBeenCalledWith(
+      {
+        deviceId: undefined,
+        facingMode: 'environment',
+        width: 1280,
+        height: 720,
+      },
+      expect.any(Tracer),
+    );
   });
 
   it(`shouldn't set deviceId and facingMode at the same time`, async () => {
@@ -163,11 +176,14 @@ describe('CameraManager', () => {
 
     await manager.flip();
 
-    expect(getVideoStream).toHaveBeenCalledWith({
-      facingMode: 'environment',
-      width: 1280,
-      height: 720,
-    });
+    expect(getVideoStream).toHaveBeenCalledWith(
+      {
+        facingMode: 'environment',
+        width: 1280,
+        height: 720,
+      },
+      expect.any(Tracer),
+    );
 
     const deviceId = mockVideoDevices[1].deviceId;
     await manager.select(deviceId);

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

@@ -24,6 +24,7 @@ import {
   SoundStateChangeHandler,
 } from '../../helpers/sound-detector';
 import { PermissionsContext } from '../../permissions';
+import { Tracer } from '../../stats';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices API');
@@ -92,9 +93,10 @@ describe('MicrophoneManager', () => {
   it('get stream', async () => {
     await manager.enable();
 
-    expect(getAudioStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-    });
+    expect(getAudioStream).toHaveBeenCalledWith(
+      { deviceId: undefined },
+      expect.any(Tracer),
+    );
   });
 
   it('should get device id from stream', async () => {