livekit-client 2.15.7 → 2.15.9

package/dist/ts4.2/{src/api → api}/SignalClient.d.ts

@@ -1,6 +1,7 @@
-import { AddTrackRequest, AudioTrackFeature, ConnectionQualityUpdate, JoinResponse, LeaveRequest, ParticipantInfo, ReconnectReason, ReconnectResponse, RequestResponse, Room, RoomMovedResponse, SessionDescription, SignalRequest, SignalTarget, SimulateScenario, SpeakerInfo, StreamStateUpdate, SubscribedQualityUpdate, SubscriptionPermissionUpdate, SubscriptionResponse, SyncState, TrackPermission, TrackPublishedResponse, TrackUnpublishedResponse, UpdateSubscription, UpdateTrackSettings, VideoLayer } from '@livekit/protocol';
+import { AddTrackRequest, AudioTrackFeature, ConnectionQualityUpdate, JoinResponse, LeaveRequest, MediaSectionsRequirement, ParticipantInfo, ReconnectReason, ReconnectResponse, RequestResponse, Room, RoomMovedResponse, SessionDescription, SignalRequest, SignalResponse, SignalTarget, SimulateScenario, SpeakerInfo, StreamStateUpdate, SubscribedQualityUpdate, SubscriptionPermissionUpdate, SubscriptionResponse, SyncState, TrackPermission, TrackPublishedResponse, TrackUnpublishedResponse, UpdateSubscription, UpdateTrackSettings, VideoLayer } from '@livekit/protocol';
 import type { LoggerOptions } from '../room/types';
 import { AsyncQueue } from '../utils/AsyncQueue';
