livekit-client 1.11.3 → 1.12.0

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

@@ -0,0 +1,46 @@
+import EventEmitter from 'eventemitter3';
+import type { KeyProviderOptions, KeySet, ParticipantKeyHandlerCallbacks } from '../types';
+/**
+ * ParticipantKeyHandler is responsible for providing a cryptor instance with the
+ * en-/decryption key of a participant. It assumes that all tracks of a specific participant
+ * are encrypted with the same key.
+ * Additionally it exposes a method to ratchet a key which can be used by the cryptor either automatically
+ * if decryption fails or can be triggered manually on both sender and receiver side.
+ *
+ */
+export declare class ParticipantKeyHandler extends EventEmitter<ParticipantKeyHandlerCallbacks> {
+    private currentKeyIndex;
+    private cryptoKeyRing;
+    private enabled;
+    private keyProviderOptions;
+    private ratchetPromiseMap;
+    private participantId;
+    constructor(participantId: string | undefined, isEnabled: boolean, keyProviderOptions: KeyProviderOptions);
+    setEnabled(enabled: boolean): void;
+    /**
+     * Ratchets the current key (or the one at keyIndex if provided) and
+     * returns the ratcheted material
+     * if `setKey` is true (default), it will also set the ratcheted key directly on the crypto key ring
+     * @param keyIndex
+     * @param setKey
+     */
+    ratchetKey(keyIndex?: number, setKey?: boolean): Promise<CryptoKey>;
+    /**
+     * takes in a key material with `deriveBits` and `deriveKey` set as key usages
+     * and derives encryption keys from the material and sets it on the key ring buffer
+     * together with the material
+     * also updates the currentKeyIndex
+     */
+    setKeyFromMaterial(material: CryptoKey, keyIndex?: number, emitRatchetEvent?: boolean): Promise<void>;
+    setKeySet(keySet: KeySet, keyIndex: number, emitRatchetEvent?: boolean): Promise<void>;
+    setCurrentKeyIndex(index: number): Promise<void>;
+    isEnabled(): boolean;
+    getCurrentKeyIndex(): number;
+    /**
+     * returns currently used KeySet or the one at `keyIndex` if provided
+     * @param keyIndex
+     * @returns
+     */
+    getKeySet(keyIndex?: number): KeySet;
+}
+//# sourceMappingURL=ParticipantKeyHandler.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=e2ee.worker.d.ts.map

package/dist/ts4.2/src/index.d.ts

@@ -27,9 +27,11 @@ export * from './room/events';
 export * from './room/track/Track';
 export * from './room/track/create';
 export * from './room/track/options';
+export { facingModeFromDeviceLabel, facingModeFromLocalTrack } from './room/track/facingMode';
 export * from './room/track/types';
 export type { DataPublishOptions, SimulationScenario } from './room/types';
 export * from './version';
+export * from './e2ee';
 export * from './room/track/processor/types';
 export { setLogLevel, setLogExtension, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isBrowserSupported, supportsAdaptiveStream, supportsDynacast, supportsAV1, supportsVP9, createAudioAnalyser, LogLevel, Room, ConnectionState, RoomState, DataPacket_Kind, DisconnectReason, Participant, RemoteParticipant, LocalParticipant, LocalAudioTrack, LocalVideoTrack, LocalTrack, LocalTrackPublication, RemoteTrack, RemoteAudioTrack, RemoteVideoTrack, RemoteTrackPublication, TrackPublication, VideoQuality, ConnectionQuality, DefaultReconnectPolicy, CriticalTimers, };
 export type { ElementInfo, ParticipantTrackPermission, AudioAnalyserOptions, LiveKitReactNativeInfo, };

package/dist/ts4.2/src/logger.d.ts

