livekit-client 2.22.3 → 2.23.0

package/dist/livekit-client.esm.mjs

@@ -5473,6 +5473,9 @@ const ClientInfo_SDK = /* @__PURE__ */proto3.makeEnum("livekit.ClientInfo.SDK",
 }, {
   no: 14,
   name: "ESP32"
+}, {
+  no: 15,
+  name: "DOTNET"
 }]);
 const ClientInfo_Capability = /* @__PURE__ */proto3.makeEnum("livekit.ClientInfo.Capability", [{
   no: 0,
@@ -5841,6 +5844,9 @@ const EncodingOptionsPreset = /* @__PURE__ */proto3.makeEnum("livekit.EncodingOp
 }, {
   no: 7,
   name: "PORTRAIT_H264_1080P_60"
+}, {
+  no: 8,
+  name: "PASSTHROUGH"
 }]);
 const EncodedFileType = /* @__PURE__ */proto3.makeEnum("livekit.EncodedFileType", [{
   no: 0,
@@ -7825,6 +7831,11 @@ const SyncState = /* @__PURE__ */proto3.makeMessageType("livekit.SyncState", ()
   kind: "message",
   T: PublishDataTrackResponse,
   repeated: true
+}, {
+  no: 9,
+  name: "data_subscription",
+  kind: "message",
+  T: UpdateDataSubscription
 }]);
 const DataChannelReceiveState = /* @__PURE__ */proto3.makeMessageType("livekit.DataChannelReceiveState", () => [{
   no: 1,
@@ -8697,6 +8708,11 @@ function onWorkerLogLevelChanged(cb) {
     workerLogLevelListeners.delete(cb);
   };
 }const maxRetryDelay = 7000;
+/**
+ * Upper bound of the random delay added to the first retry, whose base delay is 0. It keeps a
+ * brief network blip recovering quickly while spreading out clients that disconnect together.
+ */
+const maxFirstRetryJitterInMs = 500;
 const DEFAULT_RETRY_DELAYS_IN_MS = [0, 300, 2 * 2 * 300, 3 * 3 * 300, 4 * 4 * 300, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay];
 class DefaultReconnectPolicy {
   constructor(retryDelays) {
@@ -8705,8 +8721,13 @@ class DefaultReconnectPolicy {
   nextRetryDelayInMs(context) {
     if (context.retryCount >= this._retryDelays.length) return null;
     const retryDelay = this._retryDelays[context.retryCount];
-    if (context.retryCount <= 1) return retryDelay;
-    return retryDelay + Math.random() * 1000;
+    // The first retry has no base delay to scale, so it gets a fixed window instead. A zero at a
+    // later index is an explicit request for an immediate retry and passes through the formula as zero.
+    if (context.retryCount === 0 && retryDelay === 0) {
+      return Math.random() * maxFirstRetryJitterInMs;
+    }
+    // Jitter scales with the delay (+/-50%) so clients spread out further on later retries.
+    return Math.round(retryDelay * (0.5 + Math.random()));
   }
 }/******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -12279,7 +12300,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.22.3";const version = version$1;
+}var version$1 = "2.23.0";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -12360,6 +12381,32 @@ class ConnectionError extends LivekitReasonedError {
     return new ConnectionError(message, ConnectionErrorReason.ServiceNotFound, undefined, serviceName);
   }
 }
+/**
+ * Whether a failed connection attempt may be retried against a different LiveKit Cloud region.
+ *
+ * LiveKit Cloud signals project-level region pinning by returning 403 on the RTC paths when the
+ * project is not allowed in the region the client geo-routed to. `/settings/regions` is
+ * deliberately left reachable so the client can discover its allowed regions and connect there, so
+ * a 403 must not be treated as terminal.
+ *
+ * A 401 stays terminal: no other region will accept a token this one rejected. So does the 404
+ * "requested room does not exist" case, which is also reported as `NotAllowed`.
+ *
+ * We key on the status rather than the server's error message because that message is an
+ * unversioned human-readable string; matching it would let a copy edit break already-shipped
+ * clients. If a 403 really was a permissions failure rather than region pinning, every region
+ * attempt fails the same way and the original error still surfaces — at the cost of one extra
+ * region lookup.
+ */
+function canFailOverToAnotherRegion(error) {
+  if (error.reason === ConnectionErrorReason.Cancelled) {
+    return false;
+  }
+  if (error.reason === ConnectionErrorReason.NotAllowed) {
+    return error.status === 403;
+  }
+  return true;
+}
 class DeviceUnsupportedError extends LivekitError {
   constructor(message) {
     super(21, message !== null && message !== void 0 ? message : 'device is unsupported');
@@ -12693,7 +12740,7 @@ var RoomEvent;
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
    * All participants in the room will receive the messages sent to the room.
    *
-   * args: (payload: NonSharedUint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
+   * args: (payload: NonSharedUint8Array, participant: [[Participant]] | undefined, kind: [[DataPacket_Kind]], topic?: string, encryptionType?: Encryption_Type, participantIdentity?: string)
    */
   RoomEvent["DataReceived"] = "dataReceived";
   /**
@@ -13051,6 +13098,7 @@ var EngineEvent;
   EngineEvent["Joined"] = "joined";
   EngineEvent["TokenRefreshed"] = "tokenRefreshed";
   EngineEvent["ServerRegionsReported"] = "serverRegionsReported";
+  EngineEvent["RequestSubscribedCodecRefresh"] = "requestSubscribedCodecRefresh";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -13520,20 +13568,44 @@ function detectSilence(track_1) {
     let timeOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
     return function* () {
       const ctx = getNewAudioContext();
-      if (ctx) {
-        const analyser = ctx.createAnalyser();
+      if (!ctx) {
+        return false;
+      }
+      let source;
+      let analyser;
+      try {
+        analyser = ctx.createAnalyser();
         analyser.fftSize = 2048;
         const bufferLength = analyser.frequencyBinCount;
         const dataArray = new Uint8Array(bufferLength);
-        const source = ctx.createMediaStreamSource(new MediaStream([track.mediaStreamTrack]));
+        source = ctx.createMediaStreamSource(new MediaStream([track.mediaStreamTrack]));
         source.connect(analyser);
+        // read through a function so that `state` isn't narrowed to its value from before `resume`
+        const isRunning = () => ctx.state === 'running';
+        if (!isRunning()) {
+          try {
+            // `resume` can stay pending indefinitely on a blocked page rather than rejecting, which
+            // would keep the context and its nodes alive past the `finally` below
+            yield Promise.race([ctx.resume(), sleep(200)]);
+          } catch (_a) {
+            // autoplay policies can keep us from resuming the context
+          }
+          if (!isRunning()) {
+            // a context that isn't running doesn't process any audio, so the analyser would only ever
+            // read silence. Report the track as not silent rather than raising a false positive.
+            return false;
+          }
+        }
         yield sleep(timeOffset);
         analyser.getByteTimeDomainData(dataArray);
         const someNoise = dataArray.some(sample => sample !== 128 && sample !== 0);
-        ctx.close();
         return !someNoise;
+      } finally {
+        source === null || source === void 0 ? void 0 : source.disconnect();
+        analyser === null || analyser === void 0 ? void 0 : analyser.disconnect();
+        // don't let a failing teardown mask the detection result
+        yield ctx.close().catch(() => {});
       }
-      return false;
     }();
   });
 }
@@ -13745,6 +13817,85 @@ function areDimensionsSmaller(a, b) {
 function layerDimensionsFor(trackInfo, quality) {
   var _a;
   return (_a = trackInfo.layers) === null || _a === void 0 ? void 0 : _a.find(l => l.quality === quality);
+}
+/**
+ * Waits until `track` has actually produced a video frame.
+ *
+ * iOS keeps reporting the camera's sensor frame from `getSettings()` until the camera has
+ * delivered its first picture, so a portrait capture initially reads as landscape. The arrival
+ * of that first frame is the only reliable signal that the reported settings describe reality.
+ *
+ * Best effort, never throws. Resolves `true` when a frame was observed, `false` when no frame
+ * can be observed (the track is already ended, muted or disabled) or `timeoutMs` elapsed first.
+ *
+ * @internal
+ */
+function waitForFirstVideoFrame(track_1, timeoutMs_1) {
+  return __awaiter(this, arguments, void 0, function (track, timeoutMs) {
+    let candidateElements = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    return function* () {
+      var _a;
+      if (typeof document === 'undefined') {
+        return false;
+      }
+      if (track.readyState === 'ended' || track.muted || !track.enabled) {
+        // no frame is ever going to arrive, don't hold the caller up for the full timeout
+        return false;
+      }
+      // requestVideoFrameCallback (Safari 15.4 and up) is a platform capability, so the answer is the
+      // same for every element
+      const supportsFrameCallback = typeof HTMLVideoElement.prototype.requestVideoFrameCallback === 'function';
+      // prefer an element that is already rendering this track (a local preview, typically) over
+      // spinning up a second decode just to observe a frame
+      const existingElement = candidateElements.find(el => el instanceof HTMLVideoElement && el.srcObject instanceof MediaStream && el.srcObject.getVideoTracks().includes(track) && (
+      // without requestVideoFrameCallback we depend on `loadeddata`, which is one-shot: an element
+      // that already decoded a frame (readyState >= HAVE_CURRENT_DATA) never fires it again.
+      // Leave those alone and set up our own element, which starts out empty.
+      supportsFrameCallback || el.readyState < 2));
+      const element = existingElement !== null && existingElement !== void 0 ? existingElement : document.createElement('video');
+      if (!existingElement) {
+        element.playsInline = true;
+        element.muted = true;
+        element.srcObject = new MediaStream([track]);
+        // the element is deliberately never added to the DOM, it only exists to pull frames.
+        // WebKit delivers frames to a paused element too, so a rejected play() (Safari's low power
+        // mode, for instance) is not a reason to stop waiting
+        element.play().catch(error => {
+          livekitLogger.debug('could not play element while waiting for the first video frame', {
+            error
+          });
+        });
+      }
+      let timer;
+      let frameHandle;
+      let onLoadedData;
+      try {
+        return yield new Promise(resolve => {
+          timer = setTimeout(() => resolve(false), timeoutMs);
+          if (supportsFrameCallback) {
+            frameHandle = element.requestVideoFrameCallback(() => resolve(true));
+          } else {
+            // Safari below 15.4 has no requestVideoFrameCallback. `loadeddata` fires once the first
+            // frame has been decoded, which is the same signal a few milliseconds earlier.
+            onLoadedData = () => resolve(true);
+            element.addEventListener('loadeddata', onLoadedData);
+          }
+        });
+      } finally {
+        clearTimeout(timer);
+        if (frameHandle !== undefined) {
+          (_a = element.cancelVideoFrameCallback) === null || _a === void 0 ? void 0 : _a.call(element, frameHandle);
+        }
+        if (onLoadedData) {
+          element.removeEventListener('loadeddata', onLoadedData);
+        }
+        if (!existingElement) {
+          element.pause();
+          element.srcObject = null;
+        }
+      }
+    }();
+  });
 }const BACKGROUND_REACTION_DELAY = 5000;
 // keep old audio elements when detached, we would re-use them since on iOS
 // Safari tracks which audio elements have been "blessed" by the user.
@@ -14384,6 +14535,32 @@ function isSafariBased() {
   const b = getBrowser();
   return (b === null || b === void 0 ? void 0 : b.name) === 'Safari' || (b === null || b === void 0 ? void 0 : b.os) === 'iOS';
 }
+/**
+ * iPadOS has sent the desktop Macintosh user agent by default since iPadOS 13, so `getBrowser()`
+ * reports `os: 'macOS'` there and every `os === 'iOS'` check misses it. macOS Safari implements no
+ * touch events at all (`TouchEvent` undefined, `maxTouchPoints` 0) regardless of any touchscreen
+ * attached, so touch capability separates the two. Measured on an iPad 6 / iPadOS 17
+ * (`maxTouchPoints` 5) against macOS Safari 26.4 (`maxTouchPoints` 0).
+ *
+ * Deliberately a separate helper rather than a fix in `browserParser`: iPadOS spoofs the Mac
+ * version too, so reporting `os: 'iOS'` there would leave `osVersion` at `10.15.7` and silently
+ * break {@link isSafari17Based} and {@link isSafariSvcApi}, which compare it.
+ */
+function isIPadOS() {
+  if (!isWeb()) {
+    return false;
+  }
+  const b = getBrowser();
+  return (b === null || b === void 0 ? void 0 : b.name) === 'Safari' && (b === null || b === void 0 ? void 0 : b.os) === 'macOS' && navigator.maxTouchPoints > 1;
+}
+/**
+ * iPhone, iPad and iOS-hosted browsers — everything running the Apple camera capture pipeline,
+ * including iPads that present themselves as a Mac.
+ */
+function isAppleMobile() {
+  var _a;
+  return ((_a = getBrowser()) === null || _a === void 0 ? void 0 : _a.os) === 'iOS' || isIPadOS();
+}
 function isSafari17Based() {
   const b = getBrowser();
   return (b === null || b === void 0 ? void 0 : b.name) === 'Safari' && b.version.startsWith('17.') || (b === null || b === void 0 ? void 0 : b.os) === 'iOS' && !!(b === null || b === void 0 ? void 0 : b.osVersion) && compareVersions(b.osVersion, '17') >= 0;
@@ -14567,6 +14744,15 @@ function createDummyVideoStreamTrack() {
   return dummyTrack;
 }
 let emptyAudioStreamTrack;
+let emptyAudioStreamContext;
+/** tracks handed out by `getEmptyAudioStreamTrack` that haven't been released yet */
+const outstandingEmptyAudioStreamTracks = new Set();
+/**
+ * Returns a silent audio track, cloned off a shared `AudioContext` created on first use. Hand the
+ * clone back to `releaseEmptyAudioStreamTrack` rather than stopping it, so the context can close.
+ * A clone that is only stopped stays counted as outstanding, which holds the shared context open
+ * for the lifetime of the page.
+ */
 function getEmptyAudioStreamTrack() {
   if (!emptyAudioStreamTrack) {
     // implementation adapted from https://blog.mozilla.org/webrtc/warm-up-with-replacetrack/
@@ -14582,11 +14768,38 @@ function getEmptyAudioStreamTrack() {
     var _dst$stream$getAudioT2 = _slicedToArray(_dst$stream$getAudioT, 1);
     emptyAudioStreamTrack = _dst$stream$getAudioT2[0];
     if (!emptyAudioStreamTrack) {
+      // don't hold on to a context we can't get a track out of
+      ctx.close().catch(() => {});
       throw Error('Could not get empty media stream audio track');
     }
     emptyAudioStreamTrack.enabled = false;
+    emptyAudioStreamContext = ctx;
   }
-  return emptyAudioStreamTrack.clone();
+  const track = emptyAudioStreamTrack.clone();
+  outstandingEmptyAudioStreamTracks.add(track);
+  return track;
+}
+/**
+ * Stops a track obtained from `getEmptyAudioStreamTrack` and closes the shared `AudioContext`
+ * backing it once every track it handed out has been released. Does nothing for a track this
+ * module never handed out, or one that has been released already.
+ */
+function releaseEmptyAudioStreamTrack(track) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (!outstandingEmptyAudioStreamTracks.delete(track)) {
+      // the track wasn't obtained from `getEmptyAudioStreamTrack`, or has been released before
+      return;
+    }
+    track.stop();
+    if (outstandingEmptyAudioStreamTracks.size > 0) {
+      return;
+    }
+    const context = emptyAudioStreamContext;
+    emptyAudioStreamTrack === null || emptyAudioStreamTrack === void 0 ? void 0 : emptyAudioStreamTrack.stop();
+    emptyAudioStreamTrack = undefined;
+    emptyAudioStreamContext = undefined;
+    yield context === null || context === void 0 ? void 0 : context.close();
+  });
 }
 /** An object that represents a serialized version of a `new Promise((resolve, reject) => {})`
  * constructor. Wait for a promise resolution with `await future.promise` and explicitly resolve or
@@ -14650,11 +14863,19 @@ function createAudioAnalyser(track, options) {
     const volume = Math.sqrt(sum / dataArray.length);
     return volume;
   };
+  let isCleanedUp = false;
   const cleanup = () => __awaiter(this, void 0, void 0, function* () {
-    yield audioContext.close();
+    if (isCleanedUp) {
+      // closing an already closed context would reject, make repeated cleanups a no-op instead
+      return;
+    }
+    isCleanedUp = true;
+    mediaStreamSource.disconnect();
+    analyser.disconnect();
     if (opts.cloneTrack) {
       streamTrack.stop();
     }
+    yield audioContext.close();
   });
   return {
     calculateVolume,
@@ -14689,6 +14910,31 @@ function unwrapConstraint(constraint) {
   }
   throw Error('could not unwrap constraint');
 }
+/**
+ * The getUserMedia rejections that no softer constraint can recover from, because the user or the
+ * document refused capture outright. Retrying one of these would put a second prompt in front of
+ * someone who already said no. The last two names are legacy spellings still reported by older
+ * engines. Matched by `name` rather than with `instanceof`, because these are not reliably distinct
+ * constructors across environments. happy-dom, which the tests run under, aliases them to `Event`.
+ */
+function isPermissionDeniedError(e) {
+  return typeof e === 'object' && e !== null && 'name' in e && (e.name === 'NotAllowedError' || e.name === 'SecurityError' || e.name === 'PermissionDeniedError' || e.name === 'PermissionDismissedError');
+}
+const deviceAcquisitionFailures = new WeakSet();
+/** Records that `e` is the rejection getUserMedia itself produced. */
+function markDeviceAcquisitionFailure(e) {
+  if (typeof e === 'object' && e !== null) {
+    deviceAcquisitionFailures.add(e);
+  }
+}
+/**
+ * Whether a track restart failed at getUserMedia rather than in the work that adopts the new track.
+ * Recorded on the side rather than by wrapping, because callers of `restartTrack` match on the
+ * rejection's own name.
+ */
+function isDeviceAcquisitionFailure(e) {
+  return typeof e === 'object' && e !== null && deviceAcquisitionFailures.has(e);
+}
 function toWebsocketUrl(url) {
   if (url.startsWith('http')) {
     return url.replace(/^(http)/, 'ws');
@@ -14875,6 +15121,35 @@ function extractMaxAgeFromRequestHeaders(headers) {
 function isCompressionStreamSupported() {
   return typeof CompressionStream !== 'undefined';
 }
+let deflateRawCompressionSupported = null;
+/**
+ * Whether this runtime can compress AND decompress the `deflate-raw` format, which is a stricter
+ * requirement than {@link isCompressionStreamSupported}: Chromium 80-102 included
+ * `CompressionStream` supporting only `gzip` / `deflate`, and `deflate-raw` was added in Chromium
+ * 103 (Firefox 113, Safari 16.4).
+ */
+function isDeflateRawCompressionSupported() {
+  if (typeof deflateRawCompressionSupported !== 'boolean') {
+    deflateRawCompressionSupported = probeDeflateRawCompressionSupport();
+  }
+  return deflateRawCompressionSupported;
+}
+function probeDeflateRawCompressionSupport() {
+  if (typeof CompressionStream === 'undefined' || typeof DecompressionStream === 'undefined') {
+    return false;
+  }
+  try {
+    // There is no api to query format support, and constructing with an unsupported format throws
+    // synchronously, so constructing one of each is the probe. Both are checked because the
+    // deflate-raw capability advertised to peers is as much about decompressing what they send us
+    // as it is about compressing what we send them.
+    new CompressionStream('deflate-raw');
+    new DecompressionStream('deflate-raw');
+    return true;
+  } catch (_a) {
+    return false;
+  }
+}
 function isPublisherOfferWithJoinSupported() {
   // we have connectivity issue about publisher offer with join on firefox #1919
   return isCompressionStreamSupported() && !isFireFox();
@@ -15877,11 +16152,38 @@ class HTMLElementInfo {
   }
 }
 function isElementInPiP(el) {
-  var _a, _b;
+  var _a;
   // Simple video PiP
   if (document.pictureInPictureElement === el) return true;
-  // Document PiP
-  if ((_a = window.documentPictureInPicture) === null || _a === void 0 ? void 0 : _a.window) return isElementInViewport(el, (_b = window.documentPictureInPicture) === null || _b === void 0 ? void 0 : _b.window);
+  // Document PiP: the element has to actually live in the PiP window, otherwise an
+  // opener-document element whose coordinates happen to fall inside the PiP window's
+  // bounds is reported as being in PiP.
+  const pipWindow = (_a = window.documentPictureInPicture) === null || _a === void 0 ? void 0 : _a.window;
+  if (pipWindow) {
+    return isDocumentInPiPWindow(el.ownerDocument, pipWindow) && isElementInViewport(el, pipWindow);
+  }
+  return false;
+}
+// Whether the document is the Document PiP window's own document, or the document of a frame
+// nested inside it. The spec allows frames in a PiP window, so an element in one is in PiP:
+// https://wicg.github.io/document-picture-in-picture/#iframes
+function isDocumentInPiPWindow(doc, pipWindow) {
+  var _a, _b, _c;
+  // A cross-origin frame anywhere between the element and the PiP window hides frameElement
+  // from the walk below, but top stays readable across origins and identifies the top-level
+  // window the element belongs to. For an opener element that is the opener, not the PiP window.
+  if (((_a = doc.defaultView) === null || _a === void 0 ? void 0 : _a.top) === pipWindow) return true;
+  let current = doc;
+  while (current) {
+    if (current === pipWindow.document) return true;
+    try {
+      // Reading frameElement across a cross-origin boundary throws, which means we cannot
+      // establish the ancestry and must not claim the element is in PiP.
+      current = (_c = (_b = current.defaultView) === null || _b === void 0 ? void 0 : _b.frameElement) === null || _c === void 0 ? void 0 : _c.ownerDocument;
+    } catch (_d) {
+      return false;
+    }
+  }
   return false;
 }
 // does not account for occlusion by other elements or opacity property
@@ -16346,12 +16648,16 @@ class E2EEManager extends eventsExports.EventEmitter {
     this.handleReceiver(track.receiver, track.mediaStreamID, remoteId, track.kind === 'video' ? mimeTypeToVideoCodecString(trackInfo.mimeType) : undefined, hasPacketTrailer);
   }
   setupE2EESender(track, sender) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (!isLocalTrack(track) || !sender) {
       if (!sender) this.log.warn('early return because sender is not ready');
       return;
     }
-    this.handleSender(sender, track.mediaStreamID, undefined, isVideoTrack(track) ? (_b = (_a = track.publishOptions) === null || _a === void 0 ? void 0 : _a.frameMetadata) !== null && _b !== void 0 ? _b : (_c = track.publishOptions) === null || _c === void 0 ? void 0 : _c.packetTrailer : undefined);
+    const isVideo = isVideoTrack(track);
+    // Safari exposes no per-frame codec info until trackInfo arrives. Seed only h264/h265:
+    // a wrong vp8 seed would skip the NALU path, a wrong NALU seed only costs a logged fallback.
+    const publishedCodec = isVideo ? (_a = track.publishOptions) === null || _a === void 0 ? void 0 : _a.videoCodec : undefined;
+    this.handleSender(sender, track.mediaStreamID, publishedCodec === 'h264' || publishedCodec === 'h265' ? publishedCodec : undefined, isVideo ? (_c = (_b = track.publishOptions) === null || _b === void 0 ? void 0 : _b.frameMetadata) !== null && _c !== void 0 ? _c : (_d = track.publishOptions) === null || _d === void 0 ? void 0 : _d.packetTrailer : undefined);
   }
   /**
    * Handles the given {@code RTCRtpReceiver} by creating a {@code TransformStream} which will inject
@@ -17121,6 +17427,58 @@ class AsyncQueue {
   snapshot() {
     return Array.from(this.pendingTasks.values());
   }
+}/**
+ * Implementation of AbortSignal.any
+ * Creates a signal that will be aborted when any of the given signals is aborted.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
+ */
+function abortSignalAny(signals) {
+  // Handle empty signals array
+  if (signals.length === 0) {
+    const controller = new AbortController();
+    return controller.signal;
+  }
+  // Fast path for single signal
+  if (signals.length === 1) {
+    return signals[0];
+  }
+  // Check if any signal is already aborted
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal;
+    }
+  }
+  // Create a new controller for the combined signal
+  const controller = new AbortController();
+  const unlisteners = Array(signals.length);
+  // Function to clean up all event listeners
+  const cleanup = () => {
+    for (const unsubscribe of unlisteners) {
+      unsubscribe();
+    }
+  };
+  // Add event listeners to each signal
+  signals.forEach((signal, index) => {
+    const handler = () => {
+      controller.abort(signal.reason);
+      cleanup();
+    };
+    signal.addEventListener('abort', handler);
+    unlisteners[index] = () => signal.removeEventListener('abort', handler);
+  });
+  return controller.signal;
+}
+/**
+ * Implementation of AbortSignal.timeout
+ * Creates a signal that will be aborted after the specified timeout.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
+ */
+function abortSignalTimeout(ms) {
+  const controller = new AbortController();
+  setTimeout(() => {
+    controller.abort(new DOMException("signal timed out after ".concat(ms, " ms"), 'TimeoutError'));
+  }, ms);
+  return controller.signal;
 }/**
  * Opt-in registry that lets a development tool observe the state machines driving the connection
  * layer.
@@ -18278,7 +18636,7 @@ class WebSocketStream {
       let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
         code = _ref.closeCode,
         reason = _ref.reason;
-      return ws.close(code, reason);
+      return ws.close(code, reason === undefined ? undefined : truncateCloseReason(reason));
     };
     this.opened = new TypedPromise((resolve, reject) => {
       const rejectHandler = () => {
@@ -18354,6 +18712,25 @@ class WebSocketStream {
     }
     this.close = closeWithInfo;
   }
+}
+/** `WebSocket.close` throws a `SyntaxError` for a reason longer than this many UTF-8 bytes. */
+const MAX_CLOSE_REASON_BYTES = 123;
+function truncateCloseReason(reason) {
+  const encoder = new TextEncoder();
+  if (encoder.encode(reason).length <= MAX_CLOSE_REASON_BYTES) {
+    return reason;
+  }
+  // cut on code point boundaries, so a multi-byte character is never split
+  let truncated = '';
+  let bytes = 0;
+  for (const char of reason) {
+    bytes += encoder.encode(char).length;
+    if (bytes > MAX_CLOSE_REASON_BYTES) {
+      break;
+    }
+    truncated += char;
+  }
+  return truncated;
 }const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 /**
  * Whether a failed resume may be followed by another one. Mirrors how `RTCEngine` classifies these
@@ -18569,14 +18946,27 @@ class SignalClient {
       let publisherOffer = arguments.length > 5 ? arguments[5] : undefined;
       return function* () {
         const unlock = yield _this2.connectionLock.lock();
-        _this2.connectOptions = opts;
-        _this2.useV0SignalPath = useV0Path;
-        const clientInfo = getClientInfo(opts.clientInfoCapabilities);
-        const params = useV0Path ? createConnectionParams(token, clientInfo, opts) : yield createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
-        const rtcUrl = createRtcUrl(url, params, useV0Path).toString();
-        const validateUrl = createValidateUrl(rtcUrl).toString();
+        let rtcUrl;
+        let validateUrl;
+        try {
+          _this2.connectOptions = opts;
+          _this2.useV0SignalPath = useV0Path;
+          const clientInfo = getClientInfo(opts.clientInfoCapabilities);
+          const params = useV0Path ? createConnectionParams(token, clientInfo, opts) : yield createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
+          rtcUrl = createRtcUrl(url, params, useV0Path).toString();
+          validateUrl = createValidateUrl(rtcUrl).toString();
+        } catch (e) {
+          // the executor below owns the lock from here on
+          unlock();
+          throw e;
+        }
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+          unlock();
+          _this2.log.debug('signal connect abandoned before opening a transport');
+          throw ConnectionError.cancelled('Connection aborted');
+        }
         return new Promise((resolve, reject) => __awaiter(_this2, void 0, void 0, function* () {
-          var _a, _b;
+          var _a, _b, _c, _d, _e;
           try {
             let alreadyAborted = false;
             const abortHandler = eventOrError => __awaiter(this, void 0, void 0, function* () {
@@ -18588,12 +18978,12 @@ class SignalClient {
               const reason = getAbortReasonAsString(target, 'Abort handler called');
               // send leave if we have an active stream writer (connection is open)
               if (this.streamWriter && !this.isDisconnected) {
-                this.sendLeave().then(() => this.close(reason)).catch(e => {
+                this.sendLeave().then(() => this.close(true, reason)).catch(e => {
                   this.log.error(e);
-                  this.close();
+                  this.close(true, reason);
                 });
               } else {
-                this.close();
+                this.close(true, reason);
               }
               cleanupAbortHandlers();
               // The caller may already have classified this failure: the connect timeout hands us a
@@ -18619,6 +19009,10 @@ class SignalClient {
               yield this.teardownTransport('replaced by a new connection attempt');
               this.log.debug("closed previous ws connection in ".concat(performance.now() - startClose, "ms"));
             }
+            if (alreadyAborted) {
+              this.log.debug('signal connect abandoned after tearing down the previous transport');
+              return;
+            }
             // the transport created below belongs to this attempt; events arriving from it after a
             // newer attempt has started are dropped by the machine
             const attemptId = this.attemptId;
@@ -18663,6 +19057,12 @@ class SignalClient {
                 }
               });
               const connection = yield this.ws.opened.catch(reason => __awaiter(this, void 0, void 0, function* () {
+                if (alreadyAborted) {
+                  // the abort handler has already rejected this attempt; don't probe the validate
+                  // endpoint for a failure nobody is waiting on
+                  this.log.debug('signal connect abandoned while the websocket was opening');
+                  return;
+                }
                 if (this.lifecycleState !== 'connected') {
                   // claimed synchronously, before the await below: the socket's close event is already
                   // on its way and would otherwise reject first with a less useful error
@@ -18683,38 +19083,63 @@ class SignalClient {
               const signalReader = connection.readable.getReader();
               this.streamWriter = connection.writable.getWriter();
               // 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;
+              // its own deadline so a silent server can't hang join() forever.
+              // During reconnect, drop any stray messages that arrive before the
+              // ReconnectResponse so we do not declare the channel reconnected on the
+              // wrong signal.
+              let firstSignalResponse;
               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);
-                })]);
+                const deadline = Date.now() + JOIN_RESPONSE_TIMEOUT;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                  const remaining = deadline - Date.now();
+                  if (remaining <= 0) {
+                    throw ConnectionError.timeout('signal connection timed out while waiting for the first message');
+                  }
+                  let readTimeout;
+                  const readResult = yield Promise.race([signalReader.read(), new Promise((_, rejectRead) => {
+                    readTimeout = setTimeout(() => {
+                      rejectRead(ConnectionError.timeout('signal connection timed out while waiting for the first message'));
+                    }, remaining);
+                  })]);
+                  clearTimeout(readTimeout);
+                  if (!readResult.value) {
+                    throw ConnectionError.internal('no message received as first message');
+                  }
+                  const parsed = parseSignalResponse(readResult.value);
+                  if (this.lifecycleState === 'reconnecting' && ((_a = parsed.message) === null || _a === void 0 ? void 0 : _a.case) !== 'reconnect' && ((_b = parsed.message) === null || _b === void 0 ? void 0 : _b.case) !== 'leave') {
+                    this.log.warn('dropping signal message while awaiting reconnect response', {
+                      messageCase: (_c = parsed.message) === null || _c === void 0 ? void 0 : _c.case
+                    });
+                    continue;
+                  }
+                  firstSignalResponse = parsed;
+                  break;
+                }
               } catch (e) {
-                // No first message in time: release the reader and tear down the ws
+                // No usable 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');
+              if (alreadyAborted) {
+                // The abort handler has already rejected this attempt and is closing the transport.
+                // Don't act on a join that raced it: `onJoined` would publish an abandoned session's
+                // state to the room.
+                this.log.debug('signal connect abandoned while waiting for the first message');
+                return;
               }
-              const firstSignalResponse = parseSignalResponse(firstMessage.value);
               // Validate the first message
-              const validation = this.validateFirstMessage(firstSignalResponse, (_a = opts.reconnect) !== null && _a !== void 0 ? _a : false);
+              const validation = this.validateFirstMessage(firstSignalResponse, (_d = opts.reconnect) !== null && _d !== void 0 ? _d : false);
               if (!validation.isValid) {
                 reject(validation.error);
                 return;
               }
               // Handle join response
-              if (((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) === 'join') {
+              if (((_e = firstSignalResponse.message) === null || _e === void 0 ? void 0 : _e.case) === 'join') {
                 // Set up ping configuration
                 this.pingTimeoutDuration = firstSignalResponse.message.value.pingTimeout;
                 this.pingIntervalDuration = firstSignalResponse.message.value.pingInterval;
@@ -18728,9 +19153,7 @@ class SignalClient {
                   this.onJoined(firstSignalResponse.message.value);
                 }
               }
-              // Handle successful connection
-              const firstMessageToProcess = validation.shouldProcessFirstMessage ? firstSignalResponse : undefined;
-              this.handleSignalConnected(connection, wsTimeout, attemptId, firstMessageToProcess);
+              this.handleSignalConnected(connection, wsTimeout, attemptId);
               resolve(validation.response);
             } catch (e) {
               reject(e);
@@ -18744,11 +19167,8 @@ class SignalClient {
       }();
     });
   }
-  startReadingLoop(signalReader, firstMessage) {
+  startReadingLoop(signalReader) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (firstMessage) {
-        this.handleSignalResponse(firstMessage);
-      }
       const attemptId = this.attemptId;
       while (true) {
         if (this.signalLatency) {
@@ -18808,16 +19228,17 @@ class SignalClient {
     return __awaiter(this, void 0, void 0, function* () {
       try {
         this.clearPingInterval();
-        if (this.ws) {
-          this.ws.close({
+        const ws = this.ws;
+        if (ws) {
+          // released before closing, so a close that throws cannot leave the transport attached
+          this.ws = undefined;
+          this.streamWriter = undefined;
+          ws.close({
             closeCode: 1000,
             reason
           });
           // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
-          const closePromise = this.ws.closed;
-          this.ws = undefined;
-          this.streamWriter = undefined;
-          yield Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
+          yield Promise.race([ws.closed, sleep(MAX_WS_CLOSE_TIME)]);
         }
       } catch (e) {
         this.log.debug('websocket error while closing', {
@@ -19184,6 +19605,7 @@ class SignalClient {
     return __awaiter(this, arguments, void 0, function (reason) {
       var _this6 = this;
       let attemptId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.attemptId;
+      let simulateReconnectDelay = arguments.length > 2 ? arguments[2] : undefined;
       return function* () {
         const onCloseCallback = _this6.onClose;
         if (!_this6.sendLifecycleInput({
@@ -19205,6 +19627,10 @@ class SignalClient {
         _this6.log.info("websocket connection closed: ".concat(reason), {
           reason
         });
+        if (simulateReconnectDelay) {
+          _this6.log.info("waiting for ".concat(simulateReconnectDelay, "ms until reconnecting signal"));
+          yield sleep(simulateReconnectDelay);
+        }
         if (onCloseCallback) {
           onCloseCallback(reason);
         }
@@ -19265,7 +19691,7 @@ class SignalClient {
    * @param firstMessage Optional first message to process
    * @internal
    */
-  handleSignalConnected(connection, timeoutHandle, attemptId, firstMessage) {
+  handleSignalConnected(connection, timeoutHandle, attemptId) {
     clearTimeout(timeoutHandle);
     const established = this.sendLifecycleInput(this.lifecycleState === 'reconnecting' ? {
       type: 'reconnectComplete',
@@ -19287,7 +19713,7 @@ class SignalClient {
     }
     this.log.info('signal connected');
     this.startPingInterval();
-    this.startReadingLoop(connection.readable.getReader(), firstMessage);
+    this.startReadingLoop(connection.readable.getReader());
   }
   /**
    * Validates the first message received from the signal server
@@ -19297,28 +19723,18 @@ class SignalClient {
    * @internal
    */
   validateFirstMessage(firstSignalResponse, isReconnect) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     if (((_a = firstSignalResponse.message) === null || _a === void 0 ? void 0 : _a.case) === 'join') {
       return {
         isValid: true,
         response: firstSignalResponse.message.value
       };
-    } else if (this.lifecycleState === 'reconnecting' && ((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) !== 'leave') {
-      if (((_c = firstSignalResponse.message) === null || _c === void 0 ? void 0 : _c.case) === 'reconnect') {
-        return {
-          isValid: true,
-          response: firstSignalResponse.message.value
-        };
-      } else {
-        // in reconnecting, any message received means signal reconnected and we still need to process it
-        this.log.debug('declaring signal reconnected without reconnect response received');
-        return {
-          isValid: true,
-          response: undefined,
-          shouldProcessFirstMessage: true
-        };
-      }
-    } else if (this.isEstablishingConnection && ((_d = firstSignalResponse.message) === null || _d === void 0 ? void 0 : _d.case) === 'leave') {
+    } else if (this.lifecycleState === 'reconnecting' && ((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) === 'reconnect') {
+      return {
+        isValid: true,
+        response: firstSignalResponse.message.value
+      };
+    } else if (this.isEstablishingConnection && ((_c = firstSignalResponse.message) === null || _c === void 0 ? void 0 : _c.case) === 'leave') {
       return {
         isValid: false,
         error: ConnectionError.leaveRequest('Received leave request while trying to (re)connect', firstSignalResponse.message.value.reason)
@@ -19327,7 +19743,7 @@ class SignalClient {
       // non-reconnect case, should receive join response first
       return {
         isValid: false,
-        error: ConnectionError.internal("did not receive join response, got ".concat((_e = firstSignalResponse.message) === null || _e === void 0 ? void 0 : _e.case, " instead"))
+        error: ConnectionError.internal("did not receive join response, got ".concat((_d = firstSignalResponse.message) === null || _d === void 0 ? void 0 : _d.case, " instead"))
       };
     }
     return {
@@ -19345,7 +19761,9 @@ class SignalClient {
   handleConnectionError(reason, validateUrl) {
     return __awaiter(this, void 0, void 0, function* () {
       try {
-        const resp = yield fetch(validateUrl);
+        const resp = yield fetch(validateUrl, {
+          signal: abortSignalTimeout(3000)
+        });
         switch (resp.status) {
           case 404:
             const errorMsg = yield resp.text();
@@ -19369,7 +19787,11 @@ class SignalClient {
           });
         }
       } catch (e) {
-        return e instanceof ConnectionError ? e : ConnectionError.serverUnreachable(e instanceof Error ? e.message : 'server was not reachable');
+        if (e instanceof ConnectionError) {
+          return e;
+        } else {
+          return ConnectionError.serverUnreachable(e instanceof Error ? e.message : 'server was not reachable');
+        }
       }
     });
   }
@@ -19432,6 +19854,12 @@ function createConnectionParams(token, info, opts) {
   if (opts.adaptiveStream) {
     params.set('adaptive_stream', '1');
   }
+  if (opts.disableIceLite) {
+    params.set('disable_ice_lite', '1');
+  }
+  if (typeof opts.subscriberAllowPause !== 'undefined') {
+    params.set('subscriber_allow_pause', opts.subscriberAllowPause ? '1' : '0');
+  }
   if (opts.reconnectReason) {
     params.set('reconnect_reason', opts.reconnectReason.toString());
   }
@@ -19450,7 +19878,9 @@ function createJoinRequestConnectionParams(token, info, opts, publisherOffer) {
       clientInfo: info,
       connectionSettings: new ConnectionSettings({
         autoSubscribe: !!opts.autoSubscribe,
-        adaptiveStream: !!opts.adaptiveStream
+        adaptiveStream: !!opts.adaptiveStream,
+        disableIceLite: !!opts.disableIceLite,
+        subscriberAllowPause: opts.subscriberAllowPause
       }),
       reconnect: !!opts.reconnect,
       participantSid: opts.sid ? opts.sid : undefined,
@@ -20287,68 +20717,206 @@ function requireLib() {
  * 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.
+ * The cap is lowered further for connections that were slow to set up, see
+ * `computeStartBitrateCap`, or that the browser reports as slow, see
+ * `connectionEffectiveTypeStartBitrateCap`.
  */
 const startBitrateMultiplier = 0.9;
 /** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
 const maxStartBitrateKbps = 1000;
+/**
+ * Minimum x-google-start-bitrate in kbps: libwebrtc's own default starting estimate. A target
+ * below this gets no hint, since seeding above the real capacity costs more than the ramp it
+ * saves, and a slow connection is seeded no higher than this.
+ */
+const minTargetBitrateKbps = 300;
+/**
+ * Connection setup times (ms) bounding the ramp in `computeStartBitrateCap`: at or below the
+ * first the hint is capped at `maxStartBitrateKbps`, at or above the second at
+ * `minTargetBitrateKbps`. Measured on shaped links (CLT-3380): healthy links set up in under
+ * 860 ms, a 1 Mbps link with 150 ms RTT took 1.1–1.7 s, a 500 kbps link ~2.3 s at the median,
+ * and a 300 kbps link never under 3 s. The first sits above the 1 Mbps link, which a lower seed
+ * only slows down, and the second above the 500 kbps link's median, so only links that cannot
+ * carry more land at the floor.
+ */
+const setupTimeForMaxStartBitrateMs = 1500;
+const setupTimeForMinStartBitrateMs = 3500;
+/** Cap on the start bitrate hint, in kbps, when the browser reports a `3g` connection. */
+const effectiveType3gStartBitrateKbps = 500;
 const debounceInterval = 20;
 /**
- * Applies the configured start bitrate when this media section belongs to `cid`.
- * This SDP munging is used for a bitrate setting that cannot be applied through
- * `RTCRtpEncodingParameters`.
+ * Codec payload for `codec` in this media section, when the section carries `cid`.
  *
- * Returns `undefined` when the section does not belong to the track, `0` when
- * it does but does not offer the requested codec, and the codec payload when the
- * requested codec is present (whether the bitrate was added or already set).
+ * Returns `undefined` when the section does not belong to the track, `0` when it does but
+ * does not offer the requested codec, and the codec payload otherwise.
  *
  * @internal
  */
-function applyVideoStartBitrate(media, cid, codec, maxbr) {
-  let isScreenShare = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+function findTrackCodecPayload(media, cid, codec) {
   var _a, _b, _c;
   if (!((_a = media.msid) === null || _a === void 0 ? void 0 : _a.includes(cid))) {
     return undefined;
   }
-  const codecPayload = (_c = (_b = media.rtp.find(rtp => rtp.codec.toUpperCase() === codec.toUpperCase())) === null || _b === void 0 ? void 0 : _b.payload) !== null && _c !== void 0 ? _c : 0;
-  if (codecPayload === 0) {
-    return 0;
+  return (_c = (_b = media.rtp.find(rtp => rtp.codec.toUpperCase() === codec.toUpperCase())) === null || _b === void 0 ? void 0 : _b.payload) !== null && _c !== void 0 ? _c : 0;
+}
+/**
+ * Start bitrate hinted for a single track, or `undefined` when its target is too low to
+ * be worth seeding.
+ *
+ * 90% of the target leaves ~10% headroom for the estimator to settle. The same multiplier
+ * is used for every codec because the target already reflects the codec's efficiency.
+ * Camera is capped at 1 Mbps so the estimator does not open too aggressively on a
+ * high-bitrate track; screen share is exempt, because its content needs the bitrate
+ * immediately to stay legible.
+ *
+ * The cap is lowered for a connection that was slow to set up (`computeStartBitrateCap`), and
+ * for one the browser reports as slow (`connectionEffectiveTypeStartBitrateCap`), whichever is
+ * lower. Screen share is exempt from both, however slow the connection.
+ *
+ * @internal
+ */
+function computeTrackStartBitrate(trackbr, connectionSetupTimeMs) {
+  if (trackbr.maxbr < minTargetBitrateKbps) {
+    return undefined;
   }
-  // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE
-  // from starting too aggressively. Screen share is not capped since text/UI
-  // clarity requires high bitrate from the start.
-  // TODO: dynamically adjust start bitrate based on network conditions (e.g., previous BWE estimate)
-  const calculatedStartBitrate = Math.round(maxbr * startBitrateMultiplier);
-  const startBitrate = isScreenShare ? calculatedStartBitrate : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
-  const fmtp = media.fmtp.find(entry => entry.payload === codecPayload);
-  if (fmtp) {
-    // If another track's fmtp already has a start bitrate, it cannot be
-    // overridden here because the payload type is shared across the bundle.
-    // This forces every track sharing that payload to use the initial track's
-    // start bitrate.
-    if (!fmtp.config.includes('x-google-start-bitrate')) {
-      fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
-    }
-  } else {
-    // VP8 and some codecs may not have an existing fmtp line.
-    media.fmtp.push({
-      payload: codecPayload,
-      config: "x-google-start-bitrate=".concat(startBitrate)
-    });
+  const calculated = Math.min(Math.round(trackbr.maxbr * startBitrateMultiplier), trackbr.maxbr);
+  if (trackbr.isScreenShare) {
+    return calculated;
   }
-  return codecPayload;
+  const cap = Math.min(computeStartBitrateCap(connectionSetupTimeMs), connectionEffectiveTypeStartBitrateCap());
+  return Math.min(calculated, cap);
 }
-const PCEvents = {
-  NegotiationStarted: 'negotiationStarted',
-  NegotiationComplete: 'negotiationComplete',
-  // Fired with the offerId for every successful publisher answer application,
-  // including answers that immediately recurse into another offer via
-  // `renegotiate`. Use this rather than NegotiationComplete to know that a
-  // specific offer has been negotiated end-to-end.
-  OfferAnswered: 'offerAnswered',
-  RTPVideoPayloadTypes: 'rtpVideoPayloadTypes'
-};
-/** @internal */
-class PCTransport extends eventsExports.EventEmitter {
+/**
+ * Cap on the start bitrate hint, in kbps, from the browser's effective connection type
+ * (`navigator.connection.effectiveType`, Chromium only): `slow-2g` and `2g` cap at
+ * `minTargetBitrateKbps`, `3g` at `effectiveType3gStartBitrateKbps`.
+ *
+ * It catches links that have low bandwidth but low latency, which set up quickly and so slip
+ * past the setup time ramp. `4g`, and browsers without the API, give no guidance and stay at the
+ * `maxStartBitrateKbps` ceiling, as `computeStartBitrateCap` does without a setup time. The
+ * connection RTT the API also reports is not used: it lags behind network changes, and the setup
+ * time already reflects latency.
+ */
+function connectionEffectiveTypeStartBitrateCap() {
+  // A `typeof` guard, since `globalThis` is missing from some supported browsers (Chrome < 71,
+  // Firefox < 65, Safari < 12.1) and the build does not polyfill it.
+  const connection = typeof navigator !== 'undefined' ? navigator.connection : undefined;
+  switch (connection === null || connection === void 0 ? void 0 : connection.effectiveType) {
+    case 'slow-2g':
+    case '2g':
+      return minTargetBitrateKbps;
+    case '3g':
+      return effectiveType3gStartBitrateKbps;
+    default:
+      return maxStartBitrateKbps;
+  }
+}
+/**
+ * Cap on the start bitrate hint, in kbps, from how long the connection took to set up.
+ *
+ * Connection setup time (signaling join plus ICE/DTLS) is the network signal every platform has
+ * before the first video offer, since libwebrtc cannot probe the path until a video sender
+ * exists. It grows with round-trip time and loss, which also mark the links where a 1 Mbps
+ * seed overshoots, so the cap ramps linearly from `maxStartBitrateKbps` at
+ * `setupTimeForMaxStartBitrateMs` down to `minTargetBitrateKbps` at
+ * `setupTimeForMinStartBitrateMs`. A video offer built while the connection is still being set
+ * up (publishing during connect) passes the time elapsed so far, a lower bound on the setup time.
+ * Without any timing the cap stays at the 1 Mbps ceiling.
+ */
+function computeStartBitrateCap(connectionSetupTimeMs) {
+  if (connectionSetupTimeMs === undefined) {
+    return maxStartBitrateKbps;
+  }
+  const ramp = Math.min(Math.max((connectionSetupTimeMs - setupTimeForMaxStartBitrateMs) / (setupTimeForMinStartBitrateMs - setupTimeForMaxStartBitrateMs), 0), 1);
+  return Math.round(maxStartBitrateKbps - ramp * (maxStartBitrateKbps - minTargetBitrateKbps));
+}
+/**
+ * The single start bitrate for this peer connection: the largest hint among the video
+ * m-sections of `media` that map to a published track.
+ *
+ * libwebrtc reads `x-google-start-bitrate` per m-section but applies it to the shared
+ * `Call` (`WebRtcVideoSendChannel::ApplyChangedParams` -> `SetSdpBitrateParameters`), where
+ * `RtpBitrateConfigurator` holds one config for the whole connection. Differing per-section
+ * values are therefore last-writer-wins, decided by m-section order, so every video section
+ * gets the same number instead.
+ *
+ * Only sections that can send local media are considered. `trackBitrates` is append-only and an
+ * unpublished section keeps its `a=msid`, so matching on msid alone would still pair a stale
+ * entry with its old section — letting an uncapped screen-share target seed a connection that
+ * now carries only a camera, or consuming the one-shot hint on a section that sends nothing.
+ *
+ * The direction is the discriminator, as an exclusion rather than a match: `recvonly` and
+ * `inactive` are the only directions that cannot carry local media, and they are exactly the
+ * two a dead section lands on — unpublish sets `inactive` (explicitly in
+ * `LocalParticipant.unpublishTrack`, and via `removeTrack`'s sendonly -> inactive transition for
+ * the simulcast senders), `removeTrack` on a `sendrecv` transceiver leaves `recvonly`, and the
+ * pre-populated placeholders are `recvonly`. Everything else sends: `sendonly` from the
+ * `addTransceiver` path, `sendrecv` from the legacy `addTrack` fallback (which reuses a
+ * transceiver rather than creating a sendonly one), and a section with no direction attribute,
+ * which SDP defaults to `sendrecv`.
+ *
+ * @internal
+ */
+function computeConnectionStartBitrate(media, trackBitrates, connectionSetupTimeMs) {
+  let connectionStartBitrate;
+  for (const m of media) {
+    if (m.type !== 'video' || m.direction === 'recvonly' || m.direction === 'inactive') {
+      continue;
+    }
+    for (const trackbr of trackBitrates) {
+      if (!trackbr.cid) {
+        continue;
+      }
+      const codecPayload = findTrackCodecPayload(m, trackbr.cid, trackbr.codec);
+      if (codecPayload === undefined) {
+        continue;
+      }
+      const startBitrate = codecPayload > 0 ? computeTrackStartBitrate(trackbr, connectionSetupTimeMs) : undefined;
+      if (startBitrate !== undefined && (connectionStartBitrate === undefined || startBitrate > connectionStartBitrate)) {
+        connectionStartBitrate = startBitrate;
+      }
+      break;
+    }
+  }
+  return connectionStartBitrate;
+}
+/**
+ * Declares `x-google-start-bitrate` on `codecPayload`'s fmtp. This SDP munging is used for
+ * a bitrate setting that cannot be applied through `RTCRtpEncodingParameters`.
+ *
+ * Returns whether the section now carries the hint.
+ *
+ * @internal
+ */
+function applyVideoStartBitrate(media, codecPayload, startBitrate) {
+  const fmtp = media.fmtp.find(entry => entry.payload === codecPayload);
+  if (fmtp) {
+    // A payload type is shared across the bundle, so a value written for one section is
+    // already the connection-level one; leave it rather than rewrite it.
+    if (!fmtp.config.includes('x-google-start-bitrate')) {
+      fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
+    }
+  } else {
+    // VP8 and some codecs may not have an existing fmtp line.
+    media.fmtp.push({
+      payload: codecPayload,
+      config: "x-google-start-bitrate=".concat(startBitrate)
+    });
+  }
+  return true;
+}
+const PCEvents = {
+  NegotiationStarted: 'negotiationStarted',
+  NegotiationComplete: 'negotiationComplete',
+  // Fired with the offerId for every successful publisher answer application,
+  // including answers that immediately recurse into another offer via
+  // `renegotiate`. Use this rather than NegotiationComplete to know that a
+  // specific offer has been negotiated end-to-end.
+  OfferAnswered: 'offerAnswered',
+  RTPVideoPayloadTypes: 'rtpVideoPayloadTypes'
+};
+/** @internal */
+class PCTransport extends eventsExports.EventEmitter {
   get pc() {
     if (!this._pc) {
       this._pc = this.createPC();
@@ -20363,11 +20931,20 @@ class PCTransport extends eventsExports.EventEmitter {
     this.iceLog = livekitLogger;
     this.ddExtID = 0;
     this.latestOfferId = 0;
+    this.answeredOfferId = 0;
     this.latestAcknowledgedOfferId = 0;
     this.pendingCandidates = [];
     this.restartingIce = false;
     this.renegotiate = false;
     this.trackBitrates = [];
+    /**
+     * Whether an offer carrying the connection-level `x-google-start-bitrate` has been
+     * accepted locally. The hint is written once per peer connection: libwebrtc retains
+     * `start_bitrate_bps` in `RtpBitrateConfigurator` and re-applies it on network route
+     * changes, so a later rewrite is at best a no-op and at worst restarts a converged
+     * bandwidth estimator. A new peer connection (full reconnect) seeds a new estimator.
+     */
+    this.hasAppliedVideoStartBitrate = false;
     this.remoteStereoMids = [];
     this.remoteNackMids = [];
     // debounced negotiate interface
@@ -20476,7 +21053,7 @@ class PCTransport extends eventsExports.EventEmitter {
   }
   setRemoteDescription(sd, offerId) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
+      var _a;
       if (sd.type === 'answer' && this.latestOfferId > 0 && offerId > 0 && offerId !== this.latestOfferId) {
         this.log.warn('ignoring answer for old offer', {
           offerId,
@@ -20484,6 +21061,29 @@ class PCTransport extends eventsExports.EventEmitter {
         });
         return false;
       }
+      if (sd.type === 'answer') {
+        if (isDuplicateAnswer(offerId, this.answerInFlight, this.answeredOfferId, (_a = this._pc) === null || _a === void 0 ? void 0 : _a.signalingState, this.pendingInitialOffer !== undefined)) {
+          // a repeat of an answer already applied or being applied (e.g.
+          // duplicated by a proxy): there is no local offer left to answer
+          this.log.warn('ignoring duplicate answer', {
+            offerId
+          });
+          return false;
+        }
+        // claimed before any await, so a copy arriving mid-apply is caught too;
+        // released however the apply ends, so a genuine retry is still possible
+        this.answerInFlight = offerId;
+      }
+      try {
+        return yield this.applyRemoteDescription(sd, offerId);
+      } finally {
+        if (sd.type === 'answer') this.answerInFlight = undefined;
+      }
+    });
+  }
+  applyRemoteDescription(sd, offerId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b;
       let mungedSDP = undefined;
       if (sd.type === 'offer') {
         let _extractStereoAndNack = extractStereoAndNackAudioFromOffer(sd),
@@ -20557,6 +21157,8 @@ class PCTransport extends eventsExports.EventEmitter {
         mungedSDP = libExports.write(sdpParsed);
       }
       yield this.setMungedSDP(sd, mungedSDP, true);
+      // only a successfully applied answer makes later copies duplicates
+      if (sd.type === 'answer' && offerId > 0) this.answeredOfferId = offerId;
       if (this.pendingCandidates.length > 0) {
         this.iceLog.debug('flushing queued ICE candidates', {
           count: this.pendingCandidates.length
@@ -20664,6 +21266,12 @@ class PCTransport extends eventsExports.EventEmitter {
           sdp: offer.sdp
         });
         const sdpParsed = libExports.parse((_a = offer.sdp) !== null && _a !== void 0 ? _a : '');
+        // One value for every video m-section, written only on the first offer that carries
+        // local video: the hint is connection-level in libwebrtc, so differing per-section
+        // values would be last-writer-wins on m-section order. Offers before any video is
+        // published (data channel or audio only) find no target and leave the latch unset.
+        const connectionStartBitrate = this.hasAppliedVideoStartBitrate ? undefined : computeConnectionStartBitrate(sdpParsed.media, this.trackBitrates, this.connectionSetupTimeEstimateMs());
+        let appliedVideoStartBitrate = false;
         sdpParsed.media.forEach(media => {
           ensureIPAddrMatchVersion(media);
           if (media.type === 'audio') {
@@ -20673,12 +21281,17 @@ class PCTransport extends eventsExports.EventEmitter {
               if (!trackbr.cid) {
                 return false;
               }
-              const codecPayload = applyVideoStartBitrate(media, trackbr.cid, trackbr.codec, trackbr.maxbr, trackbr.isScreenShare);
+              const codecPayload = findTrackCodecPayload(media, trackbr.cid, trackbr.codec);
               if (codecPayload === undefined) {
                 return false;
               }
-              if (codecPayload > 0 && isSVCCodec(trackbr.codec) && !isSafari()) {
-                this.ddExtID = ensureVideoDDExtension(media, sdpParsed, this.ddExtID);
+              if (codecPayload > 0) {
+                if (connectionStartBitrate !== undefined) {
+                  appliedVideoStartBitrate = applyVideoStartBitrate(media, codecPayload, connectionStartBitrate) || appliedVideoStartBitrate;
+                }
+                if (isSVCCodec(trackbr.codec) && !isSafari()) {
+                  this.ddExtID = ensureVideoDDExtension(media, sdpParsed, this.ddExtID);
+                }
               }
               return true;
             });
@@ -20700,7 +21313,17 @@ class PCTransport extends eventsExports.EventEmitter {
           });
           return;
         }
-        yield this.setMungedSDP(offer, libExports.write(sdpParsed));
+        const mungedSdp = libExports.write(sdpParsed);
+        yield this.setMungedSDP(offer, mungedSdp);
+        // setMungedSDP falls back to the unmunged SDP on rejection. Only consume the
+        // one-shot hint once the SDP carrying it has been accepted locally.
+        if (appliedVideoStartBitrate && offer.sdp === mungedSdp) {
+          this.hasAppliedVideoStartBitrate = true;
+          this.log.info('applied x-google-start-bitrate', {
+            startBitrateKbps: connectionStartBitrate,
+            connectionSetupTimeMs: this.connectionSetupTimeEstimateMs()
+          });
+        }
         this.onOffer(offer, this.latestOfferId);
       } finally {
         unlock();
@@ -20751,6 +21374,27 @@ class PCTransport extends eventsExports.EventEmitter {
   setTrackCodecBitrate(info) {
     this.trackBitrates.push(info);
   }
+  /**
+   * Record how long this peer connection took to set up. Called once, when the initial connect
+   * succeeds; resumes and ICE restarts keep the estimator they have and never call this.
+   */
+  setConnectionSetupTime(ms) {
+    this.connectionSetupTimeMs = ms;
+  }
+  /** Record when the connection attempt that built this peer connection began. */
+  setConnectionStartedAt(startedAt) {
+    this.connectionStartedAt = startedAt;
+  }
+  /** The measured setup time, or while still connecting, the time elapsed so far. */
+  connectionSetupTimeEstimateMs() {
+    if (this.connectionSetupTimeMs !== undefined) {
+      return this.connectionSetupTimeMs;
+    }
+    if (this.connectionStartedAt === undefined) {
+      return undefined;
+    }
+    return Math.round(performance.now() - this.connectionStartedAt);
+  }
   setConfiguration(rtcConfig) {
     var _a;
     if (!this._pc) {
@@ -21096,6 +21740,19 @@ function conformBundledCodecFmtp(media, isPlaceholder) {
   }
 }
 /** @internal */
+/**
+ * Whether an incoming answer repeats one already applied or being applied.
+ * Any answer for the offer whose answer is in flight is a duplicate, numbered
+ * or not. With an offerId (current servers) an answer is also a duplicate if
+ * that offer's answer was already applied. Without one, fall back to the
+ * signaling state: in `stable` no local offer is pending, unless the initial
+ * offer is still deferred (it is set locally only once its answer arrives).
+ */
+function isDuplicateAnswer(offerId, answerInFlight, answeredOfferId, signalingState, hasPendingInitialOffer) {
+  if (answerInFlight === offerId) return true;
+  if (offerId > 0) return offerId === answeredOfferId;
+  return signalingState === 'stable' && !hasPendingInitialOffer;
+}
 function extractStereoAndNackAudioFromOffer(offer) {
   var _a;
   const stereoMids = [];
@@ -21187,6 +21844,7 @@ const roomOptionDefaults = {
 };
 const roomConnectOptionDefaults = {
   autoSubscribe: true,
+  disableIceLite: false,
   maxRetries: 1,
   peerConnectionTimeout: 15000,
   websocketTimeout: 15000
@@ -21400,7 +22058,9 @@ class PCTransportManager {
       try {
         if (this.isPublisherConnectionRequired && this.publisher.getConnectionState() !== 'connected' && this.publisher.getConnectionState() !== 'connecting') {
           this.log.debug('negotiation required, start negotiating');
-          this.publisher.negotiate();
+          this.publisher.negotiate().catch(err => {
+            this.log.error(err);
+          });
         }
         yield Promise.all((_a = this.requiredTransports) === null || _a === void 0 ? void 0 : _a.map(transport => this.ensureTransportConnected(transport, abortController, timeout)));
       } finally {
@@ -21551,7 +22211,8 @@ class PCTransportManager {
  * 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.
+ * gets a fresh controller. {@link attach} and {@link detach} do this, and close the released
+ * handle, as part of handle turnover.
  */
 class FlowControlledDataChannel {
   constructor(opts) {
@@ -21571,25 +22232,38 @@ class FlowControlledDataChannel {
     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.
+   * Attaches the channel handle this wrapper controls. Replacing an existing handle closes it and
+   * rejects parked waiters — their events would never fire again on the abandoned object — and
+   * installs a fresh controller. Wrappers outlive their handles: this is the one place handle
+   * turnover happens, so a handle the wrapper lets go of is never left open, and stranding a
+   * waiter is structurally impossible.
    */
   attach(dc) {
-    if (this.handle && this.handle !== dc) {
-      this.invalidateWaiters('data channel replaced');
-    }
+    const old = this.handle;
     this.handle = dc;
+    if (old && old !== dc) {
+      this.release(old, 'data channel replaced');
+    }
   }
-  /** Detaches the handle on teardown, rejecting parked waiters. */
+  /** Detaches and closes 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);
-    }
+    const old = this.handle;
     this.handle = undefined;
+    if (old) {
+      this.release(old, reason);
+    }
+  }
+  /**
+   * Closes a handle the wrapper no longer controls. `close()` moves it to `closing` synchronously,
+   * so senders still holding it (queued on the headroom lock) fail the open check once they get
+   * the lock. Parked waiters are aborted directly instead of relying on the `close` event, which
+   * fires asynchronously, if at all (the spec lets `pc.close()` skip it). Strip any handlers that
+   * must not observe the close before calling this.
+   */
+  release(dc, reason) {
+    this.invalidateWaiters(reason);
+    dc.close();
   }
   getChannel() {
     return this.handle;
@@ -21620,32 +22294,35 @@ class FlowControlledDataChannel {
     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
+   * Resolves once the caller may send on `dc`: immediately while its send buffer is at or below
+   * the 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.
+   * checks run inside the lock so queued callers proceed in FIFO order.
+   *
+   * The caller passes the handle it resolved before queueing, and the wait is against that one
+   * handle throughout: if it was replaced meanwhile, it has been closed, so the wait rejects
+   * rather than letting the caller send on the replacement out of turn.
    */
-  waitForHeadroomWithLock() {
+  waitForHeadroomWithLock(dc) {
     return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.lockHeadroom();
       try {
-        yield this.waitForHeadroomWithoutLock();
+        yield this.waitForHeadroomWithoutLock(dc);
       } finally {
         unlock();
       }
     });
   }
   /** Core wait of {@link waitForHeadroomWithLock}. The caller must hold the headroom lock. */
-  waitForHeadroomWithoutLock() {
+  waitForHeadroomWithoutLock(dc) {
     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 (dc.readyState !== 'open') {
+        throw new UnexpectedConnectionState("DataChannel ".concat(this.kind, " is ").concat(dc.readyState));
       }
       if (this.isBelowHighWaterMark(dc)) {
         return;
@@ -21735,7 +22412,16 @@ class LossyDataChannel extends FlowControlledDataChannel {
       switch (this.bufferFullBehavior) {
         case 'wait':
           if (!this.isBelowHighWaterMark(dc)) {
-            yield this.waitForHeadroomWithLock();
+            try {
+              yield this.waitForHeadroomWithLock(dc);
+            } catch (error) {
+              if (this.isEngineClosed()) {
+                throw error;
+              }
+              // The channel closed or was replaced while this send waited. The replacement may
+              // still be connecting, so drop the packet, as sends during a reconnect are.
+              return;
+            }
           }
           break;
         case 'drop':
@@ -21917,7 +22603,7 @@ class ReliableDataChannel extends FlowControlledDataChannel {
         return;
       }
       try {
-        yield this.waitForHeadroomWithLock();
+        yield this.waitForHeadroomWithLock(dc);
       } catch (error) {
         if (this.isEngineClosed()) {
           // No replay is coming after an engine close — surface the failure.
@@ -21925,7 +22611,9 @@ class ReliableDataChannel extends FlowControlledDataChannel {
         }
         // 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.
+        // rejecting a send the app can't meaningfully retry. This also keeps the order: a send
+        // queued behind one aborted by a replacement fails the same way (the old handle is closed),
+        // so it can't reach the replacement ahead of the lower sequence the replay will deliver.
         this.messageBuffer.push({
           data: msg,
           sequence,
@@ -21960,13 +22648,18 @@ class ReliableDataChannel extends FlowControlledDataChannel {
    */
   replay(lastMessageSeq) {
     return __awaiter(this, void 0, void 0, function* () {
-      const dc = this.getChannel();
-      if (!dc) {
+      if (!this.getChannel()) {
         return;
       }
       this.messageBuffer.popToSequence(lastMessageSeq);
       const unlock = yield this.lockHeadroom();
       try {
+        // Resolved only once the lock is held: the handle can be replaced while the replay waits
+        // for it.
+        const dc = this.getChannel();
+        if (!dc) {
+          throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(this.kind));
+        }
         // 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,
@@ -21978,7 +22671,10 @@ class ReliableDataChannel extends FlowControlledDataChannel {
         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();
+            // Against the handle resolved under the lock: if it is replaced mid-replay (another
+            // resume), it has been closed, so this throws and that resume's replay picks up the
+            // entries still flagged unsent.
+            yield this.waitForHeadroomWithoutLock(dc);
             dc.send(item.data);
             this.messageBuffer.markSent(item);
           }
@@ -22033,13 +22729,23 @@ function dataChannelHighWaterMark(kind) {
 }const lossyDataChannelLabel = '_lossy';
 const reliableDataChannelLabel = '_reliable';
 const dataTrackDataChannelLabel = '_data_track';
+/** Unhooks every handler the manager may have wired onto `dc`, ahead of closing it. */
+function clearHandlers(dc) {
+  dc.onbufferedamountlow = null;
+  dc.onclose = null;
+  dc.onclosing = null;
+  dc.onerror = null;
+  dc.onmessage = null;
+  dc.onopen = null;
+}
 /**
  * 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.
+ * Handle turnover goes through {@link FlowControlledDataChannel.attach}/`detach`, which close the
+ * released handle and reject parked headroom waiters as a built-in — there is no separate
+ * invalidation step to forget.
  */
 class DataChannelManager {
   constructor(opts) {
@@ -22097,17 +22803,16 @@ class DataChannelManager {
   }
   /**
    * 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.
+   * attaches them to the wrappers — attaching closes any replaced channel objects and rejects the
+   * waiters still parked on them.
    */
   createPublisherChannels(pcManager) {
-    // clear old data channel callbacks if recreate
+    // Recreating (the Safari null-id path): attaching the new handles below closes the old ones,
+    // so unhook them first — the old channel's close must not report an unexpected close.
     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;
+        clearHandlers(old);
       }
     }
     const wire = (channel, dc, onMessage) => {
@@ -22158,38 +22863,35 @@ class DataChannelManager {
     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.
+   * Tears down all channels for a peer-connection cleanup: strips handlers, closes the handles,
+   * and resets the reliable session state. Detaching the publisher handles closes them and
+   * rejects parked waiters (the spec allows `pc.close()` to transition channels to 'closed'
+   * without firing events, so waiting for browser close events is not an option).
    */
   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]) {
+    // 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.
+    const publisherDataChannels = [this.lossy, this.reliable, this.dataTrack];
+    const subscriberDataChannels = [this.lossySub, this.reliableSub, this.dataTrackSub];
+    // Publisher handles are closed by detach, which also rejects parked waiters.
+    for (const channel of publisherDataChannels) {
       const dc = channel.channelHandle;
+      if (dc) {
+        clearHandlers(dc);
+      }
       channel.detach('peer connections cleaned up');
-      dcCleanup(dc);
     }
-    dcCleanup(this.lossySub);
-    dcCleanup(this.reliableSub);
-    dcCleanup(this.dataTrackSub);
+    // Subscriber handles have no wrapper, so close them directly.
+    for (const dc of subscriberDataChannels) {
+      if (dc) {
+        clearHandlers(dc);
+        dc.close();
+      }
+    }
     this.lossySub = undefined;
     this.reliableSub = undefined;
     this.dataTrackSub = undefined;
@@ -22351,6 +23053,9 @@ class LocalTrack extends Track {
   get isUserProvided() {
     return this.providedByUser;
   }
+  get isStopped() {
+    return this.manuallyStopped;
+  }
   get mediaStreamTrack() {
     var _a, _b;
     return (_b = (_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack) !== null && _b !== void 0 ? _b : this._mediaStreamTrack;
@@ -22408,6 +23113,9 @@ class LocalTrack extends Track {
           track: newTrack,
           kind: this.kind,
           element: this.processorElement,
+          // audio processors need the context they were initialised with in order to rebuild
+          // their graph, omitting it here would leave them without one
+          audioContext: this.audioContext,
           localTrack: this
         });
         processedTrack = this.processor.processedTrack;
@@ -22431,6 +23139,18 @@ class LocalTrack extends Track {
           attachToElement(processedTrack !== null && processedTrack !== void 0 ? processedTrack : newTrack, el);
         });
       }
+      yield this.onMediaStreamTrackChanged();
+    });
+  }
+  /**
+   * Hook invoked after the underlying MediaStreamTrack has been swapped and the processor has
+   * been restarted around it, so `processor.processedTrack` already holds the new track.
+   * Unlike `onSenderTrackSwapped` this also fires on the restart and unmute paths.
+   */
+  onMediaStreamTrackChanged() {
+    return __awaiter(this, void 0, void 0, function* () {
+      // base implementation is a no-op; LocalAudioTrack overrides this to move the krisp
+      // feature listeners onto the new processed track.
     });
   }
   waitForDimensions() {
@@ -22438,21 +23158,29 @@ class LocalTrack extends Track {
       var _this = this;
       let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_DIMENSIONS_TIMEOUT;
       return function* () {
-        var _a;
         if (_this.kind === Track.Kind.Audio) {
           throw new Error('cannot get dimensions for audio tracks');
         }
-        if (((_a = getBrowser()) === null || _a === void 0 ? void 0 : _a.os) === 'iOS') {
-          // browsers report wrong initial resolution on iOS.
-          // when slightly delaying the call to .getSettings(), the correct resolution is being reported
-          yield sleep(10);
-        }
         const started = Date.now();
-        while (Date.now() - started < timeout) {
+        if (isAppleMobile()) {
+          // iOS and iPadOS keep reporting the camera's sensor frame from getSettings() until the
+          // camera has delivered its first picture, so a portrait capture initially reads as
+          // landscape. Wait for that first frame instead of guessing at a delay.
+          // Gated to the Apple capture pipeline rather than run everywhere: elsewhere getSettings() is
+          // already right and the first frame can be hundreds of milliseconds out (measured ~500ms on
+          // macOS Safari), which would be pure added publish latency.
+          // https://github.com/livekit/client-sdk-js/issues/2099
+          // https://github.com/livekit/client-sdk-js/issues/2107
+          yield waitForFirstVideoFrame(_this._mediaStreamTrack, timeout, _this.attachedElements);
+        }
+        while (true) {
           const dims = _this.dimensions;
           if (dims) {
             return dims;
           }
+          if (Date.now() - started >= timeout) {
+            break;
+          }
           yield sleep(50);
         }
         throw new TrackInvalidError('unable to get track dimensions after timeout');
@@ -22461,7 +23189,7 @@ class LocalTrack extends Track {
   }
   setDeviceId(deviceId) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
+      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId) && this._mediaStreamTrack.readyState === 'live') {
         return true;
       }
       this._constraints.deviceId = deviceId;
@@ -22589,24 +23317,40 @@ class LocalTrack extends Track {
         // 'A MediaStreamTrack ended due to a capture failure`
         this._mediaStreamTrack.stop();
         // create new track and attach
-        const mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
+        let mediaStream;
+        try {
+          mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
+        } catch (e) {
+          markDeviceAcquisitionFailure(e);
+          throw e;
+        }
         const newTrack = mediaStream.getTracks()[0];
-        if (this.kind === Track.Kind.Video) {
-          // we already captured the audio track with the constraints, so we only need to apply the video constraints
-          yield newTrack.applyConstraints(otherConstraints);
+        try {
+          if (this.kind === Track.Kind.Video) {
+            // we already captured the audio track with the constraints, so we only need to apply the video constraints
+            yield newTrack.applyConstraints(otherConstraints);
+          }
+          newTrack.addEventListener('ended', this.handleEnded);
+          this.log.debug('re-acquired MediaStreamTrack', this.logContext);
+          yield this.setMediaStreamTrack(newTrack, false, isUnmuting);
+        } catch (e) {
+          // setMediaStreamTrack can throw after acquisition but before it adopts the new track,
+          // which would leave the capture device live with nothing referencing it
+          if (this._mediaStreamTrack !== newTrack) {
+            newTrack.stop();
+          }
+          throw e;
         }
-        newTrack.addEventListener('ended', this.handleEnded);
-        this.log.debug('re-acquired MediaStreamTrack', this.logContext);
-        yield this.setMediaStreamTrack(newTrack, false, isUnmuting);
         this._constraints = constraints;
         this.pendingDeviceChange = false;
         this.emit(TrackEvent.Restarted, this);
+        return this;
+      } finally {
+        // in the finally because a throw can also leave the new track adopted, and so still live
         if (this.manuallyStopped) {
           this.log.warn('track was stopped during a restart, stopping restarted track', this.logContext);
           this.stop();
         }
-        return this;
-      } finally {
         unlock();
       }
     });
@@ -22647,7 +23391,13 @@ class LocalTrack extends Track {
     this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
     this._mediaStreamTrack.removeEventListener('mute', this.handleTrackMuteEvent);
     this._mediaStreamTrack.removeEventListener('unmute', this.handleTrackUnmuteEvent);
-    (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy();
+    // `stop` is synchronous, so we can't await the teardown of the processor here.
+    // make sure a failing teardown doesn't surface as an unhandled rejection.
+    (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy().catch(error => {
+      this.log.error('failed to destroy processor', Object.assign(Object.assign({}, this.logContext), {
+        error
+      }));
+    });
     this.processor = undefined;
   }
   /**
@@ -22726,6 +23476,11 @@ class LocalTrack extends Track {
    * Sets a processor on this track.
    * See https://github.com/livekit/track-processors-js for example usage
    *
+   * The processor lives on the track, so stopping the track destroys it. Unpublishing and
+   * disconnecting both stop the track by default, which means a processor has to be set again on
+   * the track published after a reconnect. See {@link TrackProcessor} for the full lifecycle,
+   * including what `stopLocalTrackOnUnpublish: false` changes.
+   *
    * @param processor
    * @param showProcessedStreamLocally
    * @returns
@@ -22795,6 +23550,10 @@ class LocalTrack extends Track {
       }();
     });
   }
+  /**
+   * Returns the processor currently set on this track, or `undefined` if there is none. A track
+   * that was stopped by an unpublish or a disconnect has none. See {@link TrackProcessor}.
+   */
   getProcessor() {
     return this.processor;
   }
@@ -22802,6 +23561,8 @@ class LocalTrack extends Track {
    * Stops the track processor
    * See https://github.com/livekit/track-processors-js for example usage
    *
+   * Only needed to remove a processor from a track that stays published. Unpublishing or
+   * disconnecting already destroys it. See {@link TrackProcessor}.
    */
   stopProcessor() {
     return __awaiter(this, arguments, void 0, function () {
@@ -23042,6 +23803,38 @@ class LocalTrack extends Track {
       this.monitorSender();
     }, monitorFrequency);
   }
+  /**
+   * registers the krisp feature listeners on the given processed track, moving them over from
+   * a previously observed one. Passing `undefined` just removes the existing listeners.
+   */
+  observeProcessedTrack(processedTrack) {
+    if (this.observedProcessedTrack === processedTrack) {
+      return;
+    }
+    if (this.observedProcessedTrack) {
+      this.observedProcessedTrack.removeEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
+      this.observedProcessedTrack.removeEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+      this.observedProcessedTrack = undefined;
+      if (this.isKrispNoiseFilterEnabled) {
+        // we're no longer observing the track that had the filter enabled, so the feature
+        // can't be active anymore. Make sure the state doesn't get stuck on `true`.
+        this.handleKrispNoiseFilterDisable();
+      }
+    }
+    if (!processedTrack) {
+      return;
+    }
+    processedTrack.addEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
+    processedTrack.addEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+    this.observedProcessedTrack = processedTrack;
+  }
+  /**
+   * Sets a processor on this track.
+   *
+   * The processor is destroyed when the track is stopped, and also when the audio context goes
+   * away, so a disconnect ends it on both counts and it has to be set again after reconnecting.
+   * See {@link TrackProcessor} for the full lifecycle.
+   */
   setProcessor(processor) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
@@ -23065,8 +23858,7 @@ class LocalTrack extends Track {
         this.processor = processor;
         if (this.processor.processedTrack) {
           yield (_a = this.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(this.processor.processedTrack);
-          this.processor.processedTrack.addEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
-          this.processor.processedTrack.addEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+          this.observeProcessedTrack(this.processor.processedTrack);
         }
         this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
       } finally {
@@ -23074,12 +23866,73 @@ class LocalTrack extends Track {
       }
     });
   }
+  onMediaStreamTrackChanged() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      // the processor rebuilds its graph around the new track, so the krisp listeners have to
+      // follow it onto whatever it hands back
+      this.observeProcessedTrack((_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack);
+    });
+  }
+  internalStopProcessor() {
+    const _super = Object.create(null, {
+      internalStopProcessor: {
+        get: () => super.internalStopProcessor
+      }
+    });
+    return __awaiter(this, arguments, void 0, function () {
+      var _this = this;
+      let keepElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return function* () {
+        _this.observeProcessedTrack(undefined);
+        yield _super.internalStopProcessor.call(_this, keepElement);
+      }();
+    });
+  }
+  stop() {
+    this.observeProcessedTrack(undefined);
+    super.stop();
+  }
   /**
    * @internal
    * @experimental
+   *
+   * A processor's nodes (`AudioWorkletNode`, ...) can't move between contexts, so the processor
+   * is rebuilt whenever the context changes and torn down when there is none left to run in.
    */
   setAudioContext(audioContext) {
-    this.audioContext = audioContext;
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      if (this.audioContext === audioContext) {
+        return;
+      }
+      const unlock = yield this.trackChangeLock.lock();
+      try {
+        this.audioContext = audioContext;
+        if (!this.processor || isReactNative()) {
+          return;
+        }
+        if (!audioContext) {
+          this.log.debug('stopping audio processor, audio context has been removed', this.logContext);
+          yield this.internalStopProcessor();
+          return;
+        }
+        this.log.debug('restarting audio processor on new audio context', this.logContext);
+        yield this.processor.restart({
+          kind: this.kind,
+          track: this._mediaStreamTrack,
+          audioContext,
+          localTrack: this
+        });
+        if (this.processor.processedTrack) {
+          yield (_a = this.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(this.processor.processedTrack);
+          this.observeProcessedTrack(this.processor.processedTrack);
+        }
+        this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
+      } finally {
+        unlock();
+      }
+    });
   }
   getSenderStats() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23155,24 +24008,6 @@ const computeDefaultScreenShareSimulcastPresets = fromPreset => {
     return new VideoPreset(Math.floor(fromPreset.width / t.scaleResolutionDownBy), Math.floor(fromPreset.height / t.scaleResolutionDownBy), Math.max(150000, Math.floor(fromPreset.encoding.maxBitrate / (Math.pow(t.scaleResolutionDownBy, 2) * (((_a = fromPreset.encoding.maxFramerate) !== null && _a !== void 0 ? _a : 30) / ((_b = t.fps) !== null && _b !== void 0 ? _b : 30))))), t.fps, fromPreset.encoding.priority);
   });
 };
-// /**
-//  *
-//  * @internal
-//  * @experimental
-//  */
-// const computeDefaultMultiCodecSimulcastEncodings = (width: number, height: number) => {
-//   // use vp8 as a default
-//   const vp8 = determineAppropriateEncoding(false, width, height);
-//   const vp9 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.9 };
-//   const h264 = { ...vp8, maxBitrate: vp8.maxBitrate * 1.1 };
-//   const av1 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.7 };
-//   return {
-//     vp8,
-//     vp9,
-//     h264,
-//     av1,
-//   };
-// };
 const videoRids = ['q', 'h', 'f'];
 /* @internal */
 function computeVideoEncodings(isScreenShare, width, height, options) {
@@ -23927,6 +24762,13 @@ class LocalVideoTrack extends LocalTrack {
       yield sender.setParameters(params);
     });
   }
+  /**
+   * Sets a processor on this track, and wires its processed track into the simulcast codecs.
+   *
+   * The processor is destroyed when the track is stopped, which unpublishing and disconnecting
+   * both do by default, so it has to be set again after reconnecting. See {@link TrackProcessor}
+   * for the full lifecycle.
+   */
   setProcessor(processor_1) {
     const _super = Object.create(null, {
       setProcessor: {
@@ -24027,12 +24869,20 @@ class LocalVideoTrack extends LocalTrack {
       // browser will reenable disabled codec/layers after new codec has been published,
       // so refresh subscribedCodecs after publish a new codec
       setTimeout(() => {
-        if (this.subscribedCodecs) {
-          this.setPublishingCodecs(this.subscribedCodecs);
-        }
+        this.refreshSubscribedCodecs();
       }, refreshSubscribedCodecAfterNewCodec);
     });
   }
+  /** @interal */
+  refreshSubscribedCodecs() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.subscribedCodecs) {
+        return this.setPublishingCodecs(this.subscribedCodecs).catch(e => this.log.warn("failed to refresh codec for track", Object.assign(Object.assign({}, this.logContext), {
+          error: e
+        })));
+      }
+    });
+  }
   /**
    * @internal
    * Sets codecs that should be publishing, returns new codecs that have not yet
@@ -24377,6 +25227,13 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.midToTrackId = {};
     /** used to indicate whether the browser is currently waiting to reconnect */
     this.isWaitingForNetworkReconnect = false;
+    /**
+     * Abort handlers for the in-flight `negotiate()` calls, which a single central
+     * Closing/Restarting listener pair fans out to. Registering a listener pair per call instead
+     * accumulates them on the engine emitter and trips its max-listener warning under
+     * renegotiation bursts.
+     */
+    this.pendingNegotiationAborts = new Set();
     this.handleDataChannel = _a => __awaiter(this, [_a], void 0, function (_ref) {
       var _this = this;
       let channel = _ref.channel;
@@ -24513,7 +25370,17 @@ class RTCEngine extends eventsExports.EventEmitter {
         return;
       }
       if (connection === leaveReconnect) {
-        delay = 0;
+        // The server asked for a reconnect, so skip any remaining backoff. Use the policy's first
+        // retry delay instead of 0 so that clients told to reconnect together don't all reconnect
+        // at the same instant.
+        delay = this.getNextRetryDelay({
+          elapsedMs: duration,
+          retryCount: 0
+        });
+        if (delay === null) {
+          disconnect(duration);
+          return;
+        }
       }
       this.log.debug("reconnecting in ".concat(delay, "ms"));
       this.clearReconnectTimeout();
@@ -24622,6 +25489,14 @@ 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);
+    const abortPendingNegotiations = () => {
+      // Iterate a copy: each handler removes itself from the set as its negotiation settles.
+      for (const abort of Array.from(this.pendingNegotiationAborts)) {
+        abort();
+      }
+    };
+    this.on(EngineEvent.Closing, abortPendingNegotiations);
+    this.on(EngineEvent.Restarting, abortPendingNegotiations);
   }
   /** @internal */
   get logContext() {
@@ -24638,7 +25513,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       var _this2 = this;
       let useV0Path = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
       return function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         _this2._isNewlyCreated = false;
         _this2.url = url;
         _this2.token = token;
@@ -24646,6 +25521,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         _this2.maxJoinAttempts = opts.maxRetries;
         try {
           _this2.joinAttempts += 1;
+          _this2.joinStartedAt = performance.now();
           _this2.setupSignalClientCallbacks();
           // Whether the initial publisher offer is bundled with the join request. Computed once and
           // reused after the join below. Only the (non-Firefox) offer-with-join path does this.
@@ -24675,6 +25551,10 @@ class RTCEngine extends eventsExports.EventEmitter {
             throw ConnectionError.serviceNotFound('Simulated v1 path failure', 'v0-rtc');
           }
           const joinResponse = yield _this2.client.join(url, token, opts, abortSignal, useV0Path, offerProto);
+          if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            _this2.log.info('join cancelled after the signal join response');
+            throw ConnectionError.cancelled('Connection aborted');
+          }
           _this2._isClosed = false;
           _this2.latestJoinResponse = joinResponse;
           _this2.participantSid = (_b = joinResponse.participant) === null || _b === void 0 ? void 0 : _b.sid;
@@ -24687,6 +25567,10 @@ class RTCEngine extends eventsExports.EventEmitter {
               // the server's ICE servers and topology, then negotiate separately rather than bundling
               // the offer with the join.
               yield _this2.configure(joinResponse, !useV0Path);
+              if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                _this2.log.info('join cancelled after configuring peer connections');
+                throw ConnectionError.cancelled('Connection aborted');
+              }
               if (!useV0Path) {
                 // The V1 first offer must carry the media layout so Firefox binds receive decoders for
                 // subscribed tracks — without it, subscribed audio/video arrive as RTP but
@@ -24701,6 +25585,11 @@ class RTCEngine extends eventsExports.EventEmitter {
               });
             }
           }
+          if (_this2.joinStartedAt !== undefined) {
+            // Lets a video published before the transports connect be seeded from the time elapsed
+            // so far, rather than delaying its offer until the setup time is measured.
+            (_d = _this2.pcManager) === null || _d === void 0 ? void 0 : _d.publisher.setConnectionStartedAt(_this2.joinStartedAt);
+          }
           _this2.registerOnLineListener();
           _this2.clientConfiguration = joinResponse.clientConfiguration;
           _this2.emit(EngineEvent.SignalConnected, joinResponse);
@@ -24749,6 +25638,9 @@ class RTCEngine extends eventsExports.EventEmitter {
    */
   close(reason) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      (_a = this.reconnectAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+      this.reconnectAbortController = undefined;
       const unlock = yield this.closingLock.lock();
       if (this.isClosed) {
         unlock();
@@ -24757,6 +25649,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       try {
         this._isClosed = true;
         this.joinAttempts = 0;
+        this.joinStartedAt = undefined;
         this.emit(EngineEvent.Closing);
         this.removeAllListeners();
         this.deregisterOnLineListener();
@@ -24885,6 +25778,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       };
       this.pcManager.onDataChannel = this.handleDataChannel;
       this.pcManager.onStateChange = (connectionState, publisherState, subscriberState) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         this.log.debug("primary PC state changed ".concat(connectionState));
         // Record when the primary transport actually entered CONNECTING so
         // verifyTransport() can bound how long we tolerate it. Deriving it from the
@@ -24900,6 +25794,16 @@ class RTCEngine extends eventsExports.EventEmitter {
           this.publisherConnectionPromise = undefined;
         }
         if (connectionState === PCTransportState.CONNECTED) {
+          if (this.joinStartedAt !== undefined) {
+            // Connection setup time is the only network signal there is before the first video
+            // offer. Set synchronously, so it is in place before `room.connect()` resolves and the
+            // app can publish. A full restart joins again and builds new transports, so it is
+            // measured again; a resume keeps its estimator and never restarts the timer.
+            const setupTimeMs = Math.round(performance.now() - this.joinStartedAt);
+            this.joinStartedAt = undefined;
+            this.log.info("connection setup took ".concat(setupTimeMs, " ms"));
+            (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.publisher.setConnectionSetupTime(setupTimeMs);
+          }
           const shouldEmit = this.pcState === PCState.New;
           this.pcState = PCState.Connected;
           if (shouldEmit) {
@@ -24944,6 +25848,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.midToTrackId = midToTrackId;
       }
       yield this.pcManager.setPublisherAnswer(sd, offerId);
+      this.emit(EngineEvent.RequestSubscribedCodecRefresh);
     });
     // add candidate on trickle
     this.client.onTrickle = (candidate, target) => {
@@ -25010,7 +25915,9 @@ class RTCEngine extends eventsExports.EventEmitter {
     };
     this.client.onMediaSectionsRequirement = requirement => {
       this.addMediaSections(requirement.numAudios, requirement.numVideos);
-      this.negotiate();
+      this.negotiate().catch(err => {
+        this.log.error(err);
+      });
     };
     this.client.onPublishDataTrackResponse = event => {
       this.emit(EngineEvent.PublishDataTrackResponse, event);
@@ -25131,6 +26038,12 @@ class RTCEngine extends eventsExports.EventEmitter {
     if (!this.pcManager) {
       return;
     }
+    if (this.dataChannels.hasPublisherChannels) {
+      // Replacing live channels (the Safari null-id path in resumeConnection): the new ones start
+      // out connecting, so drop the memoized readiness check and make the next sender wait for
+      // them to open.
+      this.publisherConnectionPromise = undefined;
+    }
     this.dataChannels.createPublisherChannels(this.pcManager);
   }
   /** Normalizes an incoming data-channel message into bytes, or logs and returns undefined. */
@@ -25363,16 +26276,28 @@ class RTCEngine extends eventsExports.EventEmitter {
       const fullReconnect = this.fullReconnectOnNext;
       this.fullReconnectOnNext = false;
       let succeeded = false;
+      const abortController = new AbortController();
+      this.reconnectAbortController = abortController;
       try {
         this.attemptingReconnect = true;
         if (fullReconnect) {
-          yield this.restartConnection();
+          yield this.restartConnection(abortController.signal);
         } else {
           yield this.resumeConnection(reason);
         }
+        if (abortController.signal.aborted) {
+          this.log.info('reconnect attempt cancelled, not marking it as succeeded');
+          return;
+        }
         this.clearPendingReconnect();
         succeeded = true;
       } catch (e) {
+        if (abortController.signal.aborted) {
+          this.log.info('reconnect attempt cancelled, not retrying', {
+            error: e
+          });
+          return;
+        }
         this.reconnectAttempts += 1;
         let recoverable = true;
         if (e instanceof UnexpectedConnectionState) {
@@ -25394,6 +26319,10 @@ class RTCEngine extends eventsExports.EventEmitter {
           yield this.close("gave up reconnecting after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms"));
         }
       } finally {
+        // close() may already have cleared this (or a later attempt replaced it); only release our own
+        if (this.reconnectAbortController === abortController) {
+          this.reconnectAbortController = undefined;
+        }
         this.attemptingReconnect = false;
         // A full reconnect requested while this attempt was running (e.g. a `RECONNECT` leave
         // during a resume or a restart) that a successful attempt didn't act on; dispatch it now
@@ -25416,10 +26345,16 @@ class RTCEngine extends eventsExports.EventEmitter {
     // error in user code with provided reconnect policy, stop reconnecting
     return null;
   }
-  restartConnection(regionUrl) {
+  restartConnection(abortSignal, regionUrl) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b, _c;
       try {
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled before starting', {
+            regionUrl
+          });
+          return;
+        }
         if (!this.url || !this.token) {
           // permanent failure, don't attempt reconnection
           throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -25431,6 +26366,12 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
         yield this.cleanupPeerConnections();
         yield this.cleanupClient();
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after cleaning up the previous session', {
+            regionUrl
+          });
+          return;
+        }
         let joinResponse;
         try {
           if (!this.signalOpts) {
@@ -25438,13 +26379,19 @@ class RTCEngine extends eventsExports.EventEmitter {
             throw new SignalReconnectError();
           }
           // in case a regionUrl is passed, the region URL takes precedence
-          joinResponse = (yield this.join(regionUrl !== null && regionUrl !== void 0 ? regionUrl : this.url, this.token, this.signalOpts, undefined, !this.options.singlePeerConnection)).joinResponse;
+          joinResponse = (yield this.join(regionUrl !== null && regionUrl !== void 0 ? regionUrl : this.url, this.token, this.signalOpts, abortSignal, !this.options.singlePeerConnection)).joinResponse;
         } catch (e) {
           if (e instanceof ConnectionError && e.reason === ConnectionErrorReason.NotAllowed) {
             throw new UnexpectedConnectionState('could not reconnect, token might be expired');
           }
           throw new SignalReconnectError();
         }
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after the signal join response', {
+            regionUrl
+          });
+          return;
+        }
         if (this.shouldFailNext) {
           this.shouldFailNext = false;
           throw new Error('simulated failure');
@@ -25452,6 +26399,12 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.client.setReconnected();
         this.emit(EngineEvent.SignalRestarted, joinResponse);
         yield this.waitForPCReconnected();
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after peer connections reconnected', {
+            regionUrl
+          });
+          return;
+        }
         // re-check signal connection state before setting engine as resumed
         if (this.client.currentState !== SignalConnectionState.CONNECTED) {
           throw new SignalReconnectError('Signal connection got severed during reconnect');
@@ -25460,9 +26413,21 @@ class RTCEngine extends eventsExports.EventEmitter {
         // reconnect success
         this.emit(EngineEvent.Restarted);
       } catch (error) {
-        const nextRegionUrl = yield (_b = this.regionStrategy) === null || _b === void 0 ? void 0 : _b.getNextUrl();
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after a failed attempt', {
+            regionUrl
+          });
+          return;
+        }
+        const nextRegionUrl = yield (_b = this.regionStrategy) === null || _b === void 0 ? void 0 : _b.getNextUrl(abortSignal);
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled during region selection', {
+            regionUrl
+          });
+          return;
+        }
         if (nextRegionUrl) {
-          yield this.restartConnection(nextRegionUrl);
+          yield this.restartConnection(abortSignal, nextRegionUrl);
           return;
         } else {
           // no more regions to try (or we're not on cloud)
@@ -25657,7 +26622,11 @@ class RTCEngine extends eventsExports.EventEmitter {
    */
   waitForBufferHeadroom(kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      return this.flowControlFor(kind).waitForHeadroomWithLock();
+      const dc = this.dataChannelForKind(kind);
+      if (!dc) {
+        throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(kind));
+      }
+      return this.flowControlFor(kind).waitForHeadroomWithLock(dc);
     });
   }
   /**
@@ -25763,8 +26732,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         if (this.isClosed) {
           reject(new NegotiationError('cannot negotiate on closed engine'));
         }
-        this.on(EngineEvent.Closing, handleClosed);
-        this.on(EngineEvent.Restarting, handleClosed);
+        this.pendingNegotiationAborts.add(handleClosed);
         this.pcManager.publisher.off(PCEvents.RTPVideoPayloadTypes, this.onRtpMapAvailable);
         this.pcManager.publisher.once(PCEvents.RTPVideoPayloadTypes, this.onRtpMapAvailable);
         try {
@@ -25787,8 +26755,7 @@ class RTCEngine extends eventsExports.EventEmitter {
             reject(new Error(String(e)));
           }
         } finally {
-          this.off(EngineEvent.Closing, handleClosed);
-          this.off(EngineEvent.Restarting, handleClosed);
+          this.pendingNegotiationAborts.delete(handleClosed);
         }
       }));
     });
@@ -26519,6 +27486,16 @@ class TextStreamReader extends BaseStreamReader {
     this.byteStreamHandlers.delete(topic);
   }
   clearControllers() {
+    // Error any in flight streams so readers do not wait forever for chunks that can no longer arrive.
+    const abnormalEndError = new DataStreamError('Room disconnected in the middle of receiving data', DataStreamErrorReason.AbnormalEnd);
+    for (const _ref2 of this.byteStreamControllers.values()) {
+      const controller = _ref2.controller;
+      controller.error(abnormalEndError);
+    }
+    for (const _ref3 of this.textStreamControllers.values()) {
+      const controller = _ref3.controller;
+      controller.error(abnormalEndError);
+    }
     this.byteStreamControllers.clear();
     this.textStreamControllers.clear();
     this.bufferedPackets = [];
@@ -26527,20 +27504,20 @@ class TextStreamReader extends BaseStreamReader {
     // Terminate any in flight data stream receives from the given participant
     const textStreamsBeingSentByDisconnectingParticipant = Array.from(this.textStreamControllers.entries()).filter(entry => entry[1].sendingParticipantIdentity === participantIdentity);
     const byteStreamsBeingSentByDisconnectingParticipant = Array.from(this.byteStreamControllers.entries()).filter(entry => entry[1].sendingParticipantIdentity === participantIdentity);
-    if (textStreamsBeingSentByDisconnectingParticipant.length > 0 || byteStreamsBeingSentByDisconnectingParticipant.length > 0) {
-      const abnormalEndError = new DataStreamError("Participant ".concat(participantIdentity, " unexpectedly disconnected in the middle of sending data"), DataStreamErrorReason.AbnormalEnd);
-      for (const _ref2 of byteStreamsBeingSentByDisconnectingParticipant) {
-        var _ref3 = _slicedToArray(_ref2, 2);
-        const id = _ref3[0];
-        const controller = _ref3[1];
-        controller.controller.error(abnormalEndError);
-        this.byteStreamControllers.delete(id);
-      }
-      for (const _ref4 of textStreamsBeingSentByDisconnectingParticipant) {
+    if (textStreamsBeingSentByDisconnectingParticipant.length > 0 || byteStreamsBeingSentByDisconnectingParticipant.length > 0) {
+      const abnormalEndError = new DataStreamError("Participant ".concat(participantIdentity, " unexpectedly disconnected in the middle of sending data"), DataStreamErrorReason.AbnormalEnd);
+      for (const _ref4 of byteStreamsBeingSentByDisconnectingParticipant) {
         var _ref5 = _slicedToArray(_ref4, 2);
         const id = _ref5[0];
         const controller = _ref5[1];
         controller.controller.error(abnormalEndError);
+        this.byteStreamControllers.delete(id);
+      }
+      for (const _ref6 of textStreamsBeingSentByDisconnectingParticipant) {
+        var _ref7 = _slicedToArray(_ref6, 2);
+        const id = _ref7[0];
+        const controller = _ref7[1];
+        controller.controller.error(abnormalEndError);
         this.textStreamControllers.delete(id);
       }
     }
@@ -26589,10 +27566,10 @@ class TextStreamReader extends BaseStreamReader {
           let compressed;
           switch (streamHeader.compression) {
             case DataStream_CompressionType.DEFLATE_RAW:
-              if (!isCompressionStreamSupported()) {
+              if (!isDeflateRawCompressionSupported()) {
                 // 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..."));
+                livekitLogger.warn("Data stream ".concat(streamHeader.streamId, " received with deflate-raw compression, but this browser does not support deflate-raw decompression. Dropping..."));
                 return;
               }
               compressed = true;
@@ -26660,10 +27637,10 @@ class TextStreamReader extends BaseStreamReader {
           let compressed;
           switch (streamHeader.compression) {
             case DataStream_CompressionType.DEFLATE_RAW:
-              if (!isCompressionStreamSupported()) {
+              if (!isDeflateRawCompressionSupported()) {
                 // 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..."));
+                livekitLogger.warn("Data stream ".concat(streamHeader.streamId, " received with deflate-raw compression, but this browser does not support deflate-raw decompression. Dropping..."));
                 return;
               }
               compressed = true;
@@ -27028,7 +28005,7 @@ class OutgoingDataStreamManager {
         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);
+      const compressEligible = compress && isDeflateRawCompressionSupported() && 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;
@@ -27137,7 +28114,7 @@ class OutgoingDataStreamManager {
         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);
+      const compressEligible = compress && isDeflateRawCompressionSupported() && 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)) {
@@ -27334,7 +28311,7 @@ class OutgoingDataStreamManager {
     return __awaiter(this, void 0, void 0, function* () {
       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 compress = ((_a = options === null || options === void 0 ? void 0 : options.compress) !== null && _a !== void 0 ? _a : true) && isDeflateRawCompressionSupported() && this.allRecipientsSupportV2(destinationIdentities) && this.allRecipientsSupportCompression(destinationIdentities);
       const info = {
         id: streamId,
         name: file.name,
@@ -27537,58 +28514,6 @@ function sendStreamTrailer(streamId, destinationIdentities, engine) {
     });
     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.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
- */
-function abortSignalAny(signals) {
-  // Handle empty signals array
-  if (signals.length === 0) {
-    const controller = new AbortController();
-    return controller.signal;
-  }
-  // Fast path for single signal
-  if (signals.length === 1) {
-    return signals[0];
-  }
-  // Check if any signal is already aborted
-  for (const signal of signals) {
-    if (signal.aborted) {
-      return signal;
-    }
-  }
-  // Create a new controller for the combined signal
-  const controller = new AbortController();
-  const unlisteners = Array(signals.length);
-  // Function to clean up all event listeners
-  const cleanup = () => {
-    for (const unsubscribe of unlisteners) {
-      unsubscribe();
-    }
-  };
-  // Add event listeners to each signal
-  signals.forEach((signal, index) => {
-    const handler = () => {
-      controller.abort(signal.reason);
-      cleanup();
-    };
-    signal.addEventListener('abort', handler);
-    unlisteners[index] = () => signal.removeEventListener('abort', handler);
-  });
-  return controller.signal;
-}
-/**
- * Implementation of AbortSignal.timeout
- * Creates a signal that will be aborted after the specified timeout.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
- */
-function abortSignalTimeout(ms) {
-  const controller = new AbortController();
-  setTimeout(() => {
-    controller.abort(new DOMException("signal timed out after ".concat(ms, " ms"), 'TimeoutError'));
-  }, ms);
-  return controller.signal;
 }// Number type sizes
 const U8_LENGTH_BYTES = 1;
 const U16_LENGTH_BYTES = 2;
@@ -29945,6 +30870,12 @@ function truncateBytes(str, maxBytes) {
       high = mid - 1;
     }
   }
+  // Never end on the first half of a surrogate pair: it would be encoded as a replacement
+  // character, and the truncated string would no longer round trip.
+  const lastCode = low > 0 ? str.charCodeAt(low - 1) : 0;
+  if (lastCode >= 0xd800 && lastCode <= 0xdbff) {
+    low -= 1;
+  }
   return str.slice(0, low);
 }/**
  * Manages the client (caller) side of RPC: sending requests, tracking pending
@@ -30005,20 +30936,37 @@ class RpcClientManager extends eventsExports.EventEmitter {
           completionFuture,
           participantIdentity: destinationIdentity
         });
-        yield _this.publishRpcRequest(destinationIdentity, id, method, payload, effectiveTimeoutMs, remoteClientProtocol);
-        responseTimeoutId = setTimeout(() => {
-          var _a;
-          _this.pendingResponses.delete(id);
-          (_a = completionFuture.reject) === null || _a === void 0 ? void 0 : _a.call(completionFuture, RpcError.builtIn('RESPONSE_TIMEOUT'));
-        }, responseTimeoutMs);
+        // Observe the future before publishing: a slow send can outlast the ack timer.
+        // Keep the returned promise rejected for callers, while marking its rejection
+        // handled until performRpc has finished publishing and can return it.
         const completionPromise = completionFuture.promise.finally(() => {
-          clearTimeout(responseTimeoutId);
+          if (responseTimeoutId !== null) {
+            clearTimeout(responseTimeoutId);
+          }
           if (_this.pendingAcks.has(id)) {
             _this.log.warn('RPC response received before ack', id);
             _this.pendingAcks.delete(id);
             clearTimeout(ackTimeoutId);
           }
         });
+        completionPromise.catch(() => {});
+        try {
+          yield _this.publishRpcRequest(destinationIdentity, id, method, payload, effectiveTimeoutMs, remoteClientProtocol);
+        } catch (e) {
+          // The caller receives the publish error. Do not leave an ack timer that
+          // later rejects a future the caller never received.
+          clearTimeout(ackTimeoutId);
+          _this.pendingAcks.delete(id);
+          _this.pendingResponses.delete(id);
+          throw e;
+        }
+        if (_this.pendingResponses.has(id)) {
+          responseTimeoutId = setTimeout(() => {
+            var _a;
+            _this.pendingResponses.delete(id);
+            (_a = completionFuture.reject) === null || _a === void 0 ? void 0 : _a.call(completionFuture, RpcError.builtIn('RESPONSE_TIMEOUT'));
+          }, responseTimeoutMs);
+        }
         return [id, completionPromise];
       }();
     });
@@ -30332,6 +31280,12 @@ class RpcServerManager extends eventsExports.EventEmitter {
 }class RemoteAudioTrack extends RemoteTrack {
   constructor(mediaTrack, sid, receiver, audioContext, audioOutput, loggerOptions) {
     super(mediaTrack, sid, Track.Kind.Audio, receiver, loggerOptions);
+    /**
+     * the nodes of the graph currently wired up, in order, so teardown can undo exactly the edges
+     * `connectWebAudio` created. Reading `webAudioPluginNodes` instead would miss the old plugins
+     * once `setWebAudioPlugins` has replaced them.
+     */
+    this.connectedNodes = [];
     this.monitorReceiver = () => __awaiter(this, void 0, void 0, function* () {
       if (!this.receiver) {
         this._currentBitrate = 0;
@@ -30354,10 +31308,11 @@ class RpcServerManager extends eventsExports.EventEmitter {
    */
   setVolume(volume) {
     var _a;
-    for (const el of this.attachedElements) {
-      if (this.audioContext) {
-        (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.gain.setTargetAtTime(volume, 0, 0.1);
-      } else {
+    if (this.audioContext) {
+      // playback goes through the web audio graph, the attached elements themselves stay silent
+      (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.gain.setTargetAtTime(volume, 0, 0.1);
+    } else {
+      for (const el of this.attachedElements) {
         el.volume = volume;
       }
     }
@@ -30371,7 +31326,7 @@ class RpcServerManager extends eventsExports.EventEmitter {
    * gets the volume of attached audio elements (loudest)
    */
   getVolume() {
-    if (this.elementVolume) {
+    if (this.elementVolume !== undefined) {
       return this.elementVolume;
     }
     if (isReactNative()) {
@@ -30403,7 +31358,9 @@ class RpcServerManager extends eventsExports.EventEmitter {
     });
   }
   attach(element) {
-    const needsNewWebAudioConnection = this.attachedElements.length === 0;
+    // the graph is fed by the track rather than by a specific element, so one connection covers
+    // all attached elements
+    const needsNewWebAudioConnection = !this.sourceNode;
     if (!element) {
       element = super.attach();
     } else {
@@ -30414,13 +31371,17 @@ class RpcServerManager extends eventsExports.EventEmitter {
         this.log.error('Failed to set sink id on remote audio track', e, this.logContext);
       });
     }
-    if (this.audioContext && needsNewWebAudioConnection) {
-      this.log.debug('using audio context mapping', this.logContext);
-      this.connectWebAudio(this.audioContext, element);
+    if (this.audioContext) {
+      // audio is routed through the web audio graph, so every attached element has to stay
+      // silent, no matter whether it is the one the graph was built from
       element.volume = 0;
       element.muted = true;
+      if (needsNewWebAudioConnection) {
+        this.log.debug('using audio context mapping', this.logContext);
+        this.connectWebAudio(this.audioContext, element);
+      }
     }
-    if (this.elementVolume) {
+    if (this.elementVolume !== undefined) {
       // make sure volume setting is being applied to the newly attached element
       this.setVolume(this.elementVolume);
     }
@@ -30450,11 +31411,27 @@ class RpcServerManager extends eventsExports.EventEmitter {
    * @experimental
    */
   setAudioContext(audioContext) {
+    var _a;
+    if (this.audioContext === audioContext) {
+      return;
+    }
     this.audioContext = audioContext;
-    if (audioContext && this.attachedElements.length > 0) {
-      this.connectWebAudio(audioContext, this.attachedElements[0]);
-    } else if (!audioContext) {
+    if (audioContext) {
+      // playback moves into the web audio graph, mute the elements to avoid double playback
+      for (const element of this.attachedElements) {
+        element.volume = 0;
+        element.muted = true;
+      }
+      if (this.attachedElements.length > 0) {
+        this.connectWebAudio(audioContext, this.attachedElements[0]);
+      }
+    } else {
       this.disconnectWebAudio();
+      // playback moves back into the elements, which `attach` had muted in favour of the graph
+      for (const element of this.attachedElements) {
+        element.muted = false;
+        element.volume = (_a = this.elementVolume) !== null && _a !== void 0 ? _a : 1;
+      }
     }
   }
   /**
@@ -30473,14 +31450,17 @@ class RpcServerManager extends eventsExports.EventEmitter {
     // @ts-ignore attached elements always have a srcObject set
     this.sourceNode = context.createMediaStreamSource(element.srcObject);
     let lastNode = this.sourceNode;
+    this.connectedNodes = [this.sourceNode];
     this.webAudioPluginNodes.forEach(node => {
       lastNode.connect(node);
       lastNode = node;
+      this.connectedNodes.push(node);
     });
     this.gainNode = context.createGain();
     lastNode.connect(this.gainNode);
+    this.connectedNodes.push(this.gainNode);
     this.gainNode.connect(context.destination);
-    if (this.elementVolume) {
+    if (this.elementVolume !== undefined) {
       this.gainNode.gain.setTargetAtTime(this.elementVolume, 0, 0.1);
     }
     // try to resume the context if it isn't running already
@@ -30496,6 +31476,19 @@ class RpcServerManager extends eventsExports.EventEmitter {
   }
   disconnectWebAudio() {
     var _a, _b;
+    // the plugin nodes belong to whoever passed them in and may feed graphs of their own, so only
+    // the edges this track created come down. A bare `node.disconnect()` would drop the
+    // application's own routing with them
+    for (let i = 0; i < this.connectedNodes.length - 1; i += 1) {
+      try {
+        this.connectedNodes[i].disconnect(this.connectedNodes[i + 1]);
+      } catch (_c) {
+        // a plugin node the application already disconnected itself, the rest of the chain still
+        // has to come apart
+      }
+    }
+    this.connectedNodes = [];
+    // the source and gain nodes are ours alone, so every remaining edge of theirs is ours to drop
     (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.disconnect();
     (_b = this.sourceNode) === null || _b === void 0 ? void 0 : _b.disconnect();
     this.gainNode = undefined;
@@ -31157,8 +32150,10 @@ class Participant extends eventsExports.EventEmitter {
    * @internal
    */
   setAudioContext(ctx) {
-    this.audioContext = ctx;
-    this.audioTrackPublications.forEach(track => isAudioTrack(track.track) && track.track.setAudioContext(ctx));
+    return __awaiter(this, void 0, void 0, function* () {
+      this.audioContext = ctx;
+      yield Promise.all(Array.from(this.audioTrackPublications.values()).map(publication => publication.track).filter(isAudioTrack).map(track => track.setAudioContext(ctx)));
+    });
   }
   addTrackPublication(publication) {
     this.log.debug("adding track publication", {
@@ -31417,10 +32412,7 @@ class Participant extends eventsExports.EventEmitter {
           if (!track.isMuted) {
             this.log.debug('track ended, attempting to use a different device', getLogContextFromTrack(track));
             if (isLocalAudioTrack(track)) {
-              // fall back to default device if available
-              yield track.restartTrack({
-                deviceId: 'default'
-              });
+              yield this.restartOnDefaultAudioDevice(track);
             } else {
               yield track.restartTrack();
             }
@@ -31767,10 +32759,10 @@ class Participant extends eventsExports.EventEmitter {
           loggerName: this.roomOptions.loggerName,
           loggerContextCb: () => this.logContext
         });
-        const localTracks = tracks.map(track => {
+        const localTracks = yield Promise.all(tracks.map(track => __awaiter(this, void 0, void 0, function* () {
           if (isAudioTrack(track)) {
             this.microphoneError = undefined;
-            track.setAudioContext(this.audioContext);
+            yield track.setAudioContext(this.audioContext);
             track.source = Track.Source.Microphone;
             this.emit(ParticipantEvent.AudioStreamAcquired);
           }
@@ -31779,7 +32771,7 @@ class Participant extends eventsExports.EventEmitter {
             track.source = Track.Source.Camera;
           }
           return track;
-        });
+        })));
         return localTracks;
       } catch (err) {
         if (err instanceof Error) {
@@ -31889,7 +32881,7 @@ class Participant extends eventsExports.EventEmitter {
       return function* () {
         var _a, _b, _c, _d;
         if (isLocalAudioTrack(track)) {
-          track.setAudioContext(_this2.audioContext);
+          yield track.setAudioContext(_this2.audioContext);
         }
         yield (_a = _this2.reconnectFuture) === null || _a === void 0 ? void 0 : _a.promise;
         if (_this2.republishPromise && !isRepublish) {
@@ -32489,19 +33481,36 @@ class Participant extends eventsExports.EventEmitter {
         return;
       }
       const packetTrailerFeatures = this.normalizeRequestedFrameMetadataOptions(track, opts);
+      // the backup sender encodes the processed track, not the raw capture track.dimensions reports
+      const _track$mediaStreamTra = track.mediaStreamTrack.getSettings(),
+        width = _track$mediaStreamTra.width,
+        height = _track$mediaStreamTra.height;
+      const dims = width && height ? {
+        width,
+        height
+      } : undefined;
+      if (!dims) {
+        this.log.warn('could not determine track dimensions, publishing backup codec without layers', getLogContextFromTrack(track));
+      }
+      // the server reads the layers off the codec entry for a request that carries a sid, and
+      // falls back to the top level ones when it predates per codec layers
+      const layers = dims ? videoLayersFromEncodings(dims.width, dims.height, encodings) : [];
       const req = new AddTrackRequest({
         cid: simulcastTrack.mediaStreamTrack.id,
         type: Track.kindToProto(track.kind),
         muted: track.isMuted,
         source: Track.sourceToProto(track.source),
         sid: track.sid,
+        width: dims === null || dims === void 0 ? void 0 : dims.width,
+        height: dims === null || dims === void 0 ? void 0 : dims.height,
         packetTrailerFeatures,
+        layers,
         simulcastCodecs: [{
           codec: opts.videoCodec,
-          cid: simulcastTrack.mediaStreamTrack.id
+          cid: simulcastTrack.mediaStreamTrack.id,
+          layers
         }]
       });
-      req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
       if (!this.engine || this.engine.isClosed) {
         throw new UnexpectedConnectionState('cannot publish track when not connected');
       }
@@ -32921,6 +33930,35 @@ class Participant extends eventsExports.EventEmitter {
     }
     return this.activeAgentFuture.promise;
   }
+  /**
+   * @internal
+   */
+  restartOnDefaultAudioDevice(track) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b;
+      try {
+        if (isChromiumBased()) {
+          // only chrome has the notion of a literal `default` device
+          yield track.setDeviceId({
+            exact: 'default'
+          });
+        } else {
+          // just try to restart for other browsers and try to change the device id as a fallback in the catch clause
+          yield track.restartTrack();
+        }
+      } catch (e) {
+        // restart() clears the manually-stopped flag on entry, so retrying a track the user stopped
+        // while the first attempt was in flight would re-open the capture device behind their back
+        if (!isDeviceAcquisitionFailure(e) || isPermissionDeniedError(e) || track.isStopped) {
+          throw e;
+        }
+        this.log.debug('could not reacquire the audio device, retrying with an enumerated device', getLogContextFromTrack(track));
+        // permission is already granted at this point, so skip the probe that would re-acquire media
+        const allDevices = yield DeviceManager.getInstance().getDevices('audioinput', false);
+        yield track.setDeviceId((_b = (_a = allDevices === null || allDevices === void 0 ? void 0 : allDevices[0]) === null || _a === void 0 ? void 0 : _a.deviceId) !== null && _b !== void 0 ? _b : 'default');
+      }
+    });
+  }
   getPublicationForTrack(track) {
     let publication;
     this.trackPublications.forEach(pub => {
@@ -33631,6 +34669,30 @@ class DeferrableMap extends Map {
 })(ConnectionState || (ConnectionState = {}));
 const CONNECTION_RECONCILE_FREQUENCY_MS = 4 * 1000;
 const STATS_LOG_FREQUENCY_MS = 30 * 1000;
+const DUMMY_AUDIO_ELEMENT_ID = 'livekit-dummy-audio-el';
+/**
+ * One silent audio element serves every room on the page, so it is reference counted: a room
+ * disconnecting must not pull it out from under the rooms still playing through it. The element
+ * and its track go away once the last room hands its reference back.
+ */
+let sharedDummyAudioElement;
+function createSharedDummyAudioElement() {
+  const element = document.createElement('audio');
+  element.id = DUMMY_AUDIO_ELEMENT_ID;
+  element.autoplay = true;
+  element.hidden = true;
+  const track = getEmptyAudioStreamTrack();
+  track.enabled = true;
+  const stream = new MediaStream([track]);
+  element.srcObject = stream;
+  document.body.append(element);
+  return {
+    element,
+    stream,
+    track,
+    refCount: 0
+  };
+}
 /**
  * In LiveKit, a room is the logical grouping for a list of participants.
  * Participants in a room can publish tracks, and subscribe to others' tracks.
@@ -33661,6 +34723,24 @@ class Room extends eventsExports.EventEmitter {
     /** reflects the sender encryption status of the local participant */
     this.isE2EEEnabled = false;
     this.audioEnabled = true;
+    /**
+     * whether `audioContext` was created by the SDK and therefore has to be closed by it.
+     * A context handed in through `webAudioMix` is owned by the application instead.
+     */
+    this.ownsAudioContext = false;
+    /**
+     * set once the audio context has been released as part of a disconnect. Guards against
+     * creating a new context outside of a connection lifecycle, where nothing would close it again.
+     */
+    this.audioContextReleased = false;
+    /**
+     * serialises `acquireAudioContext` against `releaseAudioContext`. Both await per-track graph
+     * rebuilds, so without it a reconnect landing inside a disconnect's teardown leaves the two
+     * racing to set the participants' context, and the loser's value is the one that sticks.
+     */
+    this.audioContextMutex = new _();
+    /** silent audio tracks this room acquired, handed back to the shared source on disconnect */
+    this.acquiredEmptyAudioTracks = new Set();
     this.e2eeStateMutex = new _();
     this.isVideoPlaybackBlocked = false;
     this.log = livekitLogger;
@@ -33731,7 +34811,7 @@ class Room extends eventsExports.EventEmitter {
           this.abortController = undefined;
           resolve();
         } catch (error) {
-          if (this.regionUrlProvider && error instanceof ConnectionError && error.reason !== ConnectionErrorReason.Cancelled && error.reason !== ConnectionErrorReason.NotAllowed) {
+          if (this.regionUrlProvider && error instanceof ConnectionError && canFailOverToAnotherRegion(error)) {
             let nextUrl = null;
             try {
               this.log.debug('Fetching next region');
@@ -33780,6 +34860,8 @@ class Room extends eventsExports.EventEmitter {
       const _yield$engine$join = yield engine.join(url, token, {
           autoSubscribe: connectOptions.autoSubscribe,
           adaptiveStream: typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
+          disableIceLite: connectOptions.disableIceLite,
+          subscriberAllowPause: connectOptions.subscriberAllowPause,
           clientInfoCapabilities: this.getClientInfoCapabilities(roomOptions),
           maxRetries: connectOptions.maxRetries,
           e2eeEnabled: !!this.e2eeManager,
@@ -33831,7 +34913,9 @@ class Room extends eventsExports.EventEmitter {
       if ((_b = this.regionUrlProvider) === null || _b === void 0 ? void 0 : _b.isCloud()) {
         this.engine.setRegionStrategy(this.createRegionStrategy());
       }
-      this.acquireAudioContext();
+      this.acquireAudioContext(true).catch(error => this.log.warn('Could not acquire audio context', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
       this.connOptions = Object.assign(Object.assign({}, roomConnectOptionDefaults), opts);
       if (this.connOptions.rtcConfig) {
         this.engine.rtcConfig = this.connOptions.rtcConfig;
@@ -33950,44 +35034,8 @@ class Room extends eventsExports.EventEmitter {
     this.startAudio = () => __awaiter(this, void 0, void 0, function* () {
       const elements = [];
       const browser = getBrowser();
-      if (browser && browser.os === 'iOS') {
-        /**
-         * iOS blocks audio element playback if
-         * - user is not publishing audio themselves and
-         * - no other audio source is playing
-         *
-         * as a workaround, we create an audio element with an empty track, so that
-         * silent audio is always playing
-         */
-        const audioId = 'livekit-dummy-audio-el';
-        let dummyAudioEl = document.getElementById(audioId);
-        if (!dummyAudioEl) {
-          dummyAudioEl = document.createElement('audio');
-          dummyAudioEl.id = audioId;
-          dummyAudioEl.autoplay = true;
-          dummyAudioEl.hidden = true;
-          const track = getEmptyAudioStreamTrack();
-          track.enabled = true;
-          const stream = new MediaStream([track]);
-          dummyAudioEl.srcObject = stream;
-          document.addEventListener('visibilitychange', () => {
-            if (!dummyAudioEl) {
-              return;
-            }
-            // set the srcObject to null on page hide in order to prevent lock screen controls to show up for it
-            dummyAudioEl.srcObject = document.hidden ? null : stream;
-            if (!document.hidden) {
-              this.log.debug('page visible again, triggering startAudio to resume playback and update playback status');
-              this.startAudio();
-            }
-          });
-          document.body.append(dummyAudioEl);
-          this.once(RoomEvent.Disconnected, () => {
-            dummyAudioEl === null || dummyAudioEl === void 0 ? void 0 : dummyAudioEl.remove();
-            dummyAudioEl = null;
-          });
-        }
-        elements.push(dummyAudioEl);
+      if (browser && browser.os === 'iOS' && !this.audioContextReleased) {
+        elements.push(this.acquireDummyAudioElement());
       }
       this.remoteParticipants.forEach(p => {
         p.audioTrackPublications.forEach(t => {
@@ -33999,7 +35047,10 @@ class Room extends eventsExports.EventEmitter {
         });
       });
       try {
-        yield Promise.all([this.acquireAudioContext(), ...elements.map(e => {
+        yield Promise.all([
+        // once the audio context has been released as part of a disconnect there is nothing left
+        // to unlock, and creating a new context here would leak it as no disconnect will follow
+        ...(this.audioContextReleased ? [] : [this.acquireAudioContext()]), ...elements.map(e => {
           // 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
@@ -34218,7 +35269,7 @@ class Room extends eventsExports.EventEmitter {
       // find the participant
       const participant = this.remoteParticipants.get(packet.participantIdentity);
       if (packet.value.case === 'user') {
-        this.handleUserPacket(participant, packet.value.value, packet.kind, encryptionType);
+        this.handleUserPacket(participant, packet.value.value, packet.kind, encryptionType, packet.participantIdentity);
       } else if (packet.value.case === 'transcription') {
         this.handleTranscription(participant, packet.value.value);
       } else if (packet.value.case === 'sipDtmf') {
@@ -34249,8 +35300,8 @@ class Room extends eventsExports.EventEmitter {
         this.rpcClientManager.handleIncomingRpcAck(packet.value.value.requestId);
       }
     };
-    this.handleUserPacket = (participant, userPacket, kind, encryptionType) => {
-      this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic, encryptionType);
+    this.handleUserPacket = (participant, userPacket, kind, encryptionType, participantIdentity) => {
+      this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic, encryptionType, participantIdentity);
       // also emit on the participant
       participant === null || participant === void 0 ? void 0 : participant.emit(ParticipantEvent.DataReceived, userPacket.payload, kind, encryptionType);
     };
@@ -34825,6 +35876,12 @@ class Room extends eventsExports.EventEmitter {
         updatedAtInMs: Date.now(),
         maxAgeInMs: DEFAULT_MAX_AGE_MS
       });
+    }).on(EngineEvent.RequestSubscribedCodecRefresh, () => {
+      for (const videoPub of this.localParticipant.videoTrackPublications.values()) {
+        if (isLocalVideoTrack(videoPub.track)) {
+          videoPub.track.refreshSubscribedCodecs();
+        }
+      }
     });
     if (this.localParticipant) {
       this.localParticipant.setupEngine(this.engine);
@@ -34921,8 +35978,9 @@ class Room extends eventsExports.EventEmitter {
       let req;
       switch (scenario) {
         case 'signal-reconnect':
+          const reconnectDelay = typeof arg === 'number' ? arg : 0;
           // @ts-expect-error function is private
-          yield this.engine.client.handleOnClose('simulate disconnect');
+          yield this.engine.client.handleOnClose('simulate disconnect', undefined, reconnectDelay);
           break;
         case 'fail-on-v1-path':
           this.engine.failNextV1Path();
@@ -35036,6 +36094,78 @@ class Room extends eventsExports.EventEmitter {
       }
     });
   }
+  /**
+   * iOS blocks audio element playback if
+   * - user is not publishing audio themselves and
+   * - no other audio source is playing
+   *
+   * as a workaround, we create an audio element with an empty track, so that
+   * silent audio is always playing
+   *
+   * The element is shared with any other room on the page and handed back on disconnect, so it
+   * outlives whichever room happened to create it.
+   */
+  acquireDummyAudioElement() {
+    if (!sharedDummyAudioElement) {
+      sharedDummyAudioElement = createSharedDummyAudioElement();
+    }
+    const shared = sharedDummyAudioElement;
+    if (this.releaseDummyAudioElement) {
+      // this room already holds a reference, a second one would never be handed back
+      return shared.element;
+    }
+    shared.refCount += 1;
+    // the listener is per room rather than shared, so that the room it resumes playback for is
+    // still connected, and so that it goes away with the room that installed it
+    const handleVisibilityChange = () => {
+      // set the srcObject to null on page hide in order to prevent lock screen controls to show up for it
+      shared.element.srcObject = document.hidden ? null : shared.stream;
+      if (!document.hidden) {
+        this.log.debug('page visible again, triggering startAudio to resume playback and update playback status');
+        this.startAudio().catch(error => this.log.warn('Could not restart audio on page becoming visible', Object.assign(Object.assign({}, this.logContext), {
+          error
+        })));
+      }
+    };
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    this.releaseDummyAudioElement = () => {
+      this.releaseDummyAudioElement = undefined;
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+      shared.refCount -= 1;
+      if (shared.refCount > 0) {
+        return;
+      }
+      shared.element.srcObject = null;
+      shared.element.remove();
+      sharedDummyAudioElement = undefined;
+      releaseEmptyAudioStreamTrack(shared.track).catch(error => this.log.warn('Could not release the dummy audio element track', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
+    };
+    return shared.element;
+  }
+  /**
+   * Obtains a silent audio track from the shared source and keeps track of it, so that it can be
+   * handed back on disconnect and the shared `AudioContext` behind it can be closed again.
+   */
+  acquireEmptyAudioStreamTrack() {
+    const track = getEmptyAudioStreamTrack();
+    this.acquiredEmptyAudioTracks.add(track);
+    return track;
+  }
+  releaseAcquiredEmptyAudioTrack(track) {
+    if (!this.acquiredEmptyAudioTracks.delete(track)) {
+      return;
+    }
+    releaseEmptyAudioStreamTrack(track).catch(error => this.log.warn('Could not release empty audio stream track', Object.assign(Object.assign({}, this.logContext), {
+      error
+    })));
+  }
+  releaseAcquiredEmptyAudioTracks() {
+    for (const track of this.acquiredEmptyAudioTracks) {
+      this.releaseAcquiredEmptyAudioTrack(track);
+    }
+  }
   /**
    * Returns true if audio playback is enabled
    */
@@ -35318,7 +36448,7 @@ class Room extends eventsExports.EventEmitter {
   handleDisconnect() {
     let shouldStopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     let reason = arguments.length > 1 ? arguments[1] : undefined;
-    var _a, _b;
+    var _a, _b, _c;
     this.clearConnectionReconcile();
     this.isResuming = false;
     this.bufferedEvents = [];
@@ -35335,6 +36465,9 @@ class Room extends eventsExports.EventEmitter {
       this.regionUrlProvider.notifyDisconnected();
     }
     try {
+      // audio tracks that outlive this room are about to become unreachable through the local
+      // participant, collect them while we can so they can be detached from the context below
+      const retainedAudioTracks = shouldStopTracks ? [] : Array.from(this.localParticipant.audioTrackPublications.values()).map(pub => pub.track).filter(isLocalAudioTrack);
       this.remoteParticipants.forEach(p => {
         p.trackPublications.forEach(pub => {
           p.unpublishTrack(pub.trackSid);
@@ -35359,15 +36492,18 @@ class Room extends eventsExports.EventEmitter {
       this.remoteParticipants.clear();
       this.sidToIdentity.clear();
       this.activeSpeakers = [];
-      if (this.audioContext && typeof this.options.webAudioMix === 'boolean') {
-        this.audioContext.close();
-        this.audioContext = undefined;
-      }
+      (_a = this.releaseDummyAudioElement) === null || _a === void 0 ? void 0 : _a.call(this);
+      this.releaseAcquiredEmptyAudioTracks();
+      // teardown is asynchronous (processors need to release their web audio nodes), but
+      // `handleDisconnect` is not, so let it finish in the background
+      this.releaseAudioContext(retainedAudioTracks).catch(error => this.log.warn('Could not release audio context', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
       if (isWeb()) {
         window.removeEventListener('beforeunload', this.onPageLeave);
         window.removeEventListener('pagehide', this.onPageLeave);
         window.removeEventListener('freeze', this.onPageLeave);
-        (_b = (_a = navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'devicechange', this.handleDeviceChange);
+        (_c = (_b = navigator.mediaDevices) === null || _b === void 0 ? void 0 : _b.removeEventListener) === null || _c === void 0 ? void 0 : _c.call(_b, 'devicechange', this.handleDeviceChange);
       }
     } finally {
       this.setAndEmitConnectionState(ConnectionState.Disconnected);
@@ -35442,39 +36578,139 @@ class Room extends eventsExports.EventEmitter {
       }
     });
   }
+  /**
+   * @param forConnect whether this acquisition belongs to a connect, which is the only caller
+   * allowed to put a released room back on an audio context.
+   */
   acquireAudioContext() {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
-      if (typeof this.options.webAudioMix !== 'boolean' && this.options.webAudioMix.audioContext) {
-        // override audio context with custom audio context if supplied by user
-        this.audioContext = this.options.webAudioMix.audioContext;
-      } else if (!this.audioContext || this.audioContext.state === 'closed') {
-        // by using an AudioContext, it reduces lag on audio elements
-        // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
-        this.audioContext = (_a = getNewAudioContext()) !== null && _a !== void 0 ? _a : undefined;
-      }
-      if (this.options.webAudioMix) {
-        this.remoteParticipants.forEach(participant => participant.setAudioContext(this.audioContext));
-      }
-      this.localParticipant.setAudioContext(this.audioContext);
-      if (this.audioContext && this.audioContext.state === 'suspended') {
-        // for iOS a newly created AudioContext is always in `suspended` state.
-        // we try our best to resume the context here, if that doesn't work, we just continue with regular processing
+    return __awaiter(this, arguments, void 0, function () {
+      var _this4 = this;
+      let forConnect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      return function* () {
+        var _a, _b;
+        const unlock = yield _this4.audioContextMutex.lock();
         try {
-          yield Promise.race([this.audioContext.resume(), sleep(200)]);
-        } catch (e) {
-          this.log.warn('Could not resume audio context', {
-            error: e
-          });
+          if (_this4.audioContextReleased && !forConnect) {
+            // a disconnect set the flag and took the lock while this call was queued behind it.
+            // Creating a context now would leave one open on a room nothing tears down again
+            return;
+          }
+          _this4.audioContextReleased = false;
+          const providedAudioContext = typeof _this4.options.webAudioMix !== 'boolean' ? _this4.options.webAudioMix.audioContext : undefined;
+          if (providedAudioContext) {
+            // override audio context with custom audio context if supplied by user
+            yield _this4.setRoomAudioContext(providedAudioContext, false);
+          } else if (!_this4.audioContext || _this4.audioContext.state === 'closed') {
+            // by using an AudioContext, it reduces lag on audio elements
+            // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
+            yield _this4.setRoomAudioContext((_a = getNewAudioContext()) !== null && _a !== void 0 ? _a : undefined, true);
+          }
+          if (_this4.audioContext && _this4.audioContext.state === 'suspended') {
+            // for iOS a newly created AudioContext is always in `suspended` state.
+            // we try our best to resume the context here, if that doesn't work, we just continue with regular processing
+            try {
+              yield Promise.race([_this4.audioContext.resume(), sleep(200)]);
+            } catch (e) {
+              _this4.log.warn('Could not resume audio context', {
+                error: e
+              });
+            }
+          }
+          const newContextIsRunning = ((_b = _this4.audioContext) === null || _b === void 0 ? void 0 : _b.state) === 'running';
+          if (newContextIsRunning !== _this4.canPlaybackAudio) {
+            _this4.audioEnabled = newContextIsRunning;
+            _this4.emit(RoomEvent.AudioPlaybackStatusChanged, newContextIsRunning);
+          }
+        } finally {
+          unlock();
         }
+      }();
+    });
+  }
+  /**
+   * Points the room and its participants at `audioContext`, rebuilding the web audio graph of
+   * every audio track in it. Closes the previous context if the SDK `owned` it.
+   */
+  setRoomAudioContext(audioContext, owned) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const ownsAudioContext = !!audioContext && owned;
+      if (this.audioContext === audioContext) {
+        this.ownsAudioContext = ownsAudioContext;
+        return;
       }
-      const newContextIsRunning = ((_b = this.audioContext) === null || _b === void 0 ? void 0 : _b.state) === 'running';
-      if (newContextIsRunning !== this.canPlaybackAudio) {
-        this.audioEnabled = newContextIsRunning;
-        this.emit(RoomEvent.AudioPlaybackStatusChanged, newContextIsRunning);
+      const contextToClose = this.ownsAudioContext ? this.audioContext : undefined;
+      this.audioContext = audioContext;
+      this.ownsAudioContext = ownsAudioContext;
+      try {
+        // every audio track rebuilds its nodes in the new context, which has to happen before the
+        // previous one is closed so that processors can move off it while it is still alive
+        if (this.options.webAudioMix) {
+          yield Promise.all(Array.from(this.remoteParticipants.values()).map(participant => participant.setAudioContext(audioContext)));
+        }
+        yield this.localParticipant.setAudioContext(audioContext);
+      } catch (error) {
+        // the context is being abandoned either way, so a track that failed to move off it must
+        // not stop us closing it — that would leak the context this whole path exists to release
+        this.log.warn('Could not move audio tracks to the new audio context', Object.assign(Object.assign({}, this.logContext), {
+          error
+        }));
+      } finally {
+        if (contextToClose && contextToClose.state !== 'closed') {
+          try {
+            yield contextToClose.close();
+          } catch (error) {
+            this.log.warn('Could not close audio context', Object.assign(Object.assign({}, this.logContext), {
+              error
+            }));
+          }
+        }
       }
     });
   }
+  /**
+   * Detaches the web audio graph the SDK built from the current audio context and closes that
+   * context if the SDK created it. A context provided through `webAudioMix` is left untouched.
+   */
+  releaseAudioContext() {
+    return __awaiter(this, arguments, void 0, function () {
+      var _this5 = this;
+      let retainedAudioTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return function* () {
+        // both reads happen before the first await, so they describe the room as it was when the
+        // disconnect started rather than after a reconnect has had a chance to run
+        _this5.audioContextReleased = true;
+        const contextToRelease = _this5.audioContext;
+        const unlock = yield _this5.audioContextMutex.lock();
+        try {
+          if (!_this5.audioContextReleased || _this5.audioContext !== contextToRelease) {
+            // a reconnect acquired a new context while we were waiting, closing it would leave the
+            // reconnected room without one
+            return;
+          }
+          if (!_this5.ownsAudioContext) {
+            // a provided context stays open, so tracks that outlive the room stay functional on it.
+            // The tracks this room detached have released their nodes during track teardown already.
+            // read under the lock: an acquire queued behind an in-flight release flips this flag
+            return;
+          }
+          try {
+            // tracks that outlive the room aren't reachable through the local participant anymore,
+            // but still hold web audio nodes in the context we're about to close
+            yield Promise.all(retainedAudioTracks.map(track => track.setAudioContext(undefined)));
+          } catch (error) {
+            _this5.log.warn('Could not detach retained audio tracks from the audio context', Object.assign(Object.assign({}, _this5.logContext), {
+              error
+            }));
+          }
+          // the participant maps have already been cleared by `handleDisconnect`, so this reaches no
+          // tracks of its own — `retainedAudioTracks` above is what detaches them
+          yield _this5.setRoomAudioContext(undefined, false);
+        } finally {
+          unlock();
+        }
+      }();
+    });
+  }
   createParticipant(identity, info) {
     var _a;
     let participant;
@@ -35490,7 +36726,9 @@ class Room extends eventsExports.EventEmitter {
       });
     }
     if (this.options.webAudioMix) {
-      participant.setAudioContext(this.audioContext);
+      participant.setAudioContext(this.audioContext).catch(error => this.log.warn('Could not set audio context', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
     }
     if ((_a = this.options.audioOutput) === null || _a === void 0 ? void 0 : _a.deviceId) {
       participant.setAudioOutput(this.options.audioOutput).catch(e => this.log.warn("Could not set audio output: ".concat(e.message)));
@@ -35603,28 +36841,28 @@ class Room extends eventsExports.EventEmitter {
     }
     // 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()) {
+    if (isDeflateRawCompressionSupported()) {
       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;
+      var _this6 = this;
       let identity = _ref7.identity;
       return function* () {
         var _b;
         const attributes = (_b = reader.info.attributes) !== null && _b !== void 0 ? _b : {};
-        yield _this4.rpcServerManager.handleIncomingDataStream(reader, identity, attributes);
+        yield _this6.rpcServerManager.handleIncomingDataStream(reader, identity, attributes);
       }();
     }));
     this.incomingDataStreamManager.registerTextStreamHandler(RPC_RESPONSE_DATA_STREAM_TOPIC, (reader_1, _a) => __awaiter(this, [reader_1, _a], void 0, function (reader, _ref8) {
-      var _this5 = this;
+      var _this7 = this;
       let identity = _ref8.identity;
       return function* () {
         var _b;
         const attributes = (_b = reader.info.attributes) !== null && _b !== void 0 ? _b : {};
-        yield _this5.rpcClientManager.handleIncomingDataStream(reader, identity, attributes);
+        yield _this7.rpcClientManager.handleIncomingDataStream(reader, identity, attributes);
       }();
     }));
   }
@@ -35783,7 +37021,7 @@ class Room extends eventsExports.EventEmitter {
           type: TrackType.AUDIO
         }), new LocalAudioTrack(publishOptions.useRealTracks && ((_c = navigator.mediaDevices) === null || _c === void 0 ? void 0 : _c.getUserMedia) ? (yield navigator.mediaDevices.getUserMedia({
           audio: true
-        })).getAudioTracks()[0] : getEmptyAudioStreamTrack(), undefined, false, this.audioContext, {
+        })).getAudioTracks()[0] : this.acquireEmptyAudioStreamTrack(), undefined, false, this.audioContext, {
           loggerName: this.options.loggerName,
           loggerContextCb: () => this.logContext
         }), {
@@ -35814,7 +37052,7 @@ class Room extends eventsExports.EventEmitter {
           info.tracks = [...info.tracks, videoTrack];
         }
         if (participantOptions.audio) {
-          const dummyTrack = getEmptyAudioStreamTrack();
+          const dummyTrack = this.acquireEmptyAudioStreamTrack();
           const audioTrack = new TrackInfo({
             source: TrackSource.MICROPHONE,
             sid: Math.floor(Math.random() * 10000).toString(),
@@ -36653,225 +37891,186 @@ class TokenSourceFixed {}
  * and {@link TokenSourceCustom}.
  */
 class TokenSourceConfigurable {}new TextEncoder();
-const decoder = new TextDecoder();
-const strictDecoder = new TextDecoder('utf-8', {
-  fatal: true
-});class JOSEError extends Error {
+  const decoder = new TextDecoder(),
+  strictDecoder = new TextDecoder("utf-8", {
+    fatal: true
+  });
+function decodeBase64(encoded) {
+  let url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (Uint8Array.fromBase64) return Uint8Array.fromBase64(encoded, {
+    alphabet: url ? "base64url" : "base64"
+  });
+  if (url) {
+    if (encoded.includes("+") || encoded.includes("/")) throw new TypeError("Invalid base64url");
+    encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  }
+  const binary = atob(encoded),
+    bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}class JOSEError extends Error {
   constructor(message, options) {
     var _Error$captureStackTr;
-    super(message, options);
-    _defineProperty(this, "code", 'ERR_JOSE_GENERIC');
-    this.name = this.constructor.name;
-    (_Error$captureStackTr = Error.captureStackTrace) === null || _Error$captureStackTr === void 0 || _Error$captureStackTr.call(Error, this, this.constructor);
+    super(message, options), _defineProperty(this, "code", "ERR_JOSE_GENERIC"), this.name = this.constructor.name, (_Error$captureStackTr = Error.captureStackTrace) === null || _Error$captureStackTr === void 0 ? void 0 : _Error$captureStackTr.call(Error, this, this.constructor);
   }
 }
-_defineProperty(JOSEError, "code", 'ERR_JOSE_GENERIC');
+_defineProperty(JOSEError, "code", "ERR_JOSE_GENERIC");
 class JWTClaimValidationFailed extends JOSEError {
   constructor(message, payload) {
-    let claim = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'unspecified';
-    let reason = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unspecified';
+    let claim = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "unspecified";
+    let reason = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "unspecified";
     super(message, {
       cause: {
         claim,
         reason,
         payload
       }
-    });
-    _defineProperty(this, "code", 'ERR_JWT_CLAIM_VALIDATION_FAILED');
-    _defineProperty(this, "claim", void 0);
-    _defineProperty(this, "reason", void 0);
-    _defineProperty(this, "payload", void 0);
-    this.claim = claim;
-    this.reason = reason;
-    this.payload = payload;
+    }), _defineProperty(this, "code", "ERR_JWT_CLAIM_VALIDATION_FAILED"), _defineProperty(this, "claim", void 0), _defineProperty(this, "reason", void 0), _defineProperty(this, "payload", void 0), this.claim = claim, this.reason = reason, this.payload = payload;
   }
 }
-_defineProperty(JWTClaimValidationFailed, "code", 'ERR_JWT_CLAIM_VALIDATION_FAILED');
+_defineProperty(JWTClaimValidationFailed, "code", "ERR_JWT_CLAIM_VALIDATION_FAILED");
 class JWTExpired extends JOSEError {
   constructor(message, payload) {
-    let claim = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'unspecified';
-    let reason = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unspecified';
+    let claim = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "unspecified";
+    let reason = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "unspecified";
     super(message, {
       cause: {
         claim,
         reason,
         payload
       }
-    });
-    _defineProperty(this, "code", 'ERR_JWT_EXPIRED');
-    _defineProperty(this, "claim", void 0);
-    _defineProperty(this, "reason", void 0);
-    _defineProperty(this, "payload", void 0);
-    this.claim = claim;
-    this.reason = reason;
-    this.payload = payload;
+    }), _defineProperty(this, "code", "ERR_JWT_EXPIRED"), _defineProperty(this, "claim", void 0), _defineProperty(this, "reason", void 0), _defineProperty(this, "payload", void 0), this.claim = claim, this.reason = reason, this.payload = payload;
   }
 }
-_defineProperty(JWTExpired, "code", 'ERR_JWT_EXPIRED');
+_defineProperty(JWTExpired, "code", "ERR_JWT_EXPIRED");
 class JOSEAlgNotAllowed extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JOSE_ALG_NOT_ALLOWED');
+    _defineProperty(this, "code", "ERR_JOSE_ALG_NOT_ALLOWED");
   }
 }
-_defineProperty(JOSEAlgNotAllowed, "code", 'ERR_JOSE_ALG_NOT_ALLOWED');
+_defineProperty(JOSEAlgNotAllowed, "code", "ERR_JOSE_ALG_NOT_ALLOWED");
 class JOSENotSupported extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JOSE_NOT_SUPPORTED');
+    _defineProperty(this, "code", "ERR_JOSE_NOT_SUPPORTED");
   }
 }
-_defineProperty(JOSENotSupported, "code", 'ERR_JOSE_NOT_SUPPORTED');
+_defineProperty(JOSENotSupported, "code", "ERR_JOSE_NOT_SUPPORTED");
 class JWEDecryptionFailed extends JOSEError {
   constructor() {
-    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'decryption operation failed';
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "decryption operation failed";
     let options = arguments.length > 1 ? arguments[1] : undefined;
     super(message, options);
-    _defineProperty(this, "code", 'ERR_JWE_DECRYPTION_FAILED');
+    _defineProperty(this, "code", "ERR_JWE_DECRYPTION_FAILED");
   }
 }
-_defineProperty(JWEDecryptionFailed, "code", 'ERR_JWE_DECRYPTION_FAILED');
+_defineProperty(JWEDecryptionFailed, "code", "ERR_JWE_DECRYPTION_FAILED");
 class JWEInvalid extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JWE_INVALID');
+    _defineProperty(this, "code", "ERR_JWE_INVALID");
   }
 }
-_defineProperty(JWEInvalid, "code", 'ERR_JWE_INVALID');
+_defineProperty(JWEInvalid, "code", "ERR_JWE_INVALID");
 class JWSInvalid extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JWS_INVALID');
+    _defineProperty(this, "code", "ERR_JWS_INVALID");
   }
 }
-_defineProperty(JWSInvalid, "code", 'ERR_JWS_INVALID');
+_defineProperty(JWSInvalid, "code", "ERR_JWS_INVALID");
 class JWTInvalid extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JWT_INVALID');
+    _defineProperty(this, "code", "ERR_JWT_INVALID");
   }
 }
-_defineProperty(JWTInvalid, "code", 'ERR_JWT_INVALID');
+_defineProperty(JWTInvalid, "code", "ERR_JWT_INVALID");
 class JWKInvalid extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JWK_INVALID');
+    _defineProperty(this, "code", "ERR_JWK_INVALID");
   }
 }
-_defineProperty(JWKInvalid, "code", 'ERR_JWK_INVALID');
+_defineProperty(JWKInvalid, "code", "ERR_JWK_INVALID");
 class JWKSInvalid extends JOSEError {
   constructor() {
     super(...arguments);
-    _defineProperty(this, "code", 'ERR_JWKS_INVALID');
+    _defineProperty(this, "code", "ERR_JWKS_INVALID");
   }
 }
-_defineProperty(JWKSInvalid, "code", 'ERR_JWKS_INVALID');
+_defineProperty(JWKSInvalid, "code", "ERR_JWKS_INVALID");
 class JWKSNoMatchingKey extends JOSEError {
   constructor() {
-    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'no applicable key found in the JSON Web Key Set';
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "no applicable key found in the JSON Web Key Set";
     let options = arguments.length > 1 ? arguments[1] : undefined;
     super(message, options);
-    _defineProperty(this, "code", 'ERR_JWKS_NO_MATCHING_KEY');
+    _defineProperty(this, "code", "ERR_JWKS_NO_MATCHING_KEY");
   }
 }
-_defineProperty(JWKSNoMatchingKey, "code", 'ERR_JWKS_NO_MATCHING_KEY');
+_defineProperty(JWKSNoMatchingKey, "code", "ERR_JWKS_NO_MATCHING_KEY");
 class JWKSMultipleMatchingKeys extends JOSEError {
   constructor() {
-    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'multiple matching keys found in the JSON Web Key Set';
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "multiple matching keys found in the JSON Web Key Set";
     let options = arguments.length > 1 ? arguments[1] : undefined;
     super(message, options);
     _defineProperty(this, Symbol.asyncIterator, _wrapAsyncGenerator(function* () {}));
-    _defineProperty(this, "code", 'ERR_JWKS_MULTIPLE_MATCHING_KEYS');
+    _defineProperty(this, "code", "ERR_JWKS_MULTIPLE_MATCHING_KEYS");
   }
 }
-_defineProperty(JWKSMultipleMatchingKeys, "code", 'ERR_JWKS_MULTIPLE_MATCHING_KEYS');
+_defineProperty(JWKSMultipleMatchingKeys, "code", "ERR_JWKS_MULTIPLE_MATCHING_KEYS");
 class JWKSTimeout extends JOSEError {
   constructor() {
-    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'request timed out';
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "request timed out";
     let options = arguments.length > 1 ? arguments[1] : undefined;
     super(message, options);
-    _defineProperty(this, "code", 'ERR_JWKS_TIMEOUT');
+    _defineProperty(this, "code", "ERR_JWKS_TIMEOUT");
   }
 }
-_defineProperty(JWKSTimeout, "code", 'ERR_JWKS_TIMEOUT');
+_defineProperty(JWKSTimeout, "code", "ERR_JWKS_TIMEOUT");
 class JWSSignatureVerificationFailed extends JOSEError {
   constructor() {
-    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'signature verification failed';
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "signature verification failed";
     let options = arguments.length > 1 ? arguments[1] : undefined;
     super(message, options);
-    _defineProperty(this, "code", 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');
+    _defineProperty(this, "code", "ERR_JWS_SIGNATURE_VERIFICATION_FAILED");
   }
 }
-_defineProperty(JWSSignatureVerificationFailed, "code", 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');function decodeBase64(encoded) {
-  if (Uint8Array.fromBase64) {
-    return Uint8Array.fromBase64(encoded);
-  }
-  const binary = atob(encoded);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}const invalid = 'The input to be decoded is not correctly encoded.';
+_defineProperty(JWSSignatureVerificationFailed, "code", "ERR_JWS_SIGNATURE_VERIFICATION_FAILED");const invalid = "The input to be decoded is not correctly encoded.";
 function decode(input) {
-  if (Uint8Array.fromBase64) {
-    try {
-      return Uint8Array.fromBase64(typeof input === 'string' ? input : decoder.decode(input), {
-        alphabet: 'base64url'
-      });
-    } catch (cause) {
-      throw new TypeError(invalid, {
-        cause
-      });
-    }
-  }
-  let encoded = input;
-  if (encoded instanceof Uint8Array) {
-    encoded = decoder.decode(encoded);
-  }
-  if (encoded.includes('+') || encoded.includes('/')) {
-    throw new TypeError(invalid);
-  }
-  encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
   try {
-    return decodeBase64(encoded);
-  } catch (_unused) {
-    throw new TypeError(invalid);
+    return decodeBase64(typeof input == "string" ? input : decoder.decode(input), !0);
+  } catch (cause) {
+    throw new TypeError(invalid, {
+      cause
+    });
   }
 }function isObject(input) {
-  if (typeof input !== 'object' || input === null || Object.prototype.toString.call(input) !== '[object Object]') {
-    return false;
-  }
+  if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]") return false;
   const prototype = Object.getPrototypeOf(input);
-  if (prototype === null) {
-    return true;
-  }
-  let proto = prototype;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return prototype === proto;
+  return prototype === null || Object.getPrototypeOf(prototype) === null;
 }function decodeJwt(jwt) {
-  if (typeof jwt !== 'string') throw new JWTInvalid('JWTs must use Compact JWS serialization, JWT must be a string');
-  const _jwt$split = jwt.split('.'),
+  if (typeof jwt != "string") throw new JWTInvalid("JWTs must use Compact JWS serialization, JWT must be a string");
+  const _jwt$split = jwt.split("."),
     payload = _jwt$split[1],
     length = _jwt$split.length;
-  if (length === 5) throw new JWTInvalid('Only JWTs using Compact JWS serialization can be decoded');
-  if (length !== 3) throw new JWTInvalid('Invalid JWT');
-  if (!payload) throw new JWTInvalid('JWTs must contain a payload');
+  if (length === 5) throw new JWTInvalid("Only JWTs using Compact JWS serialization can be decoded");
+  if (length !== 3) throw new JWTInvalid("Invalid JWT");
+  if (!payload) throw new JWTInvalid("JWTs must contain a payload");
   let decoded;
   try {
     decoded = decode(payload);
   } catch (_unused) {
-    throw new JWTInvalid('Failed to base64url decode the payload');
+    throw new JWTInvalid("Failed to base64url decode the payload");
   }
   let result;
   try {
     result = JSON.parse(strictDecoder.decode(decoded));
   } catch (_unused2) {
-    throw new JWTInvalid('Failed to parse the decoded payload as JSON');
+    throw new JWTInvalid("Failed to parse the decoded payload as JSON");
   }
-  if (!isObject(result)) throw new JWTInvalid('Invalid JWT Claims Set');
+  if (!isObject(result)) throw new JWTInvalid("Invalid JWT Claims Set");
   return result;
 }const ONE_SECOND_IN_MILLISECONDS = 1000;
 const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
@@ -37279,4 +38478,4 @@ const serializers = {
   json,
   raw,
   custom
-};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,isSVCCodec,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsH265,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,canFailOverToAnotherRegion,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,isSVCCodec,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,releaseEmptyAudioStreamTrack,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsH265,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map