livekit-client 2.22.3 → 2.22.4

package/src/room/RTCEngine.ts

@@ -268,6 +268,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /** timestamp (ms) the primary transport entered `CONNECTING`, used to bound how long we tolerate it */
   private transportConnectingSince?: number;
 
+  /**
+   * Abort handlers for the in-flight `negotiate()` calls, which a single central
+   * Closing/Restarting listener pair fans out to. Registering a listener pair per call instead
+   * accumulates them on the engine emitter and trips its max-listener warning under
+   * renegotiation bursts.
+   */
+  private pendingNegotiationAborts = new Set<() => void>();
+
   constructor(private options: InternalRoomOptions) {
     super();
     this.log = getLogger(options.loggerName ?? LoggerNames.Engine, () => this.logContext);
@@ -308,6 +316,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.client.onParticipantUpdate = (updates) =>
       this.emit(EngineEvent.ParticipantUpdate, updates);
     this.client.onJoined = (joinResponse) => this.emit(EngineEvent.Joined, joinResponse);
+
+    const abortPendingNegotiations = () => {
+      // Iterate a copy: each handler removes itself from the set as its negotiation settles.
+      for (const abort of Array.from(this.pendingNegotiationAborts)) {
+        abort();
+      }
+    };
+    this.on(EngineEvent.Closing, abortPendingNegotiations);
+    this.on(EngineEvent.Restarting, abortPendingNegotiations);
   }
 
   /** @internal */
@@ -669,6 +686,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.midToTrackId = midToTrackId;
       }
       await this.pcManager.setPublisherAnswer(sd, offerId);
+      this.emit(EngineEvent.RequestSubscribedCodecRefresh);
     };
 
     // add candidate on trickle
@@ -738,7 +756,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.client.onMediaSectionsRequirement = (requirement: MediaSectionsRequirement) => {
       this.addMediaSections(requirement.numAudios, requirement.numVideos);
-      this.negotiate();
+      this.negotiate().catch((err) => {
+        this.log.error(err);
+      });
     };
 
     this.client.onPublishDataTrackResponse = (event: PublishDataTrackResponse) => {
@@ -1807,8 +1827,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       if (this.isClosed) {
         reject(new NegotiationError('cannot negotiate on closed engine'));
       }
-      this.on(EngineEvent.Closing, handleClosed);
-      this.on(EngineEvent.Restarting, handleClosed);
+      this.pendingNegotiationAborts.add(handleClosed);
       this.pcManager.publisher.off(PCEvents.RTPVideoPayloadTypes, this.onRtpMapAvailable);
       this.pcManager.publisher.once(PCEvents.RTPVideoPayloadTypes, this.onRtpMapAvailable);
 
@@ -1832,8 +1851,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           reject(new Error(String(e)));
         }
       } finally {
-        this.off(EngineEvent.Closing, handleClosed);
-        this.off(EngineEvent.Restarting, handleClosed);
+        this.pendingNegotiationAborts.delete(handleClosed);
       }
     });
   }
