livekit-client 2.18.10 → 2.19.1

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

@@ -8,7 +8,7 @@ import LocalDataTrack from '../data-track/LocalDataTrack';
 import type OutgoingDataTrackManager from '../data-track/outgoing/OutgoingDataTrackManager';
 import type { DataTrackOptions } from '../data-track/outgoing/types';
 import type { PerformRpcParams, RpcInvocationData } from '../rpc';
-import { RpcError } from '../rpc';
+import { RpcClientManager, RpcError, RpcServerManager } from '../rpc';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import { Track } from '../track/Track';
@@ -40,15 +40,14 @@ export default class LocalParticipant extends Participant {
     private signalConnectedFuture?;
     private activeAgentFuture?;
     private firstActiveAgent?;
-    private rpcHandlers;
     private roomOutgoingDataStreamManager;
     private roomOutgoingDataTrackManager;
+    private rpcClientManager;
+    private rpcServerManager;
     private pendingSignalRequests;
     private enabledPublishVideoCodecs;
-    private pendingAcks;
-    private pendingResponses;
     /** @internal */
-    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>, roomOutgoingDataStreamManager: OutgoingDataStreamManager, roomOutgoingDataTrackManager: OutgoingDataTrackManager);
+    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomOutgoingDataStreamManager: OutgoingDataStreamManager, roomOutgoingDataTrackManager: OutgoingDataTrackManager, rpcClientManager: RpcClientManager, rpcServerManager: RpcServerManager);
     get lastCameraError(): Error | undefined;
     get lastMicrophoneError(): Error | undefined;
     get isE2EEEnabled(): boolean;
@@ -63,7 +62,6 @@ export default class LocalParticipant extends Participant {
     private handleClosing;
     private handleSignalConnected;
     private handleSignalRequestResponse;
-    private handleDataPacket;
     /**
      * Sets and updates the metadata of the local participant.
      * Note: this requires `canUpdateOwnMetadata` permission.
@@ -222,7 +220,7 @@ export default class LocalParticipant extends Participant {
      * @returns A promise that resolves with the response payload or rejects with an error.
      * @throws Error on failure. Details in `message`.
      */
-    performRpc({ destinationIdentity, method, payload, responseTimeout, }: PerformRpcParams): TypedPromise<string, RpcError>;
+    performRpc(params: PerformRpcParams): TypedPromise<string, RpcError>;
     /**
      * @deprecated use `room.registerRpcMethod` instead
      */
@@ -249,12 +247,6 @@ export default class LocalParticipant extends Participant {
      *  participant/track. Any omitted participants will not receive any permissions.
      */
     setTrackSubscriptionPermissions(allParticipantsAllowed: boolean, participantTrackPermissions?: ParticipantTrackPermission[]): void;
-    private handleIncomingRpcAck;
-    private handleIncomingRpcResponse;
-    /** @internal */
-    private publishRpcRequest;
-    /** @internal */
-    handleParticipantDisconnected(participantIdentity: string): void;
     /** @internal */
     setEnabledPublishCodecs(codecs: Codec[]): void;
     /** @internal */

package/dist/ts4.2/room/participant/RemoteParticipant.d.ts

@@ -22,6 +22,10 @@ export default class RemoteParticipant extends Participant {
      * const track = await remoteParticipant.dataTracks.getDeferred("data track name"); */
     dataTracks: DeferrableMap<RemoteDataTrack['info']['name'], RemoteDataTrack>;
     signalClient: SignalClient;
+    /** A version number indicating the set of features that the report participant's client supports.
+     * @internal
+     **/
+    clientProtocol: number;
     private volumeMap;
     private audioOutput?;
     /** @internal */
@@ -31,7 +35,7 @@ export default class RemoteParticipant extends Participant {
         remoteParticipant: string;
     };
     /** @internal */
-    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, attributes?: Record<string, string>, loggerOptions?: LoggerOptions, kind?: ParticipantKind, remoteDataTracks?: Array<RemoteDataTrack>);
+    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, attributes?: Record<string, string>, loggerOptions?: LoggerOptions, kind?: ParticipantKind, remoteDataTracks?: Array<RemoteDataTrack>, clientProtocol?: number);
     protected addTrackPublication(publication: RemoteTrackPublication): void;
     getTrackPublication(source: Track.Source): RemoteTrackPublication | undefined;
     getTrackPublicationByName(name: string): RemoteTrackPublication | undefined;

package/dist/ts4.2/room/rpc/client/RpcClientManager.d.ts

@@ -0,0 +1,43 @@
+import type TypedEmitter from 'typed-emitter';
+import type { StructuredLogger } from '../../../logger';
+import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import type { PerformRpcParams } from '../utils';
+import { RpcError } from '../utils';
+import type { RpcClientManagerCallbacks } from './events';
+declare const RpcClientManager_base: new () => TypedEmitter<RpcClientManagerCallbacks>;
+/**
+ * Manages the client (caller) side of RPC: sending requests, tracking pending
+ * ack/response state, and handling incoming ack/response packets.
+ * @internal
+ */
+export default class RpcClientManager extends RpcClientManager_base {
+    private log;
+    private outgoingDataStreamManager;
+    private getRemoteParticipantClientProtocol;
+    private getServerVersion;
+    private pendingAcks;
+    private pendingResponses;
+    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number, getServerVersion: () => string | undefined);
+    performRpc({ destinationIdentity, method, payload, responseTimeout: responseTimeoutMs, }: PerformRpcParams): Promise<[
+        id: string,
+        completionPromise: Promise<string>
+    ]>;
+    private publishRpcRequest;
+    /**
+     * Handle an incoming data stream containing an RPC response payload.
+     * @internal
+     */
+    handleIncomingDataStream(reader: TextStreamReader, senderIdentity: Participant['identity'], attributes: Record<string, string>): Promise<void>;
+    /** @internal */
+    handleIncomingRpcResponseSuccess(requestId: string, payload: string): void;
+    /** @internal */
+    handleIncomingRpcResponseFailure(requestId: string, error: RpcError): void;
+    /** @internal */
+    handleIncomingRpcAck(requestId: string): void;
+    /** @internal */
+    handleParticipantDisconnected(participantIdentity: string): void;
+}
+export {};
+//# sourceMappingURL=RpcClientManager.d.ts.map

