@stream-io/video-client 1.51.0 → 1.52.0

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: browserVersion,
   };
 };

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/Subscriber.ts

@@ -196,6 +196,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);
+  });
+});