livekit-client 2.18.10 → 2.19.1

package/dist/livekit-client.esm.mjs

@@ -8720,7 +8720,8 @@ function requireEvents() {
     }
   }
   return events.exports;
-}var eventsExports = requireEvents();/*
+}var eventsExports = requireEvents();
+var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);/*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
@@ -11792,8 +11793,16 @@ function getMatch(exp, ua) {
 }
 function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
-}var version$1 = "2.18.10";const version = version$1;
-const protocolVersion = 17;/** Base error that all LiveKit specific custom errors inherit from. */
+}var version$1 = "2.19.1";const version = version$1;
+const protocolVersion = 17;
+/** Initial client protocol. */
+const CLIENT_PROTOCOL_DEFAULT = 0;
+/** Replaces RPC v1 protocol with a v2 data streams based one to support unlimited request /
+ * response payload length. */
+const CLIENT_PROTOCOL_DATA_STREAM_RPC = 1;
+/** The client protocol version indicates what level of support that the client has for
+ * client <-> client api interactions. */
+const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_RPC;/** Base error that all LiveKit specific custom errors inherit from. */
 class LivekitError extends Error {
   constructor(code, message, options) {
     super(message || 'an error has occurred');
@@ -13725,6 +13734,7 @@ function getClientInfo(capabilities) {
     capabilities,
     sdk: ClientInfo_SDK.JS,
     protocol: protocolVersion,
+    clientProtocol,
     version
   });
   if (isReactNative()) {
@@ -14029,6 +14039,10 @@ function extractMaxAgeFromRequestHeaders(headers) {
 }
 function isCompressionStreamSupported() {
   return typeof CompressionStream !== 'undefined';
+}
+function isPublisherOfferWithJoinSupported() {
+  // we have connectivity issue about publisher offer with join on firefox #1919
+  return isCompressionStreamSupported() && !isFireFox();
 }function createRtcUrl(url, searchParams) {
   let useV0Path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   const v0Url = createV0RtcUrl(url, searchParams);
@@ -17067,6 +17081,7 @@ function createConnectionParams(token, info, opts) {
   params.set('sdk', isReactNative() ? 'reactnative' : 'js');
   params.set('version', info.version);
   params.set('protocol', info.protocol.toString());
+  params.set('client_protocol', info.clientProtocol.toString());
   if (info.deviceModel) {
     params.set('device_model', info.deviceModel);
   }
@@ -18970,118 +18985,6 @@ class PCTransportManager {
       }();
     });
   }
-}// 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);
 }// Check if MediaRecorder is available
 const isMediaRecorderAvailable = typeof MediaRecorder !== 'undefined';
 // Fallback class for environments without MediaRecorder
