livekit-client 2.22.4 → 2.23.0

package/dist/livekit-client.esm.mjs

@@ -8708,6 +8708,11 @@ function onWorkerLogLevelChanged(cb) {
     workerLogLevelListeners.delete(cb);
   };
 }const maxRetryDelay = 7000;
+/**
+ * Upper bound of the random delay added to the first retry, whose base delay is 0. It keeps a
+ * brief network blip recovering quickly while spreading out clients that disconnect together.
+ */
+const maxFirstRetryJitterInMs = 500;
 const DEFAULT_RETRY_DELAYS_IN_MS = [0, 300, 2 * 2 * 300, 3 * 3 * 300, 4 * 4 * 300, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay];
 class DefaultReconnectPolicy {
   constructor(retryDelays) {
@@ -8716,8 +8721,13 @@ class DefaultReconnectPolicy {
   nextRetryDelayInMs(context) {
     if (context.retryCount >= this._retryDelays.length) return null;
     const retryDelay = this._retryDelays[context.retryCount];
-    if (context.retryCount <= 1) return retryDelay;
-    return retryDelay + Math.random() * 1000;
+    // The first retry has no base delay to scale, so it gets a fixed window instead. A zero at a
+    // later index is an explicit request for an immediate retry and passes through the formula as zero.
+    if (context.retryCount === 0 && retryDelay === 0) {
+      return Math.random() * maxFirstRetryJitterInMs;
+    }
+    // Jitter scales with the delay (+/-50%) so clients spread out further on later retries.
+    return Math.round(retryDelay * (0.5 + Math.random()));
   }
 }/******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -12290,7 +12300,7 @@ function getMatch(exp, ua) {
 }
 function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
-}var version$1 = "2.22.4";const version = version$1;
+}var version$1 = "2.23.0";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -13558,20 +13568,44 @@ function detectSilence(track_1) {
     let timeOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200;
     return function* () {
       const ctx = getNewAudioContext();
-      if (ctx) {
-        const analyser = ctx.createAnalyser();
+      if (!ctx) {
+        return false;
+      }
+      let source;
+      let analyser;
+      try {
+        analyser = ctx.createAnalyser();
         analyser.fftSize = 2048;
         const bufferLength = analyser.frequencyBinCount;
         const dataArray = new Uint8Array(bufferLength);
-        const source = ctx.createMediaStreamSource(new MediaStream([track.mediaStreamTrack]));
+        source = ctx.createMediaStreamSource(new MediaStream([track.mediaStreamTrack]));
         source.connect(analyser);
+        // read through a function so that `state` isn't narrowed to its value from before `resume`
+        const isRunning = () => ctx.state === 'running';
+        if (!isRunning()) {
+          try {
+            // `resume` can stay pending indefinitely on a blocked page rather than rejecting, which
+            // would keep the context and its nodes alive past the `finally` below
+            yield Promise.race([ctx.resume(), sleep(200)]);
+          } catch (_a) {
+            // autoplay policies can keep us from resuming the context
+          }
+          if (!isRunning()) {
+            // a context that isn't running doesn't process any audio, so the analyser would only ever
+            // read silence. Report the track as not silent rather than raising a false positive.
+            return false;
+          }
+        }
         yield sleep(timeOffset);
         analyser.getByteTimeDomainData(dataArray);
         const someNoise = dataArray.some(sample => sample !== 128 && sample !== 0);
-        ctx.close();
         return !someNoise;
+      } finally {
+        source === null || source === void 0 ? void 0 : source.disconnect();
+        analyser === null || analyser === void 0 ? void 0 : analyser.disconnect();
+        // don't let a failing teardown mask the detection result
+        yield ctx.close().catch(() => {});
       }
-      return false;
     }();
   });
 }
@@ -14710,6 +14744,15 @@ function createDummyVideoStreamTrack() {
   return dummyTrack;
 }
 let emptyAudioStreamTrack;
+let emptyAudioStreamContext;
+/** tracks handed out by `getEmptyAudioStreamTrack` that haven't been released yet */
+const outstandingEmptyAudioStreamTracks = new Set();
+/**
+ * Returns a silent audio track, cloned off a shared `AudioContext` created on first use. Hand the
+ * clone back to `releaseEmptyAudioStreamTrack` rather than stopping it, so the context can close.
+ * A clone that is only stopped stays counted as outstanding, which holds the shared context open
+ * for the lifetime of the page.
+ */
 function getEmptyAudioStreamTrack() {
   if (!emptyAudioStreamTrack) {
     // implementation adapted from https://blog.mozilla.org/webrtc/warm-up-with-replacetrack/
@@ -14725,11 +14768,38 @@ function getEmptyAudioStreamTrack() {
     var _dst$stream$getAudioT2 = _slicedToArray(_dst$stream$getAudioT, 1);
     emptyAudioStreamTrack = _dst$stream$getAudioT2[0];
     if (!emptyAudioStreamTrack) {
+      // don't hold on to a context we can't get a track out of
+      ctx.close().catch(() => {});
       throw Error('Could not get empty media stream audio track');
     }
     emptyAudioStreamTrack.enabled = false;
+    emptyAudioStreamContext = ctx;
   }
-  return emptyAudioStreamTrack.clone();
+  const track = emptyAudioStreamTrack.clone();
+  outstandingEmptyAudioStreamTracks.add(track);
+  return track;
+}
+/**
+ * Stops a track obtained from `getEmptyAudioStreamTrack` and closes the shared `AudioContext`
+ * backing it once every track it handed out has been released. Does nothing for a track this
+ * module never handed out, or one that has been released already.
+ */
+function releaseEmptyAudioStreamTrack(track) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (!outstandingEmptyAudioStreamTracks.delete(track)) {
+      // the track wasn't obtained from `getEmptyAudioStreamTrack`, or has been released before
+      return;
+    }
+    track.stop();
+    if (outstandingEmptyAudioStreamTracks.size > 0) {
+      return;
+    }
+    const context = emptyAudioStreamContext;
+    emptyAudioStreamTrack === null || emptyAudioStreamTrack === void 0 ? void 0 : emptyAudioStreamTrack.stop();
+    emptyAudioStreamTrack = undefined;
+    emptyAudioStreamContext = undefined;
+    yield context === null || context === void 0 ? void 0 : context.close();
+  });
 }
 /** An object that represents a serialized version of a `new Promise((resolve, reject) => {})`
  * constructor. Wait for a promise resolution with `await future.promise` and explicitly resolve or
@@ -14793,11 +14863,19 @@ function createAudioAnalyser(track, options) {
     const volume = Math.sqrt(sum / dataArray.length);
     return volume;
   };
+  let isCleanedUp = false;
   const cleanup = () => __awaiter(this, void 0, void 0, function* () {
-    yield audioContext.close();
+    if (isCleanedUp) {
+      // closing an already closed context would reject, make repeated cleanups a no-op instead
+      return;
+    }
+    isCleanedUp = true;
+    mediaStreamSource.disconnect();
+    analyser.disconnect();
     if (opts.cloneTrack) {
       streamTrack.stop();
     }
+    yield audioContext.close();
   });
   return {
     calculateVolume,
@@ -14832,6 +14910,31 @@ function unwrapConstraint(constraint) {
   }
   throw Error('could not unwrap constraint');
 }
+/**
+ * The getUserMedia rejections that no softer constraint can recover from, because the user or the
+ * document refused capture outright. Retrying one of these would put a second prompt in front of
+ * someone who already said no. The last two names are legacy spellings still reported by older
+ * engines. Matched by `name` rather than with `instanceof`, because these are not reliably distinct
+ * constructors across environments. happy-dom, which the tests run under, aliases them to `Event`.
+ */
+function isPermissionDeniedError(e) {
+  return typeof e === 'object' && e !== null && 'name' in e && (e.name === 'NotAllowedError' || e.name === 'SecurityError' || e.name === 'PermissionDeniedError' || e.name === 'PermissionDismissedError');
+}
+const deviceAcquisitionFailures = new WeakSet();
+/** Records that `e` is the rejection getUserMedia itself produced. */
+function markDeviceAcquisitionFailure(e) {
+  if (typeof e === 'object' && e !== null) {
+    deviceAcquisitionFailures.add(e);
+  }
+}
+/**
+ * Whether a track restart failed at getUserMedia rather than in the work that adopts the new track.
+ * Recorded on the side rather than by wrapping, because callers of `restartTrack` match on the
+ * rejection's own name.
+ */
+function isDeviceAcquisitionFailure(e) {
+  return typeof e === 'object' && e !== null && deviceAcquisitionFailures.has(e);
+}
 function toWebsocketUrl(url) {
   if (url.startsWith('http')) {
     return url.replace(/^(http)/, 'ws');
@@ -16545,12 +16648,16 @@ class E2EEManager extends eventsExports.EventEmitter {
     this.handleReceiver(track.receiver, track.mediaStreamID, remoteId, track.kind === 'video' ? mimeTypeToVideoCodecString(trackInfo.mimeType) : undefined, hasPacketTrailer);
   }
   setupE2EESender(track, sender) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (!isLocalTrack(track) || !sender) {
       if (!sender) this.log.warn('early return because sender is not ready');
       return;
     }
-    this.handleSender(sender, track.mediaStreamID, undefined, isVideoTrack(track) ? (_b = (_a = track.publishOptions) === null || _a === void 0 ? void 0 : _a.frameMetadata) !== null && _b !== void 0 ? _b : (_c = track.publishOptions) === null || _c === void 0 ? void 0 : _c.packetTrailer : undefined);
+    const isVideo = isVideoTrack(track);
+    // Safari exposes no per-frame codec info until trackInfo arrives. Seed only h264/h265:
+    // a wrong vp8 seed would skip the NALU path, a wrong NALU seed only costs a logged fallback.
+    const publishedCodec = isVideo ? (_a = track.publishOptions) === null || _a === void 0 ? void 0 : _a.videoCodec : undefined;
+    this.handleSender(sender, track.mediaStreamID, publishedCodec === 'h264' || publishedCodec === 'h265' ? publishedCodec : undefined, isVideo ? (_c = (_b = track.publishOptions) === null || _b === void 0 ? void 0 : _b.frameMetadata) !== null && _c !== void 0 ? _c : (_d = track.publishOptions) === null || _d === void 0 ? void 0 : _d.packetTrailer : undefined);
   }
   /**
    * Handles the given {@code RTCRtpReceiver} by creating a {@code TransformStream} which will inject
@@ -17320,6 +17427,58 @@ class AsyncQueue {
   snapshot() {
     return Array.from(this.pendingTasks.values());
   }
+}/**
+ * Implementation of AbortSignal.any
+ * Creates a signal that will be aborted when any of the given signals is aborted.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
+ */
+function abortSignalAny(signals) {
+  // Handle empty signals array
+  if (signals.length === 0) {
+    const controller = new AbortController();
+    return controller.signal;
+  }
+  // Fast path for single signal
+  if (signals.length === 1) {
+    return signals[0];
+  }
+  // Check if any signal is already aborted
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal;
+    }
+  }
+  // Create a new controller for the combined signal
+  const controller = new AbortController();
+  const unlisteners = Array(signals.length);
+  // Function to clean up all event listeners
+  const cleanup = () => {
+    for (const unsubscribe of unlisteners) {
+      unsubscribe();
+    }
+  };
+  // Add event listeners to each signal
+  signals.forEach((signal, index) => {
+    const handler = () => {
+      controller.abort(signal.reason);
+      cleanup();
+    };
+    signal.addEventListener('abort', handler);
+    unlisteners[index] = () => signal.removeEventListener('abort', handler);
+  });
+  return controller.signal;
+}
+/**
+ * Implementation of AbortSignal.timeout
+ * Creates a signal that will be aborted after the specified timeout.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
+ */
+function abortSignalTimeout(ms) {
+  const controller = new AbortController();
+  setTimeout(() => {
+    controller.abort(new DOMException("signal timed out after ".concat(ms, " ms"), 'TimeoutError'));
+  }, ms);
+  return controller.signal;
 }/**
  * Opt-in registry that lets a development tool observe the state machines driving the connection
  * layer.
@@ -18477,7 +18636,7 @@ class WebSocketStream {
       let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
         code = _ref.closeCode,
         reason = _ref.reason;
-      return ws.close(code, reason);
+      return ws.close(code, reason === undefined ? undefined : truncateCloseReason(reason));
     };
     this.opened = new TypedPromise((resolve, reject) => {
       const rejectHandler = () => {
@@ -18553,6 +18712,25 @@ class WebSocketStream {
     }
     this.close = closeWithInfo;
   }
+}
+/** `WebSocket.close` throws a `SyntaxError` for a reason longer than this many UTF-8 bytes. */
+const MAX_CLOSE_REASON_BYTES = 123;
+function truncateCloseReason(reason) {
+  const encoder = new TextEncoder();
+  if (encoder.encode(reason).length <= MAX_CLOSE_REASON_BYTES) {
+    return reason;
+  }
+  // cut on code point boundaries, so a multi-byte character is never split
+  let truncated = '';
+  let bytes = 0;
+  for (const char of reason) {
+    bytes += encoder.encode(char).length;
+    if (bytes > MAX_CLOSE_REASON_BYTES) {
+      break;
+    }
+    truncated += char;
+  }
+  return truncated;
 }const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 /**
  * Whether a failed resume may be followed by another one. Mirrors how `RTCEngine` classifies these
@@ -18768,12 +18946,25 @@ class SignalClient {
       let publisherOffer = arguments.length > 5 ? arguments[5] : undefined;
       return function* () {
         const unlock = yield _this2.connectionLock.lock();
-        _this2.connectOptions = opts;
-        _this2.useV0SignalPath = useV0Path;
-        const clientInfo = getClientInfo(opts.clientInfoCapabilities);
-        const params = useV0Path ? createConnectionParams(token, clientInfo, opts) : yield createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
-        const rtcUrl = createRtcUrl(url, params, useV0Path).toString();
-        const validateUrl = createValidateUrl(rtcUrl).toString();
+        let rtcUrl;
+        let validateUrl;
+        try {
+          _this2.connectOptions = opts;
+          _this2.useV0SignalPath = useV0Path;
+          const clientInfo = getClientInfo(opts.clientInfoCapabilities);
+          const params = useV0Path ? createConnectionParams(token, clientInfo, opts) : yield createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
+          rtcUrl = createRtcUrl(url, params, useV0Path).toString();
+          validateUrl = createValidateUrl(rtcUrl).toString();
+        } catch (e) {
+          // the executor below owns the lock from here on
+          unlock();
+          throw e;
+        }
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+          unlock();
+          _this2.log.debug('signal connect abandoned before opening a transport');
+          throw ConnectionError.cancelled('Connection aborted');
+        }
         return new Promise((resolve, reject) => __awaiter(_this2, void 0, void 0, function* () {
           var _a, _b, _c, _d, _e;
           try {
@@ -18787,12 +18978,12 @@ class SignalClient {
               const reason = getAbortReasonAsString(target, 'Abort handler called');
               // send leave if we have an active stream writer (connection is open)
               if (this.streamWriter && !this.isDisconnected) {
-                this.sendLeave().then(() => this.close(reason)).catch(e => {
+                this.sendLeave().then(() => this.close(true, reason)).catch(e => {
                   this.log.error(e);
-                  this.close();
+                  this.close(true, reason);
                 });
               } else {
-                this.close();
+                this.close(true, reason);
               }
               cleanupAbortHandlers();
               // The caller may already have classified this failure: the connect timeout hands us a
@@ -18818,6 +19009,10 @@ class SignalClient {
               yield this.teardownTransport('replaced by a new connection attempt');
               this.log.debug("closed previous ws connection in ".concat(performance.now() - startClose, "ms"));
             }
+            if (alreadyAborted) {
+              this.log.debug('signal connect abandoned after tearing down the previous transport');
+              return;
+            }
             // the transport created below belongs to this attempt; events arriving from it after a
             // newer attempt has started are dropped by the machine
             const attemptId = this.attemptId;
@@ -18862,6 +19057,12 @@ class SignalClient {
                 }
               });
               const connection = yield this.ws.opened.catch(reason => __awaiter(this, void 0, void 0, function* () {
+                if (alreadyAborted) {
+                  // the abort handler has already rejected this attempt; don't probe the validate
+                  // endpoint for a failure nobody is waiting on
+                  this.log.debug('signal connect abandoned while the websocket was opening');
+                  return;
+                }
                 if (this.lifecycleState !== 'connected') {
                   // claimed synchronously, before the await below: the socket's close event is already
                   // on its way and would otherwise reject first with a less useful error
@@ -18924,6 +19125,13 @@ class SignalClient {
                 return;
               }
               signalReader.releaseLock();
+              if (alreadyAborted) {
+                // The abort handler has already rejected this attempt and is closing the transport.
+                // Don't act on a join that raced it: `onJoined` would publish an abandoned session's
+                // state to the room.
+                this.log.debug('signal connect abandoned while waiting for the first message');
+                return;
+              }
               // Validate the first message
               const validation = this.validateFirstMessage(firstSignalResponse, (_d = opts.reconnect) !== null && _d !== void 0 ? _d : false);
               if (!validation.isValid) {
@@ -19020,16 +19228,17 @@ class SignalClient {
     return __awaiter(this, void 0, void 0, function* () {
       try {
         this.clearPingInterval();
-        if (this.ws) {
-          this.ws.close({
+        const ws = this.ws;
+        if (ws) {
+          // released before closing, so a close that throws cannot leave the transport attached
+          this.ws = undefined;
+          this.streamWriter = undefined;
+          ws.close({
             closeCode: 1000,
             reason
           });
           // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
-          const closePromise = this.ws.closed;
-          this.ws = undefined;
-          this.streamWriter = undefined;
-          yield Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
+          yield Promise.race([ws.closed, sleep(MAX_WS_CLOSE_TIME)]);
         }
       } catch (e) {
         this.log.debug('websocket error while closing', {
@@ -19552,7 +19761,9 @@ class SignalClient {
   handleConnectionError(reason, validateUrl) {
     return __awaiter(this, void 0, void 0, function* () {
       try {
-        const resp = yield fetch(validateUrl);
+        const resp = yield fetch(validateUrl, {
+          signal: abortSignalTimeout(3000)
+        });
         switch (resp.status) {
           case 404:
             const errorMsg = yield resp.text();
@@ -19576,7 +19787,11 @@ class SignalClient {
           });
         }
       } catch (e) {
-        return e instanceof ConnectionError ? e : ConnectionError.serverUnreachable(e instanceof Error ? e.message : 'server was not reachable');
+        if (e instanceof ConnectionError) {
+          return e;
+        } else {
+          return ConnectionError.serverUnreachable(e instanceof Error ? e.message : 'server was not reachable');
+        }
       }
     });
   }
@@ -20502,15 +20717,32 @@ function requireLib() {
  * Why same for all codecs: Target bitrate already accounts for codec efficiency
  * (e.g., users set lower targets for VP9/AV1 knowing they're more efficient).
  * Why cap at 1 Mbps: Prevents BWE from starting too aggressively on high bitrate tracks.
+ * The cap is lowered further for connections that were slow to set up, see
+ * `computeStartBitrateCap`, or that the browser reports as slow, see
+ * `connectionEffectiveTypeStartBitrateCap`.
  */
 const startBitrateMultiplier = 0.9;
 /** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
 const maxStartBitrateKbps = 1000;
 /**
- * Minimum target bitrate in kbps for the start bitrate hint. Below this, seeding above the
- * real capacity costs more than the ramp it saves, so libwebrtc's default is left in place.
+ * Minimum x-google-start-bitrate in kbps: libwebrtc's own default starting estimate. A target
+ * below this gets no hint, since seeding above the real capacity costs more than the ramp it
+ * saves, and a slow connection is seeded no higher than this.
  */
 const minTargetBitrateKbps = 300;
