livekit-client 2.5.9 → 2.6.0

package/dist/livekit-client.esm.mjs

@@ -1,16 +1,44 @@
 function _mergeNamespaces(n, m) {
-    m.forEach(function (e) {
-        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-            if (k !== 'default' && !(k in n)) {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
         });
+      }
     });
-    return Object.freeze(n);
+  });
+  return Object.freeze(n);
+}
+
+var k = Object.defineProperty;
+var n = (s, o, c) => o in s ? k(s, o, {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: c
+}) : s[o] = c;
+var l = (s, o, c) => n(s, typeof o != "symbol" ? o + "" : o, c);
+class h {
+  constructor() {
+    l(this, "_locking");
+    l(this, "_locks");
+    this._locking = Promise.resolve(), this._locks = 0;
+  }
+  isLocked() {
+    return this._locks > 0;
+  }
+  lock() {
+    this._locks += 1;
+    let o;
+    const c = new Promise(i => o = () => {
+        this._locks -= 1, i();
+      }),
+      t = this._locking.then(() => o);
+    return this._locking = this._locking.then(() => c), t;
+  }
 }
 
 // Copyright 2021-2024 Buf Technologies, Inc.
@@ -4718,14 +4746,14 @@ const RpcResponse = /*@__PURE__*/proto3.makeMessageType("livekit.RpcResponse", (
   no: 3,
   name: "error",
   kind: "message",
-  T: RpcError,
+  T: RpcError$1,
   oneof: "value"
 }]);
 
 /**
  * @generated from message livekit.RpcError
  */
