livekit-client 2.5.9 → 2.6.0

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/LocalTrack.d.ts

@@ -1,5 +1,5 @@
+import { Mutex } from '@livekit/mutex';
 import type { LoggerOptions } from '../types';
-import { Mutex } from '../utils';
 import { Track } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';

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/dist/ts4.2/src/room/utils.d.ts

@@ -80,16 +80,6 @@ export declare function createAudioAnalyser(track: LocalAudioTrack | RemoteAudio
     analyser: AnalyserNode;
     cleanup: () => Promise<void>;
 };
-/**
- * @internal
- */
-export declare class Mutex {
-    private _locking;
-    private _locks;
-    constructor();
-    isLocked(): boolean;
-    lock(): Promise<() => void>;
-}
 export declare function isVideoCodec(maybeCodec: string): maybeCodec is VideoCodec;
 export declare function unwrapConstraint(constraint: ConstrainDOMString): string;
 export declare function unwrapConstraint(constraint: ConstrainULong): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.5.9",
+  "version": "2.6.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -36,6 +36,7 @@
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "dependencies": {
+    "@livekit/mutex": "1.0.0",
     "@livekit/protocol": "1.24.0",
     "events": "^3.3.0",
     "loglevel": "^1.8.0",
@@ -87,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

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import {
   AddTrackRequest,
   AudioTrackFeature,
@@ -42,7 +43,7 @@ import log, { LoggerNames, getLogger } from '../logger';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
 import CriticalTimers from '../room/timers';
 import type { LoggerOptions } from '../room/types';
-import { Mutex, getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../room/utils';
+import { getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../room/utils';
 import { AsyncQueue } from '../utils/AsyncQueue';
 
 // internal options

package/src/index.ts

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import { DataPacket_Kind, DisconnectReason, SubscriptionError } from '@livekit/protocol';
 import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
@@ -26,7 +27,6 @@ import { TrackPublication } from './room/track/TrackPublication';
 import type { LiveKitReactNativeInfo } from './room/types';
 import type { AudioAnalyserOptions } from './room/utils';
 import {
-  Mutex,
   compareVersions,
   createAudioAnalyser,
   getEmptyAudioStreamTrack,
@@ -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

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import { SignalTarget } from '@livekit/protocol';
 import log, { LoggerNames, getLogger } from '../logger';
 import PCTransport, { PCEvents } from './PCTransport';
@@ -5,7 +6,7 @@ import { roomConnectOptionDefaults } from './defaults';
 import { ConnectionError, ConnectionErrorReason } from './errors';
 import CriticalTimers from './timers';
 import type { LoggerOptions } from './types';
-import { Mutex, sleep } from './utils';
+import { sleep } from './utils';
 
 export enum PCTransportState {
   NEW,

package/src/room/RTCEngine.ts

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import {
   type AddTrackRequest,
   ClientConfigSetting,
@@ -63,7 +64,7 @@ import type { Track } from './track/Track';
 import type { TrackPublishOptions, VideoCodec } from './track/options';
 import { getTrackPublicationInfo } from './track/utils';
 import type { LoggerOptions } from './types';
-import { Mutex, isVideoCodec, isWeb, sleep, supportsAddTrack, supportsTransceiver } from './utils';
+import { isVideoCodec, isWeb, sleep, supportsAddTrack, supportsTransceiver } from './utils';
 
 const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
@@ -262,6 +263,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
     try {
       this._isClosed = true;
+      this.joinAttempts = 0;
       this.emit(EngineEvent.Closing);
       this.removeAllListeners();
       this.deregisterOnLineListener();

package/src/room/Room.ts

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import {
   ChatMessage as ChatMessageModel,
   ConnectionQualityUpdate,
@@ -77,7 +78,6 @@ import type {
 } from './types';
 import {
   Future,
-  Mutex,
   createDummyVideoStreamTrack,
   extractChatMessage,
   extractTranscriptionSegments,
@@ -1414,6 +1414,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/participant/LocalParticipant.test.ts

@@ -0,0 +1,304 @@
+import { DataPacket, DataPacket_Kind } from '@livekit/protocol';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { InternalRoomOptions } from '../../options';
+import type RTCEngine from '../RTCEngine';
+import { RpcError } from '../rpc';
+import LocalParticipant from './LocalParticipant';
+import { ParticipantKind } from './Participant';
+import RemoteParticipant from './RemoteParticipant';
+
+describe('LocalParticipant', () => {
+  describe('registerRpcMethod', () => {
+    let localParticipant: LocalParticipant;
+    let mockEngine: RTCEngine;
+    let mockRoomOptions: InternalRoomOptions;
+    let mockSendDataPacket: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+      mockSendDataPacket = vi.fn();
+      mockEngine = {
+        client: {
+          sendUpdateLocalMetadata: vi.fn(),
+        },
+        on: vi.fn().mockReturnThis(),
+        sendDataPacket: mockSendDataPacket,
+      } as unknown as RTCEngine;
+
+      mockRoomOptions = {} as InternalRoomOptions;
+
+      localParticipant = new LocalParticipant(
+        'test-sid',
+        'test-identity',
+        mockEngine,
+        mockRoomOptions,
+      );
+    });
+
+    it('should register an RPC method handler', async () => {
+      const methodName = 'testMethod';
+      const handler = vi.fn().mockResolvedValue('test response');
+
+      localParticipant.registerRpcMethod(methodName, handler);
+
+      const mockCaller = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+
+      await localParticipant.handleIncomingRpcRequest(
+        mockCaller.identity,
+        'test-request-id',
+        methodName,
+        'test payload',
+        5000,
+        1,
+      );
+
+      expect(handler).toHaveBeenCalledWith({
+        requestId: 'test-request-id',
+        callerIdentity: mockCaller.identity,
+        payload: 'test payload',
+        responseTimeout: 5000,
+      });
+
+      // Check if sendDataPacket was called twice (once for ACK and once for response)
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+      // Check if the first call was for ACK
+      expect(mockSendDataPacket.mock.calls[0][0].value.case).toBe('rpcAck');
+      expect(mockSendDataPacket.mock.calls[0][1]).toBe(DataPacket_Kind.RELIABLE);
+
+      // Check if the second call was for response
+      expect(mockSendDataPacket.mock.calls[1][0].value.case).toBe('rpcResponse');
+      expect(mockSendDataPacket.mock.calls[1][1]).toBe(DataPacket_Kind.RELIABLE);
+    });
+
+    it('should catch and transform unhandled errors in the RPC method handler', async () => {
+      const methodName = 'errorMethod';
+      const errorMessage = 'Test error';
+      const handler = vi.fn().mockRejectedValue(new Error(errorMessage));
+
+      localParticipant.registerRpcMethod(methodName, handler);
+
+      const mockCaller = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+
+      await localParticipant.handleIncomingRpcRequest(
+        mockCaller.identity,
+        'test-error-request-id',
+        methodName,
+        'test payload',
+        5000,
+        1,
+      );
+
+      expect(handler).toHaveBeenCalledWith({
+        requestId: 'test-error-request-id',
+        callerIdentity: mockCaller.identity,
+        payload: 'test payload',
+        responseTimeout: 5000,
+      });
+
+      // Check if sendDataPacket was called twice (once for ACK and once for error response)
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+      // Check if the second call was for error response
+      const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
+      expect(errorResponse.code).toBe(RpcError.ErrorCode.APPLICATION_ERROR);
+    });
+
+    it('should pass through RpcError thrown by the RPC method handler', async () => {
+      const methodName = 'rpcErrorMethod';
+      const errorCode = 101;
+      const errorMessage = 'some-error-message';
+      const handler = vi.fn().mockRejectedValue(new RpcError(errorCode, errorMessage));
+
+      localParticipant.registerRpcMethod(methodName, handler);
+
+      const mockCaller = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+
+      await localParticipant.handleIncomingRpcRequest(
+        mockCaller.identity,
+        'test-rpc-error-request-id',
+        methodName,
+        'test payload',
+        5000,
+        1,
+      );
+
+      expect(handler).toHaveBeenCalledWith({
+        requestId: 'test-rpc-error-request-id',
+        callerIdentity: mockCaller.identity,
+        payload: 'test payload',
+        responseTimeout: 5000,
+      });
+
+      // Check if sendDataPacket was called twice (once for ACK and once for error response)
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+      // Check if the second call was for error response
+      const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
+      expect(errorResponse.code).toBe(errorCode);
+      expect(errorResponse.message).toBe(errorMessage);
+    });
+  });
+
+  describe('performRpc', () => {
+    let localParticipant: LocalParticipant;
+    let mockRemoteParticipant: RemoteParticipant;
+    let mockEngine: RTCEngine;
+    let mockRoomOptions: InternalRoomOptions;
+    let mockSendDataPacket: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+      mockSendDataPacket = vi.fn();
+      mockEngine = {
+        client: {
+          sendUpdateLocalMetadata: vi.fn(),
+        },
+        on: vi.fn().mockReturnThis(),
+        sendDataPacket: mockSendDataPacket,
+      } as unknown as RTCEngine;
+
+      mockRoomOptions = {} as InternalRoomOptions;
+
+      localParticipant = new LocalParticipant(
+        'local-sid',
+        'local-identity',
+        mockEngine,
+        mockRoomOptions,
+      );
+
+      mockRemoteParticipant = new RemoteParticipant(
+        {} as any,
+        'remote-sid',
+        'remote-identity',
+        'Remote Participant',
+        '',
+        undefined,
+        ParticipantKind.STANDARD,
+      );
+    });
+
+    it('should send RPC request and receive successful response', async () => {
+      const method = 'testMethod';
+      const payload = 'testPayload';
+      const responsePayload = 'responsePayload';
+
+      mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
+        const requestId = packet.value.value.id;
+        setTimeout(() => {
+          localParticipant.handleIncomingRpcAck(requestId);
+          setTimeout(() => {
+            localParticipant.handleIncomingRpcResponse(requestId, responsePayload, null);
+          }, 10);
+        }, 10);
+      });
+
+      const result = await localParticipant.performRpc({
+        destinationIdentity: mockRemoteParticipant.identity,
+        method,
+        payload,
+      });
+
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
+      expect(result).toBe(responsePayload);
+    });
+
+    it('should handle RPC request timeout', async () => {
+      const method = 'timeoutMethod';
+      const payload = 'timeoutPayload';
+
+      const timeout = 50;
+
+      const resultPromise = localParticipant.performRpc({
+        destinationIdentity: mockRemoteParticipant.identity,
+        method,
+        payload,
+        responseTimeout: timeout,
+      });
+
+      mockSendDataPacket.mockImplementationOnce(() => {
+        return new Promise((resolve) => {
+          setTimeout(resolve, timeout + 10);
+        });
+      });
+
+      const startTime = Date.now();
+
+      await expect(resultPromise).rejects.toThrow('Response timeout');
+
+      const elapsedTime = Date.now() - startTime;
+      expect(elapsedTime).toBeGreaterThanOrEqual(timeout);
+      expect(elapsedTime).toBeLessThan(timeout + 50); // Allow some margin for test execution
+
+      expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle RPC error response', async () => {
+      const method = 'errorMethod';
+      const payload = 'errorPayload';
+      const errorCode = 101;
+      const errorMessage = 'Test error message';
+
+      mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
+        const requestId = packet.value.value.id;
+        setTimeout(() => {
+          localParticipant.handleIncomingRpcAck(requestId);
+          localParticipant.handleIncomingRpcResponse(
+            requestId,
+            null,
+            new RpcError(errorCode, errorMessage),
+          );
+        }, 10);
+      });
+
+      await expect(
+        localParticipant.performRpc({
+          destinationIdentity: mockRemoteParticipant.identity,
+          method,
+          payload,
+        }),
+      ).rejects.toThrow(errorMessage);
+    });
+
+    it('should handle participant disconnection during RPC request', async () => {
+      const method = 'disconnectMethod';
+      const payload = 'disconnectPayload';
+
+      mockSendDataPacket.mockImplementationOnce(() => Promise.resolve());
+
+      const resultPromise = localParticipant.performRpc({
+        destinationIdentity: mockRemoteParticipant.identity,
+        method,
+        payload,
+      });
+
+      // Simulate a small delay before disconnection
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      localParticipant.handleParticipantDisconnected(mockRemoteParticipant.identity);
+
+      await expect(resultPromise).rejects.toThrow('Recipient disconnected');
+    });
+  });
+});