+/**
+ * Connection setup times (ms) bounding the ramp in `computeStartBitrateCap`: at or below the
+ * first the hint is capped at `maxStartBitrateKbps`, at or above the second at
+ * `minTargetBitrateKbps`. Measured on shaped links (CLT-3380): healthy links set up in under
+ * 860 ms, a 1 Mbps link with 150 ms RTT took 1.1–1.7 s, a 500 kbps link ~2.3 s at the median,
+ * and a 300 kbps link never under 3 s. The first sits above the 1 Mbps link, which a lower seed
+ * only slows down, and the second above the 500 kbps link's median, so only links that cannot
+ * carry more land at the floor.
+ */
+const setupTimeForMaxStartBitrateMs = 1500;
+const setupTimeForMinStartBitrateMs = 3500;
+/** Cap on the start bitrate hint, in kbps, when the browser reports a `3g` connection. */
+const effectiveType3gStartBitrateKbps = 500;
 const debounceInterval = 20;
 /**
  * Codec payload for `codec` in this media section, when the section carries `cid`.
@@ -20537,17 +20769,66 @@ function findTrackCodecPayload(media, cid, codec) {
  * high-bitrate track; screen share is exempt, because its content needs the bitrate
  * immediately to stay legible.
  *
- * TODO: adjust dynamically from network conditions (e.g. a previous BWE estimate) rather
- * than a fixed cap.
+ * The cap is lowered for a connection that was slow to set up (`computeStartBitrateCap`), and
+ * for one the browser reports as slow (`connectionEffectiveTypeStartBitrateCap`), whichever is
+ * lower. Screen share is exempt from both, however slow the connection.
  *
  * @internal
  */
