livekit-client 2.15.4 → 2.15.6

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.4";
+var version$1 = "2.15.6";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -11401,17 +11425,24 @@ var VideoQuality;
   VideoQuality[VideoQuality["HIGH"] = 2] = "HIGH";
 })(VideoQuality || (VideoQuality = {}));
 class Track extends eventsExports.EventEmitter {
+  /**
+   * indicates current state of stream, it'll indicate `paused` if the track
+   * has been paused by congestion controller
+   */
+  get streamState() {
+    return this._streamState;
+  }
+  /** @internal */
+  setStreamState(value) {
+    this._streamState = value;
+  }
   constructor(mediaTrack, kind) {
     let loggerOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     var _a;
     super();
     this.attachedElements = [];
     this.isMuted = false;
-    /**
-     * indicates current state of stream, it'll indicate `paused` if the track
-     * has been paused by congestion controller
-     */
-    this.streamState = Track.StreamState.Active;
+    this._streamState = Track.StreamState.Active;
     this.isInBackground = false;
     this._currentBitrate = 0;
     this.log = livekitLogger;
@@ -11904,8 +11935,9 @@ function supportsAV1() {
   if (!('getCapabilities' in RTCRtpSender)) {
     return false;
   }
-  if (isSafari()) {
+  if (isSafari() || isFireFox()) {
     // Safari 17 on iPhone14 reports AV1 capability, but does not actually support it
+    // Firefox does support AV1, but SVC publishing is not supported
     return false;
   }
   const capabilities = RTCRtpSender.getCapabilities('video');
@@ -12007,9 +12039,9 @@ function isE2EESimulcastSupported() {
   if (browser) {
     if (browser.name !== 'Safari' && browser.os !== 'iOS') {
       return true;
-    } else if (browser.os === 'iOS' && browser.osVersion && compareVersions(supportedSafariVersion, browser.osVersion) >= 0) {
+    } else if (browser.os === 'iOS' && browser.osVersion && compareVersions(browser.osVersion, supportedSafariVersion) >= 0) {
       return true;
-    } else if (browser.name === 'Safari' && compareVersions(supportedSafariVersion, browser.version) >= 0) {
+    } else if (browser.name === 'Safari' && compareVersions(browser.version, supportedSafariVersion) >= 0) {
       return true;
     } else {
       return false;
@@ -12057,6 +12089,14 @@ function getDevicePixelRatio() {
   }
   return 1;
 }
+/**
+ * @param v1 - The first version string to compare.
+ * @param v2 - The second version string to compare.
+ * @returns A number indicating the order of the versions:
+ *   - 1 if v1 is greater than v2
+ *   - -1 if v1 is less than v2
+ *   - 0 if v1 and v2 are equal
+ */
 function compareVersions(v1, v2) {
   const parts1 = v1.split('.');
   const parts2 = v2.split('.');
@@ -12246,13 +12286,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];
     }
@@ -12851,6 +12891,21 @@ class E2EEManager extends eventsExports.EventEmitter {
     room.localParticipant.on(ParticipantEvent.LocalSenderCreated, (sender, track) => __awaiter(this, void 0, void 0, function* () {
       this.setupE2EESender(track, sender);
     }));
+    room.localParticipant.on(ParticipantEvent.LocalTrackPublished, publication => {
+      // Safari doesn't support retrieving payload information on RTCEncodedVideoFrame, so we need to update the codec manually once we have the trackInfo from the server
+      if (!isVideoTrack(publication.track) || !isSafariBased()) {
+        return;
+      }
+      const msg = {
+        kind: 'updateCodec',
+        data: {
+          trackId: publication.track.mediaStreamID,
+          codec: mimeTypeToVideoCodecString(publication.trackInfo.codecs[0].mimeType),
+          participantIdentity: this.room.localParticipant.identity
+        }
+      };
+      this.worker.postMessage(msg);
+    });
     keyProvider.on(KeyProviderEvent.SetKey, keyInfo => this.postKey(keyInfo)).on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex));
   }
   postRatchetRequest(participantIdentity, keyIndex) {
@@ -15931,9 +15986,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) {
@@ -16009,26 +16069,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);
@@ -16126,32 +16181,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;
@@ -16174,9 +16234,9 @@ class LocalTrack extends Track {
             facingMode
           } : true;
         } else {
-          streamConstraints.audio = deviceId ? {
+          streamConstraints.audio = deviceId ? Object.assign({
             deviceId
-          } : true;
+          }, otherConstraints) : true;
         }
         // these steps are duplicated from setMediaStreamTrack because we must stop
         // the previous tracks before new tracks can be acquired
@@ -16191,7 +16251,10 @@ class LocalTrack extends Track {
         // create new track and attach
         const mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
         const newTrack = mediaStream.getTracks()[0];
-        yield newTrack.applyConstraints(otherConstraints);
+        if (this.kind === Track.Kind.Video) {
+          // we already captured the audio track with the constraints, so we only need to apply the video constraints
+          yield newTrack.applyConstraints(otherConstraints);
+        }
         newTrack.addEventListener('ended', this.handleEnded);
         this.log.debug('re-acquired MediaStreamTrack', this.logContext);
         yield this.setMediaStreamTrack(newTrack);
@@ -16334,7 +16397,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);
@@ -16347,7 +16410,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');
@@ -16405,22 +16468,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);
       }();
     });
   }
