livekit-client 2.22.1 → 2.22.3

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.
  *
@@ -8625,7 +8682,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 +12279,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.1";const version = version$1;
+}var version$1 = "2.22.3";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -14216,6 +14287,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;
@@ -14824,11 +14945,25 @@ 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;
 // flag set to indicate that e2ee has been setup for sender/receiver;
 const E2EE_FLAG = 'lk_e2ee';
+/**
+ * trackId a receiver's/sender's encoded stream pipeline was last set up for.
+ * Needed to recover the right cryptor when a transceiver gets reused.
+ */
+const E2EE_TRACK_ID = 'lk_e2ee_track_id';
 const SALT = 'LKFrameEncryptionKey';
 const KEY_PROVIDER_DEFAULTS = {
   sharedKey: false,
@@ -15770,10 +15905,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,
@@ -15781,22 +15924,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':
@@ -15841,10 +15984,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);
@@ -15867,7 +16013,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);
@@ -15880,20 +16026,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);
   }
   /**
@@ -15901,7 +16121,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);
     }
@@ -15925,12 +16145,12 @@ class E2EEManager extends eventsExports.EventEmitter {
     });
   }
   setupEventListeners(room, keyProvider) {
-    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
+    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabledForPublication(pub, participant.identity));
     room.on(RoomEvent.ConnectionStateChanged, state => {
       if (state === ConnectionState.Connected) {
         room.remoteParticipants.forEach(participant => {
           participant.trackPublications.forEach(pub => {
-            this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity);
+            this.setParticipantCryptorEnabledForPublication(pub, participant.identity);
           });
         });
       }
@@ -16100,6 +16320,21 @@ class E2EEManager extends eventsExports.EventEmitter {
     };
     this.worker.postMessage(msg);
   }
+  /**
+   * Derive the participant's encryption state from one of its publications.
+   * Publications without trackInfo are skipped rather than thrown on: throwing
+   * inside the forEach above would leave every remaining participant without an
+   * encryption state, and a cryptor with unknown state can no longer decrypt.
+   */
+  setParticipantCryptorEnabledForPublication(pub, participantIdentity) {
+    if (!pub.trackInfo) {
+      this.log.warn('skipping e2ee enabled update for publication without trackInfo', {
+        trackSid: pub.trackSid
+      });
+      return;
+    }
+    this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participantIdentity);
+  }
   setupE2EEReceiver(track, remoteId, trackInfo) {
     if (!track.receiver) {
       return;
@@ -16113,7 +16348,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);
@@ -16136,21 +16371,27 @@ class E2EEManager extends eventsExports.EventEmitter {
           codec,
           hasPacketTrailer
         };
-        // @ts-ignore
         receiver.transform = new RTCRtpScriptTransform(this.worker, options);
       } else {
-        if (E2EE_FLAG in receiver && codec) {
-          // update track-specific state when the transceiver is reused
+        if (E2EE_FLAG in receiver && E2EE_TRACK_ID in receiver) {
+          // The transceiver is being reused for a new track. We cannot set up a new
+          // pipeline from here: this receiver's encoded streams were transferred to
+          // the worker on first setup and a transferred stream can't be transferred
+          // again, while createEncodedStreams() may only be called once per receiver.
+          // So hand the worker the new track/participant and let it re-point (and if
+          // necessary rebuild) the cryptor that still owns those streams.
           const msg = {
             kind: 'updateCodec',
             data: {
               trackId,
+              previousTrackId: receiver[E2EE_TRACK_ID],
               codec,
               participantIdentity,
               hasPacketTrailer
             }
           };
           this.worker.postMessage(msg);
+          receiver[E2EE_TRACK_ID] = trackId;
           return;
         }
         // @ts-ignore
@@ -16175,7 +16416,6 @@ class E2EEManager extends eventsExports.EventEmitter {
             trackId: trackId,
             codec,
             participantIdentity: participantIdentity,
-            isReuse: E2EE_FLAG in receiver,
             hasPacketTrailer
           }
         };
@@ -16183,6 +16423,8 @@ class E2EEManager extends eventsExports.EventEmitter {
       }
       // @ts-ignore
       receiver[E2EE_FLAG] = true;
+      // @ts-ignore
+      receiver[E2EE_TRACK_ID] = trackId;
     });
   }
   /**
@@ -16199,7 +16441,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,
@@ -16211,7 +16453,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 = {
@@ -16222,7 +16464,6 @@ class E2EEManager extends eventsExports.EventEmitter {
           codec,
           trackId,
           participantIdentity: this.room.localParticipant.identity,
-          isReuse: false,
           hasPacketTrailer: hasFrameMetadataPublishOptions(frameMetadata),
           packetTrailer: frameMetadata
         }
@@ -16232,7 +16473,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.
@@ -18043,9 +18292,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)));
@@ -18500,6 +18749,7 @@ class SignalClient {
       if (firstMessage) {
         this.handleSignalResponse(firstMessage);
       }
+      const attemptId = this.attemptId;
       while (true) {
         if (this.signalLatency) {
           yield sleep(this.signalLatency);
@@ -18517,7 +18767,7 @@ class SignalClient {
           this.log.error("error reading from signal stream", {
             error: e
           });
-          yield this.close(false, 'error in reading loop');
+          yield this.handleOnClose('error in reading loop', attemptId);
           break;
         }
       }
@@ -21074,13 +21324,21 @@ class PCTransportManager {
       this.updateState();
     });
   }
+  /**
+   * Restarts ICE on the transports that need it. Only the publisher: the server restarts the
+   * subscriber's ICE itself and follows with a fresh offer.
+   *
+   * The subscriber deliberately does NOT enter `restartingIce` here. Queueing its remote
+   * candidates would guard against candidates for a new generation arriving before the offer
+   * that introduces it, but the server does not send them in that order -- on a same-node
+   * resume it buffers them until the offer has gone out, and on a reconnect that lands on
+   * another node it withholds subscriber candidates until immediately before creating the
+   * offer. Setting the flag only risks withholding candidates during the window that decides
+   * whether the reconnect succeeded.
+   */
   triggerIceRestart() {
     return __awaiter(this, void 0, void 0, function* () {
       this.iceLog.warn('triggering ICE restart');
-      if (this.subscriber) {
-        this.subscriber.restartingIce = true;
-      }
-      // only restart publisher if it's needed
       if (this.needsPublisher) {
         yield this.createAndSendPublisherOffer({
           iceRestart: true
@@ -22926,6 +23184,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
@@ -22938,23 +23198,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);
@@ -22990,6 +23243,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);
@@ -23015,13 +23280,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;
@@ -23475,6 +23765,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) {
@@ -23484,7 +23783,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* () {
@@ -23749,7 +24048,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;
@@ -23760,7 +24059,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), {
@@ -23775,7 +24074,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);
             }
           }
         }
@@ -24035,6 +24334,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;
   }