-const RpcError = /*@__PURE__*/proto3.makeMessageType("livekit.RpcError", () => [{
+const RpcError$1 = /*@__PURE__*/proto3.makeMessageType("livekit.RpcError", () => [{
   no: 1,
   name: "code",
   kind: "scalar",
@@ -8056,16 +8084,16 @@ function fixNegotiationNeeded(window, browserDetails) {
 }
 
 var chromeShim = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    fixNegotiationNeeded: fixNegotiationNeeded,
-    shimAddTrackRemoveTrack: shimAddTrackRemoveTrack,
-    shimAddTrackRemoveTrackWithNative: shimAddTrackRemoveTrackWithNative,
-    shimGetSendersWithDtmf: shimGetSendersWithDtmf,
-    shimGetUserMedia: shimGetUserMedia$2,
-    shimMediaStream: shimMediaStream,
-    shimOnTrack: shimOnTrack$1,
-    shimPeerConnection: shimPeerConnection$1,
-    shimSenderReceiverGetStats: shimSenderReceiverGetStats
+  __proto__: null,
+  fixNegotiationNeeded: fixNegotiationNeeded,
+  shimAddTrackRemoveTrack: shimAddTrackRemoveTrack,
+  shimAddTrackRemoveTrackWithNative: shimAddTrackRemoveTrackWithNative,
+  shimGetSendersWithDtmf: shimGetSendersWithDtmf,
+  shimGetUserMedia: shimGetUserMedia$2,
+  shimMediaStream: shimMediaStream,
+  shimOnTrack: shimOnTrack$1,
+  shimPeerConnection: shimPeerConnection$1,
+  shimSenderReceiverGetStats: shimSenderReceiverGetStats
 });
 
 /*
@@ -8425,19 +8453,19 @@ function shimCreateAnswer(window) {
 }
 
 var firefoxShim = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    shimAddTransceiver: shimAddTransceiver,
-    shimCreateAnswer: shimCreateAnswer,
-    shimCreateOffer: shimCreateOffer,
-    shimGetDisplayMedia: shimGetDisplayMedia,
-    shimGetParameters: shimGetParameters,
-    shimGetUserMedia: shimGetUserMedia$1,
-    shimOnTrack: shimOnTrack,
-    shimPeerConnection: shimPeerConnection,
-    shimRTCDataChannel: shimRTCDataChannel,
-    shimReceiverGetStats: shimReceiverGetStats,
-    shimRemoveStream: shimRemoveStream,
-    shimSenderGetStats: shimSenderGetStats
+  __proto__: null,
+  shimAddTransceiver: shimAddTransceiver,
+  shimCreateAnswer: shimCreateAnswer,
+  shimCreateOffer: shimCreateOffer,
+  shimGetDisplayMedia: shimGetDisplayMedia,
+  shimGetParameters: shimGetParameters,
+  shimGetUserMedia: shimGetUserMedia$1,
+  shimOnTrack: shimOnTrack,
+  shimPeerConnection: shimPeerConnection,
+  shimRTCDataChannel: shimRTCDataChannel,
+  shimReceiverGetStats: shimReceiverGetStats,
+  shimRemoveStream: shimRemoveStream,
+  shimSenderGetStats: shimSenderGetStats
 });
 
 /*
@@ -8758,16 +8786,16 @@ function shimAudioContext(window) {
 }
 
 var safariShim = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    shimAudioContext: shimAudioContext,
-    shimCallbacksAPI: shimCallbacksAPI,
-    shimConstraints: shimConstraints,
-    shimCreateOfferLegacy: shimCreateOfferLegacy,
-    shimGetUserMedia: shimGetUserMedia,
-    shimLocalStreamsAPI: shimLocalStreamsAPI,
-    shimRTCIceServerUrls: shimRTCIceServerUrls,
-    shimRemoteStreamsAPI: shimRemoteStreamsAPI,
-    shimTrackEventTransceiver: shimTrackEventTransceiver
+  __proto__: null,
+  shimAudioContext: shimAudioContext,
+  shimCallbacksAPI: shimCallbacksAPI,
+  shimConstraints: shimConstraints,
+  shimCreateOfferLegacy: shimCreateOfferLegacy,
+  shimGetUserMedia: shimGetUserMedia,
+  shimLocalStreamsAPI: shimLocalStreamsAPI,
+  shimRTCIceServerUrls: shimRTCIceServerUrls,
+  shimRemoteStreamsAPI: shimRemoteStreamsAPI,
+  shimTrackEventTransceiver: shimTrackEventTransceiver
 });
 
 var sdp$1 = {exports: {}};
@@ -9523,8 +9551,8 @@ var sdpExports = requireSdp();
 var SDPUtils = /*@__PURE__*/getDefaultExportFromCjs(sdpExports);
 
 var sdp = /*#__PURE__*/_mergeNamespaces({
-    __proto__: null,
-    default: SDPUtils
+  __proto__: null,
+  default: SDPUtils
 }, [sdpExports]);
 
 /*
@@ -9944,15 +9972,15 @@ function shimParameterlessSetLocalDescription(window, browserDetails) {
 }
 
 var commonShim = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    removeExtmapAllowMixed: removeExtmapAllowMixed,
-    shimAddIceCandidateNullOrEmpty: shimAddIceCandidateNullOrEmpty,
-    shimConnectionState: shimConnectionState,
-    shimMaxMessageSize: shimMaxMessageSize,
-    shimParameterlessSetLocalDescription: shimParameterlessSetLocalDescription,
-    shimRTCIceCandidate: shimRTCIceCandidate,
-    shimRTCIceCandidateRelayProtocol: shimRTCIceCandidateRelayProtocol,
-    shimSendThrowTypeError: shimSendThrowTypeError
+  __proto__: null,
+  removeExtmapAllowMixed: removeExtmapAllowMixed,
+  shimAddIceCandidateNullOrEmpty: shimAddIceCandidateNullOrEmpty,
+  shimConnectionState: shimConnectionState,
+  shimMaxMessageSize: shimMaxMessageSize,
+  shimParameterlessSetLocalDescription: shimParameterlessSetLocalDescription,
+  shimRTCIceCandidate: shimRTCIceCandidate,
+  shimRTCIceCandidateRelayProtocol: shimRTCIceCandidateRelayProtocol,
+  shimSendThrowTypeError: shimSendThrowTypeError
 });
 
 /*
@@ -11148,7 +11176,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.5.9";
+var version$1 = "2.6.0";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -11218,19 +11246,19 @@ var AudioPresets;
     maxBitrate: 12000
   };
   AudioPresets.speech = {
-    maxBitrate: 20000
+    maxBitrate: 24000
   };
   AudioPresets.music = {
-    maxBitrate: 32000
+    maxBitrate: 48000
   };
   AudioPresets.musicStereo = {
-    maxBitrate: 48000
+    maxBitrate: 64000
   };
   AudioPresets.musicHighQuality = {
-    maxBitrate: 64000
+    maxBitrate: 96000
   };
   AudioPresets.musicHighQualityStereo = {
-    maxBitrate: 96000
+    maxBitrate: 128000
   };
 })(AudioPresets || (AudioPresets = {}));
 /**
@@ -11808,11 +11836,7 @@ function screenCaptureToDisplayMediaStreamOptions(options) {
   };
 }
 function mimeTypeToVideoCodecString(mimeType) {
-  const codec = mimeType.split('/')[1].toLowerCase();
-  if (!videoCodecs.includes(codec)) {
-    throw Error("Video codec not supported: ".concat(codec));
-  }
-  return codec;
+  return mimeType.split('/')[1].toLowerCase();
 }
 function getTrackPublicationInfo(tracks) {
   const infos = [];
@@ -12217,29 +12241,6 @@ function createAudioAnalyser(track, options) {
     cleanup
   };
 }
-/**
- * @internal
- */
-class Mutex {
-  constructor() {
-    this._locking = Promise.resolve();
-    this._locks = 0;
-  }
-  isLocked() {
-    return this._locks > 0;
-  }
-  lock() {
-    this._locks += 1;
-    let unlockNext;
-    const willLock = new Promise(resolve => unlockNext = () => {
-      this._locks -= 1;
-      resolve();
-    });
-    const willUnlock = this._locking.then(() => unlockNext);
-    this._locking = this._locking.then(() => willLock);
-    return willUnlock;
-  }
-}
 function isVideoCodec(maybeCodec) {
   return videoCodecs.includes(maybeCodec);
 }
@@ -12447,10 +12448,10 @@ class LocalTrack extends Track {
     };
     this.reacquireTrack = false;
     this.providedByUser = userProvidedTrack;
-    this.muteLock = new Mutex();
-    this.pauseUpstreamLock = new Mutex();
-    this.processorLock = new Mutex();
-    this.restartLock = new Mutex();
+    this.muteLock = new h();
+    this.pauseUpstreamLock = new h();
+    this.processorLock = new h();
+    this.restartLock = new h();
     this.setMediaStreamTrack(mediaTrack, true);
     // added to satisfy TS compiler, constraints are synced with MediaStreamTrack
     this._constraints = mediaTrack.getConstraints();
@@ -13237,7 +13238,7 @@ var QueueTaskStatus;
 class AsyncQueue {
   constructor() {
     this.pendingTasks = new Map();
-    this.taskMutex = new Mutex();
+    this.taskMutex = new h();
     this.nextTaskIndex = 0;
   }
   run(task) {
@@ -13330,8 +13331,8 @@ class SignalClient {
     this.useJSON = useJSON;
     this.requestQueue = new AsyncQueue();
     this.queuedRequests = [];
-    this.closingLock = new Mutex();
-    this.connectionLock = new Mutex();
+    this.closingLock = new h();
+    this.connectionLock = new h();
     this.state = SignalConnectionState.DISCONNECTED;
   }
   get logContext() {
@@ -14668,6 +14669,7 @@ class PCTransport extends eventsExports.EventEmitter {
     var _a;
     super();
     this.log = livekitLogger;
+    this.ddExtID = 0;
     this.pendingCandidates = [];
     this.restartingIce = false;
     this.renegotiate = false;
@@ -14889,7 +14891,7 @@ class PCTransport extends eventsExports.EventEmitter {
               return true;
             }
             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
             // mung sdp for av1 bitrate setting that can't apply by sendEncoding
@@ -15076,6 +15078,36 @@ class PCTransport extends eventsExports.EventEmitter {
       }
     });
   }
+  ensureVideoDDExtensionForSVC(media, sdp) {
+    var _a, _b;
+    const ddFound = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => {
+      if (ext.uri === ddExtensionURI) {
+        return true;
+      }
+      return false;
+    });
+    if (!ddFound) {
+      if (this.ddExtID === 0) {
+        let maxID = 0;
+        sdp.media.forEach(m => {
+          var _a;
+          if (m.type !== 'video') {
+            return;
+          }
+          (_a = m.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
+            if (ext.value > maxID) {
+              maxID = ext.value;
+            }
+          });
+        });
+        this.ddExtID = maxID + 1;
+      }
+      (_b = media.ext) === null || _b === void 0 ? void 0 : _b.push({
+        value: this.ddExtID,
+        uri: ddExtensionURI
+      });
+    }
+  }
 }
 function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
   // found opus codec to add nack fb
@@ -15111,25 +15143,6 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
     }
   }
 }
