livekit-client 1.4.4 → 1.6.0

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

@@ -0,0 +1,24 @@
+import LocalAudioTrack from './LocalAudioTrack';
+import type LocalTrack from './LocalTrack';
+import LocalVideoTrack from './LocalVideoTrack';
+import { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions } from './options';
+/**
+ * Creates a local video and audio track at the same time. When acquiring both
+ * audio and video tracks together, it'll display a single permission prompt to
+ * the user instead of two separate ones.
+ * @param options
+ */
+export declare function createLocalTracks(options?: CreateLocalTracksOptions): Promise<Array<LocalTrack>>;
+/**
+ * Creates a [[LocalVideoTrack]] with getUserMedia()
+ * @param options
+ */
+export declare function createLocalVideoTrack(options?: VideoCaptureOptions): Promise<LocalVideoTrack>;
+export declare function createLocalAudioTrack(options?: AudioCaptureOptions): Promise<LocalAudioTrack>;
+/**
+ * Creates a screen capture tracks with getDisplayMedia().
+ * A LocalVideoTrack is always created and returned.
+ * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+ */
+export declare function createLocalScreenTracks(options?: ScreenShareCaptureOptions): Promise<Array<LocalTrack>>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1,241 @@
+import type { Track } from './Track';
+export interface TrackPublishDefaults {
+    /**
+     * encoding parameters for camera track
+     */
+    videoEncoding?: VideoEncoding;
+    /**
+     * @experimental
+     */
+    backupCodec?: {
+        codec: BackupVideoCodec;
+        encoding: VideoEncoding;
+    } | false;
+    /**
+     * encoding parameters for screen share track
+     */
+    screenShareEncoding?: VideoEncoding;
+    /**
+     * codec, defaults to vp8; for svc codecs, auto enable vp8
+     * as backup. (TBD)
+     */
+    videoCodec?: VideoCodec;
+    /**
+     * max audio bitrate, defaults to [[AudioPresets.speech]]
+     */
+    audioBitrate?: number;
+    /**
+     * dtx (Discontinuous Transmission of audio), defaults to true
+     */
+    dtx?: boolean;
+    /**
+     * red (Redundant Audio Data), defaults to true
+     */
+    red?: boolean;
+    /**
+     * stereo audio track. defaults determined by capture channel count.
+     */
+    forceStereo?: boolean;
+    /**
+     * use simulcast, defaults to true.
+     * When using simulcast, LiveKit will publish up to three versions of the stream
+     * at various resolutions.
+     */
+    simulcast?: boolean;
+    /**
+     * scalability mode for svc codecs, defaults to 'L3T3'.
+     * for svc codecs, simulcast is disabled.
+     */
+    scalabilityMode?: ScalabilityMode;
+    /**
+     * custom video simulcast layers for camera tracks, defaults to h180, h360, h540
+     * You can specify up to two custom layers that will be used instead of
+     * the LiveKit default layers.
+     * Note: the layers need to be ordered from lowest to highest quality
+     */
+    videoSimulcastLayers?: Array<VideoPreset>;
+    /**
+     * custom video simulcast layers for screen tracks
+     * Note: the layers need to be ordered from lowest to highest quality
+     */
+    screenShareSimulcastLayers?: Array<VideoPreset>;
+    /**
+     * For local tracks, stop the underlying MediaStreamTrack when the track is muted (or paused)
+     * on some platforms, this option is necessary to disable the microphone recording indicator.
+     * Note: when this is enabled, and BT devices are connected, they will transition between
+     * profiles (e.g. HFP to A2DP) and there will be an audible difference in playback.
+     *
+     * defaults to false
+     */
+    stopMicTrackOnMute?: boolean;
+}
+/**
+ * Options when publishing tracks
+ */
+export interface TrackPublishOptions extends TrackPublishDefaults {
+    /**
+     * set a track name
+     */
+    name?: string;
+    /**
+     * Source of track, camera, microphone, or screen
+     */
+    source?: Track.Source;
+}
+export interface CreateLocalTracksOptions {
+    /**
+     * audio track options, true to create with defaults. false if audio shouldn't be created
+     * default true
+     */
+    audio?: boolean | AudioCaptureOptions;
+    /**
+     * video track options, true to create with defaults. false if video shouldn't be created
+     * default true
+     */
+    video?: boolean | VideoCaptureOptions;
+}
+export interface VideoCaptureOptions {
+    /**
+     * A ConstrainDOMString object specifying a device ID or an array of device
+     * IDs which are acceptable and/or required.
+     */
+    deviceId?: ConstrainDOMString;
+    /**
+     * a facing or an array of facings which are acceptable and/or required.
+     */
+    facingMode?: 'user' | 'environment' | 'left' | 'right';
+    resolution?: VideoResolution;
+}
+export interface ScreenShareCaptureOptions {
+    /**
+     * true to capture audio shared. browser support for audio capturing in
+     * screenshare is limited: https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia#browser_compatibility
+     */
+    audio?: boolean | AudioCaptureOptions;
+    /** capture resolution, defaults to full HD */
+    resolution?: VideoResolution;
+}
+export interface AudioCaptureOptions {
+    /**
+     * specifies whether automatic gain control is preferred and/or required
+     */
+    autoGainControl?: ConstrainBoolean;
+    /**
+     * the channel count or range of channel counts which are acceptable and/or required
+     */
+    channelCount?: ConstrainULong;
+    /**
+     * A ConstrainDOMString object specifying a device ID or an array of device
+     * IDs which are acceptable and/or required.
+     */
+    deviceId?: ConstrainDOMString;
+    /**
+     * whether or not echo cancellation is preferred and/or required
+     */
+    echoCancellation?: ConstrainBoolean;
+    /**
+     * the latency or range of latencies which are acceptable and/or required.
+     */
+    latency?: ConstrainDouble;
+    /**
+     * whether noise suppression is preferred and/or required.
+     */
+    noiseSuppression?: ConstrainBoolean;
+    /**
+     * the sample rate or range of sample rates which are acceptable and/or required.
+     */
+    sampleRate?: ConstrainULong;
+    /**
+     * sample size or range of sample sizes which are acceptable and/or required.
+     */
+    sampleSize?: ConstrainULong;
+}
+export interface AudioOutputOptions {
+    /**
+     * deviceId to output audio
+     *
+     * Only supported on browsers where `setSinkId` is available
+     */
+    deviceId?: string;
+}
+export interface VideoResolution {
+    width: number;
+    height: number;
+    frameRate?: number;
+    aspectRatio?: number;
+}
+export interface VideoEncoding {
+    maxBitrate: number;
+    maxFramerate?: number;
+}
+export declare class VideoPreset {
+    encoding: VideoEncoding;
+    width: number;
+    height: number;
+    constructor(width: number, height: number, maxBitrate: number, maxFramerate?: number);
+    get resolution(): VideoResolution;
+}
+export interface AudioPreset {
+    maxBitrate: number;
+}
+declare const codecs: readonly [
+    "vp8",
+    "h264",
+    "av1"
+];
+declare const backupCodecs: readonly [
+    "vp8",
+    "h264"
+];
+export type VideoCodec = typeof codecs[number];
+export type BackupVideoCodec = typeof backupCodecs[number];
+export declare function isBackupCodec(codec: string): codec is BackupVideoCodec;
+/**
+ * scalability modes for svc, only supprot l3t3 now.
+ */
+export type ScalabilityMode = 'L3T3';
+export declare namespace AudioPresets {
+    const telephone: AudioPreset;
+    const speech: AudioPreset;
+    const music: AudioPreset;
+    const musicStereo: AudioPreset;
+    const musicHighQuality: AudioPreset;
+    const musicHighQualityStereo: AudioPreset;
+}
+/**
+ * Sane presets for video resolution/encoding
+ */
+export declare const VideoPresets: {
+    readonly h90: VideoPreset;
+    readonly h180: VideoPreset;
+    readonly h216: VideoPreset;
+    readonly h360: VideoPreset;
+    readonly h540: VideoPreset;
+    readonly h720: VideoPreset;
+    readonly h1080: VideoPreset;
+    readonly h1440: VideoPreset;
+    readonly h2160: VideoPreset;
+};
+/**
+ * Four by three presets
+ */
+export declare const VideoPresets43: {
+    readonly h120: VideoPreset;
+    readonly h180: VideoPreset;
+    readonly h240: VideoPreset;
+    readonly h360: VideoPreset;
+    readonly h480: VideoPreset;
+    readonly h540: VideoPreset;
+    readonly h720: VideoPreset;
+    readonly h1080: VideoPreset;
+    readonly h1440: VideoPreset;
+};
+export declare const ScreenSharePresets: {
+    readonly h360fps3: VideoPreset;
+    readonly h720fps5: VideoPreset;
+    readonly h720fps15: VideoPreset;
+    readonly h1080fps15: VideoPreset;
+    readonly h1080fps30: VideoPreset;
+};
+export {};
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1,23 @@
+import type LocalAudioTrack from './LocalAudioTrack';
+import type LocalVideoTrack from './LocalVideoTrack';
+import type RemoteAudioTrack from './RemoteAudioTrack';
+import type RemoteVideoTrack from './RemoteVideoTrack';
+export type AudioTrack = RemoteAudioTrack | LocalAudioTrack;
+export type VideoTrack = RemoteVideoTrack | LocalVideoTrack;
+export type AdaptiveStreamSettings = {
+    /**
+     * Set a custom pixel density, defaults to 1
+     * When streaming videos on a ultra high definition screen this setting
+     * let's you account for the devicePixelRatio of those screens.
+     * Set it to `screen` to use the actual pixel density of the screen
+     * Note: this might significantly increase the bandwidth consumed by people
+     * streaming on high definition screens.
+     */
+    pixelDensity?: number | 'screen';
+    /**
+     * If true, video gets paused when switching to another tab.
+     * Defaults to true.
+     */
+    pauseVideoInBackground?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { AudioCaptureOptions, CreateLocalTracksOptions, VideoCaptureOptions } from './options';
+import type { AudioTrack } from './types';
+export declare function mergeDefaultOptions(options?: CreateLocalTracksOptions, audioDefaults?: AudioCaptureOptions, videoDefaults?: VideoCaptureOptions): CreateLocalTracksOptions;
+export declare function constraintsForOptions(options: CreateLocalTracksOptions): MediaStreamConstraints;
+/**
+ * This function detects silence on a given [[Track]] instance.
+ * Returns true if the track seems to be entirely silent.
+ */
+export declare function detectSilence(track: AudioTrack, timeOffset?: number): Promise<boolean>;
+/**
+ * @internal
+ */
+export declare function getNewAudioContext(): AudioContext | void;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,13 @@
+export type SimulationOptions = {
+    publish?: {
+        audio?: boolean;
+        video?: boolean;
+    };
+    participants?: {
+        count?: number;
+        aspectRatios?: Array<number>;
+        audio?: boolean;
+        video?: boolean;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,79 @@
+import { ClientInfo } from '../proto/livekit_models';
+import type LocalAudioTrack from './track/LocalAudioTrack';
+import type RemoteAudioTrack from './track/RemoteAudioTrack';
+export declare function unpackStreamId(packed: string): string[];
+export declare function sleep(duration: number): Promise<void>;
+/** @internal */
+export declare function supportsTransceiver(): boolean;
+/** @internal */
+export declare function supportsAddTrack(): boolean;
+export declare function supportsAdaptiveStream(): boolean;
+export declare function supportsDynacast(): boolean;
+export declare function supportsAV1(): boolean;
+export declare function supportsSetSinkId(elm?: HTMLMediaElement): boolean;
+export declare function supportsSetCodecPreferences(transceiver: RTCRtpTransceiver): boolean;
+export declare function isBrowserSupported(): boolean;
+export declare function isFireFox(): boolean;
+export declare function isSafari(): boolean;
+export declare function isMobile(): boolean;
+export declare function isWeb(): boolean;
+export declare function compareVersions(v1: string, v2: string): number;
+export declare const getResizeObserver: () => ResizeObserver;
+export declare const getIntersectionObserver: () => IntersectionObserver;
+export interface ObservableMediaElement extends HTMLMediaElement {
+    handleResize: (entry: ResizeObserverEntry) => void;
+    handleVisibilityChanged: (entry: IntersectionObserverEntry) => void;
+}
+export declare function getClientInfo(): ClientInfo;
+export declare function getEmptyVideoStreamTrack(): MediaStreamTrack;
+export declare function createDummyVideoStreamTrack(width?: number, height?: number, enabled?: boolean, paintContent?: boolean): MediaStreamTrack;
+export declare function getEmptyAudioStreamTrack(): MediaStreamTrack;
+export declare class Future<T> {
+    promise: Promise<T>;
+    resolve?: (arg: T) => void;
+    reject?: (e: any) => void;
+    onFinally?: () => void;
+    constructor(futureBase?: (resolve: (arg: T) => void, reject: (e: any) => void) => void, onFinally?: () => void);
+}
+export type AudioAnalyserOptions = {
+    /**
+     * If set to true, the analyser will use a cloned version of the underlying mediastreamtrack, which won't be impacted by muting the track.
+     * Useful for local tracks when implementing things like "seems like you're muted, but trying to speak".
+     * Defaults to false
+     */
+    cloneTrack?: boolean;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/fftSize
+     */
+    fftSize?: number;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/smoothingTimeConstant
+     */
+    smoothingTimeConstant?: number;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/minDecibels
+     */
+    minDecibels?: number;
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/maxDecibels
+     */
+    maxDecibels?: number;
+};
+/**
+ * Creates and returns an analyser web audio node that is attached to the provided track.
+ * Additionally returns a convenience method `calculateVolume` to perform instant volume readings on that track.
+ * Call the returned `cleanup` function to close the audioContext that has been created for the instance of this helper
+ */
+export declare function createAudioAnalyser(track: LocalAudioTrack | RemoteAudioTrack, options?: AudioAnalyserOptions): {
+    calculateVolume: () => number;
+    analyser: AnalyserNode;
+    cleanup: () => void;
+};
+export declare class Mutex {
+    private _locking;
+    private _locks;
+    constructor();
+    isLocked(): boolean;
+    lock(): Promise<() => void>;
+}
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/src/test/MockMediaStreamTrack.d.ts

@@ -0,0 +1,26 @@
+export default class MockMediaStreamTrack implements MediaStreamTrack {
+    contentHint: string;
+    enabled: boolean;
+    id: string;
+    kind: string;
+    label: string;
+    muted: boolean;
+    onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    readyState: MediaStreamTrackState;
+    isolated: boolean;
+    onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null;
+    applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
+    clone(): MediaStreamTrack;
+    getCapabilities(): MediaTrackCapabilities;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    stop(): void;
+    addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+}
+//# sourceMappingURL=MockMediaStreamTrack.d.ts.map

package/dist/ts4.2/src/test/mocks.d.ts

@@ -0,0 +1,11 @@
+import { SignalClient } from '../api/SignalClient';
+import RTCEngine from '../room/RTCEngine';
+declare const mocks: {
+    SignalClient: jest.MockedClass<typeof SignalClient>;
+    RTCEngine: jest.MockedClass<typeof RTCEngine>;
+    MockLocalVideoTrack: {
+        stop: jest.Mock<any, any>;
+    };
+};
+export default mocks;
+//# sourceMappingURL=mocks.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const version: string;
+export declare const protocolVersion = 8;
+//# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.4.4",
+  "version": "1.6.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -15,11 +15,18 @@
     "src"
   ],
   "types": "dist/src/index.d.ts",
+  "typesVersions": {
+    "<4.8": {
+      "./dist/src/index.d.ts": [
+        "./dist/src/ts4.2/index.d.ts"
+      ]
+    }
+  },
   "repository": "git@github.com:livekit/client-sdk-js.git",
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "rollup --config",
+    "build": "rollup --config --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",
@@ -29,7 +36,8 @@
     "deploy": "gh-pages -d example/dist",
     "format": "prettier --write src example/sample.ts",
     "format:check": "prettier --check src",
-    "release": "yarn build && changeset publish"
+    "release": "yarn build && changeset publish",
+    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2"
   },
   "dependencies": {
     "async-await-queue": "^1.2.1",
@@ -43,38 +51,40 @@
     "webrtc-adapter": "^8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.19.3",
-    "@babel/preset-env": "7.19.3",
+    "@babel/core": "7.20.5",
+    "@babel/preset-env": "7.20.2",
     "@changesets/changelog-github": "0.4.7",
-    "@changesets/cli": "2.25.0",
-    "@rollup/plugin-babel": "5.3.1",
-    "@rollup/plugin-commonjs": "22.0.2",
-    "@rollup/plugin-json": "4.1.0",
-    "@rollup/plugin-node-resolve": "14.1.0",
-    "@types/jest": "29.1.1",
+    "@changesets/cli": "2.25.2",
+    "@rollup/plugin-babel": "6.0.3",
+    "@rollup/plugin-commonjs": "23.0.4",
+    "@rollup/plugin-json": "5.0.2",
+    "@rollup/plugin-node-resolve": "15.0.1",
+    "@types/jest": "29.2.4",
     "@types/sdp-transform": "2.4.5",
     "@types/ua-parser-js": "0.7.36",
     "@types/ws": "8.5.3",
-    "@typescript-eslint/eslint-plugin": "5.38.1",
-    "@typescript-eslint/parser": "5.38.1",
-    "eslint": "8.24.0",
+    "@typescript-eslint/eslint-plugin": "5.46.0",
+    "@typescript-eslint/parser": "5.46.0",
+    "downlevel-dts": "^0.11.0",
+    "eslint": "8.29.0",
     "eslint-config-airbnb-typescript": "17.0.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-import": "2.26.0",
     "gh-pages": "4.0.0",
-    "jest": "29.1.2",
-    "prettier": "2.7.1",
-    "rollup": "2.79.1",
+    "jest": "29.3.1",
+    "prettier": "2.8.1",
+    "rollup": "3.7.0",
+    "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-filesize": "9.1.2",
     "rollup-plugin-re": "1.0.7",
     "rollup-plugin-terser": "7.0.2",
-    "rollup-plugin-typescript2": "0.34.0",
+    "rollup-plugin-typescript2": "0.34.1",
     "ts-jest": "29.0.3",
-    "ts-proto": "1.126.1",
-    "typedoc": "0.23.15",
+    "ts-proto": "1.135.0",
+    "typedoc": "0.23.21",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "4.8.4",
-    "vite": "3.1.8"
+    "typescript": "4.9.4",
+    "vite": "3.2.5"
   },
   "browserslist": [
     "safari >= 11",

package/src/api/SignalClient.ts

@@ -30,7 +30,7 @@ import {
   UpdateTrackSettings,
 } from '../proto/livekit_rtc';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
-import { getClientInfo, sleep } from '../room/utils';
+import { getClientInfo, Mutex, sleep } from '../room/utils';
 
 // internal options
 interface ConnectOpts {
@@ -139,12 +139,15 @@ export class SignalClient {
 
   private pingInterval: ReturnType<typeof setInterval> | undefined;
 
+  private closingLock: Mutex;
+
   constructor(useJSON: boolean = false) {
     this.isConnected = false;
     this.isReconnecting = false;
     this.useJSON = useJSON;
     this.requestQueue = new Queue();
     this.queuedRequests = [];
+    this.closingLock = new Mutex();
   }
 
   async join(
@@ -190,9 +193,9 @@ export class SignalClient {
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
 
-    return new Promise<JoinResponse | void>((resolve, reject) => {
-      const abortHandler = () => {
-        this.close();
+    return new Promise<JoinResponse | void>(async (resolve, reject) => {
+      const abortHandler = async () => {
+        await this.close();
         reject(new ConnectionError('room connection has been cancelled'));
       };
 
@@ -202,7 +205,7 @@ export class SignalClient {
       abortSignal?.addEventListener('abort', abortHandler);
       log.debug(`connecting to ${url + params}`);
       if (this.ws) {
-        this.close();
+        await this.close();
       }
       this.ws = new WebSocket(url + params);
       this.ws.binaryType = 'arraybuffer';
@@ -277,7 +280,11 @@ export class SignalClient {
             }
             resolve(resp.message.join);
           } else {
-            reject(new ConnectionError('did not receive join response'));
+            reject(
+              new ConnectionError(
+                `did not receive join response, got ${resp.message?.$case} instead`,
+              ),
+            );
           }
           return;
         }
@@ -301,16 +308,33 @@ export class SignalClient {
     });
   }
 
-  close() {
-    this.isConnected = false;
-    if (this.ws) {
-      this.ws.onclose = null;
-      this.ws.onmessage = null;
-      this.ws.onopen = null;
-      this.ws.close();
+  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;
+
+        // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
+        const closePromise = new Promise((resolve) => {
+          if (this.ws) {
+            this.ws.onclose = resolve;
+          } else {
+            resolve(true);
+          }
+        });
+
+        this.ws.close();
+        // 250ms grace period for ws to close gracefully
+        await Promise.race([closePromise, sleep(250)]);
+      }
+      this.ws = undefined;
+      this.clearPingInterval();
+    } finally {
+      unlock();
     }
-    this.ws = undefined;
-    this.clearPingInterval();
   }
 
   // initial offer after joining
@@ -441,8 +465,8 @@ export class SignalClient {
     if (this.signalLatency) {
       await sleep(this.signalLatency);
     }
-    if (!this.ws) {
-      log.error('cannot send signal request before connected');
+    if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
+      log.error(`cannot send signal request before connected, type: ${message?.$case}`);
       return;
     }