livekit-client 1.11.4 → 1.12.1

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,6 +57,7 @@ declare class Room extends EventEmitter<RoomEventCallbacks> {
     /** future holding client initiated connection attempt */
     private connectFuture?;
     private disconnectLock;
+    private e2eeManager;
     private cachedParticipantSids;
     private connectionReconcileInterval?;
     /**
@@ -62,6 +65,11 @@ declare class Room extends EventEmitter<RoomEventCallbacks> {
      * @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
      **/
@@ -228,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';
@@ -26,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);
@@ -71,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).
@@ -108,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/participant/RemoteParticipant.d.ts

@@ -12,7 +12,7 @@ export default class RemoteParticipant extends Participant {
     videoTracks: Map<string, RemoteTrackPublication>;
     tracks: Map<string, RemoteTrackPublication>;
     signalClient: SignalClient;
-    private volume?;
+    private volumeMap;
     private audioContext?;
     private audioOutput?;
     /** @internal */
@@ -23,14 +23,16 @@ export default class RemoteParticipant extends Participant {
     getTrack(source: Track.Source): RemoteTrackPublication | undefined;
     getTrackByName(name: string): RemoteTrackPublication | undefined;
     /**
-     * sets the volume on the participant's microphone track
+     * sets the volume on the participant's audio track
+     * by default, this affects the microphone publication
+     * a different source can be passed in as a second argument
      * if no track exists the volume will be applied when the microphone track is added
      */
-    setVolume(volume: number): void;
+    setVolume(volume: number, source?: Track.Source.Microphone | Track.Source.ScreenShareAudio): void;
     /**
      * gets the volume on the participant's microphone track
      */
-    getVolume(): number | undefined;
+    getVolume(source?: Track.Source.Microphone | Track.Source.ScreenShareAudio): number | undefined;
     /** @internal */
     addSubscribedMediaTrack(mediaTrack: MediaStreamTrack, sid: Track.SID, mediaStream: MediaStream, receiver?: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, triesLeft?: number): RemoteTrackPublication | undefined;
     /** @internal */

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/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,3 +1,4 @@
+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;
@@ -11,4 +12,12 @@ export declare function detectSilence(track: AudioTrack, timeOffset?: number): P
  * @internal
  */
 export declare function getNewAudioContext(): AudioContext | void;
+/**
+ * @internal
+ */
+export declare function kindToSource(kind: MediaDeviceKind): Track.Source.Camera | Track.Source.Microphone | Track.Source.Unknown;
+/**
+ * @internal
+ */
+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/dist/ts4.2/src/utils/browserParser.d.ts

@@ -1,7 +1,9 @@
 export type DetectableBrowser = 'Chrome' | 'Firefox' | 'Safari';
+export type DetectableOS = 'iOS' | 'macOS';
 export type BrowserDetails = {
     name: DetectableBrowser;
     version: string;
+    os?: DetectableOS;
 };
 /**
  * @internal

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "livekit-client",
-  "version": "1.11.4",
+  "version": "1.12.1",
   "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;

package/src/connectionHelper/checks/websocket.ts

@@ -15,6 +15,7 @@ export class WebSocketCheck extends Checker {
     const joinRes = await signalClient.join(this.url, this.token, {
       autoSubscribe: true,
       maxRetries: 0,
+      e2eeEnabled: false,
     });
     this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
     await signalClient.close();