livekit-client 2.17.3 → 2.18.1

package/dist/ts4.2/room/data-track/track-interfaces.d.ts

@@ -0,0 +1,23 @@
+import type { DataTrackInfo } from './types';
+export declare const TrackSymbol: symbol;
+export interface ITrack {
+    readonly trackSymbol: typeof TrackSymbol;
+}
+/** An interface representing a track (of any type) which is local and sending data to the SFU. */
+export interface ILocalTrack extends ITrack {
+    readonly isLocal: true;
+    isPublished(): boolean;
+}
+export declare const RemoteTrackSymbol: symbol;
+/** An interface representing a track (of any type) which is remote and receiving data from the SFU. */
+export interface IRemoteTrack extends ITrack {
+    readonly isLocal: false;
+}
+export declare const DataTrackSymbol: symbol;
+/** An interface representing a data track, either local or remote. */
+export interface IDataTrack extends ITrack {
+    readonly typeSymbol: typeof DataTrackSymbol;
+    readonly info?: DataTrackInfo;
+}
+export declare function isDataTrack(subject: unknown): subject is IDataTrack;
+//# sourceMappingURL=track-interfaces.d.ts.map

package/dist/ts4.2/room/data-track/types.d.ts

@@ -0,0 +1,15 @@
+import { DataTrackInfo as ProtocolDataTrackInfo } from '@livekit/protocol';
+import type { DataTrackHandle } from './handle';
+export type DataTrackSid = string;
+/** Information about a published data track. */
+export type DataTrackInfo = {
+    sid: DataTrackSid;
+    pubHandle: DataTrackHandle;
+    name: string;
+    usesE2ee: boolean;
+};
+export declare const DataTrackInfo: {
+    from(protocolInfo: ProtocolDataTrackInfo): DataTrackInfo;
+    toProtobuf(info: DataTrackInfo): ProtocolDataTrackInfo;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/room/events.d.ts

@@ -291,7 +291,7 @@ export declare enum RoomEvent {
     EncryptionError = "encryptionError",
     /**
      * Emits whenever the current buffer status of a data channel changes
-     * args: (isLow: boolean, kind: [[DataPacket_Kind]])
+     * args: (isLow: boolean, kind: [[DataChannelKind]])
      */
     DCBufferStatusChanged = "dcBufferStatusChanged",
     /**
@@ -307,7 +307,23 @@ export declare enum RoomEvent {
     /**
      * fired when the client receives connection metrics from other participants
      */
-    MetricsReceived = "metricsReceived"
+    MetricsReceived = "metricsReceived",
+    /**
+     * Emits when a new data track has been published by a downstream participant.
+     */
+    DataTrackPublished = "dataTrackPublished",
+    /**
+     * Emits when a new data track has been unpublished by a downstream participant.
+     */
+    DataTrackUnpublished = "dataTrackUnpublished",
+    /**
+     * Emits when a new data track has been published locally.
+     */
+    LocalDataTrackPublished = "localDataTrackPublished",
+    /**
+     * Emits when a new data track has been unpublished locally.
+     */
+    LocalDataTrackUnpublished = "localDataTrackUnpublished"
 }
 export declare enum ParticipantEvent {
     /**
@@ -528,7 +544,12 @@ export declare enum EngineEvent {
     Offline = "offline",
     SignalRequestResponse = "signalRequestResponse",
     SignalConnected = "signalConnected",
-    RoomMoved = "roomMoved"
+    RoomMoved = "roomMoved",
+    PublishDataTrackResponse = "publishDataTrackResponse",
+    UnPublishDataTrackResponse = "unPublishDataTrackResponse",
+    DataTrackSubscriberHandles = "dataTrackSubscriberHandles",
+    DataTrackPacketReceived = "dataTrackPacketReceived",
+    Joined = "joined"
 }
 export declare enum TrackEvent {
     Message = "message",

package/dist/ts4.2/room/participant/LocalParticipant.d.ts

@@ -4,6 +4,9 @@ import TypedPromise from '../../utils/TypedPromise';
 import type RTCEngine from '../RTCEngine';
 import type OutgoingDataStreamManager from '../data-stream/outgoing/OutgoingDataStreamManager';
 import type { TextStreamWriter } from '../data-stream/outgoing/StreamWriter';
+import LocalDataTrack from '../data-track/LocalDataTrack';
+import type OutgoingDataTrackManager from '../data-track/outgoing/OutgoingDataTrackManager';
+import type { DataTrackOptions } from '../data-track/outgoing/types';
 import type { PerformRpcParams, RpcInvocationData } from '../rpc';
 import { RpcError } from '../rpc';
 import LocalTrack from '../track/LocalTrack';
@@ -38,12 +41,13 @@ export default class LocalParticipant extends Participant {
     private firstActiveAgent?;
     private rpcHandlers;
     private roomOutgoingDataStreamManager;
+    private roomOutgoingDataTrackManager;
     private pendingSignalRequests;
     private enabledPublishVideoCodecs;
     private pendingAcks;
     private pendingResponses;
     /** @internal */
-    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>, roomOutgoingDataStreamManager: OutgoingDataStreamManager);
+    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>, roomOutgoingDataStreamManager: OutgoingDataStreamManager, roomOutgoingDataTrackManager: OutgoingDataTrackManager);
     get lastCameraError(): Error | undefined;
     get lastMicrophoneError(): Error | undefined;
     get isE2EEEnabled(): boolean;