@@ -24087,7 +24390,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 {
@@ -24112,20 +24415,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);
           }
@@ -24626,7 +24938,11 @@ 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);
     });
     // add candidate on trickle
@@ -25911,8 +26227,11 @@ const DEFAULT_MAX_PAYLOAD_BYTE_LENGTH = 5000000000;class BaseStreamReader {
     this._info = info;
     this.bytesReceived = 0;
   }
-}
-class ByteStreamReader extends BaseStreamReader {
+  /**
+   * Counts a chunk's bytes against `totalByteSize` and reports progress. Chunk ordering and
+   * de-duplication happen upstream in the manager's `ensureOrderedChunks`, so every chunk reaching
+   * here is new and in order.
+   */
   handleChunkReceived(chunk) {
     var _a;
     this.bytesReceived += chunk.content.byteLength;
@@ -25920,6 +26239,8 @@ class ByteStreamReader extends BaseStreamReader {
     const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : undefined;
     (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, currentProgress);
   }
+}
+class ByteStreamReader extends BaseStreamReader {
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
     // Suppress unhandled rejection on reader.closed — errors are
@@ -26027,35 +26348,18 @@ class ByteStreamReader extends BaseStreamReader {
   }
 }
 /**
- * A class to read chunks from a ReadableStream and provide them in a structured format.
+ * A class to read chunks from a ReadableStream and decode them as UTF-8 text.
+ *
+ * NOTE: chunk-level `version` (resending a chunk at an already-received `chunkIndex` to supersede
+ * it) is not supported. The reader used to rebuild the whole string from a per-index chunk map and
+ * yield it as `TextStreamChunk.collected`, which made superseding work; 5d4a6346 (#1410, text auto
+ * chunking) changed the iterator to yield each chunk's text as it arrives, and a streaming reader
+ * cannot retract text it has already handed to the consumer. No sender emits a versioned chunk.
  */
 class TextStreamReader extends BaseStreamReader {
-  /**
-   * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
-   * that has been received up to the current point in time.
-   */
-  constructor(info, stream, totalChunkCount) {
-    super(info, stream, totalChunkCount);
-    this.receivedChunks = new Map();
-  }
-  handleChunkReceived(chunk) {
-    var _a;
-    const index = bigIntToNumber(chunk.chunkIndex);
-    const previousChunkAtIndex = this.receivedChunks.get(index);
-    if (previousChunkAtIndex && previousChunkAtIndex.version > chunk.version) {
-      // we have a newer version already, dropping the old one
-      return;
-    }
-    this.receivedChunks.set(index, chunk);
-    this.bytesReceived += chunk.content.byteLength;
-    this.validateBytesReceived();
-    const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : undefined;
-    (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, currentProgress);
-  }
   /**
    * Async iterator implementation to allow usage of `for await...of` syntax.
-   * Yields structured chunks from the stream.
-   *
+   * Yields each chunk's decoded text as it arrives - a delta, not the string accumulated so far.
    */
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
@@ -26326,7 +26630,7 @@ class TextStreamReader extends BaseStreamReader {
               });
             }
           });