@@ -1,3 +1,4 @@
+import * as log from 'loglevel';
 export declare enum LogLevel {
     trace = 0,
     debug = 1,
@@ -13,14 +14,16 @@ type StructuredLogger = {
     info: (msg: string, context?: object) => void;
     warn: (msg: string, context?: object) => void;
     error: (msg: string, context?: object) => void;
+    setDefaultLevel: (level: log.LogLevelDesc) => void;
 };
 declare const _default: StructuredLogger;
 export default _default;
-export declare function setLogLevel(level: LogLevel | LogLevelString): void;
+export declare function setLogLevel(level: LogLevel | LogLevelString, loggerName?: 'livekit' | 'lk-e2ee'): void;
 export type LogExtension = (level: LogLevel, msg: string, context?: object) => void;
 /**
  * use this to hook into the logging function to allow sending internal livekit logs to third party services
  * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
  */
 export declare function setLogExtension(extension: LogExtension): void;
+export declare const workerLogger: StructuredLogger;
 //# sourceMappingURL=logger.d.ts.map

package/dist/ts4.2/src/options.d.ts

@@ -1,3 +1,4 @@
+import type { E2EEOptions } from './e2ee/types';
 import type { ReconnectPolicy } from './room/ReconnectPolicy';
 import type { AudioCaptureOptions, AudioOutputOptions, TrackPublishDefaults, VideoCaptureOptions } from './room/track/options';
 import type { AdaptiveStreamSettings } from './room/track/types';
@@ -65,6 +66,10 @@ export interface InternalRoomOptions {
      * experimental flag, mix all audio tracks in web audio
      */
     expWebAudioMix: boolean | WebAudioSettings;
+    /**
+     * @experimental
+     */
+    e2ee?: E2EEOptions;
 }
 /**
  * Options for when creating a new room

package/dist/ts4.2/src/proto/livekit_models.d.ts

@@ -75,7 +75,7 @@ export declare enum DisconnectReason {
 export declare function disconnectReasonFromJSON(object: any): DisconnectReason;
 export declare function disconnectReasonToJSON(object: DisconnectReason): string;
 export declare enum ReconnectReason {
-    RR_UNKOWN = 0,
+    RR_UNKNOWN = 0,
     RR_SIGNAL_DISCONNECTED = 1,
     RR_PUBLISHER_FAILED = 2,
     RR_SUBSCRIBER_FAILED = 3,
@@ -85,7 +85,7 @@ export declare enum ReconnectReason {
 export declare function reconnectReasonFromJSON(object: any): ReconnectReason;
 export declare function reconnectReasonToJSON(object: ReconnectReason): string;
 export declare enum SubscriptionError {
-    SE_UNKOWN = 0,
+    SE_UNKNOWN = 0,
     SE_CODEC_UNSUPPORTED = 1,
     SE_TRACK_NOTFOUND = 2,
     UNRECOGNIZED = -1

package/dist/ts4.2/src/room/PCTransport.d.ts

@@ -9,10 +9,12 @@ interface TrackBitrateInfo {
 export declare const PCEvents: {
     readonly NegotiationStarted: "negotiationStarted";
     readonly NegotiationComplete: "negotiationComplete";
+    readonly RTPVideoPayloadTypes: "rtpVideoPayloadTypes";
 };
 /** @internal */
 export default class PCTransport extends EventEmitter {
-    pc: RTCPeerConnection;
+    private _pc;
+    get pc(): RTCPeerConnection;
     pendingCandidates: RTCIceCandidateInit[];
     restartingIce: boolean;
     renegotiate: boolean;

package/dist/ts4.2/src/room/RTCEngine.d.ts

@@ -2,13 +2,14 @@ import EventEmitter from 'eventemitter3';
 import { SignalClient } from '../api/SignalClient';
 import type { SignalOptions } from '../api/SignalClient';
 import type { InternalRoomOptions } from '../options';
-import { DataPacket, DataPacket_Kind, DisconnectReason, SpeakerInfo, TrackInfo, UserPacket } from '../proto/livekit_models';
-import { AddTrackRequest, JoinResponse } from '../proto/livekit_rtc';
+import { DataPacket, DataPacket_Kind, DisconnectReason, ParticipantInfo, Room as RoomModel, SpeakerInfo, TrackInfo, UserPacket } from '../proto/livekit_models';
+import { AddTrackRequest, ConnectionQualityUpdate, JoinResponse, StreamStateUpdate, SubscriptionPermissionUpdate, SubscriptionResponse } from '../proto/livekit_rtc';
 import PCTransport from './PCTransport';
 import type LocalTrack from './track/LocalTrack';
 import type LocalVideoTrack from './track/LocalVideoTrack';
 import type { SimulcastTrackInfo } from './track/LocalVideoTrack';
-import type { TrackPublishOptions } from './track/options';
+import { Track } from './track/Track';
+import type { TrackPublishOptions, VideoCodec } from './track/options';
 /** @internal */
 export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     private options;
@@ -55,6 +56,8 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     constructor(options: InternalRoomOptions);
     join(url: string, token: string, opts: SignalOptions, abortSignal?: AbortSignal): Promise<JoinResponse>;
     close(): Promise<void>;
+    cleanupPeerConnections(): Promise<void>;
+    cleanupClient(): Promise<void>;
     addTrack(req: AddTrackRequest): Promise<TrackInfo>;
     /**
      * Removes sender from PeerConnection, returning true if it was removed successfully
@@ -67,6 +70,7 @@ export default class RTCEngine extends EventEmitter<EngineEventCallbacks> {
     get dataSubscriberReadyState(): string | undefined;
     getConnectedServerAddress(): Promise<string | undefined>;
     private configure;
+    private setupSignalClientCallbacks;
     private makeRTCConfiguration;
     private createDataChannels;
     private handleDataChannel;
@@ -120,6 +124,16 @@ export type EngineEventCallbacks = {
     activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
     dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void;
     transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void;
+    /** @internal */
+    trackSenderAdded: (track: Track, sender: RTCRtpSender) => void;
+    rtpVideoMapUpdate: (rtpMap: Map<number, VideoCodec>) => void;
     dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
+    participantUpdate: (infos: ParticipantInfo[]) => void;
+    roomUpdate: (room: RoomModel) => void;
+    connectionQualityUpdate: (update: ConnectionQualityUpdate) => void;
+    speakersChanged: (speakerUpdates: SpeakerInfo[]) => void;
+    streamStateChanged: (update: StreamStateUpdate) => void;
+    subscriptionError: (resp: SubscriptionResponse) => void;
+    subscriptionPermissionUpdate: (update: SubscriptionPermissionUpdate) => void;
 };
 //# sourceMappingURL=RTCEngine.d.ts.map

package/dist/ts4.2/src/room/Room.d.ts

@@ -44,6 +44,8 @@ declare class Room extends EventEmitter<RoomEventCallbacks> {
     localParticipant: LocalParticipant;
     /** options of room */
     options: InternalRoomOptions;
+    /** reflects the sender encryption status of the local participant */
+    isE2EEEnabled: boolean;
     private roomInfo?;
     private identityToSid;
     /** connect options of room */
@@ -55,14 +57,19 @@ declare class Room extends EventEmitter<RoomEventCallbacks> {
     /** future holding client initiated connection attempt */
     private connectFuture?;
     private disconnectLock;
+    private e2eeManager;
     private cachedParticipantSids;
     private connectionReconcileInterval?;
-    private activeDeviceMap;
     /**
      * Creates a new Room, the primary construct for a LiveKit session.
      * @param options
      */
     constructor(options?: RoomOptions);
+    /**
+     * @experimental
+     */
+    setE2EEEnabled(enabled: boolean): Promise<void>;
+    private setupE2EE;
     /**
      * if the current room has a participant with `recorder: true` in its JWT grant
      **/
@@ -229,6 +236,8 @@ export type RoomEventCallbacks = {
     audioPlaybackChanged: (playing: boolean) => void;
     signalConnected: () => void;
     recordingStatusChanged: (recording: boolean) => void;
+    participantEncryptionStatusChanged: (encrypted: boolean, participant?: Participant) => void;
+    encryptionError: (error: Error) => void;
     dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
     activeDeviceChanged: (kind: MediaDeviceKind, deviceId: string) => void;
 };

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

@@ -239,6 +239,8 @@ export declare enum RoomEvent {
      * args: (isRecording: boolean)
      */
     RecordingStatusChanged = "recordingStatusChanged",
+    ParticipantEncryptionStatusChanged = "participantEncryptionStatusChanged",
+    EncryptionError = "encryptionError",
     /**
      * Emits whenever the current buffer status of a data channel changes
      * args: (isLow: boolean, kind: [[DataPacket_Kind]])
@@ -387,7 +389,9 @@ export declare enum ParticipantEvent {
      * A participant's permission has changed. Currently only fired on LocalParticipant.
      * args: (prevPermissions: [[ParticipantPermission]])
      */
-    ParticipantPermissionsChanged = "participantPermissionsChanged"
+    ParticipantPermissionsChanged = "participantPermissionsChanged",
+    /** @internal */
+    PCTrackAdded = "pcTrackAdded"
 }
 /** @internal */
 export declare enum EngineEvent {
@@ -404,7 +408,15 @@ export declare enum EngineEvent {
     MediaTrackAdded = "mediaTrackAdded",
     ActiveSpeakersUpdate = "activeSpeakersUpdate",
     DataPacketReceived = "dataPacketReceived",
-    DCBufferStatusChanged = "dcBufferStatusChanged"
+    RTPVideoMapUpdate = "rtpVideoMapUpdate",
+    DCBufferStatusChanged = "dcBufferStatusChanged",
+    ParticipantUpdate = "participantUpdate",
+    RoomUpdate = "roomUpdate",
+    SpeakersChanged = "speakersChanged",
+    StreamStateChanged = "streamStateChanged",
+    ConnectionQualityUpdate = "connectionQualityUpdate",
+    SubscriptionError = "subscriptionError",
+    SubscriptionPermissionUpdate = "subscriptionPermissionUpdate"
 }
 export declare enum TrackEvent {
     Message = "message",

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

@@ -1,5 +1,5 @@
 import type { InternalRoomOptions } from '../../options';
-import { DataPacket_Kind, ParticipantInfo } from '../../proto/livekit_models';
+import { DataPacket_Kind, ParticipantInfo, ParticipantPermission } from '../../proto/livekit_models';
 import { DataChannelInfo, TrackPublishedResponse } from '../../proto/livekit_rtc';
 import type RTCEngine from '../RTCEngine';
 import LocalTrack from '../track/LocalTrack';
@@ -17,6 +17,8 @@ export default class LocalParticipant extends Participant {
     tracks: Map<string, LocalTrackPublication>;
     /** @internal */
     engine: RTCEngine;
+    /** @internal */
+    activeDeviceMap: Map<MediaDeviceKind, string>;
     private pendingPublishing;
     private pendingPublishPromises;
     private cameraError;
@@ -24,6 +26,7 @@ export default class LocalParticipant extends Participant {
     private participantTrackPermissions;
     private allParticipantsAllowedToSubscribe;
     private roomOptions;
+    private encryptionType;
     private reconnectFuture?;
     /** @internal */
     constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions);
@@ -69,6 +72,10 @@ export default class LocalParticipant extends Participant {
      * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
      */
     setScreenShareEnabled(enabled: boolean, options?: ScreenShareCaptureOptions, publishOptions?: TrackPublishOptions): Promise<LocalTrackPublication | undefined>;
+    /** @internal */
+    setPermissions(permissions: ParticipantPermission): boolean;
+    /** @internal */
+    setE2EEEnabled(enabled: boolean): Promise<void>;
     /**
      * Enable or disable publishing for a track by source. This serves as a simple
      * way to manage the common tracks (camera, mic, or screen share).
@@ -106,7 +113,7 @@ export default class LocalParticipant extends Participant {
     publishAdditionalCodecForTrack(track: LocalTrack | MediaStreamTrack, videoCodec: BackupVideoCodec, options?: TrackPublishOptions): Promise<void>;
     unpublishTrack(track: LocalTrack | MediaStreamTrack, stopOnUnpublish?: boolean): Promise<LocalTrackPublication | undefined>;
     unpublishTracks(tracks: LocalTrack[] | MediaStreamTrack[]): Promise<LocalTrackPublication[]>;
-    republishAllTracks(options?: TrackPublishOptions): Promise<void>;
+    republishAllTracks(options?: TrackPublishOptions, restartTracks?: boolean): Promise<void>;
     /**
      * Publish a new data payload to the room. Data will be forwarded to each
      * participant in the room if the destination field in publishOptions is empty

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

@@ -32,6 +32,7 @@ export default class Participant extends EventEmitter<ParticipantEventCallbacks>
     lastSpokeAt?: Date | undefined;
     permissions?: ParticipantPermission;
     private _connectionQuality;
+    get isEncrypted(): boolean;
     /** @internal */
     constructor(sid: string, identity: string, name?: string, metadata?: string);
     getTracks(): TrackPublication[];

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

@@ -7,14 +7,15 @@ export default abstract class LocalTrack extends Track {
     sender?: RTCRtpSender;
     /** @internal */
     codec?: VideoCodec;
-    protected constraints: MediaTrackConstraints;
+    get constraints(): MediaTrackConstraints;
+    protected _constraints: MediaTrackConstraints;
     protected reacquireTrack: boolean;
     protected providedByUser: boolean;
     protected muteLock: Mutex;
     protected pauseUpstreamLock: Mutex;
     protected processorElement?: HTMLMediaElement;
     protected processor?: TrackProcessor<typeof this.kind>;
-    protected isSettingUpProcessor: boolean;
+    protected processorLock: Mutex;
     /**
      *
      * @param mediaTrack

package/dist/ts4.2/src/room/track/TrackPublication.d.ts

@@ -1,4 +1,5 @@
 import EventEmitter from 'eventemitter3';
+import { Encryption_Type } from '../../proto/livekit_models';
 import type { SubscriptionError, TrackInfo } from '../../proto/livekit_models';
 import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
 import LocalAudioTrack from './LocalAudioTrack';
@@ -22,12 +23,14 @@ export declare class TrackPublication extends EventEmitter<PublicationEventCallb
     /** @internal */
     trackInfo?: TrackInfo;
     protected metadataMuted: boolean;
+    protected encryption: Encryption_Type;
     constructor(kind: Track.Kind, id: string, name: string);
     /** @internal */
     setTrack(track?: Track): void;
     get isMuted(): boolean;
     get isEnabled(): boolean;
     get isSubscribed(): boolean;
+    get isEncrypted(): boolean;
     /**
      * an [AudioTrack] if this publication holds an audio track
      */

package/dist/ts4.2/src/room/track/facingMode.d.ts

@@ -0,0 +1,41 @@
+import LocalTrack from './LocalTrack';
+import type { VideoCaptureOptions } from './options';
+type FacingMode = NonNullable<VideoCaptureOptions['facingMode']>;
+type FacingModeFromLocalTrackOptions = {
+    /**
+     * If no facing mode can be determined, this value will be used.
+     * @defaultValue 'user'
+     */
+    defaultFacingMode?: FacingMode;
+};
+type FacingModeFromLocalTrackReturnValue = {
+    /**
+     * The (probable) facingMode of the track.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+     */
+    facingMode: FacingMode;
+    /**
+     * The confidence that the returned facingMode is correct.
+     */
+    confidence: 'high' | 'medium' | 'low';
+};
+/**
+ * Try to analyze the local track to determine the facing mode of a track.
+ *
+ * @remarks
+ * There is no property supported by all browsers to detect whether a video track originated from a user- or environment-facing camera device.
+ * For this reason, we use the `facingMode` property when available, but will fall back on a string-based analysis of the device label to determine the facing mode.
+ * If both methods fail, the default facing mode will be used.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+ * @experimental
+ */
+export declare function facingModeFromLocalTrack(localTrack: LocalTrack | MediaStreamTrack, options?: FacingModeFromLocalTrackOptions): FacingModeFromLocalTrackReturnValue;
+/**
+ * Attempt to analyze the device label to determine the facing mode.
+ *
+ * @experimental
+ */
+export declare function facingModeFromDeviceLabel(deviceLabel: string): FacingModeFromLocalTrackReturnValue | undefined;
+export {};
+//# sourceMappingURL=facingMode.d.ts.map

package/dist/ts4.2/src/room/track/options.d.ts

@@ -208,17 +208,17 @@ export interface AudioPreset {
     maxBitrate: number;
     priority?: RTCPriorityType;
 }
-declare const codecs: readonly [
+declare const backupCodecs: readonly [
+    "vp8",
+    "h264"
+];
+export declare const videoCodecs: readonly [
     "vp8",
     "h264",
     "vp9",
     "av1"
 ];
-declare const backupCodecs: readonly [
-    "vp8",
-    "h264"
-];
-export type VideoCodec = (typeof codecs)[number];
+export type VideoCodec = (typeof videoCodecs)[number];
 export type BackupVideoCodec = (typeof backupCodecs)[number];
 export declare function isBackupCodec(codec: string): codec is BackupVideoCodec;
 export declare function isCodecEqual(c1: string | undefined, c2: string | undefined): boolean;

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

@@ -1,4 +1,4 @@
-import LocalTrack from './LocalTrack';
+import { Track } from './Track';
 import type { AudioCaptureOptions, CreateLocalTracksOptions, VideoCaptureOptions } from './options';
 import type { AudioTrack } from './types';
 export declare function mergeDefaultOptions(options?: CreateLocalTracksOptions, audioDefaults?: AudioCaptureOptions, videoDefaults?: VideoCaptureOptions): CreateLocalTracksOptions;
@@ -12,42 +12,12 @@ export declare function detectSilence(track: AudioTrack, timeOffset?: number): P
  * @internal
  */
 export declare function getNewAudioContext(): AudioContext | void;
-type FacingMode = NonNullable<VideoCaptureOptions['facingMode']>;
-type FacingModeFromLocalTrackOptions = {
-    /**
-     * If no facing mode can be determined, this value will be used.
-     * @defaultValue 'user'
-     */
-    defaultFacingMode?: FacingMode;
-};
-type FacingModeFromLocalTrackReturnValue = {
-    /**
-     * The (probable) facingMode of the track.
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
-     */
-    facingMode: FacingMode;
-    /**
-     * The confidence that the returned facingMode is correct.
-     */
-    confidence: 'high' | 'medium' | 'low';
-};
 /**
- * Try to analyze the local track to determine the facing mode of a track.
- *
- * @remarks
- * There is no property supported by all browsers to detect whether a video track originated from a user- or environment-facing camera device.
- * For this reason, we use the `facingMode` property when available, but will fall back on a string-based analysis of the device label to determine the facing mode.
- * If both methods fail, the default facing mode will be used.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
- * @experimental
+ * @internal
  */
-export declare function facingModeFromLocalTrack(localTrack: LocalTrack | MediaStreamTrack, options?: FacingModeFromLocalTrackOptions): FacingModeFromLocalTrackReturnValue;
+export declare function kindToSource(kind: MediaDeviceKind): Track.Source.Camera | Track.Source.Microphone | Track.Source.Unknown;
 /**
- * Attempt to analyze the device label to determine the facing mode.
- *
- * @experimental
+ * @internal
  */
-export declare function facingModeFromDeviceLabel(deviceLabel: string): FacingModeFromLocalTrackReturnValue | undefined;
-export {};
+export declare function sourceToKind(source: Track.Source): MediaDeviceKind | undefined;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1,6 +1,7 @@
 import { ClientInfo } from '../proto/livekit_models';
 import type LocalAudioTrack from './track/LocalAudioTrack';
 import type RemoteAudioTrack from './track/RemoteAudioTrack';
+import { VideoCodec } from './track/options';
 export declare const ddExtensionURI = "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension";
 export declare function unpackStreamId(packed: string): string[];
 export declare function sleep(duration: number): Promise<void>;
@@ -84,5 +85,6 @@ export declare class Mutex {
     isLocked(): boolean;
     lock(): Promise<() => void>;
 }
+export declare function isVideoCodec(maybeCodec: string): maybeCodec is VideoCodec;
 export declare function unwrapConstraint(constraint: ConstrainDOMString): string;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "livekit-client",
-  "version": "1.11.3",
+  "version": "1.12.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
   "module": "./dist/livekit-client.esm.mjs",
   "exports": {
-    "types": "./dist/src/index.d.ts",
-    "import": "./dist/livekit-client.esm.mjs",
-    "require": "./dist/livekit-client.umd.js"
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/livekit-client.esm.mjs",
+      "require": "./dist/livekit-client.umd.js"
+    },
+    "./e2ee-worker": {
+      "types": "./dist/src/e2ee/worker/e2ee.worker.d.ts",
+      "import": "./dist/livekit-client.e2ee.worker.mjs",
+      "require": "./dist/livekit-client.e2ee.worker.js"
+    }
   },
   "files": [
     "dist",
@@ -18,7 +25,10 @@
   "typesVersions": {
     "<4.8": {
       "./dist/src/index.d.ts": [
-        "./dist/src/ts4.2/index.d.ts"
+        "./dist/ts4.2/src/index.d.ts"
+      ],
+      "./dist/src/e2ee/worker/e2ee.worker.d.ts": [
+        "./dist/ts4.2//dist/src/e2ee/worker/e2ee.worker.d.ts"
       ]
     }
   },
@@ -26,11 +36,11 @@
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "rollup --config --bundleConfigAsCjs && yarn downlevel-dts",
+    "build": "rollup --config --bundleConfigAsCjs && rollup --config rollup.config.worker.js --bundleConfigAsCjs  && yarn downlevel-dts",
     "build:watch": "rollup --watch --config rollup.config.js",
     "build-docs": "typedoc",
     "proto": "protoc --plugin=node_modules/ts-proto/protoc-gen-ts_proto --ts_proto_opt=esModuleInterop=true --ts_proto_out=./src/proto --ts_proto_opt=outputClientImpl=false,useOptionals=messages,oneof=unions -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
-    "sample": "vite serve example --port 8080 --open",
+    "sample": "vite example -c vite.config.js",
     "lint": "eslint src",
     "test": "jest",
     "deploy": "gh-pages -d example/dist",

package/src/api/SignalClient.ts

@@ -60,6 +60,7 @@ export interface SignalOptions {
   publishOnly?: string;
   adaptiveStream?: boolean;
   maxRetries: number;
+  e2eeEnabled: boolean;
 }
 
 type SignalMessage = SignalRequest['message'];
@@ -198,7 +199,7 @@ export class SignalClient {
     return res;
   }
 
-  connect(
+  private connect(
     url: string,
     token: string,
     opts: ConnectOpts,
@@ -329,21 +330,38 @@ export class SignalClient {
     });
   }
 
+  /** @internal */
+  resetCallbacks = () => {
+    this.onAnswer = undefined;
+    this.onLeave = undefined;
+    this.onLocalTrackPublished = undefined;
+    this.onLocalTrackUnpublished = undefined;
+    this.onNegotiateRequested = undefined;
+    this.onOffer = undefined;
+    this.onRemoteMuteChanged = undefined;
+    this.onSubscribedQualityUpdate = undefined;
+    this.onTokenRefresh = undefined;
+    this.onTrickle = undefined;
+    this.onClose = undefined;
+  };
+
   async close() {
     const unlock = await this.closingLock.lock();
     try {
       this.isConnected = false;
       if (this.ws) {
-        this.ws.onclose = null;
         this.ws.onmessage = null;
         this.ws.onopen = null;
+        this.ws.onclose = null;
 
         // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
-        const closePromise = new Promise((resolve) => {
+        const closePromise = new Promise<void>((resolve) => {
           if (this.ws) {
-            this.ws.onclose = resolve;
+            this.ws.onclose = () => {
+              resolve();
+            };
           } else {
-            resolve(true);
+            resolve();
           }
         });
 
@@ -353,9 +371,9 @@ export class SignalClient {
           await Promise.race([closePromise, sleep(250)]);
         }
         this.ws = undefined;
-        this.clearPingInterval();
       }
     } finally {
+      this.clearPingInterval();
       unlock();
     }
   }
@@ -402,7 +420,7 @@ export class SignalClient {
   sendAddTrack(req: AddTrackRequest) {
     return this.sendRequest({
       $case: 'addTrack',
-      addTrack: AddTrackRequest.fromPartial(req),
+      addTrack: req,
     });
   }
 
@@ -622,10 +640,11 @@ export class SignalClient {
 
   private async handleOnClose(reason: string) {
     if (!this.isConnected) return;
+    const onCloseCallback = this.onClose;
     await this.close();
     log.debug(`websocket connection closed: ${reason}`);
-    if (this.onClose) {
-      this.onClose(reason);
+    if (onCloseCallback) {
+      onCloseCallback(reason);
     }
   }
 

package/src/connectionHelper/checks/turn.ts

@@ -11,6 +11,7 @@ export class TURNCheck extends Checker {
     const joinRes = await signalClient.join(this.url, this.token, {
       autoSubscribe: true,
       maxRetries: 0,
+      e2eeEnabled: false,
     });
 
     let hasTLS = false;