livekit-client 2.5.10 → 2.6.1

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

@@ -0,0 +1,96 @@
+import { RpcError as RpcError_Proto } from '@livekit/protocol';
+/** Parameters for initiating an RPC call */
+export interface PerformRpcParams {
+    /** The `identity` of the destination participant */
+    destinationIdentity: string;
+    /** The method name to call */
+    method: string;
+    /** The method payload */
+    payload: string;
+    /** Timeout for receiving a response after initial connection (milliseconds). Default: 10000 */
+    responseTimeout?: number;
+}
+/**
+ * Data passed to method handler for incoming RPC invocations
+ */
+export interface RpcInvocationData {
+    /**
+     * The unique request ID. Will match at both sides of the call, useful for debugging or logging.
+     */
+    requestId: string;
+    /**
+     * The unique participant identity of the caller.
+     */
+    callerIdentity: string;
+    /**
+     * The payload of the request. User-definable format, typically JSON.
+     */
+    payload: string;
+    /**
+     * The maximum time the caller will wait for a response.
+     */
+    responseTimeout: number;
+}
+/**
+ * Specialized error handling for RPC methods.
+ *
+ * Instances of this type, when thrown in a method handler, will have their `message`
+ * serialized and sent across the wire. The sender will receive an equivalent error on the other side.
+ *
+ * Built-in types are included but developers may use any string, with a max length of 256 bytes.
+ */
+export declare class RpcError extends Error {
+    static MAX_MESSAGE_BYTES: number;
+    static MAX_DATA_BYTES: number;
+    code: number;
+    data?: string;
+    /**
+     * Creates an error object with the given code and message, plus an optional data payload.
+     *
+     * If thrown in an RPC method handler, the error will be sent back to the caller.
+     *
+     * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
+     */
+    constructor(code: number, message: string, data?: string);
+    /**
+     * @internal
+     */
+    static fromProto(proto: RpcError_Proto): RpcError;
+    /**
+     * @internal
+     */
+    toProto(): RpcError_Proto;
+    static ErrorCode: {
+        readonly APPLICATION_ERROR: 1500;
+        readonly CONNECTION_TIMEOUT: 1501;
+        readonly RESPONSE_TIMEOUT: 1502;
+        readonly RECIPIENT_DISCONNECTED: 1503;
+        readonly RESPONSE_PAYLOAD_TOO_LARGE: 1504;
+        readonly SEND_FAILED: 1505;
+        readonly UNSUPPORTED_METHOD: 1400;
+        readonly RECIPIENT_NOT_FOUND: 1401;
+        readonly REQUEST_PAYLOAD_TOO_LARGE: 1402;
+        readonly UNSUPPORTED_SERVER: 1403;
+        readonly UNSUPPORTED_VERSION: 1404;
+    };
+    /**
+     * @internal
+     */
+    static ErrorMessage: Record<keyof typeof RpcError.ErrorCode, string>;
+    /**
+     * Creates an error object from the code, with an auto-populated message.
+     *
+     * @internal
+     */
+    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError;
+}
+export declare const MAX_PAYLOAD_BYTES = 15360;
+/**
+ * @internal
+ */
+export declare function byteLength(str: string): number;
+/**
+ * @internal
+ */
+export declare function truncateBytes(str: string, maxBytes: number): string;
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -50,6 +50,6 @@ export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
     private connectWebAudio;
     private disconnectWebAudio;
     protected monitorReceiver: () => Promise<void>;
-    protected getReceiverStats(): Promise<AudioReceiverStats | undefined>;
+    getReceiverStats(): Promise<AudioReceiverStats | undefined>;
 }
 //# sourceMappingURL=RemoteAudioTrack.d.ts.map

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

@@ -1,3 +1,4 @@
+import type { VideoReceiverStats } from '../stats';
 import type { LoggerOptions } from '../types';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
@@ -35,7 +36,7 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
     /** @internal */
     getDecoderImplementation(): string | undefined;
     protected monitorReceiver: () => Promise<void>;
-    private getReceiverStats;
+    getReceiverStats(): Promise<VideoReceiverStats | undefined>;
     private stopObservingElement;
     protected handleAppVisibilityChanged(): Promise<void>;
     private readonly debouncedHandleResize;

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

@@ -1,7 +1,7 @@
 import { TrackPublishedResponse } from '@livekit/protocol';
 import { Track } from './Track';
 import type { TrackPublication } from './TrackPublication';
-import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions } from './options';
+import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions, VideoCodec } 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;
@@ -26,7 +26,7 @@ export declare function sourceToKind(source: Track.Source): MediaDeviceKind | un
  * @internal
  */
 export declare function screenCaptureToDisplayMediaStreamOptions(options: ScreenShareCaptureOptions): DisplayMediaStreamOptions;
