livekit-client 1.12.3 → 1.13.0

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

@@ -3,7 +3,9 @@ import { VideoLayer, VideoQuality } from '../../proto/livekit_models_pb';
 import { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc_pb';
 import type { VideoSenderStats } from '../stats';
 import LocalTrack from './LocalTrack';
+import { Track } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
+import type { TrackProcessor } from './processor/types';
 export declare class SimulcastTrackInfo {
     codec: VideoCodec;
     mediaStreamTrack: MediaStreamTrack;
@@ -28,12 +30,16 @@ export default class LocalVideoTrack extends LocalTrack {
     get isSimulcast(): boolean;
     startMonitor(signalClient: SignalClient): void;
     stop(): void;
+    pauseUpstream(): Promise<void>;
+    resumeUpstream(): Promise<void>;
     mute(): Promise<LocalVideoTrack>;
     unmute(): Promise<LocalVideoTrack>;
+    protected setTrackMuted(muted: boolean): void;
     getSenderStats(): Promise<VideoSenderStats[]>;
     setPublishingQuality(maxQuality: VideoQuality): void;
     setDeviceId(deviceId: ConstrainDOMString): Promise<boolean>;
     restartTrack(options?: VideoCaptureOptions): Promise<void>;
+    setProcessor(processor: TrackProcessor<Track.Kind>, showProcessedStreamLocally?: boolean): Promise<void>;
     addSimulcastTrack(codec: VideoCodec, encodings?: RTCRtpEncodingParameters[]): SimulcastTrackInfo;
     setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender): void;
     /**

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

@@ -10,9 +10,20 @@ export type ProcessorOptions<T extends Track.Kind> = {
 /**
  * @experimental
  */
-export interface TrackProcessor<T extends Track.Kind> {
+export interface AudioProcessorOptions extends ProcessorOptions<Track.Kind.Audio> {
+    audioContext: AudioContext;
+}
+/**
+ * @experimental
+ */
+export interface VideoProcessorOptions extends ProcessorOptions<Track.Kind.Video> {
+}
+/**
+ * @experimental
+ */
+export interface TrackProcessor<T extends Track.Kind, U extends ProcessorOptions<T> = ProcessorOptions<T>> {
     name: string;
-    init: (opts: ProcessorOptions<T>) => void;
+    init: (opts: U) => void;
     destroy: () => Promise<void>;
     processedTrack?: MediaStreamTrack;
 }

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

@@ -22,5 +22,5 @@ export type LiveKitReactNativeInfo = {
     platform: 'ios' | 'android' | 'windows' | 'macos' | 'web' | 'native';
     devicePixelRatio: number;
 };
-export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect';
+export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect' | 'subscriber-bandwidth';
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.12.3",
+  "version": "1.13.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -61,10 +61,10 @@
     "webrtc-adapter": "^8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.22.1",
-    "@babel/preset-env": "7.22.4",
+    "@babel/core": "7.22.9",
+    "@babel/preset-env": "7.22.9",
     "@bufbuild/protoc-gen-es": "^1.3.0",
-    "@changesets/cli": "2.26.1",
+    "@changesets/cli": "2.26.2",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.3",
     "@rollup/plugin-commonjs": "24.1.0",
@@ -77,27 +77,26 @@
     "@types/events": "^3.0.0",
     "@types/sdp-transform": "2.4.6",
     "@types/ua-parser-js": "0.7.36",
-    "@typescript-eslint/eslint-plugin": "5.59.8",
-    "@typescript-eslint/parser": "5.59.8",
+    "@typescript-eslint/eslint-plugin": "5.62.0",
+    "@typescript-eslint/parser": "5.62.0",
     "downlevel-dts": "^0.11.0",
-    "eslint": "8.42.0",
-    "eslint-config-airbnb-typescript": "17.0.0",
-    "eslint-config-prettier": "8.8.0",
+    "eslint": "8.46.0",
+    "eslint-config-airbnb-typescript": "17.1.0",
+    "eslint-config-prettier": "8.9.0",
     "eslint-plugin-ecmascript-compat": "^3.0.0",
-    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-import": "2.28.0",
     "gh-pages": "5.0.0",
     "jsdom": "^22.1.0",
     "prettier": "^2.8.8",
-    "rollup": "3.23.1",
+    "rollup": "3.27.0",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-re": "1.0.7",
-    "rollup-plugin-typescript2": "0.34.1",
+    "rollup-plugin-typescript2": "0.35.0",
     "size-limit": "^8.2.4",
-    "ts-proto": "1.148.2",
     "typedoc": "0.24.8",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "5.1.3",
-    "vite": "4.3.9",
-    "vitest": "^0.32.0"
+    "typescript": "5.1.6",
+    "vite": "4.4.7",
+    "vitest": "^0.33.0"
   }
 }

package/src/api/SignalClient.ts

@@ -43,21 +43,13 @@ import { Mutex, getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../r
 import { AsyncQueue } from '../utils/AsyncQueue';
 
 // internal options
-interface ConnectOpts {
-  autoSubscribe: boolean;
+interface ConnectOpts extends SignalOptions {
   /** internal */
   reconnect?: boolean;
-
   /** internal */
   reconnectReason?: number;
-
   /** internal */
   sid?: string;
-
-  /** @deprecated */
-  publishOnly?: string;
-
-  adaptiveStream?: boolean;
 }
 
 // public options
@@ -68,6 +60,7 @@ export interface SignalOptions {
   adaptiveStream?: boolean;
   maxRetries: number;
   e2eeEnabled: boolean;
+  websocketTimeout: number;
 }
 
 type SignalMessage = SignalRequest['message'];
@@ -224,9 +217,15 @@ export class SignalClient {
     return new Promise<JoinResponse | ReconnectResponse | void>(async (resolve, reject) => {
       const abortHandler = async () => {
         this.close();
+        clearTimeout(wsTimeout);
         reject(new ConnectionError('room connection has been cancelled (signal)'));
       };
 
+      const wsTimeout = setTimeout(() => {
+        this.close();
+        reject(new ConnectionError('room connection has timed out (signal)'));
+      }, opts.websocketTimeout);
+
       if (abortSignal?.aborted) {
         abortHandler();
       }
@@ -238,8 +237,13 @@ export class SignalClient {
       this.ws = new WebSocket(url + params);
       this.ws.binaryType = 'arraybuffer';
 
+      this.ws.onopen = () => {
+        clearTimeout(wsTimeout);
+      };
+
       this.ws.onerror = async (ev: Event) => {
         if (!this.isConnected) {
+          clearTimeout(wsTimeout);
           try {
             const resp = await fetch(`http${url.substring(2)}/validate${params}`);
             if (resp.status.toFixed(0).startsWith('4')) {

package/src/connectionHelper/checks/turn.ts

@@ -12,6 +12,7 @@ export class TURNCheck extends Checker {
       autoSubscribe: true,
       maxRetries: 0,
       e2eeEnabled: false,
+      websocketTimeout: 15_000,
     });
 
     let hasTLS = false;

package/src/connectionHelper/checks/webrtc.ts

@@ -1,3 +1,4 @@
+import log from '../../logger';
 import { RoomEvent } from '../../room/events';
 import { Checker } from './Checker';
 
@@ -14,19 +15,20 @@ export class WebRTCCheck extends Checker {
 
       const candidates: RTCIceCandidate[] = [];
       this.room.engine.client.onTrickle = (sd, target) => {
-        console.log('got candidate', sd);
         if (sd.candidate) {
           const candidate = new RTCIceCandidate(sd);
           candidates.push(candidate);
           let str = `${candidate.protocol} ${candidate.address}:${candidate.port} ${candidate.type}`;
-          if (candidate.protocol === 'tcp' && candidate.tcpType === 'passive') {
-            hasTcp = true;
-            str += ' (active)';
-          } else if (candidate.protocol === 'udp' && candidate.address) {
+          if (candidate.address) {
             if (isIPPrivate(candidate.address)) {
               str += ' (private)';
             } else {
-              hasIpv4Udp = true;
+              if (candidate.protocol === 'tcp' && candidate.tcpType === 'passive') {
+                hasTcp = true;
+                str += ' (passive)';
+              } else if (candidate.protocol === 'udp') {
+                hasIpv4Udp = true;
+              }
             }
           }
           this.appendMessage(str);
@@ -48,7 +50,7 @@ export class WebRTCCheck extends Checker {
     });
     try {
       await this.connect();
-      console.log('now the room is connected');
+      log.info('now the room is connected');
     } catch (err) {
       this.appendWarning('ports need to be open on firewall in order to connect.');
       throw err;

package/src/connectionHelper/checks/websocket.ts

@@ -17,6 +17,7 @@ export class WebSocketCheck extends Checker {
       autoSubscribe: true,
       maxRetries: 0,
       e2eeEnabled: false,
+      websocketTimeout: 15_000,
     });
     this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
     if (joinRes.serverInfo?.edition === ServerInfo_Edition.Cloud && joinRes.serverInfo?.region) {

package/src/e2ee/E2eeManager.ts

@@ -25,6 +25,7 @@ import type {
   RatchetRequestMessage,
   RemoveTransformMessage,
   SetKeyMessage,
+  SifTrailerMessage,
   UpdateCodecMessage,
 } from './types';
 import { EncryptionEvent } from './types';
@@ -99,6 +100,17 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     }
   }
 
+  /**
+   * @internal
+   */
+  setSifTrailer(trailer: Uint8Array) {
+    if (!trailer || trailer.length === 0) {
+      log.warn("ignoring server sent trailer as it's empty");
+    } else {
+      this.postSifTrailer(trailer);
+    }
+  }
+
   private onWorkerMessage = (ev: MessageEvent<E2EEWorkerMessage>) => {
     const { kind, data } = ev.data;
     switch (kind) {
@@ -233,6 +245,19 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     this.worker.postMessage(msg);
   }
 
+  private postSifTrailer(trailer: Uint8Array) {
+    if (!this.worker) {
+      throw Error('could not post SIF trailer, worker is missing');
+    }
+    const msg: SifTrailerMessage = {
+      kind: 'setSifTrailer',
+      data: {
+        trailer,
+      },
+    };
+    this.worker.postMessage(msg);
+  }
+
   private setupE2EEReceiver(track: RemoteTrack, remoteId: string, trackInfo?: TrackInfo) {
     if (!track.receiver) {
       return;
@@ -342,7 +367,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     }
 
     if (isScriptTransformSupported()) {
-      log.warn('initialize script transform');
+      log.info('initialize script transform');
 
       const options = {
         kind: 'encode',
@@ -353,7 +378,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
       // @ts-ignore
       sender.transform = new RTCRtpScriptTransform(this.worker, options);
     } else {
-      log.warn('initialize encoded streams');
+      log.info('initialize encoded streams');
       // @ts-ignore
       const senderStreams = sender.createEncodedStreams();
       const msg: EncodeMessage = {

package/src/e2ee/KeyProvider.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
 import { KEY_PROVIDER_DEFAULTS } from './constants';
 import type { KeyInfo, KeyProviderCallbacks, KeyProviderOptions } from './types';
-import { createKeyMaterialFromString } from './utils';
+import { createKeyMaterialFromBuffer, createKeyMaterialFromString } from './utils';
 
 /**
  * @experimental
@@ -68,11 +68,16 @@ export class ExternalE2EEKeyProvider extends BaseKeyProvider {
   }
 
   /**
-   * Accepts a passphrase that's used to create the crypto keys
+   * Accepts a passphrase that's used to create the crypto keys.
+   * When passing in a string, PBKDF2 is used.
+   * Also accepts an Array buffer of cryptographically random numbers that uses HKDF.
    * @param key
    */
-  async setKey(key: string) {
-    const derivedKey = await createKeyMaterialFromString(key);
+  async setKey(key: string | ArrayBuffer) {
+    const derivedKey =
+      typeof key === 'string'
+        ? await createKeyMaterialFromString(key)
+        : await createKeyMaterialFromBuffer(key);
     this.onSetEncryptionKey(derivedKey);
   }
 }

package/src/e2ee/constants.ts

@@ -42,3 +42,6 @@ export const KEY_PROVIDER_DEFAULTS: KeyProviderOptions = {
   ratchetWindowSize: 8,
   failureTolerance: DECRYPTION_FAILURE_TOLERANCE,
 } as const;
+
+export const MAX_SIF_COUNT = 100;
+export const MAX_SIF_DURATION = 2000;

package/src/e2ee/types.ts

@@ -31,6 +31,13 @@ export interface RTPVideoMapMessage extends BaseMessage {
   };
 }
 
+export interface SifTrailerMessage extends BaseMessage {
+  kind: 'setSifTrailer';
+  data: {
+    trailer: Uint8Array;
+  };
+}
+
 export interface EncodeMessage extends BaseMessage {
   kind: 'decode' | 'encode';
   data: {
@@ -102,7 +109,8 @@ export type E2EEWorkerMessage =
   | RTPVideoMapMessage
   | UpdateCodecMessage
   | RatchetRequestMessage
-  | RatchetMessage;
+  | RatchetMessage
+  | SifTrailerMessage;
 
 export type KeySet = { material: CryptoKey; encryptionKey: CryptoKey };
 

package/src/e2ee/utils.ts

@@ -56,6 +56,15 @@ export async function createKeyMaterialFromString(password: string) {
   return keyMaterial;
 }
 
+export async function createKeyMaterialFromBuffer(cryptoBuffer: ArrayBuffer) {
+  const keyMaterial = await crypto.subtle.importKey('raw', cryptoBuffer, 'HKDF', false, [
+    'deriveBits',
+    'deriveKey',
+  ]);
+
+  return keyMaterial;
+}
+
 function getAlgoOptions(algorithmName: string, salt: string) {
   const textEncoder = new TextEncoder();
   const encodedSalt = textEncoder.encode(salt);

package/src/e2ee/worker/FrameCryptor.ts

@@ -15,6 +15,7 @@ import {
 } from '../types';
 import { deriveKeys, isVideoFrame } from '../utils';
 import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
+import { SifGuard } from './SifGuard';
 
 export interface FrameCryptorConstructor {
   new (opts?: unknown): BaseFrameCryptor;
@@ -65,13 +66,15 @@ export class FrameCryptor extends BaseFrameCryptor {
   /**
    * used for detecting server injected unencrypted frames
    */
-  private unencryptedFrameByteTrailer: Uint8Array;
+  private sifTrailer: Uint8Array;
+
+  private sifGuard: SifGuard;
 
   constructor(opts: {
     keys: ParticipantKeyHandler;
     participantId: string;
     keyProviderOptions: KeyProviderOptions;
-    unencryptedFrameBytes?: Uint8Array;
+    sifTrailer?: Uint8Array;
   }) {
     super();
     this.sendCounts = new Map();
@@ -79,8 +82,8 @@ export class FrameCryptor extends BaseFrameCryptor {
     this.participantId = opts.participantId;
     this.rtpMap = new Map();
     this.keyProviderOptions = opts.keyProviderOptions;
-    this.unencryptedFrameByteTrailer =
-      opts.unencryptedFrameBytes ?? new TextEncoder().encode('LKROCKS');
+    this.sifTrailer = opts.sifTrailer ?? Uint8Array.from([]);
+    this.sifGuard = new SifGuard();
   }
 
   /**
@@ -92,6 +95,7 @@ export class FrameCryptor extends BaseFrameCryptor {
   setParticipant(id: string, keys: ParticipantKeyHandler) {
     this.participantId = id;
     this.keys = keys;
+    this.sifGuard.reset();
   }
 
   unsetParticipant() {
@@ -130,9 +134,10 @@ export class FrameCryptor extends BaseFrameCryptor {
     codec?: VideoCodec,
   ) {
     if (codec) {
-      console.info('setting codec on cryptor to', codec);
+      workerLogger.info('setting codec on cryptor to', { codec });
       this.videoCodec = codec;
     }
+
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
       transform: transformFn.bind(this),
@@ -142,7 +147,7 @@ export class FrameCryptor extends BaseFrameCryptor {
       .pipeThrough(transformStream)
       .pipeTo(writable)
       .catch((e) => {
-        console.error(e);
+        workerLogger.warn(e);
         this.emit('cryptorError', e instanceof CryptorError ? e : new CryptorError(e.message));
       });
     this.trackId = trackId;
@@ -260,12 +265,24 @@ export class FrameCryptor extends BaseFrameCryptor {
     if (
       !this.keys.isEnabled() ||
       // skip for decryption for empty dtx frames
-      encodedFrame.data.byteLength === 0 ||
-      // skip decryption if frame is server injected
-      isFrameServerInjected(encodedFrame.data, this.unencryptedFrameByteTrailer)
+      encodedFrame.data.byteLength === 0
     ) {
+      this.sifGuard.recordUserFrame();
       return controller.enqueue(encodedFrame);
     }
+
+    if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
+      this.sifGuard.recordSif();
+
+      if (this.sifGuard.isSifAllowed()) {
+        return controller.enqueue(encodedFrame);
+      } else {
+        workerLogger.warn('SIF limit reached, dropping frame');
+        return;
+      }
+    } else {
+      this.sifGuard.recordUserFrame();
+    }
     const data = new Uint8Array(encodedFrame.data);
     const keyIndex = data[encodedFrame.data.byteLength - 1];
 
@@ -293,9 +310,17 @@ export class FrameCryptor extends BaseFrameCryptor {
           workerLogger.warn('decoding frame failed', { error });
         }
       }
+    } else if (!this.keys.getKeySet(keyIndex) && this.keys.hasValidKey) {
+      // emit an error in case the key index is out of bounds but the key handler thinks we still have a valid key
+      workerLogger.warn('skipping decryption due to missing key at index');
+      this.emit(
+        CryptorEvent.Error,
+        new CryptorError(
+          `missing key at index for participant ${this.participantId}`,
+          CryptorErrorReason.MissingKey,
+        ),
+      );
     }
-
-    return controller.enqueue(encodedFrame);
   }
 
   /**
@@ -398,12 +423,9 @@ export class FrameCryptor extends BaseFrameCryptor {
           }
 
           workerLogger.warn('maximum ratchet attempts exceeded, resetting key');
-          this.emit(
-            CryptorEvent.Error,
-            new CryptorError(
-              `valid key missing for participant ${this.participantId}`,
-              CryptorErrorReason.MissingKey,
-            ),
+          throw new CryptorError(
+            `valid key missing for participant ${this.participantId}`,
+            CryptorErrorReason.InvalidKey,
           );
         }
       } else {
@@ -513,6 +535,10 @@ export class FrameCryptor extends BaseFrameCryptor {
     const codec = payloadType ? this.rtpMap.get(payloadType) : undefined;
     return codec;
   }
+
+  setSifTrailer(trailer: Uint8Array) {
+    this.sifTrailer = trailer;
+  }
 }
 
 /**
@@ -605,6 +631,9 @@ export enum NALUType {
  * @internal
  */
 export function isFrameServerInjected(frameData: ArrayBuffer, trailerBytes: Uint8Array): boolean {
+  if (trailerBytes.byteLength === 0) {
+    return false;
+  }
   const frameTrailer = new Uint8Array(
     frameData.slice(frameData.byteLength - trailerBytes.byteLength),
   );

package/src/e2ee/worker/ParticipantKeyHandler.ts

@@ -63,6 +63,7 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
     this.decryptionFailureCount += 1;
 
     if (this.decryptionFailureCount > this.keyProviderOptions.failureTolerance) {
+      workerLogger.warn(`key for ${this.participantId} is being marked as invalid`);
       this._hasValidKey = false;
     }
   }

package/src/e2ee/worker/SifGuard.ts

@@ -0,0 +1,47 @@
+import { MAX_SIF_COUNT, MAX_SIF_DURATION } from '../constants';
+
+export class SifGuard {
+  private consecutiveSifCount = 0;
+
+  private sifSequenceStartedAt: number | undefined;
+
+  private lastSifReceivedAt: number = 0;
+
+  private userFramesSinceSif: number = 0;
+
+  recordSif() {
+    this.consecutiveSifCount += 1;
+    this.sifSequenceStartedAt ??= Date.now();
+    this.lastSifReceivedAt = Date.now();
+  }
+
+  recordUserFrame() {
+    if (this.sifSequenceStartedAt === undefined) {
+      return;
+    } else {
+      this.userFramesSinceSif += 1;
+    }
+    if (
+      // reset if we received more user frames than SIFs
+      this.userFramesSinceSif > this.consecutiveSifCount ||
+      // also reset if we got a new user frame and the latest SIF frame hasn't been updated in a while
+      Date.now() - this.lastSifReceivedAt > MAX_SIF_DURATION
+    ) {
+      this.reset();
+    }
+  }
+
+  isSifAllowed() {
+    return (
+      this.consecutiveSifCount < MAX_SIF_COUNT &&
+      (this.sifSequenceStartedAt === undefined ||
+        Date.now() - this.sifSequenceStartedAt < MAX_SIF_DURATION)
+    );
+  }
+
+  reset() {
+    this.userFramesSinceSif = 0;
+    this.consecutiveSifCount = 0;
+    this.sifSequenceStartedAt = undefined;
+  }
+}

package/src/e2ee/worker/e2ee.worker.ts

@@ -24,6 +24,8 @@ let useSharedKey: boolean = false;
 
 let sharedKey: CryptoKey | undefined;
 
+let sifTrailer: Uint8Array | undefined;
+
 let keyProviderOptions: KeyProviderOptions = KEY_PROVIDER_DEFAULTS;
 
 workerLogger.setDefaultLevel('info');
@@ -94,6 +96,10 @@ onmessage = (ev) => {
       break;
     case 'ratchetRequest':
       handleRatchetRequest(data);
+      break;
+    case 'setSifTrailer':
+      handleSifTrailer(data.trailer);
+      break;
     default:
       break;
   }
@@ -116,6 +122,7 @@ function getTrackCryptor(participantId: string, trackId: string) {
       participantId,
       keys: getParticipantKeyHandler(participantId),
       keyProviderOptions,
+      sifTrailer,
     });
 
     setupCryptorErrorEvents(cryptor);
@@ -205,6 +212,13 @@ function emitRatchetedKeys(material: CryptoKey, keyIndex?: number) {
   postMessage(msg);
 }
 
+function handleSifTrailer(trailer: Uint8Array) {
+  sifTrailer = trailer;
+  participantCryptors.forEach((c) => {
+    c.setSifTrailer(trailer);
+  });
+}
+
 // Operations using RTCRtpScriptTransform.
 // @ts-ignore
 if (self.RTCTransformEvent) {

package/src/options.ts

@@ -31,6 +31,9 @@ export interface InternalRoomOptions {
    * enable Dynacast, off by default. With Dynacast dynamically pauses
    * video layers that are not being consumed by any subscribers, significantly
    * reducing publishing CPU and bandwidth usage.
+   *
+   * Dynacast will be enabled if SVC codecs (VP9/AV1) are used. Multi-codec simulcast
+   * requires dynacast
    */
   dynacast: boolean;
 
@@ -119,6 +122,9 @@ export interface InternalRoomConnectOptions {
 
   /** specifies how often an initial join connection is allowed to retry (only applicable if server is not reachable) */
   maxRetries: number;
+
+  /** amount of time for Websocket connection to be established, defaults to 15s */
+  websocketTimeout: number;
 }
 
 /**

package/src/proto/livekit_models_pb.ts

@@ -1,3 +1,17 @@
+// Copyright 2023 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // @generated by protoc-gen-es v1.3.0 with parameter "target=ts"
 // @generated from file livekit_models.proto (package livekit, syntax proto3)
 /* eslint-disable */