livekit-client 2.20.2 → 2.22.0

package/dist/livekit-client.esm.mjs

@@ -3983,6 +3983,9 @@ const PacketTrailerFeature = /* @__PURE__ */proto3.makeEnum("livekit.PacketTrail
 }, {
   no: 1,
   name: "PTF_FRAME_ID"
+}, {
+  no: 2,
+  name: "PTF_USER_DATA"
 }]);
 const Room$1 = /* @__PURE__ */proto3.makeMessageType("livekit.Room", () => [{
   no: 1,
@@ -4250,6 +4253,12 @@ const ParticipantInfo = /* @__PURE__ */proto3.makeMessageType("livekit.Participa
   kind: "scalar",
   T: 5
   /* ScalarType.INT32 */
+}, {
+  no: 21,
+  name: "capabilities",
+  kind: "enum",
+  T: proto3.getEnumType(ClientInfo_Capability),
+  repeated: true
 }]);
 const ParticipantInfo_State = /* @__PURE__ */proto3.makeEnum("livekit.ParticipantInfo.State", [{
   no: 0,
@@ -4301,6 +4310,9 @@ const ParticipantInfo_KindDetail = /* @__PURE__ */proto3.makeEnum("livekit.Parti
 }, {
   no: 4,
   name: "BRIDGE_RTSP"
+}, {
+  no: 5,
+  name: "SIMULATION"
 }]);
 const Encryption_Type = /* @__PURE__ */proto3.makeEnum("livekit.Encryption.Type", [{
   no: 0,
@@ -4493,6 +4505,122 @@ const DataTrackInfo$1 = /* @__PURE__ */proto3.makeMessageType("livekit.DataTrack
   name: "encryption",
   kind: "enum",
   T: proto3.getEnumType(Encryption_Type)
+}, {
+  no: 5,
+  name: "frame_encoding",
+  kind: "message",
+  T: DataTrackFrameEncoding,
+  opt: true
+}, {
+  no: 6,
+  name: "schema",
+  kind: "message",
+  T: DataTrackSchemaId,
+  opt: true
+}]);
+const DataTrackFrameEncoding = /* @__PURE__ */proto3.makeMessageType("livekit.DataTrackFrameEncoding", () => [{
+  no: 1,
+  name: "well_known",
+  kind: "enum",
+  T: proto3.getEnumType(DataTrackFrameEncoding_WellKnownFrameEncoding),
+  oneof: "value"
+}, {
+  no: 2,
+  name: "custom",
+  kind: "scalar",
+  T: 9,
+  oneof: "value"
+}]);
+const DataTrackFrameEncoding_WellKnownFrameEncoding = /* @__PURE__ */proto3.makeEnum("livekit.DataTrackFrameEncoding.WellKnownFrameEncoding", [{
+  no: 0,
+  name: "WELL_KNOWN_FRAME_ENCODING_UNSPECIFIED",
+  localName: "UNSPECIFIED"
+}, {
+  no: 1,
+  name: "WELL_KNOWN_FRAME_ENCODING_ROS1",
+  localName: "ROS1"
+}, {
+  no: 2,
+  name: "WELL_KNOWN_FRAME_ENCODING_CDR",
+  localName: "CDR"
+}, {
+  no: 3,
+  name: "WELL_KNOWN_FRAME_ENCODING_PROTOBUF",
+  localName: "PROTOBUF"
+}, {
+  no: 4,
+  name: "WELL_KNOWN_FRAME_ENCODING_FLATBUFFER",
+  localName: "FLATBUFFER"
+}, {
+  no: 5,
+  name: "WELL_KNOWN_FRAME_ENCODING_CBOR",
+  localName: "CBOR"
+}, {
+  no: 6,
+  name: "WELL_KNOWN_FRAME_ENCODING_MSGPACK",
+  localName: "MSGPACK"
+}, {
+  no: 7,
+  name: "WELL_KNOWN_FRAME_ENCODING_JSON",
+  localName: "JSON"
+}]);
+const DataTrackSchemaEncoding = /* @__PURE__ */proto3.makeMessageType("livekit.DataTrackSchemaEncoding", () => [{
+  no: 1,
+  name: "well_known",
+  kind: "enum",
+  T: proto3.getEnumType(DataTrackSchemaEncoding_WellKnownSchemaEncoding),
+  oneof: "value"
+}, {
+  no: 2,
+  name: "custom",
+  kind: "scalar",
+  T: 9,
+  oneof: "value"
+}]);
+const DataTrackSchemaEncoding_WellKnownSchemaEncoding = /* @__PURE__ */proto3.makeEnum("livekit.DataTrackSchemaEncoding.WellKnownSchemaEncoding", [{
+  no: 0,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_UNSPECIFIED",
+  localName: "UNSPECIFIED"
+}, {
+  no: 1,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_PROTOBUF",
+  localName: "PROTOBUF"
+}, {
+  no: 2,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_FLATBUFFER",
+  localName: "FLATBUFFER"
+}, {
+  no: 3,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_ROS1_MSG",
+  localName: "ROS1_MSG"
+}, {
+  no: 4,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_ROS2_MSG",
+  localName: "ROS2_MSG"
+}, {
+  no: 5,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_ROS2_IDL",
+  localName: "ROS2_IDL"
+}, {
+  no: 6,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_OMG_IDL",
+  localName: "OMG_IDL"
+}, {
+  no: 7,
+  name: "WELL_KNOWN_SCHEMA_ENCODING_JSON_SCHEMA",
+  localName: "JSON_SCHEMA"
+}]);
+const DataTrackSchemaId = /* @__PURE__ */proto3.makeMessageType("livekit.DataTrackSchemaId", () => [{
+  no: 1,
+  name: "name",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "encoding",
+  kind: "message",
+  T: DataTrackSchemaEncoding
 }]);
 const DataTrackSubscriptionOptions = /* @__PURE__ */proto3.makeMessageType("livekit.DataTrackSubscriptionOptions", () => [{
   no: 1,
@@ -4501,6 +4629,31 @@ const DataTrackSubscriptionOptions = /* @__PURE__ */proto3.makeMessageType("live
   T: 13,
   opt: true
 }]);
+const DataBlobKey = /* @__PURE__ */proto3.makeMessageType("livekit.DataBlobKey", () => [{
+  no: 1,
+  name: "generic",
+  kind: "scalar",
+  T: 9,
+  oneof: "key"
+}, {
+  no: 2,
+  name: "schema_id",
+  kind: "message",
+  T: DataTrackSchemaId,
+  oneof: "key"
+}]);
+const DataBlob = /* @__PURE__ */proto3.makeMessageType("livekit.DataBlob", () => [{
+  no: 1,
+  name: "key",
+  kind: "message",
+  T: DataBlobKey
+}, {
+  no: 2,
+  name: "contents",
+  kind: "scalar",
+  T: 12
+  /* ScalarType.BYTES */
+}]);
 const VideoLayer = /* @__PURE__ */proto3.makeMessageType("livekit.VideoLayer", () => [{
   no: 1,
   name: "quality",
@@ -5223,6 +5376,9 @@ const ClientInfo_Capability = /* @__PURE__ */proto3.makeEnum("livekit.ClientInfo
 }, {
   no: 1,
   name: "CAP_PACKET_TRAILER"
+}, {
+  no: 2,
+  name: "CAP_COMPRESSION_DEFLATE_RAW"
 }]);
 const ClientConfiguration = /* @__PURE__ */proto3.makeMessageType("livekit.ClientConfiguration", () => [{
   no: 1,
@@ -5295,6 +5451,13 @@ const DataStream_OperationType = /* @__PURE__ */proto3.makeEnum("livekit.DataStr
   no: 3,
   name: "REACTION"
 }]);
+const DataStream_CompressionType = /* @__PURE__ */proto3.makeEnum("livekit.DataStream.CompressionType", [{
+  no: 0,
+  name: "NONE"
+}, {
+  no: 1,
+  name: "DEFLATE_RAW"
+}]);
 const DataStream_TextHeader = /* @__PURE__ */proto3.makeMessageType("livekit.DataStream.TextHeader", () => [{
   no: 1,
   name: "operation_type",
@@ -5393,6 +5556,17 @@ const DataStream_Header = /* @__PURE__ */proto3.makeMessageType("livekit.DataStr
   kind: "message",
   T: DataStream_ByteHeader,
   oneof: "content_header"
+}, {
+  no: 11,
+  name: "inline_content",
+  kind: "scalar",
+  T: 12,
+  opt: true
+}, {
+  no: 12,
+  name: "compression",
+  kind: "enum",
+  T: proto3.getEnumType(DataStream_CompressionType)
 }], {
   localName: "DataStream_Header"
 });
@@ -5528,6 +5702,16 @@ const RoomAgentDispatch = /* @__PURE__ */proto3.makeMessageType("livekit.RoomAge
   kind: "scalar",
   T: 9
   /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "attributes",
+  kind: "map",
+  K: 9,
+  V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
 }]);
 const EncodingOptionsPreset = /* @__PURE__ */proto3.makeEnum("livekit.EncodingOptionsPreset", [{
   no: 0,
@@ -6426,6 +6610,18 @@ const SignalRequest = /* @__PURE__ */proto3.makeMessageType("livekit.SignalReque
   kind: "message",
   T: UpdateDataSubscription,
   oneof: "message"
+}, {
+  no: 22,
+  name: "store_data_blob_request",
+  kind: "message",
+  T: StoreDataBlobRequest,
+  oneof: "message"
+}, {
+  no: 23,
+  name: "get_data_blob_request",
+  kind: "message",
+  T: GetDataBlobRequest,
+  oneof: "message"
 }]);
 const SignalResponse = /* @__PURE__ */proto3.makeMessageType("livekit.SignalResponse", () => [{
   no: 1,
@@ -6595,6 +6791,18 @@ const SignalResponse = /* @__PURE__ */proto3.makeMessageType("livekit.SignalResp
   kind: "message",
   T: DataTrackSubscriberHandles,
   oneof: "message"
+}, {
+  no: 30,
+  name: "store_data_blob_response",
+  kind: "message",
+  T: StoreDataBlobResponse,
+  oneof: "message"
+}, {
+  no: 31,
+  name: "get_data_blob_response",
+  kind: "message",
+  T: GetDataBlobResponse,
+  oneof: "message"
 }]);
 const SimulcastCodec = /* @__PURE__ */proto3.makeMessageType("livekit.SimulcastCodec", () => [{
   no: 1,
@@ -6742,6 +6950,18 @@ const PublishDataTrackRequest = /* @__PURE__ */proto3.makeMessageType("livekit.P
   name: "encryption",
   kind: "enum",
   T: proto3.getEnumType(Encryption_Type)
+}, {
+  no: 4,
+  name: "frame_encoding",
+  kind: "message",
+  T: DataTrackFrameEncoding,
+  opt: true
+}, {
+  no: 5,
+  name: "schema",
+  kind: "message",
+  T: DataTrackSchemaId,
+  opt: true
 }]);
 const PublishDataTrackResponse = /* @__PURE__ */proto3.makeMessageType("livekit.PublishDataTrackResponse", () => [{
   no: 1,
@@ -7035,6 +7255,60 @@ const UpdateDataSubscription_Update = /* @__PURE__ */proto3.makeMessageType("liv
 }], {
   localName: "UpdateDataSubscription_Update"
 });
+const StoreDataBlobRequest = /* @__PURE__ */proto3.makeMessageType("livekit.StoreDataBlobRequest", () => [{
+  no: 1,
+  name: "request_id",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 2,
+  name: "blob",
+  kind: "message",
+  T: DataBlob
+}]);
+const StoreDataBlobResponse = /* @__PURE__ */proto3.makeMessageType("livekit.StoreDataBlobResponse", () => [{
+  no: 1,
+  name: "request_id",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 2,
+  name: "key",
+  kind: "message",
+  T: DataBlobKey
+}]);
+const GetDataBlobRequest = /* @__PURE__ */proto3.makeMessageType("livekit.GetDataBlobRequest", () => [{
+  no: 1,
+  name: "request_id",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 2,
+  name: "participant_identity",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "key",
+  kind: "message",
+  T: DataBlobKey
+}]);
+const GetDataBlobResponse = /* @__PURE__ */proto3.makeMessageType("livekit.GetDataBlobResponse", () => [{
+  no: 1,
+  name: "request_id",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 2,
+  name: "blob",
+  kind: "message",
+  T: DataBlob
+}]);
 const UpdateTrackSettings = /* @__PURE__ */proto3.makeMessageType("livekit.UpdateTrackSettings", () => [{
   no: 1,
   name: "track_sids",
@@ -7697,6 +7971,9 @@ const RequestResponse_Reason = /* @__PURE__ */proto3.makeEnum("livekit.RequestRe
 }, {
   no: 10,
   name: "DUPLICATE_NAME"
+}, {
+  no: 11,
+  name: "INVALID_REQUEST"
 }]);
 const TrackSubscribed = /* @__PURE__ */proto3.makeMessageType("livekit.TrackSubscribed", () => [{
   no: 1,
@@ -11883,16 +12160,20 @@ function getMatch(exp, ua) {
 }
 function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
-}var version$1 = "2.20.2";const version = version$1;
+}var version$1 = "2.22.0";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
 /** Replaces RPC v1 protocol with a v2 data streams based one to support unlimited request /
  * response payload length. */
 const CLIENT_PROTOCOL_DATA_STREAM_RPC = 1;
+/** "Data streams v2": the client knows how to receive a single-packet data stream (a stream whose
+ * entire payload is smuggled into the header packet, with no chunk/trailer packets). Senders only
+ * use the single-packet optimization when the recipient advertises at least this protocol. */
+const CLIENT_PROTOCOL_DATA_STREAM_V2 = 2;
 /** The client protocol version indicates what level of support that the client has for
  * client <-> client api interactions. */
-const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_RPC;/** Base error that all LiveKit specific custom errors inherit from. */
+const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_V2;/** Base error that all LiveKit specific custom errors inherit from. */
 class LivekitError extends Error {
   constructor(code, message, options) {
     super(message || 'an error has occurred');
@@ -12028,6 +12309,10 @@ var DataStreamErrorReason;
   DataStreamErrorReason[DataStreamErrorReason["HandlerAlreadyRegistered"] = 7] = "HandlerAlreadyRegistered";
   // Encryption type mismatch.
   DataStreamErrorReason[DataStreamErrorReason["EncryptionTypeMismatch"] = 8] = "EncryptionTypeMismatch";
+  // The serialized stream header packet (driven mainly by attributes) exceeds the MTU budget.
+  DataStreamErrorReason[DataStreamErrorReason["HeaderTooLarge"] = 9] = "HeaderTooLarge";
+  // The stream's (decompressed) payload exceeds the maximum allowed size.
+  DataStreamErrorReason[DataStreamErrorReason["PayloadTooLarge"] = 10] = "PayloadTooLarge";
 })(DataStreamErrorReason || (DataStreamErrorReason = {}));
 class DataStreamError extends LivekitReasonedError {
   constructor(message, reason) {
@@ -13355,8 +13640,9 @@ class Track extends eventsExports.EventEmitter {
     if (this.monitorInterval) {
       clearInterval(this.monitorInterval);
     }
-    if (this.timeSyncHandle) {
+    if (this.timeSyncHandle !== undefined) {
       cancelAnimationFrame(this.timeSyncHandle);
+      this.timeSyncHandle = undefined;
     }
   }
   /** @internal */
@@ -13644,6 +13930,45 @@ function supportsVP9() {
 function isSVCCodec(codec) {
   return codec === 'av1' || codec === 'vp9';
 }
+/**
+ * Opts `transceiver` into negotiating the AV1 dependency descriptor, reporting whether it will be.
+ *
+ * Chrome only offers the extension on transceivers that can send, so one we create to receive on
+ * never negotiates it — and Chrome 152 stopped decoding AV1 that arrives without it: frames get
+ * assembled, none ever decode, and the receiver asks for a keyframe forever. Asking through the
+ * transceiver rather than munging the extension into the SDP leaves the browser owning the
+ * extension id, which is what keeps that id consistent across the bundle and across
+ * renegotiations.
+ *
+ * A no-op where the browser offers no such control, or does not know the extension at all.
+ * @internal
+ */
+function negotiateDependencyDescriptor(transceiver) {
+  var _a;
+  const extensions = (_a = transceiver.getHeaderExtensionsToNegotiate) === null || _a === void 0 ? void 0 : _a.call(transceiver);
+  if (!extensions || !transceiver.setHeaderExtensionsToNegotiate) {
+    return false;
+  }
+  const dd = extensions.find(ext => ext.uri === ddExtensionURI);
+  if (!dd) {
+    return false;
+  }
+  if (dd.direction !== 'stopped') {
+    return true;
+  }
+  // sendrecv rather than recvonly, so that the extension is written as a plain `a=extmap` line —
+  // the form the server already emits where it is the one offering — rather than one carrying a
+  // `/recvonly` suffix that its parser may not expect
+  dd.direction = 'sendrecv';
+  try {
+    transceiver.setHeaderExtensionsToNegotiate(extensions);
+    return true;
+  } catch (e) {
+    // a rejected direction throws. Negotiating without the extension is what happened before this
+    // existed, so it is not worth failing the connection over
+    return false;
+  }
+}
 function supportsSetSinkId(elm) {
   if (!document || isSafariBased()) {
     return false;
@@ -14121,6 +14446,53 @@ function splitUtf8(s, n) {
   }
   return result;
 }
+/** Wraps a byte array in a `ReadableStream` that yields it as a single chunk and then closes. */
+function readableFromBytes(bytes) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+/**
+ * Re-chunks a byte stream into pieces of exactly `chunkSize` bytes (the final piece may be
+ * smaller), coalescing or splitting the source's pieces as needed. Memory use is bounded to roughly
+ * `chunkSize` plus one source read, so it never buffers the whole stream — used to pack
+ * `CompressionStream`/`file.stream()` output into MTU-sized data-stream chunks.
+ */
+function readBytesInChunks(source, chunkSize) {
+  return __asyncGenerator(this, arguments, function* readBytesInChunks_1() {
+    const reader = source.getReader();
+    let buffer = new Uint8Array(0);
+    try {
+      while (true) {
+        const _yield$__await = yield __await(reader.read()),
+          done = _yield$__await.done,
+          value = _yield$__await.value;
+        if (done) {
+          break;
+        }
+        if (value.byteLength === 0) {
+          continue;
+        }
+        const merged = new Uint8Array(buffer.byteLength + value.byteLength);
+        merged.set(buffer);
+        merged.set(value, buffer.byteLength);
+        buffer = merged;
+        while (buffer.byteLength >= chunkSize) {
+          yield yield __await(buffer.slice(0, chunkSize));
+          buffer = buffer.slice(chunkSize);
+        }
+      }
+      if (buffer.byteLength > 0) {
+        yield yield __await(buffer);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+}
 function extractMaxAgeFromRequestHeaders(headers) {
   var _a;
   const cacheControl = headers.get('Cache-Control');
@@ -14138,6 +14510,17 @@ function isCompressionStreamSupported() {
 function isPublisherOfferWithJoinSupported() {
   // we have connectivity issue about publisher offer with join on firefox #1919
   return isCompressionStreamSupported() && !isFireFox();
+}
+function extractTrackSid(mediaTrack, stream) {
+  const _unpackStreamId = unpackStreamId(stream.id),
+    _unpackStreamId2 = _slicedToArray(_unpackStreamId, 2),
+    streamId = _unpackStreamId2[1];
+  if (streamId === null || streamId === void 0 ? void 0 : streamId.startsWith('TR')) {
+    return streamId;
+  }
+  if (mediaTrack.id.startsWith('TR')) {
+    return mediaTrack.id;
+  }
 }function createRtcUrl(url, searchParams) {
   let useV0Path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   const v0Url = createV0RtcUrl(url, searchParams);
@@ -14636,6 +15019,34 @@ function computeBitrate(currentStats, prevStats) {
 }class RemoteTrack extends Track {
   constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
     super(mediaTrack, kind, loggerOptions);
+    this.timeSyncLoop = () => {
+      var _a;
+      if (this.listenerCount(TrackEvent.TimeSyncUpdate) === 0) {
+        // nobody is listening anymore, pause the loop until a new listener subscribes
+        this.timeSyncHandle = undefined;
+        return;
+      }
+      this.timeSyncHandle = requestAnimationFrame(this.timeSyncLoop);
+      const sources = (_a = this.receiver) === null || _a === void 0 ? void 0 : _a.getSynchronizationSources()[0];
+      if (sources) {
+        const timestamp = sources.timestamp,
+          rtpTimestamp = sources.rtpTimestamp;
+        if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
+          this.emit(TrackEvent.TimeSyncUpdate, {
+            timestamp,
+            rtpTimestamp
+          });
+          this.rtpTimestamp = rtpTimestamp;
+        }
+      }
+    };
+    this.onTimeSyncListenerAdded = event => {
+      if (event === TrackEvent.TimeSyncUpdate && this.timeSyncHandle === undefined) {
+        // `newListener` fires before the listener is registered, so schedule the
+        // next frame instead of entering the loop (which would see a count of 0)
+        this.timeSyncHandle = requestAnimationFrame(this.timeSyncLoop);
+      }
+    };
     this.sid = sid;
     this.receiver = receiver;
   }
@@ -14733,24 +15144,19 @@ function computeBitrate(currentStats, prevStats) {
       this.registerTimeSyncUpdate();
     }
   }
+  /* @internal */
+  stopMonitor() {
+    super.stopMonitor();
+    this.off('newListener', this.onTimeSyncListenerAdded);
+  }
   registerTimeSyncUpdate() {
-    const loop = () => {
-      var _a;
-      this.timeSyncHandle = requestAnimationFrame(() => loop());
-      const sources = (_a = this.receiver) === null || _a === void 0 ? void 0 : _a.getSynchronizationSources()[0];
-      if (sources) {
-        const timestamp = sources.timestamp,
-          rtpTimestamp = sources.rtpTimestamp;
-        if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
-          this.emit(TrackEvent.TimeSyncUpdate, {
-            timestamp,
-            rtpTimestamp
-          });
-          this.rtpTimestamp = rtpTimestamp;
-        }
-      }
-    };
-    loop();
+    // `newListener` isn't part of the typed event map, hence the cast
+    const emitter = this;
+    emitter.off('newListener', this.onTimeSyncListenerAdded);
+    emitter.on('newListener', this.onTimeSyncListenerAdded);
+    if (this.timeSyncHandle === undefined) {
+      this.timeSyncLoop();
+    }
   }
 }const REACTION_DELAY = 100;
 class RemoteVideoTrack extends RemoteTrack {
@@ -17269,81 +17675,6 @@ function createJoinRequestConnectionParams(token, info, opts, publisherOffer) {
     params.set('join_request', bytesToBase64(wrappedBytes).replace(/\+/g, '-').replace(/\//g, '_'));
     return params;
   });
-}class DataPacketBuffer {
-  constructor() {
-    this.buffer = [];
-    this._totalSize = 0;
-    this._sentSize = 0;
-  }
-  push(item) {
-    this.buffer.push(item);
-    this._totalSize += item.data.byteLength;
-    if (item.sent) {
-      this._sentSize += item.data.byteLength;
-    }
-  }
-  pop() {
-    const item = this.buffer.shift();
-    if (item) {
-      this._totalSize -= item.data.byteLength;
-      if (item.sent) {
-        this._sentSize -= item.data.byteLength;
-      }
-    }
-    return item;
-  }
-  getAll() {
-    return this.buffer.slice();
-  }
-  /** Every queued packet not yet handed to the channel, in sequence order. */
-  getUnsent() {
-    return this.buffer.filter(item => !item.sent);
-  }
-  /** Marks a single queued packet as handed to the channel. */
-  markSent(item) {
-    if (!item.sent) {
-      item.sent = true;
-      this._sentSize += item.data.byteLength;
-    }
-  }
-  /**
-   * Marks every queued packet as not-yet-sent. Used at the start of a resume replay: whatever is
-   * still buffered was sent on the previous channel (or deferred) and must be re-handed to the
-   * current one, so none of it counts as sent until the replay actually transmits it.
-   */
-  markAllUnsent() {
-    for (const item of this.buffer) {
-      item.sent = false;
-    }
-    this._sentSize = 0;
-  }
-  popToSequence(sequence) {
-    while (this.buffer.length > 0) {
-      const first = this.buffer[0];
-      if (first.sequence <= sequence) {
-        this.pop();
-      } else {
-        break;
-      }
-    }
-  }
-  alignBufferedAmount(bufferedAmount) {
-    while (this.buffer.length > 0) {
-      const first = this.buffer[0];
-      // Unsent packets aren't part of the channel's bufferedAmount and are still awaiting the
-      // resume replay — trimming them would silently lose them.
-      if (!first.sent) {
-        break;
-      }
-      if (this._sentSize - first.data.byteLength <= bufferedAmount) {
-        break;
-      }
-      this.pop();
-    }
-  }
-  get length() {
-    return this.buffer.length;
-  }
 }class TTLMap {
   /**
    * @param ttl ttl of the key (ms)
@@ -18135,6 +18466,51 @@ const startBitrateMultiplier = 0.9;
 /** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
 const maxStartBitrateKbps = 1000;
 const debounceInterval = 20;
+/**
+ * Applies the configured start bitrate when this media section belongs to `cid`.
+ * This SDP munging is used for a bitrate setting that cannot be applied through
+ * `RTCRtpEncodingParameters`.
+ *
+ * Returns `undefined` when the section does not belong to the track, `0` when
+ * it does but does not offer the requested codec, and the codec payload when the
+ * requested codec is present (whether the bitrate was added or already set).
+ *
+ * @internal
+ */
+function applyVideoStartBitrate(media, cid, codec, maxbr) {
+  let isScreenShare = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var _a, _b, _c;
+  if (!((_a = media.msid) === null || _a === void 0 ? void 0 : _a.includes(cid))) {
+    return undefined;
+  }
+  const codecPayload = (_c = (_b = media.rtp.find(rtp => rtp.codec.toUpperCase() === codec.toUpperCase())) === null || _b === void 0 ? void 0 : _b.payload) !== null && _c !== void 0 ? _c : 0;
+  if (codecPayload === 0) {
+    return 0;
+  }
+  // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE
+  // from starting too aggressively. Screen share is not capped since text/UI
+  // clarity requires high bitrate from the start.
+  // TODO: dynamically adjust start bitrate based on network conditions (e.g., previous BWE estimate)
+  const calculatedStartBitrate = Math.round(maxbr * startBitrateMultiplier);
+  const startBitrate = isScreenShare ? calculatedStartBitrate : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
+  const fmtp = media.fmtp.find(entry => entry.payload === codecPayload);
+  if (fmtp) {
+    // If another track's fmtp already has a start bitrate, it cannot be
+    // overridden here because the payload type is shared across the bundle.
+    // This forces every track sharing that payload to use the initial track's
+    // start bitrate.
+    if (!fmtp.config.includes('x-google-start-bitrate')) {
+      fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
+    }
+  } else {
+    // VP8 and some codecs may not have an existing fmtp line.
+    media.fmtp.push({
+      payload: codecPayload,
+      config: "x-google-start-bitrate=".concat(startBitrate)
+    });
+  }
+  return codecPayload;
+}
 const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
   NegotiationComplete: 'negotiationComplete',
@@ -18436,9 +18812,13 @@ class PCTransport extends eventsExports.EventEmitter {
           // the only exception to this is when ICE restart is needed
           const currentSD = this._pc.remoteDescription;
           if ((options === null || options === void 0 ? void 0 : options.iceRestart) && currentSD) {
-            // TODO: handle when ICE restart is needed but we don't have a remote description
-            // the best thing to do is to recreate the peerconnection
+            // roll the remote description back in so createOffer produces a valid
+            // ICE-restart offer on top of the already-negotiated state
             yield this._pc.setRemoteDescription(currentSD);
+          } else if (options === null || options === void 0 ? void 0 : options.iceRestart) {
+            // ICE restart with no remote description to restart on: `renegotiate` would stall
+            // (the pending offer is never answered), so throw for the caller to recreate the PC.
+            throw new NegotiationError('ICE restart requested without a remote description, peer connection must be recreated');
           } else {
             this.renegotiate = true;
             this.log.debug('requesting renegotiation');
@@ -18464,48 +18844,15 @@ class PCTransport extends eventsExports.EventEmitter {
             ensureAudioNackAndStereo(media, ['all'], []);
           } else if (media.type === 'video') {
             this.trackBitrates.some(trackbr => {
-              if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
+              if (!trackbr.cid) {
                 return false;
               }
-              let codecPayload = 0;
-              media.rtp.some(rtp => {
-                if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
-                  codecPayload = rtp.payload;
-                  return true;
-                }
+              const codecPayload = applyVideoStartBitrate(media, trackbr.cid, trackbr.codec, trackbr.maxbr, trackbr.isScreenShare);
+              if (codecPayload === undefined) {
                 return false;
-              });
-              if (codecPayload === 0) {
-                return true;
-              }
-              if (isSVCCodec(trackbr.codec) && !isSafari()) {
-                this.ensureVideoDDExtensionForSVC(media, sdpParsed);
-              }
-              // mung sdp for bitrate setting that can't apply by sendEncoding
-              // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE from starting too aggressively
-              // Screen share is not capped since text/UI clarity requires high bitrate from the start
-              // TODO: dynamically adjust start bitrate based on network conditions (e.g., use previous BWE estimate)
-              const calculatedStartBitrate = Math.round(trackbr.maxbr * startBitrateMultiplier);
-              const startBitrate = trackbr.isScreenShare ? calculatedStartBitrate : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
-              let fmtpFound = false;
-              for (const fmtp of media.fmtp) {
-                if (fmtp.payload === codecPayload) {
-                  fmtpFound = true;
-                  // if another track's fmtp already is set, we cannot override the bitrate
-                  // this has the unfortunate consequence of being forced to use the
-                  // initial track's bitrate for all tracks
-                  if (!fmtp.config.includes('x-google-start-bitrate')) {
-                    fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
-                  }
-                  break;
-                }
               }
-              // VP8 and some codecs may not have an existing fmtp line - create one
-              if (!fmtpFound) {
-                media.fmtp.push({
-                  payload: codecPayload,
-                  config: "x-google-start-bitrate=".concat(startBitrate)
-                });
+              if (codecPayload > 0 && isSVCCodec(trackbr.codec) && !isSafari()) {
+                this.ddExtID = ensureVideoDDExtension(media, sdpParsed, this.ddExtID);
               }
               return true;
             });
@@ -18718,41 +19065,106 @@ class PCTransport extends eventsExports.EventEmitter {
       }
     });
   }
-  ensureVideoDDExtensionForSVC(media, sdp) {
-    var _a, _b;
-    const ddFound = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => {
-      if (ext.uri === ddExtensionURI) {
-        return true;
-      }
-      return false;
+}
+/**
+ * Adds the AV1 dependency descriptor extension to `media` unless it is already there, and
+ * returns the id it is mapped to so callers can pass it back in as `ddExtID` (0 when no id has
+ * been chosen yet).
+ *
+ * A bundle has to map one URI to one id, so an id already in use for the extension anywhere in
+ * `sdp` wins over both the cached one and a fresh one: Chrome advertises the extension itself on
+ * sections it can send on, and an earlier offer may have munged it into others.
+ * @internal
+ */
+function ensureVideoDDExtension(media, sdp, ddExtID) {
+  var _a, _b;
+  const id = ddExtensionIDFor(sdp, ddExtID);
+  if (id === undefined) {
+    return ddExtID;
+  }
+  if (!((_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => ext.uri === ddExtensionURI))) {
+    (_b = media.ext) !== null && _b !== void 0 ? _b : media.ext = [];
+    media.ext.push({
+      value: id,
+      uri: ddExtensionURI
     });
-    if (!ddFound) {
-      if (this.ddExtID === 0) {
-        let maxID = 0;
-        sdp.media.forEach(m => {
-          var _a;
-          (_a = m.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
-            if (ext.value > maxID) {
-              maxID = ext.value;
-            }
-          });
-        });
-        this.ddExtID = maxID + 1;
-      }
-      (_b = media.ext) === null || _b === void 0 ? void 0 : _b.push({
-        value: this.ddExtID,
-        uri: ddExtensionURI
-      });
+  }
+  return id;
+}
+/**
+ * The id to map the dependency descriptor to throughout `sdp`, or undefined when no id would be
+ * consistent for the whole bundle and the extension therefore has to be left out.
+ */
+function ddExtensionIDFor(sdp, cachedID) {
+  const mapped = mappedExtensionID(sdp, ddExtensionURI);
+  if (mapped !== undefined) {
+    // Adopting an id that also stands for another URI is what the browser rejects the bundle
+    // over, and its own half of the map is not ours to renumber, so give up on this offer.
+    return usedForOtherURI(sdp, mapped, ddExtensionURI) ? undefined : mapped;
+  }
+  // Reusing the id from the last offer keeps the mapping stable across renegotiations, but only
+  // while nothing else has taken it: the browser assigns ids to its own extensions without
+  // knowing about ours, so an id that was free when we picked it can since have been claimed —
+  // typically by the fuller extension set that arrives with the first section we send on.
+  if (cachedID !== 0 && !usedForOtherURI(sdp, cachedID, ddExtensionURI)) {
+    return cachedID;
+  }
+  return unusedExtensionID(sdp);
+}
+/** The id `uri` is mapped to in `sdp`, if any section maps it. */
+function mappedExtensionID(sdp, uri) {
+  var _a;
+  for (const media of sdp.media) {
+    const ext = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.find(candidate => candidate.uri === uri);
+    if (ext) {
+      return ext.value;
     }
   }
+  return undefined;
+}
+/** Whether `id` stands for anything in `sdp` other than `uri`. */
+function usedForOtherURI(sdp, id, uri) {
+  return sdp.media.some(media => {
+    var _a;
+    return (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => ext.value === id && ext.uri !== uri);
+  });
+}
+/**
+ * An id no extension in `sdp` uses. Stays above every id in use rather than filling gaps, so it
+ * is less likely to be an id the browser goes on to allocate to another extension, and steps
+ * over 15, which RFC 8285 reserves.
+ */
+function unusedExtensionID(sdp) {
+  let maxID = 0;
+  sdp.media.forEach(media => {
+    var _a;
+    (_a = media.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
+      if (ext.value > maxID) {
+        maxID = ext.value;
+      }
+    });
+  });
+  return maxID + 1 === 15 ? 16 : maxID + 1;
+}
+/**
+ * Checks whether an fmtp config declares `param` as an exact, `;`-delimited
+ * token. A plain substring check conflates distinct opus parameters — e.g.
+ * `stereo=1` is a substring of `sprop-stereo=1` — so `param` must match a whole
+ * parameter, not appear anywhere within the config string.
+ * @internal
+ */
+function fmtpConfigHasParam(config, param) {
+  return config.split(';').some(entry => entry.trim() === param);
 }
+/** @internal */
 function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
   // sdp-transform types don't include number however the parser outputs mids as numbers in some cases
   const mid = getMidString(media.mid);
   // found opus codec to add nack fb
   let opusPayload = 0;
   media.rtp.some(rtp => {
-    if (rtp.codec === 'opus') {
+    // rtpmap encoding names are case-insensitive (RFC 4855)
+    if (rtp.codec.toLowerCase() === 'opus') {
       opusPayload = rtp.payload;
       return true;
     }
@@ -18772,7 +19184,7 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
     if (stereoMids.includes(mid) || stereoMids.length === 1 && stereoMids[0] === 'all') {
       media.fmtp.some(fmtp => {
         if (fmtp.payload === opusPayload) {
-          if (!fmtp.config.includes('stereo=1')) {
+          if (!fmtpConfigHasParam(fmtp.config, 'stereo=1')) {
             fmtp.config += ';stereo=1';
           }
           return true;
@@ -18855,6 +19267,7 @@ function conformBundledCodecFmtp(media, isPlaceholder) {
     }
   }
 }
+/** @internal */
 function extractStereoAndNackAudioFromOffer(offer) {
   var _a;
   const stereoMids = [];
@@ -18866,7 +19279,8 @@ function extractStereoAndNackAudioFromOffer(offer) {
     const mid = getMidString(media.mid);
     if (media.type === 'audio') {
       media.rtp.some(rtp => {
-        if (rtp.codec === 'opus') {
+        // rtpmap encoding names are case-insensitive (RFC 4855)
+        if (rtp.codec.toLowerCase() === 'opus') {
           opusPayload = rtp.payload;
           return true;
         }
@@ -18877,7 +19291,7 @@ function extractStereoAndNackAudioFromOffer(offer) {
       }
       media.fmtp.some(fmtp => {
         if (fmtp.payload === opusPayload) {
-          if (fmtp.config.includes('sprop-stereo=1')) {
+          if (fmtpConfigHasParam(fmtp.config, 'sprop-stereo=1')) {
             stereoMids.push(mid);
           }
           return true;
@@ -19289,105 +19703,762 @@ class PCTransportManager {
       }();
     });
   }
-}// Check if MediaRecorder is available
-const isMediaRecorderAvailable = typeof MediaRecorder !== 'undefined';
-// Fallback class for environments without MediaRecorder
-class FallbackRecorder {
-  constructor() {
-    throw new Error('MediaRecorder is not available in this environment');
+}/**
+ * Two-watermark flow control for one data channel kind.
+ *
+ * Owns the per-kind headroom gate: senders proceed freely while the buffer is at or below the
+ * high-water mark and otherwise block — serialized FIFO through a mutex — until the browser's
+ * `bufferedamountlow` event (armed at the low-water mark) signals the buffer has drained. The
+ * serialization prevents woken senders from all refilling at once and overflowing the SCTP send
+ * buffer (see livekit/client-sdk-js#1995).
+ *
+ * Waiters are parked on the channel object captured at wait entry. If that object stops being
+ * current — replaced or torn down — its events may never fire again, so the owner must call
+ * {@link invalidateWaiters}, which aborts parked waiters (releasing the gate); the next waiter
+ * gets a fresh controller.
+ */
+class FlowControlledDataChannel {
+  constructor(opts) {
+    /** Last emitted low-water status; starts true (an empty buffer is below the mark). */
+    this.bufferStatusLow = true;
+    this.headroomLock = new _();
+    /** Cancels parked headroom waiters when the handle is replaced or torn down. */
+    this.waiterAbortController = new AbortController();
+    this.kind = opts.kind;
+    this.lowWaterMark = opts.lowWaterMark;
+    this.highWaterMark = opts.highWaterMark;
+    this.isEngineClosed = opts.isEngineClosed;
+    this.onBufferStatusChanged = opts.onBufferStatusChanged;
   }
-}
-// Use conditional inheritance to avoid parse-time errors
-const RecorderBase = isMediaRecorderAvailable ? MediaRecorder : FallbackRecorder;
-class LocalTrackRecorder extends RecorderBase {
-  constructor(track, options) {
-    if (!isMediaRecorderAvailable) {
-      throw new Error('MediaRecorder is not available in this environment');
+  /** The currently attached RTCDataChannel handle, if any. */
+  get channelHandle() {
+    return this.handle;
+  }
+  /**
+   * Attaches the channel handle this wrapper controls. Replacing an existing handle rejects
+   * parked waiters — their events would never fire again on the abandoned object — and installs a
+   * fresh controller, so queued senders re-check against the new channel. Wrappers outlive their
+   * handles: this is the one place handle turnover happens, which is what makes stranding a
+   * waiter structurally impossible.
+   */
+  attach(dc) {
+    if (this.handle && this.handle !== dc) {
+      this.invalidateWaiters('data channel replaced');
     }
-    super(new MediaStream([track.mediaStreamTrack]), options);
-    let dataListener;
-    let streamController;
-    const isClosed = () => streamController === undefined;
-    const onStop = () => {
-      this.removeEventListener('dataavailable', dataListener);
-      this.removeEventListener('stop', onStop);
-      this.removeEventListener('error', onError);
-      streamController === null || streamController === void 0 ? void 0 : streamController.close();
-      streamController = undefined;
-    };
-    const onError = event => {
-      streamController === null || streamController === void 0 ? void 0 : streamController.error(event);
-      this.removeEventListener('dataavailable', dataListener);
-      this.removeEventListener('stop', onStop);
-      this.removeEventListener('error', onError);
-      streamController = undefined;
-    };
-    this.byteStream = new ReadableStream({
-      start: controller => {
-        streamController = controller;
-        dataListener = event => __awaiter(this, void 0, void 0, function* () {
-          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(data);
-        });
-        this.addEventListener('dataavailable', dataListener);
-      },
-      cancel: () => {
-        onStop();
-      }
-    });
-    this.addEventListener('stop', onStop);
-    this.addEventListener('error', onError);
+    this.handle = dc;
   }
-}
-// Helper function to check if recording is supported
-function isRecordingSupported() {
-  return isMediaRecorderAvailable;
-}const DEFAULT_DIMENSIONS_TIMEOUT = 1000;
-const PRE_CONNECT_BUFFER_TIMEOUT = 10000;
-class LocalTrack extends Track {
-  /** @internal */
-  get sender() {
-    return this._sender;
+  /** Detaches the handle on teardown, rejecting parked waiters. */
+  detach() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data channel torn down';
+    if (this.handle) {
+      this.invalidateWaiters(reason);
+    }
+    this.handle = undefined;
   }
-  /** @internal */
-  set sender(sender) {
-    this._sender = sender;
+  getChannel() {
+    return this.handle;
   }
-  get constraints() {
-    return this._constraints;
+  /**
+   * Whether the send buffer has room to accept more data (the send gate). Senders proceed while
+   * this is true and block once it goes false. Callers resolve the handle (and decide what an
+   * absent one means) before asking.
+   */
+  isBelowHighWaterMark(dc) {
+    // RTCDataChannel has no built-in high-water mark, so we compare against our static mark.
+    return dc.bufferedAmount <= this.highWaterMark;
   }
-  get hasPreConnectBuffer() {
-    return !!this.localTrackRecorder;
+  /**
+   * Whether the send buffer has drained to its low-water mark. Drives the engine's public
+   * DCBufferStatusChanged event.
+   */
+  isBelowLowWaterMark(dc) {
+    // Read the channel's own threshold: it is tuned dynamically for the lossy channel.
+    return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
   }
   /**
-   *
-   * @param mediaTrack
-   * @param kind
-   * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
-   * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
+   * Acquires the headroom lock, resolving with the unlock function. Batch senders (the resume
+   * replay) hold it across all of their sends so no other sender can interleave, calling
+   * {@link waitForHeadroomWithoutLock} per message to respect flow control within the batch.
    */
-  constructor(mediaTrack, kind, constraints) {
-    let userProvidedTrack = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    let loggerOptions = arguments.length > 4 ? arguments[4] : undefined;
-    super(mediaTrack, kind, loggerOptions);
-    this.manuallyStopped = false;
-    this.pendingDeviceChange = false;
-    this._isUpstreamPaused = false;
-    this.handleTrackMuteEvent = () => this.debouncedTrackMuteHandler().catch(() => this.log.debug('track mute bounce got cancelled by an unmute event', this.logContext));
-    this.debouncedTrackMuteHandler = debounce(() => __awaiter(this, void 0, void 0, function* () {
+  lockHeadroom() {
+    return this.headroomLock.lock();
+  }
+  /**
+   * Resolves once the caller may send on this channel: immediately while the send buffer is at or
+   * below its high-water mark, otherwise once the buffer has drained to the low-water mark (the
+   * `bufferedamountlow` event). Callers are serialized through the headroom lock so that, when
+   * the buffer drains, they refill it one at a time (up to the high-water mark) rather than all
+   * sending at once and overflowing the SCTP send buffer (see livekit/client-sdk-js#1995). The
+   * closed/buffer checks run inside the lock so queued callers proceed in FIFO order.
+   */
+  waitForHeadroomWithLock() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.lockHeadroom();
+      try {
+        yield this.waitForHeadroomWithoutLock();
+      } finally {
+        unlock();
+      }
+    });
+  }
+  /** Core wait of {@link waitForHeadroomWithLock}. The caller must hold the headroom lock. */
+  waitForHeadroomWithoutLock() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.isEngineClosed()) {
+        throw new UnexpectedConnectionState('engine closed');
+      }
+      const dc = this.getChannel();
+      if (!dc) {
+        throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(this.kind));
+      }
+      if (this.isBelowHighWaterMark(dc)) {
+        return;
+      }
+      const abortSignal = this.waiterAbortController.signal;
+      yield new TypedPromise((resolve, reject) => {
+        const onBufferedAmountLow = () => {
+          cleanup();
+          resolve();
+        };
+        const onDCClose = () => {
+          cleanup();
+          reject(new UnexpectedConnectionState("DataChannel ".concat(this.kind, " closed while draining the buffer")));
+        };
+        const onAbort = () => {
+          cleanup();
+          reject(new UnexpectedConnectionState("DataChannel ".concat(this.kind, " was replaced or torn down while waiting for headroom")));
+        };
+        const cleanup = () => {
+          dc.removeEventListener('bufferedamountlow', onBufferedAmountLow);
+          dc.removeEventListener('close', onDCClose);
+          abortSignal.removeEventListener('abort', onAbort);
+        };
+        if (abortSignal.aborted) {
+          onAbort();
+          return;
+        }
+        dc.addEventListener('bufferedamountlow', onBufferedAmountLow);
+        // Proxy along any error caused by the data channel closing while we wait.
+        dc.addEventListener('close', onDCClose);
+        // The channel object we're parked on can be abandoned without ever firing another event
+        // (e.g. the engine recreating channels); the abort is our way out.
+        abortSignal.addEventListener('abort', onAbort);
+      });
+    });
+  }
+  /** Rejects all parked headroom waiters; the next waiter gets a fresh controller. */
+  invalidateWaiters(reason) {
+    this.waiterAbortController.abort(reason);
+    this.waiterAbortController = new AbortController();
+  }
+  /**
+   * Recomputes whether the buffer has drained to the low-water mark and, if that changed since the
+   * last check, notifies the status listener. Two independent triggers land here: a send (which
+   * raises the buffer) and the `bufferedamountlow` drain event (which lowers it) — the latter has
+   * no send to hang the work off, which is why this is a shared entry point rather than a tail of
+   * `send`.
+   */
+  refreshBufferStatus() {
+    var _a;
+    const dc = this.getChannel();
+    if (!dc) {
+      return;
+    }
+    const isLow = this.isBelowLowWaterMark(dc);
+    if (isLow !== this.bufferStatusLow) {
+      this.bufferStatusLow = isLow;
+      (_a = this.onBufferStatusChanged) === null || _a === void 0 ? void 0 : _a.call(this, isLow);
+    }
+  }
+}/**
+ * A lossy channel: flow control plus a per-instance full-buffer policy.
+ *
+ * Each instance owns its own byterate stat, drop counter, and (when tuning is started) the
+ * dynamic `bufferedAmountLowThreshold` adjustment that keeps the drop gate at roughly 100ms of
+ * buffered latency. Keeping these per instance is what prevents one channel's traffic from
+ * steering another channel's policy.
+ */
+class LossyDataChannel extends FlowControlledDataChannel {
+  constructor(opts) {
+    super(opts);
+    this.statCurrentBytes = 0;
+    this.statByterate = 0;
+    this.dropCount = 0;
+    this.bufferFullBehavior = opts.bufferFullBehavior;
+    this.shouldSkipSends = opts.shouldSkipSends;
+  }
+  /** Sends prepared bytes with this channel's full-buffer policy (drop or wait). */
+  send(msg) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const dc = this.getChannel();
+      if (!dc) {
+        return;
+      }
+      // Depending on the channel's policy, either drop or wait for the buffer to drain below the
+      // high-water mark before continuing.
+      switch (this.bufferFullBehavior) {
+        case 'wait':
+          if (!this.isBelowHighWaterMark(dc)) {
+            yield this.waitForHeadroomWithLock();
+          }
+          break;
+        case 'drop':
+          // We check against the actual threshold on the DC here, as it is tuned dynamically.
+          if (!this.isBelowLowWaterMark(dc)) {
+            // Drop messages to reduce latency
+            this.dropCount += 1;
+            if (this.dropCount % 100 === 0) {
+              livekitLogger.warn("dropping lossy data channel messages, total dropped: ".concat(this.dropCount));
+            }
+            return;
+          }
+      }
+      this.statCurrentBytes += msg.byteLength;
+      if (this.shouldSkipSends()) {
+        return;
+      }
+      try {
+        dc.send(msg);
+        this.refreshBufferStatus();
+      } catch (error) {
+        // Preserve prior surface behaviour: a send that fails because the channel is closing is
+        // logged, not thrown, so lossy/data-track sends don't reject during teardown windows.
+        if (error instanceof TypeError) {
+          livekitLogger.error(error);
+        } else {
+          throw error;
+        }
+      }
+    });
+  }
+  /**
+   * Starts the once-per-second adjustment of the channel's `bufferedAmountLowThreshold` to the
+   * observed byterate, keeping the drop gate at roughly 100ms of buffered latency (clamped to
+   * the watermarks). Restarts cleanly if already running.
+   */
+  startThresholdTuning() {
+    this.stopThresholdTuning();
+    this.statInterval = CriticalTimers.setInterval(() => {
+      this.statByterate = this.statCurrentBytes;
+      this.statCurrentBytes = 0;
+      const dc = this.getChannel();
+      if (dc) {
+        // control buffered latency to ~100ms
+        const threshold = this.statByterate / 10;
+        dc.bufferedAmountLowThreshold = Math.min(Math.max(threshold, this.lowWaterMark), this.highWaterMark);
+      }
+    }, 1000);
+  }
+  /** Stops the threshold tuning and resets the stats and drop counter. */
+  stopThresholdTuning() {
+    this.statByterate = 0;
+    this.statCurrentBytes = 0;
+    if (this.statInterval) {
+      CriticalTimers.clearInterval(this.statInterval);
+      this.statInterval = undefined;
+    }
+    this.dropCount = 0;
+  }
+}class DataPacketBuffer {
+  constructor() {
+    this.buffer = [];
+    this._totalSize = 0;
+    this._sentSize = 0;
+  }
+  push(item) {
+    this.buffer.push(item);
+    this._totalSize += item.data.byteLength;
+    if (item.sent) {
+      this._sentSize += item.data.byteLength;
+    }
+  }
+  pop() {
+    const item = this.buffer.shift();
+    if (item) {
+      this._totalSize -= item.data.byteLength;
+      if (item.sent) {
+        this._sentSize -= item.data.byteLength;
+      }
+    }
+    return item;
+  }
+  getAll() {
+    return this.buffer.slice();
+  }
+  /** Every queued packet not yet handed to the channel, in sequence order. */
+  getUnsent() {
+    return this.buffer.filter(item => !item.sent);
+  }
+  /** Marks a single queued packet as handed to the channel. */
+  markSent(item) {
+    if (!item.sent) {
+      item.sent = true;
+      this._sentSize += item.data.byteLength;
+    }
+  }
+  /**
+   * Marks every queued packet as not-yet-sent. Used at the start of a resume replay: whatever is
+   * still buffered was sent on the previous channel (or deferred) and must be re-handed to the
+   * current one, so none of it counts as sent until the replay actually transmits it.
+   */
+  markAllUnsent() {
+    for (const item of this.buffer) {
+      item.sent = false;
+    }
+    this._sentSize = 0;
+  }
+  popToSequence(sequence) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (first.sequence <= sequence) {
+        this.pop();
+      } else {
+        break;
+      }
+    }
+  }
+  alignBufferedAmount(bufferedAmount) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      // Unsent packets aren't part of the channel's bufferedAmount and are still awaiting the
+      // resume replay — trimming them would silently lose them.
+      if (!first.sent) {
+        break;
+      }
+      if (this._sentSize - first.data.byteLength <= bufferedAmount) {
+        break;
+      }
+      this.pop();
+    }
+  }
+  get length() {
+    return this.buffer.length;
+  }
+}/**
+ * The reliable channel: flow control plus delivery-across-resume semantics.
+ *
+ * Every packet gets a monotonic sequence (stamped into the protobuf by the caller before
+ * serialization, via {@link nextSequence}) and is retained in a replay buffer until the channel's
+ * `bufferedAmount` confirms it has been handed to the transport. Sends that land in a reconnect
+ * window — or whose headroom wait is torn down transiently — are queued unsent and resolve;
+ * {@link replay} delivers them (plus any unacked packets) after a resume. Only an engine close
+ * rejects, because no replay is coming after that.
+ */
+class ReliableDataChannel extends FlowControlledDataChannel {
+  constructor(opts) {
+    super(opts);
+    this.messageBuffer = new DataPacketBuffer();
+    this.sequence = 1;
+    this.isDeferringSends = opts.isDeferringSends;
+  }
+  /**
+   * Claims the next packet sequence. The caller stamps it into the packet before serialization,
+   * then passes it back to {@link send} so the replay buffer stays keyed by wire sequence.
+   */
+  nextSequence() {
+    const sequence = this.sequence;
+    this.sequence += 1;
+    return sequence;
+  }
+  /**
+   * Sends prepared bytes with reliable semantics. Resolves once the packet has either been handed
+   * to the channel or queued for the resume replay; throws only when the engine is closed.
+   */
+  send(msg, sequence) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.isDeferringSends()) {
+        // A reconnect is already underway — queue for the resume replay instead of parking on a
+        // channel that is being torn down. The send resolves; delivery is deferred to the replay.
+        this.messageBuffer.push({
+          data: msg,
+          sequence,
+          sent: false
+        });
+        return;
+      }
+      const dc = this.getChannel();
+      if (!dc) {
+        return;
+      }
+      try {
+        yield this.waitForHeadroomWithLock();
+      } catch (error) {
+        if (this.isEngineClosed()) {
+          // No replay is coming after an engine close — surface the failure.
+          throw error;
+        }
+        // Transient teardown (the channel closed or was replaced while we waited): the reliable
+        // channel promises delivery across resume, so queue the packet for the replay instead of
+        // rejecting a send the app can't meaningfully retry.
+        this.messageBuffer.push({
+          data: msg,
+          sequence,
+          sent: false
+        });
+        return;
+      }
+      if (this.isDeferringSends()) {
+        // A reconnect began while we waited for headroom — same deal as above.
+        this.messageBuffer.push({
+          data: msg,
+          sequence,
+          sent: false
+        });
+        return;
+      }
+      this.messageBuffer.push({
+        data: msg,
+        sequence,
+        sent: true
+      });
+      dc.send(msg);
+      this.refreshBufferStatus();
+    });
+  }
+  /**
+   * Replays the buffered backlog after a resume: drops everything the server acked
+   * (`lastMessageSeq`), then re-sends the rest in order. The headroom lock is held across the
+   * whole replay — releasing it between messages would let a concurrent send (whose newer
+   * sequence was already assigned before it queued on the lock) hit the wire mid-replay, and
+   * receivers would then discard the remaining lower-sequence resent messages as duplicates.
+   */
+  replay(lastMessageSeq) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const dc = this.getChannel();
+      if (!dc) {
+        return;
+      }
+      this.messageBuffer.popToSequence(lastMessageSeq);
+      const unlock = yield this.lockHeadroom();
+      try {
+        // Everything left after the ack cutoff must be re-handed to the current channel.
+        this.messageBuffer.markAllUnsent();
+        // Drain in passes, re-scanning the live buffer each time: a send that arrives (deferred,
+        // sent:false) during our own awaits appends after this pass started, so we pick it up on
+        // the next one. Mark each packet only once we've actually handed it to the channel — a
+        // blanket "mark all sent" would flip such a late arrival to sent without transmitting it,
+        // and a later alignBufferedAmount would then drop it for good. If the loop throws
+        // mid-drain, unsent entries keep their flag and the next replay picks them up.
+        for (let batch = this.messageBuffer.getUnsent(); batch.length > 0; batch = this.messageBuffer.getUnsent()) {
+          for (const item of batch) {
+            // Respect flow control on resume too, so a large resend doesn't overflow the buffer.
+            yield this.waitForHeadroomWithoutLock();
+            dc.send(item.data);
+            this.messageBuffer.markSent(item);
+          }
+        }
+      } finally {
+        unlock();
+      }
+      this.refreshBufferStatus();
+    });
+  }
+  /**
+   * Before recomputing status, trim packets the transport has now delivered — a send or a drain
+   * may have acked buffered packets, and the replay buffer is keyed off the channel's buffered
+   * bytes.
+   */
+  refreshBufferStatus() {
+    const dc = this.channelHandle;
+    if (dc) {
+      this.messageBuffer.alignBufferedAmount(dc.bufferedAmount);
+    }
+    super.refreshBufferStatus();
+  }
+  /**
+   * Drops all replay state and restarts sequencing. Only valid on a full reconnect, where the
+   * session (and the receivers' sequence tracking) starts over.
+   */
+  reset() {
+    this.messageBuffer = new DataPacketBuffer();
+    this.sequence = 1;
+  }
+}var DataChannelKind;
+(function (DataChannelKind) {
+  DataChannelKind[DataChannelKind["RELIABLE"] = 0] = "RELIABLE";
+  DataChannelKind[DataChannelKind["LOSSY"] = 1] = "LOSSY";
+  DataChannelKind[DataChannelKind["DATA_TRACK_LOSSY"] = 2] = "DATA_TRACK_LOSSY";
+})(DataChannelKind || (DataChannelKind = {}));
+// Two-watermark flow control for the reliable and data-track channels. Senders fill the buffer
+// freely up to the high-water mark; once it's exceeded they block until the browser's
+// `bufferedamountlow` event (which we arm at the low-water mark) signals the buffer has drained.
+// The gap between the marks keeps the SCTP send buffer saturated while we refill, so throughput
+// isn't starved, while the high-water mark bounds the buffer well below the level that would abort
+// the channel (see livekit/client-sdk-js#1995).
+const reliableDataChannelWaterMarkLow = 64 * 1024;
+const reliableDataChannelWaterMarkHigh = 1024 * 1024;
+const lossyDataChannelWaterMarkLow = 8 * 1024;
+const lossyDataChannelWaterMarkHigh = 256 * 1024;
+function dataChannelLowWaterMark(kind) {
+  return kind === DataChannelKind.RELIABLE ? reliableDataChannelWaterMarkLow : lossyDataChannelWaterMarkLow;
+}
+function dataChannelHighWaterMark(kind) {
+  return kind === DataChannelKind.RELIABLE ? reliableDataChannelWaterMarkHigh : lossyDataChannelWaterMarkHigh;
+}const lossyDataChannelLabel = '_lossy';
+const reliableDataChannelLabel = '_reliable';
+const dataTrackDataChannelLabel = '_data_track';
+/**
+ * Owns the engine's data channels: the three flow-controlled publisher channel wrappers (which
+ * live for the engine's lifetime and have RTCDataChannel handles attached/detached as peer
+ * connections come and go) plus the subscriber-side receive handles adopted by label.
+ *
+ * Handle turnover goes through {@link FlowControlledDataChannel.attach}/`detach`, which reject
+ * parked headroom waiters as a built-in — there is no separate invalidation step to forget.
+ */
+class DataChannelManager {
+  constructor(opts) {
+    this.opts = opts;
+    const flowControlOptions = kind => ({
+      kind,
+      lowWaterMark: dataChannelLowWaterMark(kind),
+      highWaterMark: dataChannelHighWaterMark(kind),
+      isEngineClosed: opts.isEngineClosed,
+      onBufferStatusChanged: isLow => opts.onBufferStatusChanged(kind, isLow)
+    });
+    this.reliable = new ReliableDataChannel(Object.assign(Object.assign({}, flowControlOptions(DataChannelKind.RELIABLE)), {
+      isDeferringSends: opts.isReconnecting
+    }));
+    this.lossy = new LossyDataChannel(Object.assign(Object.assign({}, flowControlOptions(DataChannelKind.LOSSY)), {
+      // Classic lossy user data: a stale packet is worthless, so drop instead of queueing.
+      bufferFullBehavior: 'drop',
+      shouldSkipSends: opts.isReconnecting
+    }));
+    this.dataTrack = new LossyDataChannel(Object.assign(Object.assign({}, flowControlOptions(DataChannelKind.DATA_TRACK_LOSSY)), {
+      // Data tracks backpressure the producer instead — it decides what to skip at frame
+      // granularity rather than the engine dropping arbitrary chunks out of frames.
+      bufferFullBehavior: 'wait',
+      shouldSkipSends: opts.isReconnecting
+    }));
+  }
+  /** The flow-control wrapper for `kind`. */
+  channelFor(kind) {
+    switch (kind) {
+      case DataChannelKind.RELIABLE:
+        return this.reliable;
+      case DataChannelKind.LOSSY:
+        return this.lossy;
+      case DataChannelKind.DATA_TRACK_LOSSY:
+        return this.dataTrack;
+    }
+  }
+  /** The raw RTCDataChannel handle for `kind`, publisher side by default. */
+  getHandle(kind) {
+    let subscriber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (!subscriber) {
+      return this.channelFor(kind).channelHandle;
+    }
+    switch (kind) {
+      case DataChannelKind.RELIABLE:
+        return this.reliableSub;
+      case DataChannelKind.LOSSY:
+        return this.lossySub;
+      case DataChannelKind.DATA_TRACK_LOSSY:
+        return this.dataTrackSub;
+    }
+  }
+  get hasPublisherChannels() {
+    return Boolean(this.reliable.channelHandle || this.lossy.channelHandle || this.dataTrack.channelHandle);
+  }
+  /**
+   * Creates the three publisher data channels on the given transport, wires their handlers, and
+   * attaches them to the wrappers — attaching rejects any waiters still parked on replaced
+   * channel objects.
+   */
+  createPublisherChannels(pcManager) {
+    // clear old data channel callbacks if recreate
+    for (const channel of [this.lossy, this.reliable, this.dataTrack]) {
+      const old = channel.channelHandle;
+      if (old) {
+        old.onmessage = null;
+        old.onerror = null;
+        old.onclose = null;
+      }
+    }
+    const wire = (channel, dc, onMessage) => {
+      // also handle messages over the pub channel, for backwards compatibility
+      dc.onmessage = onMessage;
+      // handle datachannel errors
+      dc.onerror = this.opts.onDataError;
+      // detect unexpected publisher data channel closes
+      dc.onclose = () => this.opts.onChannelClose(channel.kind);
+      // set up dc buffer threshold - if this is not set, it will default to 0
+      dc.bufferedAmountLowThreshold = channel.lowWaterMark;
+      // handle buffer amount low events
+      dc.onbufferedamountlow = () => channel.refreshBufferStatus();
+      channel.attach(dc);
+    };
+    wire(this.lossy, pcManager.createPublisherDataChannel(lossyDataChannelLabel, {
+      ordered: false,
+      maxRetransmits: 0
+    }), this.opts.onDataMessage);
+    wire(this.reliable, pcManager.createPublisherDataChannel(reliableDataChannelLabel, {
+      ordered: true
+    }), this.opts.onDataMessage);
+    wire(this.dataTrack, pcManager.createPublisherDataChannel(dataTrackDataChannelLabel, {
+      ordered: false,
+      maxRetransmits: 0
+    }), this.opts.onDataTrackMessage);
+    this.lossy.startThresholdTuning();
+  }
+  /**
+   * Adopts a subscriber-side data channel by label, wiring the matching receive handler.
+   * Returns false for labels this manager doesn't own.
+   */
+  adoptSubscriberChannel(channel) {
+    let handler;
+    if (channel.label === reliableDataChannelLabel) {
+      this.reliableSub = channel;
+      handler = this.opts.onDataMessage;
+    } else if (channel.label === lossyDataChannelLabel) {
+      this.lossySub = channel;
+      handler = this.opts.onDataMessage;
+    } else if (channel.label === dataTrackDataChannelLabel) {
+      this.dataTrackSub = channel;
+      handler = this.opts.onDataTrackMessage;
+    } else {
+      return false;
+    }
+    channel.onmessage = handler;
+    return true;
+  }
+  /**
+   * Tears down all channels for a peer-connection cleanup: rejects parked waiters (detach — the
+   * spec allows `pc.close()` to transition channels to 'closed' without firing events, so waiting
+   * for browser close events is not an option), strips handlers, closes the handles, and resets
+   * the reliable session state.
+   */
+  teardown() {
+    const dcCleanup = dc => {
+      if (!dc) {
+        return;
+      }
+      // Detach the data channel handlers before closing anything. Closing a peer connection tears
+      // down the SCTP transport, which can dispatch `error`/`close` events on the still-open data
+      // channels; if our handlers are still attached at that point, handleDataError logs a spurious
+      // "Unknown DataChannel error" during an otherwise graceful disconnect. Removing the handlers
+      // before dc.close()/pcManager.close() makes this deterministic regardless of how/when the
+      // browser dispatches those teardown events. See livekit/client-sdk-js#1953.
+      dc.onbufferedamountlow = null;
+      dc.onclose = null;
+      dc.onclosing = null;
+      dc.onerror = null;
+      dc.onmessage = null;
+      dc.onopen = null;
+      dc.close();
+    };
+    for (const channel of [this.lossy, this.reliable, this.dataTrack]) {
+      const dc = channel.channelHandle;
+      channel.detach('peer connections cleaned up');
+      dcCleanup(dc);
+    }
+    dcCleanup(this.lossySub);
+    dcCleanup(this.reliableSub);
+    dcCleanup(this.dataTrackSub);
+    this.lossySub = undefined;
+    this.reliableSub = undefined;
+    this.dataTrackSub = undefined;
+    // Full teardown starts the session over: drop replay state and restart sequencing.
+    this.reliable.reset();
+  }
+}// Check if MediaRecorder is available
+const isMediaRecorderAvailable = typeof MediaRecorder !== 'undefined';
+// Fallback class for environments without MediaRecorder
+class FallbackRecorder {
+  constructor() {
+    throw new Error('MediaRecorder is not available in this environment');
+  }
+}
+// Use conditional inheritance to avoid parse-time errors
+const RecorderBase = isMediaRecorderAvailable ? MediaRecorder : FallbackRecorder;
+class LocalTrackRecorder extends RecorderBase {
+  constructor(track, options) {
+    if (!isMediaRecorderAvailable) {
+      throw new Error('MediaRecorder is not available in this environment');
+    }
+    super(new MediaStream([track.mediaStreamTrack]), options);
+    let dataListener;
+    let streamController;
+    const isClosed = () => streamController === undefined;
+    const onStop = () => {
+      this.removeEventListener('dataavailable', dataListener);
+      this.removeEventListener('stop', onStop);
+      this.removeEventListener('error', onError);
+      streamController === null || streamController === void 0 ? void 0 : streamController.close();
+      streamController = undefined;
+    };
+    const onError = event => {
+      streamController === null || streamController === void 0 ? void 0 : streamController.error(event);
+      this.removeEventListener('dataavailable', dataListener);
+      this.removeEventListener('stop', onStop);
+      this.removeEventListener('error', onError);
+      streamController = undefined;
+    };
+    this.byteStream = new ReadableStream({
+      start: controller => {
+        streamController = controller;
+        dataListener = event => __awaiter(this, void 0, void 0, function* () {
+          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(data);
+        });
+        this.addEventListener('dataavailable', dataListener);
+      },
+      cancel: () => {
+        onStop();
+      }
+    });
+    this.addEventListener('stop', onStop);
+    this.addEventListener('error', onError);
+  }
+}
+// Helper function to check if recording is supported
+function isRecordingSupported() {
+  return isMediaRecorderAvailable;
+}const DEFAULT_DIMENSIONS_TIMEOUT = 1000;
+const PRE_CONNECT_BUFFER_TIMEOUT = 10000;
+class LocalTrack extends Track {
+  /** @internal */
+  get sender() {
+    return this._sender;
+  }
+  /** @internal */
+  set sender(sender) {
+    this._sender = sender;
+  }
+  get constraints() {
+    return this._constraints;
+  }
+  get hasPreConnectBuffer() {
+    return !!this.localTrackRecorder;
+  }
+  /**
+   *
+   * @param mediaTrack
+   * @param kind
+   * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
+   * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
+   */
+  constructor(mediaTrack, kind, constraints) {
+    let userProvidedTrack = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    let loggerOptions = arguments.length > 4 ? arguments[4] : undefined;
+    super(mediaTrack, kind, loggerOptions);
+    this.manuallyStopped = false;
+    this.pendingDeviceChange = false;
+    this._isUpstreamPaused = false;
+    this.handleTrackMuteEvent = () => this.debouncedTrackMuteHandler().catch(() => this.log.debug('track mute bounce got cancelled by an unmute event', this.logContext));
+    this.debouncedTrackMuteHandler = debounce(() => __awaiter(this, void 0, void 0, function* () {
       yield this.pauseUpstream();
     }), 5000);
     this.handleTrackUnmuteEvent = () => __awaiter(this, void 0, void 0, function* () {
@@ -21013,17 +22084,37 @@ class LocalVideoTrack extends LocalTrack {
   setDegradationPreference(preference) {
     return __awaiter(this, void 0, void 0, function* () {
       this.degradationPreference = preference;
-      if (this.sender) {
-        try {
-          this.log.debug("setting degradationPreference to ".concat(preference), this.logContext);
-          const params = this.sender.getParameters();
-          params.degradationPreference = preference;
-          this.sender.setParameters(params);
-        } catch (e) {
-          this.log.warn("failed to set degradationPreference", Object.assign({
-            error: e
-          }, this.logContext));
-        }
+      // applied one sender at a time on purpose, see applyDegradationPreference
+      yield this.applyDegradationPreference(this.sender);
+      for (const sc of this.simulcastCodecs.values()) {
+        yield this.applyDegradationPreference(sc.sender);
+      }
+    });
+  }
+  /**
+   * Degradation preference is a property of the sender, not of the track, so every sender
+   * publishing this track needs it applied separately. A backup codec publishes over its
+   * own sender, which would otherwise let the browser resolve a preference implicitly and
+   * diverge from the primary encoder.
+   *
+   * Callers apply this sequentially rather than concurrently: `setParameters` is only valid
+   * against the parameters most recently returned by `getParameters`, which is why this file
+   * serializes other sender parameter updates through `senderLock`.
+   */
+  applyDegradationPreference(sender) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!sender) {
+        return;
+      }
+      try {
+        this.log.debug("setting degradationPreference to ".concat(this.degradationPreference), this.logContext);
+        const params = sender.getParameters();
+        params.degradationPreference = this.degradationPreference;
+        yield sender.setParameters(params);
+      } catch (e) {
+        this.log.warn("failed to set degradationPreference", Object.assign({
+          error: e
+        }, this.logContext));
       }
     });
   }
@@ -21042,18 +22133,23 @@ class LocalVideoTrack extends LocalTrack {
     return simulcastCodecInfo;
   }
   setSimulcastTrackSender(codec, sender) {
-    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
-    if (!simulcastCodecInfo) {
-      return;
-    }
-    simulcastCodecInfo.sender = sender;
-    // browser will reenable disabled codec/layers after new codec has been published,
-    // so refresh subscribedCodecs after publish a new codec
-    setTimeout(() => {
-      if (this.subscribedCodecs) {
-        this.setPublishingCodecs(this.subscribedCodecs);
+    return __awaiter(this, void 0, void 0, function* () {
+      const simulcastCodecInfo = this.simulcastCodecs.get(codec);
+      if (!simulcastCodecInfo) {
+        return;
       }
-    }, refreshSubscribedCodecAfterNewCodec);
+      simulcastCodecInfo.sender = sender;
+      // the backup codec publishes over its own sender, so it needs the same degradation
+      // preference the primary sender resolved to.
+      yield this.applyDegradationPreference(sender);
+      // browser will reenable disabled codec/layers after new codec has been published,
+      // so refresh subscribedCodecs after publish a new codec
+      setTimeout(() => {
+        if (this.subscribedCodecs) {
+          this.setPublishingCodecs(this.subscribedCodecs);
+        }
+      }, refreshSubscribedCodecAfterNewCodec);
+    });
   }
   /**
    * @internal
@@ -21323,22 +22419,14 @@ function videoLayersFromEncodings(width, height, encodings, svc) {
       ssrc: 0
     });
   });
-}const lossyDataChannel = '_lossy';
-const reliableDataChannel = '_reliable';
-const dataTrackDataChannel = '_data_track';
-const minReconnectWait = 2 * 1000;
+}const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
+/**
+ * How long local connection quality must stay `LOST` while connected and publishing before we
+ * force a full reconnect — `LOST` is the server's verdict that it isn't receiving our media.
+ */
+const connectionQualityLostTimeout = 10 * 1000;
 const reliabeReceiveStateTTL = 30000;
-// Two-watermark flow control for the reliable and data-track channels. Senders fill the buffer
-// freely up to the high-water mark; once it's exceeded they block until the browser's
-// `bufferedamountlow` event (which we arm at the low-water mark) signals the buffer has drained.
-// The gap between the marks keeps the SCTP send buffer saturated while we refill, so throughput
-// isn't starved, while the high-water mark bounds the buffer well below the level that would abort
-// the channel (see livekit/client-sdk-js#1995).
-const reliableDataChannelWaterMarkLow = 64 * 1024;
-const reliableDataChannelWaterMarkHigh = 1024 * 1024;
-const lossyDataChannelWaterMarkLow = 8 * 1024;
-const lossyDataChannelWaterMarkHigh = 256 * 1024;
 const initialMediaSectionsAudio = 3;
 const initialMediaSectionsVideo = 3;
 var PCState;
@@ -21349,12 +22437,6 @@ var PCState;
   PCState[PCState["Reconnecting"] = 3] = "Reconnecting";
   PCState[PCState["Closed"] = 4] = "Closed";
 })(PCState || (PCState = {}));
-var DataChannelKind;
-(function (DataChannelKind) {
-  DataChannelKind[DataChannelKind["RELIABLE"] = 0] = "RELIABLE";
-  DataChannelKind[DataChannelKind["LOSSY"] = 1] = "LOSSY";
-  DataChannelKind[DataChannelKind["DATA_TRACK_LOSSY"] = 2] = "DATA_TRACK_LOSSY";
-})(DataChannelKind || (DataChannelKind = {}));
 // Default data-channel max message size (bytes), used when the remote SDP
 // answer does not advertise an `a=max-message-size` attribute (RFC 8841).
 // `0` means "no limit".
@@ -21370,6 +22452,15 @@ class RTCEngine extends eventsExports.EventEmitter {
   get pendingReconnect() {
     return !!this.reconnectTimeout;
   }
+  get reliableChannel() {
+    return this.dataChannels.reliable;
+  }
+  get lossyChannel() {
+    return this.dataChannels.lossy;
+  }
+  get dataTrackChannel() {
+    return this.dataChannels.dataTrack;
+  }
   constructor(options) {
     var _a;
     super();
@@ -21396,12 +22487,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.shouldFailNext = false;
     this.shouldFailOnV1Path = false;
     this.log = livekitLogger;
-    this.reliableDataSequence = 1;
-    this.reliableMessageBuffer = new DataPacketBuffer();
     this.reliableReceivedState = new TTLMap(reliabeReceiveStateTTL);
-    this.lossyDataStatCurrentBytes = 0;
-    this.lossyDataStatByterate = 0;
-    this.lossyDataDropCount = 0;
     this.midToTrackId = {};
     /** used to indicate whether the browser is currently waiting to reconnect */
     this.isWaitingForNetworkReconnect = false;
@@ -21412,21 +22498,9 @@ class RTCEngine extends eventsExports.EventEmitter {
         if (!channel) {
           return;
         }
-        let handler;
-        if (channel.label === reliableDataChannel) {
-          _this.reliableDCSub = channel;
-          handler = _this.handleDataMessage;
-        } else if (channel.label === lossyDataChannel) {
-          _this.lossyDCSub = channel;
-          handler = _this.handleDataMessage;
-        } else if (channel.label === dataTrackDataChannel) {
-          _this.dataTrackDCSub = channel;
-          handler = _this.handleDataTrackMessage;
-        } else {
-          return;
+        if (_this.dataChannels.adoptSubscriberChannel(channel)) {
+          _this.log.debug("on data channel ".concat(channel.id, ", ").concat(channel.label));
         }
-        _this.log.debug("on data channel ".concat(channel.id, ", ").concat(channel.label));
-        channel.onmessage = handler;
       }();
     });
     this.handleDataMessage = message => __awaiter(this, void 0, void 0, function* () {
@@ -21434,19 +22508,11 @@ class RTCEngine extends eventsExports.EventEmitter {
       // make sure to respect incoming data message order by processing message events one after the other
       const unlock = yield this.dataProcessLock.lock();
       try {
-        // decode
-        let buffer;
-        if (message.data instanceof ArrayBuffer) {
-          buffer = message.data;
-        } else if (message.data instanceof Blob) {
-          buffer = yield message.data.arrayBuffer();
-        } else {
-          this.log.error('unsupported data type', {
-            data: message.data
-          });
+        const bytes = yield this.decodeDataMessage(message);
+        if (!bytes) {
           return;
         }
-        const dp = DataPacket.fromBinary(new Uint8Array(buffer));
+        const dp = DataPacket.fromBinary(bytes);
         if (dp.sequence > 0 && dp.participantSid !== '') {
           const lastSeq = this.reliableReceivedState.get(dp.participantSid);
           if (lastSeq && dp.sequence <= lastSeq) {
@@ -21487,19 +22553,11 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
     });
     this.handleDataTrackMessage = message => __awaiter(this, void 0, void 0, function* () {
-      // Decode / normalize into a common format
-      let buffer;
-      if (message.data instanceof ArrayBuffer) {
-        buffer = message.data;
-      } else if (message.data instanceof Blob) {
-        buffer = yield message.data.arrayBuffer();
-      } else {
-        this.log.error('unsupported data type', {
-          data: message.data
-        });
+      const bytes = yield this.decodeDataMessage(message);
+      if (!bytes) {
         return;
       }
-      this.emit('dataTrackPacketReceived', new Uint8Array(buffer));
+      this.emit('dataTrackPacketReceived', bytes);
     });
     this.handleDataError = event => {
       // Errors fired while we're tearing the connection down (e.g. the SCTP transport aborting as
@@ -21533,9 +22591,6 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.log.error("publisher data channel '".concat(DataChannelKind[kind], "' closed unexpectedly"), this.logContext);
       }
     };
-    this.handleBufferedAmountLow = channelKind => {
-      this.updateAndEmitDCBufferStatus(channelKind);
-    };
     // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
     // continues to work, we can reconnect to websocket to continue the session
     // after a number of retries, we'll close and give up permanently
@@ -21591,60 +22646,6 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.once(EngineEvent.Disconnected, onDisconnected);
       });
     };
-    this.updateAndEmitDCBufferStatus = kind => {
-      if (kind === DataChannelKind.RELIABLE) {
-        const dc = this.dataChannelForKind(kind);
-        if (dc) {
-          this.reliableMessageBuffer.alignBufferedAmount(dc.bufferedAmount);
-        }
-      }
-      try {
-        const status = this.isBelowLowWaterMark(kind);
-        if (typeof status !== 'undefined' && status !== this.dcBufferStatus.get(kind)) {
-          this.dcBufferStatus.set(kind, status);
-          this.emit(EngineEvent.DCBufferStatusChanged, status, kind);
-        }
-      } catch (e) {
-        this.log.warn('could not update buffer status', {
-          error: e
-        });
-      }
-    };
-    /**
-     * Whether the send buffer has room to accept more data (the send gate). Senders proceed while
-     * this is true and block once it goes false.
-     */
-    this.isBelowHighWaterMark = kind => {
-      const dc = this.dataChannelForKind(kind);
-      if (!dc) {
-        throw new TypeError("Could not get data channel for kind ".concat(kind));
-      }
-      // because RTCDatachannel has no high water mark built in we read the statically defined versions as constants
-      const highMark = kind === DataChannelKind.RELIABLE ? reliableDataChannelWaterMarkHigh : lossyDataChannelWaterMarkHigh;
-      return dc.bufferedAmount <= highMark;
-    };
-    /**
-     * Whether the send buffer has drained to its low-water mark. Drives the public
-     * {@link EngineEvent.DCBufferStatusChanged} event.
-     */
-    this.isBelowLowWaterMark = kind => {
-      const dc = this.dataChannelForKind(kind);
-      if (!dc) {
-        throw new TypeError("Could not get data channel for kind ".concat(kind));
-      }
-      // because RTCDatachannel has the threshold built in we can read it dynamically to account for changing thresholds over time
-      return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
-    };
-    /** Per-kind lock serializing senders that have to wait for the buffer to drain. */
-    this.waitForBufferHeadroomLocks = new Map();
-    /**
-     * Per-kind AbortController that cancels parked headroom waiters whenever a kind's channel object
-     * stops being current (replaced by createDataChannels or torn down by cleanupPeerConnections). A
-     * waiter is parked on the channel object it captured at wait entry; if that object is abandoned
-     * its events may never fire again, so the abort is what rejects the waiter and releases the
-     * headroom lock instead of stranding every future sender behind it.
-     */
-    this.waiterAbortControllers = new Map();
     this.onRtpMapAvailable = rtpTypes => {
       const rtpMap = new Map();
       rtpTypes.forEach(rtp => {
@@ -21704,9 +22705,20 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.reconnectPolicy = this.options.reconnectPolicy;
     this.closingLock = new _();
     this.dataProcessLock = new _();
-    this.dcBufferStatus = new Map([[DataChannelKind.RELIABLE, true], [DataChannelKind.LOSSY, true], [DataChannelKind.DATA_TRACK_LOSSY, true]]);
+    this.dataChannels = new DataChannelManager({
+      isEngineClosed: () => this.isClosed,
+      isReconnecting: () => this.attemptingReconnect,
+      onDataMessage: message => this.handleDataMessage(message),
+      onDataTrackMessage: message => this.handleDataTrackMessage(message),
+      onDataError: event => this.handleDataError(event),
+      onChannelClose: kind => this.handleDataChannelClose(kind)(),
+      onBufferStatusChanged: (kind, isLow) => this.emit(EngineEvent.DCBufferStatusChanged, isLow, kind)
+    });
     this.client.onParticipantUpdate = updates => this.emit(EngineEvent.ParticipantUpdate, updates);
-    this.client.onConnectionQuality = update => this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    this.client.onConnectionQuality = update => {
+      this.handleLocalConnectionQuality(update);
+      this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    };
     this.client.onRoomUpdate = update => this.emit(EngineEvent.RoomUpdate, update);
     this.client.onSubscriptionError = resp => this.emit(EngineEvent.SubscriptionError, resp);
     this.client.onSubscriptionPermissionUpdate = update => this.emit(EngineEvent.SubscriptionPermissionUpdate, update);
@@ -21849,6 +22861,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.removeAllListeners();
         this.deregisterOnLineListener();
         this.clearPendingReconnect();
+        this.clearLostQualityTimeout();
         this.cleanupLossyDataStats();
         yield this.cleanupPeerConnections();
         yield this.cleanupClient();
@@ -21860,55 +22873,16 @@ class RTCEngine extends eventsExports.EventEmitter {
   cleanupPeerConnections() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      // Reject parked headroom waiters up front: closing the peer connection is allowed (per spec)
-      // to transition data channels to 'closed' without firing events, which would otherwise strand
-      // a waiter holding the headroom lock.
-      this.invalidateDataChannelWaiters('peer connections cleaned up');
-      const dcCleanup = dc => {
-        if (!dc) {
-          return;
-        }
-        // Detach the data channel handlers before closing anything. Closing a peer connection tears
-        // down the SCTP transport, which can dispatch `error`/`close` events on the still-open data
-        // channels; if our handlers are still attached at that point, handleDataError logs a spurious
-        // "Unknown DataChannel error" during an otherwise graceful disconnect. Removing the handlers
-        // before dc.close()/pcManager.close() makes this deterministic regardless of how/when the
-        // browser dispatches those teardown events. See livekit/client-sdk-js#1953.
-        dc.onbufferedamountlow = null;
-        dc.onclose = null;
-        dc.onclosing = null;
-        dc.onerror = null;
-        dc.onmessage = null;
-        dc.onopen = null;
-        dc.close();
-      };
-      dcCleanup(this.lossyDC);
-      dcCleanup(this.lossyDCSub);
-      dcCleanup(this.reliableDC);
-      dcCleanup(this.reliableDCSub);
-      dcCleanup(this.dataTrackDC);
-      dcCleanup(this.dataTrackDCSub);
+      this.dataChannels.teardown();
       yield (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.close();
       this.pcManager = undefined;
-      this.lossyDC = undefined;
-      this.lossyDCSub = undefined;
-      this.reliableDC = undefined;
-      this.reliableDCSub = undefined;
-      this.dataTrackDC = undefined;
-      this.dataTrackDCSub = undefined;
-      this.reliableMessageBuffer = new DataPacketBuffer();
-      this.reliableDataSequence = 1;
+      // the connecting timestamp belongs to the transports we just tore down
+      this.transportConnectingSince = undefined;
       this.reliableReceivedState.clear();
     });
   }
   cleanupLossyDataStats() {
-    this.lossyDataStatByterate = 0;
-    this.lossyDataStatCurrentBytes = 0;
-    if (this.lossyDataStatInterval) {
-      clearInterval(this.lossyDataStatInterval);
-      this.lossyDataStatInterval = undefined;
-    }
-    this.lossyDataDropCount = 0;
+    this.lossyChannel.stopThresholdTuning();
   }
   cleanupClient() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -21929,17 +22903,17 @@ class RTCEngine extends eventsExports.EventEmitter {
       throw new TrackInvalidError('a track with the same ID has already been published');
     }
     return new Promise((resolve, reject) => {
-      const publicationTimeout = setTimeout(() => {
+      const publicationTimeout = CriticalTimers.setTimeout(() => {
         delete this.pendingTrackResolvers[req.cid];
         reject(ConnectionError.timeout('publication of local track timed out, no response from server'));
       }, 10000);
       this.pendingTrackResolvers[req.cid] = {
         resolve: info => {
-          clearTimeout(publicationTimeout);
+          CriticalTimers.clearTimeout(publicationTimeout);
           resolve(info);
         },
         reject: () => {
-          clearTimeout(publicationTimeout);
+          CriticalTimers.clearTimeout(publicationTimeout);
           reject(new Error('Cancelled publication by calling unpublish'));
         }
       };
@@ -21975,7 +22949,7 @@ class RTCEngine extends eventsExports.EventEmitter {
   }
   get dataSubscriberReadyState() {
     var _a;
-    return (_a = this.reliableDCSub) === null || _a === void 0 ? void 0 : _a.readyState;
+    return (_a = this.dataChannelForKind(DataChannelKind.RELIABLE, true)) === null || _a === void 0 ? void 0 : _a.readyState;
   }
   getConnectedServerAddress() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -22012,6 +22986,15 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.pcManager.onDataChannel = this.handleDataChannel;
       this.pcManager.onStateChange = (connectionState, publisherState, subscriberState) => __awaiter(this, void 0, void 0, function* () {
         this.log.debug("primary PC state changed ".concat(connectionState));
+        // Record when the primary transport actually entered CONNECTING so
+        // verifyTransport() can bound how long we tolerate it. Deriving it from the
+        // real transition (this handler only fires on state changes) rather than from
+        // observation time keeps it from going stale across peer-connection rebuilds.
+        if (connectionState === PCTransportState.CONNECTING) {
+          this.transportConnectingSince = Date.now();
+        } else {
+          this.transportConnectingSince = undefined;
+        }
         if (['closed', 'disconnected', 'failed'].includes(publisherState)) {
           // reset publisher connection promise
           this.publisherConnectionPromise = undefined;
@@ -22220,84 +23203,45 @@ class RTCEngine extends eventsExports.EventEmitter {
     }
   }
   addMediaSections(numAudios, numVideos) {
-    var _a, _b;
+    var _a, _b, _c;
     const transceiverInit = {
       direction: 'recvonly'
     };
     for (let i = 0; i < numAudios; i++) {
       (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.addPublisherTransceiverOfKind('audio', transceiverInit);
     }
+    // media only arrives on these sections when there is no subscriber connection to arrive on
+    const receivesMedia = ((_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.mode) === 'publisher-only';
     for (let i = 0; i < numVideos; i++) {
-      (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.addPublisherTransceiverOfKind('video', transceiverInit);
+      const transceiver = (_c = this.pcManager) === null || _c === void 0 ? void 0 : _c.addPublisherTransceiverOfKind('video', transceiverInit);
+      if (receivesMedia && transceiver) {
+        const negotiated = negotiateDependencyDescriptor(transceiver);
+        this.log.debug('dependency descriptor negotiated for received video', {
+          negotiated
+        });
+      }
     }
   }
   createDataChannels() {
     if (!this.pcManager) {
       return;
     }
-    // Waiters parked on the old channel objects would never see another event from them once they
-    // are replaced below — reject them so the headroom lock is released and queued senders
-    // re-check against the new channels.
-    this.invalidateDataChannelWaiters('data channels recreated');
-    // clear old data channel callbacks if recreate
-    if (this.lossyDC) {
-      this.lossyDC.onmessage = null;
-      this.lossyDC.onerror = null;
-      this.lossyDC.onclose = null;
-    }
-    if (this.reliableDC) {
-      this.reliableDC.onmessage = null;
-      this.reliableDC.onerror = null;
-      this.reliableDC.onclose = null;
-    }
-    if (this.dataTrackDC) {
-      this.dataTrackDC.onmessage = null;
-      this.dataTrackDC.onerror = null;
-      this.dataTrackDC.onclose = null;
-    }
-    // create data channels
-    this.lossyDC = this.pcManager.createPublisherDataChannel(lossyDataChannel, {
-      ordered: false,
-      maxRetransmits: 0
-    });
-    this.reliableDC = this.pcManager.createPublisherDataChannel(reliableDataChannel, {
-      ordered: true
-    });
-    this.dataTrackDC = this.pcManager.createPublisherDataChannel(dataTrackDataChannel, {
-      ordered: false,
-      maxRetransmits: 0
-    });
-    // also handle messages over the pub channel, for backwards compatibility
-    this.lossyDC.onmessage = this.handleDataMessage;
-    this.reliableDC.onmessage = this.handleDataMessage;
-    this.dataTrackDC.onmessage = this.handleDataTrackMessage;
-    // handle datachannel errors
-    this.lossyDC.onerror = this.handleDataError;
-    this.reliableDC.onerror = this.handleDataError;
-    this.dataTrackDC.onerror = this.handleDataError;
-    // detect unexpected publisher data channel closes
-    this.lossyDC.onclose = this.handleDataChannelClose(DataChannelKind.LOSSY);
-    this.reliableDC.onclose = this.handleDataChannelClose(DataChannelKind.RELIABLE);
-    this.dataTrackDC.onclose = this.handleDataChannelClose(DataChannelKind.DATA_TRACK_LOSSY);
-    // set up dc buffer threshold - if this is not set, it will default to 0
-    this.lossyDC.bufferedAmountLowThreshold = lossyDataChannelWaterMarkLow;
-    this.reliableDC.bufferedAmountLowThreshold = reliableDataChannelWaterMarkLow;
-    this.dataTrackDC.bufferedAmountLowThreshold = lossyDataChannelWaterMarkLow;
-    // handle buffer amount low events
-    this.lossyDC.onbufferedamountlow = () => this.handleBufferedAmountLow(DataChannelKind.LOSSY);
-    this.reliableDC.onbufferedamountlow = () => this.handleBufferedAmountLow(DataChannelKind.RELIABLE);
-    this.dataTrackDC.onbufferedamountlow = () => this.handleBufferedAmountLow(DataChannelKind.DATA_TRACK_LOSSY);
-    this.cleanupLossyDataStats();
-    this.lossyDataStatInterval = setInterval(() => {
-      this.lossyDataStatByterate = this.lossyDataStatCurrentBytes;
-      this.lossyDataStatCurrentBytes = 0;
-      const dc = this.dataChannelForKind(DataChannelKind.LOSSY);
-      if (dc) {
-        // control buffered latency to ~100ms
-        const threshold = this.lossyDataStatByterate / 10;
-        dc.bufferedAmountLowThreshold = Math.min(Math.max(threshold, lossyDataChannelWaterMarkLow), lossyDataChannelWaterMarkHigh);
+    this.dataChannels.createPublisherChannels(this.pcManager);
+  }
+  /** Normalizes an incoming data-channel message into bytes, or logs and returns undefined. */
+  decodeDataMessage(message) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (message.data instanceof ArrayBuffer) {
+        return new Uint8Array(message.data);
       }
-    }, 1000);
+      if (message.data instanceof Blob) {
+        return new Uint8Array(yield message.data.arrayBuffer());
+      }
+      this.log.error('unsupported data type', {
+        data: message.data
+      });
+      return undefined;
+    });
   }
   createSender(track, opts, encodings) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -22417,7 +23361,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       if (!opts.videoCodec) {
         return;
       }
-      track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+      yield track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
       return transceiver.sender;
     });
   }
@@ -22429,6 +23373,63 @@ class RTCEngine extends eventsExports.EventEmitter {
       return this.pcManager.addPublisherTrack(track);
     });
   }
+  /**
+   * A sustained local `LOST` while connected and publishing means the server isn't receiving
+   * our media, so force a full reconnect; any non-`LOST` value cancels a pending trigger.
+   */
+  handleLocalConnectionQuality(update) {
+    if (!this.participantSid) {
+      return;
+    }
+    const localUpdate = update.updates.find(u => u.participantSid === this.participantSid);
+    if (!localUpdate) {
+      return;
+    }
+    if (localUpdate.quality === ConnectionQuality$1.LOST) {
+      this.scheduleLostQualityReconnect();
+    } else {
+      this.clearLostQualityTimeout();
+    }
+  }
+  scheduleLostQualityReconnect() {
+    if (this.lostQualityTimeout) {
+      // already counting down towards a reconnect
+      return;
+    }
+    this.lostQualityTimeout = CriticalTimers.setTimeout(() => {
+      this.lostQualityTimeout = undefined;
+      if (this._isClosed || this.pcState !== PCState.Connected || this.attemptingReconnect) {
+        return;
+      }
+      if (!this.hasActivePublisherSenders()) {
+        return;
+      }
+      this.log.warn('local connection quality lost while publishing, triggering full reconnect', this.logContext);
+      this.fullReconnectOnNext = true;
+      this.handleDisconnect('connection quality lost', ReconnectReason.RR_PUBLISHER_FAILED);
+    }, connectionQualityLostTimeout);
+  }
+  clearLostQualityTimeout() {
+    if (this.lostQualityTimeout) {
+      CriticalTimers.clearTimeout(this.lostQualityTimeout);
+      this.lostQualityTimeout = undefined;
+    }
+  }
+  /** Whether the publisher currently has any sender with a live track. */
+  hasActivePublisherSenders() {
+    var _a, _b;
+    return (_b = (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.publisher.getSenders().some(sender => !!sender.track && sender.track.readyState === 'live')) !== null && _b !== void 0 ? _b : false;
+  }
+  /**
+   * Forces a full reconnect while keeping the engine (and its saved credentials) alive. Used by
+   * Room's connection-reconcile safety net when the transport silently died but we looked connected.
+   * @internal
+   */
+  reconnect() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ReconnectReason.RR_UNKNOWN;
+    this.fullReconnectOnNext = true;
+    this.handleDisconnect('reconcile', reason);
+  }
   attemptReconnect(reason) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b, _c;
@@ -22440,21 +23441,32 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.log.warn('already attempting reconnect, returning early');
         return;
       }
+      // A pending Lost-quality countdown belongs to the session we're now leaving; cancel it so
+      // it can't fire against the reconnected session before the server has evaluated it. (A resume
+      // keeps the peer connections, so cleanupPeerConnections wouldn't cover this path.)
+      this.clearLostQualityTimeout();
       if (((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED ||
       // signaling state could change to closed due to hardware sleep
       // those connections cannot be resumed
       ((_c = (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.currentState) !== null && _c !== void 0 ? _c : PCTransportState.NEW) === PCTransportState.NEW) {
         this.fullReconnectOnNext = true;
       }
+      // Consume the flag up front: capture whether this attempt is a full reconnect, then reset
+      // it. From here on a `true` value unambiguously represents a *new* full-reconnect request
+      // that arrived while this attempt was running (e.g. a server RECONNECT leave), which the
+      // finally block dispatches — for both the resume and full-reconnect paths.
+      const fullReconnect = this.fullReconnectOnNext;
+      this.fullReconnectOnNext = false;
+      let succeeded = false;
       try {
         this.attemptingReconnect = true;
-        if (this.fullReconnectOnNext) {
+        if (fullReconnect) {
           yield this.restartConnection();
         } else {
           yield this.resumeConnection(reason);
         }
         this.clearPendingReconnect();
-        this.fullReconnectOnNext = false;
+        succeeded = true;
       } catch (e) {
         this.reconnectAttempts += 1;
         let recoverable = true;
@@ -22464,8 +23476,9 @@ class RTCEngine extends eventsExports.EventEmitter {
           });
           // unrecoverable
           recoverable = false;
-        } else if (!(e instanceof SignalReconnectError)) {
-          // cannot resume
+        } else if (fullReconnect || !(e instanceof SignalReconnectError)) {
+          // a failed full reconnect stays a full reconnect; a failed resume can only be
+          // resumed again for a signal-level error, otherwise it escalates
           this.fullReconnectOnNext = true;
         }
         if (recoverable) {
@@ -22477,6 +23490,13 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
       } finally {
         this.attemptingReconnect = false;
+        // A full reconnect requested while this attempt was running (e.g. a `RECONNECT` leave
+        // during a resume or a restart) that a successful attempt didn't act on; dispatch it now
+        // (the failure path already retries).
+        if (succeeded && this.fullReconnectOnNext && !this._isClosed) {
+          this.log.debug('full reconnect requested during in-progress attempt, dispatching');
+          this.handleDisconnect('reconnect');
+        }
       }
     });
   }
@@ -22549,7 +23569,6 @@ class RTCEngine extends eventsExports.EventEmitter {
   }
   resumeConnection(reason) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
       if (!this.url || !this.token) {
         // permanent failure, don't attempt reconnection
         throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -22603,7 +23622,8 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.client.setReconnected();
       // recreate publish datachannel if it's id is null
       // (for safari https://bugs.webkit.org/show_bug.cgi?id=184688)
-      if (((_a = this.reliableDC) === null || _a === void 0 ? void 0 : _a.readyState) === 'open' && this.reliableDC.id === null) {
+      const reliableDC = this.dataChannelForKind(DataChannelKind.RELIABLE);
+      if ((reliableDC === null || reliableDC === void 0 ? void 0 : reliableDC.readyState) === 'open' && reliableDC.id === null) {
         this.createDataChannels();
       }
       if (res === null || res === void 0 ? void 0 : res.lastMessageSeq) {
@@ -22649,291 +23669,90 @@ class RTCEngine extends eventsExports.EventEmitter {
       const packet = new DataPacket({
         destinationIdentities: [destinationIdentity],
         kind: DataPacket_Kind.RELIABLE,
-        value: {
-          case: 'rpcAck',
-          value: new RpcAck({
-            requestId
-          })
-        }
-      });
-      yield this.sendDataPacket(packet, DataChannelKind.RELIABLE);
-    });
-  }
-  /* @internal */
-  sendDataPacket(packet, kind) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
-      // make sure we do have a data connection
-      yield this.ensurePublisherConnected(kind);
-      if (this.e2eeManager && this.e2eeManager.isDataChannelEncryptionEnabled) {
-        const encryptablePacket = asEncryptablePacket(packet);
-        if (encryptablePacket) {
-          const encryptedData = yield this.e2eeManager.encryptData(encryptablePacket.toBinary());
-          packet.value = {
-            case: 'encryptedPacket',
-            value: new EncryptedPacket({
-              encryptedValue: encryptedData.payload,
-              iv: encryptedData.iv,
-              keyIndex: encryptedData.keyIndex
-            })
-          };
-        }
-      }
-      if (kind === DataChannelKind.RELIABLE) {
-        packet.sequence = this.reliableDataSequence;
-        this.reliableDataSequence += 1;
-      }
-      const msg = packet.toBinary();
-      // Clamp to the SDK default - libwebrtc advertises larger (~256 KiB)
-      // than LiveKit/pion can deliver end-to-end (~64 KiB), so we trust
-      // the answer up untilthe built in ceiling.
-      const maxPublisherMessageSizeBytes = Math.min((_b = (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.getMaxPublisherMessageSize()) !== null && _b !== void 0 ? _b : DEFAULT_MAX_MESSAGE_SIZE, DEFAULT_MAX_MESSAGE_SIZE);
-      if (typeof maxPublisherMessageSizeBytes !== 'undefined' && maxPublisherMessageSizeBytes !== 0 /* 0 means "no limit" */ && msg.byteLength > maxPublisherMessageSizeBytes) {
-        throw new PublishDataError("cannot publish data packet larger than ".concat(maxPublisherMessageSizeBytes, " bytes (got ").concat(msg.byteLength, ")"));
-      }
-      switch (kind) {
-        case DataChannelKind.LOSSY:
-        case DataChannelKind.DATA_TRACK_LOSSY:
-          return this.sendLossyBytes(msg, kind);
-        case DataChannelKind.RELIABLE:
-          {
-            if (this.attemptingReconnect) {
-              // A reconnect is already underway — queue for the resume replay instead of parking on a
-              // channel that is being torn down. The send resolves; delivery is deferred to the replay.
-              this.reliableMessageBuffer.push({
-                data: msg,
-                sequence: packet.sequence,
-                sent: false
-              });
-              return;
-            }
-            const dc = this.dataChannelForKind(kind);
-            if (dc) {
-              try {
-                yield this.waitForBufferHeadroomWithLock(kind);
-              } catch (error) {
-                if (this.isClosed) {
-                  // No replay is coming after an engine close — surface the failure.
-                  throw error;
-                }
-                // Transient teardown (the channel closed or was replaced while we waited): the
-                // reliable channel promises delivery across resume, so queue the packet for the
-                // replay instead of rejecting a send the app can't meaningfully retry.
-                this.reliableMessageBuffer.push({
-                  data: msg,
-                  sequence: packet.sequence,
-                  sent: false
-                });
-                return;
-              }
-              if (this.attemptingReconnect) {
-                // A reconnect began while we waited for headroom — same deal as above.
-                this.reliableMessageBuffer.push({
-                  data: msg,
-                  sequence: packet.sequence,
-                  sent: false
-                });
-                return;
-              }
-              this.reliableMessageBuffer.push({
-                data: msg,
-                sequence: packet.sequence,
-                sent: true
-              });
-              dc.send(msg);
-            }
-            this.updateAndEmitDCBufferStatus(kind);
-            break;
-          }
-      }
-    });
-  }
-  /* @internal */
-  sendLossyBytes(bytes_1, kind_1) {
-    return __awaiter(this, arguments, void 0, function (bytes, kind) {
-      var _this3 = this;
-      let bufferStatusFullBehavior = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'drop';
-      return function* () {
-        // Make sure we do have a data connection. This matters most for the direct data-track path
-        // (Room's packetAvailable handler), which doesn't go through sendDataPacket: it both waits for
-        // the channel to be open and — on lazily negotiated publisher connections — is what kicks the
-        // negotiation off in the first place. The call is memoized, so the steady-state cost is one
-        // await on an already-resolved promise.
-        yield _this3.ensurePublisherConnected(kind);
-        const dc = _this3.dataChannelForKind(kind);
-        try {
-          if (dc) {
-            // Depending on the exact circumstance that data is being sent, either drop or wait for the
-            // buffer to drain below the high-water mark before continuing.
-            switch (bufferStatusFullBehavior) {
-              case 'wait':
-                if (!_this3.isBelowHighWaterMark(kind)) {
-                  yield _this3.waitForBufferHeadroomWithLock(kind);
-                }
-                break;
-              case 'drop':
-                // we check against the actual threshold on the DC here, as it is dynamic for the lossy DC
-                if (!_this3.isBelowLowWaterMark(kind)) {
-                  // Drop messages to reduce latency
-                  _this3.lossyDataDropCount += 1;
-                  if (_this3.lossyDataDropCount % 100 === 0) {
-                    _this3.log.warn("dropping lossy data channel messages, total dropped: ".concat(_this3.lossyDataDropCount));
-                  }
-                  return;
-                }
-            }
-            if (kind === DataChannelKind.LOSSY) {
-              // The byterate stat tunes the LOSSY channel's dynamic drop threshold; counting data-track
-              // bytes here would inflate it and let the lossy channel buffer far more latency than the
-              // ~100ms the tuning targets.
-              _this3.lossyDataStatCurrentBytes += bytes.byteLength;
-            }
-            if (_this3.attemptingReconnect) {
-              return;
-            }
-            dc.send(bytes);
-          }
-          _this3.updateAndEmitDCBufferStatus(kind);
-        } catch (error) {
-          // ensure same surface behaviour as before with missing data channel being silently ignored, just log an error message for clarity
-          if (error instanceof TypeError) {
-            _this3.log.error(error);
-          } else {
-            throw error;
-          }
+        value: {
+          case: 'rpcAck',
+          value: new RpcAck({
+            requestId
+          })
         }
-      }();
+      });
+      yield this.sendDataPacket(packet, DataChannelKind.RELIABLE);
     });
   }
-  resendReliableMessagesForResume(lastMessageSeq) {
+  /* @internal */
+  sendDataPacket(packet, /**  Data-track frames don't come through here — they're sent pre-serialized via {@link sendDataTrackFrame }. */
+  kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      yield this.ensurePublisherConnected(DataChannelKind.RELIABLE);
-      const dc = this.dataChannelForKind(DataChannelKind.RELIABLE);
-      if (dc) {
-        this.reliableMessageBuffer.popToSequence(lastMessageSeq);
-        // Hold the headroom lock across the whole replay. Releasing it between messages would let a
-        // concurrent send — whose (newer) sequence was already assigned in sendDataPacket before it
-        // queued on the lock — hit the wire mid-replay, and receivers would then discard the
-        // remaining lower-sequence resent messages as duplicates.
-        const unlock = yield this.getBufferHeadroomLock(DataChannelKind.RELIABLE).lock();
-        try {
-          // Everything left after the ack cutoff must be re-handed to the current channel.
-          this.reliableMessageBuffer.markAllUnsent();
-          // Drain in passes, re-scanning the live buffer each time: a send that arrives (deferred,
-          // sent:false) during our own awaits appends after this pass started, so we pick it up on
-          // the next one. We mark each packet only once we've actually handed it to the channel — a
-          // blanket "mark all sent" would flip such a late arrival to sent without transmitting it,
-          // and a later alignBufferedAmount would then drop it for good. If the loop throws
-          // mid-drain, unsent entries keep their flag and the next replay picks them up.
-          for (let batch = this.reliableMessageBuffer.getUnsent(); batch.length > 0; batch = this.reliableMessageBuffer.getUnsent()) {
-            for (const item of batch) {
-              // Respect flow control on resume too, so a large resend doesn't overflow the buffer.
-              // We already hold the lock across the whole replay, so use the lock-free wait.
-              yield this.waitForBufferHeadroomWithoutLock(DataChannelKind.RELIABLE);
-              dc.send(item.data);
-              this.reliableMessageBuffer.markSent(item);
-            }
-          }
-        } finally {
-          unlock();
+      var _a, _b;
+      // make sure we do have a data connection
+      yield this.ensurePublisherConnected(kind);
+      if (this.e2eeManager && this.e2eeManager.isDataChannelEncryptionEnabled) {
+        const encryptablePacket = asEncryptablePacket(packet);
+        if (encryptablePacket) {
+          const encryptedData = yield this.e2eeManager.encryptData(encryptablePacket.toBinary());
+          packet.value = {
+            case: 'encryptedPacket',
+            value: new EncryptedPacket({
+              encryptedValue: encryptedData.payload,
+              iv: encryptedData.iv,
+              keyIndex: encryptedData.keyIndex
+            })
+          };
         }
       }
-      this.updateAndEmitDCBufferStatus(DataChannelKind.RELIABLE);
+      if (kind === DataChannelKind.RELIABLE) {
+        packet.sequence = this.reliableChannel.nextSequence();
+      }
+      const msg = packet.toBinary();
+      // Clamp to the SDK default - libwebrtc advertises larger (~256 KiB)
+      // than LiveKit/pion can deliver end-to-end (~64 KiB), so we trust
+      // the answer up untilthe built in ceiling.
+      const maxPublisherMessageSizeBytes = Math.min((_b = (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.getMaxPublisherMessageSize()) !== null && _b !== void 0 ? _b : DEFAULT_MAX_MESSAGE_SIZE, DEFAULT_MAX_MESSAGE_SIZE);
+      if (typeof maxPublisherMessageSizeBytes !== 'undefined' && maxPublisherMessageSizeBytes !== 0 /* 0 means "no limit" */ && msg.byteLength > maxPublisherMessageSizeBytes) {
+        throw new PublishDataError("cannot publish data packet larger than ".concat(maxPublisherMessageSizeBytes, " bytes (got ").concat(msg.byteLength, ")"));
+      }
+      // The full-buffer policy (drop for lossy, wait/replay for reliable) is the channel's own, as
+      // is emitting the buffer-status change once the send settles.
+      if (kind === DataChannelKind.RELIABLE) {
+        yield this.reliableChannel.send(msg, packet.sequence);
+      } else {
+        yield this.lossyChannel.send(msg);
+      }
     });
   }
-  waiterAbortSignal(kind) {
-    let controller = this.waiterAbortControllers.get(kind);
-    if (!controller) {
-      controller = new AbortController();
-      this.waiterAbortControllers.set(kind, controller);
-    }
-    return controller.signal;
-  }
-  /** Rejects all parked headroom waiters (all kinds); the next waiter gets a fresh controller. */
-  invalidateDataChannelWaiters(reason) {
-    for (const controller of this.waiterAbortControllers.values()) {
-      controller.abort(reason);
-    }
-    this.waiterAbortControllers.clear();
-  }
-  /** Acquires the per-kind headroom lock, resolving with the unlock function. */
-  getBufferHeadroomLock(kind) {
-    let lock = this.waitForBufferHeadroomLocks.get(kind);
-    if (!lock) {
-      lock = new _();
-      this.waitForBufferHeadroomLocks.set(kind, lock);
-    }
-    return lock;
-  }
   /**
-   * Acquires the `kind` headroom lock, waits until the send buffer has room, then releases. The
-   * common single-send entry point. Callers that need to hold the lock across several sends (the
-   * resume replay) acquire it via {@link getBufferHeadroomLock} and call
-   * {@link waitForBufferHeadroomWithoutLock} per message instead.
+   * Sends pre-serialized bytes on the data-track channel. This is the one send path that doesn't
+   * go through {@link sendDataPacket} — Room's `packetAvailable` handler calls it directly with
+   * bytes the data-track pipeline already serialized.
+   *
+   * @internal
    */
-  waitForBufferHeadroomWithLock(kind) {
+  sendDataTrackFrame(bytes) {
     return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.getBufferHeadroomLock(kind).lock();
-      try {
-        yield this.waitForBufferHeadroomWithoutLock(kind);
-      } finally {
-        unlock();
-      }
+      // Make sure we do have a data connection: on lazily negotiated publisher connections this is
+      // what kicks negotiation off, and it waits for the channel to open. Memoized, so the
+      // steady-state cost is one await on an already-resolved promise.
+      yield this.ensurePublisherConnected(DataChannelKind.DATA_TRACK_LOSSY);
+      yield this.dataTrackChannel.send(bytes);
+    });
+  }
+  resendReliableMessagesForResume(lastMessageSeq) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.ensurePublisherConnected(DataChannelKind.RELIABLE);
+      yield this.reliableChannel.replay(lastMessageSeq);
     });
   }
+  /** The flow-control gate for `kind` — see {@link FlowControlledDataChannel}. */
+  flowControlFor(kind) {
+    return this.dataChannels.channelFor(kind);
+  }
   /**
-   * Waits until the send buffer for `kind` is at or below the high-water mark (draining, if
-   * needed, via the `bufferedamountlow` event). Does no locking of its own — the caller must
-   * already hold the kind's headroom lock (via {@link getBufferHeadroomLock}). The resume replay
-   * holds the lock across its whole batch and calls this per message so no other sender can
-   * interleave; the single-send path goes through {@link waitForBufferHeadroomWithLock}.
-   *
-   * Serializing through the per-kind lock means that, once the buffer drains, queued callers
-   * refill it one at a time (up to the high-water mark) rather than all at once and overflowing
-   * the SCTP send buffer (see livekit/client-sdk-js#1995).
+   * Resolves once the caller may send on the `kind` channel — see
+   * {@link FlowControlledDataChannel.waitForHeadroomWithLock}.
    */
-  waitForBufferHeadroomWithoutLock(kind) {
+  waitForBufferHeadroom(kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (this.isClosed) {
-        throw new UnexpectedConnectionState('engine closed');
-      }
-      if (this.isBelowHighWaterMark(kind)) {
-        return;
-      }
-      const dc = this.dataChannelForKind(kind);
-      if (!dc) {
-        throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(kind));
-      }
-      const abortSignal = this.waiterAbortSignal(kind);
-      yield new TypedPromise((resolve, reject) => {
-        const onBufferedAmountLow = () => {
-          cleanup();
-          resolve();
-        };
-        const onDCClose = () => {
-          cleanup();
-          reject(new UnexpectedConnectionState("DataChannel ".concat(kind, " closed while draining the buffer")));
-        };
-        const onAbort = () => {
-          cleanup();
-          reject(new UnexpectedConnectionState("DataChannel ".concat(kind, " was replaced or torn down while waiting for headroom")));
-        };
-        const cleanup = () => {
-          dc.removeEventListener('bufferedamountlow', onBufferedAmountLow);
-          dc.removeEventListener('close', onDCClose);
-          abortSignal.removeEventListener('abort', onAbort);
-        };
-        if (abortSignal.aborted) {
-          onAbort();
-          return;
-        }
-        dc.addEventListener('bufferedamountlow', onBufferedAmountLow);
-        // Proxy along any error caused by the data channel closing while we wait.
-        dc.addEventListener('close', onDCClose);
-        // The channel object we're parked on can be abandoned without ever firing another event
-        // (e.g. createDataChannels replacing it); the abort is our way out.
-        abortSignal.addEventListener('abort', onAbort);
-      });
+      return this.flowControlFor(kind).waitForHeadroomWithLock();
     });
   }
   /**
@@ -22941,40 +23760,40 @@ class RTCEngine extends eventsExports.EventEmitter {
    */
   ensureDataTransportConnected(kind_1) {
     return __awaiter(this, arguments, void 0, function (kind) {
-      var _this4 = this;
+      var _this3 = this;
       let subscriber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.subscriberPrimary;
       return function* () {
         var _a;
-        if (!_this4.pcManager) {
+        if (!_this3.pcManager) {
           throw new UnexpectedConnectionState('PC manager is closed');
         }
-        const transport = subscriber ? _this4.pcManager.subscriber : _this4.pcManager.publisher;
+        const transport = subscriber ? _this3.pcManager.subscriber : _this3.pcManager.publisher;
         const transportName = subscriber ? 'Subscriber' : 'Publisher';
         if (!transport) {
           throw ConnectionError.internal("".concat(transportName, " connection not set"));
         }
         let needNegotiation = false;
-        if (!subscriber && !_this4.dataChannelForKind(kind, subscriber)) {
-          _this4.createDataChannels();
+        if (!subscriber && !_this3.dataChannelForKind(kind, subscriber)) {
+          _this3.createDataChannels();
           needNegotiation = true;
         }
-        if (!needNegotiation && !subscriber && !_this4.pcManager.publisher.isICEConnected && _this4.pcManager.publisher.getICEConnectionState() !== 'checking') {
+        if (!needNegotiation && !subscriber && !_this3.pcManager.publisher.isICEConnected && _this3.pcManager.publisher.getICEConnectionState() !== 'checking') {
           needNegotiation = true;
         }
         if (needNegotiation) {
           // start negotiation
-          _this4.negotiate().catch(err => {
-            _this4.log.error(err);
+          _this3.negotiate().catch(err => {
+            _this3.log.error(err);
           });
         }
-        const targetChannel = _this4.dataChannelForKind(kind, subscriber);
+        const targetChannel = _this3.dataChannelForKind(kind, subscriber);
         if ((targetChannel === null || targetChannel === void 0 ? void 0 : targetChannel.readyState) === 'open') {
           return;
         }
         // wait until ICE connected
-        const endTime = new Date().getTime() + _this4.peerConnectionTimeout;
+        const endTime = new Date().getTime() + _this3.peerConnectionTimeout;
         while (new Date().getTime() < endTime) {
-          if (transport.isICEConnected && ((_a = _this4.dataChannelForKind(kind, subscriber)) === null || _a === void 0 ? void 0 : _a.readyState) === 'open') {
+          if (transport.isICEConnected && ((_a = _this3.dataChannelForKind(kind, subscriber)) === null || _a === void 0 ? void 0 : _a.readyState) === 'open') {
             return;
           }
           yield sleep(50);
@@ -22996,14 +23815,23 @@ class RTCEngine extends eventsExports.EventEmitter {
     if (!this.pcManager) {
       return false;
     }
+    const state = this.pcManager.currentState;
     const allowedConnectionStates = [PCTransportState.CONNECTING, PCTransportState.CONNECTED];
-    if (!allowedConnectionStates.includes(this.pcManager.currentState)) {
+    if (!allowedConnectionStates.includes(state)) {
       return false;
     }
     // ensure signal is connected
     if (!this.client.ws || this.client.ws.readyState === WebSocket.CLOSED) {
       return false;
     }
+    // A transport stuck in CONNECTING never reaches CONNECTED nor reports FAILED, so it would
+    // otherwise look healthy forever; bound how long we tolerate it. The entry time is recorded
+    // in the pcManager state-change handler (see configure()), so this is a pure read — an
+    // unrecorded CONNECTING fails open rather than measuring against a stale timestamp.
+    if (state === PCTransportState.CONNECTING && this.transportConnectingSince !== undefined && Date.now() - this.transportConnectingSince > this.peerConnectionTimeout) {
+      this.log.warn('transport stuck in connecting state', this.logContext);
+      return false;
+    }
     return true;
   }
   /** @internal */
@@ -23017,7 +23845,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
         this.pcManager.requirePublisher();
         // don't negotiate without any transceivers or data channel, it will generate sdp without ice frag then negotiate failed
-        if (this.pcManager.publisher.getTransceivers().length == 0 && !this.lossyDC && !this.reliableDC && !this.dataTrackDC) {
+        if (this.pcManager.publisher.getTransceivers().length == 0 && !this.dataChannels.hasPublisherChannels) {
           this.createDataChannels();
         }
         const abortController = new AbortController();
@@ -23061,26 +23889,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     });
   }
   dataChannelForKind(kind, sub) {
-    switch (kind) {
-      case DataChannelKind.RELIABLE:
-        if (!sub) {
-          return this.reliableDC;
-        } else {
-          return this.reliableDCSub;
-        }
-      case DataChannelKind.LOSSY:
-        if (!sub) {
-          return this.lossyDC;
-        } else {
-          return this.lossyDCSub;
-        }
-      case DataChannelKind.DATA_TRACK_LOSSY:
-        if (!sub) {
-          return this.dataTrackDC;
-        } else {
-          return this.dataTrackDCSub;
-        }
-    }
+    return this.dataChannels.getHandle(kind, sub);
   }
   /** @internal */
   sendSyncState(remoteTracks, localTracks, localDataTrackInfos) {
@@ -23408,7 +24217,90 @@ RegionUrlProvider.connectionTrackers = new Map();
 RegionUrlProvider.fetchLock = new _();
 function getCloudConfigUrl(serverUrl) {
   return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
-}class BaseStreamReader {
+}/**
+ * A `deflate-raw` compression transform (inverse of {@link inflateRawTransform}): pipe a byte stream
+ * through it to get the compressed bytes without buffering the whole payload. Used for the chunked
+ * `sendText`/`sendBytes`/`sendFile` paths, where the full payload is known up front but is streamed
+ * (e.g. from `file.stream()`) rather than held in memory.
+ */
+function deflateRawTransform() {
+  return new CompressionStream('deflate-raw');
+}
+/**
+ * A `deflate-raw` decompression transform (inverse of {@link deflateRawTransform}): pipe a
+ * stream of compressed bytes through it to get the decompressed bytes. Inflate emits output greedily,
+ * so as long as the sender flushed at write boundaries each write's content is produced as soon as
+ * its compressed bytes arrive.
+ */
+function inflateRawTransform() {
+  return new DecompressionStream('deflate-raw');
+}
+/**
+ * Decompresses a raw-deflate byte array in full (inverse of {@link deflateRawCompress}).
+ * `maxByteLength` bounds the decompressed output (decompression-bomb guard); exceeding it rejects
+ * with a `PayloadTooLarge` error.
+ */
+function deflateRawDecompress(data, maxByteLength) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const ds = new DecompressionStream('deflate-raw');
+    const writer = ds.writable.getWriter();
+    // The writer promises are intentionally not awaited (output is consumed via `collect`), but
+    // they reject when the byte cap cancels the readable mid-stream — swallow that so an enforced
+    // cap doesn't surface as an unhandled rejection.
+    writer.write(data).catch(() => {});
+    writer.close().catch(() => {});
+    return collect(ds.readable, maxByteLength);
+  });
+}
+/**
+ * Drains a byte stream, concatenating all of its chunks into a single array. When
+ * `maxByteLength` is given, drops the stream and throws `PayloadTooLarge` as soon as the
+ * accumulated output exceeds it.
+ */
+function collect(stream, maxByteLength) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const _yield$reader$read = yield reader.read(),
+        done = _yield$reader$read.done,
+        value = _yield$reader$read.value;
+      if (done) {
+        break;
+      }
+      chunks.push(value);
+      total += value.byteLength;
+      if (typeof maxByteLength === 'number' && total > maxByteLength) {
+        yield reader.cancel();
+        throw new DataStreamError("Decompressed payload exceeds the maximum payload size of ".concat(maxByteLength, " bytes"), DataStreamErrorReason.PayloadTooLarge);
+      }
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  });
+}/**
+ * Maximum size of a single data-stream chunk in bytes, and the budget used to decide whether a
+ * payload can be sent inline as a single header packet. Kept below the ~16k data-channel MTU to
+ * leave headroom for protocol framing and E2EE overhead.
+ *
+ * @internal
+ */
+const STREAM_CHUNK_SIZE_BYTES = 15000;
+/**
+ * Default cap on the number of decompressed bytes a single incoming compressed data stream may
+ * produce (5 GB). A tiny compressed payload can inflate to an arbitrarily large output
+ * (decompression bomb), so the decompressor's output is bounded rather than trusting the wire
+ * size; streams exceeding the cap error with `PayloadTooLarge`.
+ *
+ * @internal
+ */
+const DEFAULT_MAX_PAYLOAD_BYTE_LENGTH = 5000000000;class BaseStreamReader {
   get info() {
     return this._info;
   }
@@ -23450,6 +24342,7 @@ class ByteStreamReader extends BaseStreamReader {
     };
     return {
       next: () => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
           const signal = this.signal;
           if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
@@ -23470,6 +24363,9 @@ class ByteStreamReader extends BaseStreamReader {
           });
           if (result.done) {
             this.validateBytesReceived(true);
+            if (typeof this.totalByteSize === 'number') {
+              (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, 1);
+            }
             return {
               done: true,
               value: undefined
@@ -23577,9 +24473,7 @@ class TextStreamReader extends BaseStreamReader {
     // Suppress unhandled rejection on reader.closed — errors are
     // already propagated through reader.read() to the consumer.
     reader.closed.catch(() => {});
-    const decoder = new TextDecoder('utf-8', {
-      fatal: true
-    });
+    const decoder = new TextDecoder('utf-8');
     const signal = this.signal;
     const cleanup = () => {
       reader.releaseLock();
@@ -23587,6 +24481,7 @@ class TextStreamReader extends BaseStreamReader {
     };
     return {
       next: () => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
           if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             throw signal.reason;
@@ -23606,6 +24501,9 @@ class TextStreamReader extends BaseStreamReader {
           });
           if (result.done) {
             this.validateBytesReceived(true);
+            if (typeof this.totalByteSize === 'number') {
+              (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, 1);
+            }
             return {
               done: true,
               value: undefined
@@ -23684,6 +24582,7 @@ class TextStreamReader extends BaseStreamReader {
   }
 }class IncomingDataStreamManager {
   constructor() {
+    let maxPayloadByteLength = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_MAX_PAYLOAD_BYTE_LENGTH;
     this.log = livekitLogger;
     this.byteStreamControllers = new Map();
     this.textStreamControllers = new Map();
@@ -23691,6 +24590,7 @@ class TextStreamReader extends BaseStreamReader {
     this.textStreamHandlers = new Map();
     this.isConnected = false;
     this.bufferedPackets = [];
+    this.maxPayloadByteLength = maxPayloadByteLength;
   }
   setConnected(connected) {
     this.isConnected = connected;
@@ -23773,74 +24673,150 @@ class TextStreamReader extends BaseStreamReader {
   }
   handleStreamHeader(streamHeader, participantIdentity, encryptionType) {
     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,
-        encryptionType
-      };
-      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);
+    switch (streamHeader.contentHeader.case) {
+      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,
+            encryptionType
+          };
+          // Determine if the byte payload needs to be decompressed.
+          let compressed;
+          switch (streamHeader.compression) {
+            case DataStream_CompressionType.DEFLATE_RAW:
+              if (!isCompressionStreamSupported()) {
+                // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
+                // isn't properly abiding by the data streams v2 protocol.
+                livekitLogger.warn("Data stream ".concat(streamHeader.streamId, " received with deflate-raw compression, but this browser does not have support for DecompressionStream. Dropping..."));
+                return;
+              }
+              compressed = true;
+              break;
+            case DataStream_CompressionType.NONE:
+              compressed = false;
+              break;
+            default:
+              // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
+              // isn't properly abiding by the data streams v2 protocol.
+              livekitLogger.warn("Data stream ".concat(streamHeader.streamId, " received with unknown compression type ").concat(streamHeader.compression, ", dropping..."));
+              return;
           }
-          this.byteStreamControllers.set(streamHeader.streamId, {
-            info,
-            controller: streamController,
-            startTime: Date.now(),
-            sendingParticipantIdentity: participantIdentity
+          // Single-packet stream: the entire payload was packaged into the header's `inlineContent`.
+          // Synthesize an already-complete stream and skip waiting for chunk/trailer packets.
+          const inlineContent = streamHeader.inlineContent;
+          if (typeof inlineContent !== 'undefined') {
+            // Inline bytes are the raw payload, optionally deflate-raw compressed.
+            streamHandlerCallback(new ByteStreamReader(info, createInlineStream(streamHeader.streamId, compressed ? deflateRawDecompress(inlineContent, this.maxPayloadByteLength) : inlineContent), bigIntToNumber(streamHeader.totalLength)), {
+              identity: participantIdentity
+            });
+            return;
+          }
+          const stream = new ReadableStream({
+            start: controller => {
+              streamController = controller;
+              if (this.byteStreamControllers.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
+              });
+            }
           });
+          streamHandlerCallback(new ByteStreamReader(info, compressed ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          // `totalLength` is the pre-compression size, and the reader counts decompressed bytes,
+          // so it applies to both paths (mirrors text).
+          bigIntToNumber(streamHeader.totalLength)), {
+            identity: participantIdentity
+          });
+          return;
         }
-      });
-      streamHandlerCallback(new ByteStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)), {
-        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 info = {
-        id: streamHeader.streamId,
-        mimeType: streamHeader.mimeType,
-        size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
-        topic: streamHeader.topic,
-        timestamp: Number(streamHeader.timestamp),
-        attributes: streamHeader.attributes,
-        encryptionType,
-        attachedStreamIds: streamHeader.contentHeader.value.attachedStreamIds
-      };
-      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);
+      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 info = {
+            id: streamHeader.streamId,
+            mimeType: streamHeader.mimeType,
+            size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
+            topic: streamHeader.topic,
+            timestamp: Number(streamHeader.timestamp),
+            attributes: streamHeader.attributes,
+            encryptionType,
+            attachedStreamIds: streamHeader.contentHeader.value.attachedStreamIds
+          };
+          // Determine if the byte payload needs to be decompressed.
+          let compressed;
+          switch (streamHeader.compression) {
+            case DataStream_CompressionType.DEFLATE_RAW:
+              if (!isCompressionStreamSupported()) {
+                // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
+                // isn't properly abiding by the data streams v2 protocol.
+                livekitLogger.warn("Data stream ".concat(streamHeader.streamId, " received with deflate-raw compression, but this browser does not have support for DecompressionStream. Dropping..."));
+                return;
+              }
+              compressed = true;
+              break;
+            case DataStream_CompressionType.NONE:
+              compressed = false;
+              break;
+            default:
+              // NOTE: this shouldn't really ever happen, if this warning is logged then the sender
+              // isn't properly abiding by the data streams v2 protocol.
+              livekitLogger.warn("Data stream ".concat(streamHeader.streamId, " received with unknown compression type ").concat(streamHeader.compression, ", dropping..."));
+              return;
           }
-          this.textStreamControllers.set(streamHeader.streamId, {
-            info,
-            controller: streamController,
-            startTime: Date.now(),
-            sendingParticipantIdentity: participantIdentity
+          // Single-packet stream: the entire payload was smuggled into the header's `inlineContent`.
+          // Synthesize an already-complete stream and skip waiting for chunk/trailer packets.
+          const inlineContent = streamHeader.inlineContent;
+          if (typeof inlineContent !== 'undefined') {
+            // Inline text is the raw UTF-8 payload, optionally deflate-raw compressed.
+            const content = compressed ? deflateRawDecompress(inlineContent, this.maxPayloadByteLength) : inlineContent;
+            streamHandlerCallback(new TextStreamReader(info, createInlineStream(streamHeader.streamId, content), bigIntToNumber(streamHeader.totalLength)), {
+              identity: participantIdentity
+            });
+            return;
+          }
+          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
+              });
+            }
           });
+          streamHandlerCallback(new TextStreamReader(info, compressed ? inflateRawChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          // `totalLength` is the pre-compression size, and the reader sees decompressed bytes, so
+          // it applies to both paths.
+          bigIntToNumber(streamHeader.totalLength)), {
+            identity: participantIdentity
+          });
+          return;
         }
-      });
-      streamHandlerCallback(new TextStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)), {
-        identity: participantIdentity
-      });
     }
   }
   handleStreamChunk(chunk, encryptionType) {
@@ -23853,38 +24829,205 @@ class TextStreamReader extends BaseStreamReader {
         fileBuffer.controller.enqueue(chunk);
       }
     }
-    const textBuffer = this.textStreamControllers.get(chunk.streamId);
-    if (textBuffer) {
-      if (textBuffer.info.encryptionType !== encryptionType) {
-        textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
-        this.textStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
-        textBuffer.controller.enqueue(chunk);
-      }
+    const textBuffer = this.textStreamControllers.get(chunk.streamId);
+    if (textBuffer) {
+      if (textBuffer.info.encryptionType !== encryptionType) {
+        textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+        this.textStreamControllers.delete(chunk.streamId);
+      } else if (chunk.content.length > 0) {
+        textBuffer.controller.enqueue(chunk);
+      }
+    }
+  }
+  handleStreamTrailer(trailer, encryptionType) {
+    const textBuffer = this.textStreamControllers.get(trailer.streamId);
+    if (textBuffer) {
+      if (textBuffer.info.encryptionType !== encryptionType) {
+        textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+      } else {
+        textBuffer.info.attributes = Object.assign(Object.assign({}, textBuffer.info.attributes), trailer.attributes);
+        if (trailer.reason) {
+          // A non-empty reason marks an abnormal close by the sender (e.g. an aborted send);
+          // surface it as an error rather than pretending the stream completed.
+          textBuffer.controller.error(new DataStreamError("Data stream ".concat(trailer.streamId, " closed abnormally: ").concat(trailer.reason), DataStreamErrorReason.AbnormalEnd));
+        } else {
+          textBuffer.controller.close();
+        }
+      }
+      this.textStreamControllers.delete(trailer.streamId);
+    }
+    const fileBuffer = this.byteStreamControllers.get(trailer.streamId);
+    if (fileBuffer) {
+      if (fileBuffer.info.encryptionType !== encryptionType) {
+        fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+      } else {
+        fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
+        if (trailer.reason) {
+          // A non-empty reason marks an abnormal close by the sender (e.g. an aborted send);
+          // surface it as an error rather than pretending the stream completed.
+          fileBuffer.controller.error(new DataStreamError("Data stream ".concat(trailer.streamId, " closed abnormally: ").concat(trailer.reason), DataStreamErrorReason.AbnormalEnd));
+        } else {
+          fileBuffer.controller.close();
+        }
+      }
+      this.byteStreamControllers.delete(trailer.streamId);
+    }
+  }
+}
+/**
+ * Builds a `ReadableStream` that yields the given content as a single chunk and then immediately
+ * closes - used to surface an inline (single-packet) data stream as a fully-formed stream. `content`
+ * may be a promise (e.g. async gzip decompression); a rejection errors the stream.
+ */
+function createInlineStream(streamId, content) {
+  return new ReadableStream({
+    start: controller => __awaiter(this, void 0, void 0, function* () {
+      try {
+        const bytes = yield content;
+        controller.enqueue(new DataStream_Chunk({
+          streamId,
+          chunkIndex: BigInt(0),
+          content: bytes
+        }));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    })
+  });
+}
+/**
+ * Validates that chunks are received in order, dropping duplicates and throwing if gaps are found.
+ *
+ * A stateful decompressor silently corrupts on duplicated or out-of-order input, so duplicates are
+ * dropped (with a warning - in-order delivery is expected on the reliable channel, but reconnect
+ * handling may replay) and a gap is a hard error. Shared by the text and byte deflate-raw decoders.
+ */
+function ensureOrderedChunks(streamId) {
+  let lastChunkIndex = -1;
+  return new TransformStream({
+    transform: (value, controller) => {
+      const index = bigIntToNumber(value.chunkIndex);
+      if (index <= lastChunkIndex) {
+        livekitLogger.warn("ignoring duplicate chunk ".concat(index, " for compressed data stream ").concat(streamId, " (last processed: ").concat(lastChunkIndex, ")"));
+        return;
+      }
+      if (index > lastChunkIndex + 1) {
+        throw new DataStreamError("Missing chunk(s) ".concat(lastChunkIndex + 1, "..").concat(index - 1, " for compressed data stream ").concat(streamId, " - cannot continue decompressing"), DataStreamErrorReason.Incomplete);
+      }
+      lastChunkIndex = index;
+      controller.enqueue(value);
+    }
+  });
+}
+/** Unwraps compressed `DataStream_Chunk`s to their compressed bytes (in `chunkIndex` order), */
+function chunksToBytes() {
+  return new TransformStream({
+    transform: (value, controller) => {
+      controller.enqueue(value.content);
+    }
+  });
+}
+/** Re-wraps decompressed bytes into contiguous `DataStream_Chunk`s, skipping inflate's empty reads. */
+function bytesToChunks(streamId) {
+  let outIndex = 0;
+  return new TransformStream({
+    transform: (value, controller) => {
+      // Inflate can emit empty reads; only synthesize a chunk when there is content.
+      if (value.byteLength > 0) {
+        controller.enqueue(new DataStream_Chunk({
+          streamId,
+          chunkIndex: numberToBigInt(outIndex),
+          content: value
+        }));
+        outIndex += 1;
+      }
+    }
+  });
+}
+/**
+ * Reframes decompressed byte chunks onto UTF-8 character boundaries via a streaming `TextDecoder`
+ * (a write larger than the MTU spans several packets, which may split a codepoint), so each
+ * synthesized text chunk decodes independently. The `flush` emits the decoder's trailing bytes.
+ */
+function bytesToDecodedUtf8(streamId) {
+  const decoder = new TextDecoder('utf-8');
+  const encoder = new TextEncoder();
+  let outIndex = 0;
+  const decodeOrThrow = bytes => {
+    try {
+      return bytes ? decoder.decode(bytes, {
+        stream: true
+      }) : decoder.decode();
+    } catch (err) {
+      throw new DataStreamError("Cannot decode compressed data stream ".concat(streamId, " as text: ").concat(err), DataStreamErrorReason.DecodeFailed);
     }
-  }
-  handleStreamTrailer(trailer, encryptionType) {
-    const textBuffer = this.textStreamControllers.get(trailer.streamId);
-    if (textBuffer) {
-      if (textBuffer.info.encryptionType !== encryptionType) {
-        textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
-      } else {
-        textBuffer.info.attributes = Object.assign(Object.assign({}, textBuffer.info.attributes), trailer.attributes);
-        textBuffer.controller.close();
-        this.textStreamControllers.delete(trailer.streamId);
+  };
+  return new TransformStream({
+    transform: (value, controller) => {
+      const text = decodeOrThrow(value);
+      // Everything so far may have been a partial codepoint; only emit once we have characters.
+      if (text.length > 0) {
+        controller.enqueue(new DataStream_Chunk({
+          streamId,
+          chunkIndex: numberToBigInt(outIndex),
+          content: encoder.encode(text)
+        }));
+        outIndex += 1;
+      }
+    },
+    flush: controller => {
+      const tail = decodeOrThrow();
+      if (tail.length > 0) {
+        controller.enqueue(new DataStream_Chunk({
+          streamId,
+          chunkIndex: numberToBigInt(outIndex),
+          content: encoder.encode(tail)
+        }));
+        outIndex += 1;
       }
     }
-    const fileBuffer = this.byteStreamControllers.get(trailer.streamId);
-    if (fileBuffer) {
-      if (fileBuffer.info.encryptionType !== encryptionType) {
-        fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
-      } else {
-        fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
-        fileBuffer.controller.close();
+  });
+}
+/**
+ * Transforms a stream of deflate-raw-compressed byte `DataStream_Chunk`s into a stream of
+ * decompressed chunks, so `ByteStreamReader` consumes it unchanged. All chunk contents are fed (in
+ * `chunkIndex` order) through ONE raw-deflate decompressor for the stream's lifetime; decompressed
+ * output is re-wrapped as chunks as soon as it is produced. The sender (sendFile) compresses the
+ * whole payload in one shot, but the format also supports a single context-takeover stream
+ * sync-flushed at write boundaries, so a future incremental streamBytes could compress with no
+ * protocol change. Errors and cancellation propagate through the pipe chain.
+ */
+function inflateRawByteChunkStream(raw, streamId, maxPayloadByteLength) {
+  return raw.pipeThrough(ensureOrderedChunks(streamId)).pipeThrough(chunksToBytes()).pipeThrough(inflateRawTransform()).pipeThrough(maxDecompressedLengthGuard(streamId, maxPayloadByteLength)).pipeThrough(bytesToChunks(streamId));
+}
+/**
+ * Transforms a stream of deflate-raw-compressed text `DataStream_Chunk`s into a stream of
+ * decompressed chunks, so `TextStreamReader` consumes it unchanged. Builds on
+ * {@link inflateRawByteChunkStream} (single decompressor + ordering guard) and adds a streaming
+ * `TextDecoder` that reframes the decompressed bytes on UTF-8 character boundaries so each
+ * synthesized chunk decodes independently. Errors and cancellation propagate through the pipe chain.
+ */
+function inflateRawChunkStream(raw, streamId, maxPayloadByteLength) {
+  return raw.pipeThrough(ensureOrderedChunks(streamId)).pipeThrough(chunksToBytes()).pipeThrough(inflateRawTransform()).pipeThrough(maxDecompressedLengthGuard(streamId, maxPayloadByteLength)).pipeThrough(bytesToDecodedUtf8(streamId));
+}
+/**
+ * Caps the total decompressed byte count of a compressed stream (decompression-bomb guard): a
+ * tiny compressed payload can inflate to an arbitrarily large output, so the decompressor's
+ * output is bounded rather than trusting the wire size. Exceeding the cap errors the stream with
+ * `PayloadTooLarge`.
+ */
+function maxDecompressedLengthGuard(streamId, maxByteLength) {
+  let total = 0;
+  return new TransformStream({
+    transform: (value, controller) => {
+      total += value.byteLength;
+      if (total > maxByteLength) {
+        throw new DataStreamError("Data stream ".concat(streamId, " exceeds the maximum payload size of ").concat(maxByteLength, " bytes"), DataStreamErrorReason.PayloadTooLarge);
       }
-      this.byteStreamControllers.delete(trailer.streamId);
+      controller.enqueue(value);
     }
-  }
+  });
 }class BaseStreamWriter {
   constructor(writableStream, info, onClose) {
     this.writableStream = writableStream;
@@ -23905,15 +25048,70 @@ class TextStreamReader extends BaseStreamReader {
   }
 }
 class TextStreamWriter extends BaseStreamWriter {}
-class ByteStreamWriter extends BaseStreamWriter {}const STREAM_CHUNK_SIZE = 15000;
+class ByteStreamWriter extends BaseStreamWriter {}/** Builds the `DataStream_Header` for a text stream from its info and stream options. */
+function buildTextStreamHeader(info, options, v2) {
+  var _a;
+  return new DataStream_Header({
+    streamId: info.id,
+    mimeType: info.mimeType,
+    topic: info.topic,
+    timestamp: numberToBigInt(info.timestamp),
+    totalLength: numberToBigInt(info.size),
+    attributes: info.attributes,
+    compression: (_a = v2 === null || v2 === void 0 ? void 0 : v2.compression) !== null && _a !== void 0 ? _a : DataStream_CompressionType.NONE,
+    inlineContent: v2 === null || v2 === void 0 ? void 0 : v2.inlineContent,
+    contentHeader: {
+      case: 'textHeader',
+      value: new DataStream_TextHeader({
+        version: options === null || options === void 0 ? void 0 : options.version,
+        attachedStreamIds: info.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
+      })
+    }
+  });
+}
+/** Builds the `DataStream_Header` for a byte stream from its info. */
+function buildByteStreamHeader(info, v2) {
+  var _a;
+  return new DataStream_Header({
+    streamId: info.id,
+    mimeType: info.mimeType,
+    topic: info.topic,
+    timestamp: numberToBigInt(info.timestamp),
+    totalLength: numberToBigInt(info.size),
+    attributes: info.attributes,
+    compression: (_a = v2 === null || v2 === void 0 ? void 0 : v2.compression) !== null && _a !== void 0 ? _a : DataStream_CompressionType.NONE,
+    inlineContent: v2 === null || v2 === void 0 ? void 0 : v2.inlineContent,
+    contentHeader: {
+      case: 'byteHeader',
+      value: new DataStream_ByteHeader({
+        name: info.name
+      })
+    }
+  });
+}
+/** Wraps a `DataStream_Header` in a `DataPacket` ready to be sent over a data channel. */
+function createStreamHeaderPacket(header, destinationIdentities) {
+  return new DataPacket({
+    destinationIdentities,
+    value: {
+      case: 'streamHeader',
+      value: header
+    }
+  });
+}const textEncoder = new TextEncoder();
 /**
  * Manages sending custom user data via data channels.
  * @internal
  */
 class OutgoingDataStreamManager {
-  constructor(engine, log) {
+  constructor(engine, log, getRemoteParticipantClientProtocol, getRemoteParticipantCapabilities, getAllRemoteParticipantIdentities) {
     this.engine = engine;
     this.log = log;
+    this.getRemoteParticipantClientProtocol = getRemoteParticipantClientProtocol;
+    this.getRemoteParticipantCapabilities = getRemoteParticipantCapabilities;
+    this.getAllRemoteParticipantIdentities = getAllRemoteParticipantIdentities;
   }
   setupEngine(engine) {
     this.engine = engine;
@@ -23921,42 +25119,236 @@ class OutgoingDataStreamManager {
   /** {@inheritDoc LocalParticipant.sendText} */
   sendText(text, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
+      var _a, _b, _c, _d, _e;
       const streamId = crypto.randomUUID();
-      const textInBytes = new TextEncoder().encode(text);
+      const textInBytes = 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 compress = (_a = options === null || options === void 0 ? void 0 : options.compress) !== null && _a !== void 0 ? _a : true;
+      let 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: totalTextLength,
+        // NOTE: size is always the pre-compression byte length
+        attributes: options === null || options === void 0 ? void 0 : options.attributes,
+        encryptionType: ((_c = this.engine.e2eeManager) === null || _c === void 0 ? void 0 : _c.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE
+      };
+      const compressEligible = compress && isCompressionStreamSupported() && this.allRecipientsSupportV2(options === null || options === void 0 ? void 0 : options.destinationIdentities) && this.allRecipientsSupportCompression(options === null || options === void 0 ? void 0 : options.destinationIdentities);
+      let compressedStream = compressEligible ? MaybeCollectedStream.fromStream(readableFromBytes(textInBytes).pipeThrough(deflateRawTransform())) : null;
+      // Phase 1: Try to send as a single packet data stream
+      const noAttachments = !(options === null || options === void 0 ? void 0 : options.attachments) || options.attachments.length === 0;
+      if (noAttachments && this.allRecipientsSupportV2(options === null || options === void 0 ? void 0 : options.destinationIdentities)) {
+        // The payload rides in the header's `inlineContent` (raw bytes). Keep the compressed form only
+        // if it actually shrinks the payload (deflate framing makes tiny strings larger). The
+        // compression flag is carried in the header's `compression` field; user attributes are left
+        // untouched.
+        let inlineContent = textInBytes;
+        let compression = DataStream_CompressionType.NONE;
+        if (compressedStream) {
+          const collectedBytes = yield compressedStream.collect();
+          if (collectedBytes.byteLength < textInBytes.byteLength) {
+            inlineContent = collectedBytes;
+            compression = DataStream_CompressionType.DEFLATE_RAW;
+          }
+        }
+        const header = buildTextStreamHeader(info, undefined, {
+          compression,
+          inlineContent
+        });
+        const packet = createStreamHeaderPacket(header, options === null || options === void 0 ? void 0 : options.destinationIdentities);
+        if (packet.toBinary().byteLength <= STREAM_CHUNK_SIZE_BYTES) {
+          yield this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
+          (_d = options === null || options === void 0 ? void 0 : options.onProgress) === null || _d === void 0 ? void 0 : _d.call(options, 1);
+          return info;
+        }
+      }
+      const fileIds = (_e = options === null || options === void 0 ? void 0 : options.attachments) === null || _e === void 0 ? void 0 : _e.map(() => crypto.randomUUID());
+      // Progress is split evenly across the text part (slot 0) and one slot per attachment, then
+      // normalized to a [0,1] fraction. Each slot climbs monotonically to 1, so the aggregate ends at
+      // exactly 1 once every part has completed.
+      const parts = fileIds ? fileIds.length + 1 : 1;
+      const progresses = new Array(parts).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);
+        (_a = options === null || options === void 0 ? void 0 : options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, progresses.reduce((acc, val) => acc + val, 0) / parts);
       };
-      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();
+      // Phase 2: Try to send a multi packet data stream with compressed bytes
+      if (compressedStream) {
+        info.attachedStreamIds = fileIds;
+        const header = buildTextStreamHeader(info, undefined, {
+          compression: DataStream_CompressionType.DEFLATE_RAW
+        });
+        const packet = createStreamHeaderPacket(header, options === null || options === void 0 ? void 0 : options.destinationIdentities);
+        yield this.sendChunkedByteStream(packet, streamId, options === null || options === void 0 ? void 0 : options.destinationIdentities, compressedStream.stream().pipeThrough(progressReportingStream(textInBytes.length, progress => handleProgress(progress, 0))));
+        // Ensure there's always a 100% progress event fired, even if the string is zero bytes long
+        if (textInBytes.length === 0) {
+          handleProgress(1, 0);
+        }
+      } else {
+        // Phase 3 / fallback: header + plain uncompressed chunk packets + trailer.
+        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();
+        info = writer.info;
+      }
       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,
+            destinationIdentities: options.destinationIdentities,
+            compress: options.compress,
             onProgress: progress => {
               handleProgress(progress, idx + 1);
             }
           });
         })));
       }
-      return writer.info;
+      return info;
+    });
+  }
+  /**
+   * Sends a complete in-memory byte payload. Mirrors {@link sendText}'s semantics: when every
+   * recipient supports data streams v2 the payload rides inline in a single header packet
+   * (optionally deflate-raw compressed), otherwise it is sent as a (optionally compressed)
+   * chunked byte stream. Unlike {@link sendFile}, the whole payload is already in memory, so the
+   * inline single-packet fast path applies.
+   */
+  sendBytes(bytes, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const streamId = crypto.randomUUID();
+      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
+      const compress = (_a = options === null || options === void 0 ? void 0 : options.compress) !== null && _a !== void 0 ? _a : true;
+      const info = {
+        id: streamId,
+        name: (_b = options === null || options === void 0 ? void 0 : options.name) !== null && _b !== void 0 ? _b : 'unknown',
+        mimeType: (_c = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _c !== void 0 ? _c : 'application/octet-stream',
+        timestamp: Date.now(),
+        topic: (_d = options === null || options === void 0 ? void 0 : options.topic) !== null && _d !== void 0 ? _d : '',
+        size: bytes.byteLength,
+        // NOTE: size is always the pre-compression byte length
+        attributes: options === null || options === void 0 ? void 0 : options.attributes,
+        encryptionType: ((_e = this.engine.e2eeManager) === null || _e === void 0 ? void 0 : _e.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE
+      };
+      const progressMonitorTap = progressReportingStream(bytes.length, options === null || options === void 0 ? void 0 : options.onProgress);
+      const compressEligible = compress && isCompressionStreamSupported() && this.allRecipientsSupportV2(destinationIdentities) && this.allRecipientsSupportCompression(destinationIdentities);
+      let compressedStream = compressEligible ? MaybeCollectedStream.fromStream(readableFromBytes(bytes).pipeThrough(progressMonitorTap).pipeThrough(deflateRawTransform())) : null;
+      // Phase 1: Try to send as a single packet data stream
+      if (this.allRecipientsSupportV2(destinationIdentities)) {
+        // The payload rides in the header's `inlineContent` (raw bytes). Keep the compressed form only
+        // if it actually shrinks the payload (deflate framing makes tiny payloads larger). The
+        // compression flag is carried in the header's `compression` field; user attributes are left
+        // untouched.
+        let inlineContent = bytes;
+        let compression = DataStream_CompressionType.NONE;
+        if (compressedStream) {
+          const collectedBytes = yield compressedStream.collect();
+          if (collectedBytes.byteLength < bytes.byteLength) {
+            inlineContent = collectedBytes;
+            compression = DataStream_CompressionType.DEFLATE_RAW;
+          }
+        }
+        const header = buildByteStreamHeader(info, {
+          compression,
+          inlineContent
+        });
+        const packet = createStreamHeaderPacket(header, destinationIdentities);
+        if (packet.toBinary().byteLength <= STREAM_CHUNK_SIZE_BYTES) {
+          yield this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
+          (_f = options === null || options === void 0 ? void 0 : options.onProgress) === null || _f === void 0 ? void 0 : _f.call(options, 1);
+          return info;
+        }
+      }
+      // Phase 2/3: header + (optionally compressed) chunk packets + trailer.
+      const header = buildByteStreamHeader(info, {
+        compression: compressedStream ? DataStream_CompressionType.DEFLATE_RAW : DataStream_CompressionType.NONE
+      });
+      const packet = createStreamHeaderPacket(header, destinationIdentities);
+      const source = compressedStream ? compressedStream.stream() : readableFromBytes(bytes).pipeThrough(progressMonitorTap);
+      yield this.sendChunkedByteStream(packet, streamId, destinationIdentities, source);
+      // Ensure there's always a 100% progress event fired, even if the buffer is zero bytes long
+      if (bytes.length === 0) {
+        (_g = options === null || options === void 0 ? void 0 : options.onProgress) === null || _g === void 0 ? void 0 : _g.call(options, 1);
+      }
+      return info;
+    });
+  }
+  /**
+   * Returns true only if every recipient is known to support data streams v2 (single-packet inline
+   * streams and compression). For a targeted send this checks the named destination identities; for
+   * a broadcast (no explicit destinations) it checks every remote participant currently in the room.
+   * An empty room (nobody to receive) is considered eligible.
+   */
+  allRecipientsSupportV2(destinationIdentities) {
+    const identities = destinationIdentities && destinationIdentities.length > 0 ? destinationIdentities : this.getAllRemoteParticipantIdentities();
+    return identities.every(identity => this.getRemoteParticipantClientProtocol(identity) >= CLIENT_PROTOCOL_DATA_STREAM_V2);
+  }
+  /**
+   * Returns true only if every recipient advertises the deflate-raw compression capability (so it
+   * can decompress a compressed stream). Resolved the same way as {@link allRecipientsSupportV2}:
+   * named destinations, or every remote participant for a broadcast; an empty room is eligible.
+   */
+  allRecipientsSupportCompression(destinationIdentities) {
+    const identities = destinationIdentities && destinationIdentities.length > 0 ? destinationIdentities : this.getAllRemoteParticipantIdentities();
+    return identities.every(identity => this.getRemoteParticipantCapabilities(identity).includes(ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW));
+  }
+  /**
+   * Shared chunked-stream send for `sendText`/`sendFile`: sends the prebuilt header packet, then
+   * forwards `source` (optionally deflate-raw compressed) as `streamChunk` packets re-chunked to
+   * the MTU budget with contiguous indices, then sends the trailer. The source is consumed
+   * incrementally, so a `file.stream()` is never buffered in full. The platform compressor can't
+   * flush mid-stream, so compression is only used when the whole payload is available as a stream
+   * up front (not for incremental writers like `streamText`/`streamBytes`).
+   */
+  sendChunkedByteStream(headerPacket, streamId, destinationIdentities, source) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, e_1, _b, _c;
+      const engine = this.engine;
+      yield sendHeaderPacket(engine, headerPacket);
+      let chunkId = 0;
+      try {
+        for (var _d = true, _e = __asyncValues(readBytesInChunks(source, STREAM_CHUNK_SIZE_BYTES)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+          _c = _f.value;
+          _d = false;
+          const chunk = _c;
+          const chunkPacket = new DataPacket({
+            destinationIdentities,
+            value: {
+              case: 'streamChunk',
+              value: new DataStream_Chunk({
+                content: chunk,
+                streamId,
+                chunkIndex: numberToBigInt(chunkId)
+              })
+            }
+          });
+          yield engine.sendDataPacket(chunkPacket, DataChannelKind.RELIABLE);
+          chunkId += 1;
+        }
+      } catch (e_1_1) {
+        e_1 = {
+          error: e_1_1
+        };
+      } finally {
+        try {
+          if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      yield sendStreamTrailer(streamId, destinationIdentities, engine);
     });
   }
   /**
@@ -23966,6 +25358,7 @@ class OutgoingDataStreamManager {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b, _c;
       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: 'text/plain',
@@ -23976,39 +25369,20 @@ class OutgoingDataStreamManager {
         encryptionType: ((_c = this.engine.e2eeManager) === null || _c === void 0 ? void 0 : _c.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE,
         attachedStreamIds: options === null || options === void 0 ? void 0 : options.attachedStreamIds
       };
-      const header = new DataStream_Header({
-        streamId,
-        mimeType: info.mimeType,
-        topic: info.topic,
-        timestamp: numberToBigInt(info.timestamp),
-        totalLength: numberToBigInt(info.size),
-        attributes: info.attributes,
-        contentHeader: {
-          case: 'textHeader',
-          value: new DataStream_TextHeader({
-            version: options === null || options === void 0 ? void 0 : options.version,
-            attachedStreamIds: info.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, DataChannelKind.RELIABLE);
+      const header = buildTextStreamHeader(info, options);
+      const packet = createStreamHeaderPacket(header, destinationIdentities);
+      yield sendHeaderPacket(this.engine, packet);
       let chunkId = 0;
       const engine = this.engine;
+      // Incremental text streams are never compressed (CompressionStream does not support flushing
+      // mid-stream); one-shot compression lives in sendText.
+      //
+      // Note that a future streamText could send a context-takeover style deflate-raw stream with
+      // intermedia explicit `Z_SYNC_FLUSH`s - receivers already will handle this properly today.
       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)) {
+            for (const textByteChunk of splitUtf8(text, STREAM_CHUNK_SIZE_BYTES)) {
               const chunk = new DataStream_Chunk({
                 content: textByteChunk,
                 streamId,
@@ -24028,17 +25402,7 @@ class OutgoingDataStreamManager {
         },
         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, DataChannelKind.RELIABLE);
+            yield sendStreamTrailer(streamId, destinationIdentities, engine);
           });
         },
         abort(err) {
@@ -24049,6 +25413,8 @@ class OutgoingDataStreamManager {
       let onEngineClose = () => __awaiter(this, void 0, void 0, function* () {
         yield writer.close();
       });
+      // FIXME: make this a global event to ensure "max listener" warning won't get logged for lots of
+      // in flight data streams.
       engine.once(EngineEvent.Closing, onEngineClose);
       const writer = new TextStreamWriter(writableStream, info, () => this.engine.off(EngineEvent.Closing, onEngineClose));
       return writer;
@@ -24063,29 +25429,47 @@ class OutgoingDataStreamManager {
       };
     });
   }
+  /**
+   * Streams a file as a chunked byte stream, compressed (deflate-raw) when the runtime supports it
+   * and every recipient is on data streams v2. The file is piped `file.stream()` →
+   * (`CompressionStream`) → chunk packets via {@link sendChunkedByteStream}, so it is never fully
+   * buffered in memory — unlike {@link sendBytes}, there is no inline single-packet fast path for
+   * files (the compressed size can't be known up front without buffering the whole file).
+   */
   _sendFile(streamId, file, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      const writer = yield this.streamBytes({
-        streamId,
-        totalSize: file.size,
+      var _a, _b, _c, _d, _e;
+      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
+      const compress = ((_a = options === null || options === void 0 ? void 0 : options.compress) !== null && _a !== void 0 ? _a : true) && isCompressionStreamSupported() && this.allRecipientsSupportV2(destinationIdentities) && this.allRecipientsSupportCompression(destinationIdentities);
+      const info = {
+        id: streamId,
         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
+        mimeType: (_b = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _b !== void 0 ? _b : file.type,
+        topic: (_c = options === null || options === void 0 ? void 0 : options.topic) !== null && _c !== void 0 ? _c : '',
+        timestamp: Date.now(),
+        size: file.size,
+        encryptionType: ((_d = this.engine.e2eeManager) === null || _d === void 0 ? void 0 : _d.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE
+      };
+      // Phase 1: Try to send as a single packet data stream
+      //
+      // This is not being done explictly for files, because it's challenging to determine ahead of
+      // time how well the file contents will compress (and whether the total output will be under the
+      // MTU). Revisit this in the future though.
+      // Phase 2 (compressed) / Phase 3 (uncompressed fallback): header + chunk packets + trailer. Both
+      // funnel through the shared sendChunkedByteStream primitive, differing only by whether the file
+      // stream is wrapped in the deflate-raw compressor; the file is never fully buffered in memory.
+      const header = buildByteStreamHeader(info, {
+        compression: compress ? DataStream_CompressionType.DEFLATE_RAW : DataStream_CompressionType.NONE
       });
-      const reader = file.stream().getReader();
-      while (true) {
-        const _yield$reader$read = yield reader.read(),
-          done = _yield$reader$read.done,
-          value = _yield$reader$read.value;
-        if (done) {
-          break;
-        }
-        yield writer.write(value);
+      const packet = createStreamHeaderPacket(header, destinationIdentities);
+      const tapped = file.stream().pipeThrough(progressReportingStream(file.size, options === null || options === void 0 ? void 0 : options.onProgress));
+      const source = compress ? tapped.pipeThrough(deflateRawTransform()) : tapped;
+      yield this.sendChunkedByteStream(packet, streamId, destinationIdentities, source);
+      // Ensure there's always a 100% progress event fired, even if the file is zero bytes long
+      if (file.size === 0) {
+        (_e = options === null || options === void 0 ? void 0 : options.onProgress) === null || _e === void 0 ? void 0 : _e.call(options, 1);
       }
-      yield writer.close();
-      return writer.info;
+      return info;
     });
   }
   streamBytes(options) {
@@ -24103,32 +25487,18 @@ class OutgoingDataStreamManager {
         name: (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : 'unknown',
         encryptionType: ((_e = this.engine.e2eeManager) === null || _e === void 0 ? void 0 : _e.isDataChannelEncryptionEnabled) ? Encryption_Type.GCM : Encryption_Type.NONE
       };
-      const header = new DataStream_Header({
-        totalLength: numberToBigInt(info.size),
-        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, DataChannelKind.RELIABLE);
+      const header = buildByteStreamHeader(info);
+      const packet = createStreamHeaderPacket(header, destinationIdentities);
+      yield sendHeaderPacket(this.engine, packet);
       let chunkId = 0;
       const writeMutex = new _();
       const engine = this.engine;
       const logLocal = this.log;
+      // Incremental byte streams are never compressed (CompressionStream does not support flushing
+      // mid-stream); one-shot compression lives in sendFile.
+      //
+      // Note that a future streamBytes could send a context-takeover style deflate-raw stream with
+      // intermedia explicit `Z_SYNC_FLUSH`s - receivers already will handle this properly today.
       const writableStream = new WritableStream({
         write(chunk) {
           return __awaiter(this, void 0, void 0, function* () {
@@ -24136,7 +25506,7 @@ class OutgoingDataStreamManager {
             let byteOffset = 0;
             try {
               while (byteOffset < chunk.byteLength) {
-                const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
+                const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE_BYTES);
                 const chunkPacket = new DataPacket({
                   destinationIdentities,
                   value: {
@@ -24159,17 +25529,7 @@ class OutgoingDataStreamManager {
         },
         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, DataChannelKind.RELIABLE);
+            yield sendStreamTrailer(streamId, destinationIdentities, engine);
           });
         },
         abort(err) {
@@ -24180,6 +25540,109 @@ class OutgoingDataStreamManager {
       return byteWriter;
     });
   }
+}
+/**
+ * Wraps a stream of compressed bytes and defers buffering it into memory until (and only if) the
+ * full length is actually needed.
+ *
+ * The ideal way to send a compressed stream is incrementally: compress each chunk and send it as
+ * soon as it's ready, without ever holding the whole payload in memory. But to decide whether a
+ * payload is small enough to fit in a single-packet data stream, we have to know the compressed
+ * length — and the only way to learn that is to compress everything and add up the bytes. That
+ * forces us to buffer the entire compressed output before we can make the decision.
+ *
+ * This class lets us have it both ways. It holds the compressed stream unread by default and only
+ * collects it into memory ({@link collect}) when a caller needs the length for the single-packet
+ * size check. If that check never happens, the stream is instead {@link stream|passed straight
+ * through} to the downstream consumer without ever being fully buffered. Once collected, later
+ * calls reuse the buffered bytes rather than re-collecting.
+ */
+class MaybeCollectedStream {
+  constructor(state) {
+    this.state = state;
+  }
+  static fromStream(stream) {
+    return new MaybeCollectedStream({
+      type: 'stream',
+      stream
+    });
+  }
+  /** Collect data from the stream into memory and return as a Uint8Array. */
+  collect() {
+    return __awaiter(this, void 0, void 0, function* () {
+      switch (this.state.type) {
+        case 'stream':
+          const bytes = yield collect(this.state.stream);
+          this.state = {
+            type: 'collected',
+            bytes
+          };
+          return bytes;
+        case 'collected':
+          return this.state.bytes;
+      }
+    });
+  }
+  /** Pass wrapped stream through to downstream consumer. */
+  stream() {
+    switch (this.state.type) {
+      case 'stream':
+        return this.state.stream;
+      case 'collected':
+        return readableFromBytes(this.state.bytes);
+    }
+  }
+}
+/**
+ * A pass-through byte transform that reports progress as bytes flow through it, measured against
+ * `totalLength`. Used as a "tap" to instrument the source of a chunked send without threading a
+ * progress callback through the send primitive.
+ *
+ * IMPORTANT: This should be upstream of any compression step.
+ *
+ * Emits nothing when the total is unknown or zero.
+ */
+function progressReportingStream(totalPreCompressionLength, onProgress) {
+  let sent = 0;
+  return new TransformStream({
+    transform(chunk, controller) {
+      sent += chunk.byteLength;
+      if (onProgress && typeof totalPreCompressionLength === 'number' && totalPreCompressionLength > 0) {
+        onProgress(Math.min(sent / totalPreCompressionLength, 1));
+      }
+      controller.enqueue(chunk);
+    }
+  });
+}
+/**
+ * Sends a stream `streamHeader` packet, enforcing that it fits the MTU budget. The header carries
+ * the user attributes (plus topic/framing), and a single `DataPacket` larger than the MTU can't be
+ * reliably sent — so an oversized header (almost always due to large attributes) is a hard error
+ * rather than a malformed packet on the wire. The inline fast path does its own size check and
+ * falls back to the chunked path instead of calling this.
+ */
+function sendHeaderPacket(engine, packet) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (packet.toBinary().byteLength > STREAM_CHUNK_SIZE_BYTES) {
+      throw new DataStreamError("data stream header exceeds the ".concat(STREAM_CHUNK_SIZE_BYTES, "-byte limit; reduce attribute size"), DataStreamErrorReason.HeaderTooLarge);
+    }
+    yield engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
+  });
+}
+/** Sends a `streamTrailer` packet, marking the end of a stream. */
+function sendStreamTrailer(streamId, destinationIdentities, engine) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const trailerPacket = new DataPacket({
+      destinationIdentities,
+      value: {
+        case: 'streamTrailer',
+        value: new DataStream_Trailer({
+          streamId
+        })
+      }
+    });
+    yield engine.sendDataPacket(trailerPacket, DataChannelKind.RELIABLE);
+  });
 }/**
  * Implementation of AbortSignal.any
  * Creates a signal that will be aborted when any of the given signals is aborted.
@@ -26670,7 +28133,7 @@ class RpcClientManager extends eventsExports.EventEmitter {
     return __awaiter(this, void 0, void 0, function* () {
       if (remoteClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
         // Send payload as a data stream - a "version 2" rpc request.
-        const writer = yield this.outgoingDataStreamManager.streamText({
+        yield this.outgoingDataStreamManager.sendText(payload, {
           topic: RPC_REQUEST_DATA_STREAM_TOPIC,
           destinationIdentities: [destinationIdentity],
           attributes: {
@@ -26680,8 +28143,6 @@ class RpcClientManager extends eventsExports.EventEmitter {
             [RpcRequestAttrs.RPC_REQUEST_VERSION]: "".concat(RPC_VERSION_V2)
           }
         });
-        yield writer.write(payload);
-        yield writer.close();
         return;
       }
       // Fallback to sending a literal RpcRequest - a "version 1" rpc request.
@@ -26955,15 +28416,13 @@ class RpcServerManager extends eventsExports.EventEmitter {
       const callerClientProtocol = this.getRemoteParticipantClientProtocol(destinationIdentity);
       if (callerClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
         // Send response as a data stream
-        const writer = yield this.outgoingDataStreamManager.streamText({
+        yield this.outgoingDataStreamManager.sendText(payload, {
           topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
           destinationIdentities: [destinationIdentity],
           attributes: {
             [RpcRequestAttrs.RPC_REQUEST_ID]: requestId
           }
         });
-        yield writer.write(payload);
-        yield writer.close();
         return;
       }
       // Legacy client: enforce size limit and send uncompressed payload inline
@@ -29439,6 +30898,18 @@ class Participant extends eventsExports.EventEmitter {
       return this.roomOutgoingDataStreamManager.sendFile(file, options);
     });
   }
+  /**
+   * Sends the given bytes to participants in the room via the data channel.
+   * For files, consider using {@link sendFile}; for longer/incremental payloads, {@link streamBytes}.
+   *
+   * @param bytes The byte payload
+   * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+   */
+  sendBytes(bytes, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.roomOutgoingDataStreamManager.sendBytes(bytes, options);
+    });
+  }
   /**
    * Stream bytes incrementally to participants in the room via the data channel.
    * For sending files, consider using {@link sendFile} instead.
@@ -29968,7 +31439,7 @@ class DeferrableMap extends Map {
       return new RemoteDataTrack(info, manager, {
         publisherIdentity: pi.identity
       });
-    }), pi.clientProtocol);
+    }), pi.clientProtocol, pi.capabilities);
   }
   get logContext() {
     return Object.assign(Object.assign({}, super.logContext), {
@@ -29981,6 +31452,7 @@ class DeferrableMap extends Map {
     let kind = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : ParticipantInfo_Kind.STANDARD;
     let remoteDataTracks = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : [];
     let clientProtocol = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : CLIENT_PROTOCOL_DEFAULT;
+    let capabilities = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : [];
     super(sid, identity || '', name, metadata, attributes, loggerOptions, kind);
     this.signalClient = signalClient;
     this.trackPublications = new Map();
@@ -29991,6 +31463,7 @@ class DeferrableMap extends Map {
     }));
     this.volumeMap = new Map();
     this.clientProtocol = clientProtocol;
+    this.capabilities = capabilities;
   }
   addTrackPublication(publication) {
     super.addTrackPublication(publication);
@@ -30293,6 +31766,7 @@ class Room extends eventsExports.EventEmitter {
     this.log = livekitLogger;
     this.bufferedEvents = [];
     this.isResuming = false;
+    this.pendingTrackAddedCallbacks = new Map();
     this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       var _a;
       if (!isBrowserSupported()) {
@@ -30402,11 +31876,10 @@ class Room extends eventsExports.EventEmitter {
       return this.connectFuture.promise;
     });
     this.connectSignal = (url, token, engine, connectOptions, roomOptions, abortController) => __awaiter(this, void 0, void 0, function* () {
-      var _a;
       const _yield$engine$join = yield engine.join(url, token, {
           autoSubscribe: connectOptions.autoSubscribe,
           adaptiveStream: typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
-          clientInfoCapabilities: isFrameMetadataSupported((_a = roomOptions.frameMetadata) !== null && _a !== void 0 ? _a : roomOptions.packetTrailer) || !!this.e2eeManager ? [ClientInfo_Capability.CAP_PACKET_TRAILER] : undefined,
+          clientInfoCapabilities: this.getClientInfoCapabilities(roomOptions),
           maxRetries: connectOptions.maxRetries,
           e2eeEnabled: !!this.e2eeManager,
           websocketTimeout: connectOptions.websocketTimeout
@@ -30809,8 +32282,9 @@ class Room extends eventsExports.EventEmitter {
           return;
         }
         const newStreamState = Track.streamStateFromProto(streamState.state);
+        const prevStreamState = pub.track.streamState;
         pub.track.setStreamState(newStreamState);
-        if (newStreamState !== pub.track.streamState) {
+        if (newStreamState !== prevStreamState) {
           participant.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState);
           this.emitWhenConnected(RoomEvent.TrackStreamStateChanged, pub, pub.track.streamState, participant);
         }
@@ -30828,6 +32302,7 @@ class Room extends eventsExports.EventEmitter {
       pub.setAllowed(update.allowed);
     };
     this.handleSubscriptionError = update => {
+      this.cancelPendingTrackAdded(update.trackSid);
       const participant = Array.from(this.remoteParticipants.values()).find(p => p.trackPublications.has(update.trackSid));
       if (!participant) {
         return;
@@ -30966,6 +32441,13 @@ class Room extends eventsExports.EventEmitter {
       var _a, _b;
       return (_b = (_a = this.remoteParticipants.get(identity)) === null || _a === void 0 ? void 0 : _a.clientProtocol) !== null && _b !== void 0 ? _b : CLIENT_PROTOCOL_DEFAULT;
     };
+    this.getRemoteParticipantCapabilities = identity => {
+      var _a, _b;
+      return (_b = (_a = this.remoteParticipants.get(identity)) === null || _a === void 0 ? void 0 : _a.capabilities) !== null && _b !== void 0 ? _b : [];
+    };
+    this.getAllRemoteParticipantIdentities = () => {
+      return Array.from(this.remoteParticipants.keys());
+    };
     this.onLocalParticipantMetadataChanged = metadata => {
       this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
     };
@@ -31042,7 +32524,7 @@ class Room extends eventsExports.EventEmitter {
     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.outgoingDataStreamManager = new OutgoingDataStreamManager(this.engine, this.log, this.getRemoteParticipantClientProtocol, this.getRemoteParticipantCapabilities, this.getAllRemoteParticipantIdentities);
     this.incomingDataTrackManager = new IncomingDataTrackManager({
       e2eeManager: this.e2eeManager
     });
@@ -31079,7 +32561,7 @@ class Room extends eventsExports.EventEmitter {
     }).on('packetAvailable', _ref => {
       let handle = _ref.handle,
         bytes = _ref.bytes;
-      this.engine.sendLossyBytes(bytes, DataChannelKind.DATA_TRACK_LOSSY, 'wait').finally(() => this.outgoingDataTrackManager.handlePacketSendComplete(handle));
+      this.engine.sendDataTrackFrame(bytes).finally(() => this.outgoingDataTrackManager.handlePacketSendComplete(handle));
     });
     this.registerRpcDataStreamHandler();
     this.rpcClientManager = new RpcClientManager(this.log, this.outgoingDataStreamManager, this.getRemoteParticipantClientProtocol, () => {
@@ -31328,15 +32810,15 @@ class Room extends eventsExports.EventEmitter {
       this.isResuming = false;
       this.log.debug('Resumed signal connection');
       this.updateSubscriptions();
-      this.emitBufferedEvents();
       if (this.setAndEmitConnectionState(ConnectionState.Connected)) {
         this.emit(RoomEvent.Reconnected);
       }
+      this.emitBufferedEvents();
     }).on(EngineEvent.SignalResumed, () => {
-      this.bufferedEvents = [];
       if (this.state === ConnectionState.Reconnecting || this.isResuming) {
         this.sendSyncState();
       }
+      this.emitBufferedEvents();
     }).on(EngineEvent.Restarting, this.handleRestarting).on(EngineEvent.Restarted, this.handleRestarted).on(EngineEvent.SignalRestarted, this.handleSignalRestarted).on(EngineEvent.Offline, () => {
       if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
         this.emit(RoomEvent.Reconnecting);
@@ -31753,29 +33235,43 @@ class Room extends eventsExports.EventEmitter {
     this.maybeCreateEngine();
   }
   onTrackAdded(mediaTrack, stream, receiver) {
+    var _a, _b;
     // don't fire onSubscribed when connecting
     // WebRTC fires onTrack as soon as setRemoteDescription is called on the offer
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
+    if ([ConnectionState.Connecting, ConnectionState.Reconnecting].includes(this.state)) {
+      const pendingTrackSid = extractTrackSid(mediaTrack, stream);
+      this.log.debug('deferring on track for later', {
+        mediaTrackId: mediaTrack.id,
+        mediaStreamId: stream.id,
+        tracksInStream: stream.getTracks().map(track => track.id)
+      });
       const reconnectedHandler = () => {
-        this.log.debug('deferring on track for later', {
-          mediaTrackId: mediaTrack.id,
-          mediaStreamId: stream.id,
-          tracksInStream: stream.getTracks().map(track => track.id)
-        });
-        this.onTrackAdded(mediaTrack, stream, receiver);
         cleanup();
+        this.onTrackAdded(mediaTrack, stream, receiver);
       };
       const cleanup = () => {
         this.off(RoomEvent.Reconnected, reconnectedHandler);
         this.off(RoomEvent.Connected, reconnectedHandler);
         this.off(RoomEvent.Disconnected, cleanup);
+        if (pendingTrackSid) {
+          const pendingCallbacks = this.pendingTrackAddedCallbacks.get(pendingTrackSid);
+          pendingCallbacks === null || pendingCallbacks === void 0 ? void 0 : pendingCallbacks.delete(cleanup);
+          if ((pendingCallbacks === null || pendingCallbacks === void 0 ? void 0 : pendingCallbacks.size) === 0) {
+            this.pendingTrackAddedCallbacks.delete(pendingTrackSid);
+          }
+        }
       };
       this.once(RoomEvent.Reconnected, reconnectedHandler);
       this.once(RoomEvent.Connected, reconnectedHandler);
       this.once(RoomEvent.Disconnected, cleanup);
+      if (pendingTrackSid) {
+        const pendingCallbacks = (_a = this.pendingTrackAddedCallbacks.get(pendingTrackSid)) !== null && _a !== void 0 ? _a : new Set();
+        pendingCallbacks.add(cleanup);
+        this.pendingTrackAddedCallbacks.set(pendingTrackSid, pendingCallbacks);
+      }
       return;
     }
     if (this.state === ConnectionState.Disconnected) {
@@ -31788,11 +33284,10 @@ class Room extends eventsExports.EventEmitter {
     }
     const parts = unpackStreamId(stream.id);
     const participantSid = parts[0];
-    let streamId = parts[1];
-    let trackId = mediaTrack.id;
+    const streamId = parts[1];
     // firefox will get streamId (pID|trackId) instead of (pID|streamId) as it doesn't support sync tracks by stream
     // and generates its own track id instead of infer from sdp track id.
-    if (streamId && streamId.startsWith('TR')) trackId = streamId;
+    let trackId = (_b = extractTrackSid(mediaTrack, stream)) !== null && _b !== void 0 ? _b : mediaTrack.id;
     if (participantSid === this.localParticipant.sid) {
       this.log.warn('tried to create RemoteParticipant for local participant');
       return;
@@ -31836,6 +33331,10 @@ class Room extends eventsExports.EventEmitter {
       this.emit(RoomEvent.EncryptionError, new Error("Encrypted ".concat(publication.source, " track received from participant ").concat(participant.sid, ", but room does not have encryption enabled!")));
     }
   }
+  cancelPendingTrackAdded(trackSid) {
+    var _a;
+    (_a = this.pendingTrackAddedCallbacks.get(trackSid)) === null || _a === void 0 ? void 0 : _a.forEach(cleanup => cleanup());
+  }
   handleLocalTrackSubscribed(subscribedSid) {
     const findPublication = () => this.localParticipant.getTrackPublications().find(_ref6 => {
       let trackSid = _ref6.trackSid;
@@ -32099,6 +33598,7 @@ class Room extends eventsExports.EventEmitter {
       }
       this.emitWhenConnected(RoomEvent.TrackSubscribed, track, publication, participant);
     }).on(ParticipantEvent.TrackUnpublished, publication => {
+      this.cancelPendingTrackAdded(publication.trackSid);
       this.emit(RoomEvent.TrackUnpublished, publication, participant);
     }).on(ParticipantEvent.TrackUnsubscribed, (track, publication) => {
       this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
@@ -32162,6 +33662,20 @@ class Room extends eventsExports.EventEmitter {
       return this.remoteParticipants.get(identity);
     }
   }
+  /** The client capabilities this SDK advertises to other participants in its `ClientInfo`. */
+  getClientInfoCapabilities(roomOptions) {
+    var _a;
+    const capabilities = [];
+    if (isFrameMetadataSupported((_a = roomOptions.frameMetadata) !== null && _a !== void 0 ? _a : roomOptions.packetTrailer) || !!this.e2eeManager) {
+      capabilities.push(ClientInfo_Capability.CAP_PACKET_TRAILER);
+    }
+    // Advertise deflate-raw decompression support so peers know they can send us compressed data
+    // streams (gated separately from clientProtocol — see the data streams v2 spec).
+    if (isCompressionStreamSupported()) {
+      capabilities.push(ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW);
+    }
+    return capabilities;
+  }
   registerRpcDataStreamHandler() {
     this.incomingDataStreamManager.registerTextStreamHandler(RPC_REQUEST_DATA_STREAM_TOPIC, (reader_1, _a) => __awaiter(this, [reader_1, _a], void 0, function (reader, _ref7) {
       var _this4 = this;
@@ -32202,8 +33716,17 @@ class Room extends eventsExports.EventEmitter {
           } : undefined
         });
         if (consecutiveFailures >= 3) {
-          this.recreateEngine();
-          this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, DisconnectReason.STATE_MISMATCH);
+          this.clearConnectionReconcile();
+          if (this.engine && !this.engine.isClosed) {
+            // The transport silently died while we still looked connected. Try a full reconnect
+            // (keeps the room alive; the engine falls back to Disconnected if it ultimately fails).
+            this.log.warn('detected connection state mismatch, attempting full reconnect');
+            this.engine.reconnect();
+          } else {
+            // No usable engine to reconnect with; tear down.
+            this.recreateEngine();
+            this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, DisconnectReason.STATE_MISMATCH);
+          }
         }
       } else {
         consecutiveFailures = 0;
@@ -33600,24 +35123,26 @@ class TokenSourceEndpoint extends TokenSourceCached {
       const body = yield response.json();
       return TokenSourceResponse.fromJson(body, {
         // NOTE: it could be possible that the response body could contain more fields than just
-        // what's in TokenSourceResponse depending on the implementation (ie, SandboxTokenServer)
+        // what's in TokenSourceResponse depending on the implementation (ie, DevelopmentTokenServer)
         ignoreUnknownFields: true
       });
     });
   }
 }
-class TokenSourceSandboxTokenServer extends TokenSourceEndpoint {
-  constructor(sandboxId, options) {
+class TokenSourceDevelopmentTokenServer extends TokenSourceEndpoint {
+  constructor(tokenServerId, options) {
     const _options$baseUrl = options.baseUrl,
       baseUrl = _options$baseUrl === void 0 ? 'https://cloud-api.livekit.io' : _options$baseUrl,
       rest = __rest(options, ["baseUrl"]);
     super("".concat(baseUrl, "/api/v2/sandbox/connection-details"), Object.assign(Object.assign({}, rest), {
       headers: {
-        'X-Sandbox-ID': sandboxId
+        'X-Sandbox-ID': tokenServerId
       }
     }));
   }
 }
+/** @deprecated Use {@link TokenSourceDevelopmentTokenServer} instead */
+class TokenSourceSandboxTokenServer extends TokenSourceDevelopmentTokenServer {}
 const TokenSource = {
   /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
    * credentials, either provided directly or returned from a provided function. */
@@ -33636,24 +35161,31 @@ const TokenSource = {
   /**
    * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
    * the standard endpoint format:
-   * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+   * @see https://docs.livekit.io/frontends/build/authentication/endpoint/
    */
   endpoint(url) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return new TokenSourceEndpoint(url, options);
   },
   /**
-   * TokenSource.sandboxTokenServer queries a sandbox token server for credentials,
+   * @deprecated Use {@link TokenSource.developmentTokenServer} instead
+   */
+  sandboxTokenServer(sandboxId) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new TokenSourceSandboxTokenServer(sandboxId, options);
+  },
+  /**
+   * TokenSource.developmentTokenServer queries a development token server for credentials,
    * which supports quick prototyping / getting started types of use cases.
    *
    * This token provider is INSECURE and should NOT be used in production.
    *
    * For more info:
-   * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+   * @see https://docs.livekit.io/frontends/build/authentication/sandbox-token-server/
    */
-  sandboxTokenServer(sandboxId) {
+  developmentTokenServer(tokenServerId) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return new TokenSourceSandboxTokenServer(sandboxId, options);
+    return new TokenSourceDevelopmentTokenServer(tokenServerId, options);
   }
 };/**
  * Try to analyze the local track to determine the facing mode of a track.
@@ -33781,4 +35313,4 @@ const serializers = {
   json,
   raw,
   custom
-};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CLIENT_PROTOCOL_DATA_STREAM_RPC,CLIENT_PROTOCOL_DEFAULT,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,FrameMetadataManager,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,clientProtocol,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map
+};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CLIENT_PROTOCOL_DATA_STREAM_RPC,CLIENT_PROTOCOL_DATA_STREAM_V2,CLIENT_PROTOCOL_DEFAULT,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,FrameMetadataManager,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,clientProtocol,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map