livekit-client 2.13.8 → 2.15.0

package/dist/livekit-client.esm.mjs

@@ -4414,6 +4414,18 @@ const VideoLayer = /* @__PURE__ */proto3.makeMessageType("livekit.VideoLayer", (
   kind: "scalar",
   T: 13
   /* ScalarType.UINT32 */
+}, {
+  no: 6,
+  name: "spatial_layer",
+  kind: "scalar",
+  T: 5
+  /* ScalarType.INT32 */
+}, {
+  no: 7,
+  name: "rid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
 }]);
 const DataPacket = /* @__PURE__ */proto3.makeMessageType("livekit.DataPacket", () => [{
   no: 1,
@@ -4963,6 +4975,9 @@ const ClientInfo_SDK = /* @__PURE__ */proto3.makeEnum("livekit.ClientInfo.SDK",
 }, {
   no: 13,
   name: "UNREAL"
+}, {
+  no: 14,
+  name: "ESP32"
 }]);
 const ClientConfiguration = /* @__PURE__ */proto3.makeMessageType("livekit.ClientConfiguration", () => [{
   no: 1,
@@ -11025,6 +11040,19 @@ var ParticipantEvent;
    * args: ([[LocalTrackPublication]])
    */
   ParticipantEvent["LocalTrackUnpublished"] = "localTrackUnpublished";
+  /**
+   * A local track has been constrained by cpu.
+   * This event is useful to know when to reduce the capture resolution of the track.
+   *
+   * This event is emitted on the local participant.
+   *
+   * args: ([[LocalVideoTrack]], [[LocalTrackPublication]])
+   */
+  ParticipantEvent["LocalTrackCpuConstrained"] = "localTrackCpuConstrained";
+  /**
+   * @internal
+   */
+  ParticipantEvent["LocalSenderCreated"] = "localSenderCreated";
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -11101,6 +11129,10 @@ var ParticipantEvent;
    *
    */
   ParticipantEvent["TrackSubscriptionStatusChanged"] = "trackSubscriptionStatusChanged";
+  /**
+   * a local track has been constrained by cpu
+   */
+  ParticipantEvent["TrackCpuConstrained"] = "trackCpuConstrained";
   // fired only on LocalParticipant
   /** @internal */
   ParticipantEvent["MediaDevicesError"] = "mediaDevicesError";
@@ -11178,6 +11210,7 @@ var TrackEvent;
   TrackEvent["Ended"] = "ended";
   TrackEvent["Subscribed"] = "subscribed";
   TrackEvent["Unsubscribed"] = "unsubscribed";
+  TrackEvent["CpuConstrained"] = "cpuConstrained";
   /** @internal */
   TrackEvent["UpdateSettings"] = "updateSettings";
   /** @internal */
@@ -11331,7 +11364,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.13.8";
+var version$1 = "2.15.0";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -11765,7 +11798,7 @@ class VideoPreset {
   }
 }
 const backupCodecs = ['vp8', 'h264'];
-const videoCodecs = ['vp8', 'h264', 'vp9', 'av1'];
+const videoCodecs = ['vp8', 'h264', 'vp9', 'av1', 'h265'];
 function isBackupCodec(codec) {
   return !!backupCodecs.find(backup => backup === codec);
 }
@@ -11902,6 +11935,10 @@ function supportsVP9() {
       // Safari 16 and below does not support VP9
       return false;
     }
+    if ((browser === null || browser === void 0 ? void 0 : browser.os) === 'iOS' && (browser === null || browser === void 0 ? void 0 : browser.osVersion) && compareVersions(browser.osVersion, '16') < 0) {
+      // Safari 16 and below on iOS does not support VP9 we need the iOS check to account for other browsers running webkit under the hood
+      return false;
+    }
   }
   const capabilities = RTCRtpSender.getCapabilities('video');
   let hasVP9 = false;
@@ -11945,16 +11982,16 @@ 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';
 }
-function isSafari17() {
+function isSafari17Based() {
   const b = getBrowser();
-  return (b === null || b === void 0 ? void 0 : b.name) === 'Safari' && b.version.startsWith('17.');
+  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;
 }
 function isSafariSvcApi(browser) {
   if (!browser) {
     browser = getBrowser();
   }
   // Safari 18.4 requires legacy svc api and scaleResolutionDown to be set
-  return (browser === null || browser === void 0 ? void 0 : browser.name) === 'Safari' && compareVersions(browser.version, '18.3') > 0;
+  return (browser === null || browser === void 0 ? void 0 : browser.name) === 'Safari' && compareVersions(browser.version, '18.3') > 0 || (browser === null || browser === void 0 ? void 0 : browser.os) === 'iOS' && !!(browser === null || browser === void 0 ? void 0 : browser.osVersion) && compareVersions(browser.osVersion, '18.3') > 0;
 }
 function isMobile() {
   var _a, _b;
@@ -12660,6 +12697,13 @@ function getTrackSourceFromProto(source) {
       return Track.Source.Unknown;
   }
 }
+function areDimensionsSmaller(a, b) {
+  return a.width * a.height < b.width * b.height;
+}
+function layerDimensionsFor(trackInfo, quality) {
+  var _a;
+  return (_a = trackInfo.layers) === null || _a === void 0 ? void 0 : _a.find(l => l.quality === quality);
+}
 
 /**
  * @experimental
@@ -12799,8 +12843,8 @@ class E2EEManager extends eventsExports.EventEmitter {
       });
       this.setParticipantCryptorEnabled(this.room.localParticipant.isE2EEEnabled, this.room.localParticipant.identity);
     });
-    room.localParticipant.on(ParticipantEvent.LocalTrackPublished, publication => __awaiter(this, void 0, void 0, function* () {
-      this.setupE2EESender(publication.track, publication.track.sender);
+    room.localParticipant.on(ParticipantEvent.LocalSenderCreated, (sender, track) => __awaiter(this, void 0, void 0, function* () {
+      this.setupE2EESender(track, sender);
     }));
     keyProvider.on(KeyProviderEvent.SetKey, keyInfo => this.postKey(keyInfo)).on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex));
   }
@@ -14789,6 +14833,7 @@ class PCTransport extends eventsExports.EventEmitter {
     this.loggerOptions = loggerOptions;
     this.config = config;
     this._pc = this.createPC();
+    this.offerLock = new _();
   }
   createPC() {
     const pc = new RTCPeerConnection(this.config);
@@ -14927,92 +14972,97 @@ class PCTransport extends eventsExports.EventEmitter {
   createAndSendOffer(options) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
-      const offerId = this.latestOfferId + 1;
-      this.latestOfferId = offerId;
-      if (this.onOffer === undefined) {
-        return;
-      }
-      if (options === null || options === void 0 ? void 0 : options.iceRestart) {
-        this.log.debug('restarting ICE', this.logContext);
-        this.restartingIce = true;
-      }
-      if (this._pc && this._pc.signalingState === 'have-local-offer') {
-        // we're waiting for the peer to accept our offer, so we'll just wait
-        // the only exception to this is when ICE restart is needed
-        const currentSD = this._pc.remoteDescription;
-        if ((options === null || options === void 0 ? void 0 : options.iceRestart) && currentSD) {
-          // TODO: handle when ICE restart is needed but we don't have a remote description
-          // the best thing to do is to recreate the peerconnection
-          yield this._pc.setRemoteDescription(currentSD);
-        } else {
-          this.renegotiate = true;
+      const unlock = yield this.offerLock.lock();
+      try {
+        // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
+        const offerId = this.latestOfferId + 1;
+        this.latestOfferId = offerId;
+        if (this.onOffer === undefined) {
           return;
         }
-      } else if (!this._pc || this._pc.signalingState === 'closed') {
-        this.log.warn('could not createOffer with closed peer connection', this.logContext);
-        return;
-      }
-      // actually negotiate
-      this.log.debug('starting to negotiate', this.logContext);
-      const offer = yield this.pc.createOffer(options);
-      this.log.debug('original offer', Object.assign({
-        sdp: offer.sdp
-      }, this.logContext));
-      const sdpParsed = libExports.parse((_a = offer.sdp) !== null && _a !== void 0 ? _a : '');
-      sdpParsed.media.forEach(media => {
-        ensureIPAddrMatchVersion(media);
-        if (media.type === 'audio') {
-          ensureAudioNackAndStereo(media, [], []);
-        } else if (media.type === 'video') {
-          this.trackBitrates.some(trackbr => {
-            if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
-              return false;
-            }
-            let codecPayload = 0;
-            media.rtp.some(rtp => {
-              if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
-                codecPayload = rtp.payload;
+        if (options === null || options === void 0 ? void 0 : options.iceRestart) {
+          this.log.debug('restarting ICE', this.logContext);
+          this.restartingIce = true;
+        }
+        if (this._pc && this._pc.signalingState === 'have-local-offer') {
+          // we're waiting for the peer to accept our offer, so we'll just wait
+          // the only exception to this is when ICE restart is needed
+          const currentSD = this._pc.remoteDescription;
+          if ((options === null || options === void 0 ? void 0 : options.iceRestart) && currentSD) {
+            // TODO: handle when ICE restart is needed but we don't have a remote description
+            // the best thing to do is to recreate the peerconnection
+            yield this._pc.setRemoteDescription(currentSD);
+          } else {
+            this.renegotiate = true;
+            return;
+          }
+        } else if (!this._pc || this._pc.signalingState === 'closed') {
+          this.log.warn('could not createOffer with closed peer connection', this.logContext);
+          return;
+        }
+        // actually negotiate
+        this.log.debug('starting to negotiate', this.logContext);
+        const offer = yield this.pc.createOffer(options);
+        this.log.debug('original offer', Object.assign({
+          sdp: offer.sdp
+        }, this.logContext));
+        const sdpParsed = libExports.parse((_a = offer.sdp) !== null && _a !== void 0 ? _a : '');
+        sdpParsed.media.forEach(media => {
+          ensureIPAddrMatchVersion(media);
+          if (media.type === 'audio') {
+            ensureAudioNackAndStereo(media, [], []);
+          } else if (media.type === 'video') {
+            this.trackBitrates.some(trackbr => {
+              if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
+                return false;
+              }
+              let codecPayload = 0;
+              media.rtp.some(rtp => {
+                if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
+                  codecPayload = rtp.payload;
+                  return true;
+                }
+                return false;
+              });
+              if (codecPayload === 0) {
                 return true;
               }
-              return false;
-            });
-            if (codecPayload === 0) {
-              return true;
-            }
-            if (isSVCCodec(trackbr.codec)) {
-              this.ensureVideoDDExtensionForSVC(media, sdpParsed);
-            }
-            // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
-            // mung sdp for av1 bitrate setting that can't apply by sendEncoding
-            if (trackbr.codec !== 'av1') {
-              return true;
-            }
-            const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
-            for (const fmtp of media.fmtp) {
-              if (fmtp.payload === codecPayload) {
-                // if another track's fmtp already is set, we cannot override the bitrate
-                // this has the unfortunate consequence of being forced to use the
-                // initial track's bitrate for all tracks
-                if (!fmtp.config.includes('x-google-start-bitrate')) {
-                  fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
+              if (isSVCCodec(trackbr.codec)) {
+                this.ensureVideoDDExtensionForSVC(media, sdpParsed);
+              }
+              // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
+              // mung sdp for av1 bitrate setting that can't apply by sendEncoding
+              if (trackbr.codec !== 'av1') {
+                return true;
+              }
+              const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
+              for (const fmtp of media.fmtp) {
+                if (fmtp.payload === codecPayload) {
+                  // if another track's fmtp already is set, we cannot override the bitrate
+                  // this has the unfortunate consequence of being forced to use the
+                  // initial track's bitrate for all tracks
+                  if (!fmtp.config.includes('x-google-start-bitrate')) {
+                    fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
+                  }
+                  break;
                 }
-                break;
               }
-            }
-            return true;
-          });
+              return true;
+            });
+          }
+        });
+        if (this.latestOfferId > offerId) {
+          this.log.warn('latestOfferId mismatch', Object.assign(Object.assign({}, this.logContext), {
+            latestOfferId: this.latestOfferId,
+            offerId
+          }));
+          return;
         }
-      });
-      if (this.latestOfferId > offerId) {
-        this.log.warn('latestOfferId mismatch', Object.assign(Object.assign({}, this.logContext), {
-          latestOfferId: this.latestOfferId,
-          offerId
-        }));
-        return;
+        yield this.setMungedSDP(offer, libExports.write(sdpParsed));
+        this.onOffer(offer, this.latestOfferId);
+      } finally {
+        unlock();
       }
-      yield this.setMungedSDP(offer, libExports.write(sdpParsed));
-      this.onOffer(offer, this.latestOfferId);
     });
   }
   createAndSetAnswer() {
@@ -16677,7 +16727,7 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
     // before M113.
     // Announced here: https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw?pli=1
     const browser = getBrowser();
-    if (isSafari() ||
+    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
@@ -16797,6 +16847,7 @@ function determineAppropriateEncoding(isScreenShare, width, height, codec) {
   if (codec) {
     switch (codec) {
       case 'av1':
+      case 'h265':
         encoding = Object.assign({}, encoding);
         encoding.maxBitrate = encoding.maxBitrate * 0.7;
         break;
@@ -16964,6 +17015,8 @@ class LocalVideoTrack extends LocalTrack {
     /* @internal */
     this.simulcastCodecs = new Map();
     this.degradationPreference = 'balanced';
+    this.isCpuConstrained = false;
+    this.optimizeForPerformance = false;
     this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
       if (!this.sender) {
         this._currentBitrate = 0;
@@ -16973,12 +17026,19 @@ class LocalVideoTrack extends LocalTrack {
       try {
         stats = yield this.getSenderStats();
       } catch (e) {
-        this.log.error('could not get audio sender stats', Object.assign(Object.assign({}, this.logContext), {
+        this.log.error('could not get video sender stats', Object.assign(Object.assign({}, this.logContext), {
           error: e
         }));
         return;
       }
       const statsMap = new Map(stats.map(s => [s.rid, s]));
+      const isCpuConstrained = stats.some(s => s.qualityLimitationReason === 'cpu');
+      if (isCpuConstrained !== this.isCpuConstrained) {
+        this.isCpuConstrained = isCpuConstrained;
+        if (this.isCpuConstrained) {
+          this.emit(TrackEvent.CpuConstrained);
+        }
+      }
       if (this.prevStats) {
         let totalBitrate = 0;
         statsMap.forEach((s, key) => {
@@ -17214,6 +17274,8 @@ class LocalVideoTrack extends LocalTrack {
         }
       }
       yield this.restart(constraints);
+      // reset cpu constrained state after track is restarted
+      this.isCpuConstrained = false;
       try {
         for (var _e = true, _f = __asyncValues(this.simulcastCodecs.values()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
           _c = _g.value;
@@ -17383,6 +17445,12 @@ class LocalVideoTrack extends LocalTrack {
    */
   setPublishingLayers(isSvc, qualities) {
     return __awaiter(this, void 0, void 0, function* () {
+      if (this.optimizeForPerformance) {
+        this.log.info('skipping setPublishingLayers due to optimized publishing performance', Object.assign(Object.assign({}, this.logContext), {
+          qualities
+        }));
+        return;
+      }
       this.log.debug('setting publishing layers', Object.assign(Object.assign({}, this.logContext), {
         qualities
       }));
@@ -17392,6 +17460,44 @@ class LocalVideoTrack extends LocalTrack {
       yield setPublishingLayersForSender(this.sender, this.encodings, qualities, this.senderLock, isSvc, this.log, this.logContext);
     });
   }
+  /**
+   * Designed for lower powered devices, reduces video publishing quality and disables simulcast.
+   * @experimental
+   */
+  prioritizePerformance() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.sender) {
+        throw new Error('sender not found');
+      }
+      const unlock = yield this.senderLock.lock();
+      try {
+        this.optimizeForPerformance = true;
+        const params = this.sender.getParameters();
+        params.encodings = params.encodings.map((e, idx) => {
+          var _a;
+          return Object.assign(Object.assign({}, e), {
+            active: idx === 0,
+            scaleResolutionDownBy: Math.max(1, Math.ceil(((_a = this.mediaStreamTrack.getSettings().height) !== null && _a !== void 0 ? _a : 360) / 360)),
+            scalabilityMode: idx === 0 && isSVCCodec(this.codec) ? 'L1T3' : undefined,
+            maxFramerate: idx === 0 ? 15 : 0,
+            maxBitrate: idx === 0 ? e.maxBitrate : 0
+          });
+        });
+        this.log.debug('setting performance optimised encodings', Object.assign(Object.assign({}, this.logContext), {
+          encodings: params.encodings
+        }));
+        this.encodings = params.encodings;
+        yield this.sender.setParameters(params);
+      } catch (e) {
+        this.log.error('failed to set performance optimised encodings', Object.assign(Object.assign({}, this.logContext), {
+          error: e
+        }));
+        this.optimizeForPerformance = false;
+      } finally {
+        unlock();
+      }
+    });
+  }
   handleAppVisibilityChanged() {
     const _super = Object.create(null, {
       handleAppVisibilityChanged: {
@@ -19818,16 +19924,23 @@ class LocalTrackPublication extends TrackPublication {
     this.handleTrackEnded = () => {
       this.emit(TrackEvent.Ended);
     };
+    this.handleCpuConstrained = () => {
+      if (this.track && isVideoTrack(this.track)) {
+        this.emit(TrackEvent.CpuConstrained, this.track);
+      }
+    };
     this.updateInfo(ti);
     this.setTrack(track);
   }
   setTrack(track) {
     if (this.track) {
       this.track.off(TrackEvent.Ended, this.handleTrackEnded);
+      this.track.off(TrackEvent.CpuConstrained, this.handleCpuConstrained);
     }
     super.setTrack(track);
     if (track) {
       track.on(TrackEvent.Ended, this.handleTrackEnded);
+      track.on(TrackEvent.CpuConstrained, this.handleCpuConstrained);
     }
   }
   get isMuted() {
@@ -20065,7 +20178,7 @@ function createLocalScreenTracks(options) {
     if (options === undefined) {
       options = {};
     }
-    if (options.resolution === undefined && !isSafari17()) {
+    if (options.resolution === undefined && !isSafari17Based()) {
       options.resolution = ScreenSharePresets.h1080fps30.resolution;
     }
     if (navigator.mediaDevices.getDisplayMedia === undefined) {
@@ -20498,6 +20611,10 @@ class LocalParticipant extends Participant {
       }
       this.engine.client.sendUpdateLocalAudioTrack(pub.trackSid, pub.getTrackFeatures());
     };
+    this.onTrackCpuConstrained = (track, publication) => {
+      this.log.debug('track cpu constrained', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(publication)));
+      this.emit(ParticipantEvent.LocalTrackCpuConstrained, track, publication);
+    };
     this.handleSubscribedQualityUpdate = update => __awaiter(this, void 0, void 0, function* () {
       var _a, e_1, _b, _c;
       var _d;
@@ -20957,7 +21074,7 @@ class LocalParticipant extends Participant {
       if (navigator.mediaDevices.getDisplayMedia === undefined) {
         throw new DeviceUnsupportedError('getDisplayMedia not supported');
       }
-      if (options.resolution === undefined && !isSafari17()) {
+      if (options.resolution === undefined && !isSafari17Based()) {
         // we need to constrain the dimensions, otherwise it could lead to low bitrate
         // due to encoding a huge video. Encoding such large surfaces is really expensive
         // unfortunately Safari 17 has a but and cannot be constrained by default
@@ -21324,6 +21441,7 @@ class LocalParticipant extends Participant {
           throw new UnexpectedConnectionState('pcManager is not ready');
         }
         track.sender = yield this.engine.createSender(track, opts, encodings);
+        this.emit(ParticipantEvent.LocalSenderCreated, track.sender, track);
         if (isLocalVideoTrack(track)) {
           (_a = opts.degradationPreference) !== null && _a !== void 0 ? _a : opts.degradationPreference = getDefaultDegradationPreference(track);
           track.setDegradationPreference(opts.degradationPreference);
@@ -21409,6 +21527,7 @@ class LocalParticipant extends Participant {
         loggerName: this.roomOptions.loggerName,
         loggerContextCb: () => this.logContext
       });
+      publication.on(TrackEvent.CpuConstrained, constrainedTrack => this.onTrackCpuConstrained(constrainedTrack, publication));
       // save options for when it needs to be republished again
       publication.options = opts;
       track.sid = ti.sid;
@@ -22308,20 +22427,20 @@ class RemoteTrackPublication extends TrackPublication {
     this.track = undefined;
     /** @internal */
     this.allowed = true;
-    this.disabled = false;
-    this.currentVideoQuality = VideoQuality.HIGH;
+    this.requestedDisabled = undefined;
+    this.visible = true;
     this.handleEnded = track => {
       this.setTrack(undefined);
       this.emit(TrackEvent.Ended, track);
     };
     this.handleVisibilityChange = visible => {
       this.log.debug("adaptivestream video visibility ".concat(this.trackSid, ", visible=").concat(visible), this.logContext);
-      this.disabled = !visible;
+      this.visible = visible;
       this.emitTrackUpdate();
     };
     this.handleVideoDimensionsChange = dimensions => {
       this.log.debug("adaptivestream video dimensions ".concat(dimensions.width, "x").concat(dimensions.height), this.logContext);
-      this.videoDimensions = dimensions;
+      this.videoDimensionsAdaptiveStream = dimensions;
       this.emitTrackUpdate();
     };
     this.subscribed = autoSubscribe;
@@ -22380,7 +22499,7 @@ class RemoteTrackPublication extends TrackPublication {
     return this.subscribed !== false;
   }
   get isEnabled() {
-    return !this.disabled;
+    return this.requestedDisabled !== undefined ? !this.requestedDisabled : this.isAdaptiveStream ? this.visible : true;
   }
   get isLocal() {
     return false;
@@ -22392,10 +22511,10 @@ class RemoteTrackPublication extends TrackPublication {
    * @param enabled
    */
   setEnabled(enabled) {
-    if (!this.isManualOperationAllowed() || this.disabled === !enabled) {
+    if (!this.isManualOperationAllowed() || this.requestedDisabled === !enabled) {
       return;
     }
-    this.disabled = !enabled;
+    this.requestedDisabled = !enabled;
     this.emitTrackUpdate();
   }
   /**
@@ -22406,25 +22525,32 @@ class RemoteTrackPublication extends TrackPublication {
    * optimize for uninterrupted video
    */
   setVideoQuality(quality) {
-    if (!this.isManualOperationAllowed() || this.currentVideoQuality === quality) {
+    if (!this.isManualOperationAllowed() || this.requestedMaxQuality === quality) {
       return;
     }
-    this.currentVideoQuality = quality;
-    this.videoDimensions = undefined;
+    this.requestedMaxQuality = quality;
+    this.requestedVideoDimensions = undefined;
     this.emitTrackUpdate();
   }
+  /**
+   * Explicitly set the video dimensions for this track.
+   *
+   * This will take precedence over adaptive stream dimensions.
+   *
+   * @param dimensions The video dimensions to set.
+   */
   setVideoDimensions(dimensions) {
     var _a, _b;
     if (!this.isManualOperationAllowed()) {
       return;
     }
-    if (((_a = this.videoDimensions) === null || _a === void 0 ? void 0 : _a.width) === dimensions.width && ((_b = this.videoDimensions) === null || _b === void 0 ? void 0 : _b.height) === dimensions.height) {
+    if (((_a = this.requestedVideoDimensions) === null || _a === void 0 ? void 0 : _a.width) === dimensions.width && ((_b = this.requestedVideoDimensions) === null || _b === void 0 ? void 0 : _b.height) === dimensions.height) {
       return;
     }
     if (isRemoteVideoTrack(this.track)) {
-      this.videoDimensions = dimensions;
+      this.requestedVideoDimensions = dimensions;
     }
-    this.currentVideoQuality = undefined;
+    this.requestedMaxQuality = undefined;
     this.emitTrackUpdate();
   }
   setVideoFPS(fps) {
@@ -22441,7 +22567,8 @@ class RemoteTrackPublication extends TrackPublication {
     this.emitTrackUpdate();
   }
   get videoQuality() {
-    return this.currentVideoQuality;
+    var _a;
+    return (_a = this.requestedMaxQuality) !== null && _a !== void 0 ? _a : VideoQuality.HIGH;
   }
   /** @internal */
   setTrack(track) {
@@ -22508,10 +22635,6 @@ class RemoteTrackPublication extends TrackPublication {
     }
   }
   isManualOperationAllowed() {
-    if (this.kind === Track.Kind.Video && this.isAdaptiveStream) {
-      this.log.warn('adaptive stream is enabled, cannot change video track settings', this.logContext);
-      return false;
-    }
     if (!this.isDesired) {
       this.log.warn('cannot update track settings when not subscribed', this.logContext);
       return false;
@@ -22525,17 +22648,46 @@ class RemoteTrackPublication extends TrackPublication {
   emitTrackUpdate() {
     const settings = new UpdateTrackSettings({
       trackSids: [this.trackSid],
-      disabled: this.disabled,
+      disabled: !this.isEnabled,
       fps: this.fps
     });
-    if (this.videoDimensions) {
-      settings.width = Math.ceil(this.videoDimensions.width);
-      settings.height = Math.ceil(this.videoDimensions.height);
-    } else if (this.currentVideoQuality !== undefined) {
-      settings.quality = this.currentVideoQuality;
-    } else {
-      // defaults to high quality
-      settings.quality = VideoQuality.HIGH;
+    if (this.kind === Track.Kind.Video) {
+      let minDimensions = this.requestedVideoDimensions;
+      if (this.videoDimensionsAdaptiveStream !== undefined) {
+        if (minDimensions) {
+          // check whether the adaptive stream dimensions are smaller than the requested dimensions and use smaller one
+          const smallerAdaptive = areDimensionsSmaller(this.videoDimensionsAdaptiveStream, minDimensions);
+          if (smallerAdaptive) {
+            this.log.debug('using adaptive stream dimensions instead of requested', Object.assign(Object.assign({}, this.logContext), this.videoDimensionsAdaptiveStream));
+            minDimensions = this.videoDimensionsAdaptiveStream;
+          }
+        } else if (this.requestedMaxQuality !== undefined && this.trackInfo) {
+          // check whether adaptive stream dimensions are smaller than the max quality layer and use smaller one
+          const maxQualityLayer = layerDimensionsFor(this.trackInfo, this.requestedMaxQuality);
+          if (maxQualityLayer && areDimensionsSmaller(this.videoDimensionsAdaptiveStream, maxQualityLayer)) {
+            this.log.debug('using adaptive stream dimensions instead of max quality layer', Object.assign(Object.assign({}, this.logContext), this.videoDimensionsAdaptiveStream));
+            minDimensions = this.videoDimensionsAdaptiveStream;
+          }
+        } else {
+          this.log.debug('using adaptive stream dimensions', Object.assign(Object.assign({}, this.logContext), this.videoDimensionsAdaptiveStream));
+          minDimensions = this.videoDimensionsAdaptiveStream;
+        }
+      }
+      if (minDimensions) {
+        settings.width = Math.ceil(minDimensions.width);
+        settings.height = Math.ceil(minDimensions.height);
+      } else if (this.requestedMaxQuality !== undefined) {
+        this.log.debug('using requested max quality', Object.assign(Object.assign({}, this.logContext), {
+          quality: this.requestedMaxQuality
+        }));
+        settings.quality = this.requestedMaxQuality;
+      } else {
+        this.log.debug('using default quality', Object.assign(Object.assign({}, this.logContext), {
+          quality: VideoQuality.HIGH
+        }));
+        // defaults to high quality
+        settings.quality = VideoQuality.HIGH;
+      }
     }
     this.emit(TrackEvent.UpdateSettings, settings);
   }
@@ -22566,7 +22718,9 @@ class RemoteParticipant extends Participant {
     super.addTrackPublication(publication);
     // register action events
     publication.on(TrackEvent.UpdateSettings, settings => {
-      this.log.debug('send update settings', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(publication)));
+      this.log.debug('send update settings', Object.assign(Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(publication)), {
+        settings
+      }));
       this.signalClient.sendUpdateTrackSettings(settings);
     });
     publication.on(TrackEvent.UpdateSubscription, sub => {
@@ -24105,6 +24259,11 @@ class Room extends eventsExports.EventEmitter {
             _this3.options.videoCaptureDefaults.deviceId = prevDeviceId;
             throw e;
           }
+          const isMuted = tracks.some(t => {
+            var _a, _b;
+            return (_b = (_a = t.track) === null || _a === void 0 ? void 0 : _a.isMuted) !== null && _b !== void 0 ? _b : false;
+          });
+          if (success && isMuted) shouldTriggerImmediateDeviceChange = true;
         } else if (kind === 'audiooutput') {
           shouldTriggerImmediateDeviceChange = true;
           if (!supportsSetSinkId() && !_this3.options.webAudioMix || _this3.options.webAudioMix && _this3.audioContext && !('setSinkId' in _this3.audioContext)) {