livekit-client 2.5.10 → 2.6.1

package/dist/livekit-client.esm.mjs

@@ -4746,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",
@@ -11176,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.10";
+var version$1 = "2.6.1";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -11836,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 = [];
@@ -13384,11 +13380,11 @@ class SignalClient {
         const abortHandler = () => __awaiter(this, void 0, void 0, function* () {
           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 === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
           abortHandler();
@@ -13470,7 +13466,7 @@ class SignalClient {
               reject(new ConnectionError('Received leave request while trying to (re)connect', ConnectionErrorReason.LeaveRequest));
             } else if (!opts.reconnect) {
               // non-reconnect case, should receive join response first
-              reject(new ConnectionError("did not receive join response, got ".concat((_c = resp.message) === null || _c === void 0 ? void 0 : _c.case, " instead")));
+              reject(new ConnectionError("did not receive join response, got ".concat((_c = resp.message) === null || _c === void 0 ? void 0 : _c.case, " instead"), ConnectionErrorReason.InternalError));
             }
             if (!shouldProcessMessage) {
               return;
@@ -13483,7 +13479,7 @@ class SignalClient {
         });
         this.ws.onclose = ev => {
           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", Object.assign(Object.assign({}, this.logContext), {
             reason: ev.reason,
@@ -14673,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;
@@ -14894,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
@@ -15081,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
@@ -15116,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 = [];
@@ -15470,7 +15478,7 @@ class PCTransportManager {
           abortController === null || abortController === void 0 ? void 0 : abortController.signal.addEventListener('abort', abortHandler);
           const connectTimeout = CriticalTimers.setTimeout(() => {
             abortController === null || abortController === void 0 ? void 0 : 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) {
             yield sleep(50); // FIXME we shouldn't rely on `sleep` in the connection paths, as it invokes `setTimeout` which can be drastically throttled by browser implementations
@@ -17001,7 +17009,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     return new Promise((resolve, reject) => {
       const publicationTimeout = setTimeout(() => {
         delete this.pendingTrackResolvers[req.cid];
-        reject(new ConnectionError('publication of local track timed out, no response from server'));
+        reject(new ConnectionError('publication of local track timed out, no response from server', ConnectionErrorReason.InternalError));
       }, 10000);
       this.pendingTrackResolvers[req.cid] = {
         resolve: info => {
@@ -17548,7 +17556,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       } catch (e) {
         // TODO do we need a `failed` state here for the PC?
         this.pcState = PCState.Disconnected;
-        throw new ConnectionError("could not establish PC connection, ".concat(e.message));
+        throw new ConnectionError("could not establish PC connection, ".concat(e.message), ConnectionErrorReason.InternalError);
       }
     });
   }
@@ -17580,7 +17588,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         const transport = subscriber ? _this2.pcManager.subscriber : _this2.pcManager.publisher;
         const transportName = subscriber ? 'Subscriber' : 'Publisher';
         if (!transport) {
-          throw new ConnectionError("".concat(transportName, " connection not set"));
+          throw new ConnectionError("".concat(transportName, " connection not set"), ConnectionErrorReason.InternalError);
         }
         let needNegotiation = false;
         if (!subscriber && !_this2.dataChannelForKind(kind, subscriber)) {
@@ -17606,7 +17614,7 @@ class RTCEngine extends eventsExports.EventEmitter {
           }
           yield sleep(50);
         }
-        throw new ConnectionError("could not establish ".concat(transportName, " connection, state: ").concat(transport.getICEConnectionState()));
+        throw new ConnectionError("could not establish ".concat(transportName, " connection, state: ").concat(transport.getICEConnectionState()), ConnectionErrorReason.InternalError);
       }();
     });
   }
@@ -17852,7 +17860,7 @@ class RegionUrlProvider {
         this.lastUpdateAt = Date.now();
         return regionSettings;
       } else {
-        throw new ConnectionError("Could not fetch region settings: ".concat(regionSettingsResponse.statusText), regionSettingsResponse.status === 401 ? ConnectionErrorReason.NotAllowed : undefined, regionSettingsResponse.status);
+        throw new ConnectionError("Could not fetch region settings: ".concat(regionSettingsResponse.statusText), regionSettingsResponse.status === 401 ? ConnectionErrorReason.NotAllowed : ConnectionErrorReason.InternalError, regionSettingsResponse.status);
       }
     });
   }
@@ -17865,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);
@@ -19100,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();
@@ -19133,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,
@@ -19320,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.
@@ -20309,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.
    *
@@ -20334,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');
@@ -20388,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) {
@@ -21118,7 +21502,7 @@ class Room extends eventsExports.EventEmitter {
       } catch (err) {
         yield 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 = "".concat(resultingError.message, ": ").concat(err.message);
         }
@@ -21134,7 +21518,7 @@ class Room extends eventsExports.EventEmitter {
       if (abortController.signal.aborted) {
         yield this.engine.close();
         this.recreateEngine();
-        throw new ConnectionError("Connection attempt aborted");
+        throw new ConnectionError("Connection attempt aborted", ConnectionErrorReason.Cancelled);
       }
       try {
         yield this.engine.waitForPCInitialConnection(this.connOptions.peerConnectionTimeout, abortController);
@@ -21181,7 +21565,7 @@ class Room extends eventsExports.EventEmitter {
               _this2.log.warn('abort connection attempt', _this2.logContext);
               (_a = _this2.abortController) === null || _a === void 0 ? void 0 : _a.abort();
               // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
-              (_c = (_b = _this2.connectFuture) === null || _b === void 0 ? void 0 : _b.reject) === null || _c === void 0 ? void 0 : _c.call(_b, new ConnectionError('Client initiated disconnect'));
+              (_c = (_b = _this2.connectFuture) === null || _b === void 0 ? void 0 : _b.reject) === null || _c === void 0 ? void 0 : _c.call(_b, new ConnectionError('Client initiated disconnect', ConnectionErrorReason.Cancelled));
               _this2.connectFuture = undefined;
             }
             // send leave
@@ -22210,6 +22594,7 @@ class Room extends eventsExports.EventEmitter {
     }
   }
   handleParticipantDisconnected(identity, participant) {
+    var _a;
     // remove and send event
     this.remoteParticipants.delete(identity);
     if (!participant) {
@@ -22219,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* () {
@@ -23096,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, h as 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