+import { WebSocketStream } from './WebSocketStream';
 interface ConnectOpts extends SignalOptions {
     /** internal */
     reconnect?: boolean;
@@ -15,6 +16,7 @@ export interface SignalOptions {
     maxRetries: number;
     e2eeEnabled: boolean;
     websocketTimeout: number;
+    singlePeerConnection: boolean;
 }
 type SignalMessage = SignalRequest['message'];
 export declare enum SignalConnectionState {
@@ -54,8 +56,9 @@ export declare class SignalClient {
     onRequestResponse?: (response: RequestResponse) => void;
     onLocalTrackSubscribed?: (trackSid: string) => void;
     onRoomMoved?: (res: RoomMovedResponse) => void;
+    onMediaSectionsRequirement?: (requirement: MediaSectionsRequirement) => void;
     connectOptions?: ConnectOpts;
-    ws?: WebSocket;
+    ws?: WebSocketStream;
     get currentState(): SignalConnectionState;
     get isDisconnected(): boolean;
     private get isEstablishingConnection();
@@ -71,11 +74,13 @@ export declare class SignalClient {
     private log;
     private loggerContextCb?;
     private _requestId;
+    private streamWriter;
     constructor(useJSON?: boolean, loggerOptions?: LoggerOptions);
     private get logContext();
     join(url: string, token: string, opts: SignalOptions, abortSignal?: AbortSignal): Promise<JoinResponse>;
     reconnect(url: string, token: string, sid?: string, reason?: ReconnectReason): Promise<ReconnectResponse | undefined>;
     private connect;
+    startReadingLoop(signalReader: ReadableStreamDefaultReader<string | ArrayBuffer>, firstMessage?: SignalResponse): Promise<void>;
     /** @internal */
     resetCallbacks: () => void;
     close(updateState?: boolean): Promise<void>;
@@ -113,6 +118,30 @@ export declare class SignalClient {
     private clearPingTimeout;
     private startPingInterval;
     private clearPingInterval;
+    /**
+     * Handles the successful connection to the signal server
+     * @param connection The WebSocket connection
+     * @param timeoutHandle The timeout handle to clear
+     * @param firstMessage Optional first message to process
+     * @internal
+     */
+    private handleSignalConnected;
+    /**
+     * Validates the first message received from the signal server
+     * @param firstSignalResponse The first signal response received
+     * @param isReconnect Whether this is a reconnection attempt
+     * @returns Validation result with response or error
+     * @internal
+     */
+    private validateFirstMessage;
+    /**
+     * Handles WebSocket connection errors by validating with the server
+     * @param reason The error that occurred
+     * @param validateUrl The URL to validate the connection with
+     * @returns A ConnectionError with appropriate reason and status
+     * @internal
+     */
+    private handleConnectionError;
 }
 export declare function toProtoSessionDescription(rsd: RTCSessionDescription | RTCSessionDescriptionInit, id?: number): SessionDescription;
 export {};

package/dist/ts4.2/api/WebSocketStream.d.ts

@@ -0,0 +1,29 @@
+export interface WebSocketConnection<T extends ArrayBuffer | string = ArrayBuffer | string> {
+    readable: ReadableStream<T>;
+    writable: WritableStream<T>;
+    protocol: string;
+    extensions: string;
+}
+export interface WebSocketCloseInfo {
+    closeCode?: number;
+    reason?: string;
+}
+export interface WebSocketStreamOptions {
+    protocols?: string[];
+    signal?: AbortSignal;
+}
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export declare class WebSocketStream<T extends ArrayBuffer | string = ArrayBuffer | string> {
+    readonly url: string;
+    readonly opened: Promise<WebSocketConnection<T>>;
+    readonly closed: Promise<WebSocketCloseInfo>;
+    readonly close: (closeInfo?: WebSocketCloseInfo) => void;
+    get readyState(): number;
+    private ws;
+    constructor(url: string, options?: WebSocketStreamOptions);
+}
+//# sourceMappingURL=WebSocketStream.d.ts.map

package/dist/ts4.2/{src/api → api}/utils.d.ts

@@ -1,3 +1,5 @@
+import { SignalResponse } from '@livekit/protocol';
 export declare function createRtcUrl(url: string, searchParams: URLSearchParams): string;
 export declare function createValidateUrl(rtcWsUrl: string): string;
+export declare function parseSignalResponse(value: ArrayBuffer | string): SignalResponse;
 //# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/{src/e2ee → e2ee}/E2eeManager.d.ts

@@ -2,12 +2,16 @@ import type TypedEventEmitter from 'typed-emitter';
 import type RTCEngine from '../room/RTCEngine';
 import type Room from '../room/Room';
 import type { E2EEManagerCallbacks } from './events';
-import type { E2EEManagerOptions } from './types';
+import type { DecryptDataResponseMessage, E2EEManagerOptions, EncryptDataResponseMessage } from './types';
 export interface BaseE2EEManager {
     setup(room: Room): void;
     setupEngine(engine: RTCEngine): void;
+    isEnabled: boolean;
+    isDataChannelEncryptionEnabled: boolean;
     setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string): void;
     setSifTrailer(trailer: Uint8Array): void;
+    encryptData(data: Uint8Array): Promise<EncryptDataResponseMessage['data']>;
+    handleEncryptedData(payload: Uint8Array, iv: Uint8Array, participantIdentity: string, keyIndex: number): Promise<DecryptDataResponseMessage['data']>;
     on<E extends keyof E2EEManagerCallbacks>(event: E, listener: E2EEManagerCallbacks[E]): this;
 }
 declare const E2EEManager_base: new () => TypedEventEmitter<E2EEManagerCallbacks>;
@@ -19,7 +23,12 @@ export declare class E2EEManager extends E2EEManager_base implements BaseE2EEMan
     protected room?: Room;
     private encryptionEnabled;
     private keyProvider;
-    constructor(options: E2EEManagerOptions);
+    private decryptDataRequests;
+    private encryptDataRequests;
+    private dataChannelEncryptionEnabled;
+    constructor(options: E2EEManagerOptions, dcEncryptionEnabled: boolean);
+    get isEnabled(): boolean;
+    get isDataChannelEncryptionEnabled(): boolean;
     /**
      * @internal
      */
@@ -36,6 +45,11 @@ export declare class E2EEManager extends E2EEManager_base implements BaseE2EEMan
     private onWorkerError;
     setupEngine(engine: RTCEngine): void;
     private setupEventListeners;
+    encryptData(data: Uint8Array): Promise<EncryptDataResponseMessage['data']>;
+    handleEncryptedData(payload: Uint8Array, iv: Uint8Array, participantIdentity: string, keyIndex: number): Promise<{
+        uuid: string;
+        payload: Uint8Array;
+    }>;
     private postRatchetRequest;
     private postKey;
     private postEnable;

package/dist/ts4.2/{src/e2ee → e2ee}/types.d.ts

@@ -95,7 +95,41 @@ export interface InitAck extends BaseMessage {
         enabled: boolean;
     };
 }
-export type E2EEWorkerMessage = InitMessage | SetKeyMessage | EncodeMessage | ErrorMessage | EnableMessage | RemoveTransformMessage | RTPVideoMapMessage | UpdateCodecMessage | RatchetRequestMessage | RatchetMessage | SifTrailerMessage | InitAck;
+export interface DecryptDataRequestMessage extends BaseMessage {
+    kind: 'decryptDataRequest';
+    data: {
+        uuid: string;
+        payload: Uint8Array;
+        iv: Uint8Array;
+        participantIdentity: string;
+        keyIndex: number;
+    };
+}
+export interface DecryptDataResponseMessage extends BaseMessage {
+    kind: 'decryptDataResponse';
+    data: {
+        uuid: string;
+        payload: Uint8Array;
+    };
+}
+export interface EncryptDataRequestMessage extends BaseMessage {
+    kind: 'encryptDataRequest';
+    data: {
+        uuid: string;
+        payload: Uint8Array;
+        participantIdentity: string;
+    };
+}
+export interface EncryptDataResponseMessage extends BaseMessage {
+    kind: 'encryptDataResponse';
+    data: {
+        uuid: string;
+        payload: Uint8Array;
+        iv: Uint8Array;
+        keyIndex: number;
+    };
+}
+export type E2EEWorkerMessage = InitMessage | SetKeyMessage | EncodeMessage | ErrorMessage | EnableMessage | RemoveTransformMessage | RTPVideoMapMessage | UpdateCodecMessage | RatchetRequestMessage | RatchetMessage | SifTrailerMessage | InitAck | DecryptDataRequestMessage | DecryptDataResponseMessage | EncryptDataRequestMessage | EncryptDataResponseMessage;
 export type KeySet = {
     material: CryptoKey;
     encryptionKey: CryptoKey;

package/dist/ts4.2/{src/e2ee → e2ee}/utils.d.ts

@@ -1,3 +1,5 @@
+import type { DataPacket } from '@livekit/protocol';
+import { EncryptedPacketPayload } from '@livekit/protocol';
 export declare function isE2EESupported(): boolean;
 export declare function isScriptTransformSupported(): boolean;
 export declare function isInsertableStreamSupported(): boolean;
@@ -24,4 +26,5 @@ export declare function ratchet(material: CryptoKey, salt: string): Promise<Arra
 export declare function needsRbspUnescaping(frameData: Uint8Array): boolean;
 export declare function parseRbsp(stream: Uint8Array): Uint8Array;
 export declare function writeRbsp(data_in: Uint8Array): Uint8Array;
+export declare function asEncryptablePacket(packet: DataPacket): EncryptedPacketPayload | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/e2ee/worker/DataCryptor.d.ts

@@ -0,0 +1,15 @@
+import type { DecodeRatchetOptions, KeySet } from '../types';
+import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
+export declare class DataCryptor {
+    private static sendCount;
+    private static makeIV;
+    static encrypt(data: Uint8Array, keys: ParticipantKeyHandler): Promise<{
+        payload: Uint8Array;
+        iv: Uint8Array;
+        keyIndex: number;
+    }>;
+    static decrypt(data: Uint8Array, iv: Uint8Array, keys: ParticipantKeyHandler, keyIndex?: number, initialMaterial?: KeySet, ratchetOpts?: DecodeRatchetOptions): Promise<{
+        payload: Uint8Array;
+    }>;
+}
+//# sourceMappingURL=DataCryptor.d.ts.map

package/dist/ts4.2/{src/e2ee → e2ee}/worker/ParticipantKeyHandler.d.ts

@@ -14,9 +14,10 @@ export declare class ParticipantKeyHandler extends ParticipantKeyHandler_base {
     private currentKeyIndex;
     private cryptoKeyRing;
     private decryptionFailureCounts;
-    private keyProviderOptions;
     private ratchetPromiseMap;
-    private participantIdentity;
+    readonly participantIdentity: string;
+    /** @internal */
+    readonly keyProviderOptions: KeyProviderOptions;
     /**
      * true if the current key has not been marked as invalid
      */

package/dist/ts4.2/{src/e2ee → e2ee}/worker/sifPayload.d.ts

@@ -1,10 +1,10 @@
 import type { VideoCodec } from '../..';
-export declare const VP8KeyFrame8x8: Uint8Array<ArrayBuffer>;
-export declare const H264KeyFrame2x2SPS: Uint8Array<ArrayBuffer>;
-export declare const H264KeyFrame2x2PPS: Uint8Array<ArrayBuffer>;
-export declare const H264KeyFrame2x2IDR: Uint8Array<ArrayBuffer>;
-export declare const H264KeyFrame2x2: Uint8Array<ArrayBuffer>[];
-export declare const OpusSilenceFrame: Uint8Array<ArrayBuffer>;
+export declare const VP8KeyFrame8x8: Uint8Array;
+export declare const H264KeyFrame2x2SPS: Uint8Array;
+export declare const H264KeyFrame2x2PPS: Uint8Array;
+export declare const H264KeyFrame2x2IDR: Uint8Array;
+export declare const H264KeyFrame2x2: Uint8Array[];
+export declare const OpusSilenceFrame: Uint8Array;
 /**
  * Pre-computed SHA-256 hashes for secure comparison operations
  */

package/dist/ts4.2/{src/index.d.ts → index.d.ts}

@@ -1,5 +1,5 @@
 import { Mutex } from '@livekit/mutex';
-import { DataPacket_Kind, DisconnectReason, SubscriptionError, TrackType } from '@livekit/protocol';
+import { DataPacket_Kind, DisconnectReason, Encryption_Type, SubscriptionError, TrackType } from '@livekit/protocol';
 import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
@@ -23,7 +23,7 @@ import RemoteVideoTrack from './room/track/RemoteVideoTrack';
 import { TrackPublication } from './room/track/TrackPublication';
 import type { LiveKitReactNativeInfo } from './room/types';
 import type { AudioAnalyserOptions } from './room/utils';
-import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isAudioTrack, isBrowserSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isVideoTrack, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9 } from './room/utils';
+import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isAudioCodec, isAudioTrack, isBrowserSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isVideoCodec, isVideoTrack, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9 } from './room/utils';
 import { getBrowser } from './utils/browserParser';
 export type { RpcInvocationData, PerformRpcParams } from './room/rpc';
 export { RpcError } from './room/rpc';
@@ -36,6 +36,8 @@ export * from './room/errors';
 export * from './room/events';
 export * from './room/track/Track';
 export * from './room/track/create';
+export * from './room/token-source/TokenSource';
+export * from './room/token-source/types';
 export { facingModeFromDeviceLabel, facingModeFromLocalTrack } from './room/track/facingMode';
 export * from './room/track/options';
 export * from './room/track/processor/types';
@@ -46,7 +48,7 @@ export type { DataPublishOptions, SimulationScenario, TranscriptionSegment, Chat
 export * from './version';
 export { 
 /** @internal */
-attributes, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, DefaultReconnectPolicy, DisconnectReason, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, Participant, RemoteAudioTrack, RemoteParticipant, ParticipantKind, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, SubscriptionError, TrackPublication, TrackType, compareVersions, createAudioAnalyser, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, isBrowserSupported, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, Mutex, isAudioTrack, isLocalTrack, isRemoteTrack, isVideoTrack, isLocalParticipant, isRemoteParticipant, };
+attributes, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, Encryption_Type, DefaultReconnectPolicy, DisconnectReason, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, Participant, RemoteAudioTrack, RemoteParticipant, ParticipantKind, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, SubscriptionError, TrackPublication, TrackType, compareVersions, createAudioAnalyser, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, isBrowserSupported, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9, Mutex, isAudioCodec, isAudioTrack, isLocalTrack, isRemoteTrack, isVideoCodec, isVideoTrack, isLocalParticipant, isRemoteParticipant, };
 export type { AudioAnalyserOptions, ElementInfo, LiveKitReactNativeInfo, ParticipantTrackPermission, AudioReceiverStats, AudioSenderStats, VideoReceiverStats, VideoSenderStats, ReconnectContext, ReconnectPolicy, };
 export { LocalTrackRecorder } from './room/track/record';
 //# sourceMappingURL=index.d.ts.map

package/dist/ts4.2/{src/logger.d.ts → logger.d.ts}

@@ -10,6 +10,7 @@ export declare enum LogLevel {
 export declare enum LoggerNames {
     Default = "livekit",
     Room = "livekit-room",
+    TokenSource = "livekit-token-source",
     Participant = "livekit-participant",
     Track = "livekit-track",
     Publication = "livekit-track-publication",

package/dist/ts4.2/{src/options.d.ts → options.d.ts}

@@ -68,16 +68,24 @@ export interface InternalRoomOptions {
      * allows for passing in your own AudioContext instance, too
      */
     webAudioMix: boolean | WebAudioSettings;
+    e2ee?: E2EEOptions;
     /**
      * @experimental
+     * Options for enabling end-to-end encryption.
      */
-    e2ee?: E2EEOptions;
+    encryption?: E2EEOptions;
     loggerName?: string;
+    /**
+     * @experimental
+     * only supported on LiveKit Cloud
+     * and LiveKit OSS >= 1.9.2
+     */
+    singlePeerConnection: boolean;
 }
 /**
  * Options for when creating a new room
  */
-export interface RoomOptions extends Partial<InternalRoomOptions> {
+export interface RoomOptions extends Partial<Omit<InternalRoomOptions, 'encryption'>> {
 }
 /**
  * @internal

package/dist/ts4.2/{src/room → room}/PCTransport.d.ts

@@ -52,6 +52,7 @@ export default class PCTransport extends EventEmitter {
     createAndSetAnswer(): Promise<RTCSessionDescriptionInit>;
     createDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel;
     addTransceiver(mediaStreamTrack: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    addTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     addTrack(track: MediaStreamTrack): RTCRtpSender;
     setTrackCodecBitrate(info: TrackBitrateInfo): void;
     setConfiguration(rtcConfig: RTCConfiguration): void;

package/dist/ts4.2/{src/room → room}/PCTransportManager.d.ts

@@ -9,14 +9,15 @@ export declare enum PCTransportState {
     CLOSING = 4,
     CLOSED = 5
 }
+type PCMode = 'subscriber-primary' | 'publisher-primary' | 'publisher-only';
 export declare class PCTransportManager {
     publisher: PCTransport;
-    subscriber: PCTransport;
+    subscriber?: PCTransport;
     peerConnectionTimeout: number;
     get needsPublisher(): boolean;
     get needsSubscriber(): boolean;
     get currentState(): PCTransportState;
-    onStateChange?: (state: PCTransportState, pubState: RTCPeerConnectionState, subState: RTCPeerConnectionState) => void;
+    onStateChange?: (state: PCTransportState, pubState: RTCPeerConnectionState, subState?: RTCPeerConnectionState) => void;
     onIceCandidate?: (ev: RTCIceCandidate, target: SignalTarget) => void;
     onDataChannel?: (ev: RTCDataChannelEvent) => void;
     onTrack?: (ev: RTCTrackEvent) => void;
@@ -28,10 +29,9 @@ export declare class PCTransportManager {
     private remoteOfferLock;
     private log;
     private loggerOptions;
-    constructor(rtcConfig: RTCConfiguration, subscriberPrimary: boolean, loggerOptions: LoggerOptions);
+    constructor(rtcConfig: RTCConfiguration, mode: PCMode, loggerOptions: LoggerOptions);
     private get logContext();
     requirePublisher(require?: boolean): void;
-    requireSubscriber(require?: boolean): void;
     createAndSendPublisherOffer(options?: RTCOfferOptions): Promise<void>;
     setPublisherAnswer(sd: RTCSessionDescriptionInit, offerId: number): Promise<boolean>;
     removeTrack(sender: RTCRtpSender): void | undefined;
@@ -43,6 +43,7 @@ export declare class PCTransportManager {
     ensurePCTransportConnection(abortController?: AbortController, timeout?: number): Promise<void>;
     negotiate(abortController: AbortController): Promise<void>;
     addPublisherTransceiver(track: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    addPublisherTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     addPublisherTrack(track: MediaStreamTrack): RTCRtpSender;
     createPublisherDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel;
     /**
@@ -53,4 +54,5 @@ export declare class PCTransportManager {
     private updateState;
     private ensureTransportConnected;
 }
+export {};
 //# sourceMappingURL=PCTransportManager.d.ts.map

package/dist/ts4.2/{src/room → room}/RTCEngine.d.ts

@@ -1,8 +1,9 @@
 import type { AddTrackRequest, ConnectionQualityUpdate, JoinResponse, StreamStateUpdate, SubscriptionPermissionUpdate, SubscriptionResponse } from '@livekit/protocol';
-import { DataPacket, DataPacket_Kind, DisconnectReason, ParticipantInfo, RequestResponse, Room as RoomModel, RoomMovedResponse, SpeakerInfo, SubscribedQualityUpdate, TrackInfo, TrackUnpublishedResponse, Transcription } from '@livekit/protocol';
+import { DataPacket, DataPacket_Kind, DisconnectReason, Encryption_Type, ParticipantInfo, RequestResponse, Room as RoomModel, RoomMovedResponse, SpeakerInfo, SubscribedQualityUpdate, TrackInfo, TrackUnpublishedResponse, Transcription } from '@livekit/protocol';
 import type TypedEventEmitter from 'typed-emitter';
 import type { SignalOptions } from '../api/SignalClient';
 import { SignalClient } from '../api/SignalClient';
+import type { BaseE2EEManager } from '../e2ee/E2eeManager';
 import type { InternalRoomOptions } from '../options';
 import PCTransport from './PCTransport';
 import { PCTransportManager } from './PCTransportManager';
@@ -32,6 +33,8 @@ export default class RTCEngine extends RTCEngine_base {
      * @internal
      */
     latestRemoteOfferId: number;
+    /** @internal */
+    e2eeManager: BaseE2EEManager | undefined;
     get isClosed(): boolean;
     get pendingReconnect(): boolean;
     private lossyDC?;
@@ -152,9 +155,9 @@ export type EngineEventCallbacks = {
     closing: () => void;
     mediaTrackAdded: (track: MediaStreamTrack, streams: MediaStream, receiver: RTCRtpReceiver) => void;
     activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
-    dataPacketReceived: (packet: DataPacket) => void;
+    dataPacketReceived: (packet: DataPacket, encryptionType: Encryption_Type) => void;
     transcriptionReceived: (transcription: Transcription) => void;
-    transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void;
+    transportsCreated: (publisher: PCTransport, subscriber?: PCTransport) => void;
     /** @internal */
     trackSenderAdded: (track: Track, sender: RTCRtpSender) => void;
     rtpVideoMapUpdate: (rtpMap: Map<number, VideoCodec>) => void;

package/dist/ts4.2/{src/room → room}/Room.d.ts

@@ -1,4 +1,4 @@
-import { DataPacket_Kind, DisconnectReason, MetricsBatch, ParticipantPermission, ServerInfo, SipDTMF, SubscriptionError, TranscriptionSegment as TranscriptionSegmentModel } from '@livekit/protocol';
+import { DataPacket_Kind, DisconnectReason, Encryption_Type, MetricsBatch, ParticipantPermission, ServerInfo, SipDTMF, SubscriptionError, TranscriptionSegment as TranscriptionSegmentModel } from '@livekit/protocol';
 import type TypedEmitter from 'typed-emitter';
 import 'webrtc-adapter';
 import type { InternalRoomOptions, RoomConnectOptions, RoomOptions } from '../options';
@@ -77,6 +77,7 @@ declare class Room extends Room_base {
     private incomingDataStreamManager;
     private outgoingDataStreamManager;
     private rpcHandlers;
+    get hasE2EESetup(): boolean;
     /**
      * Creates a new Room, the primary construct for a LiveKit session.
      * @param options
@@ -306,7 +307,7 @@ export type RoomEventCallbacks = {
     participantAttributesChanged: (changedAttributes: Record<string, string>, participant: RemoteParticipant | LocalParticipant) => void;
     activeSpeakersChanged: (speakers: Array<Participant>) => void;
     roomMetadataChanged: (metadata: string) => void;
-    dataReceived: (payload: Uint8Array, participant?: RemoteParticipant, kind?: DataPacket_Kind, topic?: string) => void;
+    dataReceived: (payload: Uint8Array, participant?: RemoteParticipant, kind?: DataPacket_Kind, topic?: string, encryptionType?: Encryption_Type) => void;
     sipDTMFReceived: (dtmf: SipDTMF, participant?: RemoteParticipant) => void;
     transcriptionReceived: (transcription: TranscriptionSegment[], participant?: Participant, publication?: TrackPublication) => void;
     connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;

package/dist/ts4.2/{src/room → room}/data-stream/incoming/IncomingDataStreamManager.d.ts

@@ -1,4 +1,5 @@
 import type { DataPacket } from '@livekit/protocol';
+import { Encryption_Type } from '@livekit/protocol';
 import type { ByteStreamHandler, TextStreamHandler } from './StreamReader';
 export default class IncomingDataStreamManager {
     private log;
@@ -12,7 +13,7 @@ export default class IncomingDataStreamManager {
     unregisterByteStreamHandler(topic: string): void;
     clearHandlersAndControllers(): void;
     validateParticipantHasNoActiveDataStreams(participantIdentity: string): void;
-    handleDataStreamPacket(packet: DataPacket): Promise<void>;
+    handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type): Promise<void>;
     private handleStreamHeader;
     private handleStreamChunk;
     private handleStreamTrailer;

package/dist/ts4.2/{src/room → room}/errors.d.ts

@@ -52,7 +52,8 @@ export declare enum DataStreamErrorReason {
     DecodeFailed = 2,
     LengthExceeded = 3,
     Incomplete = 4,
-    HandlerAlreadyRegistered = 7
+    HandlerAlreadyRegistered = 7,
+    EncryptionTypeMismatch = 8
 }
 export declare class DataStreamError extends LivekitError {
     reason: DataStreamErrorReason;

package/dist/ts4.2/{src/room → room}/participant/Participant.d.ts

@@ -1,5 +1,5 @@
 import type { SipDTMF } from '@livekit/protocol';
-import { DataPacket_Kind, ParticipantInfo, ParticipantInfo_Kind as ParticipantKind, ParticipantPermission, ConnectionQuality as ProtoQuality, SubscriptionError } from '@livekit/protocol';
+import { DataPacket_Kind, Encryption_Type, ParticipantInfo, ParticipantInfo_Kind as ParticipantKind, ParticipantPermission, ConnectionQuality as ProtoQuality, SubscriptionError } from '@livekit/protocol';
 import type TypedEmitter from 'typed-emitter';
 import type { StructuredLogger } from '../../logger';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
@@ -124,7 +124,7 @@ export type ParticipantEventCallbacks = {
     localSenderCreated: (sender: RTCRtpSender, track: Track) => void;
     participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
     participantNameChanged: (name: string) => void;
-    dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
+    dataReceived: (payload: Uint8Array, kind: DataPacket_Kind, encryptionType?: Encryption_Type) => void;
     sipDTMFReceived: (dtmf: SipDTMF) => void;
     transcriptionReceived: (transcription: TranscriptionSegment[], publication?: TrackPublication) => void;
     isSpeakingChanged: (speaking: boolean) => void;

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

@@ -0,0 +1,71 @@
+import { TokenSourceResponse } from '@livekit/protocol';
+import type { TokenSourceFetchOptions, TokenSourceResponseObject } from './types';
+import { TokenSourceConfigurable, TokenSourceFixed } from './types';
+/** A TokenSourceCached is a TokenSource which caches the last {@link TokenSourceResponseObject} value and returns it
+ * until a) it expires or b) the {@link TokenSourceFetchOptions} provided to .fetch(...) change. */
+declare abstract class TokenSourceCached extends TokenSourceConfigurable {
+    private cachedFetchOptions;
+    private cachedResponse;
+    private fetchMutex;
+    private isSameAsCachedFetchOptions;
+    private shouldReturnCachedValueFromFetch;
+    getCachedResponseJwtPayload(): import("./types").TokenPayload | null;
+    fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    protected abstract update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+type LiteralOrFn = TokenSourceResponseObject | (() => TokenSourceResponseObject | Promise<TokenSourceResponseObject>);
+export declare class TokenSourceLiteral extends TokenSourceFixed {
+    private literalOrFn;
+    constructor(literalOrFn: LiteralOrFn);
+    fetch(): Promise<TokenSourceResponseObject>;
+}
+type CustomFn = (options: TokenSourceFetchOptions) => TokenSourceResponseObject | Promise<TokenSourceResponseObject>;
+export declare class TokenSourceCustom extends TokenSourceCached {
+    private customFn;
+    constructor(customFn: CustomFn);
+    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+export type EndpointOptions = Omit<RequestInit, 'body'>;
+export declare class TokenSourceEndpoint extends TokenSourceCached {
+    private url;
+    private endpointOptions;
+    constructor(url: string, options?: EndpointOptions);
+    private createRequestFromOptions;
+    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+export type SandboxTokenServerOptions = {
+    baseUrl?: string;
+};
+export declare class TokenSourceSandboxTokenServer extends TokenSourceEndpoint {
+    constructor(sandboxId: string, options: SandboxTokenServerOptions);
+}
+export declare const TokenSource: {
+    /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
+     * credentials, either provided directly or returned from a provided function. */
+    literal(literalOrFn: LiteralOrFn): TokenSourceLiteral;
+    /**
+     * TokenSource.custom allows a user to define a manual function which generates new
+     * {@link TokenSourceResponseObject} values on demand.
+     *
+     * Use this to get credentials from custom backends / etc.
+     */
+    custom(customFn: CustomFn): TokenSourceCustom;
+    /**
+     * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
+     * the standard endpoint format:
+     * FIXME: add docs link here in the future!
+     */
+    endpoint(url: string, options?: EndpointOptions): TokenSourceEndpoint;
+    /**
+     * TokenSource.sandboxTokenServer queries a sandbox token server for credentials,
+     * which supports quick prototyping / getting started types of use cases.
+     *
+     * This token provider is INSECURE and should NOT be used in production.
+     *
+     * For more info:
+     * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+     */
+    sandboxTokenServer(sandboxId: string, options?: SandboxTokenServerOptions): TokenSourceSandboxTokenServer;
+};
+export {};
+//# sourceMappingURL=TokenSource.d.ts.map

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

@@ -0,0 +1,68 @@
+import { RoomConfiguration, TokenSourceRequest, TokenSourceResponse } from '@livekit/protocol';
+import type { JWTPayload } from 'jose';
+import type { ValueToSnakeCase } from '../../utils/camelToSnakeCase';
+export type TokenSourceRequestObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceRequest>[0]>>;
+export type TokenSourceResponseObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceResponse>[0]>>;
+/** The `TokenSource` request object sent to the server as part of fetching a configurable
+ * `TokenSource` like {@link TokenSourceEndpoint}.
+ *
+ * Use this as a type for your request body if implementing a server endpoint in node.js.
+ */
+export type TokenSourceRequestPayload = ValueToSnakeCase<TokenSourceRequestObject>;
+/** The `TokenSource` response object sent from the server as part of fetching a configurable
+ * `TokenSource` like {@link TokenSourceEndpoint}.
+ *
+ * Use this as a type for your response body if implementing a server endpoint in node.js.
+ */
+export type TokenSourceResponsePayload = ValueToSnakeCase<TokenSourceResponseObject>;
+/** The payload of a LiveKit JWT token. */
+export type TokenPayload = JWTPayload & {
+    name?: string;
+    metadata?: string;
+    attributes?: Record<string, string>;
+    video?: {
+        room?: string;
+        roomJoin?: boolean;
+        canPublish?: boolean;
+        canPublishData?: boolean;
+        canSubscribe?: boolean;
+    };
+    roomConfig?: RoomConfigurationObject;
+};
+export type RoomConfigurationObject = NonNullable<ConstructorParameters<typeof RoomConfiguration>[0]>;
+/** A Fixed TokenSource is a token source that takes no parameters and returns a completely
+ * independently derived value on each fetch() call.
+ *
+ * The most common downstream implementer is {@link TokenSourceLiteral}.
+ */
+export declare abstract class TokenSourceFixed {
+    abstract fetch(): Promise<TokenSourceResponseObject>;
+}
+export type TokenSourceFetchOptions = {
+    roomName?: string;
+    participantName?: string;
+    participantIdentity?: string;
+    participantMetadata?: string;
+    participantAttributes?: {
+        [key: string]: string;
+    };
+    agentName?: string;
+    agentMetadata?: string;
+};
+/** A Configurable TokenSource is a token source that takes a
+ * {@link TokenSourceFetchOptions} object as input and returns a deterministic
+ * {@link TokenSourceResponseObject} output based on the options specified.
+ *
+ * For example, if options.participantName is set, it should be expected that
+ * all tokens that are generated will have participant name field set to the
+ * provided value.
+ *
+ * A few common downstream implementers are {@link TokenSourceEndpoint}
+ * and {@link TokenSourceCustom}.
+ */
+export declare abstract class TokenSourceConfigurable {
+    abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+}
+/** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */
+export type TokenSourceBase = TokenSourceFixed | TokenSourceConfigurable;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,5 @@
+import type { TokenSourceResponse } from '@livekit/protocol';
+import type { TokenPayload } from './types';
+export declare function isResponseTokenValid(response: TokenSourceResponse): boolean;
+export declare function decodeTokenPayload(token: string): TokenPayload;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/{src/room → room}/track/LocalTrack.d.ts

@@ -114,7 +114,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     /** @internal */
     stopPreConnectBuffer(): void;
     /** @internal */
-    getPreConnectBuffer(): ReadableStream<Uint8Array<ArrayBufferLike>> | undefined;
+    getPreConnectBuffer(): ReadableStream<Uint8Array> | undefined;
     getPreConnectBufferMimeType(): string | undefined;
     protected abstract monitorSender(): void;
 }