@@ -2095,6 +2113,7 @@ export type EngineEventCallbacks = {
   joined: (joinResponse: JoinResponse) => void;
   tokenRefreshed: (token: string) => void;
   serverRegionsReported: (regions: RegionSettings) => void;
+  requestSubscribedCodecRefresh: () => void;
 };
 
 export interface RegionStrategy {

package/src/room/Room.test.ts

@@ -10,6 +10,7 @@ import {
 } from '@livekit/protocol';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import MockMediaStreamTrack from '../test/MockMediaStreamTrack';
+import { stubMissingDeflateRawSupport } from '../test/compressionStreamStubs';
 import Room, { ConnectionState } from './Room';
 import { roomConnectOptionDefaults, roomOptionDefaults } from './defaults';
 import { EngineEvent, ParticipantEvent, RoomEvent } from './events';
@@ -46,8 +47,8 @@ describe('Active device switch', () => {
 });
 
 describe('Room signaling options', () => {
-  it('advertises packet trailer capability when E2EE can handle trailers', async () => {
-    const room = new Room();
+  /** Drives `connectSignal` with E2EE enabled against a stub engine, returning the `join` mock. */
+  async function connectSignalWithE2EE(room: Room) {
     const join = vi.fn().mockResolvedValue({
       joinResponse: new JoinResponse({
         room: { name: 'test-room', sid: 'room-sid' },
@@ -91,19 +92,44 @@ describe('Room signaling options', () => {
       new AbortController(),
     );
 
+    return join;
+  }
+
+  function expectCapabilities(
+    join: ReturnType<typeof vi.fn>,
+    clientInfoCapabilities: Array<ClientInfo_Capability>,
+  ) {
     expect(join).toHaveBeenCalledWith(
       'wss://test.livekit.io',
       'test-token',
       expect.objectContaining({
-        clientInfoCapabilities: [
-          ClientInfo_Capability.CAP_PACKET_TRAILER,
-          ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW,
-        ],
+        clientInfoCapabilities,
         e2eeEnabled: true,
       }),
       expect.any(AbortSignal),
       false,
     );
+  }
+
+  it('advertises packet trailer capability when E2EE can handle trailers', async () => {
+    const join = await connectSignalWithE2EE(new Room());
+
+    expectCapabilities(join, [
+      ClientInfo_Capability.CAP_PACKET_TRAILER,
+      ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW,
+    ]);
+  });
+
+  it('does not advertise deflate-raw compression when the runtime cannot decompress it', async () => {
+    const restoreCompressionStreams = stubMissingDeflateRawSupport();
+    try {
+      const join = await connectSignalWithE2EE(new Room());
+
+      // Otherwise peers would compress what they send us and we'd have to drop it.
+      expectCapabilities(join, [ClientInfo_Capability.CAP_PACKET_TRAILER]);
+    } finally {
+      restoreCompressionStreams();
+    }
   });
 });
 

package/src/room/Room.ts

@@ -77,6 +77,7 @@ import {
   ConnectionErrorReason,
   UnexpectedConnectionState,
   UnsupportedServer,
+  canFailOverToAnotherRegion,
 } from './errors';
 import { EngineEvent, ParticipantEvent, RoomEvent, TrackEvent } from './events';
 import LocalParticipant from './participant/LocalParticipant';
@@ -120,9 +121,10 @@ import {
   getEmptyAudioStreamTrack,
   isBrowserSupported,
   isCloud,
-  isCompressionStreamSupported,
+  isDeflateRawCompressionSupported,
   isLocalAudioTrack,
   isLocalParticipant,
+  isLocalVideoTrack,
   isReactNative,
   isRemotePub,
   isSafariBased,
@@ -755,6 +757,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           updatedAtInMs: Date.now(),
           maxAgeInMs: DEFAULT_MAX_AGE_MS,
         });
+      })
+      .on(EngineEvent.RequestSubscribedCodecRefresh, () => {
+        for (const videoPub of this.localParticipant.videoTrackPublications.values()) {
+          if (isLocalVideoTrack(videoPub.track)) {
+            videoPub.track.refreshSubscribedCodecs();
+          }
+        }
       });
 
     if (this.localParticipant) {
@@ -908,8 +917,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         if (
           this.regionUrlProvider &&
           error instanceof ConnectionError &&
-          error.reason !== ConnectionErrorReason.Cancelled &&
-          error.reason !== ConnectionErrorReason.NotAllowed
+          canFailOverToAnotherRegion(error)
         ) {
           let nextUrl: string | null = null;
           try {
@@ -992,6 +1000,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         autoSubscribe: connectOptions.autoSubscribe,
         adaptiveStream:
           typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
+        disableIceLite: connectOptions.disableIceLite,
+        subscriberAllowPause: connectOptions.subscriberAllowPause,
         clientInfoCapabilities: this.getClientInfoCapabilities(roomOptions),
         maxRetries: connectOptions.maxRetries,
         e2eeEnabled: !!this.e2eeManager,
@@ -1211,8 +1221,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     let req: SimulateScenario | undefined;
     switch (scenario) {
       case 'signal-reconnect':
+        const reconnectDelay = typeof arg === 'number' ? arg : 0;
         // @ts-expect-error function is private
-        await this.engine.client.handleOnClose('simulate disconnect');
+        await this.engine.client.handleOnClose('simulate disconnect', undefined, reconnectDelay);
         break;
       case 'fail-on-v1-path':
         this.engine.failNextV1Path();
@@ -2097,7 +2108,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // find the participant
     const participant = this.remoteParticipants.get(packet.participantIdentity);
     if (packet.value.case === 'user') {
-      this.handleUserPacket(participant, packet.value.value, packet.kind, encryptionType);
+      this.handleUserPacket(
+        participant,
+        packet.value.value,
+        packet.kind,
+        encryptionType,
+        packet.participantIdentity,
+      );
     } else if (packet.value.case === 'transcription') {
       this.handleTranscription(participant, packet.value.value);
     } else if (packet.value.case === 'sipDtmf') {
@@ -2147,6 +2164,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     userPacket: UserPacket,
     kind: DataPacket_Kind,
     encryptionType: Encryption_Type,
+    participantIdentity: string,
   ) => {
     this.emit(
       RoomEvent.DataReceived,
@@ -2155,6 +2173,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       kind,
       userPacket.topic,
       encryptionType,
+      participantIdentity,
     );
 
     // also emit on the participant
@@ -2566,7 +2585,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     // Advertise deflate-raw decompression support so peers know they can send us compressed data
     // streams (gated separately from clientProtocol — see the data streams v2 spec).
-    if (isCompressionStreamSupported()) {
+    if (isDeflateRawCompressionSupported()) {
       capabilities.push(ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW);
     }
     return capabilities;
@@ -3060,6 +3079,7 @@ export type RoomEventCallbacks = {
     kind?: DataPacket_Kind,
     topic?: string,
     encryptionType?: Encryption_Type,
+    participantIdentity?: string,
   ) => void;
   sipDTMFReceived: (dtmf: SipDTMF, participant?: RemoteParticipant) => void;
   transcriptionReceived: (

package/src/room/data-stream/incoming/IncomingDataStreamManager.test.ts

@@ -9,6 +9,10 @@ import {
   Encryption_Type,
 } from '@livekit/protocol';
 import { describe, expect, it } from 'vitest';
+import {
+  stubMissingCompressionStreams,
+  stubMissingDeflateRawSupport,
+} from '../../../test/compressionStreamStubs';
 import { deflateRawCompress } from '../compression';
 import { STREAM_CHUNK_SIZE_BYTES } from '../constants';
 import IncomingDataStreamManager from './IncomingDataStreamManager';
@@ -907,18 +911,15 @@ describe('IncomingDataStreamManager', () => {
       expect(await reader.readAll()).toStrictEqual(text);
     });
 
-    it(`should ignore a v2 TEXT data stream with compression if DecompressionStream doesn't exist`, async () => {
+    it.each([
+      [`DecompressionStream doesn't exist`, stubMissingCompressionStreams],
+      [`deflate-raw isn't a supported format`, stubMissingDeflateRawSupport],
+    ])(`should ignore a v2 TEXT data stream with compression if %s`, async (_label, stub) => {
       const text = 'hello world';
       const compressed = await deflateRawCompress(new TextEncoder().encode(text));
 
-      let originalCompressionStream: typeof CompressionStream,
-        originalDecompressionStream: typeof DecompressionStream;
+      const restoreCompressionStreams = stub();
       try {
-        originalCompressionStream = CompressionStream;
-        (globalThis as any).CompressionStream = undefined;
-        originalDecompressionStream = DecompressionStream;
-        (globalThis as any).DecompressionStream = undefined;
-
         const manager = new IncomingDataStreamManager();
         manager.setConnected(true);
 
@@ -977,23 +978,19 @@ describe('IncomingDataStreamManager', () => {
           Promise.race([readerPromise, Promise.resolve('still pending')]),
         ).resolves.toStrictEqual('still pending');
       } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream!;
-        (globalThis as any).DecompressionStream = originalDecompressionStream!;
+        restoreCompressionStreams();
       }
     });
 
-    it(`should ignore a v2 BYTES data stream with compression if DecompressionStream doesn't exist`, async () => {
+    it.each([
+      [`DecompressionStream doesn't exist`, stubMissingCompressionStreams],
+      [`deflate-raw isn't a supported format`, stubMissingDeflateRawSupport],
+    ])(`should ignore a v2 BYTES data stream with compression if %s`, async (_label, stub) => {
       const bytes = new Uint8Array([0x01, 0x02, 0x03]);
       const compressed = await deflateRawCompress(bytes);
 
-      let originalCompressionStream: typeof CompressionStream,
-        originalDecompressionStream: typeof DecompressionStream;
+      const restoreCompressionStreams = stub();
       try {
-        originalCompressionStream = CompressionStream;
-        (globalThis as any).CompressionStream = undefined;
-        originalDecompressionStream = DecompressionStream;
-        (globalThis as any).DecompressionStream = undefined;
-
         const manager = new IncomingDataStreamManager();
         manager.setConnected(true);
 
@@ -1052,8 +1049,7 @@ describe('IncomingDataStreamManager', () => {
           Promise.race([readerPromise, Promise.resolve('still pending')]),
         ).resolves.toStrictEqual('still pending');
       } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream!;
-        (globalThis as any).DecompressionStream = originalDecompressionStream!;
+        restoreCompressionStreams();
       }
     });
 

package/src/room/data-stream/incoming/IncomingDataStreamManager.ts

@@ -10,7 +10,7 @@ import log from '../../../logger';
 import { type NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
 import { DataStreamError, DataStreamErrorReason } from '../../errors';
 import { type ByteStreamInfo, type StreamController, type TextStreamInfo } from '../../types';
-import { bigIntToNumber, isCompressionStreamSupported, numberToBigInt } from '../../utils';
+import { bigIntToNumber, isDeflateRawCompressionSupported, numberToBigInt } from '../../utils';
 import { deflateRawDecompress, inflateRawTransform } from '../compression';
 import { DEFAULT_MAX_PAYLOAD_BYTE_LENGTH } from '../constants';
 import {
@@ -174,11 +174,11 @@ export default class IncomingDataStreamManager {
         let compressed;
         switch (streamHeader.compression) {
           case DataStream_CompressionType.DEFLATE_RAW:
-            if (!isCompressionStreamSupported()) {
+            if (!isDeflateRawCompressionSupported()) {
               // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
               // isn't properly abiding by the data streams v2 protocol.
               log.warn(
-                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not have support for DecompressionStream. Dropping...`,
+                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not support deflate-raw decompression. Dropping...`,
               );
               return;
             }
@@ -279,11 +279,11 @@ export default class IncomingDataStreamManager {
         let compressed;
         switch (streamHeader.compression) {
           case DataStream_CompressionType.DEFLATE_RAW:
-            if (!isCompressionStreamSupported()) {
+            if (!isDeflateRawCompressionSupported()) {
               // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
               // isn't properly abiding by the data streams v2 protocol.
               log.warn(
-                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not have support for DecompressionStream. Dropping...`,
+                `Data stream ${streamHeader.streamId} received with deflate-raw compression, but this browser does not support deflate-raw decompression. Dropping...`,
               );
               return;
             }

package/src/room/data-stream/outgoing/OutgoingDataStreamManager.test.ts

@@ -5,14 +5,19 @@ import {
   DataStream_CompressionType,
   type DataStream_TextHeader,
 } from '@livekit/protocol';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import log from '../../../logger';
+import {
+  stubMissingCompressionStreams,
+  stubMissingDeflateRawSupport,
+} from '../../../test/compressionStreamStubs';
 import {
   CLIENT_PROTOCOL_DATA_STREAM_RPC,
   CLIENT_PROTOCOL_DATA_STREAM_V2,
   CLIENT_PROTOCOL_DEFAULT,
 } from '../../../version';
 import type RTCEngine from '../../RTCEngine';
+import { STREAM_CHUNK_SIZE_BYTES } from '../constants';
 import OutgoingDataStreamManager from './OutgoingDataStreamManager';
 
 /** Builds a low quality random string of the given length. */
@@ -1195,7 +1200,7 @@ describe('OutgoingDataStreamManager', () => {
       // The split backs off below the MTU rather than bisecting the emoji, so each chunk decodes
       // independently.
       expect(first.content).toHaveLength(14_999);
-      const decode = (bytes: Uint8Array) => new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+      const decode = (bytes: Uint8Array) => new TextDecoder('utf-8').decode(bytes);
       expect(() => decode(first.content)).not.toThrow();
       expect(() => decode(second.content)).not.toThrow();
       expect(decode(first.content) + decode(second.content)).toStrictEqual(text);
@@ -1243,50 +1248,66 @@ describe('OutgoingDataStreamManager', () => {
     });
   });
 
-  describe('runtime without CompressionStream', () => {
+  describe.each([
+    ['a runtime without CompressionStream', stubMissingCompressionStreams],
+    ['a runtime without deflate-raw support', stubMissingDeflateRawSupport],
+  ])('on %s', (_label, stub) => {
+    let restoreCompressionStreams: () => void;
+
+    beforeEach(() => {
+      restoreCompressionStreams = stub();
+    });
+
+    afterEach(() => {
+      restoreCompressionStreams();
+    });
+
     it('should send raw inline even to compression-capable recipients when the runtime cannot compress', async () => {
-      const originalCompressionStream = CompressionStream;
-      try {
-        (globalThis as any).CompressionStream = undefined;
+      const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
+      await manager.sendText('hello hello compressible world', {
+        topic: 'my-topic',
+        destinationIdentities: ['alice'],
+      });
 
-        const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
-        await manager.sendText('hello hello compressible world', {
-          topic: 'my-topic',
-          destinationIdentities: ['alice'],
-        });
+      // Compression eligibility also requires a local compressor; without one, inline still
+      // applies but the payload is sent raw.
+      expect(sentPackets).toHaveLength(1);
+      const header = headerOf(sentPackets[0]);
+      expect(header.compression).toBe(DataStream_CompressionType.NONE);
+      expect(header.inlineContent).toStrictEqual(
+        new TextEncoder().encode('hello hello compressible world'),
+      );
+    });
 
-        // Compression eligibility also requires a local compressor; without one, inline still
-        // applies but the payload is sent raw.
-        expect(sentPackets).toHaveLength(1);
-        const header = headerOf(sentPackets[0]);
-        expect(header.compression).toBe(DataStream_CompressionType.NONE);
-        expect(header.inlineContent).toStrictEqual(
-          new TextEncoder().encode('hello hello compressible world'),
-        );
-      } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream;
-      }
+    it('should send BYTES uncompressed when the runtime cannot compress', async () => {
+      const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
+      // Larger than the inline budget, so this takes the chunked path rather than riding along in
+      // the header.
+      const bytes = new Uint8Array(20_000).fill(0x07);
+      await manager.sendBytes(bytes, {
+        topic: 'my-topic',
+        destinationIdentities: ['alice'],
+      });
+
+      expect(sentPackets).toHaveLength(4);
+      const header = headerOf(sentPackets[0]);
+      expect(header.compression).toBe(DataStream_CompressionType.NONE);
+      expect(chunkOf(sentPackets[1]).content).toHaveLength(STREAM_CHUNK_SIZE_BYTES);
+      expect(chunkOf(sentPackets[2]).content).toHaveLength(20_000 - STREAM_CHUNK_SIZE_BYTES);
     });
 
     it('should send a FILE uncompressed when the runtime cannot compress', async () => {
-      const originalCompressionStream = CompressionStream;
-      try {
-        (globalThis as any).CompressionStream = undefined;
-
-        const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
-        const bytes = new Uint8Array(10_000).fill(0x07);
-        await manager.sendFile(new File([bytes as NonSharedUint8Array], 'text.txt'), {
-          topic: 'my-topic',
-          destinationIdentities: ['alice'],
-        });
+      const { manager, sentPackets } = createManager({ alice: CLIENT_PROTOCOL_DATA_STREAM_V2 });
+      const bytes = new Uint8Array(10_000).fill(0x07);
+      await manager.sendFile(new File([bytes as NonSharedUint8Array], 'text.txt'), {
+        topic: 'my-topic',
+        destinationIdentities: ['alice'],
+      });
 
-        expect(sentPackets).toHaveLength(3);
-        const header = headerOf(sentPackets[0]);
-        expect(header.compression).toBe(DataStream_CompressionType.NONE);
-        expect(chunkOf(sentPackets[1]).content).toHaveLength(10_000);
-      } finally {
-        (globalThis as any).CompressionStream = originalCompressionStream;
-      }
+      expect(sentPackets).toHaveLength(3);
+      const header = headerOf(sentPackets[0]);
+      expect(header.compression).toBe(DataStream_CompressionType.NONE);
+      expect(chunkOf(sentPackets[1]).content).toHaveLength(10_000);
     });
   });
 });

package/src/room/data-stream/outgoing/OutgoingDataStreamManager.ts

@@ -24,7 +24,7 @@ import type {
   TextStreamInfo,
 } from '../../types';
 import {
-  isCompressionStreamSupported,
+  isDeflateRawCompressionSupported,
   numberToBigInt,
   readBytesInChunks,
   readableFromBytes,
@@ -101,7 +101,7 @@ export default class OutgoingDataStreamManager {
 
     const compressEligible =
       compress &&
-      isCompressionStreamSupported() &&
+      isDeflateRawCompressionSupported() &&
       this.allRecipientsSupportV2(options?.destinationIdentities) &&
       this.allRecipientsSupportCompression(options?.destinationIdentities);
     let compressedStream = compressEligible
@@ -239,7 +239,7 @@ export default class OutgoingDataStreamManager {
 
     const compressEligible =
       compress &&
-      isCompressionStreamSupported() &&
+      isDeflateRawCompressionSupported() &&
       this.allRecipientsSupportV2(destinationIdentities) &&
       this.allRecipientsSupportCompression(destinationIdentities);
     let compressedStream = compressEligible
@@ -463,7 +463,7 @@ export default class OutgoingDataStreamManager {
     const destinationIdentities = options?.destinationIdentities;
     const compress =
       (options?.compress ?? true) &&
-      isCompressionStreamSupported() &&
+      isDeflateRawCompressionSupported() &&
       this.allRecipientsSupportV2(destinationIdentities) &&
       this.allRecipientsSupportCompression(destinationIdentities);
 

package/src/room/defaults.ts

@@ -47,6 +47,7 @@ export const roomOptionDefaults: InternalRoomOptions = {
 
 export const roomConnectOptionDefaults: InternalRoomConnectOptions = {
   autoSubscribe: true,
+  disableIceLite: false,
   maxRetries: 1,
   peerConnectionTimeout: 15_000,
   websocketTimeout: 15_000,

package/src/room/errors.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { ConnectionError, canFailOverToAnotherRegion } from './errors';
+
+describe('canFailOverToAnotherRegion', () => {
+  it('allows failover on 403, which LiveKit Cloud uses to signal region pinning', () => {
+    // The RTC paths 403 when the project is not allowed in the region the client geo-routed to.
+    // `/settings/regions` stays reachable so the client can discover where it is allowed.
+    expect(
+      canFailOverToAnotherRegion(
+        ConnectionError.notAllowed('project not allowed in this region.', 403),
+      ),
+    ).toBe(true);
+  });
+
+  it('does not allow failover on 401 — no other region will accept the same token', () => {
+    expect(canFailOverToAnotherRegion(ConnectionError.notAllowed('unauthorized', 401))).toBe(false);
+  });
+
+  it('does not allow failover when the room does not exist, reported as NotAllowed with 404', () => {
+    expect(
+      canFailOverToAnotherRegion(ConnectionError.notAllowed('requested room does not exist', 404)),
+    ).toBe(false);
+  });
+
+  it('does not allow failover on a cancelled attempt', () => {
+    expect(canFailOverToAnotherRegion(ConnectionError.cancelled('aborted'))).toBe(false);
+  });
+
+  it.each([
+    ['server unreachable', ConnectionError.serverUnreachable('unreachable')],
+    ['timeout', ConnectionError.timeout('timed out')],
+    ['internal', ConnectionError.internal('internal')],
+  ])('allows failover on a %s error', (_name, error) => {
+    expect(canFailOverToAnotherRegion(error)).toBe(true);
+  });
+});

package/src/room/errors.ts

@@ -188,6 +188,33 @@ export class ConnectionError<
   }
 }
 
+/**
+ * Whether a failed connection attempt may be retried against a different LiveKit Cloud region.
+ *
+ * LiveKit Cloud signals project-level region pinning by returning 403 on the RTC paths when the
+ * project is not allowed in the region the client geo-routed to. `/settings/regions` is
+ * deliberately left reachable so the client can discover its allowed regions and connect there, so
+ * a 403 must not be treated as terminal.
+ *
+ * A 401 stays terminal: no other region will accept a token this one rejected. So does the 404
+ * "requested room does not exist" case, which is also reported as `NotAllowed`.
+ *
+ * We key on the status rather than the server's error message because that message is an
+ * unversioned human-readable string; matching it would let a copy edit break already-shipped
+ * clients. If a 403 really was a permissions failure rather than region pinning, every region
+ * attempt fails the same way and the original error still surfaces — at the cost of one extra
+ * region lookup.
+ */
+export function canFailOverToAnotherRegion(error: ConnectionError): boolean {
+  if (error.reason === ConnectionErrorReason.Cancelled) {
+    return false;
+  }
+  if (error.reason === ConnectionErrorReason.NotAllowed) {
+    return error.status === 403;
+  }
+  return true;
+}
+
 export class DeviceUnsupportedError extends LivekitError {
   readonly name = 'DeviceUnsupportedError';
 

package/src/room/events.ts

@@ -225,7 +225,7 @@ export enum RoomEvent {
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
    * All participants in the room will receive the messages sent to the room.
    *
-   * args: (payload: NonSharedUint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
+   * args: (payload: NonSharedUint8Array, participant: [[Participant]] | undefined, kind: [[DataPacket_Kind]], topic?: string, encryptionType?: Encryption_Type, participantIdentity?: string)
    */
   DataReceived = 'dataReceived',
 
@@ -633,6 +633,7 @@ export enum EngineEvent {
   Joined = 'joined',
   TokenRefreshed = 'tokenRefreshed',
   ServerRegionsReported = 'serverRegionsReported',
+  RequestSubscribedCodecRefresh = 'requestSubscribedCodecRefresh',
 }
 
 export enum TrackEvent {

package/src/room/participant/publishUtils.ts

@@ -74,25 +74,6 @@ export const computeDefaultScreenShareSimulcastPresets = (fromPreset: VideoPrese
   );
 };
 
-// /**
-//  *
-//  * @internal
-//  * @experimental
-//  */
-// const computeDefaultMultiCodecSimulcastEncodings = (width: number, height: number) => {
-//   // use vp8 as a default
-//   const vp8 = determineAppropriateEncoding(false, width, height);
-//   const vp9 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.9 };
-//   const h264 = { ...vp8, maxBitrate: vp8.maxBitrate * 1.1 };
-//   const av1 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.7 };
-//   return {
-//     vp8,
-//     vp9,
-//     h264,
-//     av1,
-//   };
-// };
-
 const videoRids = ['q', 'h', 'f'];
 
 /* @internal */