livekit-client 2.20.1 → 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,
@@ -8226,6 +8503,8 @@ var LoggerNames;
   LoggerNames["PCTransport"] = "livekit-pc-transport";
   LoggerNames["E2EE"] = "lk-e2ee";
   LoggerNames["DataTracks"] = "livekit-data-tracks";
+  LoggerNames["Region"] = "livekit-region";
+  LoggerNames["ICE"] = "livekit-ice";
 })(LoggerNames || (LoggerNames = {}));
 let livekitLogger = loglevelExports.getLogger(LoggerNames.Default);
 const livekitLoggers = Object.values(LoggerNames).map(name => loglevelExports.getLogger(name));
@@ -8810,7 +9089,7 @@ function wrapPeerConnectionEvent(window, eventNameToWrap, wrapper) {
   }
   const addEventListener = Object.getOwnPropertyDescriptor(EventTarget.prototype, 'addEventListener');
   if (!addEventListener.writable) {
-    log$4('Unable to polyfill events');
+    log$5('Unable to polyfill events');
     return;
   }
   const proto = window.RTCPeerConnection.prototype;
@@ -8890,7 +9169,7 @@ function disableWarnings(bool) {
   deprecationWarnings_ = !bool;
   return 'adapter.js deprecation warnings ' + (bool ? 'disabled' : 'enabled');
 }
