livekit-client 2.15.3 → 2.15.5

package/dist/livekit-client.esm.mjs

@@ -10617,6 +10617,30 @@ class SignalRequestError extends LivekitError {
     this.reasonName = typeof reason === 'string' ? reason : RequestResponse_Reason[reason];
   }
 }
+// NOTE: matches with https://github.com/livekit/client-sdk-swift/blob/f37bbd260d61e165084962db822c79f995f1a113/Sources/LiveKit/DataStream/StreamError.swift#L17
+var DataStreamErrorReason;
+(function (DataStreamErrorReason) {
+  // Unable to open a stream with the same ID more than once.
+  DataStreamErrorReason[DataStreamErrorReason["AlreadyOpened"] = 0] = "AlreadyOpened";
+  // Stream closed abnormally by remote participant.
+  DataStreamErrorReason[DataStreamErrorReason["AbnormalEnd"] = 1] = "AbnormalEnd";
+  // Incoming chunk data could not be decoded.
+  DataStreamErrorReason[DataStreamErrorReason["DecodeFailed"] = 2] = "DecodeFailed";
+  // Read length exceeded total length specified in stream header.
+  DataStreamErrorReason[DataStreamErrorReason["LengthExceeded"] = 3] = "LengthExceeded";
+  // Read length less than total length specified in stream header.
+  DataStreamErrorReason[DataStreamErrorReason["Incomplete"] = 4] = "Incomplete";
+  // Unable to register a stream handler more than once.
+  DataStreamErrorReason[DataStreamErrorReason["HandlerAlreadyRegistered"] = 7] = "HandlerAlreadyRegistered";
+})(DataStreamErrorReason || (DataStreamErrorReason = {}));
+class DataStreamError extends LivekitError {
+  constructor(message, reason) {
+    super(16, message);
+    this.name = 'DataStreamError';
+    this.reason = reason;
+    this.reasonName = DataStreamErrorReason[reason];
+  }
+}
 var MediaDeviceFailure;
 (function (MediaDeviceFailure) {
   // user rejected permissions
@@ -11364,7 +11388,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.15.3";
+var version$1 = "2.15.5";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -11956,7 +11980,7 @@ function isSVCCodec(codec) {
   return codec === 'av1' || codec === 'vp9';
 }
 function supportsSetSinkId(elm) {
-  if (!document) {
+  if (!document || isSafariBased()) {
     return false;
   }
   if (!elm) {
@@ -12246,13 +12270,13 @@ function unwrapConstraint(constraint) {
   if (Array.isArray(constraint)) {
     return constraint[0];
   }
-  if (constraint.exact) {
+  if (constraint.exact !== undefined) {
     if (Array.isArray(constraint.exact)) {
       return constraint.exact[0];
     }
     return constraint.exact;
   }
-  if (constraint.ideal) {
+  if (constraint.ideal !== undefined) {
     if (Array.isArray(constraint.ideal)) {
       return constraint.ideal[0];
     }
@@ -13639,6 +13663,12 @@ class SignalClient {
         if (_this3.signalLatency) {
           yield sleep(_this3.signalLatency);
         }
+        if (_this3.isDisconnected) {
+          // Skip requests if the signal layer is disconnected
+          // This can happen if an event is sent in the mist of room.connect() initializing
+          _this3.log.debug("skipping signal request (type: ".concat(message.case, ") - SignalClient disconnected"));
+          return;
+        }
         if (!_this3.ws || _this3.ws.readyState !== _this3.ws.OPEN) {
           _this3.log.error("cannot send signal request before connected, type: ".concat(message === null || message === void 0 ? void 0 : message.case), _this3.logContext);
           return;
@@ -15844,11 +15874,21 @@ class LocalTrackRecorder extends RecorderBase {
       start: controller => {
         streamController = controller;
         dataListener = event => __awaiter(this, void 0, void 0, function* () {
-          const arrayBuffer = yield event.data.arrayBuffer();
+          let data;
+          if (event.data.arrayBuffer) {
+            const arrayBuffer = yield event.data.arrayBuffer();
+            data = new Uint8Array(arrayBuffer);
+            // @ts-expect-error react-native passes over Uint8Arrays directly
+          } else if (event.data.byteArray) {
+            // @ts-expect-error
+            data = event.data.byteArray;
+          } else {
+            throw new Error('no data available!');
+          }
           if (isClosed()) {
             return;
           }
-          controller.enqueue(new Uint8Array(arrayBuffer));
+          controller.enqueue(data);
         });
         this.addEventListener('dataavailable', dataListener);
       },
@@ -15915,9 +15955,14 @@ class LocalTrack extends Track {
     this.providedByUser = userProvidedTrack;
     this.muteLock = new _();
     this.pauseUpstreamLock = new _();
-    this.processorLock = new _();
-    this.restartLock = new _();
-    this.setMediaStreamTrack(mediaTrack, true);
+    this.trackChangeLock = new _();
+    this.trackChangeLock.lock().then(unlock => __awaiter(this, void 0, void 0, function* () {
+      try {
+        yield this.setMediaStreamTrack(mediaTrack, true);
+      } finally {
+        unlock();
+      }
+    }));
     // added to satisfy TS compiler, constraints are synced with MediaStreamTrack
     this._constraints = mediaTrack.getConstraints();
     if (constraints) {
@@ -15993,26 +16038,21 @@ class LocalTrack extends Track {
       }
       let processedTrack;
       if (this.processor && newTrack) {
-        const unlock = yield this.processorLock.lock();
-        try {
-          this.log.debug('restarting processor', this.logContext);
-          if (this.kind === 'unknown') {
-            throw TypeError('cannot set processor on track of unknown kind');
-          }
-          if (this.processorElement) {
-            attachToElement(newTrack, this.processorElement);
-            // ensure the processorElement itself stays muted
-            this.processorElement.muted = true;
-          }
-          yield this.processor.restart({
-            track: newTrack,
-            kind: this.kind,
-            element: this.processorElement
-          });
-          processedTrack = this.processor.processedTrack;
-        } finally {
-          unlock();
+        this.log.debug('restarting processor', this.logContext);
+        if (this.kind === 'unknown') {
+          throw TypeError('cannot set processor on track of unknown kind');
         }
+        if (this.processorElement) {
+          attachToElement(newTrack, this.processorElement);
+          // ensure the processorElement itself stays muted
+          this.processorElement.muted = true;
+        }
+        yield this.processor.restart({
+          track: newTrack,
+          kind: this.kind,
+          element: this.processorElement
+        });
+        processedTrack = this.processor.processedTrack;
       }
       if (this.sender && ((_a = this.sender.transport) === null || _a === void 0 ? void 0 : _a.state) !== 'closed') {
         yield this.sender.replaceTrack(processedTrack !== null && processedTrack !== void 0 ? processedTrack : newTrack);
@@ -16110,32 +16150,37 @@ class LocalTrack extends Track {
   }
   replaceTrack(track, userProvidedOrOptions) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (!this.sender) {
-        throw new TrackInvalidError('unable to replace an unpublished track');
-      }
-      let userProvidedTrack;
-      let stopProcessor;
-      if (typeof userProvidedOrOptions === 'boolean') {
-        userProvidedTrack = userProvidedOrOptions;
-      } else if (userProvidedOrOptions !== undefined) {
-        userProvidedTrack = userProvidedOrOptions.userProvidedTrack;
-        stopProcessor = userProvidedOrOptions.stopProcessor;
-      }
-      this.providedByUser = userProvidedTrack !== null && userProvidedTrack !== void 0 ? userProvidedTrack : true;
-      this.log.debug('replace MediaStreamTrack', this.logContext);
-      yield this.setMediaStreamTrack(track);
-      // this must be synced *after* setting mediaStreamTrack above, since it relies
-      // on the previous state in order to cleanup
-      if (stopProcessor && this.processor) {
-        yield this.stopProcessor();
+      const unlock = yield this.trackChangeLock.lock();
+      try {
+        if (!this.sender) {
+          throw new TrackInvalidError('unable to replace an unpublished track');
+        }
+        let userProvidedTrack;
+        let stopProcessor;
+        if (typeof userProvidedOrOptions === 'boolean') {
+          userProvidedTrack = userProvidedOrOptions;
+        } else if (userProvidedOrOptions !== undefined) {
+          userProvidedTrack = userProvidedOrOptions.userProvidedTrack;
+          stopProcessor = userProvidedOrOptions.stopProcessor;
+        }
+        this.providedByUser = userProvidedTrack !== null && userProvidedTrack !== void 0 ? userProvidedTrack : true;
+        this.log.debug('replace MediaStreamTrack', this.logContext);
+        yield this.setMediaStreamTrack(track);
+        // this must be synced *after* setting mediaStreamTrack above, since it relies
+        // on the previous state in order to cleanup
+        if (stopProcessor && this.processor) {
+          yield this.internalStopProcessor();
+        }
+        return this;
+      } finally {
+        unlock();
       }
-      return this;
     });
   }
   restart(constraints) {
     return __awaiter(this, void 0, void 0, function* () {
       this.manuallyStopped = false;
-      const unlock = yield this.restartLock.lock();
+      const unlock = yield this.trackChangeLock.lock();
       try {
         if (!constraints) {
           constraints = this._constraints;
@@ -16318,7 +16363,7 @@ class LocalTrack extends Track {
       let showProcessedStreamLocally = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
       return function* () {
         var _a;
-        const unlock = yield _this3.processorLock.lock();
+        const unlock = yield _this3.trackChangeLock.lock();
         try {
           _this3.log.debug('setting up processor', _this3.logContext);
           const processorElement = document.createElement(_this3.kind);
@@ -16331,7 +16376,7 @@ class LocalTrack extends Track {
           yield processor.init(processorOptions);
           _this3.log.debug('processor initialized', _this3.logContext);
           if (_this3.processor) {
-            yield _this3.stopProcessor();
+            yield _this3.internalStopProcessor();
           }
           if (_this3.kind === 'unknown') {
             throw TypeError('cannot set processor on track of unknown kind');
@@ -16389,22 +16434,41 @@ class LocalTrack extends Track {
     return __awaiter(this, arguments, void 0, function () {
       var _this4 = this;
       let keepElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return function* () {
+        const unlock = yield _this4.trackChangeLock.lock();
+        try {
+          yield _this4.internalStopProcessor(keepElement);
+        } finally {
+          unlock();
+        }
+      }();
+    });
+  }
+  /**
+   * @internal
+   * This method assumes the caller has acquired a trackChangeLock already.
+   * The public facing method for stopping the processor is `stopProcessor` and it wraps this method in the trackChangeLock.
+   */
+  internalStopProcessor() {
+    return __awaiter(this, arguments, void 0, function () {
+      var _this5 = this;
+      let keepElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       return function* () {
         var _a, _b;
-        if (!_this4.processor) return;
-        _this4.log.debug('stopping processor', _this4.logContext);
-        (_a = _this4.processor.processedTrack) === null || _a === void 0 ? void 0 : _a.stop();
-        yield _this4.processor.destroy();
-        _this4.processor = undefined;
+        if (!_this5.processor) return;
+        _this5.log.debug('stopping processor', _this5.logContext);
+        (_a = _this5.processor.processedTrack) === null || _a === void 0 ? void 0 : _a.stop();
+        yield _this5.processor.destroy();
+        _this5.processor = undefined;
         if (!keepElement) {
-          (_b = _this4.processorElement) === null || _b === void 0 ? void 0 : _b.remove();
-          _this4.processorElement = undefined;
+          (_b = _this5.processorElement) === null || _b === void 0 ? void 0 : _b.remove();
+          _this5.processorElement = undefined;
         }
         // apply original track constraints in case the processor changed them
-        yield _this4._mediaStreamTrack.applyConstraints(_this4._constraints);
+        yield _this5._mediaStreamTrack.applyConstraints(_this5._constraints);
         // force re-setting of the mediaStreamTrack on the sender
-        yield _this4.setMediaStreamTrack(_this4._mediaStreamTrack, true);
-        _this4.emit(TrackEvent.TrackProcessorUpdate);
+        yield _this5.setMediaStreamTrack(_this5._mediaStreamTrack, true);
+        _this5.emit(TrackEvent.TrackProcessorUpdate);
       }();
     });
   }
@@ -16416,8 +16480,13 @@ class LocalTrack extends Track {
       return;
     }
     if (!this.localTrackRecorder) {
+      let mimeType = 'audio/webm;codecs=opus';
+      if (!MediaRecorder.isTypeSupported(mimeType)) {
+        // iOS currently only supports video/mp4 as a mime type - even for audio.
+        mimeType = 'video/mp4';
+      }
       this.localTrackRecorder = new LocalTrackRecorder(this, {
-        mimeType: 'audio/webm;codecs=opus'
+        mimeType
       });
     } else {
       this.log.warn('preconnect buffer already started');
@@ -16442,6 +16511,10 @@ class LocalTrack extends Track {
     var _a;
     return (_a = this.localTrackRecorder) === null || _a === void 0 ? void 0 : _a.byteStream;
   }
+  getPreConnectBufferMimeType() {
+    var _a;
+    return (_a = this.localTrackRecorder) === null || _a === void 0 ? void 0 : _a.mimeType;
+  }
 }
 
 class LocalAudioTrack extends LocalTrack {
@@ -16589,13 +16662,13 @@ class LocalAudioTrack extends LocalTrack {
   setProcessor(processor) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const unlock = yield this.processorLock.lock();
+      const unlock = yield this.trackChangeLock.lock();
       try {
         if (!isReactNative() && !this.audioContext) {
           throw Error('Audio context needs to be set on LocalAudioTrack in order to enable processors');
         }
         if (this.processor) {
-          yield this.stopProcessor();
+          yield this.internalStopProcessor();
         }
         const processorOptions = {
           kind: this.kind,
@@ -18979,30 +19052,71 @@ class BaseStreamReader {
   get info() {
     return this._info;
   }
-  constructor(info, stream, totalByteSize) {
+  /** @internal */
+  validateBytesReceived() {
+    let doneReceiving = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    if (typeof this.totalByteSize !== 'number' || this.totalByteSize === 0) {
+      return;
+    }
+    if (doneReceiving && this.bytesReceived < this.totalByteSize) {
+      throw new DataStreamError("Not enough chunk(s) received - expected ".concat(this.totalByteSize, " bytes of data total, only received ").concat(this.bytesReceived, " bytes"), DataStreamErrorReason.Incomplete);
+    } else if (this.bytesReceived > this.totalByteSize) {
+      throw new DataStreamError("Extra chunk(s) received - expected ".concat(this.totalByteSize, " bytes of data total, received ").concat(this.bytesReceived, " bytes"), DataStreamErrorReason.LengthExceeded);
+    }
+  }
+  constructor(info, stream, totalByteSize, outOfBandFailureRejectingFuture) {
     this.reader = stream;
     this.totalByteSize = totalByteSize;
     this._info = info;
     this.bytesReceived = 0;
+    this.outOfBandFailureRejectingFuture = outOfBandFailureRejectingFuture;
   }
 }
 class ByteStreamReader extends BaseStreamReader {
   handleChunkReceived(chunk) {
     var _a;
     this.bytesReceived += chunk.content.byteLength;
+    this.validateBytesReceived();
     const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : undefined;
     (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, currentProgress);
   }
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
+    let rejectingSignalFuture = new Future();
+    let activeSignal = null;
+    let onAbort = null;
+    if (this.signal) {
+      const signal = this.signal;
+      onAbort = () => {
+        var _a;
+        (_a = rejectingSignalFuture.reject) === null || _a === void 0 ? void 0 : _a.call(rejectingSignalFuture, signal.reason);
+      };
+      signal.addEventListener('abort', onAbort);
+      activeSignal = signal;
+    }
+    const cleanup = () => {
+      reader.releaseLock();
+      if (activeSignal && onAbort) {
+        activeSignal.removeEventListener('abort', onAbort);
+      }
+      this.signal = undefined;
+    };
     return {
       next: () => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         try {
           const {
             done,
             value
-          } = yield reader.read();
+          } = yield Promise.race([reader.read(),
+          // Rejects if this.signal is aborted
+          rejectingSignalFuture.promise,
+          // Rejects if something external says it should, like a participant disconnecting, etc
+          (_b = (_a = this.outOfBandFailureRejectingFuture) === null || _a === void 0 ? void 0 : _a.promise) !== null && _b !== void 0 ? _b : new Promise(() => {
+            /* never resolves */
+          })]);
           if (done) {
+            this.validateBytesReceived(true);
             return {
               done: true,
               value: undefined
@@ -19014,17 +19128,16 @@ class ByteStreamReader extends BaseStreamReader {
               value: value.content
             };
           }
-        } catch (error) {
-          // TODO handle errors
-          return {
-            done: true,
-            value: undefined
-          };
+        } catch (err) {
+          cleanup();
+          throw err;
         }
       }),
+      // note: `return` runs only for premature exits, see:
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#errors_during_iteration
       return() {
         return __awaiter(this, void 0, void 0, function* () {
-          reader.releaseLock();
+          cleanup();
           return {
             done: true,
             value: undefined
@@ -19033,29 +19146,45 @@ class ByteStreamReader extends BaseStreamReader {
       }
     };
   }
+  /**
+   * Injects an AbortSignal, which if aborted, will terminate the currently active
+   * stream iteration operation.
+   *
+   * Note that when using AbortSignal.timeout(...), the timeout applies across
+   * the whole iteration operation, not just one individual chunk read.
+   */
+  withAbortSignal(signal) {
+    this.signal = signal;
+    return this;
+  }
   readAll() {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, e_1, _b, _c;
-      let chunks = new Set();
-      try {
-        for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-          _c = _f.value;
-          _d = false;
-          const chunk = _c;
-          chunks.add(chunk);
-        }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
+    return __awaiter(this, arguments, void 0, function () {
+      var _this = this;
+      let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return function* () {
+        var _a, e_1, _b, _c;
+        let chunks = new Set();
+        const iterator = opts.signal ? _this.withAbortSignal(opts.signal) : _this;
         try {
-          if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+          for (var _d = true, iterator_1 = __asyncValues(iterator), iterator_1_1; iterator_1_1 = yield iterator_1.next(), _a = iterator_1_1.done, !_a; _d = true) {
+            _c = iterator_1_1.value;
+            _d = false;
+            const chunk = _c;
+            chunks.add(chunk);
+          }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
         } finally {
-          if (e_1) throw e_1.error;
+          try {
+            if (!_d && !_a && (_b = iterator_1.return)) yield _b.call(iterator_1);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
         }
-      }
-      return Array.from(chunks);
+        return Array.from(chunks);
+      }();
     });
   }
 }
@@ -19067,8 +19196,8 @@ class TextStreamReader extends BaseStreamReader {
    * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
    * that has been received up to the current point in time.
    */
-  constructor(info, stream, totalChunkCount) {
-    super(info, stream, totalChunkCount);
+  constructor(info, stream, totalChunkCount, outOfBandFailureRejectingFuture) {
+    super(info, stream, totalChunkCount, outOfBandFailureRejectingFuture);
     this.receivedChunks = new Map();
   }
   handleChunkReceived(chunk) {
@@ -19081,6 +19210,7 @@ class TextStreamReader extends BaseStreamReader {
     }
     this.receivedChunks.set(index, chunk);
     this.bytesReceived += chunk.content.byteLength;
+    this.validateBytesReceived();
     const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : undefined;
     (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, currentProgress);
   }
@@ -19091,37 +19221,71 @@ class TextStreamReader extends BaseStreamReader {
    */
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
-    const decoder = new TextDecoder();
+    const decoder = new TextDecoder('utf-8', {
+      fatal: true
+    });
+    let rejectingSignalFuture = new Future();
+    let activeSignal = null;
+    let onAbort = null;
+    if (this.signal) {
+      const signal = this.signal;
+      onAbort = () => {
+        var _a;
+        (_a = rejectingSignalFuture.reject) === null || _a === void 0 ? void 0 : _a.call(rejectingSignalFuture, signal.reason);
+      };
+      signal.addEventListener('abort', onAbort);
+      activeSignal = signal;
+    }
+    const cleanup = () => {
+      reader.releaseLock();
+      if (activeSignal && onAbort) {
+        activeSignal.removeEventListener('abort', onAbort);
+      }
+      this.signal = undefined;
+    };
     return {
       next: () => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         try {
           const {
             done,
             value
-          } = yield reader.read();
+          } = yield Promise.race([reader.read(),
+          // Rejects if this.signal is aborted
+          rejectingSignalFuture.promise,
+          // Rejects if something external says it should, like a participant disconnecting, etc
+          (_b = (_a = this.outOfBandFailureRejectingFuture) === null || _a === void 0 ? void 0 : _a.promise) !== null && _b !== void 0 ? _b : new Promise(() => {
+            /* never resolves */
+          })]);
           if (done) {
+            this.validateBytesReceived(true);
             return {
               done: true,
               value: undefined
             };
           } else {
             this.handleChunkReceived(value);
+            let decodedResult;
+            try {
+              decodedResult = decoder.decode(value.content);
+            } catch (err) {
+              throw new DataStreamError("Cannot decode datastream chunk ".concat(value.chunkIndex, " as text: ").concat(err), DataStreamErrorReason.DecodeFailed);
+            }
             return {
               done: false,
-              value: decoder.decode(value.content)
+              value: decodedResult
             };
           }
-        } catch (error) {
-          // TODO handle errors
-          return {
-            done: true,
-            value: undefined
-          };
+        } catch (err) {
+          cleanup();
+          throw err;
         }
       }),
+      // note: `return` runs only for premature exits, see:
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#errors_during_iteration
       return() {
         return __awaiter(this, void 0, void 0, function* () {
-          reader.releaseLock();
+          cleanup();
           return {
             done: true,
             value: undefined
@@ -19130,31 +19294,217 @@ class TextStreamReader extends BaseStreamReader {
       }
     };
   }
+  /**
+   * Injects an AbortSignal, which if aborted, will terminate the currently active
+   * stream iteration operation.
+   *
+   * Note that when using AbortSignal.timeout(...), the timeout applies across
+   * the whole iteration operation, not just one individual chunk read.
+   */
+  withAbortSignal(signal) {
+    this.signal = signal;
+    return this;
+  }
   readAll() {
+    return __awaiter(this, arguments, void 0, function () {
+      var _this2 = this;
+      let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return function* () {
+        var _a, e_2, _b, _c;
+        let finalString = '';
+        const iterator = opts.signal ? _this2.withAbortSignal(opts.signal) : _this2;
+        try {
+          for (var _d = true, iterator_2 = __asyncValues(iterator), iterator_2_1; iterator_2_1 = yield iterator_2.next(), _a = iterator_2_1.done, !_a; _d = true) {
+            _c = iterator_2_1.value;
+            _d = false;
+            const chunk = _c;
+            finalString += chunk;
+          }
+        } catch (e_2_1) {
+          e_2 = {
+            error: e_2_1
+          };
+        } finally {
+          try {
+            if (!_d && !_a && (_b = iterator_2.return)) yield _b.call(iterator_2);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+        return finalString;
+      }();
+    });
+  }
+}
+
+class IncomingDataStreamManager {
+  constructor() {
+    this.log = livekitLogger;
+    this.byteStreamControllers = new Map();
+    this.textStreamControllers = new Map();
+    this.byteStreamHandlers = new Map();
+    this.textStreamHandlers = new Map();
+  }
+  registerTextStreamHandler(topic, callback) {
+    if (this.textStreamHandlers.has(topic)) {
+      throw new DataStreamError("A text stream handler for topic \"".concat(topic, "\" has already been set."), DataStreamErrorReason.HandlerAlreadyRegistered);
+    }
+    this.textStreamHandlers.set(topic, callback);
+  }
+  unregisterTextStreamHandler(topic) {
+    this.textStreamHandlers.delete(topic);
+  }
+  registerByteStreamHandler(topic, callback) {
+    if (this.byteStreamHandlers.has(topic)) {
+      throw new DataStreamError("A byte stream handler for topic \"".concat(topic, "\" has already been set."), DataStreamErrorReason.HandlerAlreadyRegistered);
+    }
+    this.byteStreamHandlers.set(topic, callback);
+  }
+  unregisterByteStreamHandler(topic) {
+    this.byteStreamHandlers.delete(topic);
+  }
+  clearHandlersAndControllers() {
+    this.byteStreamControllers.clear();
+    this.textStreamControllers.clear();
+    this.byteStreamHandlers.clear();
+    this.textStreamHandlers.clear();
+  }
+  validateParticipantHasNoActiveDataStreams(participantIdentity) {
+    var _a, _b, _c, _d;
+    // Terminate any in flight data stream receives from the given participant
+    const textStreamsBeingSentByDisconnectingParticipant = Array.from(this.textStreamControllers.entries()).filter(entry => entry[1].sendingParticipantIdentity === participantIdentity);
+    const byteStreamsBeingSentByDisconnectingParticipant = Array.from(this.byteStreamControllers.entries()).filter(entry => entry[1].sendingParticipantIdentity === participantIdentity);
+    if (textStreamsBeingSentByDisconnectingParticipant.length > 0 || byteStreamsBeingSentByDisconnectingParticipant.length > 0) {
+      const abnormalEndError = new DataStreamError("Participant ".concat(participantIdentity, " unexpectedly disconnected in the middle of sending data"), DataStreamErrorReason.AbnormalEnd);
+      for (const [id, controller] of byteStreamsBeingSentByDisconnectingParticipant) {
+        (_b = (_a = controller.outOfBandFailureRejectingFuture).reject) === null || _b === void 0 ? void 0 : _b.call(_a, abnormalEndError);
+        this.byteStreamControllers.delete(id);
+      }
+      for (const [id, controller] of textStreamsBeingSentByDisconnectingParticipant) {
+        (_d = (_c = controller.outOfBandFailureRejectingFuture).reject) === null || _d === void 0 ? void 0 : _d.call(_c, abnormalEndError);
+        this.textStreamControllers.delete(id);
+      }
+    }
+  }
+  handleDataStreamPacket(packet) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, e_2, _b, _c;
-      let finalString = '';
-      try {
-        for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-          _c = _f.value;
-          _d = false;
-          const chunk = _c;
-          finalString += chunk;
+      switch (packet.value.case) {
+        case 'streamHeader':
+          return this.handleStreamHeader(packet.value.value, packet.participantIdentity);
+        case 'streamChunk':
+          return this.handleStreamChunk(packet.value.value);
+        case 'streamTrailer':
+          return this.handleStreamTrailer(packet.value.value);
+        default:
+          throw new Error("DataPacket of value \"".concat(packet.value.case, "\" is not data stream related!"));
+      }
+    });
+  }
+  handleStreamHeader(streamHeader, participantIdentity) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      if (streamHeader.contentHeader.case === 'byteHeader') {
+        const streamHandlerCallback = this.byteStreamHandlers.get(streamHeader.topic);
+        if (!streamHandlerCallback) {
+          this.log.debug('ignoring incoming byte stream due to no handler for topic', streamHeader.topic);
+          return;
         }
-      } catch (e_2_1) {
-        e_2 = {
-          error: e_2_1
+        let streamController;
+        const outOfBandFailureRejectingFuture = new Future();
+        const info = {
+          id: streamHeader.streamId,
+          name: (_a = streamHeader.contentHeader.value.name) !== null && _a !== void 0 ? _a : 'unknown',
+          mimeType: streamHeader.mimeType,
+          size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
+          topic: streamHeader.topic,
+          timestamp: bigIntToNumber(streamHeader.timestamp),
+          attributes: streamHeader.attributes
         };
-      } finally {
-        try {
-          if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-        } finally {
-          if (e_2) throw e_2.error;
+        const stream = new ReadableStream({
+          start: controller => {
+            streamController = controller;
+            if (this.textStreamControllers.has(streamHeader.streamId)) {
+              throw new DataStreamError("A data stream read is already in progress for a stream with id ".concat(streamHeader.streamId, "."), DataStreamErrorReason.AlreadyOpened);
+            }
+            this.byteStreamControllers.set(streamHeader.streamId, {
+              info,
+              controller: streamController,
+              startTime: Date.now(),
+              sendingParticipantIdentity: participantIdentity,
+              outOfBandFailureRejectingFuture
+            });
+          }
+        });
+        streamHandlerCallback(new ByteStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength), outOfBandFailureRejectingFuture), {
+          identity: participantIdentity
+        });
+      } else if (streamHeader.contentHeader.case === 'textHeader') {
+        const streamHandlerCallback = this.textStreamHandlers.get(streamHeader.topic);
+        if (!streamHandlerCallback) {
+          this.log.debug('ignoring incoming text stream due to no handler for topic', streamHeader.topic);
+          return;
         }
+        let streamController;
+        const outOfBandFailureRejectingFuture = new Future();
+        const info = {
+          id: streamHeader.streamId,
+          mimeType: streamHeader.mimeType,
+          size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
+          topic: streamHeader.topic,
+          timestamp: Number(streamHeader.timestamp),
+          attributes: streamHeader.attributes
+        };
+        const stream = new ReadableStream({
+          start: controller => {
+            streamController = controller;
+            if (this.textStreamControllers.has(streamHeader.streamId)) {
+              throw new DataStreamError("A data stream read is already in progress for a stream with id ".concat(streamHeader.streamId, "."), DataStreamErrorReason.AlreadyOpened);
+            }
+            this.textStreamControllers.set(streamHeader.streamId, {
+              info,
+              controller: streamController,
+              startTime: Date.now(),
+              sendingParticipantIdentity: participantIdentity,
+              outOfBandFailureRejectingFuture
+            });
+          }
+        });
+        streamHandlerCallback(new TextStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength), outOfBandFailureRejectingFuture), {
+          identity: participantIdentity
+        });
       }
-      return finalString;
     });
   }
+  handleStreamChunk(chunk) {
+    const fileBuffer = this.byteStreamControllers.get(chunk.streamId);
+    if (fileBuffer) {
+      if (chunk.content.length > 0) {
+        fileBuffer.controller.enqueue(chunk);
+      }
+    }
+    const textBuffer = this.textStreamControllers.get(chunk.streamId);
+    if (textBuffer) {
+      if (chunk.content.length > 0) {
+        textBuffer.controller.enqueue(chunk);
+      }
+    }
+  }
+  handleStreamTrailer(trailer) {
+    const textBuffer = this.textStreamControllers.get(trailer.streamId);
+    if (textBuffer) {
+      textBuffer.info.attributes = Object.assign(Object.assign({}, textBuffer.info.attributes), trailer.attributes);
+      textBuffer.controller.close();
+      this.textStreamControllers.delete(trailer.streamId);
+    }
+    const fileBuffer = this.byteStreamControllers.get(trailer.streamId);
+    if (fileBuffer) {
+      {
+        fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
+        fileBuffer.controller.close();
+        this.byteStreamControllers.delete(trailer.streamId);
+      }
+    }
+  }
 }
 
 class BaseStreamWriter {
@@ -19179,11 +19529,289 @@ class BaseStreamWriter {
 class TextStreamWriter extends BaseStreamWriter {}
 class ByteStreamWriter extends BaseStreamWriter {}
 
-class RemoteTrack extends Track {
-  constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
-    super(mediaTrack, kind, loggerOptions);
-    this.sid = sid;
-    this.receiver = receiver;
+const STREAM_CHUNK_SIZE = 15000;
+/**
+ * Manages sending custom user data via data channels.
+ * @internal
+ */
+class OutgoingDataStreamManager {
+  constructor(engine, log) {
+    this.engine = engine;
+    this.log = log;
+  }
+  setupEngine(engine) {
+    this.engine = engine;
+  }
+  /** {@inheritDoc LocalParticipant.sendText} */
+  sendText(text, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const streamId = crypto.randomUUID();
+      const textInBytes = new TextEncoder().encode(text);
+      const totalTextLength = textInBytes.byteLength;
+      const fileIds = (_a = options === null || options === void 0 ? void 0 : options.attachments) === null || _a === void 0 ? void 0 : _a.map(() => crypto.randomUUID());
+      const progresses = new Array(fileIds ? fileIds.length + 1 : 1).fill(0);
+      const handleProgress = (progress, idx) => {
+        var _a;
+        progresses[idx] = progress;
+        const totalProgress = progresses.reduce((acc, val) => acc + val, 0);
+        (_a = options === null || options === void 0 ? void 0 : options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, totalProgress);
+      };
+      const writer = yield this.streamText({
+        streamId,
+        totalSize: totalTextLength,
+        destinationIdentities: options === null || options === void 0 ? void 0 : options.destinationIdentities,
+        topic: options === null || options === void 0 ? void 0 : options.topic,
+        attachedStreamIds: fileIds,
+        attributes: options === null || options === void 0 ? void 0 : options.attributes
+      });
+      yield writer.write(text);
+      // set text part of progress to 1
+      handleProgress(1, 0);
+      yield writer.close();
+      if ((options === null || options === void 0 ? void 0 : options.attachments) && fileIds) {
+        yield Promise.all(options.attachments.map((file, idx) => __awaiter(this, void 0, void 0, function* () {
+          return this._sendFile(fileIds[idx], file, {
+            topic: options.topic,
+            mimeType: file.type,
+            onProgress: progress => {
+              handleProgress(progress, idx + 1);
+            }
+          });
+        })));
+      }
+      return writer.info;
+    });
+  }
+  /**
+   * @internal
+   * @experimental CAUTION, might get removed in a minor release
+   */
+  streamText(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b;
+      const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
+      const info = {
+        id: streamId,
+        mimeType: 'text/plain',
+        timestamp: Date.now(),
+        topic: (_b = options === null || options === void 0 ? void 0 : options.topic) !== null && _b !== void 0 ? _b : '',
+        size: options === null || options === void 0 ? void 0 : options.totalSize,
+        attributes: options === null || options === void 0 ? void 0 : options.attributes
+      };
+      const header = new DataStream_Header({
+        streamId,
+        mimeType: info.mimeType,
+        topic: info.topic,
+        timestamp: numberToBigInt(info.timestamp),
+        totalLength: numberToBigInt(options === null || options === void 0 ? void 0 : options.totalSize),
+        attributes: info.attributes,
+        contentHeader: {
+          case: 'textHeader',
+          value: new DataStream_TextHeader({
+            version: options === null || options === void 0 ? void 0 : options.version,
+            attachedStreamIds: options === null || options === void 0 ? void 0 : options.attachedStreamIds,
+            replyToStreamId: options === null || options === void 0 ? void 0 : options.replyToStreamId,
+            operationType: (options === null || options === void 0 ? void 0 : options.type) === 'update' ? DataStream_OperationType.UPDATE : DataStream_OperationType.CREATE
+          })
+        }
+      });
+      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
+      const packet = new DataPacket({
+        destinationIdentities,
+        value: {
+          case: 'streamHeader',
+          value: header
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+      let chunkId = 0;
+      const engine = this.engine;
+      const writableStream = new WritableStream({
+        // Implement the sink
+        write(text) {
+          return __awaiter(this, void 0, void 0, function* () {
+            for (const textByteChunk of splitUtf8(text, STREAM_CHUNK_SIZE)) {
+              yield engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+              const chunk = new DataStream_Chunk({
+                content: textByteChunk,
+                streamId,
+                chunkIndex: numberToBigInt(chunkId)
+              });
+              const chunkPacket = new DataPacket({
+                destinationIdentities,
+                value: {
+                  case: 'streamChunk',
+                  value: chunk
+                }
+              });
+              yield engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+              chunkId += 1;
+            }
+          });
+        },
+        close() {
+          return __awaiter(this, void 0, void 0, function* () {
+            const trailer = new DataStream_Trailer({
+              streamId
+            });
+            const trailerPacket = new DataPacket({
+              destinationIdentities,
+              value: {
+                case: 'streamTrailer',
+                value: trailer
+              }
+            });
+            yield engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+          });
+        },
+        abort(err) {
+          console.log('Sink error:', err);
+          // TODO handle aborts to signal something to receiver side
+        }
+      });
+      let onEngineClose = () => __awaiter(this, void 0, void 0, function* () {
+        yield writer.close();
+      });
+      engine.once(EngineEvent.Closing, onEngineClose);
+      const writer = new TextStreamWriter(writableStream, info, () => this.engine.off(EngineEvent.Closing, onEngineClose));
+      return writer;
+    });
+  }
+  sendFile(file, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const streamId = crypto.randomUUID();
+      yield this._sendFile(streamId, file, options);
+      return {
+        id: streamId
+      };
+    });
+  }
+  _sendFile(streamId, file, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      const writer = yield this.streamBytes({
+        streamId,
+        totalSize: file.size,
+        name: file.name,
+        mimeType: (_a = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _a !== void 0 ? _a : file.type,
+        topic: options === null || options === void 0 ? void 0 : options.topic,
+        destinationIdentities: options === null || options === void 0 ? void 0 : options.destinationIdentities
+      });
+      const reader = file.stream().getReader();
+      while (true) {
+        const {
+          done,
+          value
+        } = yield reader.read();
+        if (done) {
+          break;
+        }
+        yield writer.write(value);
+      }
+      yield writer.close();
+      return writer.info;
+    });
+  }
+  streamBytes(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c, _d, _e;
+      const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
+      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
+      const info = {
+        id: streamId,
+        mimeType: (_b = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _b !== void 0 ? _b : 'application/octet-stream',
+        topic: (_c = options === null || options === void 0 ? void 0 : options.topic) !== null && _c !== void 0 ? _c : '',
+        timestamp: Date.now(),
+        attributes: options === null || options === void 0 ? void 0 : options.attributes,
+        size: options === null || options === void 0 ? void 0 : options.totalSize,
+        name: (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : 'unknown'
+      };
+      const header = new DataStream_Header({
+        totalLength: numberToBigInt((_e = info.size) !== null && _e !== void 0 ? _e : 0),
+        mimeType: info.mimeType,
+        streamId,
+        topic: info.topic,
+        timestamp: numberToBigInt(Date.now()),
+        attributes: info.attributes,
+        contentHeader: {
+          case: 'byteHeader',
+          value: new DataStream_ByteHeader({
+            name: info.name
+          })
+        }
+      });
+      const packet = new DataPacket({
+        destinationIdentities,
+        value: {
+          case: 'streamHeader',
+          value: header
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+      let chunkId = 0;
+      const writeMutex = new _();
+      const engine = this.engine;
+      const logLocal = this.log;
+      const writableStream = new WritableStream({
+        write(chunk) {
+          return __awaiter(this, void 0, void 0, function* () {
+            const unlock = yield writeMutex.lock();
+            let byteOffset = 0;
+            try {
+              while (byteOffset < chunk.byteLength) {
+                const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
+                yield engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+                const chunkPacket = new DataPacket({
+                  destinationIdentities,
+                  value: {
+                    case: 'streamChunk',
+                    value: new DataStream_Chunk({
+                      content: subChunk,
+                      streamId,
+                      chunkIndex: numberToBigInt(chunkId)
+                    })
+                  }
+                });
+                yield engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+                chunkId += 1;
+                byteOffset += subChunk.byteLength;
+              }
+            } finally {
+              unlock();
+            }
+          });
+        },
+        close() {
+          return __awaiter(this, void 0, void 0, function* () {
+            const trailer = new DataStream_Trailer({
+              streamId
+            });
+            const trailerPacket = new DataPacket({
+              destinationIdentities,
+              value: {
+                case: 'streamTrailer',
+                value: trailer
+              }
+            });
+            yield engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+          });
+        },
+        abort(err) {
+          logLocal.error('Sink error:', err);
+        }
+      });
+      const byteWriter = new ByteStreamWriter(writableStream, info);
+      return byteWriter;
+    });
+  }
+}
+
+class RemoteTrack extends Track {
+  constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
+    super(mediaTrack, kind, loggerOptions);
+    this.sid = sid;
+    this.receiver = receiver;
   }
   get isLocal() {
     return false;
@@ -20508,10 +21136,9 @@ function trackPermissionToProto(perms) {
   });
 }
 
-const STREAM_CHUNK_SIZE = 15000;
 class LocalParticipant extends Participant {
   /** @internal */
-  constructor(sid, identity, engine, options, roomRpcHandlers) {
+  constructor(sid, identity, engine, options, roomRpcHandlers, roomOutgoingDataStreamManager) {
     super(sid, identity, undefined, undefined, undefined, {
       loggerName: options.loggerName,
       loggerContextCb: () => this.engine.logContext
@@ -20535,7 +21162,7 @@ class LocalParticipant extends Participant {
       this.reconnectFuture = undefined;
       this.updateTrackSubscriptionPermissions();
     };
-    this.handleDisconnected = () => {
+    this.handleClosing = () => {
       var _a, _b, _c, _d, _e, _f;
       if (this.reconnectFuture) {
         this.reconnectFuture.promise.catch(e => this.log.warn(e.message, this.logContext));
@@ -20743,6 +21370,7 @@ class LocalParticipant extends Participant {
     this.activeDeviceMap = new Map([['audioinput', 'default'], ['videoinput', 'default'], ['audiooutput', 'default']]);
     this.pendingSignalRequests = new Map();
     this.rpcHandlers = roomRpcHandlers;
+    this.roomOutgoingDataStreamManager = roomOutgoingDataStreamManager;
   }
   get lastCameraError() {
     return this.cameraError;
@@ -20785,7 +21413,7 @@ class LocalParticipant extends Participant {
     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.Disconnected, this.handleDisconnected).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).on(EngineEvent.DataPacketReceived, this.handleDataPacket);
   }
   /**
    * Sets and updates the metadata of the local participant.
@@ -20969,7 +21597,8 @@ class LocalParticipant extends Participant {
             throw e;
           }
           for (const localTrack of localTracks) {
-            if (source === Track.Source.Microphone && isAudioTrack(localTrack) && (publishOptions === null || publishOptions === void 0 ? void 0 : publishOptions.preConnectBuffer)) {
+            const opts = Object.assign(Object.assign({}, this.roomOptions.publishDefaults), options);
+            if (source === Track.Source.Microphone && isAudioTrack(localTrack) && opts.preConnectBuffer) {
               this.log.info('starting preconnect buffer for microphone', Object.assign({}, this.logContext));
               localTrack.startPreConnectBuffer();
             }
@@ -21569,6 +22198,7 @@ class LocalParticipant extends Participant {
       this.emit(ParticipantEvent.LocalTrackPublished, publication);
       if (isLocalAudioTrack(track) && ti.audioFeatures.includes(AudioTrackFeature.TF_PRECONNECT_BUFFER)) {
         const stream = track.getPreConnectBuffer();
+        const mimeType = track.getPreConnectBufferMimeType();
         // TODO: we're registering the listener after negotiation, so there might be a race
         this.on(ParticipantEvent.LocalTrackSubscribed, pub => {
           if (pub.trackSid === ti.sid) {
@@ -21594,7 +22224,7 @@ class LocalParticipant extends Participant {
               this.log.debug('sending preconnect buffer', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
               const writer = yield this.streamBytes({
                 name: 'preconnect-buffer',
-                mimeType: 'audio/opus',
+                mimeType,
                 topic: 'lk.agent.pre-connect-audio-buffer',
                 destinationIdentities: [agent.identity],
                 attributes: {
@@ -21892,6 +22522,7 @@ class LocalParticipant extends Participant {
       yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
     });
   }
+  /** @deprecated Consider migrating to {@link sendText} */
   sendChatMessage(text, options) {
     return __awaiter(this, void 0, void 0, function* () {
       const msg = {
@@ -21913,6 +22544,7 @@ class LocalParticipant extends Participant {
       return msg;
     });
   }
+  /** @deprecated Consider migrating to {@link sendText} */
   editChatMessage(editText, originalMessage) {
     return __awaiter(this, void 0, void 0, function* () {
       const msg = Object.assign(Object.assign({}, originalMessage), {
@@ -21922,277 +22554,62 @@ class LocalParticipant extends Participant {
       const packet = new DataPacket({
         value: {
           case: 'chatMessage',
-          value: new ChatMessage(Object.assign(Object.assign({}, msg), {
-            timestamp: protoInt64.parse(msg.timestamp),
-            editTimestamp: protoInt64.parse(msg.editTimestamp)
-          }))
-        }
-      });
-      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-      this.emit(ParticipantEvent.ChatMessage, msg);
-      return msg;
-    });
-  }
-  sendText(text, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      const streamId = crypto.randomUUID();
-      const textInBytes = new TextEncoder().encode(text);
-      const totalTextLength = textInBytes.byteLength;
-      const fileIds = (_a = options === null || options === void 0 ? void 0 : options.attachments) === null || _a === void 0 ? void 0 : _a.map(() => crypto.randomUUID());
-      const progresses = new Array(fileIds ? fileIds.length + 1 : 1).fill(0);
-      const handleProgress = (progress, idx) => {
-        var _a;
-        progresses[idx] = progress;
-        const totalProgress = progresses.reduce((acc, val) => acc + val, 0);
-        (_a = options === null || options === void 0 ? void 0 : options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, totalProgress);
-      };
-      const writer = yield this.streamText({
-        streamId,
-        totalSize: totalTextLength,
-        destinationIdentities: options === null || options === void 0 ? void 0 : options.destinationIdentities,
-        topic: options === null || options === void 0 ? void 0 : options.topic,
-        attachedStreamIds: fileIds,
-        attributes: options === null || options === void 0 ? void 0 : options.attributes
-      });
-      yield writer.write(text);
-      // set text part of progress to 1
-      handleProgress(1, 0);
-      yield writer.close();
-      if ((options === null || options === void 0 ? void 0 : options.attachments) && fileIds) {
-        yield Promise.all(options.attachments.map((file, idx) => __awaiter(this, void 0, void 0, function* () {
-          return this._sendFile(fileIds[idx], file, {
-            topic: options.topic,
-            mimeType: file.type,
-            onProgress: progress => {
-              handleProgress(progress, idx + 1);
-            }
-          });
-        })));
-      }
-      return writer.info;
-    });
-  }
-  /**
-   * @internal
-   * @experimental CAUTION, might get removed in a minor release
-   */
-  streamText(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
-      const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
-      const info = {
-        id: streamId,
-        mimeType: 'text/plain',
-        timestamp: Date.now(),
-        topic: (_b = options === null || options === void 0 ? void 0 : options.topic) !== null && _b !== void 0 ? _b : '',
-        size: options === null || options === void 0 ? void 0 : options.totalSize,
-        attributes: options === null || options === void 0 ? void 0 : options.attributes
-      };
-      const header = new DataStream_Header({
-        streamId,
-        mimeType: info.mimeType,
-        topic: info.topic,
-        timestamp: numberToBigInt(info.timestamp),
-        totalLength: numberToBigInt(options === null || options === void 0 ? void 0 : options.totalSize),
-        attributes: info.attributes,
-        contentHeader: {
-          case: 'textHeader',
-          value: new DataStream_TextHeader({
-            version: options === null || options === void 0 ? void 0 : options.version,
-            attachedStreamIds: options === null || options === void 0 ? void 0 : options.attachedStreamIds,
-            replyToStreamId: options === null || options === void 0 ? void 0 : options.replyToStreamId,
-            operationType: (options === null || options === void 0 ? void 0 : options.type) === 'update' ? DataStream_OperationType.UPDATE : DataStream_OperationType.CREATE
-          })
-        }
-      });
-      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
-      const packet = new DataPacket({
-        destinationIdentities,
-        value: {
-          case: 'streamHeader',
-          value: header
-        }
-      });
-      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-      let chunkId = 0;
-      const localP = this;
-      const writableStream = new WritableStream({
-        // Implement the sink
-        write(text) {
-          return __awaiter(this, void 0, void 0, function* () {
-            for (const textByteChunk of splitUtf8(text, STREAM_CHUNK_SIZE)) {
-              yield localP.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-              const chunk = new DataStream_Chunk({
-                content: textByteChunk,
-                streamId,
-                chunkIndex: numberToBigInt(chunkId)
-              });
-              const chunkPacket = new DataPacket({
-                destinationIdentities,
-                value: {
-                  case: 'streamChunk',
-                  value: chunk
-                }
-              });
-              yield localP.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
-              chunkId += 1;
-            }
-          });
-        },
-        close() {
-          return __awaiter(this, void 0, void 0, function* () {
-            const trailer = new DataStream_Trailer({
-              streamId
-            });
-            const trailerPacket = new DataPacket({
-              destinationIdentities,
-              value: {
-                case: 'streamTrailer',
-                value: trailer
-              }
-            });
-            yield localP.engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
-          });
-        },
-        abort(err) {
-          console.log('Sink error:', err);
-          // TODO handle aborts to signal something to receiver side
-        }
-      });
-      let onEngineClose = () => __awaiter(this, void 0, void 0, function* () {
-        yield writer.close();
-      });
-      localP.engine.once(EngineEvent.Closing, onEngineClose);
-      const writer = new TextStreamWriter(writableStream, info, () => this.engine.off(EngineEvent.Closing, onEngineClose));
-      return writer;
-    });
-  }
-  sendFile(file, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const streamId = crypto.randomUUID();
-      yield this._sendFile(streamId, file, options);
-      return {
-        id: streamId
-      };
-    });
-  }
-  _sendFile(streamId, file, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      const writer = yield this.streamBytes({
-        streamId,
-        totalSize: file.size,
-        name: file.name,
-        mimeType: (_a = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _a !== void 0 ? _a : file.type,
-        topic: options === null || options === void 0 ? void 0 : options.topic,
-        destinationIdentities: options === null || options === void 0 ? void 0 : options.destinationIdentities
-      });
-      const reader = file.stream().getReader();
-      while (true) {
-        const {
-          done,
-          value
-        } = yield reader.read();
-        if (done) {
-          break;
-        }
-        yield writer.write(value);
-      }
-      yield writer.close();
-      return writer.info;
-    });
-  }
-  streamBytes(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d, _e;
-      const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
-      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
-      const info = {
-        id: streamId,
-        mimeType: (_b = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _b !== void 0 ? _b : 'application/octet-stream',
-        topic: (_c = options === null || options === void 0 ? void 0 : options.topic) !== null && _c !== void 0 ? _c : '',
-        timestamp: Date.now(),
-        attributes: options === null || options === void 0 ? void 0 : options.attributes,
-        size: options === null || options === void 0 ? void 0 : options.totalSize,
-        name: (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : 'unknown'
-      };
-      const header = new DataStream_Header({
-        totalLength: numberToBigInt((_e = info.size) !== null && _e !== void 0 ? _e : 0),
-        mimeType: info.mimeType,
-        streamId,
-        topic: info.topic,
-        timestamp: numberToBigInt(Date.now()),
-        attributes: info.attributes,
-        contentHeader: {
-          case: 'byteHeader',
-          value: new DataStream_ByteHeader({
-            name: info.name
-          })
-        }
-      });
-      const packet = new DataPacket({
-        destinationIdentities,
-        value: {
-          case: 'streamHeader',
-          value: header
+          value: new ChatMessage(Object.assign(Object.assign({}, msg), {
+            timestamp: protoInt64.parse(msg.timestamp),
+            editTimestamp: protoInt64.parse(msg.editTimestamp)
+          }))
         }
       });
       yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-      let chunkId = 0;
-      const writeMutex = new _();
-      const engine = this.engine;
-      const log = this.log;
-      const writableStream = new WritableStream({
-        write(chunk) {
-          return __awaiter(this, void 0, void 0, function* () {
-            const unlock = yield writeMutex.lock();
-            let byteOffset = 0;
-            try {
-              while (byteOffset < chunk.byteLength) {
-                const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
-                yield engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-                const chunkPacket = new DataPacket({
-                  destinationIdentities,
-                  value: {
-                    case: 'streamChunk',
-                    value: new DataStream_Chunk({
-                      content: subChunk,
-                      streamId,
-                      chunkIndex: numberToBigInt(chunkId)
-                    })
-                  }
-                });
-                yield engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
-                chunkId += 1;
-                byteOffset += subChunk.byteLength;
-              }
-            } finally {
-              unlock();
-            }
-          });
-        },
-        close() {
-          return __awaiter(this, void 0, void 0, function* () {
-            const trailer = new DataStream_Trailer({
-              streamId
-            });
-            const trailerPacket = new DataPacket({
-              destinationIdentities,
-              value: {
-                case: 'streamTrailer',
-                value: trailer
-              }
-            });
-            yield engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
-          });
-        },
-        abort(err) {
-          log.error('Sink error:', err);
-        }
-      });
-      const byteWriter = new ByteStreamWriter(writableStream, info);
-      return byteWriter;
+      this.emit(ParticipantEvent.ChatMessage, msg);
+      return msg;
+    });
+  }
+  /**
+   * Sends the given string to participants in the room via the data channel.
+   * For longer messages, consider using {@link streamText} instead.
+   *
+   * @param text The text payload
+   * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+   */
+  sendText(text, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.roomOutgoingDataStreamManager.sendText(text, options);
+    });
+  }
+  /**
+   * Creates a new TextStreamWriter which can be used to stream text incrementally
+   * to participants in the room via the data channel.
+   *
+   * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+   *
+   * @internal
+   * @experimental CAUTION, might get removed in a minor release
+   */
+  streamText(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.roomOutgoingDataStreamManager.streamText(options);
+    });
+  }
+  /** Send a File to all participants in the room via the data channel.
+   * @param file The File object payload
+   * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+   * @param options.onProgress A callback function used to monitor the upload progress percentage.
+   */
+  sendFile(file, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.roomOutgoingDataStreamManager.sendFile(file, options);
+    });
+  }
+  /**
+   * Stream bytes incrementally to participants in the room via the data channel.
+   * For sending files, consider using {@link sendFile} instead.
+   *
+   * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+   */
+  streamBytes(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.roomOutgoingDataStreamManager.streamBytes(options);
     });
   }
   /**
@@ -23024,10 +23441,6 @@ class Room extends eventsExports.EventEmitter {
     this.log = livekitLogger;
     this.bufferedEvents = [];
     this.isResuming = false;
-    this.byteStreamControllers = new Map();
-    this.textStreamControllers = new Map();
-    this.byteStreamHandlers = new Map();
-    this.textStreamHandlers = new Map();
     this.rpcHandlers = new Map();
     this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       var _a;
@@ -23567,12 +23980,8 @@ class Room extends eventsExports.EventEmitter {
         this.handleChatMessage(participant, packet.value.value);
       } else if (packet.value.case === 'metrics') {
         this.handleMetrics(packet.value.value, participant);
-      } else if (packet.value.case === 'streamHeader') {
-        this.handleStreamHeader(packet.value.value, packet.participantIdentity);
-      } else if (packet.value.case === 'streamChunk') {
-        this.handleStreamChunk(packet.value.value);
-      } else if (packet.value.case === 'streamTrailer') {
-        this.handleStreamTrailer(packet.value.value);
+      } else if (packet.value.case === 'streamHeader' || packet.value.case === 'streamChunk' || packet.value.case === 'streamTrailer') {
+        this.handleDataStream(packet);
       } 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);
@@ -23588,7 +23997,6 @@ class Room extends eventsExports.EventEmitter {
       // also emit on the participant
       participant === null || participant === void 0 ? void 0 : participant.emit(ParticipantEvent.SipDTMFReceived, dtmf);
     };
-    this.bufferedSegments = new Map();
     this.handleTranscription = (_remoteParticipant, transcription) => {
       // find the participant
       const participant = transcription.transcribedParticipantIdentity === this.localParticipant.identity ? this.localParticipant : this.getParticipantByIdentity(transcription.transcribedParticipantIdentity);
@@ -23605,6 +24013,10 @@ class Room extends eventsExports.EventEmitter {
     this.handleMetrics = (metrics, participant) => {
       this.emit(RoomEvent.MetricsReceived, metrics, participant);
     };
+    this.handleDataStream = packet => {
+      this.incomingDataStreamManager.handleDataStreamPacket(packet);
+    };
+    this.bufferedSegments = new Map();
     this.handleAudioPlaybackStarted = () => {
       if (this.canPlaybackAudio) {
         return;
@@ -23739,8 +24151,10 @@ class Room extends eventsExports.EventEmitter {
     this.options.videoCaptureDefaults = Object.assign(Object.assign({}, videoDefaults), options === null || options === void 0 ? void 0 : options.videoCaptureDefaults);
     this.options.publishDefaults = Object.assign(Object.assign({}, publishDefaults), options === null || options === void 0 ? void 0 : options.publishDefaults);
     this.maybeCreateEngine();
+    this.incomingDataStreamManager = new IncomingDataStreamManager();
+    this.outgoingDataStreamManager = new OutgoingDataStreamManager(this.engine, this.log);
     this.disconnectLock = new _();
-    this.localParticipant = new LocalParticipant('', '', this.engine, this.options, this.rpcHandlers);
+    this.localParticipant = new LocalParticipant('', '', this.engine, this.options, this.rpcHandlers, this.outgoingDataStreamManager);
     if (this.options.videoCaptureDefaults.deviceId) {
       this.localParticipant.activeDeviceMap.set('videoinput', unwrapConstraint(this.options.videoCaptureDefaults.deviceId));
     }
@@ -23767,22 +24181,16 @@ class Room extends eventsExports.EventEmitter {
     }
   }
   registerTextStreamHandler(topic, callback) {
-    if (this.textStreamHandlers.has(topic)) {
-      throw new TypeError("A text stream handler for topic \"".concat(topic, "\" has already been set."));
-    }
-    this.textStreamHandlers.set(topic, callback);
+    return this.incomingDataStreamManager.registerTextStreamHandler(topic, callback);
   }
   unregisterTextStreamHandler(topic) {
-    this.textStreamHandlers.delete(topic);
+    return this.incomingDataStreamManager.unregisterTextStreamHandler(topic);
   }
   registerByteStreamHandler(topic, callback) {
-    if (this.byteStreamHandlers.has(topic)) {
-      throw new TypeError("A byte stream handler for topic \"".concat(topic, "\" has already been set."));
-    }
-    this.byteStreamHandlers.set(topic, callback);
+    return this.incomingDataStreamManager.registerByteStreamHandler(topic, callback);
   }
   unregisterByteStreamHandler(topic) {
-    this.byteStreamHandlers.delete(topic);
+    return this.incomingDataStreamManager.unregisterByteStreamHandler(topic);
   }
   /**
    * Establishes the participant as a receiver for calls of the specified RPC method.
@@ -23824,44 +24232,6 @@ class Room extends eventsExports.EventEmitter {
   unregisterRpcMethod(method) {
     this.rpcHandlers.delete(method);
   }
-  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');
-          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.engine.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
-    });
-  }
   /**
    * @experimental
    */
@@ -24026,6 +24396,9 @@ class Room extends eventsExports.EventEmitter {
     if (this.e2eeManager) {
       this.e2eeManager.setupEngine(this.engine);
     }
+    if (this.outgoingDataStreamManager) {
+      this.outgoingDataStreamManager.setupEngine(this.engine);
+    }
   }
   /**
    * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
@@ -24291,7 +24664,7 @@ class Room extends eventsExports.EventEmitter {
         } else if (kind === 'audiooutput') {
           shouldTriggerImmediateDeviceChange = true;
           if (!supportsSetSinkId() && !_this3.options.webAudioMix || _this3.options.webAudioMix && _this3.audioContext && !('setSinkId' in _this3.audioContext)) {
-            throw new Error('cannot switch audio output, setSinkId not supported');
+            throw new Error('cannot switch audio output, the current browser does not support it');
           }
           if (_this3.options.webAudioMix) {
             // setting `default` for web audio output doesn't work, so we need to normalize the id before
@@ -24402,6 +24775,7 @@ class Room extends eventsExports.EventEmitter {
     this.isResuming = false;
     this.bufferedEvents = [];
     this.transcriptionReceivedTimes.clear();
+    this.incomingDataStreamManager.clearHandlersAndControllers();
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
@@ -24453,6 +24827,7 @@ class Room extends eventsExports.EventEmitter {
     if (!participant) {
       return;
     }
+    this.incomingDataStreamManager.validateParticipantHasNoActiveDataStreams(identity);
     participant.trackPublications.forEach(publication => {
       participant.unpublishTrack(publication.trackSid, true);
     });
@@ -24460,99 +24835,44 @@ class Room extends eventsExports.EventEmitter {
     participant.setDisconnected();
     (_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.handleParticipantDisconnected(participant.identity);
   }
-  handleStreamHeader(streamHeader, participantIdentity) {
+  handleIncomingRpcRequest(callerIdentity, requestId, method, payload, responseTimeout, version) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      if (streamHeader.contentHeader.case === 'byteHeader') {
-        const streamHandlerCallback = this.byteStreamHandlers.get(streamHeader.topic);
-        if (!streamHandlerCallback) {
-          this.log.debug('ignoring incoming byte stream due to no handler for topic', streamHeader.topic);
-          return;
-        }
-        let streamController;
-        const info = {
-          id: streamHeader.streamId,
-          name: (_a = streamHeader.contentHeader.value.name) !== null && _a !== void 0 ? _a : 'unknown',
-          mimeType: streamHeader.mimeType,
-          size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
-          topic: streamHeader.topic,
-          timestamp: bigIntToNumber(streamHeader.timestamp),
-          attributes: streamHeader.attributes
-        };
-        const stream = new ReadableStream({
-          start: controller => {
-            streamController = controller;
-            this.byteStreamControllers.set(streamHeader.streamId, {
-              info,
-              controller: streamController,
-              startTime: Date.now()
-            });
-          }
-        });
-        streamHandlerCallback(new ByteStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)), {
-          identity: participantIdentity
+      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
         });
-      } else if (streamHeader.contentHeader.case === 'textHeader') {
-        const streamHandlerCallback = this.textStreamHandlers.get(streamHeader.topic);
-        if (!streamHandlerCallback) {
-          this.log.debug('ignoring incoming text stream due to no handler for topic', streamHeader.topic);
-          return;
+        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');
         }
-        let streamController;
-        const info = {
-          id: streamHeader.streamId,
-          mimeType: streamHeader.mimeType,
-          size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
-          topic: streamHeader.topic,
-          timestamp: Number(streamHeader.timestamp),
-          attributes: streamHeader.attributes
-        };
-        const stream = new ReadableStream({
-          start: controller => {
-            streamController = controller;
-            this.textStreamControllers.set(streamHeader.streamId, {
-              info,
-              controller: streamController,
-              startTime: Date.now()
-            });
-          }
-        });
-        streamHandlerCallback(new TextStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)), {
-          identity: participantIdentity
-        });
       }
+      yield this.engine.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
     });
   }
-  handleStreamChunk(chunk) {
-    const fileBuffer = this.byteStreamControllers.get(chunk.streamId);
-    if (fileBuffer) {
-      if (chunk.content.length > 0) {
-        fileBuffer.controller.enqueue(chunk);
-      }
-    }
-    const textBuffer = this.textStreamControllers.get(chunk.streamId);
-    if (textBuffer) {
-      if (chunk.content.length > 0) {
-        textBuffer.controller.enqueue(chunk);
-      }
-    }
-  }
-  handleStreamTrailer(trailer) {
-    const textBuffer = this.textStreamControllers.get(trailer.streamId);
-    if (textBuffer) {
-      textBuffer.info.attributes = Object.assign(Object.assign({}, textBuffer.info.attributes), trailer.attributes);
-      textBuffer.controller.close();
-      this.textStreamControllers.delete(trailer.streamId);
-    }
-    const fileBuffer = this.byteStreamControllers.get(trailer.streamId);
-    if (fileBuffer) {
-      {
-        fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
-        fileBuffer.controller.close();
-        this.byteStreamControllers.delete(trailer.streamId);
-      }
-    }
-  }
   /**
    * attempt to select the default devices if the previously selected devices are no longer available after a device change event
    */
@@ -25808,5 +26128,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, BackupCodecPolicy, 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, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, attributeTypings as attributes, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DataStreamError, DataStreamErrorReason, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, attributeTypings as attributes, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map