@@ -261,5 +265,11 @@ export default class LocalParticipant extends Participant {
     private handleTrackEnded;
     private getPublicationForTrack;
     private waitForPendingPublicationOfSource;
+    /** Publishes a data track.
+     *
+     * Returns the published data track if successful. Use {@link LocalDataTrack#tryPush}
+     * to send data frames on the track.
+     */
+    publishDataTrack(options: DataTrackOptions): Promise<LocalDataTrack>;
 }
 //# sourceMappingURL=LocalParticipant.d.ts.map

package/dist/ts4.2/room/participant/RemoteParticipant.d.ts

@@ -1,5 +1,7 @@
 import type { ParticipantInfo } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
+import { DeferrableMap } from '../../utils/deferrable-map';
+import type RemoteDataTrack from '../data-track/RemoteDataTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import type { AudioOutputOptions } from '../track/options';
@@ -11,13 +13,20 @@ export default class RemoteParticipant extends Participant {
     audioTrackPublications: Map<string, RemoteTrackPublication>;
     videoTrackPublications: Map<string, RemoteTrackPublication>;
     trackPublications: Map<string, RemoteTrackPublication>;
+    /** A map of data track name to the corresponding {@link RemoteDataTrack}.
+     * @example
+     * // An already existing data track:
+     * const track = remoteParticipant.dataTracks.get("data track name");
+     * // Wait for a data track which will be published soon:
+     * const track = await remoteParticipant.dataTracks.getDeferred("data track name"); */
+    dataTracks: DeferrableMap<RemoteDataTrack['info']['name'], RemoteDataTrack>;
     signalClient: SignalClient;
     private volumeMap;
     private audioOutput?;
     /** @internal */
     static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo, loggerOptions: LoggerOptions): RemoteParticipant;
     protected get logContext(): {
-        rpID: string;
+        remoteParticipantID: string;
         remoteParticipant: string;
     };
     /** @internal */
@@ -53,6 +62,10 @@ export default class RemoteParticipant extends Participant {
      */
     setAudioOutput(output: AudioOutputOptions): Promise<void>;
     /** @internal */
+    addRemoteDataTrack(remoteDataTrack: RemoteDataTrack): void;
+    /** @internal */
+    removeRemoteDataTrack(remoteDataTrackSid: RemoteDataTrack['info']['sid']): void;
+    /** @internal */
     emit<E extends keyof ParticipantEventCallbacks>(event: E, ...args: Parameters<ParticipantEventCallbacks[E]>): boolean;
 }
 //# sourceMappingURL=RemoteParticipant.d.ts.map

package/dist/ts4.2/room/token-source/TokenSource.d.ts