@@ -21457,7 +21360,7 @@ class RTCEngine extends eventsExports.EventEmitter {
           _this2.joinAttempts += 1;
           _this2.setupSignalClientCallbacks();
           let offerProto;
-          if (!useV0Path && isCompressionStreamSupported()) {
+          if (!useV0Path && isPublisherOfferWithJoinSupported()) {
             if (!_this2.pcManager) {
               yield _this2.configure();
               _this2.createDataChannels();
@@ -21480,7 +21383,7 @@ class RTCEngine extends eventsExports.EventEmitter {
           _this2.latestJoinResponse = joinResponse;
           _this2.participantSid = (_b = joinResponse.participant) === null || _b === void 0 ? void 0 : _b.sid;
           _this2.subscriberPrimary = joinResponse.subscriberPrimary;
-          if (!useV0Path && isCompressionStreamSupported()) {
+          if (!useV0Path && isPublisherOfferWithJoinSupported()) {
             (_c = _this2.pcManager) === null || _c === void 0 ? void 0 : _c.updateConfiguration(_this2.makeRTCConfiguration(joinResponse));
           } else {
             if (!_this2.pcManager) {
@@ -22296,29 +22199,6 @@ class RTCEngine extends eventsExports.EventEmitter {
     });
   }
   /** @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.sendDataPacket(packet, DataChannelKind.RELIABLE);
-    });
-  }
-  /** @internal */
   publishRpcAck(destinationIdentity, requestId) {
     return __awaiter(this, void 0, void 0, function* () {
       const packet = new DataPacket({
@@ -25863,112 +25743,635 @@ class OutgoingDataTrackManager extends eventsExports.EventEmitter {
       this.emit('reset');
     });
   }
-}class RemoteAudioTrack extends RemoteTrack {
-  constructor(mediaTrack, sid, receiver, audioContext, audioOutput, loggerOptions) {
-    super(mediaTrack, sid, Track.Kind.Audio, receiver, loggerOptions);
-    this.monitorReceiver = () => __awaiter(this, void 0, void 0, function* () {
-      if (!this.receiver) {
-        this._currentBitrate = 0;
-        return;
-      }
-      const stats = yield this.getReceiverStats();
-      if (stats && this.prevStats && this.receiver) {
-        this._currentBitrate = computeBitrate(stats, this.prevStats);
-      }
-      this.prevStats = stats;
-    });
-    this.audioContext = audioContext;
-    this.webAudioPluginNodes = [];
-    if (audioOutput) {
-      this.sinkId = audioOutput.deviceId;
-    }
-  }
+}/**
+ * 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 {
   /**
-   * sets the volume for all attached audio elements
+   * 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).
    */
-  setVolume(volume) {
-    var _a;
-    for (const el of this.attachedElements) {
-      if (this.audioContext) {
-        (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.gain.setTargetAtTime(volume, 0, 0.1);
-      } else {
-        el.volume = volume;
-      }
-    }
-    if (isReactNative()) {
-      // @ts-ignore
-      this._mediaStreamTrack._setVolume(volume);
+  constructor(code, message, data, options) {
+    super(message);
+    this.code = code;
+    this.message = truncateBytes(message, RpcError.MAX_MESSAGE_BYTES);
+    this.data = data ? truncateBytes(data, RpcError.MAX_DATA_BYTES) : undefined;
+    if (typeof (options === null || options === void 0 ? void 0 : options.cause) !== 'undefined') {
+      this.cause = options === null || options === void 0 ? void 0 : options.cause;
     }
-    this.elementVolume = volume;
   }
   /**
-   * gets the volume of attached audio elements (loudest)
+   * @internal
    */
-  getVolume() {
-    if (this.elementVolume) {
-      return this.elementVolume;
-    }
-    if (isReactNative()) {
-      // RN volume value defaults to 1.0 if hasn't been changed.
-      return 1.0;
-    }
-    let highestVolume = 0;
-    this.attachedElements.forEach(element => {
-      if (element.volume > highestVolume) {
-        highestVolume = element.volume;
-      }
-    });
-    return highestVolume;
+  static fromProto(proto) {
+    return new RpcError(proto.code, proto.message, proto.data);
   }
   /**
-   * calls setSinkId on all attached elements, if supported
-   * @param deviceId audio output device
+   * @internal
    */
-  setSinkId(deviceId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.sinkId = deviceId;
-      yield Promise.all(this.attachedElements.map(elm => {
-        if (!supportsSetSinkId(elm)) {
-          return;
-        }
-        /* @ts-ignore */
-        return elm.setSinkId(deviceId);
-      }));
+  toProto() {
+    return new RpcError$1({
+      code: this.code,
+      message: this.message,
+      data: this.data
     });
   }
-  attach(element) {
-    const needsNewWebAudioConnection = this.attachedElements.length === 0;
-    if (!element) {
-      element = super.attach();
-    } else {
-      super.attach(element);
-    }
-    if (this.sinkId && supportsSetSinkId(element)) {
-      element.setSinkId(this.sinkId).catch(e => {
-        this.log.error('Failed to set sink id on remote audio track', e, this.logContext);
-      });
-    }
-    if (this.audioContext && needsNewWebAudioConnection) {
-      this.log.debug('using audio context mapping', this.logContext);
-      this.connectWebAudio(this.audioContext, element);
-      element.volume = 0;
-      element.muted = true;
-    }
-    if (this.elementVolume) {
-      // make sure volume setting is being applied to the newly attached element
-      this.setVolume(this.elementVolume);
-    }
-    return element;
+  /**
+   * Creates an error object from the code, with an auto-populated message.
+   *
+   * @internal
+   */
+  static builtIn(key, data, options) {
+    return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data, options);
   }
-  detach(element) {
-    let detached;
-    if (!element) {
-      detached = super.detach();
-      this.disconnectWebAudio();
-    } else {
-      detached = super.detach(element);
-      // if there are still any attached elements after detaching, connect webaudio to the first element that's left
-      // disconnect webaudio otherwise
+}
+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 for clients with a clientProtocol of less
+ * than CLIENT_PROTOCOL_DATA_STREAM_RPC.
+ *
+ * If a payload exceeds this size and the remote client does not support compression,
+ * the RPC call will fail with a REQUEST_PAYLOAD_TOO_LARGE(1402) or RESPONSE_PAYLOAD_TOO_LARGE(1504) error.
+ */
+const MAX_V1_PAYLOAD_BYTES = 15360; // 15 KB
+/**
+ * Topic used for v2 RPC request data streams.
+ * @internal
+ */
+const RPC_REQUEST_DATA_STREAM_TOPIC = 'lk.rpc_request';
+/**
+ * Topic used for v2 RPC response data streams.
+ * @internal
+ */
+const RPC_RESPONSE_DATA_STREAM_TOPIC = 'lk.rpc_response';
+/** @internal */
+var RpcRequestAttrs;
+(function (RpcRequestAttrs) {
+  RpcRequestAttrs["RPC_REQUEST_ID"] = "lk.rpc_request_id";
+  RpcRequestAttrs["RPC_REQUEST_METHOD"] = "lk.rpc_request_method";
+  RpcRequestAttrs["RPC_REQUEST_RESPONSE_TIMEOUT_MS"] = "lk.rpc_request_response_timeout_ms";
+  RpcRequestAttrs["RPC_REQUEST_VERSION"] = "lk.rpc_request_version";
+})(RpcRequestAttrs || (RpcRequestAttrs = {}));
+/** Initial version of rpc which uses RpcRequest / RpcResponse messages.
+ * @internal
+ **/
+const RPC_VERSION_V1 = 1;
+/** Rpc version backed by data streams instead of RpcRequest / RpcResponse.
+ * @internal
+ **/
+const RPC_VERSION_V2 = 2;
+/**
+ * @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);
+}/**
+ * Manages the client (caller) side of RPC: sending requests, tracking pending
+ * ack/response state, and handling incoming ack/response packets.
+ * @internal
+ */
+class RpcClientManager extends EventEmitter {
+  constructor(log, outgoingDataStreamManager, getRemoteParticipantClientProtocol, getServerVersion) {
+    super();
+    this.pendingAcks = new Map();
+    this.pendingResponses = new Map();
+    this.log = log;
+    this.outgoingDataStreamManager = outgoingDataStreamManager;
+    this.getRemoteParticipantClientProtocol = getRemoteParticipantClientProtocol;
+    this.getServerVersion = getServerVersion;
+  }
+  performRpc(_a) {
+    return __awaiter(this, arguments, void 0, function (_ref) {
+      var _this = this;
+      let {
+        destinationIdentity,
+        method,
+        payload,
+        responseTimeout: responseTimeoutMs = 15000
+      } = _ref;
+      return function* () {
+        const maxRoundTripLatencyMs = 7000;
+        const minEffectiveTimeoutMs = maxRoundTripLatencyMs + 1000;
+        const remoteClientProtocol = _this.getRemoteParticipantClientProtocol(destinationIdentity);
+        const payloadBytes = byteLength(payload);
+        // Only enforce the legacy size limit when on rpc v1
+        if (payloadBytes > MAX_V1_PAYLOAD_BYTES && remoteClientProtocol < CLIENT_PROTOCOL_DATA_STREAM_RPC) {
+          throw RpcError.builtIn('REQUEST_PAYLOAD_TOO_LARGE');
+        }
+        const serverVersion = _this.getServerVersion();
+        if (serverVersion && compareVersions(serverVersion, '1.8.0') < 0) {
+          throw RpcError.builtIn('UNSUPPORTED_SERVER');
+        }
+        const effectiveTimeoutMs = Math.max(responseTimeoutMs, minEffectiveTimeoutMs);
+        const id = crypto.randomUUID();
+        const completionFuture = new Future();
+        const ackTimeoutId = setTimeout(() => {
+          var _a;
+          _this.pendingAcks.delete(id);
+          (_a = completionFuture.reject) === null || _a === void 0 ? void 0 : _a.call(completionFuture, RpcError.builtIn('CONNECTION_TIMEOUT'));
+          _this.pendingResponses.delete(id);
+          clearTimeout(responseTimeoutId);
+        }, maxRoundTripLatencyMs);
+        _this.pendingAcks.set(id, {
+          resolve: () => {
+            clearTimeout(ackTimeoutId);
+          },
+          participantIdentity: destinationIdentity
+        });
+        _this.pendingResponses.set(id, {
+          completionFuture,
+          participantIdentity: destinationIdentity
+        });
+        yield _this.publishRpcRequest(destinationIdentity, id, method, payload, effectiveTimeoutMs, remoteClientProtocol);
+        const responseTimeoutId = setTimeout(() => {
+          var _a;
+          _this.pendingResponses.delete(id);
+          (_a = completionFuture.reject) === null || _a === void 0 ? void 0 : _a.call(completionFuture, RpcError.builtIn('RESPONSE_TIMEOUT'));
+        }, responseTimeoutMs);
+        const completionPromise = completionFuture.promise.finally(() => {
+          clearTimeout(responseTimeoutId);
+          if (_this.pendingAcks.has(id)) {
+            _this.log.warn('RPC response received before ack', id);
+            _this.pendingAcks.delete(id);
+            clearTimeout(ackTimeoutId);
+          }
+        });
+        return [id, completionPromise];
+      }();
+    });
+  }
+  publishRpcRequest(destinationIdentity, requestId, method, payload, responseTimeout, remoteClientProtocol) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (remoteClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
+        // Send payload as a data stream - a "version 2" rpc request.
+        const writer = yield this.outgoingDataStreamManager.streamText({
+          topic: RPC_REQUEST_DATA_STREAM_TOPIC,
+          destinationIdentities: [destinationIdentity],
+          attributes: {
+            [RpcRequestAttrs.RPC_REQUEST_ID]: requestId,
+            [RpcRequestAttrs.RPC_REQUEST_METHOD]: method,
+            [RpcRequestAttrs.RPC_REQUEST_RESPONSE_TIMEOUT_MS]: "".concat(responseTimeout),
+            [RpcRequestAttrs.RPC_REQUEST_VERSION]: "".concat(RPC_VERSION_V2)
+          }
+        });
+        yield writer.write(payload);
+        yield writer.close();
+        return;
+      }
+      // Fallback to sending a literal RpcRequest - a "version 1" rpc request.
+      this.emit('sendDataPacket', {
+        packet: new DataPacket({
+          destinationIdentities: [destinationIdentity],
+          kind: DataPacket_Kind.RELIABLE,
+          value: {
+            case: 'rpcRequest',
+            value: new RpcRequest({
+              id: requestId,
+              method,
+              payload,
+              responseTimeoutMs: responseTimeout,
+              version: RPC_VERSION_V1
+            })
+          }
+        })
+      });
+    });
+  }
+  /**
+   * Handle an incoming data stream containing an RPC response payload.
+   * @internal
+   */
+  handleIncomingDataStream(reader, senderIdentity, attributes) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const associatedRequestId = attributes[RpcRequestAttrs.RPC_REQUEST_ID];
+      if (!associatedRequestId) {
+        this.log.warn("RPC data stream malformed: ".concat(RpcRequestAttrs.RPC_REQUEST_ID, " not set."));
+        // NOTE: no response can be sent here, because there's no request id so associate
+        // so logging is the best we can do here.
+        return;
+      }
+      const pending = this.pendingResponses.get(associatedRequestId);
+      if (pending && pending.participantIdentity !== senderIdentity) {
+        this.log.warn("RPC response stream for ".concat(associatedRequestId, " arrived from unexpected sender ").concat(senderIdentity, ", expected ").concat(pending.participantIdentity, ". Ignoring."));
+        return;
+      }
+      let payload;
+      try {
+        payload = yield reader.readAll();
+      } catch (e) {
+        this.log.warn("Error reading RPC response payload: ".concat(e));
+        this.handleIncomingRpcResponseFailure(associatedRequestId, RpcError.builtIn('APPLICATION_ERROR', 'Error reading RPC response payload', {
+          cause: e
+        }));
+        return;
+      }
+      this.handleIncomingRpcResponseSuccess(associatedRequestId, payload);
+    });
+  }
+  /** @internal */
+  handleIncomingRpcResponseSuccess(requestId, payload) {
+    var _a, _b;
+    const handler = this.pendingResponses.get(requestId);
+    if (handler) {
+      (_b = (_a = handler.completionFuture).resolve) === null || _b === void 0 ? void 0 : _b.call(_a, payload);
+      this.pendingResponses.delete(requestId);
+    } else {
+      this.log.error('Response received for unexpected RPC request', requestId);
+    }
+  }
+  /** @internal */
+  handleIncomingRpcResponseFailure(requestId, error) {
+    var _a, _b;
+    const handler = this.pendingResponses.get(requestId);
+    if (handler) {
+      (_b = (_a = handler.completionFuture).reject) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+      this.pendingResponses.delete(requestId);
+    } else {
+      this.log.error('Response received for unexpected RPC request', requestId);
+    }
+  }
+  /** @internal */
+  handleIncomingRpcAck(requestId) {
+    const handler = this.pendingAcks.get(requestId);
+    if (handler) {
+      handler.resolve();
+      this.pendingAcks.delete(requestId);
+    } else {
+      this.log.error("Ack received for unexpected RPC request: ".concat(requestId));
+    }
+  }
+  /** @internal */
+  handleParticipantDisconnected(participantIdentity) {
+    var _a;
+    for (const [id, {
+      participantIdentity: pendingIdentity
+    }] of this.pendingAcks) {
+      if (pendingIdentity === participantIdentity) {
+        this.pendingAcks.delete(id);
+      }
+    }
+    for (const [id, {
+      participantIdentity: pendingIdentity,
+      completionFuture
+    }] of this.pendingResponses) {
+      if (pendingIdentity === participantIdentity) {
+        (_a = completionFuture.reject) === null || _a === void 0 ? void 0 : _a.call(completionFuture, RpcError.builtIn('RECIPIENT_DISCONNECTED'));
+        this.pendingResponses.delete(id);
+      }
+    }
+  }
+}/**
+ * Manages the server (handler) side of RPC: processing incoming requests,
+ * managing registered method handlers, and sending responses.
+ * @internal
+ */
+class RpcServerManager extends EventEmitter {
+  constructor(log, outgoingDataStreamManager, getRemoteParticipantClientProtocol) {
+    super();
+    this.rpcHandlers = new Map();
+    this.log = log;
+    this.outgoingDataStreamManager = outgoingDataStreamManager;
+    this.getRemoteParticipantClientProtocol = getRemoteParticipantClientProtocol;
+  }
+  registerRpcMethod(method, handler) {
+    if (this.rpcHandlers.has(method)) {
+      throw Error("RPC handler already registered for method ".concat(method, ", unregisterRpcMethod before trying to register again"));
+    }
+    this.rpcHandlers.set(method, handler);
+  }
+  unregisterRpcMethod(method) {
+    this.rpcHandlers.delete(method);
+  }
+  /**
+   * Handle an incoming RPCRequest message containing a payload.
+   * This handles "version 1" of rpc requests.
+   * @internal
+   */
+  handleIncomingRpcRequest(callerIdentity, rpcRequest) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      this.publishRpcAck(callerIdentity, rpcRequest.id);
+      if (rpcRequest.version !== 1) {
+        this.publishRpcResponsePacket(callerIdentity, rpcRequest.id, null, RpcError.builtIn('UNSUPPORTED_VERSION'));
+        return;
+      }
+      const handler = this.rpcHandlers.get(rpcRequest.method);
+      if (!handler) {
+        this.publishRpcResponsePacket(callerIdentity, rpcRequest.id, null, RpcError.builtIn('UNSUPPORTED_METHOD'));
+        return;
+      }
+      let response;
+      try {
+        response = yield handler({
+          requestId: rpcRequest.id,
+          callerIdentity,
+          payload: rpcRequest.payload,
+          responseTimeout: rpcRequest.responseTimeoutMs
+        });
+      } catch (error) {
+        let responseError;
+        if (error instanceof RpcError) {
+          responseError = error;
+        } else {
+          this.log.warn("Uncaught error returned by RPC handler for ".concat(rpcRequest.method, ". Returning APPLICATION_ERROR instead."), error);
+          responseError = RpcError.builtIn('APPLICATION_ERROR', "Uncaught error: ".concat((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error), {
+            cause: error
+          });
+        }
+        this.publishRpcResponsePacket(callerIdentity, rpcRequest.id, null, responseError);
+        return;
+      }
+      yield this.publishRpcResponse(callerIdentity, rpcRequest.id, response !== null && response !== void 0 ? response : '');
+    });
+  }
+  /**
+   * Handle an incoming data stream containing a RPC request payload.
+   * This handles "version 2" of rpc requests.
+   * @internal
+   */
+  handleIncomingDataStream(reader, callerIdentity, dataStreamAttrs) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const requestId = dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_ID];
+      const method = dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_METHOD];
+      const responseTimeout = parseInt(dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_RESPONSE_TIMEOUT_MS], 10);
+      const version = parseInt(dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_VERSION], 10);
+      if (!requestId || !method || Number.isNaN(responseTimeout) || Number.isNaN(version)) {
+        this.log.warn("RPC data stream malformed: ".concat(RpcRequestAttrs.RPC_REQUEST_ID, " / ").concat(RpcRequestAttrs.RPC_REQUEST_METHOD, " / ").concat(RpcRequestAttrs.RPC_REQUEST_RESPONSE_TIMEOUT_MS, " / ").concat(RpcRequestAttrs.RPC_REQUEST_VERSION, " not set."));
+        this.publishRpcResponsePacket(callerIdentity, requestId, null, RpcError.builtIn('APPLICATION_ERROR', 'RPC data stream malformed'));
+        return;
+      }
+      this.publishRpcAck(callerIdentity, requestId);
+      if (version !== RPC_VERSION_V2) {
+        this.publishRpcResponsePacket(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_VERSION'));
+        return;
+      }
+      let payload;
+      try {
+        payload = yield reader.readAll();
+      } catch (e) {
+        this.log.warn("Error reading RPC request payload: ".concat(e));
+        this.publishRpcResponsePacket(callerIdentity, requestId, null, RpcError.builtIn('APPLICATION_ERROR', 'Error reading RPC request payload', {
+          cause: e
+        }));
+        return;
+      }
+      const handler = this.rpcHandlers.get(method);
+      if (!handler) {
+        this.publishRpcResponsePacket(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_METHOD'));
+        return;
+      }
+      let response;
+      try {
+        response = yield handler({
+          requestId,
+          callerIdentity,
+          payload,
+          responseTimeout
+        });
+      } catch (error) {
+        let responseError;
+        if (error instanceof RpcError) {
+          responseError = error;
+        } else {
+          this.log.warn("Uncaught error returned by RPC handler for ".concat(method, ". Returning APPLICATION_ERROR instead."), error);
+          responseError = RpcError.builtIn('APPLICATION_ERROR');
+        }
+        this.publishRpcResponsePacket(callerIdentity, requestId, null, responseError);
+        return;
+      }
+      yield this.publishRpcResponse(callerIdentity, requestId, response !== null && response !== void 0 ? response : '');
+    });
+  }
+  publishRpcAck(destinationIdentity, requestId) {
+    this.emit('sendDataPacket', {
+      packet: new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcAck',
+          value: new RpcAck({
+            requestId
+          })
+        }
+      })
+    });
+  }
+  publishRpcResponsePacket(destinationIdentity, requestId, payload, error) {
+    this.emit('sendDataPacket', {
+      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 : ''
+            }
+          })
+        }
+      })
+    });
+  }
+  /**
+   * Send a successful RPC response payload, choosing the transport based on
+   * the caller's client protocol version.
+   */
+  publishRpcResponse(destinationIdentity, requestId, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const callerClientProtocol = this.getRemoteParticipantClientProtocol(destinationIdentity);
+      if (callerClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
+        // Send response as a data stream
+        const writer = yield this.outgoingDataStreamManager.streamText({
+          topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
+          destinationIdentities: [destinationIdentity],
+          attributes: {
+            [RpcRequestAttrs.RPC_REQUEST_ID]: requestId
+          }
+        });
+        yield writer.write(payload);
+        yield writer.close();
+        return;
+      }
+      // Legacy client: enforce size limit and send uncompressed payload inline
+      const responseBytes = byteLength(payload);
+      if (responseBytes > MAX_V1_PAYLOAD_BYTES) {
+        this.log.warn("RPC Response payload too large for request ".concat(requestId, ". To send larger responses, consider updating the sending client."));
+        this.publishRpcResponsePacket(destinationIdentity, requestId, null, RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE'));
+        return;
+      }
+      this.publishRpcResponsePacket(destinationIdentity, requestId, payload, null);
+    });
+  }
+}class RemoteAudioTrack extends RemoteTrack {
+  constructor(mediaTrack, sid, receiver, audioContext, audioOutput, loggerOptions) {
+    super(mediaTrack, sid, Track.Kind.Audio, receiver, loggerOptions);
+    this.monitorReceiver = () => __awaiter(this, void 0, void 0, function* () {
+      if (!this.receiver) {
+        this._currentBitrate = 0;
+        return;
+      }
+      const stats = yield this.getReceiverStats();
+      if (stats && this.prevStats && this.receiver) {
+        this._currentBitrate = computeBitrate(stats, this.prevStats);
+      }
+      this.prevStats = stats;
+    });
+    this.audioContext = audioContext;
+    this.webAudioPluginNodes = [];
+    if (audioOutput) {
+      this.sinkId = audioOutput.deviceId;
+    }
+  }
+  /**
+   * sets the volume for all attached audio elements
+   */
+  setVolume(volume) {
+    var _a;
+    for (const el of this.attachedElements) {
+      if (this.audioContext) {
+        (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.gain.setTargetAtTime(volume, 0, 0.1);
+      } else {
+        el.volume = volume;
+      }
+    }
+    if (isReactNative()) {
+      // @ts-ignore
+      this._mediaStreamTrack._setVolume(volume);
+    }
+    this.elementVolume = volume;
+  }
+  /**
+   * gets the volume of attached audio elements (loudest)
+   */
+  getVolume() {
+    if (this.elementVolume) {
+      return this.elementVolume;
+    }
+    if (isReactNative()) {
+      // RN volume value defaults to 1.0 if hasn't been changed.
+      return 1.0;
+    }
+    let highestVolume = 0;
+    this.attachedElements.forEach(element => {
+      if (element.volume > highestVolume) {
+        highestVolume = element.volume;
+      }
+    });
+    return highestVolume;
+  }
+  /**
+   * calls setSinkId on all attached elements, if supported
+   * @param deviceId audio output device
+   */
+  setSinkId(deviceId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.sinkId = deviceId;
+      yield Promise.all(this.attachedElements.map(elm => {
+        if (!supportsSetSinkId(elm)) {
+          return;
+        }
+        /* @ts-ignore */
+        return elm.setSinkId(deviceId);
+      }));
+    });
+  }
+  attach(element) {
+    const needsNewWebAudioConnection = this.attachedElements.length === 0;
+    if (!element) {
+      element = super.attach();
+    } else {
+      super.attach(element);
+    }
+    if (this.sinkId && supportsSetSinkId(element)) {
+      element.setSinkId(this.sinkId).catch(e => {
+        this.log.error('Failed to set sink id on remote audio track', e, this.logContext);
+      });
+    }
+    if (this.audioContext && needsNewWebAudioConnection) {
+      this.log.debug('using audio context mapping', this.logContext);
+      this.connectWebAudio(this.audioContext, element);
+      element.volume = 0;
+      element.muted = true;
+    }
+    if (this.elementVolume) {
+      // make sure volume setting is being applied to the newly attached element
+      this.setVolume(this.elementVolume);
+    }
+    return element;
+  }
+  detach(element) {
+    let detached;
+    if (!element) {
+      detached = super.detach();
+      this.disconnectWebAudio();
+    } else {
+      detached = super.detach(element);
+      // if there are still any attached elements after detaching, connect webaudio to the first element that's left
+      // disconnect webaudio otherwise
       if (this.audioContext) {
         if (this.attachedElements.length > 0) {
           this.connectWebAudio(this.audioContext, this.attachedElements[0]);
@@ -26726,7 +27129,7 @@ class Participant extends eventsExports.EventEmitter {
   });
 }class LocalParticipant extends Participant {
   /** @internal */
-  constructor(sid, identity, engine, options, roomRpcHandlers, roomOutgoingDataStreamManager, roomOutgoingDataTrackManager) {
+  constructor(sid, identity, engine, options, roomOutgoingDataStreamManager, roomOutgoingDataTrackManager, rpcClientManager, rpcServerManager) {
     super(sid, identity, undefined, undefined, undefined, {
       loggerName: options.loggerName,
       loggerContextCb: () => this.engine.logContext
@@ -26738,8 +27141,6 @@ class Participant extends eventsExports.EventEmitter {
     this.encryptionType = Encryption_Type.NONE;
     this.e2eeStateMutex = new _();
     this.enabledPublishVideoCodecs = [];
-    this.pendingAcks = new Map();
-    this.pendingResponses = new Map();
     this.handleReconnecting = () => {
       if (!this.reconnectFuture) {
         this.reconnectFuture = new Future();
@@ -26820,25 +27221,6 @@ class Participant extends eventsExports.EventEmitter {
           }
       }
     };
-    this.handleDataPacket = packet => {
-      switch (packet.value.case) {
-        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', {
         allParticipantsAllowed: this.allParticipantsAllowedToSubscribe,
@@ -26988,9 +27370,10 @@ class Participant extends eventsExports.EventEmitter {
     this.setupEngine(engine);
     this.activeDeviceMap = new Map([['audioinput', 'default'], ['videoinput', 'default'], ['audiooutput', 'default']]);
     this.pendingSignalRequests = new Map();
-    this.rpcHandlers = roomRpcHandlers;
     this.roomOutgoingDataStreamManager = roomOutgoingDataStreamManager;
     this.roomOutgoingDataTrackManager = roomOutgoingDataTrackManager;
+    this.rpcClientManager = rpcClientManager;
+    this.rpcServerManager = rpcServerManager;
   }
   get lastCameraError() {
     return this.cameraError;
@@ -27033,7 +27416,7 @@ class Participant extends eventsExports.EventEmitter {
     if ((_a = this.signalConnectedFuture) === null || _a === void 0 ? void 0 : _a.isResolved) {
       this.signalConnectedFuture = undefined;
     }
-    this.engine.on(EngineEvent.Connected, this.handleReconnected).on(EngineEvent.SignalConnected, this.handleSignalConnected).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.Closing, this.handleClosing).on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse).on(EngineEvent.DataPacketReceived, this.handleDataPacket);
+    this.engine.on(EngineEvent.Connected, this.handleReconnected).on(EngineEvent.SignalConnected, this.handleSignalConnected).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.Closing, this.handleClosing).on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse);
   }
   /**
    * Sets and updates the metadata of the local participant.
@@ -28336,76 +28719,23 @@ class Participant extends eventsExports.EventEmitter {
    * @returns A promise that resolves with the response payload or rejects with an error.
    * @throws Error on failure. Details in `message`.
    */
-  performRpc(_ref3) {
-    let {
-      destinationIdentity,
-      method,
-      payload,
-      responseTimeout = 15000
-    } = _ref3;
-    const maxRoundTripLatency = 7000;
-    const minEffectiveTimeout = maxRoundTripLatency + 1000;
-    return new TypedPromise((resolve, reject) => __awaiter(this, 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 effectiveTimeout = Math.max(responseTimeout, minEffectiveTimeout);
-      const id = crypto.randomUUID();
-      yield this.publishRpcRequest(destinationIdentity, id, method, payload, effectiveTimeout);
-      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)) {
-            this.log.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
-      });
-    }));
+  performRpc(params) {
+    return this.rpcClientManager.performRpc(params).then(_ref3 => {
+      let [_id, completionPromise] = _ref3;
+      return completionPromise;
+    });
   }
   /**
    * @deprecated use `room.registerRpcMethod` instead
    */
   registerRpcMethod(method, handler) {
-    if (this.rpcHandlers.has(method)) {
-      this.log.warn("you're overriding the RPC handler for method ".concat(method, ", in the future this will throw an error"));
-    }
-    this.rpcHandlers.set(method, handler);
+    this.rpcServerManager.registerRpcMethod(method, handler);
   }
   /**
    * @deprecated use `room.unregisterRpcMethod` instead
    */
   unregisterRpcMethod(method) {
-    this.rpcHandlers.delete(method);
+    this.rpcServerManager.unregisterRpcMethod(method);
   }
   /**
    * Control who can subscribe to LocalParticipant's published tracks.
@@ -28432,63 +28762,6 @@ class Participant extends eventsExports.EventEmitter {
       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);
-    }
-  }
-  /** @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, DataChannelKind.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');
@@ -28955,7 +29228,7 @@ class DeferrableMap extends Map {
       return new RemoteDataTrack(info, manager, {
         publisherIdentity: pi.identity
       });
-    }));
+    }), pi.clientProtocol);
   }
   get logContext() {
     return Object.assign(Object.assign({}, super.logContext), {
@@ -28967,6 +29240,7 @@ class DeferrableMap extends Map {
   constructor(signalClient, sid, identity, name, metadata, attributes, loggerOptions) {
     let kind = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : ParticipantInfo_Kind.STANDARD;
     let remoteDataTracks = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : [];
+    let clientProtocol = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : CLIENT_PROTOCOL_DEFAULT;
     super(sid, identity || '', name, metadata, attributes, loggerOptions, kind);
     this.signalClient = signalClient;
     this.trackPublications = new Map();
@@ -28976,6 +29250,7 @@ class DeferrableMap extends Map {
       return [remoteDataTrack.info.name, remoteDataTrack];
     }));
     this.volumeMap = new Map();
+    this.clientProtocol = clientProtocol;
   }
   addTrackPublication(publication) {
     super.addTrackPublication(publication);
@@ -29277,7 +29552,6 @@ class Room extends eventsExports.EventEmitter {
     this.log = livekitLogger;
     this.bufferedEvents = [];
     this.isResuming = false;
-    this.rpcHandlers = new Map();
     this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       var _a;
       if (!isBrowserSupported()) {
@@ -29834,7 +30108,22 @@ class Room extends eventsExports.EventEmitter {
         this.handleDataStream(packet, encryptionType);
       } else if (packet.value.case === 'rpcRequest') {
         const rpc = packet.value.value;
-        this.handleIncomingRpcRequest(packet.participantIdentity, rpc.id, rpc.method, rpc.payload, rpc.responseTimeoutMs, rpc.version);
+        this.rpcServerManager.handleIncomingRpcRequest(packet.participantIdentity, rpc);
+      } else if (packet.value.case === 'rpcResponse') {
+        const rpcResponse = packet.value.value;
+        switch (rpcResponse.value.case) {
+          case 'payload':
+            this.rpcClientManager.handleIncomingRpcResponseSuccess(rpcResponse.requestId, rpcResponse.value.value);
+            break;
+          case 'error':
+            this.rpcClientManager.handleIncomingRpcResponseFailure(rpcResponse.requestId, RpcError.fromProto(rpcResponse.value.value));
+            break;
+          default:
+            this.log.warn("Unknown rpcResponse.value.case: ".concat(rpcResponse.value.case), this.logContext);
+            break;
+        }
+      } else if (packet.value.case === 'rpcAck') {
+        this.rpcClientManager.handleIncomingRpcAck(packet.value.value.requestId);
       }
     };
     this.handleUserPacket = (participant, userPacket, kind, encryptionType) => {
@@ -29926,6 +30215,10 @@ class Room extends eventsExports.EventEmitter {
         }
       });
     };
+    this.getRemoteParticipantClientProtocol = identity => {
+      var _a, _b;
+      return (_b = (_a = this.remoteParticipants.get(identity)) === null || _a === void 0 ? void 0 : _a.clientProtocol) !== null && _b !== void 0 ? _b : CLIENT_PROTOCOL_DEFAULT;
+    };
     this.onLocalParticipantMetadataChanged = metadata => {
       this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
     };
@@ -30043,8 +30336,28 @@ class Room extends eventsExports.EventEmitter {
       } = _ref;
       this.engine.sendLossyBytes(bytes, DataChannelKind.DATA_TRACK_LOSSY, 'wait').finally(() => this.outgoingDataTrackManager.handlePacketSendComplete(handle));
     });
+    this.registerRpcDataStreamHandler();
+    this.rpcClientManager = new RpcClientManager(this.log, this.outgoingDataStreamManager, this.getRemoteParticipantClientProtocol, () => {
+      var _a, _b;
+      return (_b = (_a = this.engine.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.serverInfo) === null || _b === void 0 ? void 0 : _b.version;
+    });
+    this.rpcClientManager.on('sendDataPacket', _ref2 => {
+      let {
+        packet
+      } = _ref2;
+      var _a;
+      (_a = this.engine) === null || _a === void 0 ? void 0 : _a.sendDataPacket(packet, DataChannelKind.RELIABLE);
+    });
+    this.rpcServerManager = new RpcServerManager(this.log, this.outgoingDataStreamManager, this.getRemoteParticipantClientProtocol);
+    this.rpcServerManager.on('sendDataPacket', _ref3 => {
+      let {
+        packet
+      } = _ref3;
+      var _a;
+      (_a = this.engine) === null || _a === void 0 ? void 0 : _a.sendDataPacket(packet, DataChannelKind.RELIABLE);
+    });
     this.disconnectLock = new _();
-    this.localParticipant = new LocalParticipant('', '', this.engine, this.options, this.rpcHandlers, this.outgoingDataStreamManager, this.outgoingDataTrackManager);
+    this.localParticipant = new LocalParticipant('', '', this.engine, this.options, this.outgoingDataStreamManager, this.outgoingDataTrackManager, this.rpcClientManager, this.rpcServerManager);
     this.setupPacketTrailer();
     if (this.options.e2ee || this.options.encryption) {
       this.setupE2EE();
@@ -30062,16 +30375,32 @@ class Room extends eventsExports.EventEmitter {
       this.switchActiveDevice('audiooutput', unwrapConstraint(this.options.audioOutput.deviceId)).catch(e => this.log.warn("Could not set audio output: ".concat(e.message)));
     }
     if (isWeb()) {
-      const abortController = new AbortController();
-      // in order to catch device changes prior to room connection we need to register the event in the constructor
-      (_f = (_e = navigator.mediaDevices) === null || _e === void 0 ? void 0 : _e.addEventListener) === null || _f === void 0 ? void 0 : _f.call(_e, 'devicechange', this.handleDeviceChange, {
-        signal: abortController.signal
-      });
+      const cleanupController = new AbortController();
+      let onDeviceChange;
       if (Room.cleanupRegistry) {
+        // Wrap the listener in a WeakRef closure so navigator.mediaDevices does not
+        // strongly retain the Room. When the user drops their Room ref, the
+        // FinalizationRegistry callback aborts the controller and removes the listener.
+        const roomRef = new WeakRef(this);
+        onDeviceChange = () => {
+          const self = roomRef.deref();
+          if (!self) {
+            return;
+          }
+          self.handleDeviceChange();
+        };
         Room.cleanupRegistry.register(this, () => {
-          abortController.abort();
+          cleanupController.abort();
         });
+      } else {
+        // Legacy browsers without WeakRef/FinalizationRegistry: fall back to a
+        // direct listener (matches pre-#1944 behavior).
+        onDeviceChange = this.handleDeviceChange;
       }
+      // in order to catch device changes prior to room connection we need to register the event in the constructor
+      (_f = (_e = navigator.mediaDevices) === null || _e === void 0 ? void 0 : _e.addEventListener) === null || _f === void 0 ? void 0 : _f.call(_e, 'devicechange', onDeviceChange, {
+        signal: cleanupController.signal
+      });
     }
   }
   registerTextStreamHandler(topic, callback) {
@@ -30113,10 +30442,7 @@ class Room extends eventsExports.EventEmitter {
    * 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) {
-    if (this.rpcHandlers.has(method)) {
-      throw Error("RPC handler already registered for method ".concat(method, ", unregisterRpcMethod before trying to register again"));
-    }
-    this.rpcHandlers.set(method, handler);
+    this.rpcServerManager.registerRpcMethod(method, handler);
   }
   /**
    * Unregisters a previously registered RPC method.
@@ -30124,7 +30450,7 @@ class Room extends eventsExports.EventEmitter {
    * @param method - The name of the RPC method to unregister
    */
   unregisterRpcMethod(method) {
-    this.rpcHandlers.delete(method);
+    this.rpcServerManager.unregisterRpcMethod(method);
   }
   /**
    * @experimental
@@ -30313,8 +30639,8 @@ class Room extends eventsExports.EventEmitter {
       }
       this.outgoingDataTrackManager.receivedSfuUnpublishResponse(event.info.pubHandle);
     }).on(EngineEvent.DataTrackSubscriberHandles, event => {
-      const handleToSidMapping = new Map(Object.entries(event.subHandles).map(_ref2 => {
-        let [key, value] = _ref2;
+      const handleToSidMapping = new Map(Object.entries(event.subHandles).map(_ref4 => {
+        let [key, value] = _ref4;
         return [parseInt(key, 10), value.trackSid];
       }));
       this.incomingDataTrackManager.receivedSfuSubscriberHandles(handleToSidMapping);
@@ -30768,10 +31094,10 @@ class Room extends eventsExports.EventEmitter {
     }
   }
   handleLocalTrackSubscribed(subscribedSid) {
-    const findPublication = () => this.localParticipant.getTrackPublications().find(_ref3 => {
+    const findPublication = () => this.localParticipant.getTrackPublications().find(_ref5 => {
       let {
         trackSid
-      } = _ref3;
+      } = _ref5;
       return trackSid === subscribedSid;
     });
     const trackPublication = findPublication();
@@ -30877,7 +31203,6 @@ class Room extends eventsExports.EventEmitter {
     }
   }
   handleParticipantDisconnected(identity, participant) {
-    var _a;
     // remove and send event
     this.remoteParticipants.delete(identity);
     if (!participant) {
@@ -30890,45 +31215,7 @@ class Room extends eventsExports.EventEmitter {
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
     participant.setDisconnected();
-    (_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.handleParticipantDisconnected(participant.identity);
-  }
-  handleIncomingRpcRequest(callerIdentity, requestId, method, payload, responseTimeout, version) {
-    return __awaiter(this, void 0, void 0, function* () {
-      yield this.engine.publishRpcAck(callerIdentity, requestId);
-      if (version !== 1) {
-        yield this.engine.publishRpcResponse(callerIdentity, requestId, null, RpcError.builtIn('UNSUPPORTED_VERSION'));
-        return;
-      }
-      const handler = this.rpcHandlers.get(method);
-      if (!handler) {
-        yield this.engine.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');
-          this.log.warn("RPC Response payload too large for ".concat(method));
-        } else {
-          responsePayload = response;
-        }
-      } catch (error) {
-        if (error instanceof RpcError) {
-          responseError = error;
-        } else {
-          this.log.warn("Uncaught error returned by RPC handler for ".concat(method, ". Returning APPLICATION_ERROR instead."), error);
-          responseError = RpcError.builtIn('APPLICATION_ERROR');
-        }
-      }
-      yield this.engine.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
-    });
+    this.rpcClientManager.handleParticipantDisconnected(participant.identity);
   }
   /**
    * attempt to select the default devices if the previously selected devices are no longer available after a device change event
@@ -31134,6 +31421,30 @@ class Room extends eventsExports.EventEmitter {
       return this.remoteParticipants.get(identity);
     }
   }
+  registerRpcDataStreamHandler() {
+    this.incomingDataStreamManager.registerTextStreamHandler(RPC_REQUEST_DATA_STREAM_TOPIC, (reader_1, _a) => __awaiter(this, [reader_1, _a], void 0, function (reader, _ref6) {
+      var _this4 = this;
+      let {
+        identity
+      } = _ref6;
+      return function* () {
+        var _b;
+        const attributes = (_b = reader.info.attributes) !== null && _b !== void 0 ? _b : {};
+        yield _this4.rpcServerManager.handleIncomingDataStream(reader, identity, attributes);
+      }();
+    }));
+    this.incomingDataStreamManager.registerTextStreamHandler(RPC_RESPONSE_DATA_STREAM_TOPIC, (reader_1, _a) => __awaiter(this, [reader_1, _a], void 0, function (reader, _ref7) {
+      var _this5 = this;
+      let {
+        identity
+      } = _ref7;
+      return function* () {
+        var _b;
+        const attributes = (_b = reader.info.attributes) !== null && _b !== void 0 ? _b : {};
+        yield _this5.rpcClientManager.handleIncomingDataStream(reader, identity, attributes);
+      }();
+    }));
+  }
   registerConnectionReconcile() {
     this.clearConnectionReconcile();
     let consecutiveFailures = 0;
@@ -31179,8 +31490,8 @@ class Room extends eventsExports.EventEmitter {
     return true;
   }
   emitBufferedEvents() {
-    this.bufferedEvents.forEach(_ref4 => {
-      let [ev, args] = _ref4;
+    this.bufferedEvents.forEach(_ref8 => {
+      let [ev, args] = _ref8;
       this.emit(ev, ...args);
     });
     this.bufferedEvents = [];
@@ -31331,7 +31642,7 @@ class Room extends eventsExports.EventEmitter {
     return super.emit(event, ...args);
   }
 }
-Room.cleanupRegistry = typeof FinalizationRegistry !== 'undefined' && new FinalizationRegistry(cleanup => {
+Room.cleanupRegistry = typeof FinalizationRegistry !== 'undefined' && typeof WeakRef !== 'undefined' && new FinalizationRegistry(cleanup => {
   cleanup();
 });
 function mapArgs(args) {
@@ -32766,4 +33077,4 @@ const serializers = {
   json,
   raw,
   custom
-};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map
+};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CLIENT_PROTOCOL_DATA_STREAM_RPC,CLIENT_PROTOCOL_DEFAULT,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,clientProtocol,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map