package/dist/ts4.2/room/rpc/client/events.d.ts

@@ -0,0 +1,8 @@
+import type { DataPacket } from '@livekit/protocol';
+export type EventSendDataPacket = {
+    packet: DataPacket;
+};
+export type RpcClientManagerCallbacks = {
+    sendDataPacket: (event: EventSendDataPacket) => void;
+};
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1,7 @@
+export { default as RpcClientManager } from './client/RpcClientManager';
+export type { RpcClientManagerCallbacks } from './client/events';
+export { default as RpcServerManager } from './server/RpcServerManager';
+export type { RpcServerManagerCallbacks } from './server/events';
+export type { PerformRpcParams, RpcInvocationData } from './utils';
+export { RPC_REQUEST_DATA_STREAM_TOPIC, RPC_RESPONSE_DATA_STREAM_TOPIC, RpcRequestAttrs, RpcError, byteLength, truncateBytes } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/ts4.2/room/rpc/server/RpcServerManager.d.ts

@@ -0,0 +1,44 @@
+import { RpcRequest } from '@livekit/protocol';
+import type TypedEmitter from 'typed-emitter';
+import type { StructuredLogger } from '../../../logger';
+import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import type { RpcInvocationData } from '../utils';
+import type { RpcServerManagerCallbacks } from './events';
+declare const RpcServerManager_base: new () => TypedEmitter<RpcServerManagerCallbacks>;
+/**
+ * Manages the server (handler) side of RPC: processing incoming requests,
+ * managing registered method handlers, and sending responses.
+ * @internal
+ */
+export default class RpcServerManager extends RpcServerManager_base {
+    private log;
+    private outgoingDataStreamManager;
+    private getRemoteParticipantClientProtocol;
+    private rpcHandlers;
+    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number);
+    registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>): void;
+    unregisterRpcMethod(method: string): void;
+    /**
+     * Handle an incoming RPCRequest message containing a payload.
+     * This handles "version 1" of rpc requests.
+     * @internal
+     */
+    handleIncomingRpcRequest(callerIdentity: string, rpcRequest: RpcRequest): Promise<void>;
+    /**
+     * Handle an incoming data stream containing a RPC request payload.
+     * This handles "version 2" of rpc requests.
+     * @internal
+     */
+    handleIncomingDataStream(reader: TextStreamReader, callerIdentity: Participant['identity'], dataStreamAttrs: Record<string, string>): Promise<void>;
+    private publishRpcAck;
+    private publishRpcResponsePacket;
+    /**
+     * Send a successful RPC response payload, choosing the transport based on
+     * the caller's client protocol version.
+     */
+    private publishRpcResponse;
+}
+export {};
+//# sourceMappingURL=RpcServerManager.d.ts.map

