livekit-client 2.20.1 → 2.20.2

package/dist/livekit-client.esm.mjs

@@ -8226,6 +8226,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 +8812,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 +8892,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 +9054,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 +11681,7 @@ function adapterFactory() {
     shimSafari: true
   };
   // Utils.
-  const logging = log$4;
+  const logging = log$5;
   const browserDetails = detectBrowser(window);
   const adapter = {
     browserDetails,
@@ -11881,7 +11883,7 @@ 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.20.2";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -11972,25 +11974,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';
   }
 }
@@ -13195,6 +13197,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 +13224,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 +13293,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 +13340,7 @@ class Track extends eventsExports.EventEmitter {
     }
   }
   stop() {
+    this.log.debug('stopping track');
     this.stopMonitor();
     this._mediaStreamTrack.stop();
   }
@@ -13353,12 +13361,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) {
@@ -16317,6 +16325,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 +16477,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 +16488,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 +16516,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');
@@ -17243,21 +17273,50 @@ function createJoinRequestConnectionParams(token, info, opts, publisherOffer) {
   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];
@@ -17271,7 +17330,12 @@ function createJoinRequestConnectionParams(token, info, opts, publisherOffer) {
   alignBufferedAmount(bufferedAmount) {
     while (this.buffer.length > 0) {
       const first = this.buffer[0];
-      if (this._totalSize - first.data.byteLength <= bufferedAmount) {
+      // 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();
@@ -18056,13 +18120,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 +18158,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 +18185,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 +18201,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 +18213,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 +18266,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 +18276,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 +18297,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 +18355,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 +18395,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 +18428,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 +18441,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 +18482,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 +18500,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 +18521,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 +18672,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 +18680,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 +18711,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 +18974,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 +18993,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 +19072,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 +19084,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 +19099,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 +19113,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 +19134,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 +19149,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 +19263,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'));
           };
@@ -19984,6 +20099,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 +20547,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 {
@@ -21195,8 +21329,16 @@ const dataTrackDataChannel = '_data_track';
 const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
 const reliabeReceiveStateTTL = 30000;
-const lossyDataChannelBufferThresholdMin = 8 * 1024;
-const lossyDataChannelBufferThresholdMax = 256 * 1024;
+// Two-watermark flow control for the reliable and data-track channels. Senders fill the buffer
+// freely up to the high-water mark; once it's exceeded they block until the browser's
+// `bufferedamountlow` event (which we arm at the low-water mark) signals the buffer has drained.
+// The gap between the marks keeps the SCTP send buffer saturated while we refill, so throughput
+// isn't starved, while the high-water mark bounds the buffer well below the level that would abort
+// the channel (see livekit/client-sdk-js#1995).
+const reliableDataChannelWaterMarkLow = 64 * 1024;
+const reliableDataChannelWaterMarkHigh = 1024 * 1024;
+const lossyDataChannelWaterMarkLow = 8 * 1024;
+const lossyDataChannelWaterMarkHigh = 256 * 1024;
 const initialMediaSectionsAudio = 3;
 const initialMediaSectionsVideo = 3;
 var PCState;
@@ -21263,7 +21405,6 @@ class RTCEngine extends eventsExports.EventEmitter {
     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;
@@ -21457,18 +21598,53 @@ class RTCEngine extends eventsExports.EventEmitter {
           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);
+      try {
+        const status = this.isBelowLowWaterMark(kind);
+        if (typeof status !== 'undefined' && status !== this.dcBufferStatus.get(kind)) {
+          this.dcBufferStatus.set(kind, status);
+          this.emit(EngineEvent.DCBufferStatusChanged, status, kind);
+        }
+      } catch (e) {
+        this.log.warn('could not update buffer status', {
+          error: e
+        });
       }
     };
-    this.isBufferStatusLow = kind => {
+    /**
+     * Whether the send buffer has room to accept more data (the send gate). Senders proceed while
+     * this is true and block once it goes false.
+     */
+    this.isBelowHighWaterMark = kind => {
       const dc = this.dataChannelForKind(kind);
-      if (dc) {
-        return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
+      if (!dc) {
+        throw new TypeError("Could not get data channel for kind ".concat(kind));
+      }
+      // because RTCDatachannel has no high water mark built in we read the statically defined versions as constants
+      const highMark = kind === DataChannelKind.RELIABLE ? reliableDataChannelWaterMarkHigh : lossyDataChannelWaterMarkHigh;
+      return dc.bufferedAmount <= highMark;
+    };
+    /**
+     * Whether the send buffer has drained to its low-water mark. Drives the public
+     * {@link EngineEvent.DCBufferStatusChanged} event.
+     */
+    this.isBelowLowWaterMark = kind => {
+      const dc = this.dataChannelForKind(kind);
+      if (!dc) {
+        throw new TypeError("Could not get data channel for kind ".concat(kind));
       }
+      // because RTCDatachannel has the threshold built in we can read it dynamically to account for changing thresholds over time
+      return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
     };
+    /** Per-kind lock serializing senders that have to wait for the buffer to drain. */
+    this.waitForBufferHeadroomLocks = new Map();
+    /**
+     * Per-kind AbortController that cancels parked headroom waiters whenever a kind's channel object
+     * stops being current (replaced by createDataChannels or torn down by cleanupPeerConnections). A
+     * waiter is parked on the channel object it captured at wait entry; if that object is abandoned
+     * its events may never fire again, so the abort is what rejects the waiter and releases the
+     * headroom lock instead of stranding every future sender behind it.
+     */
+    this.waiterAbortControllers = new Map();
     this.onRtpMapAvailable = rtpTypes => {
       const rtpMap = new Map();
       rtpTypes.forEach(rtp => {
@@ -21539,13 +21715,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,6 +21860,10 @@ class RTCEngine extends eventsExports.EventEmitter {
   cleanupPeerConnections() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
+      // Reject parked headroom waiters up front: closing the peer connection is allowed (per spec)
+      // to transition data channels to 'closed' without firing events, which would otherwise strand
+      // a waiter holding the headroom lock.
+      this.invalidateDataChannelWaiters('peer connections cleaned up');
       const dcCleanup = dc => {
         if (!dc) {
           return;
@@ -22062,6 +22235,10 @@ class RTCEngine extends eventsExports.EventEmitter {
     if (!this.pcManager) {
       return;
     }
+    // Waiters parked on the old channel objects would never see another event from them once they
+    // are replaced below — reject them so the headroom lock is released and queued senders
+    // re-check against the new channels.
+    this.invalidateDataChannelWaiters('data channels recreated');
     // clear old data channel callbacks if recreate
     if (this.lossyDC) {
       this.lossyDC.onmessage = null;
@@ -22102,10 +22279,10 @@ class RTCEngine extends eventsExports.EventEmitter {
     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;
+    // set up dc buffer threshold - if this is not set, it will default to 0
+    this.lossyDC.bufferedAmountLowThreshold = lossyDataChannelWaterMarkLow;
+    this.reliableDC.bufferedAmountLowThreshold = reliableDataChannelWaterMarkLow;
+    this.dataTrackDC.bufferedAmountLowThreshold = lossyDataChannelWaterMarkLow;
     // handle buffer amount low events
     this.lossyDC.onbufferedamountlow = () => this.handleBufferedAmountLow(DataChannelKind.LOSSY);
     this.reliableDC.onbufferedamountlow = () => this.handleBufferedAmountLow(DataChannelKind.RELIABLE);
@@ -22118,7 +22295,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       if (dc) {
         // control buffered latency to ~100ms
         const threshold = this.lossyDataStatByterate / 10;
-        dc.bufferedAmountLowThreshold = Math.min(Math.max(threshold, lossyDataChannelBufferThresholdMin), lossyDataChannelBufferThresholdMax);
+        dc.bufferedAmountLowThreshold = Math.min(Math.max(threshold, lossyDataChannelWaterMarkLow), lossyDataChannelWaterMarkHigh);
       }
     }, 1000);
   }
@@ -22430,7 +22607,11 @@ class RTCEngine extends eventsExports.EventEmitter {
         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);
@@ -22515,20 +22696,55 @@ class RTCEngine extends eventsExports.EventEmitter {
         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) {
+              // A reconnect is already underway — queue for the resume replay instead of parking on a
+              // channel that is being torn down. The send resolves; delivery is deferred to the replay.
+              this.reliableMessageBuffer.push({
+                data: msg,
+                sequence: packet.sequence,
+                sent: false
+              });
               return;
             }
-            dc.send(msg);
+            const dc = this.dataChannelForKind(kind);
+            if (dc) {
+              try {
+                yield this.waitForBufferHeadroomWithLock(kind);
+              } catch (error) {
+                if (this.isClosed) {
+                  // No replay is coming after an engine close — surface the failure.
+                  throw error;
+                }
+                // Transient teardown (the channel closed or was replaced while we waited): the
+                // reliable channel promises delivery across resume, so queue the packet for the
+                // replay instead of rejecting a send the app can't meaningfully retry.
+                this.reliableMessageBuffer.push({
+                  data: msg,
+                  sequence: packet.sequence,
+                  sent: false
+                });
+                return;
+              }
+              if (this.attemptingReconnect) {
+                // A reconnect began while we waited for headroom — same deal as above.
+                this.reliableMessageBuffer.push({
+                  data: msg,
+                  sequence: packet.sequence,
+                  sent: false
+                });
+                return;
+              }
+              this.reliableMessageBuffer.push({
+                data: msg,
+                sequence: packet.sequence,
+                sent: true
+              });
+              dc.send(msg);
+            }
+            this.updateAndEmitDCBufferStatus(kind);
+            break;
           }
-          this.updateAndEmitDCBufferStatus(kind);
-          break;
       }
     });
   }
@@ -22536,36 +22752,56 @@ class RTCEngine extends eventsExports.EventEmitter {
   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';
+      let bufferStatusFullBehavior = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'drop';
       return function* () {
-        // make sure we do have a data connection
+        // Make sure we do have a data connection. This matters most for the direct data-track path
+        // (Room's packetAvailable handler), which doesn't go through sendDataPacket: it both waits for
+        // the channel to be open and — on lazily negotiated publisher connections — is what kicks the
+        // negotiation off in the first place. The call is memoized, so the steady-state cost is one
+        // await on an already-resolved promise.
         yield _this3.ensurePublisherConnected(kind);
         const dc = _this3.dataChannelForKind(kind);
-        if (dc) {
-          if (!_this3.isBufferStatusLow(kind)) {
+        try {
+          if (dc) {
             // 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) {
+            // buffer to drain below the high-water mark before continuing.
+            switch (bufferStatusFullBehavior) {
               case 'wait':
-                yield _this3.waitForBufferStatusLow(kind);
+                if (!_this3.isBelowHighWaterMark(kind)) {
+                  yield _this3.waitForBufferHeadroomWithLock(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));
+                // we check against the actual threshold on the DC here, as it is dynamic for the lossy DC
+                if (!_this3.isBelowLowWaterMark(kind)) {
+                  // Drop messages to reduce latency
+                  _this3.lossyDataDropCount += 1;
+                  if (_this3.lossyDataDropCount % 100 === 0) {
+                    _this3.log.warn("dropping lossy data channel messages, total dropped: ".concat(_this3.lossyDataDropCount));
+                  }
+                  return;
                 }
-                return;
             }
+            if (kind === DataChannelKind.LOSSY) {
+              // The byterate stat tunes the LOSSY channel's dynamic drop threshold; counting data-track
+              // bytes here would inflate it and let the lossy channel buffer far more latency than the
+              // ~100ms the tuning targets.
+              _this3.lossyDataStatCurrentBytes += bytes.byteLength;
+            }
+            if (_this3.attemptingReconnect) {
+              return;
+            }
+            dc.send(bytes);
           }
-          _this3.lossyDataStatCurrentBytes += bytes.byteLength;
-          if (_this3.attemptingReconnect) {
-            return;
+          _this3.updateAndEmitDCBufferStatus(kind);
+        } catch (error) {
+          // ensure same surface behaviour as before with missing data channel being silently ignored, just log an error message for clarity
+          if (error instanceof TypeError) {
+            _this3.log.error(error);
+          } else {
+            throw error;
           }
-          dc.send(bytes);
         }
-        _this3.updateAndEmitDCBufferStatus(kind);
       }();
     });
   }
@@ -22575,33 +22811,129 @@ class RTCEngine extends eventsExports.EventEmitter {
       const dc = this.dataChannelForKind(DataChannelKind.RELIABLE);
       if (dc) {
         this.reliableMessageBuffer.popToSequence(lastMessageSeq);
-        this.reliableMessageBuffer.getAll().forEach(msg => {
-          dc.send(msg.data);
-        });
+        // Hold the headroom lock across the whole replay. Releasing it between messages would let a
+        // concurrent send — whose (newer) sequence was already assigned in sendDataPacket before it
+        // queued on the lock — hit the wire mid-replay, and receivers would then discard the
+        // remaining lower-sequence resent messages as duplicates.
+        const unlock = yield this.getBufferHeadroomLock(DataChannelKind.RELIABLE).lock();
+        try {
+          // Everything left after the ack cutoff must be re-handed to the current channel.
+          this.reliableMessageBuffer.markAllUnsent();
+          // Drain in passes, re-scanning the live buffer each time: a send that arrives (deferred,
+          // sent:false) during our own awaits appends after this pass started, so we pick it up on
+          // the next one. We mark each packet only once we've actually handed it to the channel — a
+          // blanket "mark all sent" would flip such a late arrival to sent without transmitting it,
+          // and a later alignBufferedAmount would then drop it for good. If the loop throws
+          // mid-drain, unsent entries keep their flag and the next replay picks them up.
+          for (let batch = this.reliableMessageBuffer.getUnsent(); batch.length > 0; batch = this.reliableMessageBuffer.getUnsent()) {
+            for (const item of batch) {
+              // Respect flow control on resume too, so a large resend doesn't overflow the buffer.
+              // We already hold the lock across the whole replay, so use the lock-free wait.
+              yield this.waitForBufferHeadroomWithoutLock(DataChannelKind.RELIABLE);
+              dc.send(item.data);
+              this.reliableMessageBuffer.markSent(item);
+            }
+          }
+        } finally {
+          unlock();
+        }
       }
       this.updateAndEmitDCBufferStatus(DataChannelKind.RELIABLE);
     });
   }
-  waitForBufferStatusLow(kind) {
+  waiterAbortSignal(kind) {
+    let controller = this.waiterAbortControllers.get(kind);
+    if (!controller) {
+      controller = new AbortController();
+      this.waiterAbortControllers.set(kind, controller);
+    }
+    return controller.signal;
+  }
+  /** Rejects all parked headroom waiters (all kinds); the next waiter gets a fresh controller. */
+  invalidateDataChannelWaiters(reason) {
+    for (const controller of this.waiterAbortControllers.values()) {
+      controller.abort(reason);
+    }
+    this.waiterAbortControllers.clear();
+  }
+  /** Acquires the per-kind headroom lock, resolving with the unlock function. */
+  getBufferHeadroomLock(kind) {
+    let lock = this.waitForBufferHeadroomLocks.get(kind);
+    if (!lock) {
+      lock = new _();
+      this.waitForBufferHeadroomLocks.set(kind, lock);
+    }
+    return lock;
+  }
+  /**
+   * Acquires the `kind` headroom lock, waits until the send buffer has room, then releases. The
+   * common single-send entry point. Callers that need to hold the lock across several sends (the
+   * resume replay) acquire it via {@link getBufferHeadroomLock} and call
+   * {@link waitForBufferHeadroomWithoutLock} per message instead.
+   */
+  waitForBufferHeadroomWithLock(kind) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.getBufferHeadroomLock(kind).lock();
+      try {
+        yield this.waitForBufferHeadroomWithoutLock(kind);
+      } finally {
+        unlock();
+      }
+    });
+  }
+  /**
+   * Waits until the send buffer for `kind` is at or below the high-water mark (draining, if
+   * needed, via the `bufferedamountlow` event). Does no locking of its own — the caller must
+   * already hold the kind's headroom lock (via {@link getBufferHeadroomLock}). The resume replay
+   * holds the lock across its whole batch and calls this per message so no other sender can
+   * interleave; the single-send path goes through {@link waitForBufferHeadroomWithLock}.
+   *
+   * Serializing through the per-kind lock means that, once the buffer drains, queued callers
+   * refill it one at a time (up to the high-water mark) rather than all at once and overflowing
+   * the SCTP send buffer (see livekit/client-sdk-js#1995).
+   */
+  waitForBufferHeadroomWithoutLock(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)) {
+      if (this.isClosed) {
+        throw new UnexpectedConnectionState('engine closed');
+      }
+      if (this.isBelowHighWaterMark(kind)) {
+        return;
+      }
+      const dc = this.dataChannelForKind(kind);
+      if (!dc) {
+        throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(kind));
+      }
+      const abortSignal = this.waiterAbortSignal(kind);
+      yield new TypedPromise((resolve, reject) => {
+        const onBufferedAmountLow = () => {
+          cleanup();
           resolve();
-        } 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
-          });
+        };
+        const onDCClose = () => {
+          cleanup();
+          reject(new UnexpectedConnectionState("DataChannel ".concat(kind, " closed while draining the buffer")));
+        };
+        const onAbort = () => {
+          cleanup();
+          reject(new UnexpectedConnectionState("DataChannel ".concat(kind, " was replaced or torn down while waiting for headroom")));
+        };
+        const cleanup = () => {
+          dc.removeEventListener('bufferedamountlow', onBufferedAmountLow);
+          dc.removeEventListener('close', onDCClose);
+          abortSignal.removeEventListener('abort', onAbort);
+        };
+        if (abortSignal.aborted) {
+          onAbort();
+          return;
         }
-      }));
+        dc.addEventListener('bufferedamountlow', onBufferedAmountLow);
+        // Proxy along any error caused by the data channel closing while we wait.
+        dc.addEventListener('close', onDCClose);
+        // The channel object we're parked on can be abandoned without ever firing another event
+        // (e.g. createDataChannels replacing it); the abort is our way out.
+        abortSignal.addEventListener('abort', onAbort);
+      });
     });
   }
   /**
@@ -22883,7 +23215,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 +23270,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 +23306,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 +23386,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;
@@ -24829,6 +25164,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 +25176,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 +25195,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 +25207,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 +25322,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 +25436,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 +25496,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 +25573,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 +25597,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 +25674,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 +26343,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;
@@ -27403,6 +27808,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 +28857,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 +28893,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();
@@ -30206,7 +30626,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();