-function ensureVideoDDExtensionForSVC(media) {
-  var _a, _b;
-  let maxID = 0;
-  const ddFound = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => {
-    if (ext.uri === ddExtensionURI) {
-      return true;
-    }
-    if (ext.value > maxID) {
-      maxID = ext.value;
-    }
-    return false;
-  });
-  if (!ddFound) {
-    (_b = media.ext) === null || _b === void 0 ? void 0 : _b.push({
-      value: maxID + 1,
-      uri: ddExtensionURI
-    });
-  }
-}
 function extractStereoAndNackAudioFromOffer(offer) {
   var _a;
   const stereoMids = [];
@@ -15280,8 +15293,8 @@ class PCTransportManager {
       (_a = this.onPublisherOffer) === null || _a === void 0 ? void 0 : _a.call(this, offer);
     };
     this.state = PCTransportState.NEW;
-    this.connectionLock = new Mutex();
-    this.remoteOfferLock = new Mutex();
+    this.connectionLock = new h();
+    this.remoteOfferLock = new h();
   }
   get logContext() {
     var _a, _b;
@@ -16120,7 +16133,7 @@ class LocalVideoTrack extends LocalTrack {
       }
       this.prevStats = statsMap;
     });
-    this.senderLock = new Mutex();
+    this.senderLock = new h();
   }
   get isSimulcast() {
     if (this.sender && this.sender.getParameters().encodings.length > 1) {
@@ -16880,8 +16893,8 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.client.signalLatency = this.options.expSignalLatency;
     this.reconnectPolicy = this.options.reconnectPolicy;
     this.registerOnLineListener();
-    this.closingLock = new Mutex();
-    this.dataProcessLock = new Mutex();
+    this.closingLock = new h();
+    this.dataProcessLock = new h();
     this.dcBufferStatus = new Map([[DataPacket_Kind.LOSSY, true], [DataPacket_Kind.RELIABLE, true]]);
     this.client.onParticipantUpdate = updates => this.emit(EngineEvent.ParticipantUpdate, updates);
     this.client.onConnectionQuality = update => this.emit(EngineEvent.ConnectionQualityUpdate, update);
@@ -16946,6 +16959,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       try {
         this._isClosed = true;
+        this.joinAttempts = 0;
         this.emit(EngineEvent.Closing);
         this.removeAllListeners();
         this.deregisterOnLineListener();
@@ -17859,6 +17873,120 @@ function getCloudConfigUrl(serverUrl) {
   return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
 }
 
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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.
+ */
+class RpcError extends Error {
+  /**
+   * 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, message, data) {
+    super(message);
+    this.code = code;
+    this.message = truncateBytes(message, RpcError.MAX_MESSAGE_BYTES);
+    this.data = data ? truncateBytes(data, RpcError.MAX_DATA_BYTES) : undefined;
+  }
+  /**
+   * @internal
+   */
+  static fromProto(proto) {
+    return new RpcError(proto.code, proto.message, proto.data);
+  }
+  /**
+   * @internal
+   */
+  toProto() {
+    return new RpcError$1({
+      code: this.code,
+      message: this.message,
+      data: this.data
+    });
+  }
+  /**
+   * Creates an error object from the code, with an auto-populated message.
+   *
+   * @internal
+   */
+  static builtIn(key, data) {
+    return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data);
+  }
+}
+RpcError.MAX_MESSAGE_BYTES = 256;
+RpcError.MAX_DATA_BYTES = 15360; // 15 KB
+RpcError.ErrorCode = {
+  APPLICATION_ERROR: 1500,
+  CONNECTION_TIMEOUT: 1501,
+  RESPONSE_TIMEOUT: 1502,
+  RECIPIENT_DISCONNECTED: 1503,
+  RESPONSE_PAYLOAD_TOO_LARGE: 1504,
+  SEND_FAILED: 1505,
+  UNSUPPORTED_METHOD: 1400,
+  RECIPIENT_NOT_FOUND: 1401,
+  REQUEST_PAYLOAD_TOO_LARGE: 1402,
+  UNSUPPORTED_SERVER: 1403,
+  UNSUPPORTED_VERSION: 1404
+};
+/**
+ * @internal
+ */
+RpcError.ErrorMessage = {
+  APPLICATION_ERROR: 'Application error in method handler',
+  CONNECTION_TIMEOUT: 'Connection timeout',
+  RESPONSE_TIMEOUT: 'Response timeout',
+  RECIPIENT_DISCONNECTED: 'Recipient disconnected',
+  RESPONSE_PAYLOAD_TOO_LARGE: 'Response payload too large',
+  SEND_FAILED: 'Failed to send',
+  UNSUPPORTED_METHOD: 'Method not supported at destination',
+  RECIPIENT_NOT_FOUND: 'Recipient not found',
+  REQUEST_PAYLOAD_TOO_LARGE: 'Request payload too large',
+  UNSUPPORTED_SERVER: 'RPC not supported by server',
+  UNSUPPORTED_VERSION: 'Unsupported RPC version'
+};
+/*
+ * Maximum payload size for RPC requests and responses. If a payload exceeds this size,
+ * the RPC call will fail with a REQUEST_PAYLOAD_TOO_LARGE(1402) or RESPONSE_PAYLOAD_TOO_LARGE(1504) error.
+ */
+const MAX_PAYLOAD_BYTES = 15360; // 15 KB
+/**
+ * @internal
+ */
+function byteLength(str) {
+  const encoder = new TextEncoder();
+  return encoder.encode(str).length;
+}
+/**
+ * @internal
+ */
+function truncateBytes(str, maxBytes) {
+  if (byteLength(str) <= maxBytes) {
+    return str;
+  }
+  let low = 0;
+  let high = str.length;
+  const encoder = new TextEncoder();
+  while (low < high) {
+    const mid = Math.floor((low + high + 1) / 2);
+    if (encoder.encode(str.slice(0, mid)).length <= maxBytes) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return str.slice(0, low);
+}
+
 class RemoteTrack extends Track {
   constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
     super(mediaTrack, kind, loggerOptions);
@@ -19094,6 +19222,9 @@ class LocalParticipant extends Participant {
     this.allParticipantsAllowedToSubscribe = true;
     this.encryptionType = Encryption_Type.NONE;
     this.enabledPublishVideoCodecs = [];
+    this.rpcHandlers = new Map();
+    this.pendingAcks = new Map();
+    this.pendingResponses = new Map();
     this.handleReconnecting = () => {
       if (!this.reconnectFuture) {
         this.reconnectFuture = new Future();
@@ -19127,6 +19258,29 @@ class LocalParticipant extends Participant {
         this.pendingSignalRequests.delete(requestId);
       }
     };
+    this.handleDataPacket = packet => {
+      switch (packet.value.case) {
+        case 'rpcRequest':
+          let rpcRequest = packet.value.value;
+          this.handleIncomingRpcRequest(packet.participantIdentity, rpcRequest.id, rpcRequest.method, rpcRequest.payload, rpcRequest.responseTimeoutMs, rpcRequest.version);
+          break;
+        case 'rpcResponse':
+          let rpcResponse = packet.value.value;
+          let payload = null;
+          let error = null;
+          if (rpcResponse.value.case === 'payload') {
+            payload = rpcResponse.value.value;
+          } else if (rpcResponse.value.case === 'error') {
+            error = RpcError.fromProto(rpcResponse.value.value);
+          }
+          this.handleIncomingRpcResponse(rpcResponse.requestId, payload, error);
+          break;
+        case 'rpcAck':
+          let rpcAck = packet.value.value;
+          this.handleIncomingRpcAck(rpcAck.requestId);
+          break;
+      }
+    };
     this.updateTrackSubscriptionPermissions = () => {
       this.log.debug('updating track subscription permissions', Object.assign(Object.assign({}, this.logContext), {
         allParticipantsAllowed: this.allParticipantsAllowedToSubscribe,
@@ -19314,7 +19468,7 @@ class LocalParticipant extends Participant {
         pub.unmute();
       }
     });
-    this.engine.on(EngineEvent.Connected, this.handleReconnected).on(EngineEvent.SignalRestarted, this.handleReconnected).on(EngineEvent.SignalResumed, this.handleReconnected).on(EngineEvent.Restarting, this.handleReconnecting).on(EngineEvent.Resuming, this.handleReconnecting).on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished).on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate).on(EngineEvent.Disconnected, this.handleDisconnected).on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse);
+    this.engine.on(EngineEvent.Connected, this.handleReconnected).on(EngineEvent.SignalRestarted, this.handleReconnected).on(EngineEvent.SignalResumed, this.handleReconnected).on(EngineEvent.Restarting, this.handleReconnecting).on(EngineEvent.Resuming, this.handleReconnecting).on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished).on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate).on(EngineEvent.Disconnected, this.handleDisconnected).on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse).on(EngineEvent.DataPacketReceived, this.handleDataPacket);
   }
   /**
    * Sets and updates the metadata of the local participant.
@@ -20303,6 +20457,108 @@ class LocalParticipant extends Participant {
       return msg;
     });
   }
+  /**
+   * Initiate an RPC call to a remote participant
+   * @param params - Parameters for initiating the RPC call, see {@link PerformRpcParams}
+   * @returns A promise that resolves with the response payload or rejects with an error.
+   * @throws Error on failure. Details in `message`.
+   */
+  performRpc(_a) {
+    return __awaiter(this, arguments, void 0, function (_ref3) {
+      var _this5 = this;
+      let {
+        destinationIdentity,
+        method,
+        payload,
+        responseTimeout = 10000
+      } = _ref3;
+      return function* () {
+        const maxRoundTripLatency = 2000;
+        return new Promise((resolve, reject) => __awaiter(_this5, void 0, void 0, function* () {
+          var _a, _b, _c, _d;
+          if (byteLength(payload) > MAX_PAYLOAD_BYTES) {
+            reject(RpcError.builtIn('REQUEST_PAYLOAD_TOO_LARGE'));
+            return;
+          }
+          if (((_b = (_a = this.engine.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.serverInfo) === null || _b === void 0 ? void 0 : _b.version) && compareVersions((_d = (_c = this.engine.latestJoinResponse) === null || _c === void 0 ? void 0 : _c.serverInfo) === null || _d === void 0 ? void 0 : _d.version, '1.8.0') < 0) {
+            reject(RpcError.builtIn('UNSUPPORTED_SERVER'));
+            return;
+          }
+          const id = crypto.randomUUID();
+          yield this.publishRpcRequest(destinationIdentity, id, method, payload, responseTimeout - maxRoundTripLatency);
+          const ackTimeoutId = setTimeout(() => {
+            this.pendingAcks.delete(id);
+            reject(RpcError.builtIn('CONNECTION_TIMEOUT'));
+            this.pendingResponses.delete(id);
+            clearTimeout(responseTimeoutId);
+          }, maxRoundTripLatency);
+          this.pendingAcks.set(id, {
+            resolve: () => {
+              clearTimeout(ackTimeoutId);
+            },
+            participantIdentity: destinationIdentity
+          });
+          const responseTimeoutId = setTimeout(() => {
+            this.pendingResponses.delete(id);
+            reject(RpcError.builtIn('RESPONSE_TIMEOUT'));
+          }, responseTimeout);
+          this.pendingResponses.set(id, {
+            resolve: (responsePayload, responseError) => {
+              clearTimeout(responseTimeoutId);
+              if (this.pendingAcks.has(id)) {
+                console.warn('RPC response received before ack', id);
+                this.pendingAcks.delete(id);
+                clearTimeout(ackTimeoutId);
+              }
+              if (responseError) {
+                reject(responseError);
+              } else {
+                resolve(responsePayload !== null && responsePayload !== void 0 ? responsePayload : '');
+              }
+            },
+            participantIdentity: destinationIdentity
+          });
+        }));
+      }();
+    });
+  }
+  /**
+   * Establishes the participant as a receiver for calls of the specified RPC method.
+   * Will overwrite any existing callback for the same method.
+   *
+   * @param method - The name of the indicated RPC method
+   * @param handler - Will be invoked when an RPC request for this method is received
+   * @returns A promise that resolves when the method is successfully registered
+   *
+   * @example
+   * ```typescript
+   * room.localParticipant?.registerRpcMethod(
+   *   'greet',
+   *   async (data: RpcInvocationData) => {
+   *     console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
+   *     return `Hello, ${data.callerIdentity}!`;
+   *   }
+   * );
+   * ```
+   *
+   * The handler should return a Promise that resolves to a string.
+   * If unable to respond within `responseTimeout`, the request will result in an error on the caller's side.
+   *
+   * You may throw errors of type `RpcError` with a string `message` in the handler,
+   * and they will be received on the caller's side with the message intact.
+   * Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as `1500` ("Application Error").
+   */
+  registerRpcMethod(method, handler) {
+    this.rpcHandlers.set(method, handler);
+  }
+  /**
+   * Unregisters a previously registered RPC method.
+   *
+   * @param method - The name of the RPC method to unregister
+   */
+  unregisterRpcMethod(method) {
+    this.rpcHandlers.delete(method);
+  }
   /**
    * Control who can subscribe to LocalParticipant's published tracks.
    *
@@ -20328,6 +20584,140 @@ class LocalParticipant extends Participant {
       this.updateTrackSubscriptionPermissions();
     }
   }
+  handleIncomingRpcAck(requestId) {
+    const handler = this.pendingAcks.get(requestId);
+    if (handler) {
+      handler.resolve();
+      this.pendingAcks.delete(requestId);
+    } else {
+      console.error('Ack received for unexpected RPC request', requestId);
+    }
+  }
+  handleIncomingRpcResponse(requestId, payload, error) {
+    const handler = this.pendingResponses.get(requestId);
+    if (handler) {
+      handler.resolve(payload, error);
+      this.pendingResponses.delete(requestId);
+    } else {
+      console.error('Response received for unexpected RPC request', requestId);
+    }
+  }
+  handleIncomingRpcRequest(callerIdentity, requestId, method, payload, responseTimeout, version) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.publishRpcAck(callerIdentity, requestId);
+      if (version !== 1) {
+        yield this.publishRpcResponse(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_VERSION'));
+        return;
+      }
+      const handler = this.rpcHandlers.get(method);
+      if (!handler) {
+        yield this.publishRpcResponse(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_METHOD'));
+        return;
+      }
+      let responseError = null;
+      let responsePayload = null;
+      try {
+        const response = yield handler({
+          requestId,
+          callerIdentity,
+          payload,
+          responseTimeout
+        });
+        if (byteLength(response) > MAX_PAYLOAD_BYTES) {
+          responseError = RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE');
+          console.warn("RPC Response payload too large for ".concat(method));
+        } else {
+          responsePayload = response;
+        }
+      } catch (error) {
+        if (error instanceof RpcError) {
+          responseError = error;
+        } else {
+          console.warn("Uncaught error returned by RPC handler for ".concat(method, ". Returning APPLICATION_ERROR instead."), error);
+          responseError = RpcError.builtIn('APPLICATION_ERROR');
+        }
+      }
+      yield this.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
+    });
+  }
+  /** @internal */
+  publishRpcRequest(destinationIdentity, requestId, method, payload, responseTimeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const packet = new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcRequest',
+          value: new RpcRequest({
+            id: requestId,
+            method,
+            payload,
+            responseTimeoutMs: responseTimeout,
+            version: 1
+          })
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    });
+  }
+  /** @internal */
+  publishRpcResponse(destinationIdentity, requestId, payload, error) {
+    return __awaiter(this, void 0, void 0, function* () {
+      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 !== null && payload !== void 0 ? payload : ''
+            }
+          })
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    });
+  }
+  /** @internal */
+  publishRpcAck(destinationIdentity, requestId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const packet = new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcAck',
+          value: new RpcAck({
+            requestId
+          })
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    });
+  }
+  /** @internal */
+  handleParticipantDisconnected(participantIdentity) {
+    for (const [id, {
+      participantIdentity: pendingIdentity
+    }] of this.pendingAcks) {
+      if (pendingIdentity === participantIdentity) {
+        this.pendingAcks.delete(id);
+      }
+    }
+    for (const [id, {
+      participantIdentity: pendingIdentity,
+      resolve
+    }] of this.pendingResponses) {
+      if (pendingIdentity === participantIdentity) {
+        resolve(null, RpcError.builtIn('RECIPIENT_DISCONNECTED'));
+        this.pendingResponses.delete(id);
+      }
+    }
+  }
   /** @internal */
   setEnabledPublishCodecs(codecs) {
     this.enabledPublishVideoCodecs = codecs.filter(c => c.mime.split('/')[0].toLowerCase() === 'video');
@@ -20382,8 +20772,8 @@ class LocalParticipant extends Participant {
   }
   waitForPendingPublicationOfSource(source) {
     return __awaiter(this, void 0, void 0, function* () {
-      const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref3 => {
-        let [pendingTrack] = _ref3;
+      const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref4 => {
+        let [pendingTrack] = _ref4;
         return pendingTrack.source === source;
       });
       if (publishPromiseEntry) {
@@ -21638,7 +22028,7 @@ class Room extends eventsExports.EventEmitter {
     this.options.videoCaptureDefaults = Object.assign(Object.assign({}, videoDefaults), options === null || options === void 0 ? void 0 : options.videoCaptureDefaults);
     this.options.publishDefaults = Object.assign(Object.assign({}, publishDefaults), options === null || options === void 0 ? void 0 : options.publishDefaults);
     this.maybeCreateEngine();
-    this.disconnectLock = new Mutex();
+    this.disconnectLock = new h();
     this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
     if (this.options.videoCaptureDefaults.deviceId) {
       this.localParticipant.activeDeviceMap.set('videoinput', unwrapConstraint(this.options.videoCaptureDefaults.deviceId));
@@ -22204,6 +22594,7 @@ class Room extends eventsExports.EventEmitter {
     }
   }
   handleParticipantDisconnected(identity, participant) {
+    var _a;
     // remove and send event
     this.remoteParticipants.delete(identity);
     if (!participant) {
@@ -22213,6 +22604,7 @@ class Room extends eventsExports.EventEmitter {
       participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
+    (_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.handleParticipantDisconnected(participant.identity);
   }
   acquireAudioContext() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23090,5 +23482,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, extractProcessorsFromOptions, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, h as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, extractProcessorsFromOptions, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map