livekit-client 2.21.0 → 2.22.1

package/src/room/token-source/utils.test.ts

@@ -31,6 +31,33 @@ describe('isResponseTokenValid', () => {
     );
     expect(isValid).toBe(false);
   });
+  it('should treat a jwt without exp as expired', () => {
+    const isValid = isResponseTokenValid(
+      TokenSourceResponse.fromJson({
+        serverUrl: 'ws://localhost:7800',
+        participantToken: TOKENS.NO_EXP,
+      }),
+    );
+    expect(isValid).toBe(false);
+  });
+  it('should honor exp when nbf is absent', () => {
+    const isValid = isResponseTokenValid(
+      TokenSourceResponse.fromJson({
+        serverUrl: 'ws://localhost:7800',
+        participantToken: TOKENS.EXP_IN_PAST_NO_NBF,
+      }),
+    );
+    expect(isValid).toBe(false);
+  });
+  it('should accept a non-expired jwt that omits nbf', () => {
+    const isValid = isResponseTokenValid(
+      TokenSourceResponse.fromJson({
+        serverUrl: 'ws://localhost:7800',
+        participantToken: TOKENS.VALID_NO_NBF,
+      }),
+    );
+    expect(isValid).toBe(true);
+  });
 });
 
 describe('decodeTokenPayload', () => {

package/src/room/token-source/utils.ts

@@ -7,19 +7,26 @@ const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
 
 export function isResponseTokenValid(response: TokenSourceResponse) {
   const jwtPayload = decodeTokenPayload(response.participantToken);
-  if (!jwtPayload?.nbf || !jwtPayload?.exp) {
-    return true;
+  // Missing exp: TokenSourceCached would otherwise return this response forever.
+  // nbf is optional (RFC 7519); do not skip the exp check when it is absent.
+  if (!jwtPayload?.exp) {
+    return false;
   }
 
   const now = new Date();
 
-  const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
-  const nbfDate = new Date(nbfInMilliseconds);
+  if (jwtPayload.nbf) {
+    const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
+    const nbfDate = new Date(nbfInMilliseconds);
+    if (nbfDate > now) {
+      return false;
+    }
+  }
 
   const expInMilliseconds = jwtPayload.exp * ONE_SECOND_IN_MILLISECONDS;
   const expDate = new Date(expInMilliseconds - ONE_MINUTE_IN_MILLISECONDS);
 
-  return nbfDate <= now && expDate > now;
+  return expDate > now;
 }
 
 /** Given a LiveKit generated participant token, decodes and returns the associated {@link TokenPayload} data. */

package/src/room/track/LocalAudioTrack.ts

@@ -245,12 +245,18 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
           type: 'audio',
           streamId: v.id,
           packetsSent: v.packetsSent,
-          packetsLost: v.packetsLost,
           bytesSent: v.bytesSent,
           timestamp: v.timestamp,
-          roundTripTime: v.roundTripTime,
-          jitter: v.jitter,
         };
+
+        // loss, jitter and RTT are only known from what the remote reports back,
+        // the same way the video sender picks them up
+        const remote = stats.get(v.remoteId);
+        if (remote) {
+          audioStats.packetsLost = remote.packetsLost;
+          audioStats.jitter = remote.jitter;
+          audioStats.roundTripTime = remote.roundTripTime;
+        }
       }
     });
 

package/src/room/track/LocalVideoTrack.test.ts

@@ -1,6 +1,8 @@
-import { describe, expect, it } from 'vitest';
-import { videoLayersFromEncodings } from './LocalVideoTrack';
+import { describe, expect, it, vi } from 'vitest';
+import LocalVideoTrack, { videoLayersFromEncodings } from './LocalVideoTrack';
+import type { SimulcastTrackInfo } from './LocalVideoTrack';
 import { VideoQuality } from './Track';