-export declare function mimeTypeToVideoCodecString(mimeType: string): "vp8" | "h264" | "vp9" | "av1";
+export declare function mimeTypeToVideoCodecString(mimeType: string): VideoCodec;
 export declare function getTrackPublicationInfo<T extends TrackPublication>(tracks: T[]): TrackPublishedResponse[];
 export declare function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown>;
 export declare function supportsSynchronizationSources(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.5.10",
+  "version": "2.6.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -88,7 +88,7 @@
     "build": "rollup --config --bundleConfigAsCjs && rollup --config rollup.config.worker.js --bundleConfigAsCjs && pnpm downlevel-dts",
     "build:watch": "rollup --watch --config --bundleConfigAsCjs",
     "build:worker:watch": "rollup --watch --config rollup.config.worker.js --bundleConfigAsCjs",
-    "build-docs": "typedoc",
+    "build-docs": "typedoc && mkdir -p docs/assets/github && cp .github/*.png docs/assets/github/ && find docs -name '*.html' -type f -exec sed -i.bak 's|=\"/.github/|=\"assets/github/|g' {} + && find docs -name '*.bak' -delete",
     "proto": "protoc --es_out src/proto --es_opt target=ts -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
     "examples:demo": "vite examples/demo -c vite.config.mjs",
     "lint": "eslint src",

package/src/api/SignalClient.ts

@@ -272,12 +272,22 @@ export class SignalClient {
         const abortHandler = async () => {
           this.close();
           clearTimeout(wsTimeout);
-          reject(new ConnectionError('room connection has been cancelled (signal)'));
+          reject(
+            new ConnectionError(
+              'room connection has been cancelled (signal)',
+              ConnectionErrorReason.Cancelled,
+            ),
+          );
         };
 
         const wsTimeout = setTimeout(() => {
           this.close();
-          reject(new ConnectionError('room connection has timed out (signal)'));
+          reject(
+            new ConnectionError(
+              'room connection has timed out (signal)',
+              ConnectionErrorReason.ServerUnreachable,
+            ),
+          );
         }, opts.websocketTimeout);
 
         if (abortSignal?.aborted) {
@@ -391,6 +401,7 @@ export class SignalClient {
               reject(
                 new ConnectionError(
                   `did not receive join response, got ${resp.message?.case} instead`,
+                  ConnectionErrorReason.InternalError,
                 ),
               );
             }
@@ -407,7 +418,12 @@ export class SignalClient {
 
         this.ws.onclose = (ev: CloseEvent) => {
           if (this.isEstablishingConnection) {
-            reject(new ConnectionError('Websocket got closed during a (re)connection attempt'));
+            reject(
+              new ConnectionError(
+                'Websocket got closed during a (re)connection attempt',
+                ConnectionErrorReason.InternalError,
+              ),
+            );
           }
 
           this.log.warn(`websocket closed`, {

package/src/index.ts

@@ -39,6 +39,8 @@ import {
 } from './room/utils';
 import { getBrowser } from './utils/browserParser';
 
+export { RpcError, type RpcInvocationData, type PerformRpcParams } from './room/rpc';
+
 export * from './connectionHelper/ConnectionCheck';
 export * from './connectionHelper/checks/Checker';
 export * from './e2ee';

package/src/room/PCTransport.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import type { MediaDescription } from 'sdp-transform';
+import type { MediaDescription, SessionDescription } from 'sdp-transform';
 import { parse, write } from 'sdp-transform';
 import { debounce } from 'ts-debounce';
 import log, { LoggerNames, getLogger } from '../logger';
@@ -48,6 +48,8 @@ export default class PCTransport extends EventEmitter {
 
   private loggerOptions: LoggerOptions;
 
+  private ddExtID = 0;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -288,7 +290,7 @@ export default class PCTransport extends EventEmitter {
           }
 
           if (isSVCCodec(trackbr.codec)) {
-            ensureVideoDDExtensionForSVC(media);
+            this.ensureVideoDDExtensionForSVC(media, sdpParsed);
           }
 
           // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
@@ -503,6 +505,44 @@ export default class PCTransport extends EventEmitter {
       throw new NegotiationError(msg);
     }
   }
+
+  private ensureVideoDDExtensionForSVC(
+    media: {
+      type: string;
+      port: number;
+      protocol: string;
+      payloads?: string | undefined;
+    } & MediaDescription,
+    sdp: SessionDescription,
+  ) {
+    const ddFound = media.ext?.some((ext): boolean => {
+      if (ext.uri === ddExtensionURI) {
+        return true;
+      }
+      return false;
+    });
+
+    if (!ddFound) {
+      if (this.ddExtID === 0) {
+        let maxID = 0;
+        sdp.media.forEach((m) => {
+          if (m.type !== 'video') {
+            return;
+          }
+          m.ext?.forEach((ext) => {
+            if (ext.value > maxID) {
+              maxID = ext.value;
+            }
+          });
+        });
+        this.ddExtID = maxID + 1;
+      }
+      media.ext?.push({
+        value: this.ddExtID,
+        uri: ddExtensionURI,
+      });
+    }
+  }
 }
 
 function ensureAudioNackAndStereo(
@@ -555,33 +595,6 @@ function ensureAudioNackAndStereo(
   }
 }
 
-function ensureVideoDDExtensionForSVC(
-  media: {
-    type: string;
-    port: number;
-    protocol: string;
-    payloads?: string | undefined;
-  } & MediaDescription,
-) {
-  let maxID = 0;
-  const ddFound = media.ext?.some((ext): boolean => {
-    if (ext.uri === ddExtensionURI) {
-      return true;
-    }
-    if (ext.value > maxID) {
-      maxID = ext.value;
-    }
-    return false;
-  });
-
-  if (!ddFound) {
-    media.ext?.push({
-      value: maxID + 1,
-      uri: ddExtensionURI,
-    });
-  }
-}
-
 function extractStereoAndNackAudioFromOffer(offer: RTCSessionDescriptionInit): {
   stereoMids: string[];
   nackMids: string[];

package/src/room/PCTransportManager.ts

@@ -342,7 +342,12 @@ export class PCTransportManager {
 
       const connectTimeout = CriticalTimers.setTimeout(() => {
         abortController?.signal.removeEventListener('abort', abortHandler);
-        reject(new ConnectionError('could not establish pc connection'));
+        reject(
+          new ConnectionError(
+            'could not establish pc connection',
+            ConnectionErrorReason.InternalError,
+          ),
+        );
       }, timeout);
 
       while (this.state !== PCTransportState.CONNECTED) {

package/src/room/RTCEngine.ts

@@ -313,7 +313,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       const publicationTimeout = setTimeout(() => {
         delete this.pendingTrackResolvers[req.cid];
         reject(
-          new ConnectionError('publication of local track timed out, no response from server'),
+          new ConnectionError(
+            'publication of local track timed out, no response from server',
+            ConnectionErrorReason.InternalError,
+          ),
         );
       }, 10_000);
       this.pendingTrackResolvers[req.cid] = {
@@ -1061,7 +1064,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     } catch (e: any) {
       // TODO do we need a `failed` state here for the PC?
       this.pcState = PCState.Disconnected;
-      throw new ConnectionError(`could not establish PC connection, ${e.message}`);
+      throw new ConnectionError(
+        `could not establish PC connection, ${e.message}`,
+        ConnectionErrorReason.InternalError,
+      );
     }
   }
 
@@ -1126,7 +1132,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     const transport = subscriber ? this.pcManager.subscriber : this.pcManager.publisher;
     const transportName = subscriber ? 'Subscriber' : 'Publisher';
     if (!transport) {
-      throw new ConnectionError(`${transportName} connection not set`);
+      throw new ConnectionError(
+        `${transportName} connection not set`,
+        ConnectionErrorReason.InternalError,
+      );
     }
 
     let needNegotiation = false;
@@ -1167,6 +1176,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     throw new ConnectionError(
       `could not establish ${transportName} connection, state: ${transport.getICEConnectionState()}`,
+      ConnectionErrorReason.InternalError,
     );
   }
 

package/src/room/RegionUrlProvider.ts

@@ -70,7 +70,9 @@ export class RegionUrlProvider {
     } else {
       throw new ConnectionError(
         `Could not fetch region settings: ${regionSettingsResponse.statusText}`,
-        regionSettingsResponse.status === 401 ? ConnectionErrorReason.NotAllowed : undefined,
+        regionSettingsResponse.status === 401
+          ? ConnectionErrorReason.NotAllowed
+          : ConnectionErrorReason.InternalError,
         regionSettingsResponse.status,
       );
     }

package/src/room/Room.ts

@@ -714,7 +714,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     } catch (err) {
       await this.engine.close();
       this.recreateEngine();
-      const resultingError = new ConnectionError(`could not establish signal connection`);
+      const resultingError = new ConnectionError(
+        `could not establish signal connection`,
+        ConnectionErrorReason.ServerUnreachable,
+      );
       if (err instanceof Error) {
         resultingError.message = `${resultingError.message}: ${err.message}`;
       }
@@ -732,7 +735,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (abortController.signal.aborted) {
       await this.engine.close();
       this.recreateEngine();
-      throw new ConnectionError(`Connection attempt aborted`);
+      throw new ConnectionError(`Connection attempt aborted`, ConnectionErrorReason.Cancelled);
     }
 
     try {
@@ -783,7 +786,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.log.warn('abort connection attempt', this.logContext);
         this.abortController?.abort();
         // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
-        this.connectFuture?.reject?.(new ConnectionError('Client initiated disconnect'));
+        this.connectFuture?.reject?.(
+          new ConnectionError('Client initiated disconnect', ConnectionErrorReason.Cancelled),
+        );
         this.connectFuture = undefined;
       }
       // send leave
@@ -1414,6 +1419,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
+    this.localParticipant?.handleParticipantDisconnected(participant.identity);
   }
 
   // updates are sent only when there's a change to speaker ordering

package/src/room/errors.ts

@@ -20,9 +20,9 @@ export const enum ConnectionErrorReason {
 export class ConnectionError extends LivekitError {
   status?: number;
 
-  reason?: ConnectionErrorReason;
+  reason: ConnectionErrorReason;
 
-  constructor(message?: string, reason?: ConnectionErrorReason, status?: number) {
+  constructor(message: string, reason: ConnectionErrorReason, status?: number) {
     super(1, message);
     this.status = status;
     this.reason = reason;