@@ -11,7 +11,7 @@ declare abstract class TokenSourceCached extends TokenSourceConfigurable {
     private isSameAsCachedFetchOptions;
     private shouldReturnCachedValueFromFetch;
     getCachedResponseJwtPayload(): import("./types").TokenPayload | null;
-    fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
     protected abstract update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
 }
 type LiteralOrFn = TokenSourceResponseObject | (() => TokenSourceResponseObject | Promise<TokenSourceResponseObject>);

package/dist/ts4.2/room/token-source/types.d.ts

@@ -62,6 +62,7 @@ export type TokenSourceFetchOptions = {
  */
 export declare abstract class TokenSourceConfigurable {
     abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    abstract fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
 }
 /** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */
 export type TokenSourceBase = TokenSourceFixed | TokenSourceConfigurable;

package/dist/ts4.2/room/utils.d.ts

@@ -1,7 +1,7 @@
 import { ChatMessage as ChatMessageModel, ClientInfo, DisconnectReason, Transcription as TranscriptionModel } from '@livekit/protocol';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import TypedPromise from '../utils/TypedPromise';
 import type { BrowserDetails } from '../utils/browserParser';
-import type { Throws } from '../utils/throws';
 import type { ConnectionError } from './errors';
 import type LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';
@@ -145,4 +145,5 @@ export declare function isLocalParticipant(p: Participant): p is LocalParticipan
 export declare function isRemoteParticipant(p: Participant): p is RemoteParticipant;
 export declare function splitUtf8(s: string, n: number): Uint8Array[];
 export declare function extractMaxAgeFromRequestHeaders(headers: Headers): number | undefined;
+export declare function isCompressionStreamSupported(): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/utils/abort-signal-polyfill.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Implementation of AbortSignal.any
+ * Creates a signal that will be aborted when any of the given signals is aborted.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
+ */
+export declare function abortSignalAny(signals: Array<AbortSignal>): AbortSignal;
+/**
+ * Implementation of AbortSignal.timeout
+ * Creates a signal that will be aborted after the specified timeout.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
+ */
+export declare function abortSignalTimeout(ms: number): AbortSignal;
+//# sourceMappingURL=abort-signal-polyfill.d.ts.map

package/dist/ts4.2/utils/deferrable-map.d.ts

@@ -0,0 +1,32 @@
+import type { Throws } from '@livekit/throws-transformer/throws';
+/** An error which is thrown if a {@link DeferrableMap#getDeferred} call is aborted midway
+ * through. */
+export declare class DeferrableMapAbortError extends DOMException {
+    reason: unknown;
+    constructor(message: string, reason?: unknown);
+}
+/**
+ * A Map-like container keyed by unique strings that supports the ability to wait
+ * for future keys to show up in the map.
+ *
+ * @example
+ * // An already existing key:
+ * const value = map.get("key");
+ * // Wait for a key which will be added soon:
+ * const value = await map.getDeferred("key");
+ */
+export declare class DeferrableMap<K, V> extends Map<K, V> {
+    private pending;
+    set(key: K, value: V): this;
+    get [Symbol.toStringTag](): string;
+    /**
+     * Returns the value for `key` immediately if it exists, otherwise returns a
+     * promise that resolves once `set(key, value)` is called.
+     *
+     * If an `AbortSignal` is provided and it is aborted before the key appears,
+     * the returned promise rejects with an {@link DeferrableMapAbortError}.
+     */
+    getDeferred(key: K): Promise<V>;
+    getDeferred(key: K, signal: AbortSignal): Promise<Throws<V, DeferrableMapAbortError>>;
+}
+//# sourceMappingURL=deferrable-map.d.ts.map

package/dist/ts4.2/utils/subscribeToEvents.d.ts

@@ -6,6 +6,9 @@ export declare function subscribeToEvents<Callbacks extends EventMap, EventNames
     /** Listen for the next occurrance of an event to be emitted, or return the last event that was
      * buffered (but hasn't been processed yet). */
     waitFor<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): Promise<EventPayload>;
