livekit-client 2.18.4 → 2.18.5

package/dist/livekit-client.esm.mjs

@@ -11744,7 +11744,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.18.4";const version = version$1;
+}var version$1 = "2.18.5";const version = version$1;
 const protocolVersion = 16;/** Base error that all LiveKit specific custom errors inherit from. */
 class LivekitError extends Error {
   constructor(code, message, options) {
@@ -12498,6 +12498,8 @@ var EngineEvent;
   EngineEvent["DataTrackSubscriberHandles"] = "dataTrackSubscriberHandles";
   EngineEvent["DataTrackPacketReceived"] = "dataTrackPacketReceived";
   EngineEvent["Joined"] = "joined";
+  EngineEvent["TokenRefreshed"] = "tokenRefreshed";
+  EngineEvent["ServerRegionsReported"] = "serverRegionsReported";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -16053,6 +16055,10 @@ class SignalClient {
         const resp = yield fetch(validateUrl);
         switch (resp.status) {
           case 404:
+            const errorMsg = yield resp.text();
+            if (errorMsg.includes('requested room does not exist')) {
+              return ConnectionError.notAllowed(errorMsg, resp.status);
+            }
             return ConnectionError.serviceNotFound('v1 RTC path not found. Consider upgrading your LiveKit server version', 'v0-rtc');
           case 401:
           case 403:
@@ -17569,8 +17575,8 @@ class PCTransport extends eventsExports.EventEmitter {
   setMungedSDP(sd, munged, remote) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b;
+      const originalSdp = sd.sdp;
       if (munged) {
-        const originalSdp = sd.sdp;
         sd.sdp = munged;
         try {
           this.log.debug("setting munged ".concat(remote ? 'remote' : 'local', " description"), this.logContext);
@@ -17583,7 +17589,8 @@ class PCTransport extends eventsExports.EventEmitter {
         } catch (e) {
           this.log.warn("not able to set ".concat(sd.type, ", falling back to unmodified sdp"), Object.assign(Object.assign({}, this.logContext), {
             error: e,
-            sdp: munged
+            mungedSdp: munged,
+            originalSdp
           }));
           sd.sdp = originalSdp;
         }
@@ -17605,6 +17612,9 @@ class PCTransport extends eventsExports.EventEmitter {
           error: msg,
           sdp: sd.sdp
         };
+        if (munged && munged !== originalSdp) {
+          fields.mungedSdp = munged;
+        }
         if (!remote && this.pc.remoteDescription) {
           fields.remoteSdp = this.pc.remoteDescription;
         }
@@ -17628,9 +17638,6 @@ class PCTransport extends eventsExports.EventEmitter {
         let maxID = 0;
         sdp.media.forEach(m => {
           var _a;
-          if (m.type !== 'video') {
-            return;
-          }
           (_a = m.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
             if (ext.value > maxID) {
               maxID = ext.value;
@@ -18097,192 +18104,6 @@ class PCTransportManager {
       }();
     });
   }
-}const DEFAULT_MAX_AGE_MS = 5000;
-const STOP_REFETCH_DELAY_MS = 30000;
-class RegionUrlProvider {
-  static fetchRegionSettings(serverUrl, token, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield RegionUrlProvider.fetchLock.lock();
-      try {
-        const regionSettingsResponse = yield fetch("".concat(getCloudConfigUrl(serverUrl), "/regions"), {
-          headers: {
-            authorization: "Bearer ".concat(token)
-          },
-          signal
-        });
-        if (regionSettingsResponse.ok) {
-          const maxAge = extractMaxAgeFromRequestHeaders(regionSettingsResponse.headers);
-          const maxAgeInMs = maxAge ? maxAge * 1000 : DEFAULT_MAX_AGE_MS;
-          const regionSettings = yield regionSettingsResponse.json();
-          return {
-            regionSettings,
-            updatedAtInMs: Date.now(),
-            maxAgeInMs
-          };
-        } else {
-          if (regionSettingsResponse.status === 401) {
-            throw ConnectionError.notAllowed("Could not fetch region settings: ".concat(regionSettingsResponse.statusText), regionSettingsResponse.status);
-          } else {
-            throw ConnectionError.internal("Could not fetch region settings: ".concat(regionSettingsResponse.statusText));
-          }
-        }
-      } catch (e) {
-        if (e instanceof ConnectionError) {
-          // rethrow connection errors
-          throw e;
-        } else if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-          throw ConnectionError.cancelled("Region fetching was aborted");
-        } else {
-          // wrap other errors as connection errors
-          throw ConnectionError.serverUnreachable("Could not fetch region settings, ".concat(e instanceof Error ? "".concat(e.name, ": ").concat(e.message) : e));
-        }
-      } finally {
-        unlock();
-      }
-    });
-  }
-  static scheduleRefetch(url, token, maxAgeInMs) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const timeout = RegionUrlProvider.settingsTimeouts.get(url.hostname);
-      clearTimeout(timeout);
-      RegionUrlProvider.settingsTimeouts.set(url.hostname, setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-        try {
-          const newSettings = yield RegionUrlProvider.fetchRegionSettings(url, token);
-          RegionUrlProvider.updateCachedRegionSettings(url, token, newSettings);
-        } catch (error) {
-          if (error instanceof ConnectionError && error.reason === ConnectionErrorReason.NotAllowed) {
-            livekitLogger.debug('token is not valid, cancelling auto region refresh');
-            return;
-          }
-          livekitLogger.debug('auto refetching of region settings failed', {
-            error
-          });
-          // continue retrying with the same max age
-          RegionUrlProvider.scheduleRefetch(url, token, maxAgeInMs);
-        }
-      }), maxAgeInMs));
-    });
-  }
-  static updateCachedRegionSettings(url, token, settings) {
-    RegionUrlProvider.cache.set(url.hostname, settings);
-    RegionUrlProvider.scheduleRefetch(url, token, settings.maxAgeInMs);
-  }
-  static stopRefetch(hostname) {
-    const timeout = RegionUrlProvider.settingsTimeouts.get(hostname);
-    if (timeout) {
-      clearTimeout(timeout);
-      RegionUrlProvider.settingsTimeouts.delete(hostname);
-    }
-  }
-  static scheduleCleanup(hostname) {
-    let tracker = RegionUrlProvider.connectionTrackers.get(hostname);
-    if (!tracker) {
-      return;
-    }
-    // Cancel any existing cleanup timeout
-    if (tracker.cleanupTimeout) {
-      clearTimeout(tracker.cleanupTimeout);
-    }
-    // Schedule cleanup to stop refetch after delay
-    tracker.cleanupTimeout = setTimeout(() => {
-      const currentTracker = RegionUrlProvider.connectionTrackers.get(hostname);
-      if (currentTracker && currentTracker.connectionCount === 0) {
-        livekitLogger.debug('stopping region refetch after disconnect delay', {
-          hostname
-        });
-        RegionUrlProvider.stopRefetch(hostname);
-      }
-      if (currentTracker) {
-        currentTracker.cleanupTimeout = undefined;
-      }
-    }, STOP_REFETCH_DELAY_MS);
-  }
-  static cancelCleanup(hostname) {
-    const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
-    if (tracker === null || tracker === void 0 ? void 0 : tracker.cleanupTimeout) {
-      clearTimeout(tracker.cleanupTimeout);
-      tracker.cleanupTimeout = undefined;
-    }
-  }
-  notifyConnected() {
-    const hostname = this.serverUrl.hostname;
-    let tracker = RegionUrlProvider.connectionTrackers.get(hostname);
-    if (!tracker) {
-      tracker = {
-        connectionCount: 0
-      };
-      RegionUrlProvider.connectionTrackers.set(hostname, tracker);
-    }
-    tracker.connectionCount++;
-    // Cancel any scheduled cleanup since we have an active connection
-    RegionUrlProvider.cancelCleanup(hostname);
-  }
-  notifyDisconnected() {
-    const hostname = this.serverUrl.hostname;
-    const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
-    if (!tracker) {
-      return;
-    }
-    tracker.connectionCount = Math.max(0, tracker.connectionCount - 1);
-    // If no more connections, schedule cleanup
-    if (tracker.connectionCount === 0) {
-      RegionUrlProvider.scheduleCleanup(hostname);
-    }
-  }
-  constructor(url, token) {
-    this.attemptedRegions = [];
-    this.serverUrl = new URL(url);
-    this.token = token;
-  }
-  updateToken(token) {
-    this.token = token;
-  }
-  isCloud() {
-    return isCloud(this.serverUrl);
-  }
-  getServerUrl() {
-    return this.serverUrl;
-  }
-  /** @internal */
-  fetchRegionSettings(abortSignal) {
-    return __awaiter(this, void 0, void 0, function* () {
-      return RegionUrlProvider.fetchRegionSettings(this.serverUrl, this.token, abortSignal);
-    });
-  }
-  getNextBestRegionUrl(abortSignal) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.isCloud()) {
-        throw Error('region availability is only supported for LiveKit Cloud domains');
-      }
-      let cachedSettings = RegionUrlProvider.cache.get(this.serverUrl.hostname);
-      if (!cachedSettings || Date.now() - cachedSettings.updatedAtInMs > cachedSettings.maxAgeInMs) {
-        cachedSettings = yield this.fetchRegionSettings(abortSignal);
-        RegionUrlProvider.updateCachedRegionSettings(this.serverUrl, this.token, cachedSettings);
-      }
-      const regionsLeft = cachedSettings.regionSettings.regions.filter(region => !this.attemptedRegions.find(attempted => attempted.url === region.url));
-      if (regionsLeft.length > 0) {
-        const nextRegion = regionsLeft[0];
-        this.attemptedRegions.push(nextRegion);
-        livekitLogger.debug("next region: ".concat(nextRegion.region));
-        return nextRegion.url;
-      } else {
-        return null;
-      }
-    });
-  }
-  resetAttempts() {
-    this.attemptedRegions = [];
-  }
-  setServerReportedRegions(settings) {
-    RegionUrlProvider.updateCachedRegionSettings(this.serverUrl, this.token, settings);
-  }
-}
-RegionUrlProvider.cache = new Map();
-RegionUrlProvider.settingsTimeouts = new Map();
-RegionUrlProvider.connectionTrackers = new Map();
-RegionUrlProvider.fetchLock = new _();
-function getCloudConfigUrl(serverUrl) {
-  return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
 }// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
