livekit-client 2.20.2 → 2.21.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.21.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) {
@@ -14121,6 +14406,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');
@@ -17269,110 +17601,35 @@ 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;
+}class TTLMap {
+  /**
+   * @param ttl ttl of the key (ms)
+   */
+  constructor(ttl) {
+    this._map = new Map();
+    this._lastCleanup = 0;
+    this.ttl = ttl;
   }
-  push(item) {
-    this.buffer.push(item);
-    this._totalSize += item.data.byteLength;
-    if (item.sent) {
-      this._sentSize += item.data.byteLength;
+  set(key, value) {
+    const now = Date.now();
+    if (now - this._lastCleanup > this.ttl / 2) {
+      this.cleanup();
     }
+    const expiresAt = now + this.ttl;
+    this._map.set(key, {
+      value,
+      expiresAt
+    });
+    return this;
   }
-  pop() {
-    const item = this.buffer.shift();
-    if (item) {
-      this._totalSize -= item.data.byteLength;
-      if (item.sent) {
-        this._sentSize -= item.data.byteLength;
-      }
+  get(key) {
+    const entry = this._map.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return undefined;
     }
-    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)
-   */
-  constructor(ttl) {
-    this._map = new Map();
-    this._lastCleanup = 0;
-    this.ttl = ttl;
-  }
-  set(key, value) {
-    const now = Date.now();
-    if (now - this._lastCleanup > this.ttl / 2) {
-      this.cleanup();
-    }
-    const expiresAt = now + this.ttl;
-    this._map.set(key, {
-      value,
-      expiresAt
-    });
-    return this;
-  }
-  get(key) {
-    const entry = this._map.get(key);
-    if (!entry) return undefined;
-    if (entry.expiresAt < Date.now()) {
-      this._map.delete(key);
-      return undefined;
-    }
-    return entry.value;
+    return entry.value;
   }
   has(key) {
     const entry = this._map.get(key);
@@ -19289,6 +19546,663 @@ class PCTransportManager {
       }();
     });
   }
+}/**
+ * 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;
+  }
+  /** 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');
+    }
+    this.handle = dc;
+  }
+  /** 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;
+  }
+  getChannel() {
+    return this.handle;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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.
+   */
+  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
@@ -21318,27 +22232,14 @@ function videoLayersFromEncodings(width, height, encodings, svc) {
     return new VideoLayer({
       quality,
       width: Math.ceil(width / scale),
-      height: Math.ceil(height / scale),
-      bitrate: (_c = encoding.maxBitrate) !== null && _c !== void 0 ? _c : 0,
-      ssrc: 0
-    });
-  });
-}const lossyDataChannel = '_lossy';
-const reliableDataChannel = '_reliable';
-const dataTrackDataChannel = '_data_track';
-const minReconnectWait = 2 * 1000;
-const leaveReconnect = 'leave-reconnect';
-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;
+      height: Math.ceil(height / scale),
+      bitrate: (_c = encoding.maxBitrate) !== null && _c !== void 0 ? _c : 0,
+      ssrc: 0
+    });
+  });
+}const minReconnectWait = 2 * 1000;
+const leaveReconnect = 'leave-reconnect';
+const reliabeReceiveStateTTL = 30000;
 const initialMediaSectionsAudio = 3;
 const initialMediaSectionsVideo = 3;
 var PCState;