-function log$4() {
+function log$5() {
   if (typeof window === 'object') {
     if (logDisabled_) {
       return;
@@ -9052,7 +9331,7 @@ function filterStats(result, track, outbound) {
  *  tree.
  */
 /* eslint-env node */
-const logging = log$4;
+const logging = log$5;
 function shimGetUserMedia$2(window, browserDetails) {
   if (browserDetails.version >= 64) {
     return;
@@ -11679,7 +11958,7 @@ function adapterFactory() {
     shimSafari: true
   };
   // Utils.
-  const logging = log$4;
+  const logging = log$5;
   const browserDetails = detectBrowser(window);
   const adapter = {
     browserDetails,
@@ -11881,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.1";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');
@@ -11972,25 +12255,25 @@ class TrackInvalidError extends LivekitError {
 }
 class UnsupportedServer extends LivekitError {
   constructor(message) {
-    super(10, message !== null && message !== void 0 ? message : 'unsupported server');
+    super(10, message || 'unsupported server');
     this.name = 'UnsupportedServer';
   }
 }
 class UnexpectedConnectionState extends LivekitError {
   constructor(message) {
-    super(12, message !== null && message !== void 0 ? message : 'unexpected connection state');
+    super(12, message || 'unexpected connection state');
     this.name = 'UnexpectedConnectionState';
   }
 }
 class NegotiationError extends LivekitError {
   constructor(message) {
-    super(13, message !== null && message !== void 0 ? message : 'unable to negotiate');
+    super(13, message || 'unable to negotiate');
     this.name = 'NegotiationError';
   }
 }
 class PublishDataError extends LivekitError {
   constructor(message) {
-    super(14, message !== null && message !== void 0 ? message : 'unable to publish data');
+    super(14, message || 'unable to publish data');
     this.name = 'PublishDataError';
   }
 }
@@ -12026,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) {
@@ -13195,6 +13482,9 @@ class Track extends eventsExports.EventEmitter {
   }
   /** @internal */
   setStreamState(value) {
+    if (this._streamState !== value) {
+      this.log.debug("stream state changed: ".concat(this._streamState, " -> ").concat(value));
+    }
     this._streamState = value;
   }
   constructor(mediaTrack, kind) {
@@ -13219,8 +13509,8 @@ class Track extends eventsExports.EventEmitter {
         this.handleAppVisibilityChanged();
       }
     };
-    this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Track);
     this.loggerContextCb = loggerOptions.loggerContextCb;
+    this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Track, () => this.logContext);
     this.setMaxListeners(100);
     this.kind = kind;
     this._mediaStreamTrack = mediaTrack;
@@ -13288,9 +13578,11 @@ class Track extends eventsExports.EventEmitter {
         this.emit(hasAudio ? TrackEvent.AudioPlaybackFailed : TrackEvent.VideoPlaybackFailed, e);
       } else if (e.name === 'AbortError') {
         // commonly triggered by another `play` request, only log for debugging purposes
-        livekitLogger.debug("".concat(hasAudio ? 'audio' : 'video', " playback aborted, likely due to new play request"));
+        this.log.debug("".concat(hasAudio ? 'audio' : 'video', " playback aborted, likely due to new play request"));
       } else {
-        livekitLogger.warn("could not playback ".concat(hasAudio ? 'audio' : 'video'), e);
+        this.log.warn("could not playback ".concat(hasAudio ? 'audio' : 'video'), {
+          error: e
+        });
       }
       // If audio playback isn't allowed make sure we still play back the video
       if (hasAudio && element && allMediaStreamTracks.some(tr => tr.kind === 'video') && e.name === 'NotAllowedError') {
@@ -13333,6 +13625,7 @@ class Track extends eventsExports.EventEmitter {
     }
   }
   stop() {
+    this.log.debug('stopping track');
     this.stopMonitor();
     this._mediaStreamTrack.stop();
   }
@@ -13353,12 +13646,12 @@ class Track extends eventsExports.EventEmitter {
   }
   /** @internal */
   updateLoggerOptions(loggerOptions) {
-    if (loggerOptions.loggerName) {
-      this.log = getLogger(loggerOptions.loggerName);
-    }
     if (loggerOptions.loggerContextCb) {
       this.loggerContextCb = loggerOptions.loggerContextCb;
     }
+    if (loggerOptions.loggerName) {
+      this.log = getLogger(loggerOptions.loggerName, () => this.logContext);
+    }
   }
   recycleElement(element) {
     if (element instanceof HTMLAudioElement) {
@@ -14113,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');
@@ -16317,6 +16657,10 @@ var SignalConnectionState;
 })(SignalConnectionState || (SignalConnectionState = {}));
 /** specifies how much time (in ms) we allow for the ws to close its connection gracefully before continuing */
 const MAX_WS_CLOSE_TIME = 250;
+/**
+ * How long (in ms) to wait for the first message after the WebSocket upgrade.
+ */
+const JOIN_RESPONSE_TIMEOUT = 5000;
 /** @internal */
 class SignalClient {
   get currentState() {
@@ -16465,7 +16809,6 @@ class SignalClient {
             this.ws = new WebSocketStream(rtcUrl);
             try {
               this.ws.closed.then(closeInfo => {
-                var _a;
                 if (this.isEstablishingConnection) {
                   reject(ConnectionError.internal("Websocket got closed during a (re)connection attempt: ".concat(closeInfo.reason)));
                 }
@@ -16477,7 +16820,7 @@ class SignalClient {
                     state: this.state
                   });
                   if (this.state === SignalConnectionState.CONNECTED) {
-                    this.handleOnClose((_a = closeInfo.reason) !== null && _a !== void 0 ? _a : 'Unexpected WS error');
+                    this.handleOnClose(closeInfo.reason || 'Unexpected WS error');
                   }
                 }
                 return;
@@ -16505,7 +16848,26 @@ class SignalClient {
               }
               const signalReader = connection.readable.getReader();
               this.streamWriter = connection.writable.getWriter();
-              const firstMessage = yield signalReader.read();
+              // wsTimeout only guarded the upgrade; guard the first-message read with
+              // its own timeout so a silent server can't hang join() forever.
+              let firstMessage;
+              let firstMessageTimeout;
+              try {
+                firstMessage = yield Promise.race([signalReader.read(), new Promise((_, rejectRead) => {
+                  firstMessageTimeout = setTimeout(() => {
+                    rejectRead(ConnectionError.timeout('signal connection timed out while waiting for the first message'));
+                  }, JOIN_RESPONSE_TIMEOUT);
+                })]);
+              } catch (e) {
+                // No first message in time: release the reader and tear down the ws
+                // so we surface the timeout instead of leaking an open connection.
+                signalReader.releaseLock();
+                reject(e);
+                this.close();
+                return;
+              } finally {
+                clearTimeout(firstMessageTimeout);
+              }
               signalReader.releaseLock();
               if (!firstMessage.value) {
                 throw ConnectionError.internal('no message received as first message');
@@ -17239,67 +17601,26 @@ 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;
-  }
-  push(item) {
-    this.buffer.push(item);
-    this._totalSize += item.data.byteLength;
+}class TTLMap {
+  /**
+   * @param ttl ttl of the key (ms)
+   */
+  constructor(ttl) {
+    this._map = new Map();
+    this._lastCleanup = 0;
+    this.ttl = ttl;
   }
-  pop() {
-    const item = this.buffer.shift();
-    if (item) {
-      this._totalSize -= item.data.byteLength;
+  set(key, value) {
+    const now = Date.now();
+    if (now - this._lastCleanup > this.ttl / 2) {
+      this.cleanup();
     }
-    return item;
-  }
-  getAll() {
-    return this.buffer.slice();
-  }
-  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];
-      if (this._totalSize - 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;
+    const expiresAt = now + this.ttl;
+    this._map.set(key, {
+      value,
+      expiresAt
+    });
+    return this;
   }
   get(key) {
     const entry = this._map.get(key);
@@ -18056,13 +18377,20 @@ function requireLib() {
   lib.parseImageAttributes = parser.parseImageAttributes;
   lib.parseSimulcastStreamList = parser.parseSimulcastStreamList;
   return lib;
-}var libExports = requireLib();/* The svc codec (av1/vp9) would use a very low bitrate at the begining and
-increase slowly by the bandwidth estimator until it reach the target bitrate. The
-process commonly cost more than 10 seconds cause subscriber will get blur video at
-the first few seconds. So we use a 70% of target bitrate here as the start bitrate to
-eliminate this issue.
-*/
-const startBitrateForSVC = 0.7;
+}var libExports = requireLib();/*
+ * Video codecs use a very low bitrate at the beginning and increase slowly by
+ * the bandwidth estimator until they reach the target bitrate. The process commonly
+ * costs more than 10 seconds causing subscribers to get blurry video at the first
+ * few seconds. We use x-google-start-bitrate to hint the BWE to start higher.
+ *
+ * Why 90%: Gives ~10% headroom for bandwidth estimation while starting close to target.
+ * Why same for all codecs: Target bitrate already accounts for codec efficiency
+ * (e.g., users set lower targets for VP9/AV1 knowing they're more efficient).
+ * Why cap at 1 Mbps: Prevents BWE from starting too aggressively on high bitrate tracks.
+ */
+const startBitrateMultiplier = 0.9;
+/** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
+const maxStartBitrateKbps = 1000;
 const debounceInterval = 20;
 const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
@@ -18087,6 +18415,7 @@ class PCTransport extends eventsExports.EventEmitter {
     var _a;
     super();
     this.log = livekitLogger;
+    this.iceLog = livekitLogger;
     this.ddExtID = 0;
     this.latestOfferId = 0;
     this.latestAcknowledgedOfferId = 0;
@@ -18113,6 +18442,7 @@ class PCTransport extends eventsExports.EventEmitter {
       if (!this._pc) {
         return;
       }
+      this.log.debug('closing peer connection');
       this.pendingInitialOffer = undefined;
       this._pc.close();
       this._pc.onconnectionstatechange = null;
@@ -18128,8 +18458,9 @@ class PCTransport extends eventsExports.EventEmitter {
       this._pc.oniceconnectionstatechange = null;
       this._pc = null;
     };
-    this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.PCTransport);
     this.loggerOptions = loggerOptions;
+    this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.PCTransport, () => this.logContext);
+    this.iceLog = getLogger(LoggerNames.ICE, () => this.logContext);
     this.config = config;
     this._pc = this.createPC();
     this.offerLock = new _();
@@ -18139,26 +18470,39 @@ class PCTransport extends eventsExports.EventEmitter {
     pc.onicecandidate = ev => {
       var _a;
       if (!ev.candidate) return;
+      this.iceLog.debug('local ICE candidate gathered', {
+        candidate: ev.candidate.candidate
+      });
       (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, ev.candidate);
     };
     pc.onicecandidateerror = ev => {
       var _a;
+      this.iceLog.debug('ICE candidate error', {
+        event: ev
+      });
       (_a = this.onIceCandidateError) === null || _a === void 0 ? void 0 : _a.call(this, ev);
     };
     pc.oniceconnectionstatechange = () => {
       var _a;
+      this.iceLog.debug("ICE connection state: ".concat(pc.iceConnectionState));
       (_a = this.onIceConnectionStateChange) === null || _a === void 0 ? void 0 : _a.call(this, pc.iceConnectionState);
     };
     pc.onsignalingstatechange = () => {
       var _a;
+      this.log.debug("signaling state: ".concat(pc.signalingState));
       (_a = this.onSignalingStatechange) === null || _a === void 0 ? void 0 : _a.call(this, pc.signalingState);
     };
     pc.onconnectionstatechange = () => {
       var _a;
+      this.log.debug("connection state: ".concat(pc.connectionState));
       (_a = this.onConnectionStateChange) === null || _a === void 0 ? void 0 : _a.call(this, pc.connectionState);
     };
     pc.ondatachannel = ev => {
       var _a;
+      this.log.debug('data channel opened by peer', {
+        label: ev.channel.label,
+        id: ev.channel.id
+      });
       (_a = this.onDataChannel) === null || _a === void 0 ? void 0 : _a.call(this, ev);
     };
     pc.ontrack = ev => {
@@ -18179,6 +18523,9 @@ class PCTransport extends eventsExports.EventEmitter {
       if (this.pc.remoteDescription && !this.restartingIce) {
         return this.pc.addIceCandidate(candidate);
       }
+      this.iceLog.debug('queuing remote ICE candidate until remote description applied', {
+        pendingCount: this.pendingCandidates.length + 1
+      });
       this.pendingCandidates.push(candidate);
     });
   }
@@ -18186,10 +18533,10 @@ class PCTransport extends eventsExports.EventEmitter {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b;
       if (sd.type === 'answer' && this.latestOfferId > 0 && offerId > 0 && offerId !== this.latestOfferId) {
-        this.log.warn('ignoring answer for old offer', Object.assign(Object.assign({}, this.logContext), {
+        this.log.warn('ignoring answer for old offer', {
           offerId,
           latestOfferId: this.latestOfferId
-        }));
+        });
         return false;
       }
       let mungedSDP = undefined;
@@ -18207,7 +18554,7 @@ class PCTransport extends eventsExports.EventEmitter {
           sdpParsed.media.forEach(media => {
             ensureIPAddrMatchVersion(media);
           });
-          this.log.debug('setting pending initial offer before processing answer', this.logContext);
+          this.log.debug('setting pending initial offer before processing answer');
           yield this.setMungedSDP(initialOffer, libExports.write(sdpParsed));
         }
         const sdpParsed = libExports.parse((_b = sd.sdp) !== null && _b !== void 0 ? _b : '');
@@ -18265,6 +18612,11 @@ class PCTransport extends eventsExports.EventEmitter {
         mungedSDP = libExports.write(sdpParsed);
       }
       yield this.setMungedSDP(sd, mungedSDP, true);
+      if (this.pendingCandidates.length > 0) {
+        this.iceLog.debug('flushing queued ICE candidates', {
+          count: this.pendingCandidates.length
+        });
+      }
       this.pendingCandidates.forEach(candidate => {
         this.pc.addIceCandidate(candidate);
       });
@@ -18300,7 +18652,7 @@ class PCTransport extends eventsExports.EventEmitter {
       const unlock = yield this.offerLock.lock();
       try {
         if (this.pc.signalingState !== 'stable') {
-          this.log.warn('signaling state is not stable, cannot create initial offer', this.logContext);
+          this.log.warn('signaling state is not stable, cannot create initial offer');
           return;
         }
         const offerId = this.latestOfferId + 1;
@@ -18333,7 +18685,7 @@ class PCTransport extends eventsExports.EventEmitter {
           return;
         }
         if (options === null || options === void 0 ? void 0 : options.iceRestart) {
-          this.log.debug('restarting ICE', this.logContext);
+          this.iceLog.debug('restarting ICE');
           this.restartingIce = true;
         }
         if (this._pc && (this._pc.signalingState === 'have-local-offer' || this.pendingInitialOffer)) {
@@ -18346,22 +18698,22 @@ class PCTransport extends eventsExports.EventEmitter {
             yield this._pc.setRemoteDescription(currentSD);
           } else {
             this.renegotiate = true;
-            this.log.debug('requesting renegotiation', Object.assign({}, this.logContext));
+            this.log.debug('requesting renegotiation');
             return;
           }
         } else if (!this._pc || this._pc.signalingState === 'closed') {
-          this.log.warn('could not createOffer with closed peer connection', this.logContext);
+          this.log.warn('could not createOffer with closed peer connection');
           return;
         }
         // actually negotiate
-        this.log.debug('starting to negotiate', this.logContext);
+        this.log.debug('starting to negotiate');
         // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
         const offerId = this.latestOfferId + 1;
         this.latestOfferId = offerId;
         const offer = yield this.pc.createOffer(options);
-        this.log.debug('original offer', Object.assign({
+        this.log.debug('original offer', {
           sdp: offer.sdp
-        }, this.logContext));
+        });
         const sdpParsed = libExports.parse((_a = offer.sdp) !== null && _a !== void 0 ? _a : '');
         sdpParsed.media.forEach(media => {
           ensureIPAddrMatchVersion(media);
@@ -18387,12 +18739,15 @@ class PCTransport extends eventsExports.EventEmitter {
                 this.ensureVideoDDExtensionForSVC(media, sdpParsed);
               }
               // mung sdp for bitrate setting that can't apply by sendEncoding
-              if (!isSVCCodec(trackbr.codec)) {
-                return true;
-              }
-              const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
+              // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE from starting too aggressively
+              // Screen share is not capped since text/UI clarity requires high bitrate from the start
+              // TODO: dynamically adjust start bitrate based on network conditions (e.g., use previous BWE estimate)
+              const calculatedStartBitrate = Math.round(trackbr.maxbr * startBitrateMultiplier);
+              const startBitrate = trackbr.isScreenShare ? calculatedStartBitrate : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
+              let fmtpFound = false;
               for (const fmtp of media.fmtp) {
                 if (fmtp.payload === codecPayload) {
+                  fmtpFound = true;
                   // if another track's fmtp already is set, we cannot override the bitrate
                   // this has the unfortunate consequence of being forced to use the
                   // initial track's bitrate for all tracks
@@ -18402,6 +18757,13 @@ class PCTransport extends eventsExports.EventEmitter {
                   break;
                 }
               }
+              // VP8 and some codecs may not have an existing fmtp line - create one
+              if (!fmtpFound) {
+                media.fmtp.push({
+                  payload: codecPayload,
+                  config: "x-google-start-bitrate=".concat(startBitrate)
+                });
+              }
               return true;
             });
           }
@@ -18416,10 +18778,10 @@ class PCTransport extends eventsExports.EventEmitter {
           conformBundledCodecFmtp(sdpParsed.media, media => placeholderMids.has(getMidString(media.mid)));
         }
         if (this.latestOfferId > offerId) {
-          this.log.warn('latestOfferId mismatch', Object.assign(Object.assign({}, this.logContext), {
+          this.log.warn('latestOfferId mismatch', {
             latestOfferId: this.latestOfferId,
             offerId
-          }));
+          });
           return;
         }
         yield this.setMungedSDP(offer, libExports.write(sdpParsed));
@@ -18567,7 +18929,7 @@ class PCTransport extends eventsExports.EventEmitter {
       if (munged) {
         sd.sdp = munged;
         try {
-          this.log.debug("setting munged ".concat(remote ? 'remote' : 'local', " description"), this.logContext);
+          this.log.debug("setting munged ".concat(remote ? 'remote' : 'local', " description"));
           if (remote) {
             yield this.pc.setRemoteDescription(sd);
           } else {
@@ -18575,11 +18937,11 @@ class PCTransport extends eventsExports.EventEmitter {
           }
           return;
         } catch (e) {
-          this.log.warn("not able to set ".concat(sd.type, ", falling back to unmodified sdp"), Object.assign(Object.assign({}, this.logContext), {
+          this.log.warn("not able to set ".concat(sd.type, ", falling back to unmodified sdp"), {
             error: e,
             mungedSdp: munged,
             originalSdp
-          }));
+          });
           sd.sdp = originalSdp;
         }
       }
@@ -18606,9 +18968,9 @@ class PCTransport extends eventsExports.EventEmitter {
         if (!remote && this.pc.remoteDescription) {
           fields.remoteSdp = this.pc.remoteDescription;
         }
-        this.log.error("unable to set ".concat(sd.type), Object.assign(Object.assign({}, this.logContext), {
+        this.log.error("unable to set ".concat(sd.type), {
           fields
-        }));
+        });
         throw new NegotiationError(msg);
       }
     });
@@ -18869,6 +19231,7 @@ class PCTransportManager {
     var _a;
     this.peerConnectionTimeout = roomConnectOptionDefaults.peerConnectionTimeout;
     this.log = livekitLogger;
+    this.iceLog = livekitLogger;
     this.updateState = () => {
       var _a, _b;
       const previousState = this.state;
@@ -18887,12 +19250,13 @@ class PCTransportManager {
         this.state = PCTransportState.NEW;
       }
       if (previousState !== this.state) {
-        this.log.debug("pc state change: from ".concat(PCTransportState[previousState], " to ").concat(PCTransportState[this.state]), this.logContext);
+        this.log.debug("pc state change: from ".concat(PCTransportState[previousState], " to ").concat(PCTransportState[this.state]));
         (_a = this.onStateChange) === null || _a === void 0 ? void 0 : _a.call(this, this.state, this.publisher.getConnectionState(), (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.getConnectionState());
       }
     };
-    this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.PCManager);
     this.loggerOptions = loggerOptions;
+    this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.PCManager, () => this.logContext);
+    this.iceLog = getLogger(LoggerNames.ICE, () => this.logContext);
     this.isPublisherConnectionRequired = mode !== 'subscriber-primary';
     this.isSubscriberConnectionRequired = mode === 'subscriber-primary';
     this.publisher = new PCTransport(rtcConfig, loggerOptions);
@@ -18965,9 +19329,9 @@ class PCTransportManager {
               publisher.removeTrack(sender);
             }
           } catch (e) {
-            this.log.warn('could not removeTrack', Object.assign(Object.assign({}, this.logContext), {
+            this.log.warn('could not removeTrack', {
               error: e
-            }));
+            });
           }
         }
       }
@@ -18977,6 +19341,7 @@ class PCTransportManager {
   }
   triggerIceRestart() {
     return __awaiter(this, void 0, void 0, function* () {
+      this.iceLog.warn('triggering ICE restart');
       if (this.subscriber) {
         this.subscriber.restartingIce = true;
       }
@@ -18991,6 +19356,10 @@ class PCTransportManager {
   addIceCandidate(candidate, target) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
+      this.iceLog.debug('adding remote ICE candidate', {
+        target,
+        candidate
+      });
       if (target === SignalTarget.PUBLISHER) {
         yield this.publisher.addIceCandidate(candidate);
       } else {
@@ -19001,11 +19370,11 @@ class PCTransportManager {
   createSubscriberAnswerFromOffer(sd, offerId) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b, _c;
-      this.log.debug('received server offer', Object.assign(Object.assign({}, this.logContext), {
+      this.log.debug('received server offer', {
         RTCSdpType: sd.type,
         sdp: sd.sdp,
         signalingState: (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.getSignallingState().toString()
-      }));
+      });
       const unlock = yield this.remoteOfferLock.lock();
       try {
         const success = yield (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.setRemoteDescription(sd, offerId);
@@ -19022,6 +19391,9 @@ class PCTransportManager {
   }
   updateConfiguration(config, iceRestart) {
     var _a;
+    this.log.debug('updating rtc configuration', {
+      iceRestart
+    });
     this.publisher.setConfiguration(config);
     (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.setConfiguration(config);
     if (iceRestart) {
@@ -19034,7 +19406,7 @@ class PCTransportManager {
       const unlock = yield this.connectionLock.lock();
       try {
         if (this.isPublisherConnectionRequired && this.publisher.getConnectionState() !== 'connected' && this.publisher.getConnectionState() !== 'connecting') {
-          this.log.debug('negotiation required, start negotiating', this.logContext);
+          this.log.debug('negotiation required, start negotiating');
           this.publisher.negotiate();
         }
         yield Promise.all((_a = this.requiredTransports) === null || _a === void 0 ? void 0 : _a.map(transport => this.ensureTransportConnected(transport, abortController, timeout)));
@@ -19148,7 +19520,7 @@ class PCTransportManager {
         }
         return new Promise((resolve, reject) => __awaiter(_this, void 0, void 0, function* () {
           const abortHandler = () => {
-            this.log.warn('abort transport connection', this.logContext);
+            this.log.warn('abort transport connection');
             CriticalTimers.clearTimeout(connectTimeout);
             reject(ConnectionError.cancelled('room connection has been cancelled'));
           };
@@ -19174,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
@@ -19984,6 +21013,18 @@ class LocalTrack extends Track {
       yield this.restart(constraints);
     });
   }
+  applyConstraints(constraints) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.trackChangeLock.lock();
+      try {
+        const res = yield this._mediaStreamTrack.applyConstraints(constraints);
+        this._constraints = Object.assign(Object.assign({}, this._constraints), constraints);
+        return res;
+      } finally {
+        unlock();
+      }
+    });
+  }
   restart(constraints, isUnmuting) {
     const _super = Object.create(null, {
       restart: {
@@ -20420,14 +21461,21 @@ class ScalabilityMode {
     return "L".concat(this.spatial, "T").concat(this.temporal).concat((_a = this.suffix) !== null && _a !== void 0 ? _a : '');
   }
 }
+/**
+ * Returns the appropriate degradation preference for a video track based on its source.
+ *
+ * - Camera: 'maintain-framerate' (smoother video for real-time communication)
+ * - Screen share: 'maintain-resolution' (clarity is critical for reading text/UI)
+ * - Other/unknown: 'balanced'
+ */
 function getDefaultDegradationPreference(track) {
-  // a few of reasons we have different default paths:
-  // 1. without this, Chrome seems to aggressively resize the SVC video stating `quality-limitation: bandwidth` even when BW isn't an issue
-  // 2. since we are overriding contentHint to motion (to workaround L1T3 publishing), it overrides the default degradationPreference to `balanced`
-  if (track.source === Track.Source.ScreenShare || track.constraints.height && unwrapConstraint(track.constraints.height) >= 1080) {
-    return 'maintain-resolution';
-  } else {
-    return 'balanced';
+  switch (track.source) {
+    case Track.Source.Camera:
+      return 'maintain-framerate';
+    case Track.Source.ScreenShare:
+      return 'maintain-resolution';
+    default:
+      return 'balanced';
   }
 }const refreshSubscribedCodecAfterNewCodec = 5000;
 class LocalVideoTrack extends LocalTrack {
@@ -21189,14 +22237,9 @@ function videoLayersFromEncodings(width, height, encodings, svc) {
       ssrc: 0
     });
   });
-}const lossyDataChannel = '_lossy';
-const reliableDataChannel = '_reliable';
-const dataTrackDataChannel = '_data_track';
-const minReconnectWait = 2 * 1000;
+}const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
 const reliabeReceiveStateTTL = 30000;
-const lossyDataChannelBufferThresholdMin = 8 * 1024;
-const lossyDataChannelBufferThresholdMax = 256 * 1024;
 const initialMediaSectionsAudio = 3;
 const initialMediaSectionsVideo = 3;
 var PCState;
@@ -21207,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".
@@ -21228,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();
@@ -21254,16 +22300,10 @@ 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;
-    this.bufferStatusLowClosingFuture = new Future();
     this.handleDataChannel = _a => __awaiter(this, [_a], void 0, function (_ref) {
       var _this = this;
       let channel = _ref.channel;
@@ -21271,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* () {
@@ -21293,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) {
@@ -21346,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
@@ -21392,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
@@ -21450,25 +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);
-        }
-      }
-      const status = this.isBufferStatusLow(kind);
-      if (typeof status !== 'undefined' && status !== this.dcBufferStatus.get(kind)) {
-        this.dcBufferStatus.set(kind, status);
-        this.emit(EngineEvent.DCBufferStatusChanged, status, kind);
-      }
-    };
-    this.isBufferStatusLow = kind => {
-      const dc = this.dataChannelForKind(kind);
-      if (dc) {
-        return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
-      }
-    };
     this.onRtpMapAvailable = rtpTypes => {
       const rtpMap = new Map();
       rtpTypes.forEach(rtp => {
@@ -21528,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);
@@ -21539,13 +22537,6 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.client.onRequestResponse = response => this.emit(EngineEvent.SignalRequestResponse, response);
     this.client.onParticipantUpdate = updates => this.emit(EngineEvent.ParticipantUpdate, updates);
     this.client.onJoined = joinResponse => this.emit(EngineEvent.Joined, joinResponse);
-    this.on(EngineEvent.Closing, () => {
-      var _a, _b;
-      (_b = (_a = this.bufferStatusLowClosingFuture).reject) === null || _b === void 0 ? void 0 : _b.call(_a, new UnexpectedConnectionState('engine closed'));
-    });
-    // Swallow the rejection at the source so it doesn't surface as an unhandled promise rejection
-    // when no waitForBufferStatusLow callers are attached.
-    this.bufferStatusLowClosingFuture.promise.catch(() => {});
   }
   /** @internal */
   get logContext() {
@@ -21691,51 +22682,14 @@ class RTCEngine extends eventsExports.EventEmitter {
   cleanupPeerConnections() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      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* () {
@@ -21802,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* () {
@@ -22062,65 +23016,22 @@ class RTCEngine extends eventsExports.EventEmitter {
     if (!this.pcManager) {
       return;
     }
-    // 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, set to 64kB (otherwise 0 by default)
-    this.lossyDC.bufferedAmountLowThreshold = 65535;
-    this.reliableDC.bufferedAmountLowThreshold = 65535;
-    this.dataTrackDC.bufferedAmountLowThreshold = 65535;
-    // 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, lossyDataChannelBufferThresholdMin), lossyDataChannelBufferThresholdMax);
+    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* () {
@@ -22372,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');
@@ -22426,11 +23336,16 @@ 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) {
-        this.resendReliableMessagesForResume(res.lastMessageSeq);
+        this.resendReliableMessagesForResume(res.lastMessageSeq).catch(error => {
+          this.log.warn('failed to resend reliable messages after resume', Object.assign(Object.assign({}, this.logContext), {
+            error
+          }));
+        });
       }
       // resume success
       this.emit(EngineEvent.Resumed);
@@ -22479,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
@@ -22499,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)
@@ -22510,98 +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:
-          const dc = this.dataChannelForKind(kind);
-          if (dc) {
-            yield this.waitForBufferStatusLow(kind);
-            this.reliableMessageBuffer.push({
-              data: msg,
-              sequence: packet.sequence
-            });
-            if (this.attemptingReconnect) {
-              return;
-            }
-            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 bufferStatusLowBehavior = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'drop';
-      return function* () {
-        // make sure we do have a data connection
-        yield _this3.ensurePublisherConnected(kind);
-        const dc = _this3.dataChannelForKind(kind);
-        if (dc) {
-          if (!_this3.isBufferStatusLow(kind)) {
-            // Depending on the exact circumstance that data is being sent, either drop or wait for the
-            // buffer status to not be low before continuing.
-            switch (bufferStatusLowBehavior) {
-              case 'wait':
-                yield _this3.waitForBufferStatusLow(kind);
-                break;
-              case 'drop':
-                // this.log.warn(`dropping lossy data channel message`, this.logContext);
-                // 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;
-            }
-          }
-          _this3.lossyDataStatCurrentBytes += bytes.byteLength;
-          if (_this3.attemptingReconnect) {
-            return;
-          }
-          dc.send(bytes);
-        }
-        _this3.updateAndEmitDCBufferStatus(kind);
-      }();
+  /**
+   * 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);
-        this.reliableMessageBuffer.getAll().forEach(msg => {
-          dc.send(msg.data);
-        });
-      }
-      this.updateAndEmitDCBufferStatus(DataChannelKind.RELIABLE);
+      yield this.reliableChannel.replay(lastMessageSeq);
     });
   }
-  waitForBufferStatusLow(kind) {
+  /** The flow-control gate for `kind` — see {@link FlowControlledDataChannel}. */
+  flowControlFor(kind) {
+    return this.dataChannels.channelFor(kind);
+  }
+  /**
+   * Resolves once the caller may send on the `kind` channel — see
+   * {@link FlowControlledDataChannel.waitForHeadroomWithLock}.
+   */
+  waitForBufferHeadroom(kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      return new TypedPromise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-        if (this.isClosed) {
-          reject(new UnexpectedConnectionState('engine closed'));
-        }
-        if (this.isBufferStatusLow(kind)) {
-          resolve();
-        } else {
-          const dc = this.dataChannelForKind(kind);
-          if (!dc) {
-            reject(new UnexpectedConnectionState("DataChannel not found, kind: ".concat(kind)));
-            return;
-          }
-          this.bufferStatusLowClosingFuture.promise.catch(e => reject(e));
-          dc.addEventListener('bufferedamountlow', () => resolve(), {
-            once: true
-          });
-        }
-      }));
+      return this.flowControlFor(kind).waitForHeadroomWithLock();
     });
   }
   /**
@@ -22609,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);
@@ -22685,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();
@@ -22729,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) {
@@ -22883,7 +23729,8 @@ function applyUserDataCompat(newObj, oldObj) {
   const destinationIdentities = newObj.destinationIdentities.length !== 0 ? newObj.destinationIdentities : oldObj.destinationIdentities;
   newObj.destinationIdentities = destinationIdentities;
   oldObj.destinationIdentities = destinationIdentities;
-}const DEFAULT_MAX_AGE_MS = 5000;
+}const log$4 = getLogger(LoggerNames.Region);
+const DEFAULT_MAX_AGE_MS = 5000;
 const STOP_REFETCH_DELAY_MS = 30000;
 class RegionUrlProvider {
   static fetchRegionSettings(serverUrl, token, signal) {
@@ -22937,10 +23784,10 @@ class RegionUrlProvider {
           RegionUrlProvider.updateCachedRegionSettings(url, token, newSettings);
         } catch (error) {
           if (error instanceof ConnectionError && error.reason === ConnectionErrorReason.NotAllowed) {
-            livekitLogger.debug('token is not valid, cancelling auto region refresh');
+            log$4.debug('token is not valid, cancelling auto region refresh');
             return;
           }
-          livekitLogger.debug('auto refetching of region settings failed', {
+          log$4.debug('auto refetching of region settings failed', {
             error
           });
           // continue retrying with the same max age
@@ -22973,7 +23820,7 @@ class RegionUrlProvider {
     tracker.cleanupTimeout = setTimeout(() => {
       const currentTracker = RegionUrlProvider.connectionTrackers.get(hostname);
       if (currentTracker && currentTracker.connectionCount === 0) {
-        livekitLogger.debug('stopping region refetch after disconnect delay', {
+        log$4.debug('stopping region refetch after disconnect delay', {
           hostname
         });
         RegionUrlProvider.stopRefetch(hostname);
@@ -23053,7 +23900,9 @@ class RegionUrlProvider {
       if (regionsLeft.length > 0) {
         const nextRegion = regionsLeft[0];
         this.attemptedRegions.push(nextRegion);
-        livekitLogger.debug("next region: ".concat(nextRegion.region));
+        log$4.info("switching to region: ".concat(nextRegion.region), {
+          region: nextRegion.region
+        });
         return nextRegion.url;
       } else {
         return null;
@@ -23073,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;
   }
@@ -23115,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) {
@@ -23135,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
@@ -23252,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;
@@ -23271,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
@@ -23349,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();
@@ -23356,6 +24297,7 @@ class TextStreamReader extends BaseStreamReader {
     this.textStreamHandlers = new Map();
     this.isConnected = false;
     this.bufferedPackets = [];
+    this.maxPayloadByteLength = maxPayloadByteLength;
   }
   setConnected(connected) {
     this.isConnected = connected;
@@ -23438,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;
           }
-          this.byteStreamControllers.set(streamHeader.streamId, {
-            info,
-            controller: streamController,
-            startTime: Date.now(),
-            sendingParticipantIdentity: participantIdentity
+          // Single-packet stream: the entire payload was packaged into the header's `inlineContent`.
+          // Synthesize an already-complete stream and skip waiting for chunk/trailer packets.
+          const inlineContent = streamHeader.inlineContent;
+          if (typeof inlineContent !== 'undefined') {
+            // Inline bytes are the raw payload, optionally deflate-raw compressed.
+            streamHandlerCallback(new ByteStreamReader(info, createInlineStream(streamHeader.streamId, compressed ? deflateRawDecompress(inlineContent, this.maxPayloadByteLength) : inlineContent), bigIntToNumber(streamHeader.totalLength)), {
+              identity: participantIdentity
+            });
+            return;
+          }
+          const stream = new ReadableStream({
+            start: controller => {
+              streamController = controller;
+              if (this.byteStreamControllers.has(streamHeader.streamId)) {
+                throw new DataStreamError("A data stream read is already in progress for a stream with id ".concat(streamHeader.streamId, "."), DataStreamErrorReason.AlreadyOpened);
+              }
+              this.byteStreamControllers.set(streamHeader.streamId, {
+                info,
+                controller: streamController,
+                startTime: Date.now(),
+                sendingParticipantIdentity: participantIdentity
+              });
+            }
           });
+          streamHandlerCallback(new ByteStreamReader(info, compressed ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          // `totalLength` is the pre-compression size, and the reader counts decompressed bytes,
+          // so it applies to both paths (mirrors text).
+          bigIntToNumber(streamHeader.totalLength)), {
+            identity: participantIdentity
+          });
+          return;
         }
-      });
-      streamHandlerCallback(new ByteStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)), {
-        identity: participantIdentity
-      });
-    } else if (streamHeader.contentHeader.case === 'textHeader') {
-      const streamHandlerCallback = this.textStreamHandlers.get(streamHeader.topic);
-      if (!streamHandlerCallback) {
-        this.log.debug('ignoring incoming text stream due to no handler for topic', streamHeader.topic);
-        return;
-      }
-      let streamController;
-      const info = {
-        id: streamHeader.streamId,
-        mimeType: streamHeader.mimeType,
-        size: streamHeader.totalLength ? Number(streamHeader.totalLength) : undefined,
-        topic: streamHeader.topic,
-        timestamp: Number(streamHeader.timestamp),
-        attributes: streamHeader.attributes,
-        encryptionType,
-        attachedStreamIds: streamHeader.contentHeader.value.attachedStreamIds
-      };
-      const stream = new ReadableStream({
-        start: controller => {
-          streamController = controller;
-          if (this.textStreamControllers.has(streamHeader.streamId)) {
-            throw new DataStreamError("A data stream read is already in progress for a stream with id ".concat(streamHeader.streamId, "."), DataStreamErrorReason.AlreadyOpened);
+      case 'textHeader':
+        {
+          const streamHandlerCallback = this.textStreamHandlers.get(streamHeader.topic);
+          if (!streamHandlerCallback) {
+            this.log.debug('ignoring incoming text stream due to no handler for topic', streamHeader.topic);
+            return;
           }
-          this.textStreamControllers.set(streamHeader.streamId, {
-            info,
-            controller: streamController,
-            startTime: Date.now(),
-            sendingParticipantIdentity: participantIdentity
+          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;
+          }
+          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) {
@@ -23535,21 +24553,190 @@ 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) {
+      if (fileBuffer.info.encryptionType !== encryptionType) {
+        fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
+      } else {
+        fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
+        if (trailer.reason) {
+          // A non-empty reason marks an abnormal close by the sender (e.g. an aborted send);
+          // surface it as an error rather than pretending the stream completed.
+          fileBuffer.controller.error(new DataStreamError("Data stream ".concat(trailer.streamId, " closed abnormally: ").concat(trailer.reason), DataStreamErrorReason.AbnormalEnd));
+        } else {
+          fileBuffer.controller.close();
+        }
+      }
+      this.byteStreamControllers.delete(trailer.streamId);
+    }
+  }
+}
+/**
+ * Builds a `ReadableStream` that yields the given content as a single chunk and then immediately
+ * closes - used to surface an inline (single-packet) data stream as a fully-formed stream. `content`
+ * may be a promise (e.g. async gzip decompression); a rejection errors the stream.
+ */
+function createInlineStream(streamId, content) {
+  return new ReadableStream({
+    start: controller => __awaiter(this, void 0, void 0, function* () {
+      try {
+        const bytes = yield content;
+        controller.enqueue(new DataStream_Chunk({
+          streamId,
+          chunkIndex: BigInt(0),
+          content: bytes
+        }));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    })
+  });
+}
+/**
+ * Validates that chunks are received in order, dropping duplicates and throwing if gaps are found.
+ *
+ * A stateful decompressor silently corrupts on duplicated or out-of-order input, so duplicates are
+ * dropped (with a warning - in-order delivery is expected on the reliable channel, but reconnect
+ * handling may replay) and a gap is a hard error. Shared by the text and byte deflate-raw decoders.
+ */
+function ensureOrderedChunks(streamId) {
+  let lastChunkIndex = -1;
+  return new TransformStream({
+    transform: (value, controller) => {
+      const index = bigIntToNumber(value.chunkIndex);
+      if (index <= lastChunkIndex) {
+        livekitLogger.warn("ignoring duplicate chunk ".concat(index, " for compressed data stream ").concat(streamId, " (last processed: ").concat(lastChunkIndex, ")"));
+        return;
+      }
+      if (index > lastChunkIndex + 1) {
+        throw new DataStreamError("Missing chunk(s) ".concat(lastChunkIndex + 1, "..").concat(index - 1, " for compressed data stream ").concat(streamId, " - cannot continue decompressing"), DataStreamErrorReason.Incomplete);
+      }
+      lastChunkIndex = index;
+      controller.enqueue(value);
+    }
+  });
+}
+/** Unwraps compressed `DataStream_Chunk`s to their compressed bytes (in `chunkIndex` order), */
+function chunksToBytes() {
+  return new TransformStream({
+    transform: (value, controller) => {
+      controller.enqueue(value.content);
+    }
+  });
+}
+/** Re-wraps decompressed bytes into contiguous `DataStream_Chunk`s, skipping inflate's empty reads. */
+function bytesToChunks(streamId) {
+  let outIndex = 0;
+  return new TransformStream({
+    transform: (value, controller) => {
+      // Inflate can emit empty reads; only synthesize a chunk when there is content.
+      if (value.byteLength > 0) {
+        controller.enqueue(new DataStream_Chunk({
+          streamId,
+          chunkIndex: numberToBigInt(outIndex),
+          content: value
+        }));
+        outIndex += 1;
+      }
+    }
+  });
+}
+/**
+ * Reframes decompressed byte chunks onto UTF-8 character boundaries via a streaming `TextDecoder`
+ * (a write larger than the MTU spans several packets, which may split a codepoint), so each
+ * synthesized text chunk decodes independently. The `flush` emits the decoder's trailing bytes.
+ */
+function bytesToDecodedUtf8(streamId) {
+  const decoder = new TextDecoder('utf-8', {
+    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;
       }
     }
-    const fileBuffer = this.byteStreamControllers.get(trailer.streamId);
-    if (fileBuffer) {
-      if (fileBuffer.info.encryptionType !== encryptionType) {
-        fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(trailer.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
-      } else {
-        fileBuffer.info.attributes = Object.assign(Object.assign({}, fileBuffer.info.attributes), trailer.attributes);
-        fileBuffer.controller.close();
+  });
+}
+/**
+ * Transforms a stream of deflate-raw-compressed byte `DataStream_Chunk`s into a stream of
+ * decompressed chunks, so `ByteStreamReader` consumes it unchanged. All chunk contents are fed (in
+ * `chunkIndex` order) through ONE raw-deflate decompressor for the stream's lifetime; decompressed
+ * output is re-wrapped as chunks as soon as it is produced. The sender (sendFile) compresses the
+ * whole payload in one shot, but the format also supports a single context-takeover stream
+ * sync-flushed at write boundaries, so a future incremental streamBytes could compress with no
+ * protocol change. Errors and cancellation propagate through the pipe chain.
+ */
+function inflateRawByteChunkStream(raw, streamId, maxPayloadByteLength) {
+  return raw.pipeThrough(ensureOrderedChunks(streamId)).pipeThrough(chunksToBytes()).pipeThrough(inflateRawTransform()).pipeThrough(maxDecompressedLengthGuard(streamId, maxPayloadByteLength)).pipeThrough(bytesToChunks(streamId));
+}
+/**
+ * Transforms a stream of deflate-raw-compressed text `DataStream_Chunk`s into a stream of
+ * decompressed chunks, so `TextStreamReader` consumes it unchanged. Builds on
+ * {@link inflateRawByteChunkStream} (single decompressor + ordering guard) and adds a streaming
+ * `TextDecoder` that reframes the decompressed bytes on UTF-8 character boundaries so each
+ * synthesized chunk decodes independently. Errors and cancellation propagate through the pipe chain.
+ */
+function inflateRawChunkStream(raw, streamId, maxPayloadByteLength) {
+  return raw.pipeThrough(ensureOrderedChunks(streamId)).pipeThrough(chunksToBytes()).pipeThrough(inflateRawTransform()).pipeThrough(maxDecompressedLengthGuard(streamId, maxPayloadByteLength)).pipeThrough(bytesToDecodedUtf8(streamId));
+}
+/**
+ * Caps the total decompressed byte count of a compressed stream (decompression-bomb guard): a
+ * tiny compressed payload can inflate to an arbitrarily large output, so the decompressor's
+ * output is bounded rather than trusting the wire size. Exceeding the cap errors the stream with
+ * `PayloadTooLarge`.
+ */
+function maxDecompressedLengthGuard(streamId, maxByteLength) {
+  let total = 0;
+  return new TransformStream({
+    transform: (value, controller) => {
+      total += value.byteLength;
+      if (total > maxByteLength) {
+        throw new DataStreamError("Data stream ".concat(streamId, " exceeds the maximum payload size of ").concat(maxByteLength, " bytes"), DataStreamErrorReason.PayloadTooLarge);
       }
-      this.byteStreamControllers.delete(trailer.streamId);
+      controller.enqueue(value);
     }
-  }
+  });
 }class BaseStreamWriter {
   constructor(writableStream, info, onClose) {
     this.writableStream = writableStream;
@@ -23570,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;
@@ -23586,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);
     });
   }
   /**
@@ -23631,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',
@@ -23641,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,
@@ -23693,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) {
@@ -23714,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;
@@ -23728,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) {
@@ -23768,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* () {
@@ -23801,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: {
@@ -23824,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) {
@@ -23845,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.
@@ -24829,6 +26336,9 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
     let bufferSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : READABLE_STREAM_DEFAULT_BUFFER_SIZE;
     let streamController = null;
     const sfuSubscriptionComplete = new Future();
+    // Hold the descriptor by reference: SID reassignment re-keys the map, so lookups
+    // with the SID captured at subscribe time would fail.
+    const descriptor = this.descriptors.get(sid);
     const detachSignal = () => {
       signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
     };
@@ -24838,8 +26348,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
         log$1.warn("ReadableStream subscribed to ".concat(sid, " was not started."));
         return;
       }
-      const descriptor = this.descriptors.get(sid);
-      if (!descriptor) {
+      if (!descriptor || this.descriptors.get(descriptor.info.sid) !== descriptor) {
         log$1.warn("Unknown track ".concat(sid, ", skipping cancel..."));
         return;
       }
@@ -24858,9 +26367,8 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
       if (!streamController) {
         return;
       }
-      const currentDescriptor = this.descriptors.get(sid);
-      if ((currentDescriptor === null || currentDescriptor === void 0 ? void 0 : currentDescriptor.subscription.type) === 'active') {
-        currentDescriptor.subscription.streamControllers.delete(streamController);
+      if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.subscription.type) === 'active') {
+        descriptor.subscription.streamControllers.delete(streamController);
       }
       streamController.error(DataTrackSubscribeError.cancelled());
       (_a = sfuSubscriptionComplete.reject) === null || _a === void 0 ? void 0 : _a.call(sfuSubscriptionComplete, DataTrackSubscribeError.cancelled());
@@ -24871,8 +26379,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
         streamController = controller;
         this.subscribeRequest(sid, signal).then(() => __awaiter(this, void 0, void 0, function* () {
           var _a, _b, _c;
-          const descriptor = this.descriptors.get(sid);
-          if (!descriptor) {
+          if (!descriptor || this.descriptors.get(descriptor.info.sid) !== descriptor) {
             log$1.error("Unknown track ".concat(sid));
             const err = DataTrackSubscribeError.disconnected();
             controller.error(err);
@@ -24987,7 +26494,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
                 };
                 // Let the SFU know that the subscribe has been cancelled
                 this.emit('sfuUpdateSubscription', {
-                  sid,
+                  sid: descriptor.info.sid,
                   subscribe: false
                 });
                 if (previousDescriptorSubscription.type === 'pending') {
@@ -25101,6 +26608,9 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
           if (this.descriptors.has(info.sid)) {
             continue;
           }
+          if (this.handleSidReassigned(publisherIdentity, info)) {
+            continue;
+          }
           yield this.handleTrackPublished(publisherIdentity, info);
         }
         publisherParticipantToSidsInUpdate.set(publisherIdentity, sidsInUpdate);
@@ -25158,6 +26668,62 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
       });
     });
   }
+  /**
+   * Detects and handles SID reassignment, which occurs when the publisher
+   * republishes its tracks after a full reconnect.
+   *
+   * Returns `true` if an SID reassignment occurred, `false` otherwise.
+   */
+  handleSidReassigned(publisherIdentity, info) {
+    // Publisher identity and pub handle are stable across republications.
+    const existingEntry = Array.from(this.descriptors.entries()).find(_ref1 => {
+      let _ref10 = _slicedToArray(_ref1, 2);
+        _ref10[0];
+        let descriptor = _ref10[1];
+      return descriptor.publisherIdentity === publisherIdentity && descriptor.info.pubHandle === info.pubHandle;
+    });
+    if (!existingEntry) {
+      return false;
+    }
+    const _existingEntry = _slicedToArray(existingEntry, 2),
+      oldSid = _existingEntry[0],
+      descriptor = _existingEntry[1];
+    // Invariant: other than SID, info should not have changed.
+    // TODO: consider refactoring to move SID out of info to allow for direct comparison.
+    const _descriptor$info = descriptor.info,
+      name = _descriptor$info.name,
+      usesE2ee = _descriptor$info.usesE2ee;
+    if (name !== info.name || usesE2ee !== info.usesE2ee) {
+      log$1.warn("Info mismatch for ".concat(oldSid, ", treating as new publication"));
+      return false;
+    }
+    const newSid = info.sid;
+    log$1.debug("SID reassigned: ".concat(oldSid, " -> ").concat(newSid));
+    if (!this.descriptors.delete(oldSid)) {
+      return false;
+    }
+    descriptor.info.sid = newSid;
+    switch (descriptor.subscription.type) {
+      case 'none':
+        break;
+      case 'pending':
+      case 'active':
+        // The SFU does not carry subscriptions across a publisher's full
+        // reconnect; re-request the subscription under the new SID.
+        this.emit('sfuUpdateSubscription', {
+          sid: newSid,
+          subscribe: true
+        });
+        break;
+    }
+    if (descriptor.subscription.type === 'active') {
+      // Keep the routing index consistent until the SFU assigns a new handle
+      // (see `registerSubscriberHandle`).
+      this.subscriptionHandles.set(descriptor.subscription.subcriptionHandle, newSid);
+    }
+    this.descriptors.set(newSid, descriptor);
+    return true;
+  }
   handleTrackUnpublished(sid) {
     const descriptor = this.descriptors.get(sid);
     if (!descriptor) {
@@ -25179,10 +26745,10 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
   /** Mapping between track handles attached to incoming packets to the
    * track SIDs they belong to. */
   mapping) {
-    for (const _ref1 of mapping.entries()) {
-      var _ref10 = _slicedToArray(_ref1, 2);
-      const handle = _ref10[0];
-      const sid = _ref10[1];
+    for (const _ref11 of mapping.entries()) {
+      var _ref12 = _slicedToArray(_ref11, 2);
+      const handle = _ref12[0];
+      const sid = _ref12[1];
       this.registerSubscriberHandle(handle, sid);
     }
   }
@@ -25203,12 +26769,17 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
       case 'active':
         {
           // Update handle for an active subscription. This can occur following a full reconnect.
+          this.subscriptionHandles.delete(descriptor.subscription.subcriptionHandle);
           descriptor.subscription.subcriptionHandle = assignedHandle;
           this.subscriptionHandles.set(assignedHandle, sid);
           return;
         }
       case 'pending':
         {
+          log$1.debug("data track subscription activated", {
+            sid,
+            handle: assignedHandle
+          });
           const pipeline = new IncomingDataTrackPipeline({
             info: descriptor.info,
             publisherIdentity: descriptor.publisherIdentity,
@@ -25275,10 +26846,10 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
    * tracks are subscribed to locally.
    */
   resendSubscriptionUpdates() {
-    for (const _ref11 of this.descriptors) {
-      var _ref12 = _slicedToArray(_ref11, 2);
-      const sid = _ref12[0];
-      const descriptor = _ref12[1];
+    for (const _ref13 of this.descriptors) {
+      var _ref14 = _slicedToArray(_ref13, 2);
+      const sid = _ref14[0];
+      const descriptor = _ref14[1];
       if (descriptor.subscription.type === 'none') {
         continue;
       }
@@ -25944,10 +27515,16 @@ class OutgoingDataTrackManager extends eventsExports.EventEmitter {
         {
           if (result.type === 'ok') {
             const info = result.data;
+            log.debug("SFU accepted publish request for handle ".concat(handle), {
+              sid: info.sid
+            });
             const e2eeManager = info.usesE2ee ? this.e2eeManager : null;
             this.descriptors.set(info.pubHandle, Descriptor.active(info, e2eeManager));
             (_b = (_a = descriptor.completionFuture).resolve) === null || _b === void 0 ? void 0 : _b.call(_a);
           } else {
+            log.debug("SFU rejected publish request for handle ".concat(handle), {
+              error: result.error
+            });
             (_d = (_c = descriptor.completionFuture).reject) === null || _d === void 0 ? void 0 : _d.call(_c, result.error);
           }
           return;
@@ -26265,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: {
@@ -26275,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.
@@ -26550,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
@@ -27403,6 +28976,11 @@ class Participant extends eventsExports.EventEmitter {
     this.audioTrackPublications.forEach(track => isAudioTrack(track.track) && track.track.setAudioContext(ctx));
   }
   addTrackPublication(publication) {
+    this.log.debug("adding track publication", {
+      trackSid: publication.trackSid,
+      source: publication.source,
+      kind: publication.kind
+    });
     // forward publication driven events
     publication.on(TrackEvent.Muted, () => {
       this.emit(ParticipantEvent.TrackMuted, publication);
@@ -28447,7 +30025,7 @@ class Participant extends eventsExports.EventEmitter {
         throw new UnexpectedConnectionState('cannot publish track when not connected');
       }
       const negotiate = () => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if (!this.engine.pcManager) {
           throw new UnexpectedConnectionState('pcManager is not ready');
         }
@@ -28483,12 +30061,22 @@ class Participant extends eventsExports.EventEmitter {
                 maxbr: ((_b = encodings[0]) === null || _b === void 0 ? void 0 : _b.maxBitrate) ? encodings[0].maxBitrate / 1000 : 0
               });
             }
-          } else if (track.codec && isSVCCodec(track.codec) && ((_c = encodings[0]) === null || _c === void 0 ? void 0 : _c.maxBitrate)) {
-            this.engine.pcManager.publisher.setTrackCodecBitrate({
-              cid: req.cid,
-              codec: track.codec,
-              maxbr: encodings[0].maxBitrate / 1000
-            });
+          } else if (track.codec && isVideoCodec(track.codec)) {
+            // Apply start bitrate for all video codecs to prevent initial blurriness.
+            // - SVC codecs: use first encoding's bitrate (single stream with built-in layers)
+            // - Simulcast: sum all encoding bitrates (independent streams, BWE needs total)
+            const targetBitrate = isSVCCodec(track.codec) ? (_d = (_c = encodings[0]) === null || _c === void 0 ? void 0 : _c.maxBitrate) !== null && _d !== void 0 ? _d : 0 : encodings.reduce((sum, enc) => {
+              var _a;
+              return sum + ((_a = enc.maxBitrate) !== null && _a !== void 0 ? _a : 0);
+            }, 0);
+            if (targetBitrate > 0) {
+              this.engine.pcManager.publisher.setTrackCodecBitrate({
+                cid: req.cid,
+                codec: track.codec,
+                maxbr: targetBitrate / 1000,
+                isScreenShare: track.source === Track.Source.ScreenShare
+              });
+            }
           }
         }
         yield this.engine.negotiate();
@@ -29019,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.
@@ -29548,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), {
@@ -29561,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();
@@ -29571,6 +31172,7 @@ class DeferrableMap extends Map {
     }));
     this.volumeMap = new Map();
     this.clientProtocol = clientProtocol;
+    this.capabilities = capabilities;
   }
   addTrackPublication(publication) {
     super.addTrackPublication(publication);
@@ -29982,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
@@ -30206,7 +31807,13 @@ class Room extends eventsExports.EventEmitter {
       });
       try {
         yield Promise.all([this.acquireAudioContext(), ...elements.map(e => {
-          e.muted = false;
+          // when webAudioMix is enabled, attached elements are deliberately kept muted by
+          // RemoteAudioTrack.attach() and audio is routed through the web audio graph instead.
+          // unmuting them here would cause double playback on platforms where element.volume
+          // has no effect (e.g. iOS Safari)
+          if (!this.options.webAudioMix) {
+            e.muted = false;
+          }
           return e.play();
         })]);
         this.handleAudioPlaybackStarted();
@@ -30540,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);
     };
@@ -30616,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
     });
@@ -30653,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, () => {
@@ -30902,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) {
@@ -31736,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;
@@ -33355,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