livekit-client 2.20.2 → 2.22.0

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

@@ -276,8 +276,9 @@ export abstract class Track<
     if (this.monitorInterval) {
       clearInterval(this.monitorInterval);
     }
-    if (this.timeSyncHandle) {
+    if (this.timeSyncHandle !== undefined) {
       cancelAnimationFrame(this.timeSyncHandle);
+      this.timeSyncHandle = undefined;
     }
   }
 

package/src/room/types.ts

@@ -21,6 +21,21 @@ export interface SendTextOptions {
   attachments?: Array<File>;
   onProgress?: (progress: number) => void;
   attributes?: Record<string, string>;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
+}
+
+export interface SendBytesOptions {
+  topic?: string;
+  destinationIdentities?: Array<string>;
+  attributes?: Record<string, string>;
+  onProgress?: (progress: number) => void;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
+  name?: string;
+  mimeType?: string;
 }
 
 export interface StreamTextOptions {
@@ -51,6 +66,9 @@ export type SendFileOptions = Pick<
 > & {
   onProgress?: (progress: number) => void;
   encryptionType?: Encryption_Type.NONE;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
 };
 
 export type DataPublishOptions = {

package/src/room/utils.test.ts

@@ -1,6 +1,13 @@
 import { ClientInfo_Capability } from '@livekit/protocol';
-import { describe, expect, it } from 'vitest';
-import { extractMaxAgeFromRequestHeaders, getClientInfo, splitUtf8, toWebsocketUrl } from './utils';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  ddExtensionURI,
+  extractMaxAgeFromRequestHeaders,
+  getClientInfo,
+  negotiateDependencyDescriptor,
+  splitUtf8,
+  toWebsocketUrl,
+} from './utils';
 
 describe('toWebsocketUrl', () => {
   it('leaves wss urls alone', () => {
@@ -188,3 +195,65 @@ 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);
+  });
+});

package/src/room/utils.ts

@@ -146,6 +146,45 @@ export function isSVCCodec(codec?: string): boolean {
   return codec === 'av1' || codec === 'vp9';
 }
 