@@ -18748,10 +18569,23 @@ class LocalTrack extends Track {
         if (stopProcessor && this.processor) {
           yield this.internalStopProcessor();
         }
-        return this;
       } finally {
         unlock();
       }
+      yield this.onSenderTrackSwapped();
+      return this;
+    });
+  }
+  /**
+   * Hook invoked after the MediaStreamTrack on the sender has been swapped
+   * (via replaceTrack, setProcessor, or stopProcessor). Fires outside the
+   * trackChangeLock so subclasses can do asynchronous work such as polling
+   * for new dimensions without blocking other track operations.
+   */
+  onSenderTrackSwapped() {
+    return __awaiter(this, void 0, void 0, function* () {
+      // base implementation is a no-op; LocalVideoTrack overrides this to
+      // recompute sender encoding parameters.
     });
   }
   restart(constraints, isUnmuting) {
@@ -18996,6 +18830,7 @@ class LocalTrack extends Track {
         } finally {
           unlock();
         }
+        yield _this3.onSenderTrackSwapped();
       }();
     });
   }
@@ -19018,6 +18853,7 @@ class LocalTrack extends Track {
         } finally {
           unlock();
         }
+        yield _this4.onSenderTrackSwapped();
       }();
     });
   }
@@ -19961,6 +19797,106 @@ class LocalVideoTrack extends LocalTrack {
           if (e_3) throw e_3.error;
         }
       }