@@ -21349,12 +22250,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 +22265,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 +22300,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 +22311,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 +22321,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 +22366,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 +22404,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 +22459,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,7 +22518,15 @@ 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.onRoomUpdate = update => this.emit(EngineEvent.RoomUpdate, update);
@@ -21860,55 +22682,14 @@ 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;
       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* () {
@@ -21975,7 +22756,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* () {
@@ -22235,69 +23016,22 @@ class RTCEngine extends eventsExports.EventEmitter {
     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* () {
@@ -22549,7 +23283,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 +23336,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) {
@@ -22660,7 +23394,8 @@ class RTCEngine extends eventsExports.EventEmitter {
     });
   }
   /* @internal */
-  sendDataPacket(packet, kind) {
+  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* () {
       var _a, _b;
       // make sure we do have a data connection
@@ -22680,8 +23415,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
       }
       if (kind === DataChannelKind.RELIABLE) {
-        packet.sequence = this.reliableDataSequence;
-        this.reliableDataSequence += 1;
+        packet.sequence = this.reliableChannel.nextSequence();
       }
       const msg = packet.toBinary();
       // Clamp to the SDK default - libwebrtc advertises larger (~256 KiB)
@@ -22691,249 +23425,48 @@ class RTCEngine extends eventsExports.EventEmitter {
       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;
-          }
+      // 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);
       }
     });
   }
-  /* @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;
-          }
-        }
-      }();
+  /**
+   * 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
+   */
+  sendDataTrackFrame(bytes) {
+    return __awaiter(this, void 0, void 0, function* () {
+      // 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);
-      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();
-        }
-      }
-      this.updateAndEmitDCBufferStatus(DataChannelKind.RELIABLE);
+      yield this.reliableChannel.replay(lastMessageSeq);
     });
   }
-  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.
-   */
-  waitForBufferHeadroomWithLock(kind) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.getBufferHeadroomLock(kind).lock();
-      try {
-        yield this.waitForBufferHeadroomWithoutLock(kind);
-      } finally {
-        unlock();
-      }
-    });
+  /** 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 +23474,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);
@@ -23017,7 +23550,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 +23594,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 +23922,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 +24047,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 +24068,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
@@ -23587,6 +24188,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 +24208,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 +24289,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 +24297,7 @@ class TextStreamReader extends BaseStreamReader {
     this.textStreamHandlers = new Map();
     this.isConnected = false;
     this.bufferedPackets = [];
+    this.maxPayloadByteLength = maxPayloadByteLength;
   }
   setConnected(connected) {
     this.isConnected = connected;
@@ -23773,74 +24380,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;
+          }
+          // 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;
           }
-          this.byteStreamControllers.set(streamHeader.streamId, {
-            info,
-            controller: streamController,
-            startTime: Date.now(),
-            sendingParticipantIdentity: participantIdentity
+          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;
+          }
+          // 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;
           }
-          this.textStreamControllers.set(streamHeader.streamId, {
-            info,
-            controller: streamController,
-            startTime: Date.now(),
-            sendingParticipantIdentity: participantIdentity
+          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) {
@@ -23870,9 +24553,15 @@ class TextStreamReader extends BaseStreamReader {
         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);
+        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) {
@@ -23880,11 +24569,174 @@ class TextStreamReader extends BaseStreamReader {
         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();
+        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', {
+    fatal: true
+  });
+  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);
+    }
+  };
+  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;
+      }
+    }
+  });
+}
+/**
+ * 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);
+      }
+      controller.enqueue(value);
+    }
+  });
 }class BaseStreamWriter {
   constructor(writableStream, info, onClose) {
     this.writableStream = writableStream;
@@ -23905,15 +24757,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 +24828,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 +25067,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 +25078,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 +25111,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 +25122,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 +25138,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 +25196,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 +25215,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 +25238,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 +25249,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 +27842,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 +27852,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 +28125,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 +30607,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 +31148,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 +31161,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 +31172,7 @@ class DeferrableMap extends Map {
     }));
     this.volumeMap = new Map();
     this.clientProtocol = clientProtocol;
+    this.capabilities = capabilities;
   }
   addTrackPublication(publication) {
     super.addTrackPublication(publication);
@@ -30402,11 +31584,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
@@ -30966,6 +32147,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 +32230,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 +32267,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,10 +32516,10 @@ 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) {
@@ -32162,6 +33350,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;
@@ -33781,4 +34983,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