@stream-io/video-client 1.51.0 → 1.52.1-beta.0

package/src/helpers/__tests__/DynascaleManager.test.ts

@@ -23,6 +23,14 @@ import { VisibilityState } from '../../types';
 import { noopComparator } from '../../sorting';
 import { TrackType } from '../../gen/video/sfu/models/models';
 
+vi.mock(import('../browsers'), async (importOriginal) => {
+  const module = await importOriginal();
+  return {
+    ...module,
+    isSafari: () => globalThis._isSafari ?? false,
+  };
+});
+
 describe('DynascaleManager', () => {
   let dynascaleManager: DynascaleManager;
   let call: Call;
@@ -50,13 +58,6 @@ describe('DynascaleManager', () => {
     beforeEach(() => {
       // Mock global isSafari to false for testing
       globalThis._isSafari = false;
-      vi.mock(import('../browsers'), async (importOriginal) => {
-        const module = await importOriginal();
-        return {
-          ...module,
-          isSafari: () => globalThis._isSafari ?? false,
-        };
-      });
 
       dynascaleManager.setUseWebAudio(false);
 

package/src/helpers/__tests__/browsers.test.ts

@@ -9,6 +9,10 @@ import {
 import { getClientDetails } from '../client-details';
 import { ClientDetails } from '../../gen/video/sfu/models/models';
 
+vi.mock('../client-details', () => ({
+  getClientDetails: vi.fn(),
+}));
+
 describe('browsers', () => {
   beforeEach(() => {
     Object.defineProperty(globalThis, 'navigator', {
@@ -156,10 +160,6 @@ describe('browsers', () => {
   });
 
   describe('isSupportedBrowser', () => {
-    vi.mock('../client-details', () => ({
-      getClientDetails: vi.fn(),
-    }));
-
     it('should return false if browser is undefined', async () => {
       vi.mocked(getClientDetails).mockResolvedValue({
         browser: undefined,

package/src/helpers/__tests__/participantUtils.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import {
   hasAudio,
+  hasInterruptedTrack,
   hasPausedTrack,
   hasScreenShare,
   hasScreenShareAudio,
@@ -120,6 +121,52 @@ describe('participantUtils', () => {
     });
   });
 
+  describe('hasInterruptedTrack', () => {
+    it('returns true when the track is both interrupted and published', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO],
+        interruptedTracks: [TrackType.AUDIO],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(true);
+    });
+
+    it('returns false when the track is interrupted but no longer published', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [],
+        interruptedTracks: [TrackType.AUDIO],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+    });
+
+    it('returns false when the track is published but not interrupted', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO],
+        interruptedTracks: [],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+    });
+
+    it('returns false when interruptedTracks is undefined', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO],
+        interruptedTracks: undefined,
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+    });
+
+    it('checks each track type independently', () => {
+      const participant = createMockParticipant({
+        publishedTracks: [TrackType.AUDIO, TrackType.VIDEO],
+        interruptedTracks: [TrackType.VIDEO],
+      });
+      expect(hasInterruptedTrack(participant, TrackType.AUDIO)).toBe(false);
+      expect(hasInterruptedTrack(participant, TrackType.VIDEO)).toBe(true);
+      expect(hasInterruptedTrack(participant, TrackType.SCREEN_SHARE)).toBe(
+        false,
+      );
+    });
+  });
+
   describe('hasPausedTrack', () => {
     it('should return true when participant has paused VIDEO track', () => {
       const participant = createMockParticipant({

package/src/helpers/client-details.ts

@@ -137,6 +137,7 @@ export const getClientDetails = async (): Promise<ClientDetails> => {
       sdk: sdkInfo,
       os: osInfo,
       device: deviceInfo,
+      webrtcVersion: webRtcInfo?.version || '',
     };
   }
 
@@ -173,11 +174,12 @@ export const getClientDetails = async (): Promise<ClientDetails> => {
   const uaBrowser = userAgentData?.fullVersionList?.find(
     (v) => !v.brand.includes('Chromium') && !v.brand.match(/[()\-./:;=?_]/g),
   );
+  const browserVersion = uaBrowser?.version || browser.version || '';
   return {
     sdk: sdkInfo,
     browser: {
       name: uaBrowser?.brand || browser.name || navigator.userAgent,
-      version: uaBrowser?.version || browser.version || '',
+      version: browserVersion,
     },
     os: {
       name: userAgentData?.platform || os.name || '',
@@ -190,5 +192,6 @@ export const getClientDetails = async (): Promise<ClientDetails> => {
         .join(' '),
       version: '',
     },
+    webrtcVersion: webRtcInfo?.version || '',
   };
 };

package/src/helpers/participantUtils.ts

@@ -41,6 +41,21 @@ export const hasScreenShareAudio = (p: StreamVideoParticipant): boolean =>
 export const isPinned = (p: StreamVideoParticipant): boolean =>
   !!p.pin && (p.pin.isLocalPin || p.pin.pinnedAt > 0);
 
+/**
+ * Check if a participant has a track that is currently interrupted: the
+ * participant intends to publish it (it is in `publishedTracks`) but no
+ * media is flowing right now (it is in `interruptedTracks`).
+ *
+ * @param p the participant to check.
+ * @param trackType the track type to check.
+ */
+export const hasInterruptedTrack = (
+  p: StreamVideoParticipant,
+  trackType: TrackType,
+): boolean =>
+  !!p.interruptedTracks?.includes(trackType) &&
+  p.publishedTracks.includes(trackType);
+
 /**
  * Check if a participant has a paused track of the specified type.
  *

package/src/rtc/BasePeerConnection.ts

@@ -69,6 +69,7 @@ export abstract class BasePeerConnection {
       enableTracing,
       clientPublishOptions,
       iceRestartDelay = 2500,
+      statsTimestampDriftThresholdMs = 0,
     }: BasePeerConnectionOpts,
   ) {
     this.peerType = peerType;
@@ -85,7 +86,12 @@ export abstract class BasePeerConnection {
       { tags: [tag] },
     );
     this.pc = this.createPeerConnection(connectionConfig);
-    this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
+    this.stats = new StatsTracer(
+      this.pc,
+      peerType,
+      this.trackIdToTrackType,
+      statsTimestampDriftThresholdMs,
+    );
     if (enableTracing) {
       this.tracer = new Tracer(
         `${tag}-${peerType === PeerType.SUBSCRIBER ? 'sub' : 'pub'}`,

package/src/rtc/Publisher.ts

@@ -39,6 +39,7 @@ export class Publisher extends BasePeerConnection {
   private readonly transceiverCache = new TransceiverCache();
   private readonly clonedTracks = new Set<MediaStreamTrack>();
   private publishOptions: PublishOption[];
+  private readonly selfSubEnabled: boolean;
 
   /**
    * Constructs a new `Publisher` instance.
@@ -46,9 +47,11 @@ export class Publisher extends BasePeerConnection {
   constructor(
     baseOptions: BasePeerConnectionOpts,
     publishOptions: PublishOption[],
+    opts: { selfSubEnabled?: boolean } = {},
   ) {
     super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
     this.publishOptions = publishOptions;
+    this.selfSubEnabled = opts.selfSubEnabled ?? false;
 
     this.on('iceRestart', (iceRestart) => {
       if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED) return;
@@ -576,6 +579,7 @@ export class Publisher extends BasePeerConnection {
       muted: !isTrackLive,
       codec: publishOption.codec,
       publishOptionId: publishOption.id,
+      selfSubAudioVideo: this.selfSubEnabled,
     };
   };
 

package/src/rtc/Subscriber.ts

@@ -14,6 +14,14 @@ import { enableStereo, removeCodecsExcept } from './helpers/sdp';
  * @internal
  */
 export class Subscriber extends BasePeerConnection {
+  /**
+   * Remote streams received from the SFU. For a self-sub case
+   * we need to be able to distinguish between the local capture stream.
+   * The map will never contain local streams so we can safely use it to
+   * check if the stream is remote and dispose it when needed.
+   */
+  private trackedStreams: WeakSet<MediaStream> = new WeakSet();
+
   /**
    * Constructs a new `Subscriber` instance.
    */
@@ -75,6 +83,7 @@ export class Subscriber extends BasePeerConnection {
     const participantToUpdate = this.state.participants.find(
       (p) => p.trackLookupPrefix === trackId,
     );
+    const isSelfSub = !!participantToUpdate?.isLocalParticipant;
     this.logger.debug(
       `[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`,
       track.id,
@@ -107,6 +116,10 @@ export class Subscriber extends BasePeerConnection {
 
     this.trackIdToTrackType.set(track.id, trackType);
 
+    if (isSelfSub) {
+      this.trackedStreams.add(primaryStream);
+    }
+
     if (!participantToUpdate) {
       this.logger.warn(
         `[onTrack]: Received track for unknown participant: ${trackId}`,
@@ -127,6 +140,13 @@ export class Subscriber extends BasePeerConnection {
       return;
     }
 
+    // Self-sub loopback audio routes to the speaker by default, which
+    // would echo the local user's voice. Default-mute here; consumers
+    // (the loopback recording hook) re-enable explicitly when needed.
+    if (isSelfSub && e.track.kind === 'audio') {
+      e.track.enabled = false;
+    }
+
     // get the previous stream to dispose it later
     // usually this happens during migration, when the stream is replaced
     // with a new one but the old one is still in the state
@@ -137,8 +157,15 @@ export class Subscriber extends BasePeerConnection {
       [streamKindProp]: primaryStream,
     });
 
-    // now, dispose the previous stream if it exists
     if (previousStream) {
+      if (isSelfSub && !this.trackedStreams.has(previousStream)) {
+        // this is the local capture stream, we don't want to dispose it
+        this.logger.debug(
+          `[onTrack]: Skipping cleanup of previous ${e.track.kind} stream for userId: ${participantToUpdate.userId} because it is not tracked`,
+        );
+        return;
+      }
+
       this.logger.info(
         `[onTrack]: Cleaning up previous remote ${track.kind} tracks for userId: ${participantToUpdate.userId}`,
       );
@@ -196,6 +223,7 @@ export class Subscriber extends BasePeerConnection {
     await this.sfuClient.sendAnswer({
       peerType: PeerType.SUBSCRIBER,
       sdp: answer.sdp || '',
+      negotiationId: subscriberOffer.negotiationId,
     });
 
     this.isIceRestarting = false;

package/src/rtc/__tests__/Subscriber.test.ts

@@ -425,7 +425,10 @@ describe('Subscriber', () => {
         .mockResolvedValue({ sdp: 'answer-sdp' });
       vi.spyOn(subscriber['pc'], 'setRemoteDescription').mockResolvedValue();
 
-      const offer = SubscriberOffer.create({ sdp: 'offer-sdp' });
+      const offer = SubscriberOffer.create({
+        sdp: 'offer-sdp',
+        negotiationId: 42,
+      });
       // @ts-expect-error - private method
       await subscriber.negotiate(offer);
       expect(subscriber['pc'].setRemoteDescription).toHaveBeenCalledWith({
@@ -437,6 +440,7 @@ describe('Subscriber', () => {
       expect(sfuClient.sendAnswer).toHaveBeenCalledWith({
         peerType: PeerType.SUBSCRIBER,
         sdp: 'answer-sdp',
+        negotiationId: 42,
       });
     });
   });

package/src/rtc/__tests__/mocks/webrtc.mocks.ts

@@ -1,6 +1,6 @@
 import { vi } from 'vitest';
 
-const RTCPeerConnectionMock = vi.fn((): Partial<RTCPeerConnection> => {
+const RTCPeerConnectionMock = vi.fn(function (): Partial<RTCPeerConnection> {
   return {
     addEventListener: vi.fn(),
     addIceCandidate: vi.fn(),
@@ -23,7 +23,7 @@ const RTCPeerConnectionMock = vi.fn((): Partial<RTCPeerConnection> => {
 });
 vi.stubGlobal('RTCPeerConnection', RTCPeerConnectionMock);
 
-const MediaStreamMock = vi.fn((): Partial<MediaStream> => {
+const MediaStreamMock = vi.fn(function (): Partial<MediaStream> {
   return {
     getTracks: vi.fn().mockReturnValue([]),
     addTrack: vi.fn(),
@@ -34,7 +34,7 @@ const MediaStreamMock = vi.fn((): Partial<MediaStream> => {
 });
 vi.stubGlobal('MediaStream', MediaStreamMock);
 
-const MediaStreamTrackMock = vi.fn((): Partial<MediaStreamTrack> => {
+const MediaStreamTrackMock = vi.fn(function (): Partial<MediaStreamTrack> {
   return {
     addEventListener: vi.fn(),
     removeEventListener: vi.fn(),
@@ -49,7 +49,7 @@ const MediaStreamTrackMock = vi.fn((): Partial<MediaStreamTrack> => {
 });
 vi.stubGlobal('MediaStreamTrack', MediaStreamTrackMock);
 
-const RTCRtpTransceiverMock = vi.fn((): Partial<RTCRtpTransceiver> => {
+const RTCRtpTransceiverMock = vi.fn(function (): Partial<RTCRtpTransceiver> {
   return {
     // @ts-expect-error - incomplete mock
     sender: {
@@ -64,24 +64,25 @@ const RTCRtpTransceiverMock = vi.fn((): Partial<RTCRtpTransceiver> => {
 });
 vi.stubGlobal('RTCRtpTransceiver', RTCRtpTransceiverMock);
 
-const RTCTrackEvent = vi.fn(
-  (type: string, eventInitDict: RTCTrackEventInit): Partial<RTCTrackEvent> => {
-    return {
-      type,
-      ...eventInitDict,
-    };
-  },
-);
+const RTCTrackEvent = vi.fn(function (
+  type: string,
+  eventInitDict: RTCTrackEventInit,
+): Partial<RTCTrackEvent> {
+  return {
+    type,
+    ...eventInitDict,
+  };
+});
 vi.stubGlobal('RTCTrackEvent', RTCTrackEvent);
 
-const RTCRtpReceiverMock = vi.fn((): Partial<typeof RTCRtpReceiver> => {
+const RTCRtpReceiverMock = vi.fn(function (): Partial<typeof RTCRtpReceiver> {
   return {
     getCapabilities: vi.fn(),
   };
 });
 vi.stubGlobal('RTCRtpReceiver', RTCRtpReceiverMock);
 
-const RTCRtpSenderMock = vi.fn((): Partial<typeof RTCRtpSender> => {
+const RTCRtpSenderMock = vi.fn(function (): Partial<typeof RTCRtpSender> {
   return {
     getCapabilities: vi.fn(),
     // @ts-expect-error - incomplete mock
@@ -90,7 +91,7 @@ const RTCRtpSenderMock = vi.fn((): Partial<typeof RTCRtpSender> => {
 });
 vi.stubGlobal('RTCRtpSender', RTCRtpSenderMock);
 
-const AudioContextMock = vi.fn((): Partial<AudioContext> => {
+const AudioContextMock = vi.fn(function (): Partial<AudioContext> {
   return {
     state: 'suspended',
     sinkId: '',

package/src/rtc/types.ts

@@ -64,6 +64,7 @@ export type BasePeerConnectionOpts = {
   enableTracing: boolean;
   iceRestartDelay?: number;
   clientPublishOptions?: ClientPublishOptions;
+  statsTimestampDriftThresholdMs?: number;
 };
 
 export type TrackPublishOptions = {

package/src/stats/rtc/StatsTracer.ts

@@ -19,6 +19,7 @@ export class StatsTracer {
   private readonly pc: RTCPeerConnection;
   private readonly peerType: PeerType;
   private readonly trackIdToTrackType: Map<string, TrackType>;
+  private readonly driftThresholdMs: number;
 
   private costOverrides?: Map<TrackType, number>;
 
@@ -33,10 +34,12 @@ export class StatsTracer {
     pc: RTCPeerConnection,
     peerType: PeerType,
     trackIdToTrackType: Map<string, TrackType>,
+    statsTimestampDriftThresholdMs: number = 0,
   ) {
     this.pc = pc;
     this.peerType = peerType;
     this.trackIdToTrackType = trackIdToTrackType;
+    this.driftThresholdMs = statsTimestampDriftThresholdMs;
   }
 
   /**
@@ -49,7 +52,11 @@ export class StatsTracer {
    */
   get = async (): Promise<ComputedStats> => {
     const stats = await this.pc.getStats();
-    const currentStats = toObject(stats);
+    const currentStats = toObjectWithCorrectedTimestamp(
+      stats,
+      Date.now(),
+      this.driftThresholdMs,
+    );
 
     const performanceStats = this.withOverrides(
       this.peerType === PeerType.SUBSCRIBER
@@ -213,14 +220,28 @@ export class StatsTracer {
 }
 
 /**
- * Convert the stat report to an object.
+ * Convert the stat report to an object, correcting clock drift along the way.
+ * Entries whose `timestamp` differs from `wallNow` by more than `thresholdMs`
+ * are replaced with a clone whose `timestamp` is set to `wallNow`. The platform
+ * clock backing `DOMHighResTimeStamp` can desynchronise from `Date.now()` after
+ * system sleep or clock-jump events (notably on Electron/Chromium), which
+ * corrupts the delta-compressed stats payload. A non-positive `thresholdMs`
+ * disables correction.
  *
  * @param report the stat report to convert.
+ * @param wallNow current wall-clock time used as the drift reference.
+ * @param thresholdMs maximum tolerated drift in milliseconds.
  */
-const toObject = (report: RTCStatsReport): Record<string, RTCStats> => {
+const toObjectWithCorrectedTimestamp = (
+  report: RTCStatsReport,
+  wallNow: number,
+  thresholdMs: number,
+): Record<string, RTCStats> => {
   const obj: Record<string, RTCStats> = {};
+  const correct = thresholdMs > 0;
   report.forEach((v, k) => {
-    obj[k] = v;
+    const drift = Math.abs(v.timestamp - wallNow);
+    obj[k] = correct && drift > thresholdMs ? { ...v, timestamp: wallNow } : v;
   });
   return obj;
 };

package/src/stats/rtc/__tests__/StatsTracer.test.ts

@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StatsTracer } from '../StatsTracer';
+import { PeerType } from '../../../gen/video/sfu/models/models';
+
+const WALL_NOW = 1_700_000_000_000;
+const THRESHOLD_MS = 5000;
+
+const makeReport = (
+  entries: Array<{ id: string; timestamp: number }>,
+): RTCStatsReport => {
+  const map = new Map<string, RTCStats>();
+  for (const e of entries) {
+    map.set(e.id, { id: e.id, timestamp: e.timestamp, type: 'codec' });
+  }
+  return map as unknown as RTCStatsReport;
+};
+
+const makePc = (report: RTCStatsReport) => {
+  return {
+    getStats: vi.fn().mockResolvedValue(report),
+  } as unknown as RTCPeerConnection;
+};
+
+describe('StatsTracer timestamp drift correction', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(WALL_NOW);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('keeps original timestamps when no entry drifts past the threshold', async () => {
+    const report = makeReport([
+      { id: 'a', timestamp: WALL_NOW - 1000 },
+      { id: 'b', timestamp: WALL_NOW + 2000 },
+    ]);
+    const tracer = new StatsTracer(
+      makePc(report),
+      PeerType.SUBSCRIBER,
+      new Map(),
+      THRESHOLD_MS,
+    );
+
+    const { delta } = await tracer.get();
+
+    expect(delta.timestamp).toBe(WALL_NOW + 2000);
+  });
+
+  it('replaces drifted timestamps with wall time', async () => {
+    const report = makeReport([
+      { id: 'a', timestamp: WALL_NOW },
+      { id: 'b', timestamp: WALL_NOW + 10_000 },
+    ]);
+    const tracer = new StatsTracer(
+      makePc(report),
+      PeerType.SUBSCRIBER,
+      new Map(),
+      THRESHOLD_MS,
+    );
+
+    const { delta } = await tracer.get();
+
+    expect(delta.timestamp).toBe(WALL_NOW);
+  });
+
+  it('clamps stale timestamps to wall time (past drift)', async () => {
+    const report = makeReport([
+      { id: 'a', timestamp: WALL_NOW + 2000 },
+      { id: 'b', timestamp: WALL_NOW - 10_000 },
+    ]);
+    const tracer = new StatsTracer(
+      makePc(report),
+      PeerType.SUBSCRIBER,
+      new Map(),
+      THRESHOLD_MS,
+    );
+
+    const { delta } = await tracer.get();
+
+    expect(delta['b'].timestamp).toBe(WALL_NOW);
+    expect(delta.timestamp).toBe(WALL_NOW + 2000);
+  });
+
+  it('keeps timestamps with drift exactly at the threshold (exclusive boundary)', async () => {
+    const report = makeReport([
+      { id: 'a', timestamp: WALL_NOW },
+      { id: 'b', timestamp: WALL_NOW + THRESHOLD_MS },
+    ]);
+    const tracer = new StatsTracer(
+      makePc(report),
+      PeerType.SUBSCRIBER,
+      new Map(),
+      THRESHOLD_MS,
+    );
+
+    const { delta } = await tracer.get();
+
+    expect(delta.timestamp).toBe(WALL_NOW + THRESHOLD_MS);
+  });
+
+  it('clamps remote-sourced stat types like any other stat (no special handling)', async () => {
+    const map = new Map<string, RTCStats>([
+      ['anchor', { id: 'anchor', timestamp: WALL_NOW + 2000, type: 'codec' }],
+      [
+        'remote-in',
+        {
+          id: 'remote-in',
+          timestamp: WALL_NOW - 30_000,
+          type: 'remote-inbound-rtp',
+        },
+      ],
+      [
+        'remote-out',
+        {
+          id: 'remote-out',
+          timestamp: WALL_NOW + 30_000,
+          type: 'remote-outbound-rtp',
+        },
+      ],
+    ]);
+    const tracer = new StatsTracer(
+      makePc(map as unknown as RTCStatsReport),
+      PeerType.SUBSCRIBER,
+      new Map(),
+      THRESHOLD_MS,
+    );
+
+    const { delta } = await tracer.get();
+
+    // both stale and future drift get clamped to wall time, while the
+    // within-threshold anchor stays the delta's top-level timestamp.
+    expect(delta['remote-in'].timestamp).toBe(WALL_NOW);
+    expect(delta['remote-out'].timestamp).toBe(WALL_NOW);
+    expect(delta.timestamp).toBe(WALL_NOW + 2000);
+  });
+
+  it('does not correct when the threshold is disabled (0)', async () => {
+    const report = makeReport([
+      { id: 'a', timestamp: WALL_NOW },
+      { id: 'b', timestamp: WALL_NOW + 99_999 },
+    ]);
+    const tracer = new StatsTracer(
+      makePc(report),
+      PeerType.SUBSCRIBER,
+      new Map(),
+      0,
+    );
+
+    const { delta } = await tracer.get();
+
+    expect(delta.timestamp).toBe(WALL_NOW + 99_999);
+  });
+});