-function computeTrackStartBitrate(trackbr) {
+function computeTrackStartBitrate(trackbr, connectionSetupTimeMs) {
   if (trackbr.maxbr < minTargetBitrateKbps) {
     return undefined;
   }
-  const calculated = Math.round(trackbr.maxbr * startBitrateMultiplier);
-  return trackbr.isScreenShare ? calculated : Math.min(calculated, maxStartBitrateKbps);
+  const calculated = Math.min(Math.round(trackbr.maxbr * startBitrateMultiplier), trackbr.maxbr);
+  if (trackbr.isScreenShare) {
+    return calculated;
+  }
+  const cap = Math.min(computeStartBitrateCap(connectionSetupTimeMs), connectionEffectiveTypeStartBitrateCap());
+  return Math.min(calculated, cap);
+}
+/**
+ * Cap on the start bitrate hint, in kbps, from the browser's effective connection type
+ * (`navigator.connection.effectiveType`, Chromium only): `slow-2g` and `2g` cap at
+ * `minTargetBitrateKbps`, `3g` at `effectiveType3gStartBitrateKbps`.
+ *
+ * It catches links that have low bandwidth but low latency, which set up quickly and so slip
+ * past the setup time ramp. `4g`, and browsers without the API, give no guidance and stay at the
+ * `maxStartBitrateKbps` ceiling, as `computeStartBitrateCap` does without a setup time. The
+ * connection RTT the API also reports is not used: it lags behind network changes, and the setup
+ * time already reflects latency.
+ */
+function connectionEffectiveTypeStartBitrateCap() {
+  // A `typeof` guard, since `globalThis` is missing from some supported browsers (Chrome < 71,
+  // Firefox < 65, Safari < 12.1) and the build does not polyfill it.
+  const connection = typeof navigator !== 'undefined' ? navigator.connection : undefined;
+  switch (connection === null || connection === void 0 ? void 0 : connection.effectiveType) {
+    case 'slow-2g':
+    case '2g':
+      return minTargetBitrateKbps;
+    case '3g':
+      return effectiveType3gStartBitrateKbps;
+    default:
+      return maxStartBitrateKbps;
+  }
+}
+/**
+ * Cap on the start bitrate hint, in kbps, from how long the connection took to set up.
+ *
+ * Connection setup time (signaling join plus ICE/DTLS) is the network signal every platform has
+ * before the first video offer, since libwebrtc cannot probe the path until a video sender
+ * exists. It grows with round-trip time and loss, which also mark the links where a 1 Mbps
+ * seed overshoots, so the cap ramps linearly from `maxStartBitrateKbps` at
+ * `setupTimeForMaxStartBitrateMs` down to `minTargetBitrateKbps` at
+ * `setupTimeForMinStartBitrateMs`. A video offer built while the connection is still being set
+ * up (publishing during connect) passes the time elapsed so far, a lower bound on the setup time.
+ * Without any timing the cap stays at the 1 Mbps ceiling.
+ */
+function computeStartBitrateCap(connectionSetupTimeMs) {
+  if (connectionSetupTimeMs === undefined) {
+    return maxStartBitrateKbps;
+  }
+  const ramp = Math.min(Math.max((connectionSetupTimeMs - setupTimeForMaxStartBitrateMs) / (setupTimeForMinStartBitrateMs - setupTimeForMaxStartBitrateMs), 0), 1);
+  return Math.round(maxStartBitrateKbps - ramp * (maxStartBitrateKbps - minTargetBitrateKbps));
 }
 /**
  * The single start bitrate for this peer connection: the largest hint among the video
@@ -20576,7 +20857,7 @@ function computeTrackStartBitrate(trackbr) {
  *
  * @internal
  */
-function computeConnectionStartBitrate(media, trackBitrates) {
+function computeConnectionStartBitrate(media, trackBitrates, connectionSetupTimeMs) {
   let connectionStartBitrate;
   for (const m of media) {
     if (m.type !== 'video' || m.direction === 'recvonly' || m.direction === 'inactive') {
@@ -20590,7 +20871,7 @@ function computeConnectionStartBitrate(media, trackBitrates) {
       if (codecPayload === undefined) {
         continue;
       }
-      const startBitrate = codecPayload > 0 ? computeTrackStartBitrate(trackbr) : undefined;
+      const startBitrate = codecPayload > 0 ? computeTrackStartBitrate(trackbr, connectionSetupTimeMs) : undefined;
       if (startBitrate !== undefined && (connectionStartBitrate === undefined || startBitrate > connectionStartBitrate)) {
         connectionStartBitrate = startBitrate;
       }
@@ -20989,7 +21270,7 @@ class PCTransport extends eventsExports.EventEmitter {
         // local video: the hint is connection-level in libwebrtc, so differing per-section
         // values would be last-writer-wins on m-section order. Offers before any video is
         // published (data channel or audio only) find no target and leave the latch unset.
-        const connectionStartBitrate = this.hasAppliedVideoStartBitrate ? undefined : computeConnectionStartBitrate(sdpParsed.media, this.trackBitrates);
+        const connectionStartBitrate = this.hasAppliedVideoStartBitrate ? undefined : computeConnectionStartBitrate(sdpParsed.media, this.trackBitrates, this.connectionSetupTimeEstimateMs());
         let appliedVideoStartBitrate = false;
         sdpParsed.media.forEach(media => {
           ensureIPAddrMatchVersion(media);
@@ -21038,6 +21319,10 @@ class PCTransport extends eventsExports.EventEmitter {
         // one-shot hint once the SDP carrying it has been accepted locally.
         if (appliedVideoStartBitrate && offer.sdp === mungedSdp) {
           this.hasAppliedVideoStartBitrate = true;
+          this.log.info('applied x-google-start-bitrate', {
+            startBitrateKbps: connectionStartBitrate,
+            connectionSetupTimeMs: this.connectionSetupTimeEstimateMs()
+          });
         }
         this.onOffer(offer, this.latestOfferId);
       } finally {
@@ -21089,6 +21374,27 @@ class PCTransport extends eventsExports.EventEmitter {
   setTrackCodecBitrate(info) {
     this.trackBitrates.push(info);
   }
+  /**
+   * Record how long this peer connection took to set up. Called once, when the initial connect
+   * succeeds; resumes and ICE restarts keep the estimator they have and never call this.
+   */
+  setConnectionSetupTime(ms) {
+    this.connectionSetupTimeMs = ms;
+  }
+  /** Record when the connection attempt that built this peer connection began. */
+  setConnectionStartedAt(startedAt) {
+    this.connectionStartedAt = startedAt;
+  }
+  /** The measured setup time, or while still connecting, the time elapsed so far. */
+  connectionSetupTimeEstimateMs() {
+    if (this.connectionSetupTimeMs !== undefined) {
+      return this.connectionSetupTimeMs;
+    }
+    if (this.connectionStartedAt === undefined) {
+      return undefined;
+    }
+    return Math.round(performance.now() - this.connectionStartedAt);
+  }
   setConfiguration(rtcConfig) {
     var _a;
     if (!this._pc) {
@@ -21905,7 +22211,8 @@ class PCTransportManager {
  * Waiters are parked on the channel object captured at wait entry. If that object stops being
  * current — replaced or torn down — its events may never fire again, so the owner must call
  * {@link invalidateWaiters}, which aborts parked waiters (releasing the gate); the next waiter
- * gets a fresh controller.
+ * gets a fresh controller. {@link attach} and {@link detach} do this, and close the released
+ * handle, as part of handle turnover.
  */
 class FlowControlledDataChannel {
   constructor(opts) {
@@ -21925,25 +22232,38 @@ class FlowControlledDataChannel {
     return this.handle;
   }
   /**
-   * Attaches the channel handle this wrapper controls. Replacing an existing handle rejects
-   * parked waiters — their events would never fire again on the abandoned object — and installs a
-   * fresh controller, so queued senders re-check against the new channel. Wrappers outlive their
-   * handles: this is the one place handle turnover happens, which is what makes stranding a
-   * waiter structurally impossible.
+   * Attaches the channel handle this wrapper controls. Replacing an existing handle closes it and
+   * rejects parked waiters — their events would never fire again on the abandoned object — and
+   * installs a fresh controller. Wrappers outlive their handles: this is the one place handle
+   * turnover happens, so a handle the wrapper lets go of is never left open, and stranding a
+   * waiter is structurally impossible.
    */
   attach(dc) {
-    if (this.handle && this.handle !== dc) {
-      this.invalidateWaiters('data channel replaced');
-    }
+    const old = this.handle;
     this.handle = dc;
+    if (old && old !== dc) {
+      this.release(old, 'data channel replaced');
+    }
   }
-  /** Detaches the handle on teardown, rejecting parked waiters. */
+  /** Detaches and closes the handle on teardown, rejecting parked waiters. */
   detach() {
     let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data channel torn down';
-    if (this.handle) {
-      this.invalidateWaiters(reason);
-    }
+    const old = this.handle;
     this.handle = undefined;
+    if (old) {
+      this.release(old, reason);
+    }
+  }
+  /**
+   * Closes a handle the wrapper no longer controls. `close()` moves it to `closing` synchronously,
+   * so senders still holding it (queued on the headroom lock) fail the open check once they get
+   * the lock. Parked waiters are aborted directly instead of relying on the `close` event, which
+   * fires asynchronously, if at all (the spec lets `pc.close()` skip it). Strip any handlers that
+   * must not observe the close before calling this.
+   */
+  release(dc, reason) {
+    this.invalidateWaiters(reason);
+    dc.close();
   }
   getChannel() {
     return this.handle;
@@ -21974,32 +22294,35 @@ class FlowControlledDataChannel {
     return this.headroomLock.lock();
   }
   /**
-   * Resolves once the caller may send on this channel: immediately while the send buffer is at or
-   * below its high-water mark, otherwise once the buffer has drained to the low-water mark (the
+   * Resolves once the caller may send on `dc`: immediately while its send buffer is at or below
+   * the high-water mark, otherwise once the buffer has drained to the low-water mark (the
    * `bufferedamountlow` event). Callers are serialized through the headroom lock so that, when
    * the buffer drains, they refill it one at a time (up to the high-water mark) rather than all
    * sending at once and overflowing the SCTP send buffer (see livekit/client-sdk-js#1995). The
-   * closed/buffer checks run inside the lock so queued callers proceed in FIFO order.
+   * checks run inside the lock so queued callers proceed in FIFO order.
+   *
+   * The caller passes the handle it resolved before queueing, and the wait is against that one
+   * handle throughout: if it was replaced meanwhile, it has been closed, so the wait rejects
+   * rather than letting the caller send on the replacement out of turn.
    */
-  waitForHeadroomWithLock() {
+  waitForHeadroomWithLock(dc) {
     return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.lockHeadroom();
       try {
-        yield this.waitForHeadroomWithoutLock();
+        yield this.waitForHeadroomWithoutLock(dc);
       } finally {
         unlock();
       }
     });
   }
   /** Core wait of {@link waitForHeadroomWithLock}. The caller must hold the headroom lock. */
-  waitForHeadroomWithoutLock() {
+  waitForHeadroomWithoutLock(dc) {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.isEngineClosed()) {
         throw new UnexpectedConnectionState('engine closed');
       }
-      const dc = this.getChannel();
-      if (!dc) {
-        throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(this.kind));
+      if (dc.readyState !== 'open') {
+        throw new UnexpectedConnectionState("DataChannel ".concat(this.kind, " is ").concat(dc.readyState));
       }
       if (this.isBelowHighWaterMark(dc)) {
         return;
@@ -22089,7 +22412,16 @@ class LossyDataChannel extends FlowControlledDataChannel {
       switch (this.bufferFullBehavior) {
         case 'wait':
           if (!this.isBelowHighWaterMark(dc)) {
-            yield this.waitForHeadroomWithLock();
+            try {
+              yield this.waitForHeadroomWithLock(dc);
+            } catch (error) {
+              if (this.isEngineClosed()) {
+                throw error;
+              }
+              // The channel closed or was replaced while this send waited. The replacement may
+              // still be connecting, so drop the packet, as sends during a reconnect are.
+              return;
+            }
           }
           break;
         case 'drop':
@@ -22271,7 +22603,7 @@ class ReliableDataChannel extends FlowControlledDataChannel {
         return;
       }
       try {
-        yield this.waitForHeadroomWithLock();
+        yield this.waitForHeadroomWithLock(dc);
       } catch (error) {
         if (this.isEngineClosed()) {
           // No replay is coming after an engine close — surface the failure.
@@ -22279,7 +22611,9 @@ class ReliableDataChannel extends FlowControlledDataChannel {
         }
         // Transient teardown (the channel closed or was replaced while we waited): the reliable
         // channel promises delivery across resume, so queue the packet for the replay instead of
-        // rejecting a send the app can't meaningfully retry.
+        // rejecting a send the app can't meaningfully retry. This also keeps the order: a send
+        // queued behind one aborted by a replacement fails the same way (the old handle is closed),
+        // so it can't reach the replacement ahead of the lower sequence the replay will deliver.
         this.messageBuffer.push({
           data: msg,
           sequence,
@@ -22314,13 +22648,18 @@ class ReliableDataChannel extends FlowControlledDataChannel {
    */
   replay(lastMessageSeq) {
     return __awaiter(this, void 0, void 0, function* () {
-      const dc = this.getChannel();
-      if (!dc) {
+      if (!this.getChannel()) {
         return;
       }
       this.messageBuffer.popToSequence(lastMessageSeq);
       const unlock = yield this.lockHeadroom();
       try {
+        // Resolved only once the lock is held: the handle can be replaced while the replay waits
+        // for it.
+        const dc = this.getChannel();
+        if (!dc) {
+          throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(this.kind));
+        }
         // Everything left after the ack cutoff must be re-handed to the current channel.
         this.messageBuffer.markAllUnsent();
         // Drain in passes, re-scanning the live buffer each time: a send that arrives (deferred,
@@ -22332,7 +22671,10 @@ class ReliableDataChannel extends FlowControlledDataChannel {
         for (let batch = this.messageBuffer.getUnsent(); batch.length > 0; batch = this.messageBuffer.getUnsent()) {
           for (const item of batch) {
             // Respect flow control on resume too, so a large resend doesn't overflow the buffer.
-            yield this.waitForHeadroomWithoutLock();
+            // Against the handle resolved under the lock: if it is replaced mid-replay (another
+            // resume), it has been closed, so this throws and that resume's replay picks up the
+            // entries still flagged unsent.
+            yield this.waitForHeadroomWithoutLock(dc);
             dc.send(item.data);
             this.messageBuffer.markSent(item);
           }
@@ -22387,13 +22729,23 @@ function dataChannelHighWaterMark(kind) {
 }const lossyDataChannelLabel = '_lossy';
 const reliableDataChannelLabel = '_reliable';
 const dataTrackDataChannelLabel = '_data_track';
+/** Unhooks every handler the manager may have wired onto `dc`, ahead of closing it. */
+function clearHandlers(dc) {
+  dc.onbufferedamountlow = null;
+  dc.onclose = null;
+  dc.onclosing = null;
+  dc.onerror = null;
+  dc.onmessage = null;
+  dc.onopen = null;
+}
 /**
  * Owns the engine's data channels: the three flow-controlled publisher channel wrappers (which
  * live for the engine's lifetime and have RTCDataChannel handles attached/detached as peer
  * connections come and go) plus the subscriber-side receive handles adopted by label.
  *
- * Handle turnover goes through {@link FlowControlledDataChannel.attach}/`detach`, which reject
- * parked headroom waiters as a built-in — there is no separate invalidation step to forget.
+ * Handle turnover goes through {@link FlowControlledDataChannel.attach}/`detach`, which close the
+ * released handle and reject parked headroom waiters as a built-in — there is no separate
+ * invalidation step to forget.
  */
 class DataChannelManager {
   constructor(opts) {
@@ -22451,17 +22803,16 @@ class DataChannelManager {
   }
   /**
    * Creates the three publisher data channels on the given transport, wires their handlers, and
-   * attaches them to the wrappers — attaching rejects any waiters still parked on replaced
-   * channel objects.
+   * attaches them to the wrappers — attaching closes any replaced channel objects and rejects the
+   * waiters still parked on them.
    */
   createPublisherChannels(pcManager) {
-    // clear old data channel callbacks if recreate
+    // Recreating (the Safari null-id path): attaching the new handles below closes the old ones,
+    // so unhook them first — the old channel's close must not report an unexpected close.
     for (const channel of [this.lossy, this.reliable, this.dataTrack]) {
       const old = channel.channelHandle;
       if (old) {
-        old.onmessage = null;
-        old.onerror = null;
-        old.onclose = null;
+        clearHandlers(old);
       }
     }
     const wire = (channel, dc, onMessage) => {
@@ -22512,38 +22863,35 @@ class DataChannelManager {
     return true;
   }
   /**
-   * Tears down all channels for a peer-connection cleanup: rejects parked waiters (detach — the
-   * spec allows `pc.close()` to transition channels to 'closed' without firing events, so waiting
-   * for browser close events is not an option), strips handlers, closes the handles, and resets
-   * the reliable session state.
+   * Tears down all channels for a peer-connection cleanup: strips handlers, closes the handles,
+   * and resets the reliable session state. Detaching the publisher handles closes them and
+   * rejects parked waiters (the spec allows `pc.close()` to transition channels to 'closed'
+   * without firing events, so waiting for browser close events is not an option).
    */
   teardown() {
-    const dcCleanup = dc => {
-      if (!dc) {
-        return;
-      }
-      // Detach the data channel handlers before closing anything. Closing a peer connection tears
-      // down the SCTP transport, which can dispatch `error`/`close` events on the still-open data
-      // channels; if our handlers are still attached at that point, handleDataError logs a spurious
-      // "Unknown DataChannel error" during an otherwise graceful disconnect. Removing the handlers
-      // before dc.close()/pcManager.close() makes this deterministic regardless of how/when the
-      // browser dispatches those teardown events. See livekit/client-sdk-js#1953.
-      dc.onbufferedamountlow = null;
-      dc.onclose = null;
-      dc.onclosing = null;
-      dc.onerror = null;
-      dc.onmessage = null;
-      dc.onopen = null;
-      dc.close();
-    };
-    for (const channel of [this.lossy, this.reliable, this.dataTrack]) {
+    // Detach the data channel handlers before closing anything. Closing a peer connection tears
+    // down the SCTP transport, which can dispatch `error`/`close` events on the still-open data
+    // channels; if our handlers are still attached at that point, handleDataError logs a spurious
+    // "Unknown DataChannel error" during an otherwise graceful disconnect. Removing the handlers
+    // before dc.close()/pcManager.close() makes this deterministic regardless of how/when the
+    // browser dispatches those teardown events. See livekit/client-sdk-js#1953.
+    const publisherDataChannels = [this.lossy, this.reliable, this.dataTrack];
+    const subscriberDataChannels = [this.lossySub, this.reliableSub, this.dataTrackSub];
+    // Publisher handles are closed by detach, which also rejects parked waiters.
+    for (const channel of publisherDataChannels) {
       const dc = channel.channelHandle;
+      if (dc) {
+        clearHandlers(dc);
+      }
       channel.detach('peer connections cleaned up');
-      dcCleanup(dc);
     }
-    dcCleanup(this.lossySub);
-    dcCleanup(this.reliableSub);
-    dcCleanup(this.dataTrackSub);
+    // Subscriber handles have no wrapper, so close them directly.
+    for (const dc of subscriberDataChannels) {
+      if (dc) {
+        clearHandlers(dc);
+        dc.close();
+      }
+    }
     this.lossySub = undefined;
     this.reliableSub = undefined;
     this.dataTrackSub = undefined;
@@ -22705,6 +23053,9 @@ class LocalTrack extends Track {
   get isUserProvided() {
     return this.providedByUser;
   }
+  get isStopped() {
+    return this.manuallyStopped;
+  }
   get mediaStreamTrack() {
     var _a, _b;
     return (_b = (_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack) !== null && _b !== void 0 ? _b : this._mediaStreamTrack;
@@ -22762,6 +23113,9 @@ class LocalTrack extends Track {
           track: newTrack,
           kind: this.kind,
           element: this.processorElement,
+          // audio processors need the context they were initialised with in order to rebuild
+          // their graph, omitting it here would leave them without one
+          audioContext: this.audioContext,
           localTrack: this
         });
         processedTrack = this.processor.processedTrack;
@@ -22785,6 +23139,18 @@ class LocalTrack extends Track {
           attachToElement(processedTrack !== null && processedTrack !== void 0 ? processedTrack : newTrack, el);
         });
       }
+      yield this.onMediaStreamTrackChanged();
+    });
+  }
+  /**
+   * Hook invoked after the underlying MediaStreamTrack has been swapped and the processor has
+   * been restarted around it, so `processor.processedTrack` already holds the new track.
+   * Unlike `onSenderTrackSwapped` this also fires on the restart and unmute paths.
+   */
+  onMediaStreamTrackChanged() {
+    return __awaiter(this, void 0, void 0, function* () {
+      // base implementation is a no-op; LocalAudioTrack overrides this to move the krisp
+      // feature listeners onto the new processed track.
     });
   }
   waitForDimensions() {
@@ -22823,7 +23189,7 @@ class LocalTrack extends Track {
   }
   setDeviceId(deviceId) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
+      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId) && this._mediaStreamTrack.readyState === 'live') {
         return true;
       }
       this._constraints.deviceId = deviceId;
@@ -22951,24 +23317,40 @@ class LocalTrack extends Track {
         // 'A MediaStreamTrack ended due to a capture failure`
         this._mediaStreamTrack.stop();
         // create new track and attach
-        const mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
+        let mediaStream;
+        try {
+          mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
+        } catch (e) {
+          markDeviceAcquisitionFailure(e);
+          throw e;
+        }
         const newTrack = mediaStream.getTracks()[0];
-        if (this.kind === Track.Kind.Video) {
-          // we already captured the audio track with the constraints, so we only need to apply the video constraints
-          yield newTrack.applyConstraints(otherConstraints);
+        try {
+          if (this.kind === Track.Kind.Video) {
+            // we already captured the audio track with the constraints, so we only need to apply the video constraints
+            yield newTrack.applyConstraints(otherConstraints);
+          }
+          newTrack.addEventListener('ended', this.handleEnded);
+          this.log.debug('re-acquired MediaStreamTrack', this.logContext);
+          yield this.setMediaStreamTrack(newTrack, false, isUnmuting);
+        } catch (e) {
+          // setMediaStreamTrack can throw after acquisition but before it adopts the new track,
+          // which would leave the capture device live with nothing referencing it
+          if (this._mediaStreamTrack !== newTrack) {
+            newTrack.stop();
+          }
+          throw e;
         }
-        newTrack.addEventListener('ended', this.handleEnded);
-        this.log.debug('re-acquired MediaStreamTrack', this.logContext);
-        yield this.setMediaStreamTrack(newTrack, false, isUnmuting);
         this._constraints = constraints;
         this.pendingDeviceChange = false;
         this.emit(TrackEvent.Restarted, this);
+        return this;
+      } finally {
+        // in the finally because a throw can also leave the new track adopted, and so still live
         if (this.manuallyStopped) {
           this.log.warn('track was stopped during a restart, stopping restarted track', this.logContext);
           this.stop();
         }
-        return this;
-      } finally {
         unlock();
       }
     });
@@ -23009,7 +23391,13 @@ class LocalTrack extends Track {
     this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
     this._mediaStreamTrack.removeEventListener('mute', this.handleTrackMuteEvent);
     this._mediaStreamTrack.removeEventListener('unmute', this.handleTrackUnmuteEvent);
-    (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy();
+    // `stop` is synchronous, so we can't await the teardown of the processor here.
+    // make sure a failing teardown doesn't surface as an unhandled rejection.
+    (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy().catch(error => {
+      this.log.error('failed to destroy processor', Object.assign(Object.assign({}, this.logContext), {
+        error
+      }));
+    });
     this.processor = undefined;
   }
   /**
@@ -23088,6 +23476,11 @@ class LocalTrack extends Track {
    * Sets a processor on this track.
    * See https://github.com/livekit/track-processors-js for example usage
    *
+   * The processor lives on the track, so stopping the track destroys it. Unpublishing and
+   * disconnecting both stop the track by default, which means a processor has to be set again on
+   * the track published after a reconnect. See {@link TrackProcessor} for the full lifecycle,
+   * including what `stopLocalTrackOnUnpublish: false` changes.
+   *
    * @param processor
    * @param showProcessedStreamLocally
    * @returns
@@ -23157,6 +23550,10 @@ class LocalTrack extends Track {
       }();
     });
   }
+  /**
+   * Returns the processor currently set on this track, or `undefined` if there is none. A track
+   * that was stopped by an unpublish or a disconnect has none. See {@link TrackProcessor}.
+   */
   getProcessor() {
     return this.processor;
   }
@@ -23164,6 +23561,8 @@ class LocalTrack extends Track {
    * Stops the track processor
    * See https://github.com/livekit/track-processors-js for example usage
    *
+   * Only needed to remove a processor from a track that stays published. Unpublishing or
+   * disconnecting already destroys it. See {@link TrackProcessor}.
    */
   stopProcessor() {
     return __awaiter(this, arguments, void 0, function () {
@@ -23404,6 +23803,38 @@ class LocalTrack extends Track {
       this.monitorSender();
     }, monitorFrequency);
   }
+  /**
+   * registers the krisp feature listeners on the given processed track, moving them over from
+   * a previously observed one. Passing `undefined` just removes the existing listeners.
+   */
+  observeProcessedTrack(processedTrack) {
+    if (this.observedProcessedTrack === processedTrack) {
+      return;
+    }
+    if (this.observedProcessedTrack) {
+      this.observedProcessedTrack.removeEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
+      this.observedProcessedTrack.removeEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+      this.observedProcessedTrack = undefined;
+      if (this.isKrispNoiseFilterEnabled) {
+        // we're no longer observing the track that had the filter enabled, so the feature
+        // can't be active anymore. Make sure the state doesn't get stuck on `true`.
+        this.handleKrispNoiseFilterDisable();
+      }
+    }
+    if (!processedTrack) {
+      return;
+    }
+    processedTrack.addEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
+    processedTrack.addEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+    this.observedProcessedTrack = processedTrack;
+  }
+  /**
+   * Sets a processor on this track.
+   *
+   * The processor is destroyed when the track is stopped, and also when the audio context goes
+   * away, so a disconnect ends it on both counts and it has to be set again after reconnecting.
+   * See {@link TrackProcessor} for the full lifecycle.
+   */
   setProcessor(processor) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
@@ -23427,8 +23858,7 @@ class LocalTrack extends Track {
         this.processor = processor;
         if (this.processor.processedTrack) {
           yield (_a = this.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(this.processor.processedTrack);
-          this.processor.processedTrack.addEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
-          this.processor.processedTrack.addEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+          this.observeProcessedTrack(this.processor.processedTrack);
         }
         this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
       } finally {
@@ -23436,12 +23866,73 @@ class LocalTrack extends Track {
       }
     });
   }
+  onMediaStreamTrackChanged() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      // the processor rebuilds its graph around the new track, so the krisp listeners have to
+      // follow it onto whatever it hands back
+      this.observeProcessedTrack((_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack);
+    });
+  }
+  internalStopProcessor() {
+    const _super = Object.create(null, {
+      internalStopProcessor: {
+        get: () => super.internalStopProcessor
+      }
+    });
+    return __awaiter(this, arguments, void 0, function () {
+      var _this = this;
+      let keepElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return function* () {
+        _this.observeProcessedTrack(undefined);
+        yield _super.internalStopProcessor.call(_this, keepElement);
+      }();
+    });
+  }
+  stop() {
+    this.observeProcessedTrack(undefined);
+    super.stop();
+  }
   /**
    * @internal
    * @experimental
+   *
+   * A processor's nodes (`AudioWorkletNode`, ...) can't move between contexts, so the processor
+   * is rebuilt whenever the context changes and torn down when there is none left to run in.
    */
   setAudioContext(audioContext) {
-    this.audioContext = audioContext;
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      if (this.audioContext === audioContext) {
+        return;
+      }
+      const unlock = yield this.trackChangeLock.lock();
+      try {
+        this.audioContext = audioContext;
+        if (!this.processor || isReactNative()) {
+          return;
+        }
+        if (!audioContext) {
+          this.log.debug('stopping audio processor, audio context has been removed', this.logContext);
+          yield this.internalStopProcessor();
+          return;
+        }
+        this.log.debug('restarting audio processor on new audio context', this.logContext);
+        yield this.processor.restart({
+          kind: this.kind,
+          track: this._mediaStreamTrack,
+          audioContext,
+          localTrack: this
+        });
+        if (this.processor.processedTrack) {
+          yield (_a = this.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(this.processor.processedTrack);
+          this.observeProcessedTrack(this.processor.processedTrack);
+        }
+        this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
+      } finally {
+        unlock();
+      }
+    });
   }
   getSenderStats() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -24271,7 +24762,14 @@ class LocalVideoTrack extends LocalTrack {
       yield sender.setParameters(params);
     });
   }
-  setProcessor(processor_1) {
+  /**
+   * Sets a processor on this track, and wires its processed track into the simulcast codecs.
+   *
+   * The processor is destroyed when the track is stopped, which unpublishing and disconnecting
+   * both do by default, so it has to be set again after reconnecting. See {@link TrackProcessor}
+   * for the full lifecycle.
+   */
+  setProcessor(processor_1) {
     const _super = Object.create(null, {
       setProcessor: {
         get: () => super.setProcessor
@@ -24872,7 +25370,17 @@ class RTCEngine extends eventsExports.EventEmitter {
         return;
       }
       if (connection === leaveReconnect) {
-        delay = 0;
+        // The server asked for a reconnect, so skip any remaining backoff. Use the policy's first
+        // retry delay instead of 0 so that clients told to reconnect together don't all reconnect
+        // at the same instant.
+        delay = this.getNextRetryDelay({
+          elapsedMs: duration,
+          retryCount: 0
+        });
+        if (delay === null) {
+          disconnect(duration);
+          return;
+        }
       }
       this.log.debug("reconnecting in ".concat(delay, "ms"));
       this.clearReconnectTimeout();
@@ -25005,7 +25513,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       var _this2 = this;
       let useV0Path = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
       return function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         _this2._isNewlyCreated = false;
         _this2.url = url;
         _this2.token = token;
@@ -25013,6 +25521,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         _this2.maxJoinAttempts = opts.maxRetries;
         try {
           _this2.joinAttempts += 1;
+          _this2.joinStartedAt = performance.now();
           _this2.setupSignalClientCallbacks();
           // Whether the initial publisher offer is bundled with the join request. Computed once and
           // reused after the join below. Only the (non-Firefox) offer-with-join path does this.
@@ -25042,6 +25551,10 @@ class RTCEngine extends eventsExports.EventEmitter {
             throw ConnectionError.serviceNotFound('Simulated v1 path failure', 'v0-rtc');
           }
           const joinResponse = yield _this2.client.join(url, token, opts, abortSignal, useV0Path, offerProto);
+          if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            _this2.log.info('join cancelled after the signal join response');
+            throw ConnectionError.cancelled('Connection aborted');
+          }
           _this2._isClosed = false;
           _this2.latestJoinResponse = joinResponse;
           _this2.participantSid = (_b = joinResponse.participant) === null || _b === void 0 ? void 0 : _b.sid;
@@ -25054,6 +25567,10 @@ class RTCEngine extends eventsExports.EventEmitter {
               // the server's ICE servers and topology, then negotiate separately rather than bundling
               // the offer with the join.
               yield _this2.configure(joinResponse, !useV0Path);
+              if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                _this2.log.info('join cancelled after configuring peer connections');
+                throw ConnectionError.cancelled('Connection aborted');
+              }
               if (!useV0Path) {
                 // The V1 first offer must carry the media layout so Firefox binds receive decoders for
                 // subscribed tracks — without it, subscribed audio/video arrive as RTP but
@@ -25068,6 +25585,11 @@ class RTCEngine extends eventsExports.EventEmitter {
               });
             }
           }
+          if (_this2.joinStartedAt !== undefined) {
+            // Lets a video published before the transports connect be seeded from the time elapsed
+            // so far, rather than delaying its offer until the setup time is measured.
+            (_d = _this2.pcManager) === null || _d === void 0 ? void 0 : _d.publisher.setConnectionStartedAt(_this2.joinStartedAt);
+          }
           _this2.registerOnLineListener();
           _this2.clientConfiguration = joinResponse.clientConfiguration;
           _this2.emit(EngineEvent.SignalConnected, joinResponse);
@@ -25116,6 +25638,9 @@ class RTCEngine extends eventsExports.EventEmitter {
    */
   close(reason) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      (_a = this.reconnectAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+      this.reconnectAbortController = undefined;
       const unlock = yield this.closingLock.lock();
       if (this.isClosed) {
         unlock();
@@ -25124,6 +25649,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       try {
         this._isClosed = true;
         this.joinAttempts = 0;
+        this.joinStartedAt = undefined;
         this.emit(EngineEvent.Closing);
         this.removeAllListeners();
         this.deregisterOnLineListener();
@@ -25252,6 +25778,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       };
       this.pcManager.onDataChannel = this.handleDataChannel;
       this.pcManager.onStateChange = (connectionState, publisherState, subscriberState) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         this.log.debug("primary PC state changed ".concat(connectionState));
         // Record when the primary transport actually entered CONNECTING so
         // verifyTransport() can bound how long we tolerate it. Deriving it from the
@@ -25267,6 +25794,16 @@ class RTCEngine extends eventsExports.EventEmitter {
           this.publisherConnectionPromise = undefined;
         }
         if (connectionState === PCTransportState.CONNECTED) {
+          if (this.joinStartedAt !== undefined) {
+            // Connection setup time is the only network signal there is before the first video
+            // offer. Set synchronously, so it is in place before `room.connect()` resolves and the
+            // app can publish. A full restart joins again and builds new transports, so it is
+            // measured again; a resume keeps its estimator and never restarts the timer.
+            const setupTimeMs = Math.round(performance.now() - this.joinStartedAt);
+            this.joinStartedAt = undefined;
+            this.log.info("connection setup took ".concat(setupTimeMs, " ms"));
+            (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.publisher.setConnectionSetupTime(setupTimeMs);
+          }
           const shouldEmit = this.pcState === PCState.New;
           this.pcState = PCState.Connected;
           if (shouldEmit) {
@@ -25501,6 +26038,12 @@ class RTCEngine extends eventsExports.EventEmitter {
     if (!this.pcManager) {
       return;
     }
+    if (this.dataChannels.hasPublisherChannels) {
+      // Replacing live channels (the Safari null-id path in resumeConnection): the new ones start
+      // out connecting, so drop the memoized readiness check and make the next sender wait for
+      // them to open.
+      this.publisherConnectionPromise = undefined;
+    }
     this.dataChannels.createPublisherChannels(this.pcManager);
   }
   /** Normalizes an incoming data-channel message into bytes, or logs and returns undefined. */
@@ -25733,16 +26276,28 @@ class RTCEngine extends eventsExports.EventEmitter {
       const fullReconnect = this.fullReconnectOnNext;
       this.fullReconnectOnNext = false;
       let succeeded = false;
+      const abortController = new AbortController();
+      this.reconnectAbortController = abortController;
       try {
         this.attemptingReconnect = true;
         if (fullReconnect) {
-          yield this.restartConnection();
+          yield this.restartConnection(abortController.signal);
         } else {
           yield this.resumeConnection(reason);
         }
+        if (abortController.signal.aborted) {
+          this.log.info('reconnect attempt cancelled, not marking it as succeeded');
+          return;
+        }
         this.clearPendingReconnect();
         succeeded = true;
       } catch (e) {
+        if (abortController.signal.aborted) {
+          this.log.info('reconnect attempt cancelled, not retrying', {
+            error: e
+          });
+          return;
+        }
         this.reconnectAttempts += 1;
         let recoverable = true;
         if (e instanceof UnexpectedConnectionState) {
@@ -25764,6 +26319,10 @@ class RTCEngine extends eventsExports.EventEmitter {
           yield this.close("gave up reconnecting after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms"));
         }
       } finally {
+        // close() may already have cleared this (or a later attempt replaced it); only release our own
+        if (this.reconnectAbortController === abortController) {
+          this.reconnectAbortController = undefined;
+        }
         this.attemptingReconnect = false;
         // A full reconnect requested while this attempt was running (e.g. a `RECONNECT` leave
         // during a resume or a restart) that a successful attempt didn't act on; dispatch it now
@@ -25786,10 +26345,16 @@ class RTCEngine extends eventsExports.EventEmitter {
     // error in user code with provided reconnect policy, stop reconnecting
     return null;
   }
-  restartConnection(regionUrl) {
+  restartConnection(abortSignal, regionUrl) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b, _c;
       try {
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled before starting', {
+            regionUrl
+          });
+          return;
+        }
         if (!this.url || !this.token) {
           // permanent failure, don't attempt reconnection
           throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -25801,6 +26366,12 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
         yield this.cleanupPeerConnections();
         yield this.cleanupClient();
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after cleaning up the previous session', {
+            regionUrl
+          });
+          return;
+        }
         let joinResponse;
         try {
           if (!this.signalOpts) {
@@ -25808,13 +26379,19 @@ class RTCEngine extends eventsExports.EventEmitter {
             throw new SignalReconnectError();
           }
           // in case a regionUrl is passed, the region URL takes precedence
-          joinResponse = (yield this.join(regionUrl !== null && regionUrl !== void 0 ? regionUrl : this.url, this.token, this.signalOpts, undefined, !this.options.singlePeerConnection)).joinResponse;
+          joinResponse = (yield this.join(regionUrl !== null && regionUrl !== void 0 ? regionUrl : this.url, this.token, this.signalOpts, abortSignal, !this.options.singlePeerConnection)).joinResponse;
         } catch (e) {
           if (e instanceof ConnectionError && e.reason === ConnectionErrorReason.NotAllowed) {
             throw new UnexpectedConnectionState('could not reconnect, token might be expired');
           }
           throw new SignalReconnectError();
         }
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after the signal join response', {
+            regionUrl
+          });
+          return;
+        }
         if (this.shouldFailNext) {
           this.shouldFailNext = false;
           throw new Error('simulated failure');
@@ -25822,6 +26399,12 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.client.setReconnected();
         this.emit(EngineEvent.SignalRestarted, joinResponse);
         yield this.waitForPCReconnected();
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after peer connections reconnected', {
+            regionUrl
+          });
+          return;
+        }
         // re-check signal connection state before setting engine as resumed
         if (this.client.currentState !== SignalConnectionState.CONNECTED) {
           throw new SignalReconnectError('Signal connection got severed during reconnect');
@@ -25830,9 +26413,21 @@ class RTCEngine extends eventsExports.EventEmitter {
         // reconnect success
         this.emit(EngineEvent.Restarted);
       } catch (error) {
-        const nextRegionUrl = yield (_b = this.regionStrategy) === null || _b === void 0 ? void 0 : _b.getNextUrl();
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled after a failed attempt', {
+            regionUrl
+          });
+          return;
+        }
+        const nextRegionUrl = yield (_b = this.regionStrategy) === null || _b === void 0 ? void 0 : _b.getNextUrl(abortSignal);
+        if (abortSignal.aborted) {
+          this.log.info('full reconnect cancelled during region selection', {
+            regionUrl
+          });
+          return;
+        }
         if (nextRegionUrl) {
-          yield this.restartConnection(nextRegionUrl);
+          yield this.restartConnection(abortSignal, nextRegionUrl);
           return;
         } else {
           // no more regions to try (or we're not on cloud)
@@ -26027,7 +26622,11 @@ class RTCEngine extends eventsExports.EventEmitter {
    */
   waitForBufferHeadroom(kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      return this.flowControlFor(kind).waitForHeadroomWithLock();
+      const dc = this.dataChannelForKind(kind);
+      if (!dc) {
+        throw new UnexpectedConnectionState("DataChannel not found, kind: ".concat(kind));
+      }
+      return this.flowControlFor(kind).waitForHeadroomWithLock(dc);
     });
   }
   /**
@@ -26887,6 +27486,16 @@ class TextStreamReader extends BaseStreamReader {
     this.byteStreamHandlers.delete(topic);
   }
   clearControllers() {
+    // Error any in flight streams so readers do not wait forever for chunks that can no longer arrive.
+    const abnormalEndError = new DataStreamError('Room disconnected in the middle of receiving data', DataStreamErrorReason.AbnormalEnd);
+    for (const _ref2 of this.byteStreamControllers.values()) {
+      const controller = _ref2.controller;
+      controller.error(abnormalEndError);
+    }
+    for (const _ref3 of this.textStreamControllers.values()) {
+      const controller = _ref3.controller;
+      controller.error(abnormalEndError);
+    }
     this.byteStreamControllers.clear();
     this.textStreamControllers.clear();
     this.bufferedPackets = [];
@@ -26897,18 +27506,18 @@ class TextStreamReader extends BaseStreamReader {
     const byteStreamsBeingSentByDisconnectingParticipant = Array.from(this.byteStreamControllers.entries()).filter(entry => entry[1].sendingParticipantIdentity === participantIdentity);
     if (textStreamsBeingSentByDisconnectingParticipant.length > 0 || byteStreamsBeingSentByDisconnectingParticipant.length > 0) {
       const abnormalEndError = new DataStreamError("Participant ".concat(participantIdentity, " unexpectedly disconnected in the middle of sending data"), DataStreamErrorReason.AbnormalEnd);
-      for (const _ref2 of byteStreamsBeingSentByDisconnectingParticipant) {
-        var _ref3 = _slicedToArray(_ref2, 2);
-        const id = _ref3[0];
-        const controller = _ref3[1];
-        controller.controller.error(abnormalEndError);
-        this.byteStreamControllers.delete(id);
-      }
-      for (const _ref4 of textStreamsBeingSentByDisconnectingParticipant) {
+      for (const _ref4 of byteStreamsBeingSentByDisconnectingParticipant) {
         var _ref5 = _slicedToArray(_ref4, 2);
         const id = _ref5[0];
         const controller = _ref5[1];
         controller.controller.error(abnormalEndError);
+        this.byteStreamControllers.delete(id);
+      }
+      for (const _ref6 of textStreamsBeingSentByDisconnectingParticipant) {
+        var _ref7 = _slicedToArray(_ref6, 2);
+        const id = _ref7[0];
+        const controller = _ref7[1];
+        controller.controller.error(abnormalEndError);
         this.textStreamControllers.delete(id);
       }
     }
@@ -27905,58 +28514,6 @@ function sendStreamTrailer(streamId, destinationIdentities, engine) {
     });
     yield engine.sendDataPacket(trailerPacket, DataChannelKind.RELIABLE);
   });
-}/**
- * Implementation of AbortSignal.any
- * Creates a signal that will be aborted when any of the given signals is aborted.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
- */
-function abortSignalAny(signals) {
-  // Handle empty signals array
-  if (signals.length === 0) {
-    const controller = new AbortController();
-    return controller.signal;
-  }
-  // Fast path for single signal
-  if (signals.length === 1) {
-    return signals[0];
-  }
-  // Check if any signal is already aborted
-  for (const signal of signals) {
-    if (signal.aborted) {
-      return signal;
-    }
-  }
-  // Create a new controller for the combined signal
-  const controller = new AbortController();
-  const unlisteners = Array(signals.length);
-  // Function to clean up all event listeners
-  const cleanup = () => {
-    for (const unsubscribe of unlisteners) {
-      unsubscribe();
-    }
-  };
-  // Add event listeners to each signal
-  signals.forEach((signal, index) => {
-    const handler = () => {
-      controller.abort(signal.reason);
-      cleanup();
-    };
-    signal.addEventListener('abort', handler);
-    unlisteners[index] = () => signal.removeEventListener('abort', handler);
-  });
-  return controller.signal;
-}
-/**
- * Implementation of AbortSignal.timeout
- * Creates a signal that will be aborted after the specified timeout.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
- */
-function abortSignalTimeout(ms) {
-  const controller = new AbortController();
-  setTimeout(() => {
-    controller.abort(new DOMException("signal timed out after ".concat(ms, " ms"), 'TimeoutError'));
-  }, ms);
-  return controller.signal;
 }// Number type sizes
 const U8_LENGTH_BYTES = 1;
 const U16_LENGTH_BYTES = 2;
@@ -30313,6 +30870,12 @@ function truncateBytes(str, maxBytes) {
       high = mid - 1;
     }
   }
+  // Never end on the first half of a surrogate pair: it would be encoded as a replacement
+  // character, and the truncated string would no longer round trip.
+  const lastCode = low > 0 ? str.charCodeAt(low - 1) : 0;
+  if (lastCode >= 0xd800 && lastCode <= 0xdbff) {
+    low -= 1;
+  }
   return str.slice(0, low);
 }/**
  * Manages the client (caller) side of RPC: sending requests, tracking pending
@@ -30717,6 +31280,12 @@ class RpcServerManager extends eventsExports.EventEmitter {
 }class RemoteAudioTrack extends RemoteTrack {
   constructor(mediaTrack, sid, receiver, audioContext, audioOutput, loggerOptions) {
     super(mediaTrack, sid, Track.Kind.Audio, receiver, loggerOptions);
+    /**
+     * the nodes of the graph currently wired up, in order, so teardown can undo exactly the edges
+     * `connectWebAudio` created. Reading `webAudioPluginNodes` instead would miss the old plugins
+     * once `setWebAudioPlugins` has replaced them.
+     */
+    this.connectedNodes = [];
     this.monitorReceiver = () => __awaiter(this, void 0, void 0, function* () {
       if (!this.receiver) {
         this._currentBitrate = 0;
@@ -30739,10 +31308,11 @@ class RpcServerManager extends eventsExports.EventEmitter {
    */
   setVolume(volume) {
     var _a;
-    for (const el of this.attachedElements) {
-      if (this.audioContext) {
-        (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.gain.setTargetAtTime(volume, 0, 0.1);
-      } else {
+    if (this.audioContext) {
+      // playback goes through the web audio graph, the attached elements themselves stay silent
+      (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.gain.setTargetAtTime(volume, 0, 0.1);
+    } else {
+      for (const el of this.attachedElements) {
         el.volume = volume;
       }
     }
@@ -30788,7 +31358,9 @@ class RpcServerManager extends eventsExports.EventEmitter {
     });
   }
   attach(element) {
-    const needsNewWebAudioConnection = this.attachedElements.length === 0;
+    // the graph is fed by the track rather than by a specific element, so one connection covers
+    // all attached elements
+    const needsNewWebAudioConnection = !this.sourceNode;
     if (!element) {
       element = super.attach();
     } else {
@@ -30799,11 +31371,15 @@ class RpcServerManager extends eventsExports.EventEmitter {
         this.log.error('Failed to set sink id on remote audio track', e, this.logContext);
       });
     }
-    if (this.audioContext && needsNewWebAudioConnection) {
-      this.log.debug('using audio context mapping', this.logContext);
-      this.connectWebAudio(this.audioContext, element);
+    if (this.audioContext) {
+      // audio is routed through the web audio graph, so every attached element has to stay
+      // silent, no matter whether it is the one the graph was built from
       element.volume = 0;
       element.muted = true;
+      if (needsNewWebAudioConnection) {
+        this.log.debug('using audio context mapping', this.logContext);
+        this.connectWebAudio(this.audioContext, element);
+      }
     }
     if (this.elementVolume !== undefined) {
       // make sure volume setting is being applied to the newly attached element
@@ -30835,11 +31411,27 @@ class RpcServerManager extends eventsExports.EventEmitter {
    * @experimental
    */
   setAudioContext(audioContext) {
+    var _a;
+    if (this.audioContext === audioContext) {
+      return;
+    }
     this.audioContext = audioContext;
-    if (audioContext && this.attachedElements.length > 0) {
-      this.connectWebAudio(audioContext, this.attachedElements[0]);
-    } else if (!audioContext) {
+    if (audioContext) {
+      // playback moves into the web audio graph, mute the elements to avoid double playback
+      for (const element of this.attachedElements) {
+        element.volume = 0;
+        element.muted = true;
+      }
+      if (this.attachedElements.length > 0) {
+        this.connectWebAudio(audioContext, this.attachedElements[0]);
+      }
+    } else {
       this.disconnectWebAudio();
+      // playback moves back into the elements, which `attach` had muted in favour of the graph
+      for (const element of this.attachedElements) {
+        element.muted = false;
+        element.volume = (_a = this.elementVolume) !== null && _a !== void 0 ? _a : 1;
+      }
     }
   }
   /**
@@ -30858,12 +31450,15 @@ class RpcServerManager extends eventsExports.EventEmitter {
     // @ts-ignore attached elements always have a srcObject set
     this.sourceNode = context.createMediaStreamSource(element.srcObject);
     let lastNode = this.sourceNode;
+    this.connectedNodes = [this.sourceNode];
     this.webAudioPluginNodes.forEach(node => {
       lastNode.connect(node);
       lastNode = node;
+      this.connectedNodes.push(node);
     });
     this.gainNode = context.createGain();
     lastNode.connect(this.gainNode);
+    this.connectedNodes.push(this.gainNode);
     this.gainNode.connect(context.destination);
     if (this.elementVolume !== undefined) {
       this.gainNode.gain.setTargetAtTime(this.elementVolume, 0, 0.1);
@@ -30881,6 +31476,19 @@ class RpcServerManager extends eventsExports.EventEmitter {
   }
   disconnectWebAudio() {
     var _a, _b;
+    // the plugin nodes belong to whoever passed them in and may feed graphs of their own, so only
+    // the edges this track created come down. A bare `node.disconnect()` would drop the
+    // application's own routing with them
+    for (let i = 0; i < this.connectedNodes.length - 1; i += 1) {
+      try {
+        this.connectedNodes[i].disconnect(this.connectedNodes[i + 1]);
+      } catch (_c) {
+        // a plugin node the application already disconnected itself, the rest of the chain still
+        // has to come apart
+      }
+    }
+    this.connectedNodes = [];
+    // the source and gain nodes are ours alone, so every remaining edge of theirs is ours to drop
     (_a = this.gainNode) === null || _a === void 0 ? void 0 : _a.disconnect();
     (_b = this.sourceNode) === null || _b === void 0 ? void 0 : _b.disconnect();
     this.gainNode = undefined;
@@ -31542,8 +32150,10 @@ class Participant extends eventsExports.EventEmitter {
    * @internal
    */
   setAudioContext(ctx) {
-    this.audioContext = ctx;
-    this.audioTrackPublications.forEach(track => isAudioTrack(track.track) && track.track.setAudioContext(ctx));
+    return __awaiter(this, void 0, void 0, function* () {
+      this.audioContext = ctx;
+      yield Promise.all(Array.from(this.audioTrackPublications.values()).map(publication => publication.track).filter(isAudioTrack).map(track => track.setAudioContext(ctx)));
+    });
   }
   addTrackPublication(publication) {
     this.log.debug("adding track publication", {
@@ -31802,10 +32412,7 @@ class Participant extends eventsExports.EventEmitter {
           if (!track.isMuted) {
             this.log.debug('track ended, attempting to use a different device', getLogContextFromTrack(track));
             if (isLocalAudioTrack(track)) {
-              // fall back to default device if available
-              yield track.restartTrack({
-                deviceId: 'default'
-              });
+              yield this.restartOnDefaultAudioDevice(track);
             } else {
               yield track.restartTrack();
             }
@@ -32152,10 +32759,10 @@ class Participant extends eventsExports.EventEmitter {
           loggerName: this.roomOptions.loggerName,
           loggerContextCb: () => this.logContext
         });
-        const localTracks = tracks.map(track => {
+        const localTracks = yield Promise.all(tracks.map(track => __awaiter(this, void 0, void 0, function* () {
           if (isAudioTrack(track)) {
             this.microphoneError = undefined;
-            track.setAudioContext(this.audioContext);
+            yield track.setAudioContext(this.audioContext);
             track.source = Track.Source.Microphone;
             this.emit(ParticipantEvent.AudioStreamAcquired);
           }
@@ -32164,7 +32771,7 @@ class Participant extends eventsExports.EventEmitter {
             track.source = Track.Source.Camera;
           }
           return track;
-        });
+        })));
         return localTracks;
       } catch (err) {
         if (err instanceof Error) {
@@ -32274,7 +32881,7 @@ class Participant extends eventsExports.EventEmitter {
       return function* () {
         var _a, _b, _c, _d;
         if (isLocalAudioTrack(track)) {
-          track.setAudioContext(_this2.audioContext);
+          yield track.setAudioContext(_this2.audioContext);
         }
         yield (_a = _this2.reconnectFuture) === null || _a === void 0 ? void 0 : _a.promise;
         if (_this2.republishPromise && !isRepublish) {
@@ -32874,19 +33481,36 @@ class Participant extends eventsExports.EventEmitter {
         return;
       }
       const packetTrailerFeatures = this.normalizeRequestedFrameMetadataOptions(track, opts);
+      // the backup sender encodes the processed track, not the raw capture track.dimensions reports
+      const _track$mediaStreamTra = track.mediaStreamTrack.getSettings(),
+        width = _track$mediaStreamTra.width,
+        height = _track$mediaStreamTra.height;
+      const dims = width && height ? {
+        width,
+        height
+      } : undefined;
+      if (!dims) {
+        this.log.warn('could not determine track dimensions, publishing backup codec without layers', getLogContextFromTrack(track));
+      }
+      // the server reads the layers off the codec entry for a request that carries a sid, and
+      // falls back to the top level ones when it predates per codec layers
+      const layers = dims ? videoLayersFromEncodings(dims.width, dims.height, encodings) : [];
       const req = new AddTrackRequest({
         cid: simulcastTrack.mediaStreamTrack.id,
         type: Track.kindToProto(track.kind),
         muted: track.isMuted,
         source: Track.sourceToProto(track.source),
         sid: track.sid,
+        width: dims === null || dims === void 0 ? void 0 : dims.width,
+        height: dims === null || dims === void 0 ? void 0 : dims.height,
         packetTrailerFeatures,
+        layers,
         simulcastCodecs: [{
           codec: opts.videoCodec,
-          cid: simulcastTrack.mediaStreamTrack.id
+          cid: simulcastTrack.mediaStreamTrack.id,
+          layers
         }]
       });
-      req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
       if (!this.engine || this.engine.isClosed) {
         throw new UnexpectedConnectionState('cannot publish track when not connected');
       }
@@ -33306,6 +33930,35 @@ class Participant extends eventsExports.EventEmitter {
     }
     return this.activeAgentFuture.promise;
   }
+  /**
+   * @internal
+   */
+  restartOnDefaultAudioDevice(track) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b;
+      try {
+        if (isChromiumBased()) {
+          // only chrome has the notion of a literal `default` device
+          yield track.setDeviceId({
+            exact: 'default'
+          });
+        } else {
+          // just try to restart for other browsers and try to change the device id as a fallback in the catch clause
+          yield track.restartTrack();
+        }
+      } catch (e) {
+        // restart() clears the manually-stopped flag on entry, so retrying a track the user stopped
+        // while the first attempt was in flight would re-open the capture device behind their back
+        if (!isDeviceAcquisitionFailure(e) || isPermissionDeniedError(e) || track.isStopped) {
+          throw e;
+        }
+        this.log.debug('could not reacquire the audio device, retrying with an enumerated device', getLogContextFromTrack(track));
+        // permission is already granted at this point, so skip the probe that would re-acquire media
+        const allDevices = yield DeviceManager.getInstance().getDevices('audioinput', false);
+        yield track.setDeviceId((_b = (_a = allDevices === null || allDevices === void 0 ? void 0 : allDevices[0]) === null || _a === void 0 ? void 0 : _a.deviceId) !== null && _b !== void 0 ? _b : 'default');
+      }
+    });
+  }
   getPublicationForTrack(track) {
     let publication;
     this.trackPublications.forEach(pub => {
@@ -34016,6 +34669,30 @@ class DeferrableMap extends Map {
 })(ConnectionState || (ConnectionState = {}));
 const CONNECTION_RECONCILE_FREQUENCY_MS = 4 * 1000;
 const STATS_LOG_FREQUENCY_MS = 30 * 1000;
+const DUMMY_AUDIO_ELEMENT_ID = 'livekit-dummy-audio-el';
+/**
+ * One silent audio element serves every room on the page, so it is reference counted: a room
+ * disconnecting must not pull it out from under the rooms still playing through it. The element
+ * and its track go away once the last room hands its reference back.
+ */
+let sharedDummyAudioElement;
+function createSharedDummyAudioElement() {
+  const element = document.createElement('audio');
+  element.id = DUMMY_AUDIO_ELEMENT_ID;
+  element.autoplay = true;
+  element.hidden = true;
+  const track = getEmptyAudioStreamTrack();
+  track.enabled = true;
+  const stream = new MediaStream([track]);
+  element.srcObject = stream;
+  document.body.append(element);
+  return {
+    element,
+    stream,
+    track,
+    refCount: 0
+  };
+}
 /**
  * In LiveKit, a room is the logical grouping for a list of participants.
  * Participants in a room can publish tracks, and subscribe to others' tracks.
@@ -34046,6 +34723,24 @@ class Room extends eventsExports.EventEmitter {
     /** reflects the sender encryption status of the local participant */
     this.isE2EEEnabled = false;
     this.audioEnabled = true;
+    /**
+     * whether `audioContext` was created by the SDK and therefore has to be closed by it.
+     * A context handed in through `webAudioMix` is owned by the application instead.
+     */
+    this.ownsAudioContext = false;
+    /**
+     * set once the audio context has been released as part of a disconnect. Guards against
+     * creating a new context outside of a connection lifecycle, where nothing would close it again.
+     */
+    this.audioContextReleased = false;
+    /**
+     * serialises `acquireAudioContext` against `releaseAudioContext`. Both await per-track graph
+     * rebuilds, so without it a reconnect landing inside a disconnect's teardown leaves the two
+     * racing to set the participants' context, and the loser's value is the one that sticks.
+     */
+    this.audioContextMutex = new _();
+    /** silent audio tracks this room acquired, handed back to the shared source on disconnect */
+    this.acquiredEmptyAudioTracks = new Set();
     this.e2eeStateMutex = new _();
     this.isVideoPlaybackBlocked = false;
     this.log = livekitLogger;
@@ -34218,7 +34913,9 @@ class Room extends eventsExports.EventEmitter {
       if ((_b = this.regionUrlProvider) === null || _b === void 0 ? void 0 : _b.isCloud()) {
         this.engine.setRegionStrategy(this.createRegionStrategy());
       }
-      this.acquireAudioContext();
+      this.acquireAudioContext(true).catch(error => this.log.warn('Could not acquire audio context', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
       this.connOptions = Object.assign(Object.assign({}, roomConnectOptionDefaults), opts);
       if (this.connOptions.rtcConfig) {
         this.engine.rtcConfig = this.connOptions.rtcConfig;
@@ -34337,44 +35034,8 @@ class Room extends eventsExports.EventEmitter {
     this.startAudio = () => __awaiter(this, void 0, void 0, function* () {
       const elements = [];
       const browser = getBrowser();
-      if (browser && browser.os === 'iOS') {
-        /**
-         * iOS blocks audio element playback if
-         * - user is not publishing audio themselves and
-         * - no other audio source is playing
-         *
-         * as a workaround, we create an audio element with an empty track, so that
-         * silent audio is always playing
-         */
-        const audioId = 'livekit-dummy-audio-el';
-        let dummyAudioEl = document.getElementById(audioId);
-        if (!dummyAudioEl) {
-          dummyAudioEl = document.createElement('audio');
-          dummyAudioEl.id = audioId;
-          dummyAudioEl.autoplay = true;
-          dummyAudioEl.hidden = true;
-          const track = getEmptyAudioStreamTrack();
-          track.enabled = true;
-          const stream = new MediaStream([track]);
-          dummyAudioEl.srcObject = stream;
-          document.addEventListener('visibilitychange', () => {
-            if (!dummyAudioEl) {
-              return;
-            }
-            // set the srcObject to null on page hide in order to prevent lock screen controls to show up for it
-            dummyAudioEl.srcObject = document.hidden ? null : stream;
-            if (!document.hidden) {
-              this.log.debug('page visible again, triggering startAudio to resume playback and update playback status');
-              this.startAudio();
-            }
-          });
-          document.body.append(dummyAudioEl);
-          this.once(RoomEvent.Disconnected, () => {
-            dummyAudioEl === null || dummyAudioEl === void 0 ? void 0 : dummyAudioEl.remove();
-            dummyAudioEl = null;
-          });
-        }
-        elements.push(dummyAudioEl);
+      if (browser && browser.os === 'iOS' && !this.audioContextReleased) {
+        elements.push(this.acquireDummyAudioElement());
       }
       this.remoteParticipants.forEach(p => {
         p.audioTrackPublications.forEach(t => {
@@ -34386,7 +35047,10 @@ class Room extends eventsExports.EventEmitter {
         });
       });
       try {
-        yield Promise.all([this.acquireAudioContext(), ...elements.map(e => {
+        yield Promise.all([
+        // once the audio context has been released as part of a disconnect there is nothing left
+        // to unlock, and creating a new context here would leak it as no disconnect will follow
+        ...(this.audioContextReleased ? [] : [this.acquireAudioContext()]), ...elements.map(e => {
           // when webAudioMix is enabled, attached elements are deliberately kept muted by
           // RemoteAudioTrack.attach() and audio is routed through the web audio graph instead.
           // unmuting them here would cause double playback on platforms where element.volume
@@ -35430,6 +36094,78 @@ class Room extends eventsExports.EventEmitter {
       }
     });
   }
+  /**
+   * iOS blocks audio element playback if
+   * - user is not publishing audio themselves and
+   * - no other audio source is playing
+   *
+   * as a workaround, we create an audio element with an empty track, so that
+   * silent audio is always playing
+   *
+   * The element is shared with any other room on the page and handed back on disconnect, so it
+   * outlives whichever room happened to create it.
+   */
+  acquireDummyAudioElement() {
+    if (!sharedDummyAudioElement) {
+      sharedDummyAudioElement = createSharedDummyAudioElement();
+    }
+    const shared = sharedDummyAudioElement;
+    if (this.releaseDummyAudioElement) {
+      // this room already holds a reference, a second one would never be handed back
+      return shared.element;
+    }
+    shared.refCount += 1;
+    // the listener is per room rather than shared, so that the room it resumes playback for is
+    // still connected, and so that it goes away with the room that installed it
+    const handleVisibilityChange = () => {
+      // set the srcObject to null on page hide in order to prevent lock screen controls to show up for it
+      shared.element.srcObject = document.hidden ? null : shared.stream;
+      if (!document.hidden) {
+        this.log.debug('page visible again, triggering startAudio to resume playback and update playback status');
+        this.startAudio().catch(error => this.log.warn('Could not restart audio on page becoming visible', Object.assign(Object.assign({}, this.logContext), {
+          error
+        })));
+      }
+    };
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    this.releaseDummyAudioElement = () => {
+      this.releaseDummyAudioElement = undefined;
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+      shared.refCount -= 1;
+      if (shared.refCount > 0) {
+        return;
+      }
+      shared.element.srcObject = null;
+      shared.element.remove();
+      sharedDummyAudioElement = undefined;
+      releaseEmptyAudioStreamTrack(shared.track).catch(error => this.log.warn('Could not release the dummy audio element track', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
+    };
+    return shared.element;
+  }
+  /**
+   * Obtains a silent audio track from the shared source and keeps track of it, so that it can be
+   * handed back on disconnect and the shared `AudioContext` behind it can be closed again.
+   */
+  acquireEmptyAudioStreamTrack() {
+    const track = getEmptyAudioStreamTrack();
+    this.acquiredEmptyAudioTracks.add(track);
+    return track;
+  }
+  releaseAcquiredEmptyAudioTrack(track) {
+    if (!this.acquiredEmptyAudioTracks.delete(track)) {
+      return;
+    }
+    releaseEmptyAudioStreamTrack(track).catch(error => this.log.warn('Could not release empty audio stream track', Object.assign(Object.assign({}, this.logContext), {
+      error
+    })));
+  }
+  releaseAcquiredEmptyAudioTracks() {
+    for (const track of this.acquiredEmptyAudioTracks) {
+      this.releaseAcquiredEmptyAudioTrack(track);
+    }
+  }
   /**
    * Returns true if audio playback is enabled
    */
@@ -35712,7 +36448,7 @@ class Room extends eventsExports.EventEmitter {
   handleDisconnect() {
     let shouldStopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     let reason = arguments.length > 1 ? arguments[1] : undefined;
-    var _a, _b;
+    var _a, _b, _c;
     this.clearConnectionReconcile();
     this.isResuming = false;
     this.bufferedEvents = [];
@@ -35729,6 +36465,9 @@ class Room extends eventsExports.EventEmitter {
       this.regionUrlProvider.notifyDisconnected();
     }
     try {
+      // audio tracks that outlive this room are about to become unreachable through the local
+      // participant, collect them while we can so they can be detached from the context below
+      const retainedAudioTracks = shouldStopTracks ? [] : Array.from(this.localParticipant.audioTrackPublications.values()).map(pub => pub.track).filter(isLocalAudioTrack);
       this.remoteParticipants.forEach(p => {
         p.trackPublications.forEach(pub => {
           p.unpublishTrack(pub.trackSid);
@@ -35753,15 +36492,18 @@ class Room extends eventsExports.EventEmitter {
       this.remoteParticipants.clear();
       this.sidToIdentity.clear();
       this.activeSpeakers = [];
-      if (this.audioContext && typeof this.options.webAudioMix === 'boolean') {
-        this.audioContext.close();
-        this.audioContext = undefined;
-      }
+      (_a = this.releaseDummyAudioElement) === null || _a === void 0 ? void 0 : _a.call(this);
+      this.releaseAcquiredEmptyAudioTracks();
+      // teardown is asynchronous (processors need to release their web audio nodes), but
+      // `handleDisconnect` is not, so let it finish in the background
+      this.releaseAudioContext(retainedAudioTracks).catch(error => this.log.warn('Could not release audio context', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
       if (isWeb()) {
         window.removeEventListener('beforeunload', this.onPageLeave);
         window.removeEventListener('pagehide', this.onPageLeave);
         window.removeEventListener('freeze', this.onPageLeave);
-        (_b = (_a = navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'devicechange', this.handleDeviceChange);
+        (_c = (_b = navigator.mediaDevices) === null || _b === void 0 ? void 0 : _b.removeEventListener) === null || _c === void 0 ? void 0 : _c.call(_b, 'devicechange', this.handleDeviceChange);
       }
     } finally {
       this.setAndEmitConnectionState(ConnectionState.Disconnected);
@@ -35836,39 +36578,139 @@ class Room extends eventsExports.EventEmitter {
       }
     });
   }
+  /**
+   * @param forConnect whether this acquisition belongs to a connect, which is the only caller
+   * allowed to put a released room back on an audio context.
+   */
   acquireAudioContext() {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
-      if (typeof this.options.webAudioMix !== 'boolean' && this.options.webAudioMix.audioContext) {
-        // override audio context with custom audio context if supplied by user
-        this.audioContext = this.options.webAudioMix.audioContext;
-      } else if (!this.audioContext || this.audioContext.state === 'closed') {
-        // by using an AudioContext, it reduces lag on audio elements
-        // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
-        this.audioContext = (_a = getNewAudioContext()) !== null && _a !== void 0 ? _a : undefined;
-      }
-      if (this.options.webAudioMix) {
-        this.remoteParticipants.forEach(participant => participant.setAudioContext(this.audioContext));
-      }
-      this.localParticipant.setAudioContext(this.audioContext);
-      if (this.audioContext && this.audioContext.state === 'suspended') {
-        // for iOS a newly created AudioContext is always in `suspended` state.
-        // we try our best to resume the context here, if that doesn't work, we just continue with regular processing
+    return __awaiter(this, arguments, void 0, function () {
+      var _this4 = this;
+      let forConnect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      return function* () {
+        var _a, _b;
+        const unlock = yield _this4.audioContextMutex.lock();
         try {
-          yield Promise.race([this.audioContext.resume(), sleep(200)]);
-        } catch (e) {
-          this.log.warn('Could not resume audio context', {
-            error: e
-          });
+          if (_this4.audioContextReleased && !forConnect) {
+            // a disconnect set the flag and took the lock while this call was queued behind it.
+            // Creating a context now would leave one open on a room nothing tears down again
+            return;
+          }
+          _this4.audioContextReleased = false;
+          const providedAudioContext = typeof _this4.options.webAudioMix !== 'boolean' ? _this4.options.webAudioMix.audioContext : undefined;
+          if (providedAudioContext) {
+            // override audio context with custom audio context if supplied by user
+            yield _this4.setRoomAudioContext(providedAudioContext, false);
+          } else if (!_this4.audioContext || _this4.audioContext.state === 'closed') {
+            // by using an AudioContext, it reduces lag on audio elements
+            // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
+            yield _this4.setRoomAudioContext((_a = getNewAudioContext()) !== null && _a !== void 0 ? _a : undefined, true);
+          }
+          if (_this4.audioContext && _this4.audioContext.state === 'suspended') {
+            // for iOS a newly created AudioContext is always in `suspended` state.
+            // we try our best to resume the context here, if that doesn't work, we just continue with regular processing
+            try {
+              yield Promise.race([_this4.audioContext.resume(), sleep(200)]);
+            } catch (e) {
+              _this4.log.warn('Could not resume audio context', {
+                error: e
+              });
+            }
+          }
+          const newContextIsRunning = ((_b = _this4.audioContext) === null || _b === void 0 ? void 0 : _b.state) === 'running';
+          if (newContextIsRunning !== _this4.canPlaybackAudio) {
+            _this4.audioEnabled = newContextIsRunning;
+            _this4.emit(RoomEvent.AudioPlaybackStatusChanged, newContextIsRunning);
+          }
+        } finally {
+          unlock();
         }
+      }();
+    });
+  }
+  /**
+   * Points the room and its participants at `audioContext`, rebuilding the web audio graph of
+   * every audio track in it. Closes the previous context if the SDK `owned` it.
+   */
+  setRoomAudioContext(audioContext, owned) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const ownsAudioContext = !!audioContext && owned;
+      if (this.audioContext === audioContext) {
+        this.ownsAudioContext = ownsAudioContext;
+        return;
       }
-      const newContextIsRunning = ((_b = this.audioContext) === null || _b === void 0 ? void 0 : _b.state) === 'running';
-      if (newContextIsRunning !== this.canPlaybackAudio) {
-        this.audioEnabled = newContextIsRunning;
-        this.emit(RoomEvent.AudioPlaybackStatusChanged, newContextIsRunning);
+      const contextToClose = this.ownsAudioContext ? this.audioContext : undefined;
+      this.audioContext = audioContext;
+      this.ownsAudioContext = ownsAudioContext;
+      try {
+        // every audio track rebuilds its nodes in the new context, which has to happen before the
+        // previous one is closed so that processors can move off it while it is still alive
+        if (this.options.webAudioMix) {
+          yield Promise.all(Array.from(this.remoteParticipants.values()).map(participant => participant.setAudioContext(audioContext)));
+        }
+        yield this.localParticipant.setAudioContext(audioContext);
+      } catch (error) {
+        // the context is being abandoned either way, so a track that failed to move off it must
+        // not stop us closing it — that would leak the context this whole path exists to release
+        this.log.warn('Could not move audio tracks to the new audio context', Object.assign(Object.assign({}, this.logContext), {
+          error
+        }));
+      } finally {
+        if (contextToClose && contextToClose.state !== 'closed') {
+          try {
+            yield contextToClose.close();
+          } catch (error) {
+            this.log.warn('Could not close audio context', Object.assign(Object.assign({}, this.logContext), {
+              error
+            }));
+          }
+        }
       }
     });
   }
+  /**
+   * Detaches the web audio graph the SDK built from the current audio context and closes that
+   * context if the SDK created it. A context provided through `webAudioMix` is left untouched.
+   */
+  releaseAudioContext() {
+    return __awaiter(this, arguments, void 0, function () {
+      var _this5 = this;
+      let retainedAudioTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return function* () {
+        // both reads happen before the first await, so they describe the room as it was when the
+        // disconnect started rather than after a reconnect has had a chance to run
+        _this5.audioContextReleased = true;
+        const contextToRelease = _this5.audioContext;
+        const unlock = yield _this5.audioContextMutex.lock();
+        try {
+          if (!_this5.audioContextReleased || _this5.audioContext !== contextToRelease) {
+            // a reconnect acquired a new context while we were waiting, closing it would leave the
+            // reconnected room without one
+            return;
+          }
+          if (!_this5.ownsAudioContext) {
+            // a provided context stays open, so tracks that outlive the room stay functional on it.
+            // The tracks this room detached have released their nodes during track teardown already.
+            // read under the lock: an acquire queued behind an in-flight release flips this flag
+            return;
+          }
+          try {
+            // tracks that outlive the room aren't reachable through the local participant anymore,
+            // but still hold web audio nodes in the context we're about to close
+            yield Promise.all(retainedAudioTracks.map(track => track.setAudioContext(undefined)));
+          } catch (error) {
+            _this5.log.warn('Could not detach retained audio tracks from the audio context', Object.assign(Object.assign({}, _this5.logContext), {
+              error
+            }));
+          }
+          // the participant maps have already been cleared by `handleDisconnect`, so this reaches no
+          // tracks of its own — `retainedAudioTracks` above is what detaches them
+          yield _this5.setRoomAudioContext(undefined, false);
+        } finally {
+          unlock();
+        }
+      }();
+    });
+  }
   createParticipant(identity, info) {
     var _a;
     let participant;
@@ -35884,7 +36726,9 @@ class Room extends eventsExports.EventEmitter {
       });
     }
     if (this.options.webAudioMix) {
-      participant.setAudioContext(this.audioContext);
+      participant.setAudioContext(this.audioContext).catch(error => this.log.warn('Could not set audio context', Object.assign(Object.assign({}, this.logContext), {
+        error
+      })));
     }
     if ((_a = this.options.audioOutput) === null || _a === void 0 ? void 0 : _a.deviceId) {
       participant.setAudioOutput(this.options.audioOutput).catch(e => this.log.warn("Could not set audio output: ".concat(e.message)));
@@ -36004,21 +36848,21 @@ class Room extends eventsExports.EventEmitter {
   }
   registerRpcDataStreamHandler() {
     this.incomingDataStreamManager.registerTextStreamHandler(RPC_REQUEST_DATA_STREAM_TOPIC, (reader_1, _a) => __awaiter(this, [reader_1, _a], void 0, function (reader, _ref7) {
-      var _this4 = this;
+      var _this6 = this;
       let identity = _ref7.identity;
       return function* () {
         var _b;
         const attributes = (_b = reader.info.attributes) !== null && _b !== void 0 ? _b : {};
-        yield _this4.rpcServerManager.handleIncomingDataStream(reader, identity, attributes);
+        yield _this6.rpcServerManager.handleIncomingDataStream(reader, identity, attributes);
       }();
     }));
     this.incomingDataStreamManager.registerTextStreamHandler(RPC_RESPONSE_DATA_STREAM_TOPIC, (reader_1, _a) => __awaiter(this, [reader_1, _a], void 0, function (reader, _ref8) {
-      var _this5 = this;
+      var _this7 = this;
       let identity = _ref8.identity;
       return function* () {
         var _b;
         const attributes = (_b = reader.info.attributes) !== null && _b !== void 0 ? _b : {};
-        yield _this5.rpcClientManager.handleIncomingDataStream(reader, identity, attributes);
+        yield _this7.rpcClientManager.handleIncomingDataStream(reader, identity, attributes);
       }();
     }));
   }
@@ -36177,7 +37021,7 @@ class Room extends eventsExports.EventEmitter {
           type: TrackType.AUDIO
         }), new LocalAudioTrack(publishOptions.useRealTracks && ((_c = navigator.mediaDevices) === null || _c === void 0 ? void 0 : _c.getUserMedia) ? (yield navigator.mediaDevices.getUserMedia({
           audio: true
-        })).getAudioTracks()[0] : getEmptyAudioStreamTrack(), undefined, false, this.audioContext, {
+        })).getAudioTracks()[0] : this.acquireEmptyAudioStreamTrack(), undefined, false, this.audioContext, {
           loggerName: this.options.loggerName,
           loggerContextCb: () => this.logContext
         }), {
@@ -36208,7 +37052,7 @@ class Room extends eventsExports.EventEmitter {
           info.tracks = [...info.tracks, videoTrack];
         }
         if (participantOptions.audio) {
-          const dummyTrack = getEmptyAudioStreamTrack();
+          const dummyTrack = this.acquireEmptyAudioStreamTrack();
           const audioTrack = new TrackInfo({
             source: TrackSource.MICROPHONE,
             sid: Math.floor(Math.random() * 10000).toString(),
@@ -37634,4 +38478,4 @@ const serializers = {
   json,
   raw,
   custom
-};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CLIENT_PROTOCOL_DATA_STREAM_RPC,CLIENT_PROTOCOL_DATA_STREAM_V2,CLIENT_PROTOCOL_DEFAULT,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,FrameMetadataManager,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,canFailOverToAnotherRegion,clientProtocol,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isSVCCodec,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsH265,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map
+};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CLIENT_PROTOCOL_DATA_STREAM_RPC,CLIENT_PROTOCOL_DATA_STREAM_V2,CLIENT_PROTOCOL_DEFAULT,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,FrameMetadataManager,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,canFailOverToAnotherRegion,clientProtocol,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isSVCCodec,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,releaseEmptyAudioStreamTrack,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,supportsH265,supportsVP9,version,videoCodecs,writeRbsp};//# sourceMappingURL=livekit-client.esm.mjs.map