+    /** Are there events of the given name which are waiting to be processed? Use this to assert
+     * that no unexpected events have been emitted. */
+    areThereBufferedEvents<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): boolean;
     /** Cleanup any lingering subscriptions. */
     unsubscribe: () => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.17.3",
+  "version": "2.18.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -56,6 +56,7 @@
     "@changesets/cli": "2.29.8",
     "@eslint/js": "9.39.2",
     "@livekit/changesets-changelog-github": "^0.0.4",
+    "@livekit/throws-transformer": "^0.1.3",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "28.0.9",
     "@rollup/plugin-json": "6.1.0",
@@ -86,6 +87,7 @@
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
+    "tsx": "^4.21.0",
     "typedoc": "0.28.16",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
@@ -107,7 +109,7 @@
     "deploy": "gh-pages -d examples/demo/dist",
     "format": "prettier --write src examples/**/*.ts",
     "format:check": "prettier --check src examples/**/*.ts",
-    "throws:check": "pnpm dlx tsx ./throws-transformer/cli.ts 'src/!(*.test).ts' 'src/**/!(*.test).ts'",
+    "throws:check": "pnpm --package=@livekit/throws-transformer dlx throws-check 'src/!(*.test).ts' 'src/**/!(*.test).ts'",
     "ci:publish": "pnpm build:clean && pnpm compat && changeset publish",
     "downlevel-dts": "downlevel-dts ./dist/src ./dist/ts4.2 --to=4.2",
     "compat": "eslint --config ./eslint.config.dist.mjs --no-inline-config  ./dist/livekit-client.esm.mjs",

package/src/api/SignalClient.test.ts