package/dist/ts4.2/room/rpc/server/events.d.ts

@@ -0,0 +1,8 @@
+import type { DataPacket } from '@livekit/protocol';
+export type EventSendDataPacket = {
+    packet: DataPacket;
+};
+export type RpcServerManagerCallbacks = {
+    sendDataPacket: (event: EventSendDataPacket) => void;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/ts4.2/room/{rpc.d.ts → rpc/utils.d.ts}

@@ -49,6 +49,7 @@ export declare class RpcError extends Error {
     static MAX_DATA_BYTES: number;
     code: number;
     data?: string;
+    cause?: unknown;
     /**
      * Creates an error object with the given code and message, plus an optional data payload.
      *
@@ -56,7 +57,9 @@ export declare class RpcError extends Error {
      *
      * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
      */
-    constructor(code: number, message: string, data?: string);
+    constructor(code: number, message: string, data?: string, options?: {
+        cause?: unknown;
+    });
     /**
      * @internal
      */
@@ -87,9 +90,36 @@ export declare class RpcError extends Error {
      *
      * @internal
      */
-    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError;
+    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string, options?: {
+        cause?: unknown;
+    }): RpcError;
 }
-export declare const MAX_PAYLOAD_BYTES = 15360;
+export declare const MAX_V1_PAYLOAD_BYTES = 15360;
+/**
+ * Topic used for v2 RPC request data streams.
+ * @internal
+ */
+export declare const RPC_REQUEST_DATA_STREAM_TOPIC = "lk.rpc_request";
+/**
+ * Topic used for v2 RPC response data streams.
+ * @internal
+ */
+export declare const RPC_RESPONSE_DATA_STREAM_TOPIC = "lk.rpc_response";
+/** @internal */
+export declare enum RpcRequestAttrs {
+    RPC_REQUEST_ID = "lk.rpc_request_id",
+    RPC_REQUEST_METHOD = "lk.rpc_request_method",
+    RPC_REQUEST_RESPONSE_TIMEOUT_MS = "lk.rpc_request_response_timeout_ms",
+    RPC_REQUEST_VERSION = "lk.rpc_request_version"
+}
+/** Initial version of rpc which uses RpcRequest / RpcResponse messages.
+ * @internal
+ **/
+export declare const RPC_VERSION_V1 = 1;
+/** Rpc version backed by data streams instead of RpcRequest / RpcResponse.
+ * @internal
+ **/
+export declare const RPC_VERSION_V2 = 2;
 /**
  * @internal
  */
@@ -98,4 +128,4 @@ export declare function byteLength(str: string): number;
  * @internal
  */
 export declare function truncateBytes(str: string, maxBytes: number): string;
-//# sourceMappingURL=rpc.d.ts.map
+//# sourceMappingURL=utils.d.ts.map

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

@@ -147,4 +147,5 @@ export declare function isRemoteParticipant(p: Participant): p is RemoteParticip
 export declare function splitUtf8(s: string, n: number): NonSharedUint8Array[];
 export declare function extractMaxAgeFromRequestHeaders(headers: Headers): number | undefined;
 export declare function isCompressionStreamSupported(): boolean;
+export declare function isPublisherOfferWithJoinSupported(): boolean;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1,3 +1,11 @@
 export declare const version: string;
 export declare const protocolVersion = 17;
+/** Initial client protocol. */
+export declare const CLIENT_PROTOCOL_DEFAULT = 0;
+/** Replaces RPC v1 protocol with a v2 data streams based one to support unlimited request /
+ * response payload length. */
+export declare const CLIENT_PROTOCOL_DATA_STREAM_RPC = 1;
+/** The client protocol version indicates what level of support that the client has for
+ * client <-> client api interactions. */
+export declare const clientProtocol = 1;
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.18.10",
+  "version": "2.19.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -91,6 +91,7 @@
     "happy-dom": "^20.0.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
+    "publint": "^0.3.21",
     "rollup": "4.60.2",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.37.0",
@@ -118,7 +119,8 @@
     "format": "prettier --write src examples/**/*.ts",
     "format:check": "prettier --check src examples/**/*.ts",
     "throws:check": "pnpm --package=@livekit/throws-transformer dlx throws-check 'src/!(*.test).ts' 'src/**/!(*.test).ts'",
-    "ci:publish": "pnpm build:clean && pnpm compat && changeset publish",
+    "type:check": "tsc --noEmit",
+    "ci:publish": "pnpm type:check && pnpm build && pnpm compat && changeset publish",
     "downlevel-dts": "downlevel-dts ./dist/src ./dist/ts4.2 --to=4.2",
     "compat": "eslint --config ./eslint.config.dist.mjs --no-inline-config  ./dist/livekit-client.esm.mjs",
     "size-limit": "size-limit"

package/src/api/SignalClient.ts

@@ -1157,6 +1157,7 @@ function createConnectionParams(
   params.set('sdk', isReactNative() ? 'reactnative' : 'js');
   params.set('version', info.version!);
   params.set('protocol', info.protocol!.toString());
+  params.set('client_protocol', info.clientProtocol!.toString());
   if (info.deviceModel) {
     params.set('device_model', info.deviceModel);
   }

package/src/room/RTCEngine.ts

@@ -26,7 +26,6 @@ import {
   Room as RoomModel,
   RoomMovedResponse,
   RpcAck,
-  RpcResponse,
   ServerInfo,
   SessionDescription,
   SignalTarget,
@@ -79,7 +78,6 @@ import {
   UnexpectedConnectionState,
 } from './errors';
 import { EngineEvent } from './events';
-import { RpcError } from './rpc';
 import CriticalTimers from './timers';
 import type LocalTrack from './track/LocalTrack';
 import type LocalTrackPublication from './track/LocalTrackPublication';
@@ -92,7 +90,7 @@ import { getTrackPublicationInfo } from './track/utils';
 import type { LoggerOptions } from './types';
 import {
   Future,
-  isCompressionStreamSupported,
+  isPublisherOfferWithJoinSupported,
   isVideoCodec,
   isVideoTrack,
   isWeb,
@@ -124,7 +122,7 @@ enum PCState {
 export enum DataChannelKind {
   RELIABLE = DataPacket_Kind.RELIABLE,
   LOSSY = DataPacket_Kind.LOSSY,
-  DATA_TRACK_LOSSY,
+  DATA_TRACK_LOSSY = 2,
 }
 
 /** @internal */
@@ -327,7 +325,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
       this.setupSignalClientCallbacks();
       let offerProto: SessionDescription | undefined;
-      if (!useV0Path && isCompressionStreamSupported()) {
+      if (!useV0Path && isPublisherOfferWithJoinSupported()) {
         if (!this.pcManager) {
           await this.configure();
           this.createDataChannels();
@@ -360,7 +358,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.participantSid = joinResponse.participant?.sid;
 
       this.subscriberPrimary = joinResponse.subscriberPrimary;
-      if (!useV0Path && isCompressionStreamSupported()) {
+      if (!useV0Path && isPublisherOfferWithJoinSupported()) {
         this.pcManager?.updateConfiguration(this.makeRTCConfiguration(joinResponse));
       } else {
         if (!this.pcManager) {
@@ -1464,30 +1462,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     });
   };
 
-  /** @internal */
-  async publishRpcResponse(
-    destinationIdentity: string,
-    requestId: string,
-    payload: string | null,
-    error: RpcError | null,
-  ) {
-    const packet = new DataPacket({
-      destinationIdentities: [destinationIdentity],
-      kind: DataPacket_Kind.RELIABLE,
-      value: {
-        case: 'rpcResponse',
-        value: new RpcResponse({
-          requestId,
-          value: error
-            ? { case: 'error', value: error.toProto() }
-            : { case: 'payload', value: payload ?? '' },
-        }),
-      },
-    });
-
-    await this.sendDataPacket(packet, DataChannelKind.RELIABLE);
-  }
-
   /** @internal */
   async publishRpcAck(destinationIdentity: string, requestId: string) {
     const packet = new DataPacket({

package/src/room/Room.test.ts

@@ -1,5 +1,5 @@
 import { ClientInfo_Capability, JoinResponse } from '@livekit/protocol';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import Room from './Room';
 import { roomConnectOptionDefaults, roomOptionDefaults } from './defaults';
 import { RoomEvent } from './events';
@@ -89,3 +89,101 @@ describe('Room signaling options', () => {
     );
   });
 });
+
+describe('Room lifecycle', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Tear down the mocked mediaDevices so other tests see the env they
+    // expected (happy-dom does not provide navigator.mediaDevices by default).
+    if ((navigator as { mediaDevices?: unknown }).mediaDevices) {
+      Object.defineProperty(navigator, 'mediaDevices', {
+        configurable: true,
+        value: undefined,
+      });
+    }
+  });
+
+  it('wraps the constructor-registered devicechange listener in a WeakRef so the Room is GC-eligible (#1940)', async () => {
+    // happy-dom does not provide navigator.mediaDevices. Install a minimal
+    // EventTarget stand-in so the constructor takes the listener-registration
+    // branch and we can observe the registered listener.
+    const mediaDevices = new EventTarget() as EventTarget & {
+      addEventListener: EventTarget['addEventListener'];
+      removeEventListener: EventTarget['removeEventListener'];
+    };
+    Object.defineProperty(navigator, 'mediaDevices', {
+      configurable: true,
+      value: mediaDevices,
+    });
+
+    const addSpy = vi.spyOn(mediaDevices, 'addEventListener');
+    const derefSpy = vi.spyOn(WeakRef.prototype, 'deref');
+    const cleanupRegistrySpy = Room.cleanupRegistry
+      ? vi.spyOn(Room.cleanupRegistry, 'register')
+      : undefined;
+
+    const room = new Room();
+    const handleDeviceChangeSpy = vi.spyOn(
+      room as unknown as { handleDeviceChange: (ev: Event) => void },
+      'handleDeviceChange',
+    );
+
+    // Constructor must register exactly one devicechange listener with AbortSignal teardown.
+    const deviceChangeAdds = addSpy.mock.calls.filter(([type]) => type === 'devicechange');
+    expect(deviceChangeAdds).toHaveLength(1);
+    const listener = deviceChangeAdds[0][1] as EventListener;
+    const addOptions = deviceChangeAdds[0][2] as AddEventListenerOptions | undefined;
+    expect(addOptions?.signal).toBeInstanceOf(AbortSignal);
+
+    // FinalizationRegistry must be registered with the Room as the target so the
+    // cleanup callback fires when the user drops their Room reference.
+    if (Room.cleanupRegistry) {
+      expect(cleanupRegistrySpy).toHaveBeenCalledWith(room, expect.any(Function));
+    }
+
+    // While the WeakRef still derefs to the Room, the listener forwards to handleDeviceChange.
+    listener.call(null, new Event('devicechange'));
+    expect(handleDeviceChangeSpy).toHaveBeenCalledTimes(1);
+
+    // Simulate the Room being GC'd by forcing deref to return undefined; the
+    // listener must short-circuit instead of calling handleDeviceChange.
+    derefSpy.mockReturnValue(undefined);
+    listener.call(null, new Event('devicechange'));
+    expect(handleDeviceChangeSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('falls back to a direct devicechange listener when WeakRef/FinalizationRegistry are unavailable (#1944)', async () => {
+    const mediaDevices = new EventTarget() as EventTarget & {
+      addEventListener: EventTarget['addEventListener'];
+      removeEventListener: EventTarget['removeEventListener'];
+    };
+    Object.defineProperty(navigator, 'mediaDevices', {
+      configurable: true,
+      value: mediaDevices,
+    });
+
+    // Simulate a legacy browser by stubbing out cleanupRegistry.
+    const originalRegistry = Room.cleanupRegistry;
+    Object.defineProperty(Room, 'cleanupRegistry', {
+      configurable: true,
+      value: false,
+    });
+
+    try {
+      const addSpy = vi.spyOn(mediaDevices, 'addEventListener');
+      const room = new Room();
+      const handleDeviceChange = (room as unknown as { handleDeviceChange: () => void })
+        .handleDeviceChange;
+
+      const deviceChangeAdds = addSpy.mock.calls.filter(([type]) => type === 'devicechange');
+      expect(deviceChangeAdds).toHaveLength(1);
+      // The registered listener is the bare handleDeviceChange method (no WeakRef closure).
+      expect(deviceChangeAdds[0][1]).toBe(handleDeviceChange);
+    } finally {
+      Object.defineProperty(Room, 'cleanupRegistry', {
+        configurable: true,
+        value: originalRegistry,
+      });
+    }
+  });
+});