+import type { VideoCodec } from './options';
 
 describe('videoLayersFromEncodings', () => {
   it('returns single layer for no encoding', () => {
@@ -131,3 +133,104 @@ describe('videoLayersFromEncodings', () => {
     expect(layers[2].width).toBe(720);
   });
 });
+
+function makeSender(label = 'sender', events: string[] = []) {
+  let params: RTCRtpSendParameters = {
+    encodings: [],
+    transactionId: '',
+    codecs: [],
+    headerExtensions: [],
+    rtcp: {},
+  };
+  return {
+    getParameters: () => params,
+    // resolves on a later task, like the real setParameters, so that a caller
+    // which fails to await it never observes the update
+    setParameters: vi.fn(async (next: RTCRtpSendParameters) => {
+      events.push(`${label}:start`);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      params = next;
+      events.push(`${label}:done`);
+    }),
+    get degradationPreference() {
+      return params.degradationPreference;
+    },
+  };
+}
+
+function makeTrack() {
+  const track = Object.create(LocalVideoTrack.prototype) as LocalVideoTrack;
+  Object.assign(track, {
+    log: { debug: vi.fn(), warn: vi.fn() },
+    simulcastCodecs: new Map<VideoCodec, SimulcastTrackInfo>(),
+    subscribedCodecs: undefined,
+  });
+  // logContext and mediaStreamTrack are getters we don't set up state for here
+  Object.defineProperty(track, 'logContext', { get: () => ({}) });
+  Object.defineProperty(track, 'mediaStreamTrack', { get: () => ({ clone: () => ({}) }) });
+  return track;
+}
+
+describe('setDegradationPreference', () => {
+  it('applies the preference to the primary sender', async () => {
+    const track = makeTrack();
+    const sender = makeSender();
+    Object.assign(track, { _sender: sender });
+
+    await track.setDegradationPreference('maintain-resolution');
+
+    expect(sender.degradationPreference).toBe('maintain-resolution');
+  });
+
+  it('applies the resolved preference to a backup codec sender', async () => {
+    const track = makeTrack();
+    const primary = makeSender();
+    Object.assign(track, { _sender: primary });
+
+    await track.setDegradationPreference('maintain-resolution');
+
+    // the backup codec transceiver is created later, when the server asks for it
+    const backupInfo = track.addSimulcastTrack('vp8', [])!;
+    const backup = makeSender();
+    await track.setSimulcastTrackSender('vp8', backup as unknown as RTCRtpSender);
+
+    expect(backupInfo.sender).toBe(backup);
+    expect(backup.degradationPreference).toBe('maintain-resolution');
+    expect(primary.degradationPreference).toBe('maintain-resolution');
+  });
+
+  it('updates every sender when the preference changes after the backup is published', async () => {
+    const track = makeTrack();
+    const primary = makeSender();
+    Object.assign(track, { _sender: primary });
+    await track.setDegradationPreference('maintain-framerate');
+
+    track.addSimulcastTrack('vp8', []);
+    const backup = makeSender();
+    await track.setSimulcastTrackSender('vp8', backup as unknown as RTCRtpSender);
+
+    await track.setDegradationPreference('balanced');
+
+    expect(primary.degradationPreference).toBe('balanced');
+    expect(backup.degradationPreference).toBe('balanced');
+  });
+
+  it('applies to senders one at a time', async () => {
+    const events: string[] = [];
+    const track = makeTrack();
+    const primary = makeSender('primary', events);
+    Object.assign(track, { _sender: primary });
+    track.addSimulcastTrack('vp8', []);
+    await track.setSimulcastTrackSender(
+      'vp8',
+      makeSender('backup', events) as unknown as RTCRtpSender,
+    );
+    events.length = 0;
+
+    await track.setDegradationPreference('balanced');
+
+    // setParameters is only valid against the most recent getParameters, so the
+    // writes must not overlap
+    expect(events).toEqual(['primary:start', 'primary:done', 'backup:start', 'backup:done']);
+  });
+});

package/src/room/track/LocalVideoTrack.ts

@@ -406,15 +406,37 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
 
   async setDegradationPreference(preference: RTCDegradationPreference) {
     this.degradationPreference = preference;
-    if (this.sender) {
-      try {
-        this.log.debug(`setting degradationPreference to ${preference}`, this.logContext);
-        const params = this.sender.getParameters();
-        params.degradationPreference = preference;
-        this.sender.setParameters(params);
-      } catch (e: any) {
-        this.log.warn(`failed to set degradationPreference`, { error: e, ...this.logContext });
-      }
+    // applied one sender at a time on purpose, see applyDegradationPreference
+    await this.applyDegradationPreference(this.sender);
+    for (const sc of this.simulcastCodecs.values()) {
+      await this.applyDegradationPreference(sc.sender);
+    }
+  }
+
+  /**
+   * Degradation preference is a property of the sender, not of the track, so every sender
+   * publishing this track needs it applied separately. A backup codec publishes over its
+   * own sender, which would otherwise let the browser resolve a preference implicitly and
+   * diverge from the primary encoder.
+   *
+   * Callers apply this sequentially rather than concurrently: `setParameters` is only valid
+   * against the parameters most recently returned by `getParameters`, which is why this file
+   * serializes other sender parameter updates through `senderLock`.
+   */
+  private async applyDegradationPreference(sender?: RTCRtpSender) {
+    if (!sender) {
+      return;
+    }
+    try {
+      this.log.debug(
+        `setting degradationPreference to ${this.degradationPreference}`,
+        this.logContext,
+      );
+      const params = sender.getParameters();
+      params.degradationPreference = this.degradationPreference;
+      await sender.setParameters(params);
+    } catch (e: any) {
+      this.log.warn(`failed to set degradationPreference`, { error: e, ...this.logContext });
     }
   }
 
@@ -436,13 +458,17 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     return simulcastCodecInfo;
   }
 
-  setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender) {
+  async setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender) {
     const simulcastCodecInfo = this.simulcastCodecs.get(codec);
     if (!simulcastCodecInfo) {
       return;
     }
     simulcastCodecInfo.sender = sender;
 
+    // the backup codec publishes over its own sender, so it needs the same degradation
+    // preference the primary sender resolved to.
+    await this.applyDegradationPreference(sender);
+
     // browser will reenable disabled codec/layers after new codec has been published,
     // so refresh subscribedCodecs after publish a new codec
     setTimeout(() => {

package/src/room/track/RemoteTrack.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
+import { TrackEvent } from '../events';
+import RemoteVideoTrack from './RemoteVideoTrack';
+
+describe('RemoteTrack time sync loop', () => {
+  let track: RemoteVideoTrack;
+  let getSynchronizationSources: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    // fake timers back `requestAnimationFrame`, so cancellation behaves like it does in a browser
+    vi.useFakeTimers();
+    // `supportsSynchronizationSources()` gates the loop on this being implemented
+    vi.stubGlobal(
+      'RTCRtpReceiver',
+      class {
+        getSynchronizationSources() {}
+      },
+    );
+
+    let rtpTimestamp = 0;
+    getSynchronizationSources = vi.fn(() => [{ timestamp: 1, rtpTimestamp: ++rtpTimestamp }]);
+    const receiver = { getSynchronizationSources } as unknown as RTCRtpReceiver;
+    track = new RemoteVideoTrack(new MockMediaStreamTrack(), 'sid', receiver, {});
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  it('does not sample the receiver when nobody listens', () => {
+    track.startMonitor();
+    vi.advanceTimersToNextFrame();
+
+    expect(getSynchronizationSources).not.toHaveBeenCalled();
+  });
+
+  it('starts the loop when a listener subscribes', () => {
+    track.startMonitor();
+    const listener = vi.fn();
+    track.on(TrackEvent.TimeSyncUpdate, listener);
+    vi.advanceTimersToNextFrame();
+
+    expect(listener).toHaveBeenCalledWith({ timestamp: 1, rtpTimestamp: 1 });
+  });
+
+  it('starts the loop for listeners that subscribed before the monitor started', () => {
+    const listener = vi.fn();
+    track.on(TrackEvent.TimeSyncUpdate, listener);
+    track.startMonitor();
+    vi.advanceTimersToNextFrame();
+
+    expect(listener).toHaveBeenCalled();
+  });
+
+  it('does not start a second loop when a second listener subscribes', () => {
+    track.startMonitor();
+    track.on(TrackEvent.TimeSyncUpdate, vi.fn());
+    track.on(TrackEvent.TimeSyncUpdate, vi.fn());
+
+    vi.advanceTimersToNextFrame();
+
+    // a second chain would sample twice per frame
+    expect(getSynchronizationSources).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not start a second loop when the monitor is started again', () => {
+    track.on(TrackEvent.TimeSyncUpdate, vi.fn());
+    track.startMonitor();
+    track.startMonitor();
+    getSynchronizationSources.mockClear();
+
+    vi.advanceTimersToNextFrame();
+
+    expect(getSynchronizationSources).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops the loop once the last listener unsubscribes', () => {
+    const listener = vi.fn();
+    track.startMonitor();
+    track.on(TrackEvent.TimeSyncUpdate, listener);
+    vi.advanceTimersToNextFrame();
+
+    track.off(TrackEvent.TimeSyncUpdate, listener);
+    vi.advanceTimersToNextFrame();
+    getSynchronizationSources.mockClear();
+    vi.advanceTimersToNextFrame();
+
+    expect(getSynchronizationSources).not.toHaveBeenCalled();
+  });
+
+  it('restarts the loop when a listener subscribes again', () => {
+    const listener = vi.fn();
+    track.startMonitor();
+    track.on(TrackEvent.TimeSyncUpdate, listener);
+    track.off(TrackEvent.TimeSyncUpdate, listener);
+    vi.advanceTimersToNextFrame();
+    listener.mockClear();
+
+    track.on(TrackEvent.TimeSyncUpdate, listener);
+    vi.advanceTimersToNextFrame();
+
+    expect(listener).toHaveBeenCalled();
+  });
+
+  it('cancels a running loop when the monitor is stopped', () => {
+    track.startMonitor();
+    // the listener stays subscribed, so only the cancellation can stop the loop
+    track.on(TrackEvent.TimeSyncUpdate, vi.fn());
+    vi.advanceTimersToNextFrame();
+    expect(getSynchronizationSources).toHaveBeenCalled();
+
+    track.stopMonitor();
+    getSynchronizationSources.mockClear();
+    vi.advanceTimersToNextFrame();
+    vi.advanceTimersToNextFrame();
+
+    expect(getSynchronizationSources).not.toHaveBeenCalled();
+  });
+
+  it('resumes the loop when the monitor is started again after a stop', () => {
+    track.startMonitor();
+    track.on(TrackEvent.TimeSyncUpdate, vi.fn());
+    vi.advanceTimersToNextFrame();
+    track.stopMonitor();
+    getSynchronizationSources.mockClear();
+
+    track.startMonitor();
+    vi.advanceTimersToNextFrame();
+
+    expect(getSynchronizationSources).toHaveBeenCalled();
+  });
+
+  it('does not restart the loop after the monitor has been stopped', () => {
+    track.startMonitor();
+    track.stopMonitor();
+
+    track.on(TrackEvent.TimeSyncUpdate, vi.fn());
+    vi.advanceTimersToNextFrame();
+
+    expect(getSynchronizationSources).not.toHaveBeenCalled();
+  });
+});

package/src/room/track/RemoteTrack.ts

@@ -1,3 +1,4 @@
+import type { EventEmitter } from 'events';
 import { TrackEvent } from '../events';
 import { monitorFrequency } from '../stats';
 import type { LoggerOptions } from '../types';
@@ -123,20 +124,46 @@ export default abstract class RemoteTrack<
     }
   }
 
+  /* @internal */
+  stopMonitor() {
+    super.stopMonitor();
+    (this as unknown as EventEmitter).off('newListener', this.onTimeSyncListenerAdded);
+  }
+
   protected abstract monitorReceiver(): void;
 
-  registerTimeSyncUpdate() {
-    const loop = () => {
-      this.timeSyncHandle = requestAnimationFrame(() => loop());
-      const sources = this.receiver?.getSynchronizationSources()[0];
-      if (sources) {
-        const { timestamp, rtpTimestamp } = sources;
-        if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
-          this.emit(TrackEvent.TimeSyncUpdate, { timestamp, rtpTimestamp });
-          this.rtpTimestamp = rtpTimestamp;
-        }
+  private timeSyncLoop = () => {
+    if (this.listenerCount(TrackEvent.TimeSyncUpdate) === 0) {
+      // nobody is listening anymore, pause the loop until a new listener subscribes
+      this.timeSyncHandle = undefined;
+      return;
+    }
+    this.timeSyncHandle = requestAnimationFrame(this.timeSyncLoop);
+    const sources = this.receiver?.getSynchronizationSources()[0];
+    if (sources) {
+      const { timestamp, rtpTimestamp } = sources;
+      if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
+        this.emit(TrackEvent.TimeSyncUpdate, { timestamp, rtpTimestamp });
+        this.rtpTimestamp = rtpTimestamp;
       }
-    };
-    loop();
+    }
+  };
+
+  private onTimeSyncListenerAdded = (event: string) => {
+    if (event === TrackEvent.TimeSyncUpdate && this.timeSyncHandle === undefined) {
+      // `newListener` fires before the listener is registered, so schedule the
+      // next frame instead of entering the loop (which would see a count of 0)
+      this.timeSyncHandle = requestAnimationFrame(this.timeSyncLoop);
+    }
+  };
+
+  registerTimeSyncUpdate() {
+    // `newListener` isn't part of the typed event map, hence the cast
+    const emitter = this as unknown as EventEmitter;
+    emitter.off('newListener', this.onTimeSyncListenerAdded);
+    emitter.on('newListener', this.onTimeSyncListenerAdded);
+    if (this.timeSyncHandle === undefined) {
+      this.timeSyncLoop();
+    }
   }
 }

package/src/room/track/Track.ts

@@ -11,6 +11,7 @@ import type { SignalClient } from '../../api/SignalClient';
 import log, { LoggerNames, type StructuredLogger, getLogger } from '../../logger';
 import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import { TrackEvent } from '../events';
+import { summarizeStatsReport } from '../statsSummary';
 import type { LoggerOptions } from '../types';
 import { isFireFox, isSafari, isWeb } from '../utils';
 import type { TrackProcessor } from './processor/types';
@@ -85,6 +86,8 @@ export abstract class Track<
 
   protected monitorInterval?: ReturnType<typeof setInterval>;
 
+  private finalStatsLogged = false;
+
   protected log: StructuredLogger = log;
 
   protected constructor(
@@ -271,14 +274,39 @@ export abstract class Track<
   /* @internal */
   abstract startMonitor(signalClient?: SignalClient): void;
 
+  /**
+   * Raw stats of the sender or receiver this track is attached to.
+   */
+  abstract getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
+
   /* @internal */
   stopMonitor() {
     if (this.monitorInterval) {
       clearInterval(this.monitorInterval);
     }
-    if (this.timeSyncHandle) {
+    if (this.timeSyncHandle !== undefined) {
       cancelAnimationFrame(this.timeSyncHandle);
+      this.timeSyncHandle = undefined;
     }
+    this.logFinalStats();
+  }
+
+  /**
+   * Dumps the raw stats of the track as it ends, once: a track that stops
+   * between two of the room's stats dumps is gone by the time the next one runs.
+   */
+  private logFinalStats() {
+    if (this.finalStatsLogged) {
+      return;
+    }
+    this.finalStatsLogged = true;
+    this.getRTCStatsReport()
+      .then((report) => {
+        if (report) {
+          this.log.info('final track stats', summarizeStatsReport(report));
+        }
+      })
+      .catch((error) => this.log.debug('could not collect final track stats', { error }));
   }
 
   /** @internal */

package/src/room/utils.test.ts

@@ -1,6 +1,14 @@
 import { ClientInfo_Capability } from '@livekit/protocol';
-import { describe, expect, it } from 'vitest';
-import { extractMaxAgeFromRequestHeaders, getClientInfo, splitUtf8, toWebsocketUrl } from './utils';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  ddExtensionURI,
+  extractMaxAgeFromRequestHeaders,
+  getClientInfo,
+  negotiateDependencyDescriptor,
+  splitUtf8,
+  supportsAdaptiveStream,
+  toWebsocketUrl,
+} from './utils';
 
 describe('toWebsocketUrl', () => {
   it('leaves wss urls alone', () => {
@@ -188,3 +196,87 @@ describe('extractMaxAgeFromRequestHeaders', () => {
     expect(extractMaxAgeFromRequestHeaders(headers)).toBe(3600);
   });
 });
+
+describe('negotiateDependencyDescriptor', () => {
+  /** A transceiver whose header extension control offers `extensions`, or none at all. */
+  const transceiverWith = (extensions?: RTCRtpHeaderExtensionCapability[], throws = false) => {
+    const set = vi.fn((updated: RTCRtpHeaderExtensionCapability[]) => {
+      if (throws) {
+        throw new Error('InvalidModificationError');
+      }
+      extensions = updated;
+    });
+    return {
+      transceiver: (extensions
+        ? {
+            getHeaderExtensionsToNegotiate: () => extensions!,
+            setHeaderExtensionsToNegotiate: set,
+          }
+        : {}) as unknown as RTCRtpTransceiver,
+      set,
+      current: () => extensions,
+    };
+  };
+
+  it('turns the extension on for a transceiver that has it stopped', () => {
+    const { transceiver, set, current } = transceiverWith([
+      { uri: 'urn:ietf:params:rtp-hdrext:sdes:mid', direction: 'sendrecv' },
+      { uri: ddExtensionURI, direction: 'stopped' },
+    ]);
+
+    expect(negotiateDependencyDescriptor(transceiver)).toBe(true);
+    expect(set).toHaveBeenCalledOnce();
+    // sendrecv keeps it a plain a=extmap line, with no direction suffix for the server to parse
+    expect(current()?.find((ext) => ext.uri === ddExtensionURI)?.direction).toBe('sendrecv');
+  });
+
+  it('leaves an extension the browser already negotiates alone', () => {
+    const { transceiver, set } = transceiverWith([{ uri: ddExtensionURI, direction: 'recvonly' }]);
+
+    expect(negotiateDependencyDescriptor(transceiver)).toBe(true);
+    expect(set).not.toHaveBeenCalled();
+  });
+
+  it('reports no negotiation where the browser does not know the extension', () => {
+    const { transceiver, set } = transceiverWith([
+      { uri: 'urn:ietf:params:rtp-hdrext:sdes:mid', direction: 'sendrecv' },
+    ]);
+
+    expect(negotiateDependencyDescriptor(transceiver)).toBe(false);
+    expect(set).not.toHaveBeenCalled();
+  });
+
+  it('reports no negotiation where the browser has no such control', () => {
+    const { transceiver } = transceiverWith();
+
+    expect(negotiateDependencyDescriptor(transceiver)).toBe(false);
+  });
+
+  it('swallows a rejected direction rather than failing the connection', () => {
+    const { transceiver } = transceiverWith([{ uri: ddExtensionURI, direction: 'stopped' }], true);
+
+    expect(negotiateDependencyDescriptor(transceiver)).toBe(false);
+  });
+});
+
+describe('supportsAdaptiveStream', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('reports support where both observers exist', () => {
+    expect(supportsAdaptiveStream()).toBe(true);
+  });
+
+  it('reports no support where ResizeObserver is missing', () => {
+    vi.stubGlobal('ResizeObserver', undefined);
+
+    expect(supportsAdaptiveStream()).toBe(false);
+  });
+
+  it('reports no support where IntersectionObserver is missing', () => {
+    vi.stubGlobal('IntersectionObserver', undefined);
+
+    expect(supportsAdaptiveStream()).toBe(false);
+  });
+});