@@ -16614,13 +16696,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,
@@ -19004,30 +19086,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
@@ -19039,17 +19162,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
@@ -19058,29 +19180,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);
+      }();
     });
   }
 }
@@ -19092,8 +19230,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) {
@@ -19106,6 +19244,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);
   }
@@ -19116,37 +19255,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
@@ -19155,138 +19328,602 @@ 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, 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;
-        }
-      } catch (e_2_1) {
-        e_2 = {
-          error: e_2_1
-        };
-      } finally {
+    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 {
-          if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+          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 {
-          if (e_2) throw e_2.error;
+          try {
+            if (!_d && !_a && (_b = iterator_2.return)) yield _b.call(iterator_2);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
         }
-      }
-      return finalString;
+        return finalString;
+      }();
     });
   }
 }
 
-class BaseStreamWriter {
-  constructor(writableStream, info, onClose) {
-    this.writableStream = writableStream;
-    this.defaultWriter = writableStream.getWriter();
-    this.onClose = onClose;
-    this.info = info;
-  }
-  write(chunk) {
-    return this.defaultWriter.write(chunk);
-  }
-  close() {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      yield this.defaultWriter.close();
-      this.defaultWriter.releaseLock();
-      (_a = this.onClose) === null || _a === void 0 ? void 0 : _a.call(this);
-    });
+class IncomingDataStreamManager {
+  constructor() {
+    this.log = livekitLogger;
+    this.byteStreamControllers = new Map();
+    this.textStreamControllers = new Map();
+    this.byteStreamHandlers = new Map();
+    this.textStreamHandlers = new Map();
   }
-}
-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;
+  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);
   }
-  get isLocal() {
-    return false;
+  unregisterTextStreamHandler(topic) {
+    this.textStreamHandlers.delete(topic);
   }
-  /** @internal */
-  setMuted(muted) {
-    if (this.isMuted !== muted) {
-      this.isMuted = muted;
-      this._mediaStreamTrack.enabled = !muted;
-      this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
+  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);
   }
-  /** @internal */
-  setMediaStream(stream) {
-    // this is needed to determine when the track is finished
-    this.mediaStream = stream;
-    const onRemoveTrack = event => {
-      if (event.track === this._mediaStreamTrack) {
-        stream.removeEventListener('removetrack', onRemoveTrack);
-        if (this.receiver && 'playoutDelayHint' in this.receiver) {
-          this.receiver.playoutDelayHint = undefined;
-        }
-        this.receiver = undefined;
-        this._currentBitrate = 0;
-        this.emit(TrackEvent.Ended, this);
-      }
-    };
-    stream.addEventListener('removetrack', onRemoveTrack);
+  unregisterByteStreamHandler(topic) {
+    this.byteStreamHandlers.delete(topic);
   }
-  start() {
-    this.startMonitor();
-    // use `enabled` of track to enable re-use of transceiver
-    super.enable();
+  clearHandlersAndControllers() {
+    this.byteStreamControllers.clear();
+    this.textStreamControllers.clear();
+    this.byteStreamHandlers.clear();
+    this.textStreamHandlers.clear();
   }
-  stop() {
-    this.stopMonitor();
-    // use `enabled` of track to enable re-use of transceiver
-    super.disable();
+  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);
+      }
+    }
   }