+      // The new MediaStreamTrack may have different dimensions than the previous one
+      // (e.g. switching between cameras with different native resolutions), which would
+      // leave the sender's encoding parameters (scaleResolutionDownBy, maxBitrate, etc.)
+      // based on the old dimensions. Recompute them so the encoded output matches the
+      // new source.
+      yield this.onSenderTrackSwapped();
+    });
+  }
+  onSenderTrackSwapped() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.refreshSenderEncodings();
+    });
+  }
+  /**
+   * Recomputes encoding parameters for this track's senders based on the current
+   * MediaStreamTrack dimensions and reapplies them via setParameters. This is a no-op
+   * if the track hasn't been published yet or if the track is in performance-optimized
+   * mode (which manages its own encodings).
+   */
+  refreshSenderEncodings() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      if (!this.sender || !this.publishOptions || this.optimizeForPerformance) {
+        return;
+      }
+      const unlock = yield this.senderLock.lock();
+      try {
+        let dims;
+        try {
+          dims = yield this.waitForDimensions();
+        } catch (e) {
+          this.log.warn('could not determine new track dimensions, skipping encoding recompute', Object.assign(Object.assign({}, this.logContext), {
+            error: e
+          }));
+          return;
+        }
+        if (this.lastEncodedDimensions && this.lastEncodedDimensions.width === dims.width && this.lastEncodedDimensions.height === dims.height) {
+          return;
+        }
+        const isScreenShare = this.source === Track.Source.ScreenShare;
+        const newEncodings = computeVideoEncodings(isScreenShare, dims.width, dims.height, Object.assign({}, this.publishOptions));
+        yield this.applyEncodingsToSender(this.sender, newEncodings);
+        this.encodings = newEncodings;
+        this.lastEncodedDimensions = dims;
+        for (const [codec, sc] of this.simulcastCodecs) {
+          if (!sc.sender || ((_a = sc.sender.transport) === null || _a === void 0 ? void 0 : _a.state) === 'closed') {
+            continue;
+          }
+          if (!isBackupVideoCodec(codec)) {
+            continue;
+          }
+          const backupOpts = Object.assign({}, this.publishOptions);
+          const backupEncodings = computeTrackBackupEncodings(this, codec, backupOpts);
+          if (!backupEncodings) {
+            continue;
+          }
+          yield this.applyEncodingsToSender(sc.sender, backupEncodings);
+          sc.encodings = backupEncodings;
+        }
+      } catch (e) {
+        this.log.warn('failed to apply recomputed encodings', Object.assign(Object.assign({}, this.logContext), {
+          error: e
+        }));
+      } finally {
+        unlock();
+      }
+    });
+  }
+  applyEncodingsToSender(sender, encodings) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const params = sender.getParameters();
+      if (!params.encodings || params.encodings.length !== encodings.length) {
+        return;
+      }
+      params.encodings.forEach((existing, idx) => {
+        // preserve disabled layers (dynacast / Firefox workaround in
+        // setPublishingLayersForSender set scaleResolutionDownBy/maxBitrate to sentinel
+        // values for disabled layers — don't clobber those).
+        if (existing.active === false) {
+          return;
+        }
+        const next = encodings[idx];
+        if (next.scaleResolutionDownBy !== undefined) {
+          existing.scaleResolutionDownBy = next.scaleResolutionDownBy;
+        }
+        if (next.maxBitrate !== undefined) {
+          existing.maxBitrate = next.maxBitrate;
+        }
+        if (next.maxFramerate !== undefined) {
+          existing.maxFramerate = next.maxFramerate;
+        }
+        if (next.priority !== undefined) {
+          existing.priority = next.priority;
+          existing.networkPriority = next.priority;
+        }
+      });
+      this.log.debug('updating sender encodings after track restart', Object.assign(Object.assign({}, this.logContext), {
+        encodings: params.encodings
+      }));
+      yield sender.setParameters(params);
     });
   }
   setProcessor(processor_1) {
@@ -20384,6 +20320,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.midToTrackId = {};
     /** used to indicate whether the browser is currently waiting to reconnect */
     this.isWaitingForNetworkReconnect = false;
+    this.bufferStatusLowClosingFuture = new Future();
     this.handleDataChannel = _a => __awaiter(this, [_a], void 0, function (_ref) {
       var _this = this;
       let {
@@ -20532,10 +20469,10 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       this.log.debug("reconnecting in ".concat(delay, "ms"), this.logContext);
       this.clearReconnectTimeout();
-      if (this.token && this.regionUrlProvider) {
+      if (this.token) {
         // token may have been refreshed, we do not want to recreate the regionUrlProvider
         // since the current engine may have inherited a regional url
-        this.regionUrlProvider.updateToken(this.token);
+        this.emit(EngineEvent.TokenRefreshed, this.token);
       }
       this.reconnectTimeout = CriticalTimers.setTimeout(() => this.attemptReconnect(disconnectReason).finally(() => this.reconnectTimeout = undefined), delay);
     };
@@ -20635,6 +20572,13 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.client.onRequestResponse = response => this.emit(EngineEvent.SignalRequestResponse, response);
     this.client.onParticipantUpdate = updates => this.emit(EngineEvent.ParticipantUpdate, updates);
     this.client.onJoined = joinResponse => this.emit(EngineEvent.Joined, joinResponse);
+    this.on(EngineEvent.Closing, () => {
+      var _a, _b;
+      (_b = (_a = this.bufferStatusLowClosingFuture).reject) === null || _b === void 0 ? void 0 : _b.call(_a, new UnexpectedConnectionState('engine closed'));
+    });
+    // Swallow the rejection at the source so it doesn't surface as an unhandled promise rejection
+    // when no waitForBufferStatusLow callers are attached.
+    this.bufferStatusLowClosingFuture.promise.catch(() => {});
   }
   /** @internal */
   get logContext() {
@@ -20679,7 +20623,6 @@ class RTCEngine extends eventsExports.EventEmitter {
             _this2.shouldFailOnV1Path = false;
             throw ConnectionError.serviceNotFound('Simulated v1 path failure', 'v0-rtc');
           }
-          livekitLogger.warn('joining signal with ', url);
           const joinResponse = yield _this2.client.join(url, token, opts, abortSignal, useV0Path, offerProto);
           _this2._isClosed = false;
           _this2.latestJoinResponse = joinResponse;
@@ -20808,6 +20751,14 @@ class RTCEngine extends eventsExports.EventEmitter {
     return __awaiter(this, void 0, void 0, function* () {
       yield this.client.close();
       this.client.resetCallbacks();
+      // Any in-flight addTrack requests are orphaned by the signal reconnect — the new session
+      // won't deliver `trackPublishedResponse` for them, so reject the pending resolvers and
+      // clear the map. Otherwise a subsequent `addTrack` call with the same client id (e.g. a
+      // publish retry after a `NegotiationError`) throws `TrackInvalidError`.
+      for (const cid of Object.keys(this.pendingTrackResolvers)) {
+        this.pendingTrackResolvers[cid].reject();
+      }
+      this.pendingTrackResolvers = {};
     });
   }
   addTrack(req) {
@@ -20872,8 +20823,8 @@ class RTCEngine extends eventsExports.EventEmitter {
     });
   }
   /* @internal */
-  setRegionUrlProvider(provider) {
-    this.regionUrlProvider = provider;
+  setRegionStrategy(strategy) {
+    this.regionStrategy = strategy;
   }
   configure(joinResponse, useSinglePeerConnection) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -20994,9 +20945,8 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.emit(EngineEvent.LocalTrackSubscribed, trackSid);
     };
     this.client.onTokenRefresh = token => {
-      var _a;
       this.token = token;
-      (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.updateToken(token);
+      this.emit(EngineEvent.TokenRefreshed, token);
     };
     this.client.onRemoteMuteChanged = (trackSid, muted) => {
       this.emit(EngineEvent.RemoteMute, trackSid, muted);
@@ -21032,13 +20982,9 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.log.debug('client leave request', Object.assign(Object.assign({}, this.logContext), {
         reason: leave === null || leave === void 0 ? void 0 : leave.reason
       }));
-      if (leave.regions && this.regionUrlProvider) {
+      if (leave.regions) {
         this.log.debug('updating regions', this.logContext);
-        this.regionUrlProvider.setServerReportedRegions({
-          updatedAtInMs: Date.now(),
-          maxAgeInMs: DEFAULT_MAX_AGE_MS,
-          regionSettings: leave.regions
-        });
+        this.emit(EngineEvent.ServerRegionsReported, leave.regions);
       }
       switch (leave.action) {
         case LeaveRequest_Action.DISCONNECT:
@@ -21342,17 +21288,17 @@ class RTCEngine extends eventsExports.EventEmitter {
         if (this.client.currentState !== SignalConnectionState.CONNECTED) {
           throw new SignalReconnectError('Signal connection got severed during reconnect');
         }
-        (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.resetAttempts();
+        (_a = this.regionStrategy) === null || _a === void 0 ? void 0 : _a.resetAttempts();
         // reconnect success
         this.emit(EngineEvent.Restarted);
       } catch (error) {
-        const nextRegionUrl = yield (_b = this.regionUrlProvider) === null || _b === void 0 ? void 0 : _b.getNextBestRegionUrl();
+        const nextRegionUrl = yield (_b = this.regionStrategy) === null || _b === void 0 ? void 0 : _b.getNextUrl();
         if (nextRegionUrl) {
           yield this.restartConnection(nextRegionUrl);
           return;
         } else {
           // no more regions to try (or we're not on cloud)
-          (_c = this.regionUrlProvider) === null || _c === void 0 ? void 0 : _c.resetAttempts();
+          (_c = this.regionStrategy) === null || _c === void 0 ? void 0 : _c.resetAttempts();
           throw error;
         }
       }
@@ -21594,17 +21540,13 @@ class RTCEngine extends eventsExports.EventEmitter {
         if (this.isBufferStatusLow(kind)) {
           resolve();
         } else {
-          const onClosing = () => reject(new UnexpectedConnectionState('engine closed'));
-          this.once(EngineEvent.Closing, onClosing);
           const dc = this.dataChannelForKind(kind);
           if (!dc) {
             reject(new UnexpectedConnectionState("DataChannel not found, kind: ".concat(kind)));
             return;
           }
-          dc.addEventListener('bufferedamountlow', () => {
-            this.off(EngineEvent.Closing, onClosing);
-            resolve();
-          }, {
+          this.bufferStatusLowClosingFuture.promise.catch(e => reject(e));
+          dc.addEventListener('bufferedamountlow', () => resolve(), {
             once: true
           });
         }
@@ -21897,6 +21839,196 @@ function applyUserDataCompat(newObj, oldObj) {
   const destinationIdentities = newObj.destinationIdentities.length !== 0 ? newObj.destinationIdentities : oldObj.destinationIdentities;
   newObj.destinationIdentities = destinationIdentities;
   oldObj.destinationIdentities = destinationIdentities;
+}const DEFAULT_MAX_AGE_MS = 5000;
+const STOP_REFETCH_DELAY_MS = 30000;
+class RegionUrlProvider {
+  static fetchRegionSettings(serverUrl, token, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield RegionUrlProvider.fetchLock.lock();
+      try {
+        const regionSettingsResponse = yield fetch("".concat(getCloudConfigUrl(serverUrl), "/regions"), {
+          headers: {
+            authorization: "Bearer ".concat(token)
+          },
+          signal
+        });
+        if (regionSettingsResponse.ok) {
+          const maxAge = extractMaxAgeFromRequestHeaders(regionSettingsResponse.headers);
+          const maxAgeInMs = maxAge ? maxAge * 1000 : DEFAULT_MAX_AGE_MS;
+          const regionSettings = yield regionSettingsResponse.json();
+          return {
+            regionSettings,
+            updatedAtInMs: Date.now(),
+            maxAgeInMs
+          };
+        } else {
+          if (regionSettingsResponse.status === 401) {
+            throw ConnectionError.notAllowed("Could not fetch region settings: ".concat(regionSettingsResponse.statusText), regionSettingsResponse.status);
+          } else {
+            throw ConnectionError.internal("Could not fetch region settings: ".concat(regionSettingsResponse.statusText));
+          }
+        }
+      } catch (e) {
+        if (e instanceof ConnectionError) {
+          // rethrow connection errors
+          throw e;
+        } else if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+          throw ConnectionError.cancelled("Region fetching was aborted");
+        } else {
+          // wrap other errors as connection errors
+          throw ConnectionError.serverUnreachable("Could not fetch region settings, ".concat(e instanceof Error ? "".concat(e.name, ": ").concat(e.message) : e));
+        }
+      } finally {
+        unlock();
+      }
+    });
+  }
+  static scheduleRefetch(url, token, maxAgeInMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const timeout = RegionUrlProvider.settingsTimeouts.get(url.hostname);
+      clearTimeout(timeout);
+      RegionUrlProvider.settingsTimeouts.set(url.hostname, setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          const newSettings = yield RegionUrlProvider.fetchRegionSettings(url, token);
+          RegionUrlProvider.updateCachedRegionSettings(url, token, newSettings);
+        } catch (error) {
+          if (error instanceof ConnectionError && error.reason === ConnectionErrorReason.NotAllowed) {
+            livekitLogger.debug('token is not valid, cancelling auto region refresh');
+            return;
+          }
+          livekitLogger.debug('auto refetching of region settings failed', {
+            error
+          });
+          // continue retrying with the same max age
+          RegionUrlProvider.scheduleRefetch(url, token, maxAgeInMs);
+        }
+      }), maxAgeInMs));
+    });
+  }
+  static updateCachedRegionSettings(url, token, settings) {
+    RegionUrlProvider.cache.set(url.hostname, settings);
+    RegionUrlProvider.scheduleRefetch(url, token, settings.maxAgeInMs);
+  }
+  static stopRefetch(hostname) {
+    const timeout = RegionUrlProvider.settingsTimeouts.get(hostname);
+    if (timeout) {
+      clearTimeout(timeout);
+      RegionUrlProvider.settingsTimeouts.delete(hostname);
+    }
+  }
+  static scheduleCleanup(hostname) {
+    let tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (!tracker) {
+      return;
+    }
+    // Cancel any existing cleanup timeout
+    if (tracker.cleanupTimeout) {
+      clearTimeout(tracker.cleanupTimeout);
+    }
+    // Schedule cleanup to stop refetch after delay
+    tracker.cleanupTimeout = setTimeout(() => {
+      const currentTracker = RegionUrlProvider.connectionTrackers.get(hostname);
+      if (currentTracker && currentTracker.connectionCount === 0) {
+        livekitLogger.debug('stopping region refetch after disconnect delay', {
+          hostname
+        });
+        RegionUrlProvider.stopRefetch(hostname);
+      }
+      if (currentTracker) {
+        currentTracker.cleanupTimeout = undefined;
+      }
+    }, STOP_REFETCH_DELAY_MS);
+  }
+  static cancelCleanup(hostname) {
+    const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (tracker === null || tracker === void 0 ? void 0 : tracker.cleanupTimeout) {
+      clearTimeout(tracker.cleanupTimeout);
+      tracker.cleanupTimeout = undefined;
+    }
+  }
+  notifyConnected() {
+    const hostname = this.serverUrl.hostname;
+    let tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (!tracker) {
+      tracker = {
+        connectionCount: 0
+      };
+      RegionUrlProvider.connectionTrackers.set(hostname, tracker);
+    }
+    tracker.connectionCount++;
+    // Cancel any scheduled cleanup since we have an active connection
+    RegionUrlProvider.cancelCleanup(hostname);
+  }
+  notifyDisconnected() {
+    const hostname = this.serverUrl.hostname;
+    const tracker = RegionUrlProvider.connectionTrackers.get(hostname);
+    if (!tracker) {
+      return;
+    }
+    tracker.connectionCount = Math.max(0, tracker.connectionCount - 1);
+    // If no more connections, schedule cleanup
+    if (tracker.connectionCount === 0) {
+      RegionUrlProvider.scheduleCleanup(hostname);
+    }
+  }
+  constructor(url, token) {
+    this.attemptedRegions = [];
+    this.serverUrl = new URL(url);
+    this.token = token;
+  }
+  updateToken(token) {
+    var _a;
+    this.token = token;
+    const url = this.getServerUrl();
+    const settings = RegionUrlProvider.cache.get(url.hostname);
+    RegionUrlProvider.scheduleRefetch(this.serverUrl, this.token, (_a = settings === null || settings === void 0 ? void 0 : settings.maxAgeInMs) !== null && _a !== void 0 ? _a : DEFAULT_MAX_AGE_MS);
+  }
+  isCloud() {
+    return isCloud(this.serverUrl);
+  }
+  getServerUrl() {
+    return this.serverUrl;
+  }
+  /** @internal */
+  fetchRegionSettings(abortSignal) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return RegionUrlProvider.fetchRegionSettings(this.serverUrl, this.token, abortSignal);
+    });
+  }
+  getNextBestRegionUrl(abortSignal) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.isCloud()) {
+        throw Error('region availability is only supported for LiveKit Cloud domains');
+      }
+      let cachedSettings = RegionUrlProvider.cache.get(this.serverUrl.hostname);
+      if (!cachedSettings || Date.now() - cachedSettings.updatedAtInMs > cachedSettings.maxAgeInMs) {
+        cachedSettings = yield this.fetchRegionSettings(abortSignal);
+        RegionUrlProvider.updateCachedRegionSettings(this.serverUrl, this.token, cachedSettings);
+      }
+      const regionsLeft = cachedSettings.regionSettings.regions.filter(region => !this.attemptedRegions.find(attempted => attempted.url === region.url));
+      if (regionsLeft.length > 0) {
+        const nextRegion = regionsLeft[0];
+        this.attemptedRegions.push(nextRegion);
+        livekitLogger.debug("next region: ".concat(nextRegion.region));
+        return nextRegion.url;
+      } else {
+        return null;
+      }
+    });
+  }
+  resetAttempts() {
+    this.attemptedRegions = [];
+  }
+  setServerReportedRegions(settings) {
+    RegionUrlProvider.updateCachedRegionSettings(this.serverUrl, this.token, settings);
+  }
+}
+RegionUrlProvider.cache = new Map();
+RegionUrlProvider.settingsTimeouts = new Map();
+RegionUrlProvider.connectionTrackers = new Map();
+RegionUrlProvider.fetchLock = new _();
+function getCloudConfigUrl(serverUrl) {
+  return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
 }class BaseStreamReader {
   get info() {
     return this._info;
@@ -25270,10 +25402,17 @@ class HTMLElementInfo {
       }
     };
     this.onEnterPiP = () => {
-      var _a, _b, _c;
+      var _a, _b;
       (_b = (_a = window.documentPictureInPicture) === null || _a === void 0 ? void 0 : _a.window) === null || _b === void 0 ? void 0 : _b.addEventListener('pagehide', this.onLeavePiP);
-      this.isPiP = isElementInPiP(this.element);
-      (_c = this.handleVisibilityChanged) === null || _c === void 0 ? void 0 : _c.call(this);
+      // Document PiP: the browser may fire 'enter' before the app has appended its subtree into
+      // documentPictureInPicture.window. Defer so pipWin.document.contains(video) is reliable.
+      queueMicrotask(() => {
+        requestAnimationFrame(() => {
+          var _a;
+          this.isPiP = isElementInPiP(this.element);
+          (_a = this.handleVisibilityChanged) === null || _a === void 0 ? void 0 : _a.call(this);
+        });
+      });
     };
     this.onLeavePiP = () => {
       var _a;
@@ -26546,11 +26685,12 @@ class Participant extends eventsExports.EventEmitter {
         if (track && track.track) {
           // screenshare cannot be muted, unpublish instead
           if (source === Track.Source.ScreenShare) {
-            track = yield this.unpublishTrack(track.track);
+            const unpublishPromises = [this.unpublishTrack(track.track)];
             const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
             if (screenAudioTrack && screenAudioTrack.track) {
-              this.unpublishTrack(screenAudioTrack.track);
+              unpublishPromises.push(this.unpublishTrack(screenAudioTrack.track));
             }
+            [track] = yield Promise.all(unpublishPromises);
           } else {
             yield track.mute();
           }
@@ -26681,10 +26821,42 @@ class Participant extends eventsExports.EventEmitter {
       return this.publishOrRepublishTrack(track, options);
     });
   }
+  /**
+   * Waits for the engine's next `Restarted` event. Unlike `engine.waitForRestarted`, this does
+   * not short-circuit when `pcState === Connected` — at the point this is called (right after a
+   * `NegotiationError`) the PC transport is still connected, but `fullReconnectOnNext` has been
+   * set and `attemptReconnect` is queued via setTimeout. We need to wait for that restart to
+   * actually complete (which clears `pendingTrackResolvers` via `cleanupClient`) before retrying.
+   */
+  waitForNextEngineRestart() {
+    let timeoutMs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 15000;
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.engine.off(EngineEvent.Restarted, onRestarted);
+        this.engine.off(EngineEvent.Closing, onClosing);
+      };
+      const onRestarted = () => {
+        cleanup();
+        resolve();
+      };
+      const onClosing = () => {
+        cleanup();
+        reject(new Error('engine closed before restart completed'));
+      };
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error('timed out waiting for engine restart'));
+      }, timeoutMs);
+      this.engine.once(EngineEvent.Restarted, onRestarted);
+      this.engine.once(EngineEvent.Closing, onClosing);
+    });
+  }
   publishOrRepublishTrack(track_1, options_1) {
     return __awaiter(this, arguments, void 0, function (track, options) {
       var _this2 = this;
       let isRepublish = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      let hasRetriedAfterNegotiationError = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
       return function* () {
         var _a, _b, _c, _d;
         if (isLocalAudioTrack(track)) {
@@ -26815,6 +26987,14 @@ class Participant extends eventsExports.EventEmitter {
           const publication = yield publishPromise;
           return publication;
         } catch (e) {
+          if (!hasRetriedAfterNegotiationError && e instanceof NegotiationError) {
+            _this2.log.warn('negotiation due to track publish failed, retrying after reconnect', Object.assign(Object.assign({}, _this2.logContext), {
+              error: e
+            }));
+            _this2.pendingPublishPromises.delete(track);
+            yield _this2.waitForNextEngineRestart();
+            return yield _this2.publishOrRepublishTrack(track, options, isRepublish, true);
+          }
           throw e;
         } finally {
           _this2.pendingPublishPromises.delete(track);
@@ -27054,7 +27234,11 @@ class Participant extends eventsExports.EventEmitter {
           resolve(ti);
         } catch (err) {
           if (track.sender && ((_a = this.engine.pcManager) === null || _a === void 0 ? void 0 : _a.publisher)) {
-            this.engine.pcManager.publisher.removeTrack(track.sender);
+            try {
+              this.engine.pcManager.publisher.removeTrack(track.sender);
+            } catch (e) {
+              this.log.error(e, this.logContext);
+            }
             yield this.engine.negotiate().catch(negotiateErr => {
               this.log.error('failed to negotiate after removing track due to failed add track request', Object.assign(Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)), {
                 error: negotiateErr
@@ -27098,6 +27282,19 @@ class Participant extends eventsExports.EventEmitter {
       // save options for when it needs to be republished again
       publication.options = opts;
       track.sid = ti.sid;
+      // keep publish options on the video track so that it can recompute encoding
+      // parameters when the MediaStreamTrack is restarted (e.g. after switching cameras).
+      // Seed the dimensions we encoded at publish time so the first no-op restart
+      // (e.g. unmute with unchanged constraints) can skip the recompute.
+      if (isLocalVideoTrack(track)) {
+        track.publishOptions = opts;
+        if (req.width && req.height) {
+          track.lastEncodedDimensions = {
+            width: req.width,
+            height: req.height
+          };
+        }
+      }
       this.log.debug("publishing ".concat(track.kind, " with encodings"), Object.assign(Object.assign({}, this.logContext), {
         encodings,
         trackInfo: ti
@@ -27297,13 +27494,19 @@ class Participant extends eventsExports.EventEmitter {
               negotiationNeeded = true;
             }
           }
-          if (this.engine.removeTrack(trackSender)) {
+          try {
+            negotiationNeeded = this.engine.removeTrack(trackSender);
+          } catch (e) {
+            this.log.warn(e, this.logContext);
             negotiationNeeded = true;
           }
           if (isLocalVideoTrack(track)) {
             for (const [, trackInfo] of track.simulcastCodecs) {
               if (trackInfo.sender) {
-                if (this.engine.removeTrack(trackInfo.sender)) {
+                try {
+                  negotiationNeeded = this.engine.removeTrack(trackInfo.sender);
+                } catch (e) {
+                  this.log.warn(e, this.logContext);
                   negotiationNeeded = true;
                 }
                 trackInfo.sender = undefined;
@@ -28641,7 +28844,7 @@ class Room extends eventsExports.EventEmitter {
         this.maybeCreateEngine();
       }
       if ((_b = this.regionUrlProvider) === null || _b === void 0 ? void 0 : _b.isCloud()) {
-        this.engine.setRegionUrlProvider(this.regionUrlProvider);
+        this.engine.setRegionStrategy(this.createRegionStrategy());
       }
       this.acquireAudioContext();
       this.connOptions = Object.assign(Object.assign({}, roomConnectOptionDefaults), opts);
@@ -29525,6 +29728,16 @@ class Room extends eventsExports.EventEmitter {
         return [participant.identity, participant.dataTracks.map(info => DataTrackInfo.from(info))];
       }));
       this.incomingDataTrackManager.receiveSfuPublicationUpdates(mapped);
+    }).on(EngineEvent.TokenRefreshed, token => {
+      var _a;
+      (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.updateToken(token);
+    }).on(EngineEvent.ServerRegionsReported, regions => {
+      var _a;
+      (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.setServerReportedRegions({
+        regionSettings: regions,
+        updatedAtInMs: Date.now(),
+        maxAgeInMs: DEFAULT_MAX_AGE_MS
+      });
     });
     if (this.localParticipant) {
       this.localParticipant.setupEngine(this.engine);
@@ -29536,6 +29749,17 @@ class Room extends eventsExports.EventEmitter {
       this.outgoingDataStreamManager.setupEngine(this.engine);
     }
   }
+  createRegionStrategy() {
+    return {
+      getNextUrl: signal => __awaiter(this, void 0, void 0, function* () {
+        return this.regionUrlProvider ? this.regionUrlProvider.getNextBestRegionUrl(signal) : null;
+      }),
+      resetAttempts: () => {
+        var _a;
+        return (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.resetAttempts();
+      }
+    };
+  }
   /**
    * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
    * In particular, it requests device permissions by default if needed