+/**
+ * Opts `transceiver` into negotiating the AV1 dependency descriptor, reporting whether it will be.
+ *
+ * Chrome only offers the extension on transceivers that can send, so one we create to receive on
+ * never negotiates it — and Chrome 152 stopped decoding AV1 that arrives without it: frames get
+ * assembled, none ever decode, and the receiver asks for a keyframe forever. Asking through the
+ * transceiver rather than munging the extension into the SDP leaves the browser owning the
+ * extension id, which is what keeps that id consistent across the bundle and across
+ * renegotiations.
+ *
+ * A no-op where the browser offers no such control, or does not know the extension at all.
+ * @internal
+ */
+export function negotiateDependencyDescriptor(transceiver: RTCRtpTransceiver): boolean {
+  const extensions = transceiver.getHeaderExtensionsToNegotiate?.();
+  if (!extensions || !transceiver.setHeaderExtensionsToNegotiate) {
+    return false;
+  }
+  const dd = extensions.find((ext) => ext.uri === ddExtensionURI);
+  if (!dd) {
+    return false;
+  }
+  if (dd.direction !== 'stopped') {
+    return true;
+  }
+  // sendrecv rather than recvonly, so that the extension is written as a plain `a=extmap` line —
+  // the form the server already emits where it is the one offering — rather than one carrying a
+  // `/recvonly` suffix that its parser may not expect
+  dd.direction = 'sendrecv';
+  try {
+    transceiver.setHeaderExtensionsToNegotiate(extensions);
+    return true;
+  } catch (e) {
+    // a rejected direction throws. Negotiating without the extension is what happened before this
+    // existed, so it is not worth failing the connection over
+    return false;
+  }
+}
+
 export function supportsSetSinkId(elm?: HTMLMediaElement): boolean {
   if (!document || isSafariBased()) {
     return false;
@@ -781,6 +820,73 @@ export function splitUtf8(s: string, n: number): NonSharedUint8Array[] {
   return result;
 }
 
+/** Wraps a byte array in a `ReadableStream` that yields it as a single chunk and then closes. */
+export function readableFromBytes(bytes: NonSharedUint8Array): ReadableStream<NonSharedUint8Array> {
+  return new ReadableStream<NonSharedUint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+}
+
+/**
+ * Re-chunks a byte stream into pieces of exactly `chunkSize` bytes (the final piece may be
+ * smaller), coalescing or splitting the source's pieces as needed. Memory use is bounded to roughly
+ * `chunkSize` plus one source read, so it never buffers the whole stream — used to pack
+ * `CompressionStream`/`file.stream()` output into MTU-sized data-stream chunks.
+ */
+export async function* readBytesInChunks(
+  source: ReadableStream<NonSharedUint8Array>,
+  chunkSize: number,
+): AsyncGenerator<NonSharedUint8Array> {
+  const reader = source.getReader();
+  let buffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value.byteLength === 0) {
+        continue;
+      }
+      const merged = new Uint8Array(buffer.byteLength + value.byteLength);
+      merged.set(buffer);
+      merged.set(value, buffer.byteLength);
+      buffer = merged;
+      while (buffer.byteLength >= chunkSize) {
+        yield buffer.slice(0, chunkSize);
+        buffer = buffer.slice(chunkSize);
+      }
+    }
+    if (buffer.byteLength > 0) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/** Encodes a byte array as a base64 string (suitable for embedding binary data in a string field). */
+export function encodeBase64(bytes: Uint8Array): string {
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary);
+}
+
+/** Decodes a base64 string (as produced by {@link encodeBase64}) back into a byte array. */
+export function decodeBase64(base64: string): Uint8Array {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 export function extractMaxAgeFromRequestHeaders(headers: Headers): number | undefined {
   const cacheControl = headers.get('Cache-Control');
   if (cacheControl) {
@@ -800,3 +906,16 @@ export function isPublisherOfferWithJoinSupported() {
   // we have connectivity issue about publisher offer with join on firefox #1919
   return isCompressionStreamSupported() && !isFireFox();
 }
+
+export function extractTrackSid(
+  mediaTrack: MediaStreamTrack,
+  stream: MediaStream,
+): Track.SID | undefined {
+  const [, streamId] = unpackStreamId(stream.id);
+  if (streamId?.startsWith('TR')) {
+    return streamId;
+  }
+  if (mediaTrack.id.startsWith('TR')) {
+    return mediaTrack.id;
+  }
+}

package/src/test/promiseState.ts

@@ -0,0 +1,23 @@
+/**
+ * Test helper: resolves `true` if `promise` is still pending after `ms`
+ * (default: one macrotask), `false` if it has already settled — regardless of
+ * whether it resolved or rejected.
+ *
+ * Use to assert that something has *not* happened yet (e.g. an onClose callback
+ * that must stay silent), optionally within a timeout window. Preferable to
+ * `Promise.race([p, Promise.resolve(sentinel)])` when the "not yet" needs to
+ * hold for a duration rather than just the current microtask.
+ */
+export async function isPending(promise: Promise<unknown>, ms = 0): Promise<boolean> {
+  const pending = Symbol('pending');
+  // Swallow settlement (incl. rejection) so racing it can't raise unhandled
+  // rejections when the timer wins.
+  const settled = promise.then(
+    () => 'settled' as const,
+    () => 'settled' as const,
+  );
+  const timer = new Promise<typeof pending>((resolve) => {
+    setTimeout(() => resolve(pending), ms);
+  });
+  return (await Promise.race([settled, timer])) === pending;
+}

package/src/test/signalServerSetup.ts

@@ -2,6 +2,7 @@ import { type ChildProcess, execFileSync, spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { Socket, createServer } from 'node:net';
 import { join } from 'node:path';
+import { sleep } from '../room/utils';
 import { createToken } from './signalToken';
 
 /**
@@ -47,7 +48,7 @@ async function waitReady(serverUrl: string): Promise<boolean> {
     } catch {
       // not up yet
     }
-    await new Promise((r) => setTimeout(r, 200));
+    await sleep(200);
   }
   return false;
 }

package/src/test/signalToken.ts

@@ -1,4 +1,4 @@
-import { SignJWT } from 'jose';
+import { AccessToken } from 'livekit-server-sdk';
 
 /**
  * Mint a LiveKit access token for the mock test-server (HS256, dev secret).
@@ -33,24 +33,28 @@ export async function createToken(opts: TokenOptions = {}): Promise<string> {
     secret = 'secret',
     ttlSeconds = 600,
   } = opts;
-  const key = new TextEncoder().encode(secret);
-  const payload: Record<string, unknown> = {
-    video: { room, roomJoin: true, canPublish: true, canSubscribe: true, canPublishData: true },
-  };
+  const attributes: Record<string, string> = {};
   if (signal) {
     const control: Record<string, unknown> = { signal };
     if (leaveAction !== undefined) {
       control.leaveAction = leaveAction;
     }
-    payload.attributes = { 'lk.mock': JSON.stringify(control) };
+    attributes['lk.mock'] = JSON.stringify(control);
   }
-  return new SignJWT(payload)
-    .setProtectedHeader({ alg: 'HS256' })
-    .setIssuer(apiKey)
-    .setSubject(identity)
-    .setIssuedAt()
-    .setExpirationTime(`${ttlSeconds}s`)
-    .sign(key);
+  const token = new AccessToken(apiKey, secret, {
+    ttl: ttlSeconds,
+    identity,
+    attributes,
+  });
+  token.addGrant({
+    room,
+    roomJoin: true,
+    canPublish: true,
+    canSubscribe: true,
+    canPublishData: true,
+  });
+
+  return token.toJwt();
 }
 
 /** A syntactically-valid token signed with the WRONG secret — for 401 tests. */

package/src/type-polyfills/header-extensions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Per-transceiver control over which RTP header extensions get negotiated. Declared as optional
+ * because it is not in lib.dom yet and not every browser implements it.
+ * https://w3c.github.io/webrtc-extensions/#rtcrtptransceiver-interface-extensions
+ */
+interface RTCRtpTransceiver {
+  getHeaderExtensionsToNegotiate?(): RTCRtpHeaderExtensionCapability[];
+  setHeaderExtensionsToNegotiate?(extensions: RTCRtpHeaderExtensionCapability[]): void;
+}
+
+interface RTCRtpHeaderExtensionCapability {
+  direction?: 'sendrecv' | 'sendonly' | 'recvonly' | 'stopped';
+}

package/src/utils/AsyncQueue.ts

@@ -3,9 +3,9 @@ import { Mutex } from '@livekit/mutex';
 type QueueTask<T> = () => PromiseLike<T>;
 
 enum QueueTaskStatus {
-  'WAITING',
-  'RUNNING',
-  'COMPLETED',
+  WAITING,
+  RUNNING,
+  COMPLETED,
 }
 
 type QueueTaskInfo = {

package/src/version.ts

@@ -8,7 +8,11 @@ export const CLIENT_PROTOCOL_DEFAULT = 0;
 /** Replaces RPC v1 protocol with a v2 data streams based one to support unlimited request /
  * response payload length. */
 export const CLIENT_PROTOCOL_DATA_STREAM_RPC = 1;
+/** "Data streams v2": the client knows how to receive a single-packet data stream (a stream whose
+ * entire payload is smuggled into the header packet, with no chunk/trailer packets). Senders only
+ * use the single-packet optimization when the recipient advertises at least this protocol. */
+export const CLIENT_PROTOCOL_DATA_STREAM_V2 = 2;
 
 /** The client protocol version indicates what level of support that the client has for
  * client <-> client api interactions. */
-export const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_RPC;
+export const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_V2;