livekit-client 2.22.2 → 2.22.4

package/dist/livekit-client.esm.mjs

@@ -930,7 +930,10 @@ function isScalarZeroValue(type, value) {
       return value == 0;
     // Loose comparison matches 0n, 0 and "0"
   }
-}function _arrayLikeToArray(r, a) {
+}function _OverloadYield(e, d) {
+  this.v = e, this.k = d;
+}
+function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
   for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
   return n;
@@ -1046,7 +1049,61 @@ function _unsupportedIterableToArray(r, a) {
     var t = {}.toString.call(r).slice(8, -1);
     return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
   }
-}/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
+}
+function _wrapAsyncGenerator(e) {
+  return function () {
+    return new AsyncGenerator(e.apply(this, arguments));
+  };
+}
+function AsyncGenerator(e) {
+  var t, n;
+  function resume(t, n) {
+    try {
+      var r = e[t](n),
+        o = r.value,
+        u = o instanceof _OverloadYield;
+      Promise.resolve(u ? o.v : o).then(function (n) {
+        if (u) {
+          var i = "return" === t && o.k ? t : "next";
+          if (!o.k || n.done) return resume(i, n);
+          n = e[i](n).value;
+        }
+        settle(!!r.done, n);
+      }, function (e) {
+        resume("throw", e);
+      });
+    } catch (e) {
+      settle(2, e);
+    }
+  }
+  function settle(e, r) {
+    2 === e ? t.reject(r) : t.resolve({
+      value: r,
+      done: e
+    }), (t = t.next) ? resume(t.key, t.arg) : n = null;
+  }
+  this._invoke = function (e, r) {
+    return new Promise(function (o, u) {
+      var i = {
+        key: e,
+        arg: r,
+        resolve: o,
+        reject: u,
+        next: null
+      };
+      n ? n = n.next = i : (t = n = i, resume(e, r));
+    });
+  }, "function" != typeof e.return && (this.return = void 0);
+}
+AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+  return this;
+}, AsyncGenerator.prototype.next = function (e) {
+  return this._invoke("next", e);
+}, AsyncGenerator.prototype.throw = function (e) {
+  return this._invoke("throw", e);
+}, AsyncGenerator.prototype.return = function (e) {
+  return this._invoke("return", e);
+};/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
 /**
  * Protobuf binary format wire types.
  *
@@ -5416,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,
@@ -5784,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,
@@ -7768,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,
@@ -8625,7 +8693,21 @@ function setLogExtension(extension, logger) {
     logR.setLevel(logR.getLevel());
   });
 }
-const workerLogger = loglevelExports.getLogger(LoggerNames.E2EE);const maxRetryDelay = 7000;
+const workerLogger = loglevelExports.getLogger(LoggerNames.E2EE);
+const workerLogLevelListeners = new Set();
+const originalWorkerSetLevel = workerLogger.setLevel.bind(workerLogger);
+workerLogger.setLevel = (level, persist) => {
+  originalWorkerSetLevel(level, persist);
+  const numeric = workerLogger.getLevel();
+  workerLogLevelListeners.forEach(cb => cb(numeric));
+};
+/** @internal Subscribe to workerLogger level changes (so E2EE workers can be kept in sync). */
+function onWorkerLogLevelChanged(cb) {
+  workerLogLevelListeners.add(cb);
+  return () => {
+    workerLogLevelListeners.delete(cb);
+  };
+}const maxRetryDelay = 7000;
 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) {
@@ -12208,7 +12290,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.2";const version = version$1;
+}var version$1 = "2.22.4";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -12289,6 +12371,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');
@@ -12622,7 +12730,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";
   /**
@@ -12980,6 +13088,7 @@ var EngineEvent;
   EngineEvent["Joined"] = "joined";
   EngineEvent["TokenRefreshed"] = "tokenRefreshed";
   EngineEvent["ServerRegionsReported"] = "serverRegionsReported";
+  EngineEvent["RequestSubscribedCodecRefresh"] = "requestSubscribedCodecRefresh";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -13674,6 +13783,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.
@@ -14216,6 +14404,56 @@ function negotiateDependencyDescriptor(transceiver) {
     return false;
   }
 }
+/**
+ * VP9 and AV1 are published as SVC (a single RTP stream carrying every spatial layer)
+ * by default. They can instead be published as real, rid based simulcast — one
+ * independent stream per rid, each carrying a single spatial layer — when the caller
+ * opts in with `simulcast: true` and a single spatial layer scalability mode (`L1Tx`).
+ *
+ * The SFU has to be told about this: without an explicit
+ * `SimulcastCodec.videoLayerMode` it assumes `MULTIPLE_SPATIAL_LAYERS_PER_STREAM` for
+ * any SVC capable codec.
+ */
+function isSVCSimulcast(codec, options) {
+  var _a;
+  return isSVCCodec(codec) && !!(options === null || options === void 0 ? void 0 : options.simulcast) && !!((_a = options.scalabilityMode) === null || _a === void 0 ? void 0 : _a.startsWith('L1T'));
+}
+/**
+ * Whether the browser reads multiple encodings on an SVC capable codec as *legacy SVC*
+ * rather than as real simulcast.
+ *
+ * Before Chrome M113, supplying more than one encoding for VP9/AV1 selected SVC mode;
+ * only from M113 does libwebrtc treat such encodings as simulcast, and only when each
+ * one carries its own scalabilityMode. Safari (and anything WebKit based, i. e. every
+ * browser on iOS) still uses the old interpretation, as does React Native's libwebrtc.
+ * Announced at https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw
+ *
+ * Where this is true the rids would not exist on the wire, so VP9/AV1 must be published
+ * as SVC no matter what the caller asked for.
+ */
+function usesLegacySVCEncodings() {
+  const browser = getBrowser();
+  return isSafariBased() ||
+  // Even tho RN runs M114, it does not produce SVC layers when a single encoding
+  // is provided. So we'll use the legacy SVC specification for now.
+  // TODO: when we upstream libwebrtc, this will need additional verification
+  isReactNative() || (browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && compareVersions(browser.version, '113') < 0;
+}
+/**
+ * Last server version that doesn't support vp9/av1 simulcast.
+ */
+const svcSimulcastMinServerVersion = '1.13.6';
+/**
+ * Whether the connected server honours `SimulcastCodec.videoLayerMode`, i. e. whether
+ * VP9/AV1 can be published as rid based simulcast. An unknown version is treated as
+ * unsupported so the publish falls back to SVC.
+ */
+function isSVCSimulcastSupportedByServer(serverVersion) {
+  if (!serverVersion) {
+    return false;
+  }
+  return compareVersions(serverVersion, svcSimulcastMinServerVersion) > 0;
+}
 function supportsSetSinkId(elm) {
   if (!document || isSafariBased()) {
     return false;
@@ -14263,6 +14501,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;
@@ -14754,6 +15018,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();
@@ -14824,6 +15117,15 @@ function getAbortReasonAsString(signal) {
     default:
       return 'toString' in reason ? reason.toString() : defaultMessage;
   }
+}
+function getErrorDescription(error, errorCategory) {
+  if (error instanceof Error) {
+    if (error.name && error.message) {
+      return "".concat(error.name, ": ").concat(error.message);
+    }
+    return error.name;
+  }
+  return "Encountered unknown ".concat(errorCategory, " error: ").concat(String(error));
 }const ENCRYPTION_ALGORITHM = 'AES-GCM';
 // How many consecutive frames can fail decrypting before a particular key gets marked as invalid
 const DECRYPTION_FAILURE_TOLERANCE = 10;
@@ -15747,11 +16049,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
@@ -15775,10 +16104,18 @@ function isElementInViewport(el, win) {
  * @experimental
  */
 class E2EEManager extends eventsExports.EventEmitter {
+  get logContext() {
+    var _a, _b;
+    return {
+      room: (_a = this.room) === null || _a === void 0 ? void 0 : _a.name,
+      participant: (_b = this.room) === null || _b === void 0 ? void 0 : _b.localParticipant.identity
+    };
+  }
   constructor(options, dcEncryptionEnabled) {
     super();
     this.decryptDataRequests = new Map();
     this.encryptDataRequests = new Map();
+    this.log = getLogger(LoggerNames.E2EE, () => this.logContext);
     this.onWorkerMessage = ev => {
       var _a, _b;
       const _ev$data = ev.data,
@@ -15786,22 +16123,22 @@ class E2EEManager extends eventsExports.EventEmitter {
         data = _ev$data.data;
       switch (kind) {
         case 'error':
-          livekitLogger.error(data.error.message);
-          // If error has uuid, it's from an async operation (encrypt/decrypt)
-          // Reject the corresponding future
+          // If error has uuid, it's from an async operation (encrypt/decrypt).
+          // Reject the corresponding future and let the caller decide how to log/handle;
+          // logging here would duplicate whatever the caller does.
           if (data.uuid) {
             const decryptFuture = this.decryptDataRequests.get(data.uuid);
             if (decryptFuture === null || decryptFuture === void 0 ? void 0 : decryptFuture.reject) {
               decryptFuture.reject(data.error);
-              break; // Don't emit general error if it's handled by future
+              break;
             }
             const encryptFuture = this.encryptDataRequests.get(data.uuid);
             if (encryptFuture === null || encryptFuture === void 0 ? void 0 : encryptFuture.reject) {
               encryptFuture.reject(data.error);
-              break; // Don't emit general error if it's handled by future
+              break;
             }
           }
-          // Emit general error event for unhandled errors
+          this.log.error(data.error.message);
           this.emit(EncryptionEvent.EncryptionError, data.error, data.participantIdentity);
           break;
         case 'initAck':
@@ -15846,10 +16183,13 @@ class E2EEManager extends eventsExports.EventEmitter {
         case 'packetTrailerMetadata':
           this.handleFrameMetadata(data.trackId, data.rtpTimestamp, data.ssrc, data.metadata);
           break;
+        case 'log':
+          workerLogger[data.level](data.msg, data.context);
+          break;
       }
     };
     this.onWorkerError = ev => {
-      livekitLogger.error('e2ee worker encountered an error:', {
+      this.log.error('e2ee worker encountered an error:', {
         error: ev.error
       });
       this.emit(EncryptionEvent.EncryptionError, ev.error, undefined);
@@ -15872,7 +16212,7 @@ class E2EEManager extends eventsExports.EventEmitter {
     if (!isE2EESupported()) {
       throw new DeviceUnsupportedError('tried to setup end-to-end encryption on an unsupported browser');
     }
-    livekitLogger.info('setting up e2ee');
+    this.log.info('setting up e2ee');
     if (room !== this.room) {
       this.room = room;
       this.setupEventListeners(room, this.keyProvider);
@@ -15885,20 +16225,94 @@ class E2EEManager extends eventsExports.EventEmitter {
         }
       };
       if (this.worker) {
-        livekitLogger.info("initializing worker", {
+        this.log.info("initializing worker", {
           worker: this.worker
         });
         this.worker.onmessage = this.onWorkerMessage;
         this.worker.onerror = this.onWorkerError;
         this.worker.postMessage(msg);
+        this.subscribeToLogLevelChanges();
       }
     }
   }
+  /**
+   * Subscribe the current worker to main-thread `workerLogger` level changes,
+   * without strongly retaining `this` or `this.worker` from the module-global
+   * listener Set on the logger. See {@link disposeRegistry}.
+   */
+  subscribeToLogLevelChanges() {
+    var _a;
+    // Guard against duplicate registration on re-setup.
+    (_a = this.unsubscribeLogLevel) === null || _a === void 0 ? void 0 : _a.call(this);
+    let unsub;
+    if (E2EEManager.disposeRegistry) {
+      // Modern engines: hold the worker weakly so the module-global listener Set
+      // on the logger can't retain this manager, and clean up the entry on GC.
+      const workerRef = new WeakRef(this.worker);
+      unsub = onWorkerLogLevelChanged(level => {
+        const worker = workerRef.deref();
+        if (!worker) {
+          unsub === null || unsub === void 0 ? void 0 : unsub();
+          return;
+        }
+        worker.postMessage({
+          kind: 'setLogLevel',
+          data: {
+            level
+          }
+        });
+      });
+      E2EEManager.disposeRegistry.register(this, unsub, this);
+    } else {
+      // Safari <14.1 and similar: no WeakRef. Fall back to a strong reference;
+      // the leak lives until the consumer calls `dispose()`.
+      const worker = this.worker;
+      unsub = onWorkerLogLevelChanged(level => {
+        worker.postMessage({
+          kind: 'setLogLevel',
+          data: {
+            level
+          }
+        });
+      });
+    }
+    this.unsubscribeLogLevel = unsub;
+  }
+  /**
+   * @internal
+   * Release the log-level subscription, reject any pending encrypt/decrypt
+   * futures, and detach the worker message handlers. The worker itself is
+   * caller-owned and is not terminated. Idempotent.
+   */
+  dispose() {
+    var _a, _b, _c;
+    (_a = this.unsubscribeLogLevel) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unsubscribeLogLevel = undefined;
+    if (E2EEManager.disposeRegistry) {
+      E2EEManager.disposeRegistry.unregister(this);
+    }
+    // Reject pending futures BEFORE detaching worker handlers, so any late
+    // response can't resolve one after we've cut the pipe. Each future's
+    // `onFinally` deletes its own map entry, so both maps drain themselves.
+    // Snapshot before iterating in case a rejection handler mutates the map.
+    const disposalError = new CryptorError('E2EEManager disposed', CryptorErrorReason.InternalError);
+    for (const future of [...this.encryptDataRequests.values()]) {
+      (_b = future.reject) === null || _b === void 0 ? void 0 : _b.call(future, disposalError);
+    }
+    for (const future of [...this.decryptDataRequests.values()]) {
+      (_c = future.reject) === null || _c === void 0 ? void 0 : _c.call(future, disposalError);
+    }
+    if (this.worker) {
+      this.worker.onmessage = null;
+      this.worker.onerror = null;
+    }
+    this.removeAllListeners();
+  }
   /**
    * @internal
    */
   setParticipantCryptorEnabled(enabled, participantIdentity) {
-    livekitLogger.debug("set e2ee to ".concat(enabled, " for participant ").concat(participantIdentity));
+    this.log.debug("set e2ee to ".concat(enabled, " for participant ").concat(participantIdentity));
     this.postEnable(enabled, participantIdentity);
   }
   /**
@@ -15906,7 +16320,7 @@ class E2EEManager extends eventsExports.EventEmitter {
    */
   setSifTrailer(trailer) {
     if (!trailer || trailer.length === 0) {
-      livekitLogger.warn("ignoring server sent trailer as it's empty");
+      this.log.warn("ignoring server sent trailer as it's empty");
     } else {
       this.postSifTrailer(trailer);
     }
@@ -16113,8 +16527,7 @@ class E2EEManager extends eventsExports.EventEmitter {
    */
   setParticipantCryptorEnabledForPublication(pub, participantIdentity) {
     if (!pub.trackInfo) {
-      livekitLogger.warn('skipping e2ee enabled update for publication without trackInfo', {
-        participant: participantIdentity,
+      this.log.warn('skipping e2ee enabled update for publication without trackInfo', {
         trackSid: pub.trackSid
       });
       return;
@@ -16134,7 +16547,7 @@ class E2EEManager extends eventsExports.EventEmitter {
   setupE2EESender(track, sender) {
     var _a, _b, _c;
     if (!isLocalTrack(track) || !sender) {
-      if (!sender) livekitLogger.warn('early return because sender is not ready');
+      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);
@@ -16227,7 +16640,7 @@ class E2EEManager extends eventsExports.EventEmitter {
       throw TypeError('local identity needs to be known in order to set up encrypted sender');
     }
     if (isScriptTransformSupportedForWorker()) {
-      livekitLogger.info('initialize script transform');
+      this.log.info('initialize script transform');
       const options = {
         kind: 'encode',
         participantIdentity: this.room.localParticipant.identity,
@@ -16239,7 +16652,7 @@ class E2EEManager extends eventsExports.EventEmitter {
       // @ts-ignore
       sender.transform = new RTCRtpScriptTransform(this.worker, options);
     } else {
-      livekitLogger.info('initialize encoded streams');
+      this.log.info('initialize encoded streams');
       // @ts-ignore
       const senderStreams = sender.createEncodedStreams();
       const msg = {
@@ -16259,7 +16672,15 @@ class E2EEManager extends eventsExports.EventEmitter {
     // @ts-ignore
     sender[E2EE_FLAG] = true;
   }
-}const MAX_ENTRIES = 300;
+}
+/**
+ * Runs a cleanup callback once this manager is garbage collected. Lets the
+ * log-level listener (held in a module-global Set on the main-thread logger)
+ * fall out of scope even when the consumer forgets to call `dispose()`.
+ */
+E2EEManager.disposeRegistry = typeof FinalizationRegistry !== 'undefined' && typeof WeakRef !== 'undefined' && new FinalizationRegistry(cleanup => {
+  cleanup();
+});const MAX_ENTRIES = 300;
 /**
  * Caches frame metadata extracted from received video frames,
  * keyed by RTP timestamp so it can be looked up when the frame is displayed.
@@ -18070,9 +18491,9 @@ class WebSocketStream {
                 let data = _ref2.data;
                 return controller.enqueue(data);
               };
-              ws.onerror = e => controller.error(ConnectionError.websocket(e instanceof Error ? "".concat(e.name, ": ").concat(e.message) : "Encountered unknown websocket error: ".concat(String(e))));
+              ws.onerror = e => controller.error(ConnectionError.websocket(getErrorDescription(e, 'websocket')));
               ws.onclose = ev => {
-                if (ev.wasClean) {
+                if (ev.wasClean || ev.code === 1000) {
                   controller.close();
                 } else {
                   controller.error(ConnectionError.websocket("WS closed unexpectedly with code ".concat(ev.code)));
@@ -18354,7 +18775,7 @@ class SignalClient {
         const rtcUrl = createRtcUrl(url, params, useV0Path).toString();
         const validateUrl = createValidateUrl(rtcUrl).toString();
         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* () {
@@ -18461,38 +18882,56 @@ 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');
-              }
-              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;
@@ -18506,9 +18945,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);
@@ -18522,11 +18959,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) {
@@ -18962,6 +19396,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({
@@ -18983,6 +19418,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);
         }
@@ -19043,7 +19482,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',
@@ -19065,7 +19504,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
@@ -19075,28 +19514,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)
@@ -19105,7 +19534,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 {
@@ -19210,6 +19639,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());
   }
@@ -19228,7 +19663,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,
@@ -20069,40 +20506,112 @@ function requireLib() {
 const startBitrateMultiplier = 0.9;
 /** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
 const maxStartBitrateKbps = 1000;
+/**
+ * Minimum target bitrate in kbps for the start bitrate hint. Below this, seeding above the
+ * real capacity costs more than the ramp it saves, so libwebrtc's default is left in place.
+ */
+const minTargetBitrateKbps = 300;
 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.
+ *
+ * TODO: adjust dynamically from network conditions (e.g. a previous BWE estimate) rather
+ * than a fixed cap.
+ *
+ * @internal
+ */
+function computeTrackStartBitrate(trackbr) {
+  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 calculated = Math.round(trackbr.maxbr * startBitrateMultiplier);
+  return trackbr.isScreenShare ? calculated : Math.min(calculated, maxStartBitrateKbps);
+}
+/**
+ * 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) {
+  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) : 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) {
-    // 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.
+    // 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);
     }
@@ -20113,7 +20622,7 @@ function applyVideoStartBitrate(media, cid, codec, maxbr) {
       config: "x-google-start-bitrate=".concat(startBitrate)
     });
   }
-  return codecPayload;
+  return true;
 }
 const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
@@ -20141,11 +20650,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
@@ -20254,7 +20772,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,
@@ -20262,6 +20780,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),
@@ -20335,6 +20876,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
@@ -20442,6 +20985,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);
+        let appliedVideoStartBitrate = false;
         sdpParsed.media.forEach(media => {
           ensureIPAddrMatchVersion(media);
           if (media.type === 'audio') {
@@ -20451,12 +21000,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;
             });
@@ -20478,7 +21032,13 @@ 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.onOffer(offer, this.latestOfferId);
       } finally {
         unlock();
@@ -20874,6 +21434,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 = [];
@@ -20965,6 +21538,7 @@ const roomOptionDefaults = {
 };
 const roomConnectOptionDefaults = {
   autoSubscribe: true,
+  disableIceLite: false,
   maxRetries: 1,
   peerConnectionTimeout: 15000,
   websocketTimeout: 15000
@@ -21178,7 +21752,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 {
@@ -22216,21 +22792,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');
@@ -22933,24 +23517,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) {
@@ -22962,6 +23528,8 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
   const useSimulcast = options === null || options === void 0 ? void 0 : options.simulcast;
   const scalabilityMode = options === null || options === void 0 ? void 0 : options.scalabilityMode;
   const videoCodec = options === null || options === void 0 ? void 0 : options.videoCodec;
+  // VP9/AV1 published as rid based simulcast rather than SVC, see isSVCSimulcast
+  const useSVCSimulcast = isSVCSimulcast(videoCodec, options);
   if (!videoEncoding && !useSimulcast && !scalabilityMode || !width || !height) {
     // when we aren't simulcasting or svc, will need to return a single encoding without
     // capping bandwidth. we always require a encoding for dynacast
@@ -22974,23 +23542,16 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
   }
   const sourceFramerate = videoEncoding.maxFramerate;
   const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate, videoEncoding.priority);
-  if (scalabilityMode && isSVCCodec(videoCodec)) {
+  if (scalabilityMode && isSVCCodec(videoCodec) && !useSVCSimulcast) {
     const sm = new ScalabilityMode(scalabilityMode);
     const encodings = [];
     if (sm.spatial > 3) {
       throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
     }
-    // Before M113 in Chrome, defining multiple encodings with an SVC codec indicated
-    // that SVC mode should be used. Safari still works this way.
-    // This is a bit confusing but is due to how libwebrtc interpreted the encodings field
-    // before M113.
-    // Announced here: https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw?pli=1
+    // Browsers that read multiple encodings on an SVC codec as SVC rather than as
+    // simulcast, see usesLegacySVCEncodings
     const browser = getBrowser();
-    if (isSafariBased() ||
-    // Even tho RN runs M114, it does not produce SVC layers when a single encoding
-    // is provided. So we'll use the legacy SVC specification for now.
-    // TODO: when we upstream libwebrtc, this will need additional verification
-    isReactNative() || (browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && compareVersions(browser === null || browser === void 0 ? void 0 : browser.version, '113') < 0) {
+    if (usesLegacySVCEncodings()) {
       const bitratesRatio = sm.suffix == 'h' ? 2 : 3;
       // safari 18.4 uses a different svc API that requires scaleResolutionDownBy to be set.
       const requireScale = isSafariSvcApi(browser);
@@ -23026,6 +23587,18 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
   if (!useSimulcast) {
     return [videoEncoding];
   }
+  // Chrome M113+ only treats multiple encodings on an SVC capable codec as real
+  // simulcast when every encoding carries an explicit scalabilityMode next to its
+  // scaleResolutionDownBy. Without it the encodings are interpreted as legacy SVC.
+  const applySVCSimulcastMode = encodings => {
+    if (useSVCSimulcast) {
+      encodings.forEach(encoding => {
+        /* @ts-ignore */
+        encoding.scalabilityMode = scalabilityMode;
+      });
+    }
+    return encodings;
+  };
   let presets;
   if (isScreenShare) {
     presets = (_a = sortPresets(options === null || options === void 0 ? void 0 : options.screenShareSimulcastLayers)) !== null && _a !== void 0 ? _a : defaultSimulcastLayers(isScreenShare, original);
@@ -23051,13 +23624,38 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
     //      based on other conditions.
     const size = Math.max(width, height);
     if (size >= 960 && midPreset) {
-      return encodingsFromPresets(width, height, [lowPreset, midPreset, original], sourceFramerate);
+      return applySVCSimulcastMode(encodingsFromPresets(width, height, [lowPreset, midPreset, original], sourceFramerate));
     }
     if (size >= 480) {
-      return encodingsFromPresets(width, height, [lowPreset, original], sourceFramerate);
+      return applySVCSimulcastMode(encodingsFromPresets(width, height, [lowPreset, original], sourceFramerate));
     }
   }
-  return encodingsFromPresets(width, height, [original]);
+  return applySVCSimulcastMode(encodingsFromPresets(width, height, [original]));
+}
+/**
+ * Bitrate to hint to the bandwidth estimator through `x-google-start-bitrate`, so that
+ * a publish does not spend its first seconds ramping up from a very low rate.
+ *
+ * It has to be the total the encoder will put on the wire, which means picking the
+ * encoding that carries the inclusive bitrate:
+ *  - SVC publishes a single stream with the layers built in. `encodings[0]` holds the
+ *    full bitrate — the legacy SVC shape orders its encodings `f`..`q`, so that holds
+ *    for both SVC shapes.
+ *  - Simulcast publishes independent streams ordered `q`..`f`, so the total is the sum.
+ *    This includes VP9/AV1 published as rid based simulcast, where `encodings[0]` is
+ *    the *smallest* layer even though the codec is SVC capable.
+ *
+ * @internal
+ */
+function computeStartTargetBitrate(codec, options, encodings) {
+  var _a, _b;
+  if (isSVCCodec(codec) && !isSVCSimulcast(codec, options)) {
+    return (_b = (_a = encodings[0]) === null || _a === void 0 ? void 0 : _a.maxBitrate) !== null && _b !== void 0 ? _b : 0;
+  }
+  return encodings.reduce((sum, enc) => {
+    var _a;
+    return sum + ((_a = enc.maxBitrate) !== null && _a !== void 0 ? _a : 0);
+  }, 0);
 }
 function computeTrackBackupEncodings(track, videoCodec, opts) {
   var _a, _b, _c, _d;
@@ -23511,6 +24109,15 @@ class LocalVideoTrack extends LocalTrack {
       return items;
     });
   }
+  /**
+   * Whether `codec` is being published as SVC (a single stream carrying all spatial
+   * layers) as opposed to rid based simulcast. VP9/AV1 are SVC unless the publisher
+   * opted into simulcast, in which case each rid is an independent stream and the
+   * layers can be enabled/disabled individually.
+   */
+  isSvcPublish(codec) {
+    return isSVCCodec(codec) && !isSVCSimulcast(codec, this.publishOptions);
+  }
   setPublishingQuality(maxQuality) {
     const qualities = [];
     for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
@@ -23520,7 +24127,7 @@ class LocalVideoTrack extends LocalTrack {
       }));
     }
     this.log.debug("setting publishing quality. max quality ".concat(maxQuality), this.logContext);
-    this.setPublishingLayers(isSVCCodec(this.codec), qualities);
+    this.setPublishingLayers(this.isSvcPublish(this.codec), qualities);
   }
   restartTrack(options) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23764,12 +24371,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
@@ -23785,7 +24400,7 @@ class LocalVideoTrack extends LocalTrack {
       }));
       // only enable simulcast codec for preference codec setted
       if (!this.codec && codecs.length > 0) {
-        yield this.setPublishingLayers(isSVCCodec(codecs[0].codec), codecs[0].qualities);
+        yield this.setPublishingLayers(this.isSvcPublish(codecs[0].codec), codecs[0].qualities);
         return [];
       }
       this.subscribedCodecs = codecs;
@@ -23796,7 +24411,7 @@ class LocalVideoTrack extends LocalTrack {
           _a = false;
           const codec = _d;
           if (!this.codec || this.codec === codec.codec) {
-            yield this.setPublishingLayers(isSVCCodec(codec.codec), codec.qualities);
+            yield this.setPublishingLayers(this.isSvcPublish(codec.codec), codec.qualities);
           } else {
             const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec);
             this.log.debug("try setPublishingCodec for ".concat(codec.codec), Object.assign(Object.assign({}, this.logContext), {
@@ -23811,7 +24426,7 @@ class LocalVideoTrack extends LocalTrack {
               }
             } else if (simulcastCodecInfo.encodings) {
               this.log.debug("try setPublishingLayersForSender ".concat(codec.codec), this.logContext);
-              yield setPublishingLayersForSender(simulcastCodecInfo.sender, simulcastCodecInfo.encodings, codec.qualities, this.senderLock, isSVCCodec(codec.codec), this.log, this.logContext);
+              yield setPublishingLayersForSender(simulcastCodecInfo.sender, simulcastCodecInfo.encodings, codec.qualities, this.senderLock, this.isSvcPublish(codec.codec), this.log, this.logContext);
             }
           }
         }
@@ -24071,6 +24686,10 @@ class RTCEngine extends eventsExports.EventEmitter {
   get pendingReconnect() {
     return !!this.reconnectTimeout;
   }
+  get serverVersion() {
+    var _a, _b, _c;
+    return ((_b = (_a = this.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.serverInfo) === null || _b === void 0 ? void 0 : _b.version) || ((_c = this.latestJoinResponse) === null || _c === void 0 ? void 0 : _c.serverVersion) || undefined;
+  }
   get reliableChannel() {
     return this.dataChannels.reliable;
   }
@@ -24110,6 +24729,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;
@@ -24123,7 +24749,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       }();
     });
     this.handleDataMessage = message => __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d;
       // make sure to respect incoming data message order by processing message events one after the other
       const unlock = yield this.dataProcessLock.lock();
       try {
@@ -24148,20 +24774,29 @@ class RTCEngine extends eventsExports.EventEmitter {
             this.log.error('Received encrypted packet but E2EE not set up');
             return;
           }
-          const decryptedData = yield (_c = this.e2eeManager) === null || _c === void 0 ? void 0 : _c.handleEncryptedData(dp.value.value.encryptedValue, dp.value.value.iv, dp.participantIdentity, dp.value.value.keyIndex);
+          let decryptedData;
+          try {
+            decryptedData = yield this.e2eeManager.handleEncryptedData(dp.value.value.encryptedValue, dp.value.value.iv, dp.participantIdentity, dp.value.value.keyIndex);
+          } catch (err) {
+            this.log.debug('failed to decrypt data packet', {
+              error: err,
+              participantIdentity: dp.participantIdentity
+            });
+            return;
+          }
           const decryptedPacket = EncryptedPacketPayload.fromBinary(decryptedData.payload);
           const newDp = new DataPacket({
             value: decryptedPacket.value,
             participantIdentity: dp.participantIdentity,
             participantSid: dp.participantSid
           });
-          if (((_d = newDp.value) === null || _d === void 0 ? void 0 : _d.case) === 'user') {
+          if (((_c = newDp.value) === null || _c === void 0 ? void 0 : _c.case) === 'user') {
             // compatibility
             applyUserDataCompat(newDp, newDp.value.value);
           }
           this.emit(EngineEvent.DataPacketReceived, newDp, dp.value.value.encryptionType);
         } else {
-          if (((_e = dp.value) === null || _e === void 0 ? void 0 : _e.case) === 'user') {
+          if (((_d = dp.value) === null || _d === void 0 ? void 0 : _d.case) === 'user') {
             // compatibility
             applyUserDataCompat(dp, dp.value.value);
           }
@@ -24346,6 +24981,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() {
@@ -24662,8 +25305,13 @@ class RTCEngine extends eventsExports.EventEmitter {
         sdp: sd.sdp,
         midToTrackId
       });
-      this.midToTrackId = midToTrackId;
+      // in dual PC mode the publisher answer carries no mapping (the server's publisher
+      // transport has no sending tracks) and must not clobber the subscriber offer mapping
+      if (this.pcManager.mode === 'publisher-only') {
+        this.midToTrackId = midToTrackId;
+      }
       yield this.pcManager.setPublisherAnswer(sd, offerId);
+      this.emit(EngineEvent.RequestSubscribedCodecRefresh);
     });
     // add candidate on trickle
     this.client.onTrickle = (candidate, target) => {
@@ -24730,7 +25378,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);
@@ -25483,8 +26133,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 {
@@ -25507,8 +26156,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);
         }
       }));
     });
@@ -26309,10 +26957,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;
@@ -26380,10 +27028,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;
@@ -26748,7 +27396,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;
@@ -26857,7 +27505,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)) {
@@ -27054,7 +27702,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,
@@ -29725,20 +30373,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];
       }();
     });