@@ -300,8 +300,10 @@ describe('SignalClient.connect', () => {
 
   describe('Failure Case - WebSocket Connection Errors', () => {
     it('should reject with NotAllowed error for 4xx HTTP status', async () => {
+      const openedPromise = Promise.reject(new Error('Connection failed'));
+      openedPromise.catch(() => {}); // prevent unhandled rejection before join attaches its handler
       mockWebSocketStream({
-        opened: Promise.reject(new Error('Connection failed')),
+        opened: openedPromise,
         readyState: 3,
       });
 
@@ -321,8 +323,10 @@ describe('SignalClient.connect', () => {
     });
 
     it('should reject with ServerUnreachable when fetch fails', async () => {
+      const openedPromise = Promise.reject(new Error('Connection failed'));
+      openedPromise.catch(() => {}); // prevent unhandled rejection before join attaches its handler
       mockWebSocketStream({
-        opened: Promise.reject(new Error('Connection failed')),
+        opened: openedPromise,
         readyState: 3,
       });
 
@@ -338,9 +342,10 @@ describe('SignalClient.connect', () => {
 
     it('should handle ConnectionError from WebSocket rejection', async () => {
       const customError = ConnectionError.internal('Custom error', { status: 500 });
-
+      const openedPromise = Promise.reject(customError);
+      openedPromise.catch(() => {}); // prevent unhandled rejection before join attaches its handler
       mockWebSocketStream({
-        opened: Promise.reject(customError),
+        opened: openedPromise,
         readyState: 3,
       });
 

package/src/api/SignalClient.ts

@@ -5,7 +5,9 @@ import {
   ClientInfo,
   ConnectionQualityUpdate,
   ConnectionSettings,
+  DataTrackSubscriberHandles,
   DisconnectReason,
+  Encryption_Type,
   JoinRequest,
   JoinResponse,
   LeaveRequest,
@@ -14,6 +16,8 @@ import {
   MuteTrackRequest,
   ParticipantInfo,
   Ping,
+  PublishDataTrackRequest,
+  PublishDataTrackResponse,
   ReconnectReason,
   ReconnectResponse,
   RequestResponse,
@@ -35,6 +39,10 @@ import {
   TrackPublishedResponse,
   TrackUnpublishedResponse,
   TrickleRequest,
+  UnpublishDataTrackRequest,
+  UnpublishDataTrackResponse,
+  UpdateDataSubscription,
+  UpdateDataSubscription_Update,
   UpdateLocalAudioTrack,
   UpdateParticipantMetadata,
   UpdateSubscription,
@@ -42,13 +50,16 @@ import {
   UpdateVideoLayers,
   VideoLayer,
   WrappedJoinRequest,
+  WrappedJoinRequest_Compression,
   protoInt64,
 } from '@livekit/protocol';
 import log, { LoggerNames, getLogger } from '../logger';
+import type { DataTrackHandle } from '../room/data-track/handle';
+import { type DataTrackSid } from '../room/data-track/types';
 import { ConnectionError } from '../room/errors';
 import CriticalTimers from '../room/timers';
 import type { LoggerOptions } from '../room/types';
-import { getClientInfo, isReactNative, sleep } from '../room/utils';
+import { getClientInfo, isCompressionStreamSupported, isReactNative, sleep } from '../room/utils';
 import { AsyncQueue } from '../utils/AsyncQueue';
 import { type WebSocketConnection, WebSocketStream } from './WebSocketStream';
 import {
@@ -174,6 +185,14 @@ export class SignalClient {
 
   onMediaSectionsRequirement?: (requirement: MediaSectionsRequirement) => void;
 
+  onPublishDataTrackResponse?: (event: PublishDataTrackResponse) => void;
+
+  onUnPublishDataTrackResponse?: (event: UnpublishDataTrackResponse) => void;
+
+  onDataTrackSubscriberHandles?: (event: DataTrackSubscriberHandles) => void;
+
+  onJoined?: (event: JoinResponse) => void;
+
   connectOptions?: ConnectOpts;
 
   ws?: WebSocketStream;
@@ -248,12 +267,13 @@ export class SignalClient {
     opts: SignalOptions,
     abortSignal?: AbortSignal,
     useV0Path: boolean = false,
+    publisherOffer?: SessionDescription,
   ): Promise<JoinResponse> {
     // during a full reconnect, we'd want to start the sequence even if currently
     // connected
     this.state = SignalConnectionState.CONNECTING;
     this.options = opts;
-    const res = await this.connect(url, token, opts, abortSignal, useV0Path);
+    const res = await this.connect(url, token, opts, abortSignal, useV0Path, publisherOffer);
     return res as JoinResponse;
   }
 
@@ -296,6 +316,7 @@ export class SignalClient {
     abortSignal?: AbortSignal,
     /** setting this to true results in dual peer connection mode being used */
     useV0Path: boolean = false,
+    publisherOffer?: SessionDescription,
   ): Promise<JoinResponse | ReconnectResponse | undefined> {
     const unlock = await this.connectionLock.lock();
 
@@ -305,7 +326,7 @@ export class SignalClient {
     const clientInfo = getClientInfo();
     const params = useV0Path
       ? createConnectionParams(token, clientInfo, opts)
-      : createJoinRequestConnectionParams(token, clientInfo, opts);
+      : await createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
     const rtcUrl = createRtcUrl(url, params, useV0Path).toString();
     const validateUrl = createValidateUrl(rtcUrl).toString();
 
@@ -437,8 +458,9 @@ export class SignalClient {
             return;
           }
 
-          // Handle join response - set up ping configuration
+          // Handle join response
           if (firstSignalResponse.message?.case === 'join') {
+            // Set up ping configuration
             this.pingTimeoutDuration = firstSignalResponse.message.value.pingTimeout;
             this.pingIntervalDuration = firstSignalResponse.message.value.pingInterval;
 
@@ -449,6 +471,10 @@ export class SignalClient {
                 interval: this.pingIntervalDuration,
               });
             }
+
+            if (this.onJoined) {
+              this.onJoined(firstSignalResponse.message.value);
+            }
           }
 
           // Handle successful connection
@@ -685,7 +711,40 @@ export class SignalClient {
     });
   }
 
-  async sendRequest(message: SignalMessage, fromQueue: boolean = false) {
+  sendPublishDataTrackRequest(handle: DataTrackHandle, name: string, usesE2ee: boolean) {
+    return this.sendRequest({
+      case: 'publishDataTrackRequest',
+      value: new PublishDataTrackRequest({
+        pubHandle: handle,
+        name: name,
+        encryption: usesE2ee ? Encryption_Type.GCM : Encryption_Type.NONE,
+      }),
+    });
+  }
+
+  sendUnPublishDataTrackRequest(handle: DataTrackHandle) {
+    return this.sendRequest({
+      case: 'unpublishDataTrackRequest',
+      value: new UnpublishDataTrackRequest({ pubHandle: handle }),
+    });
+  }
+
+  sendUpdateDataSubscription(sid: DataTrackSid, subscribe: boolean) {
+    return this.sendRequest({
+      case: 'updateDataSubscription',
+      value: new UpdateDataSubscription({
+        // FIXME: consider refactoring to allow caller to pass an array of events through
+        updates: [
+          new UpdateDataSubscription_Update({
+            trackSid: sid,
+            subscribe,
+          }),
+        ],
+      }),
+    });
+  }
+
+  private async sendRequest(message: SignalMessage, fromQueue: boolean = false) {
     // capture all requests while reconnecting and put them in a queue
     // unless the request originates from the queue, then don't enqueue again
     const canQueue = !fromQueue && !canPassThroughQueue(message);
@@ -827,6 +886,18 @@ export class SignalClient {
       if (this.onMediaSectionsRequirement) {
         this.onMediaSectionsRequirement(msg.value);
       }
+    } else if (msg.case === 'publishDataTrackResponse') {
+      if (this.onPublishDataTrackResponse) {
+        this.onPublishDataTrackResponse(msg.value);
+      }
+    } else if (msg.case === 'unpublishDataTrackResponse') {
+      if (this.onUnPublishDataTrackResponse) {
+        this.onUnPublishDataTrackResponse(msg.value);
+      }
+    } else if (msg.case === 'dataTrackSubscriberHandles') {
+      if (this.onDataTrackSubscriberHandles) {
+        this.onDataTrackSubscriberHandles(msg.value);
+      }
     } else {
       this.log.debug('unsupported message', { ...this.logContext, msgCase: msg.case });
     }
@@ -1125,11 +1196,12 @@ function createConnectionParams(
   return params;
 }
 
-function createJoinRequestConnectionParams(
+async function createJoinRequestConnectionParams(
   token: string,
   info: ClientInfo,
   opts: ConnectOpts,
-): URLSearchParams {
+  publisherOffer?: SessionDescription,
+): Promise<URLSearchParams> {
   const params = new URLSearchParams();
   params.set('access_token', token);
 
@@ -1141,14 +1213,49 @@ function createJoinRequestConnectionParams(
     }),
     reconnect: !!opts.reconnect,
     participantSid: opts.sid ? opts.sid : undefined,
+    publisherOffer: publisherOffer,
   });
   if (opts.reconnectReason) {
     joinRequest.reconnectReason = opts.reconnectReason;
   }
+  const joinRequestBytes = joinRequest.toBinary();
+  let requestBytes: Uint8Array;
+  let compression: WrappedJoinRequest_Compression;
+  if (isCompressionStreamSupported()) {
+    const stream = new CompressionStream('gzip');
+    const writer = stream.writable.getWriter();
+    writer.write(new Uint8Array(joinRequestBytes));
+    writer.close();
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    requestBytes = result;
+    compression = WrappedJoinRequest_Compression.GZIP;
+  } else {
+    requestBytes = joinRequestBytes;
+    compression = WrappedJoinRequest_Compression.NONE;
+  }
   const wrappedJoinRequest = new WrappedJoinRequest({
-    joinRequest: joinRequest.toBinary(),
+    joinRequest: requestBytes,
+    compression,
   });
-  params.set('join_request', btoa(new TextDecoder('utf-8').decode(wrappedJoinRequest.toBinary())));
+  const wrappedBytes = wrappedJoinRequest.toBinary();
+  const bytesToBase64 = (bytes: Uint8Array) => {
+    const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join('');
+    return btoa(binString);
+  };
+  params.set('join_request', bytesToBase64(wrappedBytes).replace(/\+/g, '-').replace(/\//g, '_'));
 
   return params;
 }

package/src/e2ee/constants.ts

@@ -37,6 +37,7 @@ export const KEY_PROVIDER_DEFAULTS: KeyProviderOptions = {
   ratchetWindowSize: 8,
   failureTolerance: DECRYPTION_FAILURE_TOLERANCE,
   keyringSize: 16,
+  keySize: 128,
 } as const;
 
 export const MAX_SIF_COUNT = 100;

package/src/e2ee/types.ts

@@ -183,6 +183,12 @@ export type KeyProviderOptions = {
   ratchetWindowSize: number;
   failureTolerance: number;
   keyringSize: number;
+  /**
+   * Size of the encryption key in bits.
+   * Defaults to 128. Note that 128 is currently the only value
+   * supported by non-web SDKs.
+   */
+  keySize: 128 | 256;
 };
 
 export type KeyInfo = {

package/src/e2ee/utils.ts

@@ -1,5 +1,6 @@
 import { type DataPacket, EncryptedPacketPayload } from '@livekit/protocol';
 import { ENCRYPTION_ALGORITHM } from './constants';
+import type { KeyProviderOptions } from './types';
 
 export function isE2EESupported() {
   return isInsertableStreamSupported() || isScriptTransformSupported();
@@ -92,8 +93,8 @@ function getAlgoOptions(algorithmName: string, salt: string) {
  * Derives a set of keys from the master key.
  * See https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.1
  */
-export async function deriveKeys(material: CryptoKey, salt: string) {
-  const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+export async function deriveKeys(material: CryptoKey, options: KeyProviderOptions) {
+  const algorithmOptions = getAlgoOptions(material.algorithm.name, options.ratchetSalt);
 
   // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveKey#HKDF
   // https://developer.mozilla.org/en-US/docs/Web/API/HkdfParams
@@ -102,7 +103,7 @@ export async function deriveKeys(material: CryptoKey, salt: string) {
     material,
     {
       name: ENCRYPTION_ALGORITHM,
-      length: 128,
+      length: options.keySize,
     },
     false,
     ['encrypt', 'decrypt'],

package/src/e2ee/worker/DataCryptor.ts

@@ -93,10 +93,7 @@ export class DataCryptor {
             // if not, it might be that a different frame has already ratcheted and we try with that one first
             ratchetResult = await keys.ratchetKey(keyIndex, false);
 
-            ratchetedKeySet = await deriveKeys(
-              ratchetResult.cryptoKey,
-              keys.keyProviderOptions.ratchetSalt,
-            );
+            ratchetedKeySet = await deriveKeys(ratchetResult.cryptoKey, keys.keyProviderOptions);
           }
 
           const decryptedData = await DataCryptor.decrypt(

package/src/e2ee/worker/FrameCryptor.ts

@@ -603,10 +603,7 @@ export class FrameCryptor extends BaseFrameCryptor {
             // if not, it might be that a different frame has already ratcheted and we try with that one first
             ratchetResult = await this.keys.ratchetKey(keyIndex, false);
 
-            ratchetedKeySet = await deriveKeys(
-              ratchetResult.cryptoKey,
-              this.keyProviderOptions.ratchetSalt,
-            );
+            ratchetedKeySet = await deriveKeys(ratchetResult.cryptoKey, this.keyProviderOptions);
           }
 
           const frame = await this.decryptFrame(encodedFrame, keyIndex, initialMaterial || keySet, {

package/src/e2ee/worker/ParticipantKeyHandler.ts

@@ -173,7 +173,7 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
     ratchetedResult: RatchetResult | null = null,
     updateCurrentKeyIndex = true,
   ) {
-    const keySet = await deriveKeys(material, this.keyProviderOptions.ratchetSalt);
+    const keySet = await deriveKeys(material, this.keyProviderOptions);
     const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : this.currentKeyIndex;
     workerLogger.debug(`setting new key with index ${keyIndex}`, {
       usage: material.usages,