-          streamHandlerCallback(new ByteStreamReader(info, compressed ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          streamHandlerCallback(new ByteStreamReader(info, compressed ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream.pipeThrough(ensureOrderedChunks(streamHeader.streamId)),
           // `totalLength` is the pre-compression size, and the reader counts decompressed bytes,
           // so it applies to both paths (mirrors text).
           bigIntToNumber(streamHeader.totalLength)), {
@@ -26398,7 +26702,7 @@ class TextStreamReader extends BaseStreamReader {
               });
             }
           });
-          streamHandlerCallback(new TextStreamReader(info, compressed ? inflateRawChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          streamHandlerCallback(new TextStreamReader(info, compressed ? inflateRawChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream.pipeThrough(ensureOrderedChunks(streamHeader.streamId)),
           // `totalLength` is the pre-compression size, and the reader sees decompressed bytes, so
           // it applies to both paths.
           bigIntToNumber(streamHeader.totalLength)), {
@@ -26414,7 +26718,7 @@ class TextStreamReader extends BaseStreamReader {
       if (fileBuffer.info.encryptionType !== encryptionType) {
         fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
         this.byteStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
+      } else {
         fileBuffer.controller.enqueue(chunk);
       }
     }
@@ -26423,7 +26727,7 @@ class TextStreamReader extends BaseStreamReader {
       if (textBuffer.info.encryptionType !== encryptionType) {
         textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
         this.textStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
+      } else {
         textBuffer.controller.enqueue(chunk);
       }
     }
@@ -26471,26 +26775,24 @@ class TextStreamReader extends BaseStreamReader {
 function createInlineStream(streamId, content) {
   return new ReadableStream({
     start: controller => __awaiter(this, void 0, void 0, function* () {
-      try {
-        const bytes = yield content;
-        controller.enqueue(new DataStream_Chunk({
-          streamId,
-          chunkIndex: BigInt(0),
-          content: bytes
-        }));
-        controller.close();
-      } catch (err) {
-        controller.error(err);
-      }
+      const bytes = yield content;
+      controller.enqueue(new DataStream_Chunk({
+        streamId,
+        chunkIndex: BigInt(0),
+        content: bytes
+      }));
+      controller.close();
     })
   });
 }
 /**
  * Validates that chunks are received in order, dropping duplicates and throwing if gaps are found.
  *
- * A stateful decompressor silently corrupts on duplicated or out-of-order input, so duplicates are
- * dropped (with a warning - in-order delivery is expected on the reliable channel, but reconnect
- * handling may replay) and a gap is a hard error. Shared by the text and byte deflate-raw decoders.
+ * Reassembly (and, for compressed streams, a stateful decompressor) silently corrupts on duplicated
+ * or out-of-order input, so duplicates are dropped (with a warning - in-order delivery is expected
+ * on the reliable channel, but reconnect handling may replay) and a gap is a hard error. Empty
+ * chunks consume their index and are then dropped, so they never reach the reader. Applied to every
+ * chunked stream, compressed or not.
  */
 function ensureOrderedChunks(streamId) {
   let lastChunkIndex = -1;
@@ -26498,13 +26800,16 @@ function ensureOrderedChunks(streamId) {
     transform: (value, controller) => {
       const index = bigIntToNumber(value.chunkIndex);
       if (index <= lastChunkIndex) {
-        livekitLogger.warn("ignoring duplicate chunk ".concat(index, " for compressed data stream ").concat(streamId, " (last processed: ").concat(lastChunkIndex, ")"));
+        livekitLogger.warn("ignoring duplicate chunk ".concat(index, " ").concat(value.version > 0 ? "(version ".concat(value.version, ")") : '', " for data stream ").concat(streamId, " (last processed: ").concat(lastChunkIndex, ")"));
         return;
       }
       if (index > lastChunkIndex + 1) {
-        throw new DataStreamError("Missing chunk(s) ".concat(lastChunkIndex + 1, "..").concat(index - 1, " for compressed data stream ").concat(streamId, " - cannot continue decompressing"), DataStreamErrorReason.Incomplete);
+        throw new DataStreamError("Missing chunk(s) ".concat(lastChunkIndex + 1, "..").concat(index - 1, " for data stream ").concat(streamId, " - cannot reassemble payload"), DataStreamErrorReason.Incomplete);
       }
       lastChunkIndex = index;
+      if (value.content.length === 0) {
+        return;
+      }
       controller.enqueue(value);
     }
   });
@@ -31748,7 +32053,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);
       }
@@ -31851,7 +32156,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
@@ -31867,12 +32177,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 = {
@@ -31893,19 +32207,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');
         }
@@ -31942,13 +32256,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,
@@ -34187,8 +34497,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;
@@ -36343,33 +36653,10 @@ 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);
-  }
-  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 {
+const decoder = new TextDecoder();
+const strictDecoder = new TextDecoder('utf-8', {
+  fatal: true
+});class JOSEError extends Error {
   constructor(message, options) {
     var _Error$captureStackTr;
     super(message, options);
@@ -36493,7 +36780,7 @@ class JWKSMultipleMatchingKeys extends JOSEError {
     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, Symbol.asyncIterator, _wrapAsyncGenerator(function* () {}));
     _defineProperty(this, "code", 'ERR_JWKS_MULTIPLE_MATCHING_KEYS');
   }
 }
@@ -36515,19 +36802,55 @@ class JWSSignatureVerificationFailed extends JOSEError {
     _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]') {
+_defineProperty(JWSSignatureVerificationFailed, "code", 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');function decodeBase64(encoded) {
+  if (Uint8Array.fromBase64) {
+    return Uint8Array.fromBase64(encoded);
+  }
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}const invalid = 'The input to be decoded is not correctly encoded.';
+function decode(input) {
+  if (Uint8Array.fromBase64) {
+    try {
+      return Uint8Array.fromBase64(typeof input === 'string' ? input : decoder.decode(input), {
+        alphabet: 'base64url'
+      });
+    } catch (cause) {
+      throw new TypeError(invalid, {
+        cause
+      });
+    }
+  }
+  let encoded = input;
+  if (encoded instanceof Uint8Array) {
+    encoded = decoder.decode(encoded);
+  }
+  if (encoded.includes('+') || encoded.includes('/')) {
+    throw new TypeError(invalid);
+  }
+  encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
+  try {
+    return decodeBase64(encoded);
+  } catch (_unused) {
+    throw new TypeError(invalid);
+  }
+}function isObject(input) {
+  if (typeof input !== 'object' || input === null || Object.prototype.toString.call(input) !== '[object Object]') {
     return false;
   }
-  if (Object.getPrototypeOf(input) === null) {
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype === null) {
     return true;
   }
-  let proto = input;
+  let proto = prototype;
   while (Object.getPrototypeOf(proto) !== null) {
     proto = Object.getPrototypeOf(proto);
   }
-  return Object.getPrototypeOf(input) === proto;
+  return prototype === proto;
 }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('.'),
@@ -36544,7 +36867,7 @@ function isObject(input) {
   }
   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');
   }