@stream-io/video-client 1.50.0 → 1.52.0

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

@@ -64,11 +64,11 @@ describe('Subscriber', () => {
     });
   });
 
-  afterEach(() => {
+  afterEach(async () => {
     vi.useRealTimers();
     vi.clearAllMocks();
     vi.resetModules();
-    subscriber.dispose();
+    await subscriber.dispose();
   });
 
   describe('Subscriber ICE restart', () => {
@@ -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/helpers/__tests__/degradationPreference.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import { DegradationPreference } from '../../../gen/video/sfu/models/models';
-import { toRTCDegradationPreference } from '../degradationPreference';
+import {
+  fromRTCDegradationPreference,
+  toRTCDegradationPreference,
+} from '../degradationPreference';
 
 describe('toRTCDegradationPreference', () => {
   it.each([
@@ -21,3 +24,32 @@ describe('toRTCDegradationPreference', () => {
     ).toBeUndefined();
   });
 });
+
+describe('fromRTCDegradationPreference', () => {
+  it.each([
+    ['balanced', DegradationPreference.BALANCED],
+    ['maintain-framerate', DegradationPreference.MAINTAIN_FRAMERATE],
+    ['maintain-resolution', DegradationPreference.MAINTAIN_RESOLUTION],
+    [
+      'maintain-framerate-and-resolution',
+      DegradationPreference.MAINTAIN_FRAMERATE_AND_RESOLUTION,
+    ],
+  ] as const)('maps "%s" to %s', (preference, expected) => {
+    // @ts-expect-error not in the lib types yet
+    expect(fromRTCDegradationPreference(preference)).toBe(expected);
+  });
+
+  it('returns UNSPECIFIED for undefined', () => {
+    expect(fromRTCDegradationPreference(undefined)).toBe(
+      DegradationPreference.UNSPECIFIED,
+    );
+  });
+
+  it('returns UNSPECIFIED for an unknown value', () => {
+    expect(
+      fromRTCDegradationPreference(
+        'something-else' as unknown as RTCDegradationPreference,
+      ),
+    ).toBe(DegradationPreference.UNSPECIFIED);
+  });
+});

package/src/rtc/helpers/degradationPreference.ts

@@ -20,3 +20,21 @@ export const toRTCDegradationPreference = (
       ensureExhausted(preference, 'Unknown degradation preference');
   }
 };
+
+export const fromRTCDegradationPreference = (
+  preference: RTCDegradationPreference | undefined,
+): DegradationPreference => {
+  switch (preference) {
+    case 'balanced':
+      return DegradationPreference.BALANCED;
+    case 'maintain-framerate':
+      return DegradationPreference.MAINTAIN_FRAMERATE;
+    case 'maintain-resolution':
+      return DegradationPreference.MAINTAIN_RESOLUTION;
+    // @ts-expect-error not in the typedefs yet
+    case 'maintain-framerate-and-resolution':
+      return DegradationPreference.MAINTAIN_FRAMERATE_AND_RESOLUTION;
+    default:
+      return DegradationPreference.UNSPECIFIED;
+  }
+};

package/src/rtc/types.ts

@@ -9,6 +9,7 @@ import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
+import type { VideoSender } from '../gen/video/sfu/event/events';
 
 /**
  * Canonical reasons the SDK uses to trigger a reconnection. Free-form strings
@@ -63,6 +64,7 @@ export type BasePeerConnectionOpts = {
   enableTracing: boolean;
   iceRestartDelay?: number;
   clientPublishOptions?: ClientPublishOptions;
+  statsTimestampDriftThresholdMs?: number;
 };
 
 export type TrackPublishOptions = {
@@ -73,6 +75,7 @@ export type PublishBundle = {
   publishOption: PublishOption;
   transceiver: RTCRtpTransceiver;
   options: TrackPublishOptions;
+  videoSender?: VideoSender;
 };
 
 export type TrackLayersCache = {

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);
+  });
+});