@@ -30091,7 +30756,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()) {
@@ -30140,7 +30805,7 @@ class RpcServerManager extends eventsExports.EventEmitter {
       element.volume = 0;
       element.muted = true;
     }
-    if (this.elementVolume) {
+    if (this.elementVolume !== undefined) {
       // make sure volume setting is being applied to the newly attached element
       this.setVolume(this.elementVolume);
     }
@@ -30200,7 +30865,7 @@ class RpcServerManager extends eventsExports.EventEmitter {
     this.gainNode = context.createGain();
     lastNode.connect(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
@@ -31773,7 +32438,7 @@ class Participant extends eventsExports.EventEmitter {
   }
   publish(track, opts, isStereo) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
       if (!this.hasPermissionsToPublish(track)) {
         throw new PublishTrackError('failed to publish track, insufficient permissions', 403);
       }
@@ -31876,7 +32541,12 @@ class Participant extends eventsExports.EventEmitter {
         req.height = dims.height;
         // for svc codecs, disable simulcast and use vp8 for backup codec
         if (isLocalVideoTrack(track)) {
-          if (isSVCCodec(videoCodec)) {
+          if (isSVCSimulcast(videoCodec, opts) && (usesLegacySVCEncodings() || !isSVCSimulcastSupportedByServer((_e = this.engine) === null || _e === void 0 ? void 0 : _e.serverVersion))) {
+            opts.simulcast = false;
+            this.log.info('SVC simulcast is not supported, disabling simulcast.', getLogContextFromTrack(track));
+          }
+          const svcSimulcast = isSVCSimulcast(videoCodec, opts);
+          if (isSVCCodec(videoCodec) && !svcSimulcast) {
             if (track.source === Track.Source.ScreenShare) {
               // vp9 svc with screenshare cannot encode multiple spatial layers
               // doing so reduces publish resolution to minimal resolution
@@ -31892,12 +32562,16 @@ class Participant extends eventsExports.EventEmitter {
               }
             }
             // set scalabilityMode to 'L3T3_KEY' by default
-            opts.scalabilityMode = (_e = opts.scalabilityMode) !== null && _e !== void 0 ? _e : 'L3T3_KEY';
+            opts.scalabilityMode = (_f = opts.scalabilityMode) !== null && _f !== void 0 ? _f : 'L3T3_KEY';
           }
-          req.simulcastCodecs = [new SimulcastCodec({
+          const primaryCodec = new SimulcastCodec({
             codec: videoCodec,
             cid: track.mediaStreamTrack.id
-          })];
+          });
+          if (svcSimulcast) {
+            primaryCodec.videoLayerMode = VideoLayer_Mode.ONE_SPATIAL_LAYER_PER_STREAM;
+          }
+          req.simulcastCodecs = [primaryCodec];
           // set up backup
           if (opts.backupCodec === true) {
             opts.backupCodec = {
@@ -31918,19 +32592,19 @@ class Participant extends eventsExports.EventEmitter {
           }
         }
         encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, req.width, req.height, opts);
-        req.layers = videoLayersFromEncodings(req.width, req.height, encodings, isSVCCodec(opts.videoCodec));
+        req.layers = videoLayersFromEncodings(req.width, req.height, encodings, isSVCCodec(opts.videoCodec) && !isSVCSimulcast(opts.videoCodec, opts));
       } else if (track.kind === Track.Kind.Audio) {
         encodings = [{
-          maxBitrate: (_f = opts.audioPreset) === null || _f === void 0 ? void 0 : _f.maxBitrate,
-          priority: (_h = (_g = opts.audioPreset) === null || _g === void 0 ? void 0 : _g.priority) !== null && _h !== void 0 ? _h : 'high',
-          networkPriority: (_k = (_j = opts.audioPreset) === null || _j === void 0 ? void 0 : _j.priority) !== null && _k !== void 0 ? _k : 'high'
+          maxBitrate: (_g = opts.audioPreset) === null || _g === void 0 ? void 0 : _g.maxBitrate,
+          priority: (_j = (_h = opts.audioPreset) === null || _h === void 0 ? void 0 : _h.priority) !== null && _j !== void 0 ? _j : 'high',
+          networkPriority: (_l = (_k = opts.audioPreset) === null || _k === void 0 ? void 0 : _k.priority) !== null && _l !== void 0 ? _l : 'high'
         }];
       }
       if (!this.engine || this.engine.isClosed) {
         throw new UnexpectedConnectionState('cannot publish track when not connected');
       }
       const negotiate = () => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
+        var _a, _b;
         if (!this.engine.pcManager) {
           throw new UnexpectedConnectionState('pcManager is not ready');
         }
@@ -31967,13 +32641,9 @@ class Participant extends eventsExports.EventEmitter {
               });
             }
           } else if (track.codec && isVideoCodec(track.codec)) {
-            // Apply start bitrate for all video codecs to prevent initial blurriness.
-            // - SVC codecs: use first encoding's bitrate (single stream with built-in layers)
-            // - Simulcast: sum all encoding bitrates (independent streams, BWE needs total)
-            const targetBitrate = isSVCCodec(track.codec) ? (_d = (_c = encodings[0]) === null || _c === void 0 ? void 0 : _c.maxBitrate) !== null && _d !== void 0 ? _d : 0 : encodings.reduce((sum, enc) => {
-              var _a;
-              return sum + ((_a = enc.maxBitrate) !== null && _a !== void 0 ? _a : 0);
-            }, 0);
+            // Apply start bitrate for all video codecs to prevent initial blurriness,
+            // see computeStartTargetBitrate
+            const targetBitrate = computeStartTargetBitrate(track.codec, opts, encodings);
             if (targetBitrate > 0) {
               this.engine.pcManager.publisher.setTrackCodecBitrate({
                 cid: req.cid,
@@ -33446,7 +34116,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');
@@ -33495,6 +34165,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,
@@ -33933,7 +34605,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') {
@@ -33964,8 +34636,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);
     };
@@ -34212,8 +34884,8 @@ class Room extends eventsExports.EventEmitter {
     });
     this.registerRpcDataStreamHandler();
     this.rpcClientManager = new RpcClientManager(this.log, this.outgoingDataStreamManager, this.getRemoteParticipantClientProtocol, () => {
-      var _a, _b;
-      return (_b = (_a = this.engine.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.serverInfo) === null || _b === void 0 ? void 0 : _b.version;
+      var _a;
+      return (_a = this.engine) === null || _a === void 0 ? void 0 : _a.serverVersion;
     });
     this.rpcClientManager.on('sendDataPacket', _ref2 => {
       let packet = _ref2.packet;
@@ -34540,6 +35212,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);
@@ -34636,8 +35314,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();
@@ -35318,7 +35997,7 @@ 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;
@@ -36368,212 +37047,186 @@ class TokenSourceFixed {}
  * and {@link TokenSourceCustom}.
  */
 class TokenSourceConfigurable {}new TextEncoder();
-const decoder = new TextDecoder();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);
+  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;
-}function decode(input) {
-  if (Uint8Array.fromBase64) {
-    return Uint8Array.fromBase64(typeof input === 'string' ? input : decoder.decode(input), {
-      alphabet: 'base64url'
-    });
-  }
-  let encoded = input;
-  if (encoded instanceof Uint8Array) {
-    encoded = decoder.decode(encoded);
-  }
-  encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
-  try {
-    return decodeBase64(encoded);
-  } catch (_unused) {
-    throw new TypeError('The input to be decoded is not correctly encoded.');
-  }
 }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, void 0);
-    _defineProperty(this, "code", 'ERR_JWKS_MULTIPLE_MATCHING_KEYS');
+    _defineProperty(this, Symbol.asyncIterator, _wrapAsyncGenerator(function* () {}));
+    _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');const isObjectLike = value => typeof value === 'object' && value !== null;
-function isObject(input) {
-  if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') {
-    return false;
-  }
-  if (Object.getPrototypeOf(input) === null) {
-    return true;
-  }
-  let proto = input;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
+_defineProperty(JWSSignatureVerificationFailed, "code", "ERR_JWS_SIGNATURE_VERIFICATION_FAILED");const invalid = "The input to be decoded is not correctly encoded.";
+function decode(input) {
+  try {
+    return decodeBase64(typeof input == "string" ? input : decoder.decode(input), !0);
+  } catch (cause) {
+    throw new TypeError(invalid, {
+      cause
+    });
   }
-  return Object.getPrototypeOf(input) === proto;
+}function isObject(input) {
+  if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]") return false;
+  const prototype = Object.getPrototypeOf(input);
+  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(decoder.decode(decoded));
+    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;
@@ -36981,4 +37634,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,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsH265,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map