-  /**
-   * Gets the RTCStatsReport for the RemoteTrack's underlying RTCRtpReceiver
-   * See https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport
-   *
-   * @returns Promise<RTCStatsReport> | undefined
-   */
-  getRTCStatsReport() {
+  handleDataStreamPacket(packet) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      if (!((_a = this.receiver) === null || _a === void 0 ? void 0 : _a.getStats)) {
-        return;
+      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!"));
       }
-      const statsReport = yield this.receiver.getStats();
-      return statsReport;
     });
   }
-  /**
-   * Allows to set a playout delay (in seconds) for this track.
-   * A higher value allows for more buffering of the track in the browser
-   * and will result in a delay of media being played back of `delayInSeconds`
-   */
-  setPlayoutDelay(delayInSeconds) {
-    if (this.receiver) {
-      if ('playoutDelayHint' in this.receiver) {
-        this.receiver.playoutDelayHint = delayInSeconds;
-      } else {
-        this.log.warn('Playout delay not supported in this browser');
-      }
-    } else {
-      this.log.warn('Cannot set playout delay, track already ended');
-    }
-  }
-  /**
-   * Returns the current playout delay (in seconds) of this track.
-   */
-  getPlayoutDelay() {
-    if (this.receiver) {
-      if ('playoutDelayHint' in this.receiver) {
-        return this.receiver.playoutDelayHint;
+  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;
+        }
+        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
+        };
+        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
+        });
+      }
+    });
+  }
+  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 {
+  constructor(writableStream, info, onClose) {
+    this.writableStream = writableStream;
+    this.defaultWriter = writableStream.getWriter();
+    this.onClose = onClose;
+    this.info = info;
+  }
+  write(chunk) {
+    return this.defaultWriter.write(chunk);
+  }
+  close() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      yield this.defaultWriter.close();
+      this.defaultWriter.releaseLock();
+      (_a = this.onClose) === null || _a === void 0 ? void 0 : _a.call(this);
+    });
+  }
+}
+class TextStreamWriter extends BaseStreamWriter {}
+class ByteStreamWriter extends BaseStreamWriter {}
+
+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;
+  }
+  /** @internal */
+  setMuted(muted) {
+    if (this.isMuted !== muted) {
+      this.isMuted = muted;
+      this._mediaStreamTrack.enabled = !muted;
+      this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
+    }
+  }
+  /** @internal */
+  setMediaStream(stream) {
+    // this is needed to determine when the track is finished
+    this.mediaStream = stream;
+    const onRemoveTrack = event => {
+      if (event.track === this._mediaStreamTrack) {
+        stream.removeEventListener('removetrack', onRemoveTrack);
+        if (this.receiver && 'playoutDelayHint' in this.receiver) {
+          this.receiver.playoutDelayHint = undefined;
+        }
+        this.receiver = undefined;
+        this._currentBitrate = 0;
+        this.emit(TrackEvent.Ended, this);
+      }
+    };
+    stream.addEventListener('removetrack', onRemoveTrack);
+  }
+  start() {
+    this.startMonitor();
+    // use `enabled` of track to enable re-use of transceiver
+    super.enable();
+  }
+  stop() {
+    this.stopMonitor();
+    // use `enabled` of track to enable re-use of transceiver
+    super.disable();
+  }
+  /**
+   * Gets the RTCStatsReport for the RemoteTrack's underlying RTCRtpReceiver
+   * See https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport
+   *
+   * @returns Promise<RTCStatsReport> | undefined
+   */
+  getRTCStatsReport() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      if (!((_a = this.receiver) === null || _a === void 0 ? void 0 : _a.getStats)) {
+        return;
+      }
+      const statsReport = yield this.receiver.getStats();
+      return statsReport;
+    });
+  }
+  /**
+   * Allows to set a playout delay (in seconds) for this track.
+   * A higher value allows for more buffering of the track in the browser
+   * and will result in a delay of media being played back of `delayInSeconds`
+   */
+  setPlayoutDelay(delayInSeconds) {
+    if (this.receiver) {
+      if ('playoutDelayHint' in this.receiver) {
+        this.receiver.playoutDelayHint = delayInSeconds;
+      } else {
+        this.log.warn('Playout delay not supported in this browser');
+      }
+    } else {
+      this.log.warn('Cannot set playout delay, track already ended');
+    }
+  }
+  /**
+   * Returns the current playout delay (in seconds) of this track.
+   */
+  getPlayoutDelay() {
+    if (this.receiver) {
+      if ('playoutDelayHint' in this.receiver) {
+        return this.receiver.playoutDelayHint;
       } else {
         this.log.warn('Playout delay not supported in this browser');
       }
@@ -19552,6 +20189,15 @@ class RemoteVideoTrack extends RemoteTrack {
   get isAdaptiveStream() {
     return this.adaptiveStreamSettings !== undefined;
   }
+  setStreamState(value) {
+    super.setStreamState(value);
+    console.log('setStreamState', value);
+    if (value === Track.StreamState.Active) {
+      // update visibility for adaptive stream tracks when stream state received from server is active
+      // this is needed to ensure the track is stopped when there's no element attached to it at all
+      this.updateVisibility();
+    }
+  }
   /**
    * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start
    */
@@ -19701,14 +20347,14 @@ class RemoteVideoTrack extends RemoteTrack {
       this.updateVisibility();
     });
   }
-  updateVisibility() {
+  updateVisibility(forceEmit) {
     var _a, _b;
     const lastVisibilityChange = this.elementInfos.reduce((prev, info) => Math.max(prev, info.visibilityChangedAt || 0), 0);
     const backgroundPause = ((_b = (_a = this.adaptiveStreamSettings) === null || _a === void 0 ? void 0 : _a.pauseVideoInBackground) !== null && _b !== void 0 ? _b : true // default to true
     ) ? this.isInBackground : false;
     const isPiPMode = this.elementInfos.some(info => info.pictureInPicture);
     const isVisible = this.elementInfos.some(info => info.visible) && !backgroundPause || isPiPMode;
-    if (this.lastVisible === isVisible) {
+    if (this.lastVisible === isVisible && !forceEmit) {
       return;
     }
     if (!isVisible && Date.now() - lastVisibilityChange < REACTION_DELAY) {
@@ -20533,10 +21179,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
@@ -20768,6 +21413,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;
@@ -21919,6 +22565,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 = {
@@ -21940,6 +22587,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), {
@@ -21950,276 +22598,61 @@ class LocalParticipant extends Participant {
         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
+            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);
     });
   }
   /**
@@ -23051,10 +23484,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;
@@ -23552,8 +23981,8 @@ class Room extends eventsExports.EventEmitter {
           return;
         }
         const newStreamState = Track.streamStateFromProto(streamState.state);
+        pub.track.setStreamState(newStreamState);
         if (newStreamState !== pub.track.streamState) {
-          pub.track.streamState = newStreamState;
           participant.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState);
           this.emitWhenConnected(RoomEvent.TrackStreamStateChanged, pub, pub.track.streamState, participant);
         }
@@ -23594,12 +24023,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);
@@ -23615,7 +24040,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);
@@ -23632,6 +24056,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;
@@ -23766,8 +24194,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));
     }
@@ -23794,22 +24224,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.
@@ -23851,44 +24275,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
    */
@@ -24053,6 +24439,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.
@@ -24419,7 +24808,10 @@ class Room extends eventsExports.EventEmitter {
         adaptiveStreamSettings = {};
       }
     }
-    participant.addSubscribedMediaTrack(mediaTrack, trackId, stream, receiver, adaptiveStreamSettings);
+    const publication = participant.addSubscribedMediaTrack(mediaTrack, trackId, stream, receiver, adaptiveStreamSettings);
+    if ((publication === null || publication === void 0 ? void 0 : publication.isEncrypted) && !this.e2eeManager) {
+      this.emit(RoomEvent.EncryptionError, new Error("Encrypted ".concat(publication.source, " track received from participant ").concat(participant.sid, ", but room does not have encryption enabled!")));
+    }
   }
   handleDisconnect() {
     let shouldStopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
@@ -24429,6 +24821,7 @@ class Room extends eventsExports.EventEmitter {
     this.isResuming = false;
     this.bufferedEvents = [];
     this.transcriptionReceivedTimes.clear();
+    this.incomingDataStreamManager.clearHandlersAndControllers();
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
@@ -24480,6 +24873,7 @@ class Room extends eventsExports.EventEmitter {
     if (!participant) {
       return;
     }
+    this.incomingDataStreamManager.validateParticipantHasNoActiveDataStreams(identity);
     participant.trackPublications.forEach(publication => {
       participant.unpublishTrack(publication.trackSid, true);
     });
@@ -24487,99 +24881,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
    */
@@ -25835,5 +26174,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