livekit-client 2.18.0 → 2.18.2

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

@@ -1,22 +1,23 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
-import type { EncryptionProvider } from '../e2ee';
-import type { DataTrackFrame } from '../frame';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackPacket } from '../packet';
 import type { DataTrackInfo } from '../types';
 import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
 type Options = {
     info: DataTrackInfo;
-    encryptionProvider: EncryptionProvider | null;
+    e2eeManager: BaseE2EEManager | null;
 };
 /** Processes outgoing frames into final packets for distribution to the SFU. */
 export default class DataTrackOutgoingPipeline {
-    private encryptionProvider;
+    private e2eeManager;
     private packetizer;
     /** Maximum transmission unit (MTU) of the transport. */
     private static TRANSPORT_MTU_BYTES;
     constructor(options: Options);
-    processFrame(frame: DataTrackFrame): Throws<Generator<DataTrackPacket>, DataTrackOutgoingPipelineError>;
-    encryptIfNeeded(frame: DataTrackFrame): Throws<DataTrackFrame, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>;
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    processFrame(frame: DataTrackFrameInternal): Throws<AsyncGenerator<DataTrackPacket>, DataTrackOutgoingPipelineError>;
+    encryptIfNeeded(frame: DataTrackFrameInternal): Promise<Throws<DataTrackFrameInternal, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>>;
 }
 export {};
 //# sourceMappingURL=pipeline.d.ts.map

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

@@ -1,5 +1,6 @@
+import type LocalDataTrack from '../LocalDataTrack';
 import type { DataTrackHandle } from '../handle';
-import type { DataTrackInfo } from '../types';
+import type { DataTrackInfo, DataTrackSid } from '../types';
 import type { DataTrackPublishError, DataTrackPublishErrorReason } from './errors';
 /** Options for publishing a data track. */
 export type DataTrackOptions = {
@@ -11,7 +12,7 @@ export type SfuPublishResponseResult = {
     data: DataTrackInfo;
 } | {
     type: 'error';
-    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
 };
 /** Request sent to the SFU to publish a track. */
 export type EventSfuPublishRequest = {
@@ -23,8 +24,17 @@ export type EventSfuPublishRequest = {
 export type EventSfuUnpublishRequest = {
     handle: DataTrackHandle;
 };
-/** Serialized packets are ready to be sent over the transport. */
-export type EventPacketsAvailable = {
+/** A serialized packet is ready to be sent over the transport. */
+export type EventPacketAvailable = {
     bytes: Uint8Array;
 };
+/** A track has been created by a local participant and is available to be
+ * subscribed to. */
+export type EventTrackPublished = {
+    track: LocalDataTrack;
+};
+/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+export type EventTrackUnpublished = {
+    sid: DataTrackSid;
+};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,6 +1,6 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
 import { LivekitReasonedError } from '../errors';
-import type { DataTrackFrame } from './frame';
+import type { DataTrackFrameInternal } from './frame';
 import { DataTrackHandle } from './handle';
 import { DataTrackPacket, FrameMarker } from './packet';
 import { DataTrackTimestamp } from './utils';
@@ -21,7 +21,7 @@ export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizer
 export declare enum DataTrackPacketizerReason {
     MtuTooShort = 0
 }
-/** A packetizer takes a {@link DataTrackFrame} as input and generates a series
+/** A packetizer takes a {@link DataTrackFrameInternal} as input and generates a series
  * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
 export default class DataTrackPacketizer {
     private handle;
@@ -32,12 +32,12 @@ export default class DataTrackPacketizer {
     constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number);
     /** @internal */
     static computeFrameMarker(index: number, packetCount: number): FrameMarker;
-    /** Generates a series of packets for the specified {@link DataTrackPacketizerFrame}.
+    /** Generates a series of packets for the specified {@link DataTrackFrameInternal}.
      *
      * NOTE: The return value of this function is a generator, so it can be lazily ran if desired,
      * or converted to an array with {@link Array.from}.
      */
-    packetize(frame: DataTrackFrame, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError>;
+    packetize(frame: DataTrackFrameInternal, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError>;
 }
 export {};
 //# sourceMappingURL=packetizer.d.ts.map

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

@@ -17,7 +17,7 @@ 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;
+    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

@@ -1,10 +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;
+    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';
@@ -32,18 +35,20 @@ export default class LocalParticipant extends Participant {
     private allParticipantsAllowedToSubscribe;
     private roomOptions;
     private encryptionType;
+    private e2eeStateMutex;
     private reconnectFuture?;
     private signalConnectedFuture?;
     private activeAgentFuture?;
     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 +266,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,6 +13,13 @@ 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?;
@@ -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/utils.d.ts

@@ -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/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/serializer.d.ts

@@ -0,0 +1,48 @@
+declare const SerializerSymbol: unique symbol;
+/**
+ * A bidirectional data format descriptor for message payloads.
+ *
+ * - `parse(raw)` decodes an incoming wire string into `Input` (used by handlers)
+ * - `serialize(val)` encodes an `Output` value to a wire string (used by handlers)
+ *
+ * For symmetric serializers (`serializers.raw`), `Input === Output === string`.
+ * For `serializers.json`, both default to `any` so each handler can annotate its own types.
+ * Use `serializers.custom` to supply your own `parse`/`serialize` pair.
+ *
+ * @beta
+ */
+export type Serializer<Input, Output> = {
+    symbol: typeof SerializerSymbol;
+    parse: (raw: string) => Input;
+    serialize: (val: Output) => string;
+};
+export declare function isSerializer(v: unknown): v is Serializer<any, any>;
+export type SerializerInput<S> = S extends Serializer<infer Input, any> ? Input : any;
+export type SerializerOutput<S> = S extends Serializer<any, infer Output> ? Output : any;
+/**
+ * JSON serializer — `JSON.parse` on the way in, `JSON.stringify` on the way out.
+ * Defaults to `any` so individual handlers can annotate their own payload types.
+ */
+declare function json<Input = any, Output = any>(): Serializer<Input, Output>;
+/** Raw string serializer — passes payloads through as plain strings with no encoding. */
+declare function raw(): Serializer<string, string>;
+/** Custom serializer - allows custom defined parse and serialize functions */
+declare function custom<Input = any, Output = any>(params: Omit<Serializer<Input, Output>, 'symbol'>): Serializer<Input, Output>;
+/**
+ * Serializer helpers for message payload encoding.
+ *
+ * @example
+ * ```ts
+ * const a = serializers.raw(); // Serializer<string, string>
+ * const b = serializer.json<{ foo: string }, { bar: string }>(); // Serializer<{ foo: string }, { bar: string }>
+ * ```
+ *
+ * @beta
+ */
+export declare const serializers: {
+    json: typeof json;
+    raw: typeof raw;
+    custom: typeof custom;
+};
+export {};
+//# sourceMappingURL=serializer.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.18.0",
+  "version": "2.18.2",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",

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/connectionHelper/ConnectionCheck.ts

@@ -11,7 +11,7 @@ import { TURNCheck } from './checks/turn';
 import { WebRTCCheck } from './checks/webrtc';
 import { WebSocketCheck } from './checks/websocket';
 
-export type { CheckInfo, CheckStatus };
+export { type CheckInfo, CheckStatus };
 
 export class ConnectionCheck extends (EventEmitter as new () => TypedEmitter<ConnectionCheckCallbacks>) {
   token: string;

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 = {