livekit-client 2.21.0 → 2.22.1

package/dist/livekit-client.esm.mjs

@@ -946,6 +946,9 @@ function _defineProperty(e, r, t) {
     writable: true
   }) : e[r] = t, e;
 }
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
 function _iterableToArrayLimit(r, l) {
   var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
   if (null != t) {
@@ -976,9 +979,53 @@ function _iterableToArrayLimit(r, l) {
 function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
 function _slicedToArray(r, e) {
   return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
+function _toArray(r) {
+  return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest();
+}
 function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
@@ -8505,6 +8552,7 @@ var LoggerNames;
   LoggerNames["DataTracks"] = "livekit-data-tracks";
   LoggerNames["Region"] = "livekit-region";
   LoggerNames["ICE"] = "livekit-ice";
+  LoggerNames["Stats"] = "livekit-stats";
 })(LoggerNames || (LoggerNames = {}));
 let livekitLogger = loglevelExports.getLogger(LoggerNames.Default);
 const livekitLoggers = Object.values(LoggerNames).map(name => loglevelExports.getLogger(name));
@@ -12160,7 +12208,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.21.0";const version = version$1;
+}var version$1 = "2.22.1";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -12446,7 +12494,7 @@ var RoomEvent;
    * When a [[RemoteParticipant]] leaves *after* the local
    * participant has joined.
    *
-   * args: ([[RemoteParticipant]])
+   * args: ([[RemoteParticipant]], [[DisconnectReason]] | undefined)
    */
   RoomEvent["ParticipantDisconnected"] = "participantDisconnected";
   /**
@@ -13014,7 +13062,171 @@ var TrackEvent;
    * @internal
    */
   TrackEvent["PreConnectBufferFlushed"] = "preConnectBufferFlushed";
-})(TrackEvent || (TrackEvent = {}));function cloneDeep(value) {
+})(TrackEvent || (TrackEvent = {}));function compact(summary) {
+  const compacted = {};
+  for (const _ref of Object.entries(summary)) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    const key = _ref2[0];
+    const value = _ref2[1];
+    if (value !== undefined) {
+      compacted[key] = value;
+    }
+  }
+  return compacted;
+}
+function resolution(width, height) {
+  return width && height ? "".concat(width, "x").concat(height) : undefined;
+}
+/** keeps the derived durations readable; reported values are logged as they are */
+function round(seconds) {
+  return Math.round(seconds * 10000) / 10000;
+}
+/**
+ * Average time media spent in the jitter buffer, in s. Both counters are
+ * cumulative, so this is the average over the lifetime of the stream.
+ */
+function jitterBuffer(stat) {
+  const delay = stat.jitterBufferDelay;
+  const emitted = stat.jitterBufferEmittedCount;
+  return delay !== undefined && emitted ? round(delay / emitted) : undefined;
+}
+/**
+ * Playout delay in s. Video receive reports it directly, the audio path keeps it
+ * in the linked `media-playout` stats summed over the samples played out. Pairs
+ * with `RemoteTrack.setPlayoutDelay`.
+ */
+function playoutDelay(stat, playout) {
+  if (stat.playoutDelay !== undefined) {
+    return round(stat.playoutDelay);
+  }
+  const total = playout === null || playout === void 0 ? void 0 : playout.totalPlayoutDelay;
+  const samples = playout === null || playout === void 0 ? void 0 : playout.totalSamplesCount;
+  return total !== undefined && samples ? round(total / samples) : undefined;
+}
+/**
+ * Picks the interesting fields out of a `getStats()` report and groups them by
+ * RTP stream, so a stats dump can be read without unfolding the raw report.
+ */
+function summarizeStatsReport(report) {
+  var _a, _b;
+  const byId = new Map();
+  const candidatePairs = [];
+  const inbound = [];
+  const outbound = [];
+  let transport;
+  report.forEach(stat => byId.set(stat.id, stat));
+  const codecOf = stat => {
+    var _a;
+    return stat.codecId ? (_a = byId.get(stat.codecId)) === null || _a === void 0 ? void 0 : _a.mimeType : undefined;
+  };
+  const relatedOf = (stat, key) => stat[key] ? byId.get(stat[key]) : undefined;
+  report.forEach(stat => {
+    switch (stat.type) {
+      case 'inbound-rtp':
+        {
+          const playout = relatedOf(stat, 'playoutId');
+          inbound.push(compact({
+            kind: stat.kind,
+            ssrc: stat.ssrc,
+            mid: stat.mid,
+            // matches `streamTrackID` in the track's own log context
+            trackId: stat.trackIdentifier,
+            codec: codecOf(stat),
+            decoder: stat.decoderImplementation,
+            resolution: resolution(stat.frameWidth, stat.frameHeight),
+            fps: stat.framesPerSecond,
+            bytesReceived: stat.bytesReceived,
+            packetsReceived: stat.packetsReceived,
+            packetsLost: stat.packetsLost,
+            packetsDiscarded: stat.packetsDiscarded,
+            // frames received without frames decoded is a decode failure
+            framesReceived: stat.framesReceived,
+            framesDecoded: stat.framesDecoded,
+            framesDropped: stat.framesDropped,
+            keyFramesDecoded: stat.keyFramesDecoded,
+            freezeCount: stat.freezeCount,
+            totalFreezesDuration: stat.totalFreezesDuration,
+            pauseCount: stat.pauseCount,
+            nackCount: stat.nackCount,
+            pliCount: stat.pliCount,
+            firCount: stat.firCount,
+            jitter: stat.jitter,
+            jitterBuffer: jitterBuffer(stat),
+            playoutDelay: playoutDelay(stat, playout),
+            audioLevel: stat.audioLevel,
+            totalSamplesReceived: stat.totalSamplesReceived,
+            concealedSamples: stat.concealedSamples
+          }));
+          break;
+        }
+      case 'outbound-rtp':
+        {
+          const remote = relatedOf(stat, 'remoteId');
+          const source = relatedOf(stat, 'mediaSourceId');
+          outbound.push(compact({
+            kind: stat.kind,
+            ssrc: stat.ssrc,
+            mid: stat.mid,
+            rid: stat.rid,
+            trackId: source === null || source === void 0 ? void 0 : source.trackIdentifier,
+            active: stat.active,
+            codec: codecOf(stat),
+            encoder: stat.encoderImplementation,
+            resolution: resolution(stat.frameWidth, stat.frameHeight),
+            fps: stat.framesPerSecond,
+            // what the source produces, to tell a stalled capture from a stalled encoder
+            captureResolution: resolution(source === null || source === void 0 ? void 0 : source.width, source === null || source === void 0 ? void 0 : source.height),
+            captureFps: source === null || source === void 0 ? void 0 : source.framesPerSecond,
+            audioLevel: source === null || source === void 0 ? void 0 : source.audioLevel,
+            targetBitrate: stat.targetBitrate,
+            bytesSent: stat.bytesSent,
+            packetsSent: stat.packetsSent,
+            retransmittedPacketsSent: stat.retransmittedPacketsSent,
+            framesEncoded: stat.framesEncoded,
+            keyFramesEncoded: stat.keyFramesEncoded,
+            limitedBy: stat.qualityLimitationReason === 'none' ? undefined : stat.qualityLimitationReason,
+            nackCount: stat.nackCount,
+            pliCount: stat.pliCount,
+            firCount: stat.firCount,
+            // loss, jitter and RTT are only known from what the remote reports
+            remotePacketsLost: remote === null || remote === void 0 ? void 0 : remote.packetsLost,
+            remoteFractionLost: remote === null || remote === void 0 ? void 0 : remote.fractionLost,
+            remoteJitter: remote === null || remote === void 0 ? void 0 : remote.jitter,
+            remoteRoundTripTime: remote === null || remote === void 0 ? void 0 : remote.roundTripTime
+          }));
+          break;
+        }
+      case 'transport':
+        transport = stat;
+        break;
+      case 'candidate-pair':
+        candidatePairs.push(stat);
+        break;
+    }
+  });
+  const selectedPairId = transport === null || transport === void 0 ? void 0 : transport.selectedCandidatePairId;
+  const pair = (_b = (_a = selectedPairId ? byId.get(selectedPairId) : undefined) !== null && _a !== void 0 ? _a : candidatePairs.find(candidate => candidate.selected)) !== null && _b !== void 0 ? _b : candidatePairs.find(candidate => candidate.nominated);
+  const local = (pair === null || pair === void 0 ? void 0 : pair.localCandidateId) ? byId.get(pair.localCandidateId) : undefined;
+  const remote = (pair === null || pair === void 0 ? void 0 : pair.remoteCandidateId) ? byId.get(pair.remoteCandidateId) : undefined;
+  const connection = compact({
+    ice: transport === null || transport === void 0 ? void 0 : transport.iceState,
+    dtls: transport === null || transport === void 0 ? void 0 : transport.dtlsState,
+    route: local && remote ? "".concat(local.candidateType, "/").concat(local.protocol, " -> ").concat(remote.candidateType) : undefined,
+    network: local === null || local === void 0 ? void 0 : local.networkType,
+    currentRoundTripTime: pair === null || pair === void 0 ? void 0 : pair.currentRoundTripTime,
+    // the send bandwidth estimate; no RTP stream reports it
+    availableOutgoingBitrate: pair === null || pair === void 0 ? void 0 : pair.availableOutgoingBitrate,
+    availableIncomingBitrate: pair === null || pair === void 0 ? void 0 : pair.availableIncomingBitrate,
+    bytesSent: pair === null || pair === void 0 ? void 0 : pair.bytesSent,
+    bytesReceived: pair === null || pair === void 0 ? void 0 : pair.bytesReceived,
+    candidatePairChanges: transport === null || transport === void 0 ? void 0 : transport.selectedCandidatePairChanges
+  });
+  return {
+    connection: Object.keys(connection).length > 0 ? connection : undefined,
+    outbound: outbound.length > 0 ? outbound : undefined,
+    inbound: inbound.length > 0 ? inbound : undefined
+  };
+}function cloneDeep$1(value) {
   if (typeof value === 'undefined') {
     return value;
   }
@@ -13439,7 +13651,7 @@ function extractProcessorsFromOptions(options) {
   return {
     audioProcessor,
     videoProcessor,
-    optionsWithoutProcessor: cloneDeep(newOptions)
+    optionsWithoutProcessor: cloneDeep$1(newOptions)
   };
 }
 function getTrackSourceFromProto(source) {
@@ -13496,6 +13708,7 @@ class Track extends eventsExports.EventEmitter {
     this._streamState = Track.StreamState.Active;
     this.isInBackground = false;
     this._currentBitrate = 0;
+    this.finalStatsLogged = false;
     this.log = livekitLogger;
     this.appVisibilityChangedListener = () => {
       if (this.backgroundTimeout) {
@@ -13640,9 +13853,28 @@ class Track extends eventsExports.EventEmitter {
     if (this.monitorInterval) {
       clearInterval(this.monitorInterval);
     }
-    if (this.timeSyncHandle) {
+    if (this.timeSyncHandle !== undefined) {
       cancelAnimationFrame(this.timeSyncHandle);
+      this.timeSyncHandle = undefined;
     }
+    this.logFinalStats();
+  }
+  /**
+   * Dumps the raw stats of the track as it ends, once: a track that stops
+   * between two of the room's stats dumps is gone by the time the next one runs.
+   */
+  logFinalStats() {
+    if (this.finalStatsLogged) {
+      return;
+    }
+    this.finalStatsLogged = true;
+    this.getRTCStatsReport().then(report => {
+      if (report) {
+        this.log.info('final track stats', summarizeStatsReport(report));
+      }
+    }).catch(error => this.log.debug('could not collect final track stats', {
+      error
+    }));
   }
   /** @internal */
   updateLoggerOptions(loggerOptions) {
@@ -13868,7 +14100,7 @@ function supportsAddTrack() {
   return 'addTrack' in RTCPeerConnection.prototype;
 }
 function supportsAdaptiveStream() {
-  return typeof ResizeObserver !== undefined && typeof IntersectionObserver !== undefined;
+  return typeof ResizeObserver !== 'undefined' && typeof IntersectionObserver !== 'undefined';
 }
 function supportsDynacast() {
   return supportsTransceiver();
@@ -13926,9 +14158,64 @@ function supportsVP9() {
   }
   return hasVP9;
 }
+function supportsH265() {
+  if (!('getCapabilities' in RTCRtpSender)) {
+    return false;
+  }
+  const capabilities = RTCRtpSender.getCapabilities('video');
+  let hasH265 = false;
+  if (capabilities) {
+    for (const codec of capabilities.codecs) {
+      if (codec.mimeType.toLowerCase() === 'video/h265') {
+        hasH265 = true;
+        break;
+      }
+    }
+  }
+  return hasH265;
+}
 function isSVCCodec(codec) {
   return codec === 'av1' || codec === 'vp9';
 }
+/**
+ * Opts `transceiver` into negotiating the AV1 dependency descriptor, reporting whether it will be.
+ *
+ * Chrome only offers the extension on transceivers that can send, so one we create to receive on
+ * never negotiates it — and Chrome 152 stopped decoding AV1 that arrives without it: frames get
+ * assembled, none ever decode, and the receiver asks for a keyframe forever. Asking through the
+ * transceiver rather than munging the extension into the SDP leaves the browser owning the
+ * extension id, which is what keeps that id consistent across the bundle and across
+ * renegotiations.
+ *
+ * A no-op where the browser offers no such control, or does not know the extension at all.
+ * @internal
+ */
+function negotiateDependencyDescriptor(transceiver) {
+  var _a;
+  const extensions = (_a = transceiver.getHeaderExtensionsToNegotiate) === null || _a === void 0 ? void 0 : _a.call(transceiver);
+  if (!extensions || !transceiver.setHeaderExtensionsToNegotiate) {
+    return false;
+  }
+  const dd = extensions.find(ext => ext.uri === ddExtensionURI);
+  if (!dd) {
+    return false;
+  }
+  if (dd.direction !== 'stopped') {
+    return true;
+  }
+  // sendrecv rather than recvonly, so that the extension is written as a plain `a=extmap` line —
+  // the form the server already emits where it is the one offering — rather than one carrying a
+  // `/recvonly` suffix that its parser may not expect
+  dd.direction = 'sendrecv';
+  try {
+    transceiver.setHeaderExtensionsToNegotiate(extensions);
+    return true;
+  } catch (e) {
+    // a rejected direction throws. Negotiating without the extension is what happened before this
+    // existed, so it is not worth failing the connection over
+    return false;
+  }
+}
 function supportsSetSinkId(elm) {
   if (!document || isSafariBased()) {
     return false;
@@ -14470,6 +14757,17 @@ function isCompressionStreamSupported() {
 function isPublisherOfferWithJoinSupported() {
   // we have connectivity issue about publisher offer with join on firefox #1919
   return isCompressionStreamSupported() && !isFireFox();
+}
+function extractTrackSid(mediaTrack, stream) {
+  const _unpackStreamId = unpackStreamId(stream.id),
+    _unpackStreamId2 = _slicedToArray(_unpackStreamId, 2),
+    streamId = _unpackStreamId2[1];
+  if (streamId === null || streamId === void 0 ? void 0 : streamId.startsWith('TR')) {
+    return streamId;
+  }
+  if (mediaTrack.id.startsWith('TR')) {
+    return mediaTrack.id;
+  }
 }function createRtcUrl(url, searchParams) {
   let useV0Path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   const v0Url = createV0RtcUrl(url, searchParams);
@@ -14509,6 +14807,11 @@ function parseSignalResponse(value) {
 }
 function getAbortReasonAsString(signal) {
   let defaultMessage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Unknown reason';
+  // the connect timeout hands this an Error rather than a signal, and its message is the only
+  // description of what went wrong — without this a timeout reports itself as a generic abort
+  if (signal instanceof Error) {
+    return signal.message;
+  }
   if (!(signal instanceof AbortSignal)) {
     return defaultMessage;
   }
@@ -14968,6 +15271,34 @@ function computeBitrate(currentStats, prevStats) {
 }class RemoteTrack extends Track {
   constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
     super(mediaTrack, kind, loggerOptions);
+    this.timeSyncLoop = () => {
+      var _a;
+      if (this.listenerCount(TrackEvent.TimeSyncUpdate) === 0) {
+        // nobody is listening anymore, pause the loop until a new listener subscribes
+        this.timeSyncHandle = undefined;
+        return;
+      }
+      this.timeSyncHandle = requestAnimationFrame(this.timeSyncLoop);
+      const sources = (_a = this.receiver) === null || _a === void 0 ? void 0 : _a.getSynchronizationSources()[0];
+      if (sources) {
+        const timestamp = sources.timestamp,
+          rtpTimestamp = sources.rtpTimestamp;
+        if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
+          this.emit(TrackEvent.TimeSyncUpdate, {
+            timestamp,
+            rtpTimestamp
+          });
+          this.rtpTimestamp = rtpTimestamp;
+        }
+      }
+    };
+    this.onTimeSyncListenerAdded = event => {
+      if (event === TrackEvent.TimeSyncUpdate && this.timeSyncHandle === undefined) {
+        // `newListener` fires before the listener is registered, so schedule the
+        // next frame instead of entering the loop (which would see a count of 0)
+        this.timeSyncHandle = requestAnimationFrame(this.timeSyncLoop);
+      }
+    };
     this.sid = sid;
     this.receiver = receiver;
   }
@@ -15065,24 +15396,19 @@ function computeBitrate(currentStats, prevStats) {
       this.registerTimeSyncUpdate();
     }
   }
+  /* @internal */
+  stopMonitor() {
+    super.stopMonitor();
+    this.off('newListener', this.onTimeSyncListenerAdded);
+  }
   registerTimeSyncUpdate() {
-    const loop = () => {
-      var _a;
-      this.timeSyncHandle = requestAnimationFrame(() => loop());
-      const sources = (_a = this.receiver) === null || _a === void 0 ? void 0 : _a.getSynchronizationSources()[0];
-      if (sources) {
-        const timestamp = sources.timestamp,
-          rtpTimestamp = sources.rtpTimestamp;
-        if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
-          this.emit(TrackEvent.TimeSyncUpdate, {
-            timestamp,
-            rtpTimestamp
-          });
-          this.rtpTimestamp = rtpTimestamp;
-        }
-      }
-    };
-    loop();
+    // `newListener` isn't part of the typed event map, hence the cast
+    const emitter = this;
+    emitter.off('newListener', this.onTimeSyncListenerAdded);
+    emitter.on('newListener', this.onTimeSyncListenerAdded);
+    if (this.timeSyncHandle === undefined) {
+      this.timeSyncLoop();
+    }
   }
 }const REACTION_DELAY = 100;
 class RemoteVideoTrack extends RemoteTrack {
@@ -16546,6 +16872,1140 @@ class AsyncQueue {
   snapshot() {
     return Array.from(this.pendingTasks.values());
   }
+}/**
+ * Opt-in registry that lets a development tool observe the state machines driving the connection
+ * layer.
+ *
+ * The machines are private to the objects that own them and, more importantly, do not outlive them:
+ * a full reconnect replaces the whole engine along with its `SignalClient`, so anything watching a
+ * single machine reference goes blind exactly when the interesting part starts. Machines therefore
+ * announce themselves here as they are constructed, and a subscriber sees the whole succession.
+ *
+ * Nothing is recorded until {@link enableMachineInspector} is called, which no shipping code does —
+ * with the registry off, announcing is a comparison and a return.
+ */
+/** Kept small: enough for a panel opened mid-session to see how the connection got where it is. */
+/** Announces a machine to whatever is watching. A no-op unless the inspector was enabled. */
+function announceMachine(label, machine) {
+  {
+    return;
+  }
+}const _excluded = ["client"];
+//#region src/emitter.ts
+/**
+* Minimal typed event emitter used internally by Fsm and BehavioralFsm.
+*
+* Two listener categories exist at runtime: named listeners (keyed by event
+* name) and wildcard listeners (keyed as `"*"`). The wildcard fires on EVERY
+* emit, regardless of event name, and its callback receives both the event
+* name and the data. Named listeners receive only the data.
+*
+* @typeParam TEventMap - Record mapping event names to their payload types.
+*   Constrains `on()` and `emit()` to matching event/payload pairs.
+*/
+var Emitter = class Emitter {
+  constructor() {
+    _defineProperty(this, "listeners", /* @__PURE__ */new Map());
+  }
+  on(event, cb) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(cb);
+    return {
+      off: () => {
+        set.delete(cb);
+      }
+    };
+  }
+  /**
+  * Emit a named event, notifying wildcard listeners first, then named listeners.
+  *
+  * Wildcard listeners receive `(eventName, data)`; named listeners receive
+  * only `data`. The firing order (wildcards before named) is intentional —
+  * it lets relay listeners (like Fsm's bfsm proxy) observe all events
+  * before specific subscribers react.
+  */
+  emit(event, data) {
+    const wildcards = this.listeners.get("*");
+    if (wildcards) for (const cb of wildcards) cb(event, data);
+    const named = this.listeners.get(event);
+    if (named) for (const cb of named) cb(data);
+  }
+  /**
+  * Remove all listeners (named and wildcard).
+  *
+  * Existing `Subscription` objects remain valid — their `off()` closures
+  * hold a reference to the now-empty Set, so calling them is harmless.
+  * Called by `dispose()` to prevent memory retention after an FSM shuts down.
+  */
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+//#endregion
+//#region src/json-safe.ts
+/**
+* Thrown internally when the walk hits a value that can't survive a
+* serialization boundary. Callers catch this to attach FSM/input context
+* before re-throwing a fully descriptive error — see `path`/`label` below.
+*/
+var NonSerializableValueError = class extends Error {
+  constructor(path, label) {
+    super("non-serializable value at ".concat(path, " (").concat(label, ")"));
+    this.path = path;
+    this.label = label;
+  }
+};
+/**
+* Deep-clones `value`, throwing `NonSerializableValueError` the moment it
+* finds anything that isn't `null`, a boolean, a finite number, a string, a
+* plain array, or a plain object. `rootPath` seeds the path used in error
+* messages — e.g. `"args"` so a nested failure reads as `args[1].onComplete`.
+*
+* Cloning (rather than just validating) is what keeps a returned snapshot
+* from aliasing live FSM state: mutating the snapshot afterward — or the
+* original value passed into a deferred `handle()` call — can't reach back
+* into the FSM's internal deferred queue.
+*/
+const cloneJsonSafe = (value, rootPath) => {
+  return cloneNode(value, rootPath, /* @__PURE__ */new Set());
+};
+const cloneNode = (value, path, ancestors) => {
+  if (value === null) return null;
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      if (!Number.isFinite(value)) throw new NonSerializableValueError(path, describeNonFiniteNumber(value));
+      return value;
+    case "object":
+      return cloneObject(value, path, ancestors);
+    default:
+      throw new NonSerializableValueError(path, typeof value);
+  }
+};
+const cloneObject = (obj, path, ancestors) => {
+  var _obj$constructor$name, _obj$constructor;
+  if (ancestors.has(obj)) throw new NonSerializableValueError(path, "circular reference");
+  if (Array.isArray(obj)) {
+    if (obj.length !== Object.keys(obj).length) throw new NonSerializableValueError(path, "sparse array or array with non-index properties");
+    ancestors.add(obj);
+    const cloned = obj.map((item, i) => cloneNode(item, "".concat(path, "[").concat(i, "]"), ancestors));
+    ancestors.delete(obj);
+    return cloned;
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null) throw new NonSerializableValueError(path, (_obj$constructor$name = (_obj$constructor = obj.constructor) === null || _obj$constructor === void 0 ? void 0 : _obj$constructor.name) !== null && _obj$constructor$name !== void 0 ? _obj$constructor$name : "object");
+  ancestors.add(obj);
+  const cloned = {};
+  for (const key of Object.keys(obj)) {
+    const value = cloneNode(obj[key], "".concat(path, ".").concat(key), ancestors);
+    Object.defineProperty(cloned, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  ancestors.delete(obj);
+  return cloned;
+};
+const describeNonFiniteNumber = n => {
+  if (Number.isNaN(n)) return "NaN";
+  return n > 0 ? "Infinity" : "-Infinity";
+};
+/**
+* Deep-clones `value` WITHOUT validating it — unlike `cloneJsonSafe`, this
+* never throws. Plain objects/arrays are cloned recursively (so a caller
+* can't alias state back into whatever holds the result); anything else
+* (functions, `Date`/`Map`/class instances, symbols, non-finite numbers,
+* etc.) is passed through by reference as-is.
+*
+* This is `rehydrate()`'s side of the aliasing guarantee: `dehydrate()`
+* validates-and-clones on the way OUT (via `cloneJsonSafe`), but `rehydrate()`
+* trusts the snapshot it's given is already valid data — re-validating on
+* the way IN would be a redundant, unwanted asymmetry (see the build plan's
+* disclosed known gaps). We still need the clone so mutating the caller's
+* snapshot object after `rehydrate()` returns can't reach into the live
+* FSM's internal deferred queue.
+*
+* Cycle-safe: a value that contains itself is returned as-is (by reference)
+* rather than cloned infinitely — there's no validation step here to make
+* that throw, so silently keeping the shared reference is the only option
+* that doesn't hang.
+*/
+const cloneDeep = function (value) {
+  let ancestors = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : /* @__PURE__ */new Set();
+  if (value === null || typeof value !== "object") return value;
+  if (ancestors.has(value)) return value;
+  if (Array.isArray(value)) {
+    ancestors.add(value);
+    const cloned = value.map(item => cloneDeep(item, ancestors));
+    ancestors.delete(value);
+    return cloned;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  ancestors.add(value);
+  const cloned = {};
+  for (const key of Object.keys(value)) {
+    const clonedValue = cloneDeep(value[key], ancestors);
+    Object.defineProperty(cloned, key, {
+      value: clonedValue,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  ancestors.delete(value);
+  return cloned;
+};
+
+//#endregion
+//#region src/types.ts
+/**
+* Symbol used as a property key to identify machina FSM instances at runtime.
+* Each class stamps itself with a MachinaType value so the ChildLink adapter
+* can dispatch handle()/canHandle()/reset() correctly without circular imports.
+*/
+const MACHINA_TYPE = Symbol("machina.type");
+
+//#endregion
+//#region src/behavioral-fsm.ts
+const MAX_TRANSITION_DEPTH = 20;
+/**
+* Defines FSM behavior (states + transitions) while tracking per-client state
+* in a `WeakMap`. A single `BehavioralFsm` instance can drive any number of
+* independent client objects simultaneously — each gets its own state,
+* deferred queue, and lifecycle.
+*
+* Prefer `createBehavioralFsm()` over constructing this directly — the factory
+* infers all generic parameters from the config object.
+*
+* All public methods silently no-op after `dispose()` is called.
+*
+* @typeParam TClient - The client object type. Must be an object (non-primitive)
+*   so it can serve as a WeakMap key.
+* @typeParam TStateNames - String literal union of valid state names.
+* @typeParam TInputNames - String literal union of valid input names.
+* @typeParam TBubbles - String literal union of inputs this FSM declares via
+*   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
+*   a constructed instance; nothing at runtime reads this generic.
+*/
+var BehavioralFsm = class BehavioralFsm {
+  constructor(config) {
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "initialState", void 0);
+    _defineProperty(this, MACHINA_TYPE, "BehavioralFsm");
+    _defineProperty(this, "states", void 0);
+    _defineProperty(this, "emitter", new Emitter());
+    _defineProperty(this, "clients", /* @__PURE__ */new WeakMap());
+    _defineProperty(this, "knownClients", /* @__PURE__ */new Set());
+    _defineProperty(this, "childSubscriptions", []);
+    _defineProperty(this, "disposed", false);
+    _defineProperty(this, "transitionDepth", 0);
+    this.id = config.id;
+    this.initialState = config.initialState;
+    this.states = config.states;
+    this.wrapChildLinks();
+    this.setupChildSubscriptions();
+  }
+  /**
+  * Dispatch an input to the given client's current state handler.
+  *
+  * Delegation order: if the current state has a `_child` FSM that can
+  * handle the input, it is dispatched there. If the child emits `nohandler`,
+  * the input bubbles up to this FSM's local handler. If no handler exists
+  * here either, `nohandler` is emitted on this FSM's emitter.
+  *
+  * No-ops silently when disposed.
+  */
+  handle(client, inputName) {
+    var _this$states$meta$sta;
+    if (this.disposed) return;
+    const meta = this.getOrCreateClientMeta(client);
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    meta.currentActionArgs = args;
+    const childLink = (_this$states$meta$sta = this.states[meta.state]) === null || _this$states$meta$sta === void 0 ? void 0 : _this$states$meta$sta._child;
+    if (childLink) {
+      if (childLink.canHandle(client, inputName)) {
+        try {
+          childLink.handle(client, inputName, ...args);
+        } finally {
+          meta.currentActionArgs = void 0;
+        }
+        return;
+      }
+    }
+    this.handleLocally(client, inputName, args, meta);
+  }
+  /**
+  * Returns true if the client's current state has a handler for `inputName`
+  * (or a catch-all `"*"` handler), or if the current state's `_child` chain
+  * can handle it — the check recurses to the same depth `handle()`'s
+  * delegation can actually reach, so a grandchild-only input answers true
+  * from the root. Does NOT initialize the client — no `_onEnter`, no
+  * events, no side effects. Unseen clients are treated as if they were
+  * already in `initialState`. Returns false when disposed.
+  */
+  canHandle(client, inputName) {
+    var _this$clients$get$sta, _this$clients$get, _stateObj$inputName;
+    if (this.disposed) return false;
+    const state = (_this$clients$get$sta = (_this$clients$get = this.clients.get(client)) === null || _this$clients$get === void 0 ? void 0 : _this$clients$get.state) !== null && _this$clients$get$sta !== void 0 ? _this$clients$get$sta : this.initialState;
+    const stateObj = this.states[state];
+    if ((_stateObj$inputName = stateObj === null || stateObj === void 0 ? void 0 : stateObj[inputName]) !== null && _stateObj$inputName !== void 0 ? _stateObj$inputName : stateObj === null || stateObj === void 0 ? void 0 : stateObj["*"]) return true;
+    const childLink = stateObj === null || stateObj === void 0 ? void 0 : stateObj._child;
+    return childLink ? childLink.canHandle(client, inputName) : false;
+  }
+  /**
+  * Transition the client back to `initialState`, firing `_onEnter` and
+  * lifecycle events as if entering it fresh. No-ops when disposed.
+  */
+  reset(client) {
+    if (this.disposed) return;
+    this.transition(client, this.initialState);
+  }
+  /**
+  * Returns the client's current state, or `undefined` if the client has
+  * never been initialized (i.e. `handle()`, `transition()`, or `reset()`
+  * have never been called for it). Does NOT trigger initialization.
+  */
+  currentState(client) {
+    var _this$clients$get2;
+    return (_this$clients$get2 = this.clients.get(client)) === null || _this$clients$get2 === void 0 ? void 0 : _this$clients$get2.state;
+  }
+  /**
+  * Directly transition `client` to `toState`, running the full lifecycle:
+  * `_onExit` for the current state → `transitioning` event → update state →
+  * `_onEnter` for new state → `transitioned` event → child reset → deferred
+  * queue replay → bounce (if `_onEnter` returned a state name).
+  *
+  * Same-state transitions are silently ignored. Transitions to unknown state
+  * names emit `invalidstate` instead of throwing. Throws if the transition
+  * depth exceeds `MAX_TRANSITION_DEPTH` (likely an `_onEnter` → transition loop).
+  *
+  * No-ops when disposed.
+  */
+  transition(client, toState) {
+    if (this.disposed) return;
+    const meta = this.getOrCreateClientMeta(client);
+    const fromState = meta.state;
+    if (toState === fromState) return;
+    if (!Object.hasOwn(this.states, toState)) {
+      this.emitter.emit("invalidstate", {
+        stateName: toState,
+        client
+      });
+      return;
+    }
+    this.transitionDepth++;
+    if (this.transitionDepth > MAX_TRANSITION_DEPTH) {
+      this.transitionDepth = 0;
+      throw new Error("Max transition depth (".concat(MAX_TRANSITION_DEPTH, ") exceeded in FSM \"").concat(this.id, "\". Likely an infinite _onEnter \u2192 transition loop."));
+    }
+    try {
+      const curStateObj = this.states[fromState];
+      const newStateObj = this.states[toState];
+      if (curStateObj !== null && curStateObj !== void 0 && curStateObj._onExit && typeof curStateObj._onExit === "function") {
+        const exitArgs = this.buildHandlerArgs(client, "", meta);
+        curStateObj._onExit(exitArgs);
+      }
+      meta.state = toState;
+      const payload = {
+        fromState,
+        toState,
+        client
+      };
+      this.emitter.emit("transitioning", payload);
+      let bounceTarget = void 0;
+      if (newStateObj !== null && newStateObj !== void 0 && newStateObj._onEnter && typeof newStateObj._onEnter === "function") {
+        const enterArgs = this.buildHandlerArgs(client, "", meta);
+        bounceTarget = newStateObj._onEnter(enterArgs);
+      }
+      this.emitter.emit("transitioned", payload);
+      const childLink = newStateObj === null || newStateObj === void 0 ? void 0 : newStateObj._child;
+      if (childLink) childLink.reset(client);
+      this.processQueue(client, meta);
+      if (typeof bounceTarget === "string" && meta.state === toState) this.transition(client, bounceTarget);
+    } finally {
+      this.transitionDepth--;
+    }
+  }
+  /**
+  * Returns the client's state as a dot-delimited path including any active
+  * child FSM states (e.g. `"active.connecting.retrying"`). Returns just the
+  * current state name when no child is active. Returns `""` for clients that
+  * have never been initialized (unlike `currentState()` which returns `undefined`).
+  */
+  compositeState(client) {
+    var _this$states$meta$sta2;
+    const meta = this.clients.get(client);
+    if (!meta) return "";
+    const childLink = (_this$states$meta$sta2 = this.states[meta.state]) === null || _this$states$meta$sta2 === void 0 ? void 0 : _this$states$meta$sta2._child;
+    if (childLink) {
+      const childComposite = childLink.compositeState(client);
+      if (childComposite) return "".concat(meta.state, ".").concat(childComposite);
+    }
+    return meta.state;
+  }
+  rehydrate(client, input) {
+    if (this.disposed) return;
+    if (typeof input === "string") {
+      this.rehydrateCompositePath(client, input);
+      return;
+    }
+    const writes = this.planSnapshotWrites(client, input);
+    for (const write of writes) write();
+  }
+  /**
+  * Snapshot everything machina tracks for `client`: current state, pending
+  * deferred inputs, and — recursively — the same for every `_child` that has
+  * ever seen this client, active or not. Feed the result to the object form
+  * of `rehydrate()` to restore it later, deferrals included.
+  *
+  * Returns `undefined` for a client this FSM has never seen (mirrors
+  * `currentState()`) — the call does NOT trigger initialization.
+  *
+  * Throws if any deferred input's args contain a non-serializable value
+  * (function, undefined, symbol, bigint, non-finite number, Date/Map/class
+  * instance, or a circular reference) — naming the input, its `until` target
+  * if any, the FSM id, and the exact value path. Throws for an Fsm child
+  * that's on `client`'s active path *relative to the true root* (consistent
+  * with `rehydrate()`'s conditional throw) — an Fsm owns its own context, so
+  * there's nothing per-client to snapshot. An Fsm child declared at a state
+  * `client` never visited, OR nested under a `BehavioralFsm` child that is
+  * itself off-path from the root, is skipped rather than throwing — neither
+  * has any per-client state to lose, so one Fsm child anywhere in the
+  * hierarchy doesn't disable `dehydrate()` for clients that never reach that
+  * branch, no matter how deeply nested the Fsm child is.
+  *
+  * Meant for clients at rest between `handle()` calls — `currentActionArgs`
+  * (the in-flight args mid-handler) has no meaning here and is excluded.
+  *
+  * @param isOnActivePath - @internal Whether this FSM itself is currently
+  * reachable from the true root's active path. Defaults to `true` for the
+  * public entry point (this FSM IS the root from its own perspective); the
+  * `ChildLink` adapter passes `false` down when recursing into a nested
+  * `BehavioralFsm` child that is itself off-path, so that child's own
+  * Fsm-child checks don't recompute reachability from its dormant local
+  * state alone.
+  */
+  dehydrate(client) {
+    let isOnActivePath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    const meta = this.clients.get(client);
+    if (!meta) return;
+    const snapshot = {
+      state: meta.state,
+      deferred: meta.deferredQueue.map(item => this.snapshotDeferredInput(item))
+    };
+    const children = this.collectChildSnapshots(client, meta.state, isOnActivePath);
+    if (children) snapshot.children = children;
+    return snapshot;
+  }
+  /**
+  * @internal
+  * Validates `snapshot` against this level's state graph and recurses into
+  * every declared child, returning write thunks to run only once the WHOLE
+  * tree — every level — validates successfully. Nothing is written here.
+  * Called by the object-form of `rehydrate()` and, recursively, by ChildLink
+  * so a nested BehavioralFsm participates in the same validate-then-write
+  * pass. Not part of the public persistence API — call `rehydrate()` instead.
+  */
+  planSnapshotWrites(client, snapshot) {
+    if (this.disposed) return [];
+    const state = snapshot.state,
+      deferred = snapshot.deferred,
+      children = snapshot.children;
+    if (!Object.hasOwn(this.states, state)) throw new Error("rehydrate: unknown state \"".concat(state, "\" in FSM \"").concat(this.id, "\". Valid states: ").concat(Object.keys(this.states).join(", ")));
+    const writes = [];
+    if (children) for (const stateName of Object.keys(children)) {
+      var _this$states$stateNam;
+      if (!Object.hasOwn(this.states, stateName)) throw new Error("rehydrate: unknown state \"".concat(stateName, "\" in FSM \"").concat(this.id, "\" referenced by snapshot.children."));
+      const childLink = (_this$states$stateNam = this.states[stateName]) === null || _this$states$stateNam === void 0 ? void 0 : _this$states$stateNam._child;
+      if (!childLink) throw new Error("rehydrate: state \"".concat(stateName, "\" in FSM \"").concat(this.id, "\" has no _child, but the snapshot has a children[\"").concat(stateName, "\"] entry."));
+      writes.push(...childLink.planRehydrate(client, children[stateName]));
+    }
+    const deferredQueue = deferred.map(item => _objectSpread2({
+      inputName: item.inputName,
+      args: cloneDeep(item.args)
+    }, item.untilState !== void 0 ? {
+      untilState: item.untilState
+    } : {}));
+    writes.push(() => {
+      if (!this.clients.has(client)) this.knownClients.add(new WeakRef(client));
+      this.clients.set(client, {
+        state,
+        deferredQueue
+      });
+    });
+    return writes;
+  }
+  rehydrateCompositePath(client, compositeState) {
+    const _compositeState$split = compositeState.split("."),
+      _compositeState$split2 = _toArray(_compositeState$split),
+      state = _compositeState$split2[0],
+      rest = _arrayLikeToArray(_compositeState$split2).slice(1);
+    if (!Object.hasOwn(this.states, state)) throw new Error("rehydrate: unknown state \"".concat(state, "\" in FSM \"").concat(this.id, "\". Valid states: ").concat(Object.keys(this.states).join(", ")));
+    if (rest.length > 0) {
+      var _this$states$state;
+      const childPath = rest.join(".");
+      const childLink = (_this$states$state = this.states[state]) === null || _this$states$state === void 0 ? void 0 : _this$states$state._child;
+      if (!childLink) throw new Error("rehydrate: state \"".concat(state, "\" in FSM \"").concat(this.id, "\" has no _child, but composite path \"").concat(compositeState, "\" requires one."));
+      childLink.rehydrate(client, childPath);
+    }
+    if (!this.clients.has(client)) this.knownClients.add(new WeakRef(client));
+    this.clients.set(client, {
+      state,
+      deferredQueue: []
+    });
+  }
+  /**
+  * Walks every declared state's `_child`, dehydrating each one that has ever
+  * seen `client`. The same child instance can be declared under multiple
+  * state names (shared child) — it's dehydrated once and the result is
+  * reused under every declaring state name, matching how the engine already
+  * treats shared children elsewhere (dispose, event subscriptions).
+  *
+  * Declaring names are grouped by `childLink.instance` (the actual FSM
+  * instance, not the `ChildLink` wrapper — `wrapChildLinks()` mints a fresh
+  * wrapper per declaring state, so grouping by wrapper would never hit for a
+  * shared child) BEFORE any `onPath` is computed or any child is dehydrated.
+  * A shared child's `onPath` is the OR of `stateName === activeState` across
+  * every declaring name in its group: at most one declaring name can ever
+  * equal `activeState`, so this combined flag is correct and, critically,
+  * independent of `Object.keys(this.states)` iteration order — computing
+  * `onPath` per-declaring-name and caching whichever one happened to run
+  * first would silently launder an on-path client's Fsm-child throw through
+  * an unrelated off-path declaring name.
+  *
+  * An off-path Fsm child (declared only at states other than `activeState`,
+  * OR nested anywhere under a `BehavioralFsm` child that is itself off-path
+  * relative to the true root) is skipped entirely rather than dehydrated:
+  * Fsm state isn't tracked per-client to begin with, so an off-path Fsm
+  * child has nothing to lose by being skipped — unlike a BehavioralFsm
+  * child's off-path meta, which is real per-client data. `isOnActivePath`
+  * is the inherited "am I even reachable from the root" flag; combining it
+  * with the group's `stateNames.includes(activeState)` check (rather than
+  * using that check alone) is what keeps a nested Fsm grandchild from
+  * throwing when its immediate BehavioralFsm parent is itself off-path —
+  * the parent's own dormant `activeState` is irrelevant once the parent
+  * isn't reachable. This keeps one Fsm child anywhere in the hierarchy from
+  * disabling `dehydrate()` for every client, only for clients actually on
+  * that branch.
+  */
+  collectChildSnapshots(client, activeState, isOnActivePath) {
+    const declaringNamesByInstance = /* @__PURE__ */new Map();
+    for (const stateName of Object.keys(this.states)) {
+      var _this$states$stateNam2;
+      const childLink = (_this$states$stateNam2 = this.states[stateName]) === null || _this$states$stateNam2 === void 0 ? void 0 : _this$states$stateNam2._child;
+      if (!childLink) continue;
+      const entry = declaringNamesByInstance.get(childLink.instance);
+      if (entry) entry.stateNames.push(stateName);else declaringNamesByInstance.set(childLink.instance, {
+        childLink,
+        stateNames: [stateName]
+      });
+    }
+    let children;
+    for (const _ref of declaringNamesByInstance.values()) {
+      const childLink = _ref.childLink;
+      const stateNames = _ref.stateNames;
+      const onPath = isOnActivePath && stateNames.includes(activeState);
+      if (childLink.instance[MACHINA_TYPE] === "Fsm" && !onPath) continue;
+      const childSnapshot = childLink.dehydrate(client, onPath);
+      if (childSnapshot) {
+        children !== null && children !== void 0 ? children : children = {};
+        for (const stateName of stateNames) children[stateName] = childSnapshot;
+      }
+    }
+    return children;
+  }
+  snapshotDeferredInput(item) {
+    let clonedArgs;
+    try {
+      clonedArgs = cloneJsonSafe(item.args, "args");
+    } catch (err) {
+      if (!(err instanceof NonSerializableValueError)) throw err;
+      const untilPart = item.untilState ? " (until \"".concat(item.untilState, "\")") : "";
+      throw new Error("dehydrate: deferred input \"".concat(item.inputName, "\"").concat(untilPart, " in FSM \"").concat(this.id, "\" has a non-serializable value at ").concat(err.path, " (").concat(err.label, ")"));
+    }
+    const snapshot = {
+      inputName: item.inputName,
+      args: clonedArgs
+    };
+    if (item.untilState !== void 0) snapshot.untilState = item.untilState;
+    return snapshot;
+  }
+  on(eventName, callback) {
+    if (this.disposed) return {
+      off() {}
+    };
+    return this.emitter.on(eventName, callback);
+  }
+  /**
+  * Emit a custom event through the FSM. Built-in lifecycle events are
+  * emitted automatically — this is for user-defined events from handlers.
+  * No-ops when disposed.
+  */
+  emit(eventName, data) {
+    if (this.disposed) return;
+    this.emitter.emit(eventName, data);
+  }
+  /**
+  * Permanently shut down this FSM. Irreversible — all subsequent method
+  * calls become silent no-ops. Tears down child subscriptions, clears all
+  * listeners, and cascades disposal to child FSMs (unless `preserveChildren`
+  * is set). The same child appearing in multiple states is disposed once.
+  */
+  dispose(options) {
+    this.disposed = true;
+    for (const sub of this.childSubscriptions) sub.off();
+    if (!(options !== null && options !== void 0 && options.preserveChildren)) {
+      const seen = /* @__PURE__ */new Set();
+      for (const stateName of Object.keys(this.states)) {
+        var _this$states$stateNam3;
+        const childLink = (_this$states$stateNam3 = this.states[stateName]) === null || _this$states$stateNam3 === void 0 ? void 0 : _this$states$stateNam3._child;
+        if (childLink && !seen.has(childLink.instance)) {
+          seen.add(childLink.instance);
+          childLink.dispose();
+        }
+      }
+    }
+    this.emitter.clear();
+  }
+  /**
+  * Walks all states at construction time, detects raw FSM instances assigned
+  * to _child, and wraps them into ChildLink adapters via createChildLink().
+  * Must run BEFORE setupChildSubscriptions() so the subscriptions see
+  * ChildLink objects, not raw FSM instances.
+  */
+  wrapChildLinks() {
+    for (const stateName of Object.keys(this.states)) {
+      const stateObj = this.states[stateName];
+      const rawChild = stateObj === null || stateObj === void 0 ? void 0 : stateObj._child;
+      if (!rawChild) continue;
+      if (typeof rawChild !== "object") throw new Error("State \"".concat(stateName, "\"._child: expected an Fsm or BehavioralFsm instance, got ").concat(String(rawChild)));
+      if (!(MACHINA_TYPE in rawChild)) throw new Error("State \"".concat(stateName, "\"._child: expected an Fsm or BehavioralFsm instance, got a plain object"));
+      stateObj._child = createChildLink(rawChild);
+    }
+  }
+  /**
+  * Walks all states at construction time, finds states with _child, and
+  * subscribes once to each unique child's wildcard events. Subscriptions are
+  * stored for cleanup in dispose(). We deduplicate by `childLink.instance`
+  * (the underlying Fsm/BehavioralFsm instance), not the `ChildLink` wrapper —
+  * `wrapChildLinks()` mints a fresh wrapper per declaring state, so a child
+  * shared across states would otherwise get one subscription PER declaring
+  * state, each independently walking known clients and relaying events. That
+  * silently double-fires client-less relays (Fsm-child events, or a
+  * BehavioralFsm child's custom `emit()` with no `client` in the payload)
+  * whenever two different clients are active on two different declaring
+  * names at once — the same wrapper-vs-instance identity bug
+  * `collectChildSnapshots()` had before its #184 fix.
+  */
+  setupChildSubscriptions() {
+    const seenInstances = /* @__PURE__ */new Set();
+    for (const stateName of Object.keys(this.states)) {
+      var _this$states$stateNam4;
+      const childLink = (_this$states$stateNam4 = this.states[stateName]) === null || _this$states$stateNam4 === void 0 ? void 0 : _this$states$stateNam4._child;
+      if (!childLink || seenInstances.has(childLink.instance)) continue;
+      seenInstances.add(childLink.instance);
+      const sub = childLink.onAny((eventName, data) => {
+        if (eventName === "nohandler") {
+          var _payload$args;
+          const payload = data;
+          if (payload.client !== void 0) this.bubbleNohandler(payload.client, childLink, payload.inputName, (_payload$args = payload.args) !== null && _payload$args !== void 0 ? _payload$args : []);else for (const ref of this.knownClients) {
+            var _payload$args2;
+            const client = ref.deref();
+            if (client === void 0) {
+              this.knownClients.delete(ref);
+              continue;
+            }
+            this.bubbleNohandler(client, childLink, payload.inputName, (_payload$args2 = payload.args) !== null && _payload$args2 !== void 0 ? _payload$args2 : []);
+          }
+          return;
+        }
+        const payload = data;
+        if (payload && typeof payload === "object" && "client" in payload) {
+          if (this.isChildActiveForClient(payload.client, childLink)) this.emitter.emit(eventName, data);
+        } else for (const ref of this.knownClients) {
+          const client = ref.deref();
+          if (!client) {
+            this.knownClients.delete(ref);
+            continue;
+          }
+          if (this.isChildActiveForClient(client, childLink)) {
+            this.emitter.emit(eventName, data);
+            break;
+          }
+        }
+      });
+      this.childSubscriptions.push(sub);
+    }
+  }
+  /**
+  * Bubbles a child nohandler to the parent for the given client.
+  * Only fires if the client is currently in a state that has this childLink.
+  * Extracted from the lambda in setupChildSubscriptions to keep it readable.
+  */
+  bubbleNohandler(client, childLink, inputName, args) {
+    if (!this.isChildActiveForClient(client, childLink)) return;
+    const meta = this.clients.get(client);
+    meta.currentActionArgs = args;
+    this.handleLocally(client, inputName, args, meta);
+  }
+  /**
+  * Returns true if the given client is currently in a parent state whose
+  * _child resolves to the same underlying instance as childLink. Returns
+  * false if the client has no meta (never initialized) or is in a state
+  * with a different (or no) child.
+  *
+  * Compares `.instance`, not the `ChildLink` wrapper itself — setupChildSubscriptions()
+  * dedupes subscriptions by instance and keeps only ONE representative wrapper
+  * per shared child, so the client's actual active declaring state may hold a
+  * DIFFERENT wrapper for that same instance (wrapChildLinks() mints one per
+  * declaring state). Comparing wrappers directly would only ever match the one
+  * declaring state whose wrapper happened to be kept for the subscription,
+  * silently breaking relay for every other declaring name of a shared child.
+  */
+  isChildActiveForClient(client, childLink) {
+    var _this$states$meta$sta3;
+    const meta = this.clients.get(client);
+    if (!meta) return false;
+    return ((_this$states$meta$sta3 = this.states[meta.state]) === null || _this$states$meta$sta3 === void 0 || (_this$states$meta$sta3 = _this$states$meta$sta3._child) === null || _this$states$meta$sta3 === void 0 ? void 0 : _this$states$meta$sta3.instance) === childLink.instance;
+  }
+  /**
+  * The inner handler dispatch — no delegation, no initialization side effects
+  * beyond what getOrCreateClientMeta already did. Called by handle() after
+  * the delegation check, and by the nohandler child listener for bubbling.
+  */
+  handleLocally(client, inputName, args, meta) {
+    var _stateObj$inputName2;
+    const stateObj = this.states[meta.state];
+    const handler = (_stateObj$inputName2 = stateObj === null || stateObj === void 0 ? void 0 : stateObj[inputName]) !== null && _stateObj$inputName2 !== void 0 ? _stateObj$inputName2 : stateObj === null || stateObj === void 0 ? void 0 : stateObj["*"];
+    if (!handler) {
+      this.emitter.emit("nohandler", {
+        inputName,
+        args,
+        client
+      });
+      meta.currentActionArgs = void 0;
+      return;
+    }
+    try {
+      this.emitter.emit("handling", {
+        inputName,
+        client
+      });
+      const handlerArgs = this.buildHandlerArgs(client, inputName, meta);
+      let targetState = void 0;
+      if (typeof handler === "string") targetState = handler;else if (typeof handler === "function") targetState = handler(handlerArgs, ...args);
+      this.emitter.emit("handled", {
+        inputName,
+        client
+      });
+      if (typeof targetState === "string") this.transition(client, targetState);
+    } finally {
+      meta.currentActionArgs = void 0;
+    }
+  }
+  getOrCreateClientMeta(client) {
+    let meta = this.clients.get(client);
+    if (meta) return meta;
+    meta = {
+      state: void 0,
+      deferredQueue: []
+    };
+    this.clients.set(client, meta);
+    this.knownClients.add(new WeakRef(client));
+    this.transition(client, this.initialState);
+    return meta;
+  }
+  buildHandlerArgs(client, inputName, meta) {
+    return {
+      ctx: client,
+      inputName,
+      defer: opts => {
+        if (!meta.currentActionArgs) return;
+        const deferred = {
+          inputName,
+          args: [...meta.currentActionArgs],
+          untilState: opts === null || opts === void 0 ? void 0 : opts.until
+        };
+        meta.deferredQueue.push(deferred);
+        this.emitter.emit("deferred", {
+          inputName,
+          client
+        });
+      },
+      emit: (evtName, evtData) => {
+        this.emitter.emit(evtName, evtData);
+      }
+    };
+  }
+  processQueue(client, meta) {
+    const toReplay = [];
+    const remaining = [];
+    for (const item of meta.deferredQueue) if (item.untilState === void 0 || item.untilState === meta.state) toReplay.push(item);else remaining.push(item);
+    meta.deferredQueue = remaining;
+    for (const item of toReplay) this.handle(client, item.inputName, ...item.args);
+  }
+};
+/**
+* Internal factory called by `wrapChildLinks()` during construction.
+* Wraps a raw Fsm or BehavioralFsm instance in a uniform `ChildLink` adapter
+* so the parent engine doesn't need to know which type it's talking to.
+*
+* Users never call this directly — they assign an FSM instance to `_child`
+* in their state config and `wrapChildLinks()` handles the wrapping.
+*/
+function createChildLink(child) {
+  if (!child || typeof child !== "object") throw new Error("createChildLink: expected an Fsm or BehavioralFsm instance, got ".concat(String(child)));
+  const childType = child[MACHINA_TYPE];
+  if (childType === "BehavioralFsm") return {
+    instance: child,
+    canHandle(client, inputName) {
+      return child.canHandle(client, inputName);
+    },
+    handle(client, inputName) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      child.handle(client, inputName, ...args);
+    },
+    reset(client) {
+      child.transition(client, child.initialState);
+    },
+    onAny(callback) {
+      return child.on("*", callback);
+    },
+    compositeState(client) {
+      return child.compositeState(client);
+    },
+    rehydrate(client, compositeState) {
+      child.rehydrate(client, compositeState);
+    },
+    dehydrate(client, isOnActivePath) {
+      return child.dehydrate(client, isOnActivePath);
+    },
+    planRehydrate(client, snapshot) {
+      return child.planSnapshotWrites(client, snapshot);
+    },
+    dispose() {
+      child.dispose();
+    }
+  };
+  if (childType === "Fsm") return {
+    instance: child,
+    canHandle(_client, inputName) {
+      return child.canHandle(inputName);
+    },
+    handle(_client, inputName) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+        args[_key3 - 2] = arguments[_key3];
+      }
+      child.handle(inputName, ...args);
+    },
+    reset(_client) {
+      child.reset();
+    },
+    onAny(callback) {
+      return child.on("*", callback);
+    },
+    compositeState(_client) {
+      return child.compositeState();
+    },
+    rehydrate(_client, _compositeState) {
+      throw new Error("rehydrate: cannot rehydrate an Fsm child. Fsm owns its own context; rehydrate is only valid for BehavioralFsm hierarchies.");
+    },
+    dehydrate(_client, _isOnActivePath) {
+      throw new Error("dehydrate: cannot dehydrate an Fsm child. Fsm owns its own context; dehydrate is only valid for BehavioralFsm hierarchies.");
+    },
+    planRehydrate(_client, _snapshot) {
+      throw new Error("rehydrate: cannot rehydrate an Fsm child. Fsm owns its own context; rehydrate is only valid for BehavioralFsm hierarchies.");
+    },
+    dispose() {
+      child.dispose();
+    }
+  };
+  throw new Error("createChildLink: expected an Fsm or BehavioralFsm instance, got [MACHINA_TYPE] = ".concat(String(childType !== null && childType !== void 0 ? childType : "undefined")));
+}
+
+//#endregion
+//#region src/fsm.ts
+/**
+* Single-client FSM. Wraps a BehavioralFsm and uses the config's `context`
+* object as the implicit client, so callers never pass a client argument.
+*
+* Prefer `createFsm()` over constructing this directly — the factory infers
+* all generic parameters from the config object.
+*
+* All public methods silently no-op after `dispose()` is called.
+*
+* @typeParam TCtx - The context type, inferred from `config.context`.
+* @typeParam TStateNames - String literal union of valid state names.
+* @typeParam TInputNames - String literal union of valid input names.
+* @typeParam TBubbles - String literal union of inputs this FSM declares via
+*   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
+*   a constructed instance; nothing at runtime reads this generic.
+*/
+var Fsm = class Fsm {
+  constructor(config) {
+    var _config$context;
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "initialState", void 0);
+    _defineProperty(this, MACHINA_TYPE, "Fsm");
+    _defineProperty(this, "states", void 0);
+    _defineProperty(this, "bfsm", void 0);
+    _defineProperty(this, "context", void 0);
+    _defineProperty(this, "emitter", new Emitter());
+    _defineProperty(this, "disposed", false);
+    this.id = config.id;
+    this.initialState = config.initialState;
+    this.context = (_config$context = config.context) !== null && _config$context !== void 0 ? _config$context : {};
+    this.bfsm = new BehavioralFsm(config);
+    this.states = config.states;
+    this.bfsm.on("*", (eventName, data) => {
+      if (data && typeof data === "object" && "client" in data) {
+        data.client;
+          const payload = _objectWithoutProperties(data, _excluded);
+        this.emitter.emit(eventName, payload);
+      } else this.emitter.emit(eventName, data);
+    });
+    this.bfsm.transition(this.context, config.initialState);
+  }
+  /**
+  * Dispatch an input to the current state's handler.
+  * If a `_child` FSM in the current state can handle it, delegation occurs
+  * there first; unhandled inputs bubble up to the parent.
+  * No-ops silently when disposed.
+  */
+  handle(inputName) {
+    if (this.disposed) return;
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+    this.bfsm.handle(this.context, inputName, ...args);
+  }
+  /**
+  * Returns true if the current state has a handler for `inputName`
+  * (or a catch-all `"*"` handler), or if the current state's `_child`
+  * chain can handle it (checked recursively, matching `handle()`'s
+  * delegation reach). Does not trigger initialization or any side
+  * effects. Returns false when disposed.
+  */
+  canHandle(inputName) {
+    if (this.disposed) return false;
+    return this.bfsm.canHandle(this.context, inputName);
+  }
+  /**
+  * Transition back to `initialState`, firing `_onEnter` and lifecycle
+  * events as if entering it fresh. No-ops silently when disposed.
+  */
+  reset() {
+    if (this.disposed) return;
+    this.bfsm.reset(this.context);
+  }
+  /**
+  * Returns the current state name. Always defined — Fsm eagerly
+  * initializes into `initialState` during construction.
+  */
+  currentState() {
+    return this.bfsm.currentState(this.context);
+  }
+  /**
+  * Directly transition to `toState`, firing `_onExit`, `_onEnter`, and
+  * lifecycle events. Same-state transitions are silently ignored.
+  * No-ops when disposed.
+  */
+  transition(toState) {
+    if (this.disposed) return;
+    this.bfsm.transition(this.context, toState);
+  }
+  /**
+  * Returns the current state as a dot-delimited path that includes
+  * any active child FSM states (e.g. `"active.connecting.retrying"`).
+  * Returns just the current state name when no child is active.
+  */
+  compositeState() {
+    return this.bfsm.compositeState(this.context);
+  }
+  on(eventName, callback) {
+    if (this.disposed) return {
+      off() {}
+    };
+    return this.emitter.on(eventName, callback);
+  }
+  /**
+  * Emit a custom event through the FSM. Built-in lifecycle events are
+  * emitted automatically — this is for user-defined events from handlers.
+  * Routes through the BehavioralFsm so all relay paths are consistent.
+  * No-ops when disposed.
+  */
+  emit(eventName, data) {
+    if (this.disposed) return;
+    this.bfsm.emit(eventName, data);
+  }
+  /**
+  * Permanently shut down this FSM. Irreversible — all subsequent method
+  * calls become silent no-ops. Clears all listeners and cascades disposal
+  * to child FSMs (unless `preserveChildren` is set).
+  */
+  dispose(options) {
+    this.disposed = true;
+    this.bfsm.dispose(options);
+    this.emitter.clear();
+  }
+};
+/**
+* Create a single-client FSM from a config object.
+*
+* Generic parameters are inferred automatically:
+* - `TCtx` comes from `config.context` (defaults to `{}` if omitted).
+* - `TStates` is captured with `const` inference to preserve string literal
+*   types, enabling compile-time validation of transition targets and `handle()`
+*   input names.
+*
+* State names, input names, and all handler signatures derive from `TStates`.
+*
+* @example
+* ```ts
+* const light = createFsm({
+*   id: "traffic-light",
+*   initialState: "green",
+*   context: { tickCount: 0 },
+*   states: {
+*     green:  { timeout: "yellow" },
+*     yellow: { timeout: "red" },
+*     red:    { timeout: "green" },
+*   },
+* });
+*
+* light.handle("timeout"); // transitions green → yellow
+* ```
+*/
+function createFsm(config) {
+  return new Fsm(config);
+}/**
+ * Declares a handler for one input, restoring the payload typing that machina's `...unknown[]`
+ * handler arguments give up.
+ */
+function on(handler) {
+  return handler;
+}
+/**
+ * Whether a transport-originated input belongs to the attempt that currently owns the session.
+ * Inputs from a superseded attempt are dropped: its transport is already being replaced, so it can
+ * neither declare the session live nor take it down.
+ */
+function isCurrentAttempt(ctx, event) {
+  return event.attemptId === ctx.attemptId;
+}
+const attemptEstablished = on((_ref, event) => {
+  let ctx = _ref.ctx;
+  if (!isCurrentAttempt(ctx, event)) {
+    return;
+  }
+  return 'connected';
+});
+const startConnect = on(_ref2 => {
+  let ctx = _ref2.ctx;
+  ctx.attemptId += 1;
+  ctx.lastError = undefined;
+  return 'connecting';
+});
+const startReconnect = on(_ref3 => {
+  let ctx = _ref3.ctx;
+  ctx.attemptId += 1;
+  ctx.lastError = undefined;
+  return 'reconnecting';
+});
+const requestClose = on((_ref4, event) => {
+  let ctx = _ref4.ctx;
+  ctx.closeReason = event.reason;
+  return 'disconnecting';
+});
+const signalStates = {
+  new: {
+    connect: startConnect,
+    close: requestClose
+  },
+  connecting: {
+    connectComplete: attemptEstablished,
+    // An initial connect has no session to fall back on, so failure is terminal.
+    connectFailed: on((_ref5, event) => {
+      let ctx = _ref5.ctx;
+      ctx.lastError = event.error;
+      return 'closed';
+    }),
+    close: requestClose
+  },
+  connected: {
+    reconnect: startReconnect,
+    transportFailed: on((_ref6, event) => {
+      let ctx = _ref6.ctx;
+      if (!isCurrentAttempt(ctx, event)) {
+        // a transport that has already been replaced, reporting its close late
+        return;
+      }
+      ctx.lastError = event.reason;
+      return 'offline';
+    }),
+    close: requestClose
+  },
+  offline: {
+    connect: startConnect,
+    reconnect: startReconnect,
+    close: requestClose
+  },
+  reconnecting: {
+    reconnectComplete: attemptEstablished,
+    reconnectFailed: on((_ref7, event) => {
+      let ctx = _ref7.ctx;
+      ctx.lastError = event.error;
+      return event.recoverable ? 'offline' : 'closed';
+    }),
+    close: requestClose
+  },
+  // Owns the transport until the close handshake settles. Every path into this state is followed
+  // by a `closeComplete`, so it cannot become a trap.
+  disconnecting: {
+    closeComplete: 'closed'
+  },
+  // No transport, but the session may still be resumable: the engine resumes after an unexpected
+  // close just as it does from `offline`.
+  closed: {
+    connect: startConnect,
+    reconnect: startReconnect
+  }
+};
+/**
+ * Lifecycle model of the signal connection.
+ *
+ * The machine deliberately does not own connection attempts: `SignalClient` performs the
+ * asynchronous work and reports the outcome. It also does not decide *whether* to reconnect —
+ * that policy (backoff, resume vs. full reconnect, region failover, giving up) belongs to
+ * `RTCEngine`, so transport loss lands in `offline` rather than starting a reconnect on its own.
+ *
+ * Each client gets its own instance: the context is mutable and per-connection.
+ */
+function createSignalMachine() {
+  let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'new';
+  const context = {
+    attemptId: 0
+  };
+  return createFsm({
+    id: 'signal',
+    initialState: initialState,
+    context,
+    states: signalStates
+  });
 }/**
  * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
  *
@@ -16583,7 +18043,14 @@ class WebSocketStream {
                 let data = _ref2.data;
                 return controller.enqueue(data);
               };
-              ws.onerror = e => controller.error(e);
+              ws.onerror = e => controller.error(ConnectionError.websocket(e instanceof Error ? "".concat(e.name, ": ").concat(e.message) : "Encountered unknown websocket error: ".concat(String(e))));
+              ws.onclose = ev => {
+                if (ev.wasClean) {
+                  controller.close();
+                } else {
+                  controller.error(ConnectionError.websocket("WS closed unexpectedly with code ".concat(ev.code)));
+                }
+              };
             },
             cancel: closeWithInfo
           }),
@@ -16622,7 +18089,7 @@ class WebSocketStream {
           resolve(reason);
         }
       });
-      ws.onclose = _ref3 => {
+      ws.addEventListener('close', _ref3 => {
         let code = _ref3.code,
           reason = _ref3.reason;
         resolve({
@@ -16630,7 +18097,7 @@ class WebSocketStream {
           reason
         });
         ws.removeEventListener('error', rejectHandler);
-      };
+      });
       ws.addEventListener('error', rejectHandler);
     });
     if (options.signal) {
@@ -16639,6 +18106,16 @@ class WebSocketStream {
     this.close = closeWithInfo;
   }
 }const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
+/**
+ * Whether a failed resume may be followed by another one. Mirrors how `RTCEngine` classifies these
+ * errors: a server leave ends the session, and an expired token cannot be recovered by retrying.
+ */
+function isRecoverableReconnectError(error) {
+  if (error instanceof ConnectionError) {
+    return error.reason !== ConnectionErrorReason.LeaveRequest && error.reason !== ConnectionErrorReason.NotAllowed;
+  }
+  return true;
+}
 function canPassThroughQueue(req) {
   const canPass = passThroughQueueSignals.indexOf(req.case) >= 0;
   livekitLogger.trace('request allowed to bypass queue:', {
@@ -16655,6 +18132,24 @@ var SignalConnectionState;
   SignalConnectionState[SignalConnectionState["DISCONNECTING"] = 3] = "DISCONNECTING";
   SignalConnectionState[SignalConnectionState["DISCONNECTED"] = 4] = "DISCONNECTED";
 })(SignalConnectionState || (SignalConnectionState = {}));
+/**
+ * Public projection of the lifecycle machine's states. `new`, `offline` and `closed` are all
+ * reported as `DISCONNECTED`: they differ in what may happen next
+ */
+function lifecycleToConnectionState(lifecycle) {
+  switch (lifecycle) {
+    case 'connected':
+      return SignalConnectionState.CONNECTED;
+    case 'connecting':
+      return SignalConnectionState.CONNECTING;
+    case 'reconnecting':
+      return SignalConnectionState.RECONNECTING;
+    case 'disconnecting':
+      return SignalConnectionState.DISCONNECTING;
+    default:
+      return SignalConnectionState.DISCONNECTED;
+  }
+}
 /** specifies how much time (in ms) we allow for the ws to close its connection gracefully before continuing */
 const MAX_WS_CLOSE_TIME = 250;
 /**
@@ -16664,13 +18159,41 @@ const JOIN_RESPONSE_TIMEOUT = 5000;
 /** @internal */
 class SignalClient {
   get currentState() {
-    return this.state;
+    return lifecycleToConnectionState(this.lifecycleState);
   }
   get isDisconnected() {
-    return this.state === SignalConnectionState.DISCONNECTING || this.state === SignalConnectionState.DISCONNECTED;
+    const state = this.currentState;
+    return state === SignalConnectionState.DISCONNECTING || state === SignalConnectionState.DISCONNECTED;
+  }
+  /** Runtime lifecycle state, finer grained than the public {@link currentState} projection. */
+  get lifecycleState() {
+    return this.machine.currentState();
+  }
+  /** Id of the current connection attempt and of the transport it owns. */
+  get attemptId() {
+    return this.machine.context.attemptId;
+  }
+  /**
+   * Applies a lifecycle input and reports whether it moved the machine
+   */
+  sendLifecycleInput(input) {
+    const before = this.lifecycleState;
+    this.machine.handle(input.type, input);
+    return this.lifecycleState !== before;
+  }
+  /**
+   * Waits out a close that is already in flight. Establishing a session while one is tearing down
+   * would race it for the transport — the teardown can close the socket the new attempt just
+   * opened.
+   */
+  settleInFlightClose() {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.log.debug('waiting for an in-flight close to settle before establishing a session');
+      (yield this.closingLock.lock())();
+    });
   }
   get isEstablishingConnection() {
-    return this.state === SignalConnectionState.CONNECTING || this.state === SignalConnectionState.RECONNECTING;
+    return this.lifecycleState === 'connecting' || this.lifecycleState === 'reconnecting';
   }
   getNextRequestId() {
     this._requestId += 1;
@@ -16682,7 +18205,6 @@ class SignalClient {
     var _a;
     /** signal rtt in milliseconds */
     this.rtt = 0;
-    this.state = SignalConnectionState.DISCONNECTED;
     this.log = livekitLogger;
     this._requestId = 0;
     this.useV0SignalPath = false;
@@ -16708,7 +18230,18 @@ class SignalClient {
     this.queuedRequests = [];
     this.closingLock = new _();
     this.connectionLock = new _();
-    this.state = SignalConnectionState.DISCONNECTED;
+    this.machine = createSignalMachine();
+    this.machine.on('transitioned', _ref => {
+      let fromState = _ref.fromState,
+        toState = _ref.toState;
+      this.log.debug("signal lifecycle: ".concat(fromState, " -> ").concat(toState));
+    });
+    this.machine.on('nohandler', _ref2 => {
+      let inputName = _ref2.inputName;
+      this.log.debug("ignoring signal lifecycle input ".concat(inputName, " in state ").concat(this.lifecycleState));
+    });
+    // no-op unless a development tool asked for it; see utils/machineInspector
+    announceMachine('signal', this.machine);
   }
   get logContext() {
     var _a, _b;
@@ -16720,12 +18253,30 @@ class SignalClient {
       let useV0Path = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
       let publisherOffer = arguments.length > 5 ? arguments[5] : undefined;
       return function* () {
-        // during a full reconnect, we'd want to start the sequence even if currently
-        // connected
-        _this.state = SignalConnectionState.CONNECTING;
+        if (_this.lifecycleState === 'disconnecting') {
+          yield _this.settleInFlightClose();
+        }
+        if (!_this.sendLifecycleInput({
+          type: 'connect'
+        })) {
+          // Proceeding would open a transport the lifecycle does not own: its completion would be
+          // discarded and the session left claiming a transport that had been torn down. Every caller
+          // that restarts a session closes the previous one first (see RTCEngine.restartConnection).
+          throw ConnectionError.internal("cannot establish a signal session from '".concat(_this.lifecycleState, "', close the current one first"));
+        }
         _this.options = opts;
-        const res = yield _this.connect(url, token, opts, abortSignal, useV0Path, publisherOffer);
-        return res;
+        try {
+          const res = yield _this.connect(url, token, opts, abortSignal, useV0Path, publisherOffer);
+          return res;
+        } catch (e) {
+          // reported here rather than at each rejection site inside connect(), so that no failure
+          // path can leave the machine stuck in `connecting`
+          _this.sendLifecycleInput({
+            type: 'connectFailed',
+            error: e
+          });
+          throw e;
+        }
       }();
     });
   }
@@ -16735,15 +18286,31 @@ class SignalClient {
         this.log.warn('attempted to reconnect without signal options being set, ignoring');
         return;
       }
-      this.state = SignalConnectionState.RECONNECTING;
+      if (this.lifecycleState === 'disconnecting') {
+        yield this.settleInFlightClose();
+      }
+      if (!this.sendLifecycleInput({
+        type: 'reconnect'
+      })) {
+        throw ConnectionError.internal("cannot resume the signal session from '".concat(this.lifecycleState, "'"));
+      }
       // clear ping interval and restart it once reconnected
       this.clearPingInterval();
-      const res = yield this.connect(url, token, Object.assign(Object.assign({}, this.options), {
-        reconnect: true,
-        sid,
-        reconnectReason: reason
-      }), undefined, this.useV0SignalPath);
-      return res;
+      try {
+        const res = yield this.connect(url, token, Object.assign(Object.assign({}, this.options), {
+          reconnect: true,
+          sid,
+          reconnectReason: reason
+        }), undefined, this.useV0SignalPath);
+        return res;
+      } catch (e) {
+        this.sendLifecycleInput({
+          type: 'reconnectFailed',
+          error: e,
+          recoverable: isRecoverableReconnectError(e)
+        });
+        throw e;
+      }
     });
   }
   connect(url_1, token_1, opts_1, abortSignal_1) {
@@ -16780,7 +18347,11 @@ class SignalClient {
                 this.close();
               }
               cleanupAbortHandlers();
-              reject(ConnectionError.cancelled(reason));
+              // The caller may already have classified this failure: the connect timeout hands us a
+              // Timeout error. Only a genuine abort is a cancellation, and reporting a stalled connect as
+              // one makes the engine read it as user intent — skipping region failover and never
+              // recording the attempt against the backoff strategy (see Room.connect).
+              reject(eventOrError instanceof ConnectionError ? eventOrError : ConnectionError.cancelled(reason));
             });
             abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
             const cleanupAbortHandlers = () => {
@@ -16790,48 +18361,62 @@ class SignalClient {
             const wsTimeout = setTimeout(() => {
               abortHandler(ConnectionError.timeout('room connection has timed out (signal)'));
             }, opts.websocketTimeout);
-            const handleSignalConnected = (connection, firstMessage) => {
-              this.handleSignalConnected(connection, wsTimeout, firstMessage);
-            };
             const redactedUrl = new URL(rtcUrl);
             if (redactedUrl.searchParams.has('access_token')) {
               redactedUrl.searchParams.set('access_token', '<redacted>');
             }
             if (this.ws) {
               const startClose = performance.now();
-              yield this.close(false);
+              yield this.teardownTransport('replaced by a new connection attempt');
               this.log.debug("closed previous ws connection in ".concat(performance.now() - startClose, "ms"));
             }
+            // 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;
             this.log.info("signal connecting to ".concat(redactedUrl), {
               reconnect: opts.reconnect,
               reconnectReason: opts.reconnectReason
             });
             this.ws = new WebSocketStream(rtcUrl);
+            // A failed upgrade closes the socket, so `opened` and `closed` settle for the same cause — but
+            // only the `opened` path can classify it (a 401 is known after asking the validate endpoint).
+            // Noting the failure *before* the close handler is registered means it runs first, so a close
+            // that merely reflects a failed upgrade stands down and lets the classified error reach the
+            // caller. Any other close still fails the attempt straight away: after a successful upgrade
+            // nothing else would, short of the first-message timeout.
+            let upgradeFailed = false;
+            this.ws.opened.catch(() => {
+              upgradeFailed = true;
+            });
             try {
               this.ws.closed.then(closeInfo => {
-                if (this.isEstablishingConnection) {
+                if (this.isEstablishingConnection && !upgradeFailed) {
                   reject(ConnectionError.internal("Websocket got closed during a (re)connection attempt: ".concat(closeInfo.reason)));
                 }
-                if (closeInfo.closeCode !== 1000) {
-                  this.log.warn("websocket closed", {
-                    reason: closeInfo.reason,
-                    code: closeInfo.closeCode,
-                    wasClean: closeInfo.closeCode === 1000,
-                    state: this.state
-                  });
-                  if (this.state === SignalConnectionState.CONNECTED) {
-                    this.handleOnClose(closeInfo.reason || 'Unexpected WS error');
-                  }
-                }
+                this.log.debug('websocket closed', {
+                  reason: closeInfo.reason,
+                  code: closeInfo.closeCode,
+                  attemptId,
+                  state: this.lifecycleState
+                });
+                // Every close of the live transport is reported, including a clean 1000 one: a server
+                // that drops signalling closes cleanly — a migration that never sends its
+                // `Leave{action=RESUME}` does exactly that — and treating that as "nothing happened"
+                // leaves the client believing it is still connected until something else notices.
+                // Closes we caused ourselves, and closes from a transport that has since been
+                // replaced, are dropped by the machine's state and attempt guards below rather than by
+                // a close-code test.
+                this.handleOnClose(closeInfo.reason || (closeInfo.closeCode === 1000 ? 'server closed the signal connection' : 'Unexpected WS error'), attemptId);
                 return;
               }).catch(reason => {
-                if (this.isEstablishingConnection) {
+                if (this.isEstablishingConnection && !upgradeFailed) {
                   reject(ConnectionError.internal("Websocket error during a (re)connection attempt: ".concat(reason)));
                 }
               });
               const connection = yield this.ws.opened.catch(reason => __awaiter(this, void 0, void 0, function* () {
-                if (this.state !== SignalConnectionState.CONNECTED) {
-                  this.state = SignalConnectionState.DISCONNECTED;
+                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
                   clearTimeout(wsTimeout);
                   const error = yield this.handleConnectionError(reason, validateUrl);
                   reject(error);
@@ -16896,7 +18481,7 @@ class SignalClient {
               }
               // Handle successful connection
               const firstMessageToProcess = validation.shouldProcessFirstMessage ? firstSignalResponse : undefined;
-              handleSignalConnected(connection, firstMessageToProcess);
+              this.handleSignalConnected(connection, wsTimeout, attemptId, firstMessageToProcess);
               resolve(validation.response);
             } catch (e) {
               reject(e);
@@ -16919,14 +18504,22 @@ class SignalClient {
         if (this.signalLatency) {
           yield sleep(this.signalLatency);
         }
-        const _yield$signalReader$r = yield signalReader.read(),
-          done = _yield$signalReader$r.done,
-          value = _yield$signalReader$r.value;
-        if (done) {
+        try {
+          const _yield$signalReader$r = yield signalReader.read(),
+            done = _yield$signalReader$r.done,
+            value = _yield$signalReader$r.value;
+          if (done) {
+            break;
+          }
+          const resp = parseSignalResponse(value);
+          this.handleSignalResponse(resp);
+        } catch (e) {
+          this.log.error("error reading from signal stream", {
+            error: e
+          });
+          yield this.close(false, 'error in reading loop');
           break;
         }
-        const resp = parseSignalResponse(value);
-        this.handleSignalResponse(resp);
       }
     });
   }
@@ -16936,40 +18529,53 @@ class SignalClient {
       let updateState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       let reason = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Close method called on signal client';
       return function* () {
-        if ([SignalConnectionState.DISCONNECTING || SignalConnectionState.DISCONNECTED].includes(_this3.state)) {
-          _this3.log.debug("ignoring signal close as it's already in disconnecting state");
-          return;
-        }
+        // when the lifecycle is already shutting down (or another close owns it), only the transport
+        // teardown below still applies — it is idempotent, so callers can always await a close
+        const drivesLifecycle = updateState && _this3.sendLifecycleInput({
+          type: 'close',
+          reason
+        });
         const unlock = yield _this3.closingLock.lock();
         try {
-          _this3.clearPingInterval();
-          if (updateState) {
-            _this3.state = SignalConnectionState.DISCONNECTING;
-          }
-          if (_this3.ws) {
-            _this3.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 = _this3.ws.closed;
-            _this3.ws = undefined;
-            _this3.streamWriter = undefined;
-            yield Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
-          }
-        } catch (e) {
-          _this3.log.debug('websocket error while closing', {
-            error: e
-          });
+          yield _this3.teardownTransport(reason);
         } finally {
-          if (updateState) {
-            _this3.state = SignalConnectionState.DISCONNECTED;
+          if (drivesLifecycle) {
+            _this3.sendLifecycleInput({
+              type: 'closeComplete'
+            });
           }
           unlock();
         }
       }();
     });
   }
+  /**
+   * Releases the transport and everything tied to it, without touching the lifecycle state. Used
+   * both by {@link close} and by paths that replace the transport under a live lifecycle (a new
+   * attempt, or an unexpected close that leaves the client in `offline`).
+   */
+  teardownTransport(reason) {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        this.clearPingInterval();
+        if (this.ws) {
+          this.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)]);
+        }
+      } catch (e) {
+        this.log.debug('websocket error while closing', {
+          error: e
+        });
+      }
+    });
+  }
   // initial offer after joining
   sendOffer(offer, offerId) {
     this.log.debug('sending offer', {
@@ -17148,7 +18754,8 @@ class SignalClient {
         // capture all requests while reconnecting and put them in a queue
         // unless the request originates from the queue, then don't enqueue again
         const canQueue = !fromQueue && !canPassThroughQueue(message);
-        if (canQueue && _this5.state === SignalConnectionState.RECONNECTING) {
+        const isHoldingRequests = _this5.lifecycleState === 'reconnecting' || _this5.queuedRequests.length > 0;
+        if (canQueue && isHoldingRequests) {
           _this5.queuedRequests.push(() => __awaiter(_this5, void 0, void 0, function* () {
             yield this.sendRequest(message, true);
           }));
@@ -17161,7 +18768,11 @@ class SignalClient {
         if (_this5.signalLatency) {
           yield sleep(_this5.signalLatency);
         }
-        if (_this5.isDisconnected) {
+        // `leave` is the one request whose purpose is to be sent on the way out (an aborted connect
+        // attempt tells the server before tearing down), so it is allowed through for as long as the
+        // transport is still there
+        const isLeaveOnShutdown = message.case === 'leave' && !!_this5.streamWriter;
+        if (_this5.isDisconnected && !isLeaveOnShutdown) {
           // Skip requests if the signal layer is disconnected
           // This can happen if an event is sent in the mist of room.connect() initializing
           _this5.log.debug("skipping signal request (type: ".concat(message.case, ") - SignalClient disconnected"));
@@ -17315,17 +18926,39 @@ class SignalClient {
       }
     }
   }
-  handleOnClose(reason) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (this.state === SignalConnectionState.DISCONNECTED) return;
-      const onCloseCallback = this.onClose;
-      yield this.close(undefined, reason);
-      this.log.info("websocket connection closed: ".concat(reason), {
-        reason
-      });
-      if (onCloseCallback) {
-        onCloseCallback(reason);
-      }
+  /**
+   * Handles a transport we lost without asking to. The client goes to `offline` rather than
+   * `closed`: whether this session gets resumed, restarted or given up on is the engine's call.
+   */
+  handleOnClose(reason_1) {
+    return __awaiter(this, arguments, void 0, function (reason) {
+      var _this6 = this;
+      let attemptId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.attemptId;
+      return function* () {
+        const onCloseCallback = _this6.onClose;
+        if (!_this6.sendLifecycleInput({
+          type: 'transportFailed',
+          attemptId,
+          reason
+        })) {
+          // a close we caused ourselves, or one from a transport that has since been replaced: logged
+          // rather than dropped silently, because a close that goes unnoticed leaves the client writing
+          // to a dead socket
+          _this6.log.debug("ignoring transport close in state ".concat(_this6.lifecycleState), {
+            reason,
+            attemptId,
+            currentAttemptId: _this6.attemptId
+          });
+          return;
+        }
+        yield _this6.teardownTransport(reason);
+        _this6.log.info("websocket connection closed: ".concat(reason), {
+          reason
+        });
+        if (onCloseCallback) {
+          onCloseCallback(reason);
+        }
+      }();
     });
   }
   handleWSError(error) {
@@ -17382,10 +19015,27 @@ class SignalClient {
    * @param firstMessage Optional first message to process
    * @internal
    */
-  handleSignalConnected(connection, timeoutHandle, firstMessage) {
-    this.state = SignalConnectionState.CONNECTED;
-    this.log.info('signal connected');
+  handleSignalConnected(connection, timeoutHandle, attemptId, firstMessage) {
     clearTimeout(timeoutHandle);
+    const established = this.sendLifecycleInput(this.lifecycleState === 'reconnecting' ? {
+      type: 'reconnectComplete',
+      attemptId
+    } : {
+      type: 'connectComplete',
+      attemptId
+    });
+    if (!established) {
+      // The attempt was abandoned while we waited for the server's first message: it was closed, or
+      // a newer attempt superseded it. Arming the ping interval and the read loop here would outlive
+      // the session that owns them, so leave the transport to whoever holds the lifecycle now.
+      this.log.debug('discarding a connection whose attempt no longer owns the session', {
+        attemptId,
+        currentAttemptId: this.attemptId,
+        state: this.lifecycleState
+      });
+      return;
+    }
+    this.log.info('signal connected');
     this.startPingInterval();
     this.startReadingLoop(connection.readable.getReader(), firstMessage);
   }
@@ -17403,7 +19053,7 @@ class SignalClient {
         isValid: true,
         response: firstSignalResponse.message.value
       };
-    } else if (this.state === SignalConnectionState.RECONNECTING && ((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) !== 'leave') {
+    } else if (this.lifecycleState === 'reconnecting' && ((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) !== 'leave') {
       if (((_c = firstSignalResponse.message) === null || _c === void 0 ? void 0 : _c.case) === 'reconnect') {
         return {
           isValid: true,
@@ -18392,6 +20042,51 @@ const startBitrateMultiplier = 0.9;
 /** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
 const maxStartBitrateKbps = 1000;
 const debounceInterval = 20;
+/**
+ * Applies the configured start bitrate when this media section belongs to `cid`.
+ * This SDP munging is used for a bitrate setting that cannot be applied through
+ * `RTCRtpEncodingParameters`.
+ *
+ * Returns `undefined` when the section does not belong to the track, `0` when
+ * it does but does not offer the requested codec, and the codec payload when the
+ * requested codec is present (whether the bitrate was added or already set).
+ *
+ * @internal
+ */
+function applyVideoStartBitrate(media, cid, codec, maxbr) {
+  let isScreenShare = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var _a, _b, _c;
+  if (!((_a = media.msid) === null || _a === void 0 ? void 0 : _a.includes(cid))) {
+    return undefined;
+  }
+  const codecPayload = (_c = (_b = media.rtp.find(rtp => rtp.codec.toUpperCase() === codec.toUpperCase())) === null || _b === void 0 ? void 0 : _b.payload) !== null && _c !== void 0 ? _c : 0;
+  if (codecPayload === 0) {
+    return 0;
+  }
+  // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE
+  // from starting too aggressively. Screen share is not capped since text/UI
+  // clarity requires high bitrate from the start.
+  // TODO: dynamically adjust start bitrate based on network conditions (e.g., previous BWE estimate)
+  const calculatedStartBitrate = Math.round(maxbr * startBitrateMultiplier);
+  const startBitrate = isScreenShare ? calculatedStartBitrate : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
+  const fmtp = media.fmtp.find(entry => entry.payload === codecPayload);
+  if (fmtp) {
+    // If another track's fmtp already has a start bitrate, it cannot be
+    // overridden here because the payload type is shared across the bundle.
+    // This forces every track sharing that payload to use the initial track's
+    // start bitrate.
+    if (!fmtp.config.includes('x-google-start-bitrate')) {
+      fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
+    }
+  } else {
+    // VP8 and some codecs may not have an existing fmtp line.
+    media.fmtp.push({
+      payload: codecPayload,
+      config: "x-google-start-bitrate=".concat(startBitrate)
+    });
+  }
+  return codecPayload;
+}
 const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
   NegotiationComplete: 'negotiationComplete',
@@ -18693,9 +20388,13 @@ class PCTransport extends eventsExports.EventEmitter {
           // the only exception to this is when ICE restart is needed
           const currentSD = this._pc.remoteDescription;
           if ((options === null || options === void 0 ? void 0 : options.iceRestart) && currentSD) {
-            // TODO: handle when ICE restart is needed but we don't have a remote description
-            // the best thing to do is to recreate the peerconnection
+            // roll the remote description back in so createOffer produces a valid
+            // ICE-restart offer on top of the already-negotiated state
             yield this._pc.setRemoteDescription(currentSD);
+          } else if (options === null || options === void 0 ? void 0 : options.iceRestart) {
+            // ICE restart with no remote description to restart on: `renegotiate` would stall
+            // (the pending offer is never answered), so throw for the caller to recreate the PC.
+            throw new NegotiationError('ICE restart requested without a remote description, peer connection must be recreated');
           } else {
             this.renegotiate = true;
             this.log.debug('requesting renegotiation');
@@ -18721,48 +20420,15 @@ class PCTransport extends eventsExports.EventEmitter {
             ensureAudioNackAndStereo(media, ['all'], []);
           } else if (media.type === 'video') {
             this.trackBitrates.some(trackbr => {
-              if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
+              if (!trackbr.cid) {
                 return false;
               }
-              let codecPayload = 0;
-              media.rtp.some(rtp => {
-                if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
-                  codecPayload = rtp.payload;
-                  return true;
-                }
+              const codecPayload = applyVideoStartBitrate(media, trackbr.cid, trackbr.codec, trackbr.maxbr, trackbr.isScreenShare);
+              if (codecPayload === undefined) {
                 return false;
-              });
-              if (codecPayload === 0) {
-                return true;
-              }
-              if (isSVCCodec(trackbr.codec) && !isSafari()) {
-                this.ensureVideoDDExtensionForSVC(media, sdpParsed);
               }
-              // mung sdp for bitrate setting that can't apply by sendEncoding
-              // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE from starting too aggressively
-              // Screen share is not capped since text/UI clarity requires high bitrate from the start
-              // TODO: dynamically adjust start bitrate based on network conditions (e.g., use previous BWE estimate)
-              const calculatedStartBitrate = Math.round(trackbr.maxbr * startBitrateMultiplier);
-              const startBitrate = trackbr.isScreenShare ? calculatedStartBitrate : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
-              let fmtpFound = false;
-              for (const fmtp of media.fmtp) {
-                if (fmtp.payload === codecPayload) {
-                  fmtpFound = true;
-                  // if another track's fmtp already is set, we cannot override the bitrate
-                  // this has the unfortunate consequence of being forced to use the
-                  // initial track's bitrate for all tracks
-                  if (!fmtp.config.includes('x-google-start-bitrate')) {
-                    fmtp.config += ";x-google-start-bitrate=".concat(startBitrate);
-                  }
-                  break;
-                }
-              }
-              // VP8 and some codecs may not have an existing fmtp line - create one
-              if (!fmtpFound) {
-                media.fmtp.push({
-                  payload: codecPayload,
-                  config: "x-google-start-bitrate=".concat(startBitrate)
-                });
+              if (codecPayload > 0 && isSVCCodec(trackbr.codec) && !isSafari()) {
+                this.ddExtID = ensureVideoDDExtension(media, sdpParsed, this.ddExtID);
               }
               return true;
             });
@@ -18878,8 +20544,10 @@ class PCTransport extends eventsExports.EventEmitter {
     var _a;
     return (_a = this.pc) === null || _a === void 0 ? void 0 : _a.remoteDescription;
   }
+  /** stats of the underlying connection, `undefined` when there is none */
   getStats() {
-    return this.pc.getStats();
+    var _a;
+    return (_a = this._pc) === null || _a === void 0 ? void 0 : _a.getStats();
   }
   getMaxMessageSize() {
     var _a, _b;
@@ -18975,41 +20643,106 @@ class PCTransport extends eventsExports.EventEmitter {
       }
     });
   }
-  ensureVideoDDExtensionForSVC(media, sdp) {
-    var _a, _b;
-    const ddFound = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => {
-      if (ext.uri === ddExtensionURI) {
-        return true;
-      }
-      return false;
+}
+/**
+ * Adds the AV1 dependency descriptor extension to `media` unless it is already there, and
+ * returns the id it is mapped to so callers can pass it back in as `ddExtID` (0 when no id has
+ * been chosen yet).
+ *
+ * A bundle has to map one URI to one id, so an id already in use for the extension anywhere in
+ * `sdp` wins over both the cached one and a fresh one: Chrome advertises the extension itself on
+ * sections it can send on, and an earlier offer may have munged it into others.
+ * @internal
+ */
+function ensureVideoDDExtension(media, sdp, ddExtID) {
+  var _a, _b;
+  const id = ddExtensionIDFor(sdp, ddExtID);
+  if (id === undefined) {
+    return ddExtID;
+  }
+  if (!((_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => ext.uri === ddExtensionURI))) {
+    (_b = media.ext) !== null && _b !== void 0 ? _b : media.ext = [];
+    media.ext.push({
+      value: id,
+      uri: ddExtensionURI
     });
-    if (!ddFound) {
-      if (this.ddExtID === 0) {
-        let maxID = 0;
-        sdp.media.forEach(m => {
-          var _a;
-          (_a = m.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
-            if (ext.value > maxID) {
-              maxID = ext.value;
-            }
-          });
-        });
-        this.ddExtID = maxID + 1;
-      }
-      (_b = media.ext) === null || _b === void 0 ? void 0 : _b.push({
-        value: this.ddExtID,
-        uri: ddExtensionURI
-      });
+  }
+  return id;
+}
+/**
+ * The id to map the dependency descriptor to throughout `sdp`, or undefined when no id would be
+ * consistent for the whole bundle and the extension therefore has to be left out.
+ */
+function ddExtensionIDFor(sdp, cachedID) {
+  const mapped = mappedExtensionID(sdp, ddExtensionURI);
+  if (mapped !== undefined) {
+    // Adopting an id that also stands for another URI is what the browser rejects the bundle
+    // over, and its own half of the map is not ours to renumber, so give up on this offer.
+    return usedForOtherURI(sdp, mapped, ddExtensionURI) ? undefined : mapped;
+  }
+  // Reusing the id from the last offer keeps the mapping stable across renegotiations, but only
+  // while nothing else has taken it: the browser assigns ids to its own extensions without
+  // knowing about ours, so an id that was free when we picked it can since have been claimed —
+  // typically by the fuller extension set that arrives with the first section we send on.
+  if (cachedID !== 0 && !usedForOtherURI(sdp, cachedID, ddExtensionURI)) {
+    return cachedID;
+  }
+  return unusedExtensionID(sdp);
+}
+/** The id `uri` is mapped to in `sdp`, if any section maps it. */
+function mappedExtensionID(sdp, uri) {
+  var _a;
+  for (const media of sdp.media) {
+    const ext = (_a = media.ext) === null || _a === void 0 ? void 0 : _a.find(candidate => candidate.uri === uri);
+    if (ext) {
+      return ext.value;
     }
   }
+  return undefined;
 }
+/** Whether `id` stands for anything in `sdp` other than `uri`. */
+function usedForOtherURI(sdp, id, uri) {
+  return sdp.media.some(media => {
+    var _a;
+    return (_a = media.ext) === null || _a === void 0 ? void 0 : _a.some(ext => ext.value === id && ext.uri !== uri);
+  });
+}
+/**
+ * An id no extension in `sdp` uses. Stays above every id in use rather than filling gaps, so it
+ * is less likely to be an id the browser goes on to allocate to another extension, and steps
+ * over 15, which RFC 8285 reserves.
+ */
+function unusedExtensionID(sdp) {
+  let maxID = 0;
+  sdp.media.forEach(media => {
+    var _a;
+    (_a = media.ext) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
+      if (ext.value > maxID) {
+        maxID = ext.value;
+      }
+    });
+  });
+  return maxID + 1 === 15 ? 16 : maxID + 1;
+}
+/**
+ * Checks whether an fmtp config declares `param` as an exact, `;`-delimited
+ * token. A plain substring check conflates distinct opus parameters — e.g.
+ * `stereo=1` is a substring of `sprop-stereo=1` — so `param` must match a whole
+ * parameter, not appear anywhere within the config string.
+ * @internal
+ */
+function fmtpConfigHasParam(config, param) {
+  return config.split(';').some(entry => entry.trim() === param);
+}
+/** @internal */
 function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
   // sdp-transform types don't include number however the parser outputs mids as numbers in some cases
   const mid = getMidString(media.mid);
   // found opus codec to add nack fb
   let opusPayload = 0;
   media.rtp.some(rtp => {
-    if (rtp.codec === 'opus') {
+    // rtpmap encoding names are case-insensitive (RFC 4855)
+    if (rtp.codec.toLowerCase() === 'opus') {
       opusPayload = rtp.payload;
       return true;
     }
@@ -19029,7 +20762,7 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
     if (stereoMids.includes(mid) || stereoMids.length === 1 && stereoMids[0] === 'all') {
       media.fmtp.some(fmtp => {
         if (fmtp.payload === opusPayload) {
-          if (!fmtp.config.includes('stereo=1')) {
+          if (!fmtpConfigHasParam(fmtp.config, 'stereo=1')) {
             fmtp.config += ';stereo=1';
           }
           return true;
@@ -19112,6 +20845,7 @@ function conformBundledCodecFmtp(media, isPlaceholder) {
     }
   }
 }
+/** @internal */
 function extractStereoAndNackAudioFromOffer(offer) {
   var _a;
   const stereoMids = [];
@@ -19123,7 +20857,8 @@ function extractStereoAndNackAudioFromOffer(offer) {
     const mid = getMidString(media.mid);
     if (media.type === 'audio') {
       media.rtp.some(rtp => {
-        if (rtp.codec === 'opus') {
+        // rtpmap encoding names are case-insensitive (RFC 4855)
+        if (rtp.codec.toLowerCase() === 'opus') {
           opusPayload = rtp.payload;
           return true;
         }
@@ -19134,7 +20869,7 @@ function extractStereoAndNackAudioFromOffer(offer) {
       }
       media.fmtp.some(fmtp => {
         if (fmtp.payload === opusPayload) {
-          if (fmtp.config.includes('sprop-stereo=1')) {
+          if (fmtpConfigHasParam(fmtp.config, 'sprop-stereo=1')) {
             stereoMids.push(mid);
           }
           return true;
@@ -21102,12 +22837,17 @@ class LocalTrack extends Track {
             type: 'audio',
             streamId: v.id,
             packetsSent: v.packetsSent,
-            packetsLost: v.packetsLost,
             bytesSent: v.bytesSent,
-            timestamp: v.timestamp,
-            roundTripTime: v.roundTripTime,
-            jitter: v.jitter
+            timestamp: v.timestamp
           };
+          // loss, jitter and RTT are only known from what the remote reports back,
+          // the same way the video sender picks them up
+          const remote = stats.get(v.remoteId);
+          if (remote) {
+            audioStats.packetsLost = remote.packetsLost;
+            audioStats.jitter = remote.jitter;
+            audioStats.roundTripTime = remote.roundTripTime;
+          }
         }
       });
       return audioStats;
@@ -21927,17 +23667,37 @@ class LocalVideoTrack extends LocalTrack {
   setDegradationPreference(preference) {
     return __awaiter(this, void 0, void 0, function* () {
       this.degradationPreference = preference;
-      if (this.sender) {
-        try {
-          this.log.debug("setting degradationPreference to ".concat(preference), this.logContext);
-          const params = this.sender.getParameters();
-          params.degradationPreference = preference;
-          this.sender.setParameters(params);
-        } catch (e) {
-          this.log.warn("failed to set degradationPreference", Object.assign({
-            error: e
-          }, this.logContext));
-        }
+      // applied one sender at a time on purpose, see applyDegradationPreference
+      yield this.applyDegradationPreference(this.sender);
+      for (const sc of this.simulcastCodecs.values()) {
+        yield this.applyDegradationPreference(sc.sender);
+      }
+    });
+  }
+  /**
+   * Degradation preference is a property of the sender, not of the track, so every sender
+   * publishing this track needs it applied separately. A backup codec publishes over its
+   * own sender, which would otherwise let the browser resolve a preference implicitly and
+   * diverge from the primary encoder.
+   *
+   * Callers apply this sequentially rather than concurrently: `setParameters` is only valid
+   * against the parameters most recently returned by `getParameters`, which is why this file
+   * serializes other sender parameter updates through `senderLock`.
+   */
+  applyDegradationPreference(sender) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!sender) {
+        return;
+      }
+      try {
+        this.log.debug("setting degradationPreference to ".concat(this.degradationPreference), this.logContext);
+        const params = sender.getParameters();
+        params.degradationPreference = this.degradationPreference;
+        yield sender.setParameters(params);
+      } catch (e) {
+        this.log.warn("failed to set degradationPreference", Object.assign({
+          error: e
+        }, this.logContext));
       }
     });
   }
@@ -21956,18 +23716,23 @@ class LocalVideoTrack extends LocalTrack {
     return simulcastCodecInfo;
   }
   setSimulcastTrackSender(codec, sender) {
-    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
-    if (!simulcastCodecInfo) {
-      return;
-    }
-    simulcastCodecInfo.sender = sender;
-    // browser will reenable disabled codec/layers after new codec has been published,
-    // so refresh subscribedCodecs after publish a new codec
-    setTimeout(() => {
-      if (this.subscribedCodecs) {
-        this.setPublishingCodecs(this.subscribedCodecs);
+    return __awaiter(this, void 0, void 0, function* () {
+      const simulcastCodecInfo = this.simulcastCodecs.get(codec);
+      if (!simulcastCodecInfo) {
+        return;
       }
-    }, refreshSubscribedCodecAfterNewCodec);
+      simulcastCodecInfo.sender = sender;
+      // the backup codec publishes over its own sender, so it needs the same degradation
+      // preference the primary sender resolved to.
+      yield this.applyDegradationPreference(sender);
+      // browser will reenable disabled codec/layers after new codec has been published,
+      // so refresh subscribedCodecs after publish a new codec
+      setTimeout(() => {
+        if (this.subscribedCodecs) {
+          this.setPublishingCodecs(this.subscribedCodecs);
+        }
+      }, refreshSubscribedCodecAfterNewCodec);
+    });
   }
   /**
    * @internal
@@ -22239,6 +24004,11 @@ function videoLayersFromEncodings(width, height, encodings, svc) {
   });
 }const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
+/**
+ * How long local connection quality must stay `LOST` while connected and publishing before we
+ * force a full reconnect — `LOST` is the server's verdict that it isn't receiving our media.
+ */
+const connectionQualityLostTimeout = 10 * 1000;
 const reliabeReceiveStateTTL = 30000;
 const initialMediaSectionsAudio = 3;
 const initialMediaSectionsVideo = 3;
@@ -22419,7 +24189,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       const disconnect = duration => {
         this.log.warn("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(duration, "ms. giving up"));
         this.emit(EngineEvent.Disconnected);
-        this.close();
+        this.close("gave up reconnecting after ".concat(this.reconnectAttempts, " attempts, ").concat(duration, "ms"));
       };
       const duration = Date.now() - this.reconnectStart;
       let delay = this.getNextRetryDelay({
@@ -22528,7 +24298,10 @@ class RTCEngine extends eventsExports.EventEmitter {
       onBufferStatusChanged: (kind, isLow) => this.emit(EngineEvent.DCBufferStatusChanged, isLow, kind)
     });
     this.client.onParticipantUpdate = updates => this.emit(EngineEvent.ParticipantUpdate, updates);
-    this.client.onConnectionQuality = update => this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    this.client.onConnectionQuality = update => {
+      this.handleLocalConnectionQuality(update);
+      this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    };
     this.client.onRoomUpdate = update => this.emit(EngineEvent.RoomUpdate, update);
     this.client.onSubscriptionError = resp => this.emit(EngineEvent.SubscriptionError, resp);
     this.client.onSubscriptionPermissionUpdate = update => this.emit(EngineEvent.SubscriptionPermissionUpdate, update);
@@ -22657,7 +24430,12 @@ class RTCEngine extends eventsExports.EventEmitter {
       }();
     });
   }
-  close() {
+  /**
+   * @param reason why the session is ending, recorded by the signal lifecycle. Worth passing
+   * wherever the caller knows more than "someone called close" — the server's leave reason, or
+   * having given up on reconnecting.
+   */
+  close(reason) {
     return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.closingLock.lock();
       if (this.isClosed) {
@@ -22671,9 +24449,10 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.removeAllListeners();
         this.deregisterOnLineListener();
         this.clearPendingReconnect();
+        this.clearLostQualityTimeout();
         this.cleanupLossyDataStats();
         yield this.cleanupPeerConnections();
-        yield this.cleanupClient();
+        yield this.cleanupClient(reason);
       } finally {
         unlock();
       }
@@ -22685,15 +24464,17 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.dataChannels.teardown();
       yield (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.close();
       this.pcManager = undefined;
+      // the connecting timestamp belongs to the transports we just tore down
+      this.transportConnectingSince = undefined;
       this.reliableReceivedState.clear();
     });
   }
   cleanupLossyDataStats() {
     this.lossyChannel.stopThresholdTuning();
   }
-  cleanupClient() {
+  cleanupClient(reason) {
     return __awaiter(this, void 0, void 0, function* () {
-      yield this.client.close();
+      yield this.client.close(true, reason);
       this.client.resetCallbacks();
       // Any in-flight addTrack requests are orphaned by the signal reconnect — the new session
       // won't deliver `trackPublishedResponse` for them, so reject the pending resolvers and
@@ -22710,17 +24491,17 @@ class RTCEngine extends eventsExports.EventEmitter {
       throw new TrackInvalidError('a track with the same ID has already been published');
     }
     return new Promise((resolve, reject) => {
-      const publicationTimeout = setTimeout(() => {
+      const publicationTimeout = CriticalTimers.setTimeout(() => {
         delete this.pendingTrackResolvers[req.cid];
         reject(ConnectionError.timeout('publication of local track timed out, no response from server'));
       }, 10000);
       this.pendingTrackResolvers[req.cid] = {
         resolve: info => {
-          clearTimeout(publicationTimeout);
+          CriticalTimers.clearTimeout(publicationTimeout);
           resolve(info);
         },
         reject: () => {
-          clearTimeout(publicationTimeout);
+          CriticalTimers.clearTimeout(publicationTimeout);
           reject(new Error('Cancelled publication by calling unpublish'));
         }
       };
@@ -22793,6 +24574,15 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.pcManager.onDataChannel = this.handleDataChannel;
       this.pcManager.onStateChange = (connectionState, publisherState, subscriberState) => __awaiter(this, void 0, void 0, function* () {
         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
+        // real transition (this handler only fires on state changes) rather than from
+        // observation time keeps it from going stale across peer-connection rebuilds.
+        if (connectionState === PCTransportState.CONNECTING) {
+          this.transportConnectingSince = Date.now();
+        } else {
+          this.transportConnectingSince = undefined;
+        }
         if (['closed', 'disconnected', 'failed'].includes(publisherState)) {
           // reset publisher connection promise
           this.publisherConnectionPromise = undefined;
@@ -22919,6 +24709,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
     this.client.onLeave = leave => {
+      var _a;
       this.log.info("client leave request received (action=".concat(leave === null || leave === void 0 ? void 0 : leave.action, ")"), {
         reason: leave === null || leave === void 0 ? void 0 : leave.reason
       });
@@ -22929,7 +24720,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       switch (leave.action) {
         case LeaveRequest_Action.DISCONNECT:
           this.emit(EngineEvent.Disconnected, leave === null || leave === void 0 ? void 0 : leave.reason);
-          this.close();
+          this.close("server leave: ".concat((_a = DisconnectReason[leave.reason]) !== null && _a !== void 0 ? _a : leave.reason));
           break;
         case LeaveRequest_Action.RECONNECT:
           this.fullReconnectOnNext = true;
@@ -23001,15 +24792,23 @@ class RTCEngine extends eventsExports.EventEmitter {
     }
   }
   addMediaSections(numAudios, numVideos) {
-    var _a, _b;
+    var _a, _b, _c;
     const transceiverInit = {
       direction: 'recvonly'
     };
     for (let i = 0; i < numAudios; i++) {
       (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.addPublisherTransceiverOfKind('audio', transceiverInit);
     }
+    // media only arrives on these sections when there is no subscriber connection to arrive on
+    const receivesMedia = ((_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.mode) === 'publisher-only';
     for (let i = 0; i < numVideos; i++) {
-      (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.addPublisherTransceiverOfKind('video', transceiverInit);
+      const transceiver = (_c = this.pcManager) === null || _c === void 0 ? void 0 : _c.addPublisherTransceiverOfKind('video', transceiverInit);
+      if (receivesMedia && transceiver) {
+        const negotiated = negotiateDependencyDescriptor(transceiver);
+        this.log.debug('dependency descriptor negotiated for received video', {
+          negotiated
+        });
+      }
     }
   }
   createDataChannels() {
@@ -23151,7 +24950,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       if (!opts.videoCodec) {
         return;
       }
-      track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+      yield track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
       return transceiver.sender;
     });
   }
@@ -23163,6 +24962,63 @@ class RTCEngine extends eventsExports.EventEmitter {
       return this.pcManager.addPublisherTrack(track);
     });
   }
+  /**
+   * A sustained local `LOST` while connected and publishing means the server isn't receiving
+   * our media, so force a full reconnect; any non-`LOST` value cancels a pending trigger.
+   */
+  handleLocalConnectionQuality(update) {
+    if (!this.participantSid) {
+      return;
+    }
+    const localUpdate = update.updates.find(u => u.participantSid === this.participantSid);
+    if (!localUpdate) {
+      return;
+    }
+    if (localUpdate.quality === ConnectionQuality$1.LOST) {
+      this.scheduleLostQualityReconnect();
+    } else {
+      this.clearLostQualityTimeout();
+    }
+  }
+  scheduleLostQualityReconnect() {
+    if (this.lostQualityTimeout) {
+      // already counting down towards a reconnect
+      return;
+    }
+    this.lostQualityTimeout = CriticalTimers.setTimeout(() => {
+      this.lostQualityTimeout = undefined;
+      if (this._isClosed || this.pcState !== PCState.Connected || this.attemptingReconnect) {
+        return;
+      }
+      if (!this.hasActivePublisherSenders()) {
+        return;
+      }
+      this.log.warn('local connection quality lost while publishing, triggering full reconnect', this.logContext);
+      this.fullReconnectOnNext = true;
+      this.handleDisconnect('connection quality lost', ReconnectReason.RR_PUBLISHER_FAILED);
+    }, connectionQualityLostTimeout);
+  }
+  clearLostQualityTimeout() {
+    if (this.lostQualityTimeout) {
+      CriticalTimers.clearTimeout(this.lostQualityTimeout);
+      this.lostQualityTimeout = undefined;
+    }
+  }
+  /** Whether the publisher currently has any sender with a live track. */
+  hasActivePublisherSenders() {
+    var _a, _b;
+    return (_b = (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.publisher.getSenders().some(sender => !!sender.track && sender.track.readyState === 'live')) !== null && _b !== void 0 ? _b : false;
+  }
+  /**
+   * Forces a full reconnect while keeping the engine (and its saved credentials) alive. Used by
+   * Room's connection-reconcile safety net when the transport silently died but we looked connected.
+   * @internal
+   */
+  reconnect() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ReconnectReason.RR_UNKNOWN;
+    this.fullReconnectOnNext = true;
+    this.handleDisconnect('reconcile', reason);
+  }
   attemptReconnect(reason) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b, _c;
@@ -23174,21 +25030,32 @@ class RTCEngine extends eventsExports.EventEmitter {
         this.log.warn('already attempting reconnect, returning early');
         return;
       }
+      // A pending Lost-quality countdown belongs to the session we're now leaving; cancel it so
+      // it can't fire against the reconnected session before the server has evaluated it. (A resume
+      // keeps the peer connections, so cleanupPeerConnections wouldn't cover this path.)
+      this.clearLostQualityTimeout();
       if (((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED ||
       // signaling state could change to closed due to hardware sleep
       // those connections cannot be resumed
       ((_c = (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.currentState) !== null && _c !== void 0 ? _c : PCTransportState.NEW) === PCTransportState.NEW) {
         this.fullReconnectOnNext = true;
       }
+      // Consume the flag up front: capture whether this attempt is a full reconnect, then reset
+      // it. From here on a `true` value unambiguously represents a *new* full-reconnect request
+      // that arrived while this attempt was running (e.g. a server RECONNECT leave), which the
+      // finally block dispatches — for both the resume and full-reconnect paths.
+      const fullReconnect = this.fullReconnectOnNext;
+      this.fullReconnectOnNext = false;
+      let succeeded = false;
       try {
         this.attemptingReconnect = true;
-        if (this.fullReconnectOnNext) {
+        if (fullReconnect) {
           yield this.restartConnection();
         } else {
           yield this.resumeConnection(reason);
         }
         this.clearPendingReconnect();
-        this.fullReconnectOnNext = false;
+        succeeded = true;
       } catch (e) {
         this.reconnectAttempts += 1;
         let recoverable = true;
@@ -23198,8 +25065,9 @@ class RTCEngine extends eventsExports.EventEmitter {
           });
           // unrecoverable
           recoverable = false;
-        } else if (!(e instanceof SignalReconnectError)) {
-          // cannot resume
+        } else if (fullReconnect || !(e instanceof SignalReconnectError)) {
+          // a failed full reconnect stays a full reconnect; a failed resume can only be
+          // resumed again for a signal-level error, otherwise it escalates
           this.fullReconnectOnNext = true;
         }
         if (recoverable) {
@@ -23207,10 +25075,17 @@ class RTCEngine extends eventsExports.EventEmitter {
         } else {
           this.log.info("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms. giving up"));
           this.emit(EngineEvent.Disconnected);
-          yield this.close();
+          yield this.close("gave up reconnecting after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms"));
         }
       } finally {
         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
+        // (the failure path already retries).
+        if (succeeded && this.fullReconnectOnNext && !this._isClosed) {
+          this.log.debug('full reconnect requested during in-progress attempt, dispatching');
+          this.handleDisconnect('reconnect');
+        }
       }
     });
   }
@@ -23529,14 +25404,23 @@ class RTCEngine extends eventsExports.EventEmitter {
     if (!this.pcManager) {
       return false;
     }
+    const state = this.pcManager.currentState;
     const allowedConnectionStates = [PCTransportState.CONNECTING, PCTransportState.CONNECTED];
-    if (!allowedConnectionStates.includes(this.pcManager.currentState)) {
+    if (!allowedConnectionStates.includes(state)) {
       return false;
     }
     // ensure signal is connected
     if (!this.client.ws || this.client.ws.readyState === WebSocket.CLOSED) {
       return false;
     }
+    // A transport stuck in CONNECTING never reaches CONNECTED nor reports FAILED, so it would
+    // otherwise look healthy forever; bound how long we tolerate it. The entry time is recorded
+    // in the pcManager state-change handler (see configure()), so this is a pure read — an
+    // unrecorded CONNECTING fails open rather than measuring against a stale timestamp.
+    if (state === PCTransportState.CONNECTING && this.transportConnectingSince !== undefined && Date.now() - this.transportConnectingSince > this.peerConnectionTimeout) {
+      this.log.warn('transport stuck in connecting state', this.logContext);
+      return false;
+    }
     return true;
   }
   /** @internal */
@@ -24178,9 +26062,7 @@ class TextStreamReader extends BaseStreamReader {
     // Suppress unhandled rejection on reader.closed — errors are
     // already propagated through reader.read() to the consumer.
     reader.closed.catch(() => {});
-    const decoder = new TextDecoder('utf-8', {
-      fatal: true
-    });
+    const decoder = new TextDecoder('utf-8');
     const signal = this.signal;
     const cleanup = () => {
       reader.releaseLock();
@@ -24658,9 +26540,7 @@ function bytesToChunks(streamId) {
  * synthesized text chunk decodes independently. The `flush` emits the decoder's trailing bytes.
  */
 function bytesToDecodedUtf8(streamId) {
-  const decoder = new TextDecoder('utf-8', {
-    fatal: true
-  });
+  const decoder = new TextDecoder('utf-8');
   const encoder = new TextEncoder();
   let outIndex = 0;
   const decodeOrThrow = bytes => {
@@ -31440,6 +33320,7 @@ class DeferrableMap extends Map {
   ConnectionState["SignalReconnecting"] = "signalReconnecting";
 })(ConnectionState || (ConnectionState = {}));
 const CONNECTION_RECONCILE_FREQUENCY_MS = 4 * 1000;
+const STATS_LOG_FREQUENCY_MS = 30 * 1000;
 /**
  * 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.
@@ -31458,7 +33339,7 @@ class Room extends eventsExports.EventEmitter {
    */
   constructor(options) {
     var _this;
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     super();
     _this = this;
     this.state = ConnectionState.Disconnected;
@@ -31473,8 +33354,10 @@ class Room extends eventsExports.EventEmitter {
     this.e2eeStateMutex = new _();
     this.isVideoPlaybackBlocked = false;
     this.log = livekitLogger;
+    this.statsLog = livekitLogger;
     this.bufferedEvents = [];
     this.isResuming = false;
+    this.pendingTrackAddedCallbacks = new Map();
     this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       var _a;
       if (!isBrowserSupported()) {
@@ -31904,7 +33787,7 @@ class Room extends eventsExports.EventEmitter {
         let remoteParticipant = this.remoteParticipants.get(info.identity);
         // when it's disconnected, send updates
         if (info.state === ParticipantInfo_State.DISCONNECTED) {
-          this.handleParticipantDisconnected(info.identity, remoteParticipant);
+          this.handleParticipantDisconnected(info.identity, remoteParticipant, info.disconnectReason === DisconnectReason.UNKNOWN_REASON ? undefined : info.disconnectReason);
         } else {
           // create participant if doesn't exist
           this.getOrCreateParticipant(info.identity, info);
@@ -31990,8 +33873,9 @@ class Room extends eventsExports.EventEmitter {
           return;
         }
         const newStreamState = Track.streamStateFromProto(streamState.state);
+        const prevStreamState = pub.track.streamState;
         pub.track.setStreamState(newStreamState);
-        if (newStreamState !== pub.track.streamState) {
+        if (newStreamState !== prevStreamState) {
           participant.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState);
           this.emitWhenConnected(RoomEvent.TrackStreamStateChanged, pub, pub.track.streamState, participant);
         }
@@ -32009,6 +33893,7 @@ class Room extends eventsExports.EventEmitter {
       pub.setAllowed(update.allowed);
     };
     this.handleSubscriptionError = update => {
+      this.cancelPendingTrackAdded(update.trackSid);
       const participant = Array.from(this.remoteParticipants.values()).find(p => p.trackPublications.has(update.trackSid));
       if (!participant) {
         return;
@@ -32154,6 +34039,34 @@ class Room extends eventsExports.EventEmitter {
     this.getAllRemoteParticipantIdentities = () => {
       return Array.from(this.remoteParticipants.keys());
     };
+    /**
+     * Dumps stats of both peer connections.
+     */
+    this.logWebRTCStats = () => __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c, _d;
+      const pcManager = (_a = this.engine) === null || _a === void 0 ? void 0 : _a.pcManager;
+      if (!pcManager) {
+        return;
+      }
+      try {
+        const _yield$Promise$all = yield Promise.all([pcManager.publisher.getStats(), (_b = pcManager.subscriber) === null || _b === void 0 ? void 0 : _b.getStats()]),
+          _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2),
+          publisher = _yield$Promise$all2[0],
+          subscriber = _yield$Promise$all2[1];
+        const publisherStats = publisher && summarizeStatsReport(publisher);
+        const subscriberStats = subscriber && summarizeStatsReport(subscriber);
+        this.statsLog.info("webrtc stats", {
+          publisher: publisherStats === null || publisherStats === void 0 ? void 0 : publisherStats.connection,
+          subscriber: subscriberStats === null || subscriberStats === void 0 ? void 0 : subscriberStats.connection,
+          inbound: [...((_c = publisherStats === null || publisherStats === void 0 ? void 0 : publisherStats.inbound) !== null && _c !== void 0 ? _c : []), ...((_d = subscriberStats === null || subscriberStats === void 0 ? void 0 : subscriberStats.inbound) !== null && _d !== void 0 ? _d : [])],
+          outbound: publisherStats === null || publisherStats === void 0 ? void 0 : publisherStats.outbound
+        });
+      } catch (error) {
+        this.statsLog.debug('could not collect webrtc stats', {
+          error
+        });
+      }
+    });
     this.onLocalParticipantMetadataChanged = metadata => {
       this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
     };
@@ -32224,12 +34137,15 @@ class Room extends eventsExports.EventEmitter {
     this.sidToIdentity = new Map();
     this.options = Object.assign(Object.assign({}, roomOptionDefaults), options);
     this.log = getLogger((_a = this.options.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Room, () => this.logContext);
+    // its own logger name, so the stats dumps can be silenced or routed
+    // separately from the rest of the room's logs
+    this.statsLog = getLogger(LoggerNames.Stats, () => this.logContext);
     this.transcriptionReceivedTimes = new Map();
     this.options.audioCaptureDefaults = Object.assign(Object.assign({}, audioDefaults), options === null || options === void 0 ? void 0 : options.audioCaptureDefaults);
     this.options.videoCaptureDefaults = Object.assign(Object.assign({}, videoDefaults), options === null || options === void 0 ? void 0 : options.videoCaptureDefaults);
     this.options.publishDefaults = Object.assign(Object.assign({}, publishDefaults), options === null || options === void 0 ? void 0 : options.publishDefaults);
     this.maybeCreateEngine();
-    this.incomingDataStreamManager = new IncomingDataStreamManager();
+    this.incomingDataStreamManager = new IncomingDataStreamManager((_b = this.options.dataStream) === null || _b === void 0 ? void 0 : _b.maxPayloadByteLength);
     this.outgoingDataStreamManager = new OutgoingDataStreamManager(this.engine, this.log, this.getRemoteParticipantClientProtocol, this.getRemoteParticipantCapabilities, this.getAllRemoteParticipantIdentities);
     this.incomingDataTrackManager = new IncomingDataTrackManager({
       e2eeManager: this.e2eeManager
@@ -32292,15 +34208,15 @@ class Room extends eventsExports.EventEmitter {
       this.setupE2EE();
     }
     this.engine.e2eeManager = this.e2eeManager;
-    this.incomingDataTrackManager.updateE2eeManager((_b = this.e2eeManager) !== null && _b !== void 0 ? _b : null);
-    this.outgoingDataTrackManager.updateE2eeManager((_c = this.e2eeManager) !== null && _c !== void 0 ? _c : null);
+    this.incomingDataTrackManager.updateE2eeManager((_c = this.e2eeManager) !== null && _c !== void 0 ? _c : null);
+    this.outgoingDataTrackManager.updateE2eeManager((_d = this.e2eeManager) !== null && _d !== void 0 ? _d : null);
     if (this.options.videoCaptureDefaults.deviceId) {
       this.localParticipant.activeDeviceMap.set('videoinput', unwrapConstraint(this.options.videoCaptureDefaults.deviceId));
     }
     if (this.options.audioCaptureDefaults.deviceId) {
       this.localParticipant.activeDeviceMap.set('audioinput', unwrapConstraint(this.options.audioCaptureDefaults.deviceId));
     }
-    if ((_d = this.options.audioOutput) === null || _d === void 0 ? void 0 : _d.deviceId) {
+    if ((_e = this.options.audioOutput) === null || _e === void 0 ? void 0 : _e.deviceId) {
       this.switchActiveDevice('audiooutput', unwrapConstraint(this.options.audioOutput.deviceId)).catch(e => this.log.warn("Could not set audio output: ".concat(e.message)));
     }
     if (isWeb()) {
@@ -32327,7 +34243,7 @@ class Room extends eventsExports.EventEmitter {
         onDeviceChange = this.handleDeviceChange;
       }
       // in order to catch device changes prior to room connection we need to register the event in the constructor
-      (_f = (_e = navigator.mediaDevices) === null || _e === void 0 ? void 0 : _e.addEventListener) === null || _f === void 0 ? void 0 : _f.call(_e, 'devicechange', onDeviceChange, {
+      (_g = (_f = navigator.mediaDevices) === null || _f === void 0 ? void 0 : _f.addEventListener) === null || _g === void 0 ? void 0 : _g.call(_f, 'devicechange', onDeviceChange, {
         signal: cleanupController.signal
       });
     }
@@ -32521,10 +34437,10 @@ class Room extends eventsExports.EventEmitter {
       }
       this.emitBufferedEvents();
     }).on(EngineEvent.SignalResumed, () => {
-      this.bufferedEvents = [];
       if (this.state === ConnectionState.Reconnecting || this.isResuming) {
         this.sendSyncState();
       }
+      this.emitBufferedEvents();
     }).on(EngineEvent.Restarting, this.handleRestarting).on(EngineEvent.Restarted, this.handleRestarted).on(EngineEvent.SignalRestarted, this.handleSignalRestarted).on(EngineEvent.Offline, () => {
       if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
         this.emit(RoomEvent.Reconnecting);
@@ -32941,29 +34857,43 @@ class Room extends eventsExports.EventEmitter {
     this.maybeCreateEngine();
   }
   onTrackAdded(mediaTrack, stream, receiver) {
+    var _a, _b;
     // don't fire onSubscribed when connecting
     // WebRTC fires onTrack as soon as setRemoteDescription is called on the offer
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
+    if ([ConnectionState.Connecting, ConnectionState.Reconnecting].includes(this.state)) {
+      const pendingTrackSid = extractTrackSid(mediaTrack, stream);
+      this.log.debug('deferring on track for later', {
+        mediaTrackId: mediaTrack.id,
+        mediaStreamId: stream.id,
+        tracksInStream: stream.getTracks().map(track => track.id)
+      });
       const reconnectedHandler = () => {
-        this.log.debug('deferring on track for later', {
-          mediaTrackId: mediaTrack.id,
-          mediaStreamId: stream.id,
-          tracksInStream: stream.getTracks().map(track => track.id)
-        });
-        this.onTrackAdded(mediaTrack, stream, receiver);
         cleanup();
+        this.onTrackAdded(mediaTrack, stream, receiver);
       };
       const cleanup = () => {
         this.off(RoomEvent.Reconnected, reconnectedHandler);
         this.off(RoomEvent.Connected, reconnectedHandler);
         this.off(RoomEvent.Disconnected, cleanup);
+        if (pendingTrackSid) {
+          const pendingCallbacks = this.pendingTrackAddedCallbacks.get(pendingTrackSid);
+          pendingCallbacks === null || pendingCallbacks === void 0 ? void 0 : pendingCallbacks.delete(cleanup);
+          if ((pendingCallbacks === null || pendingCallbacks === void 0 ? void 0 : pendingCallbacks.size) === 0) {
+            this.pendingTrackAddedCallbacks.delete(pendingTrackSid);
+          }
+        }
       };
       this.once(RoomEvent.Reconnected, reconnectedHandler);
       this.once(RoomEvent.Connected, reconnectedHandler);
       this.once(RoomEvent.Disconnected, cleanup);
+      if (pendingTrackSid) {
+        const pendingCallbacks = (_a = this.pendingTrackAddedCallbacks.get(pendingTrackSid)) !== null && _a !== void 0 ? _a : new Set();
+        pendingCallbacks.add(cleanup);
+        this.pendingTrackAddedCallbacks.set(pendingTrackSid, pendingCallbacks);
+      }
       return;
     }
     if (this.state === ConnectionState.Disconnected) {
@@ -32976,11 +34906,10 @@ class Room extends eventsExports.EventEmitter {
     }
     const parts = unpackStreamId(stream.id);
     const participantSid = parts[0];
-    let streamId = parts[1];
-    let trackId = mediaTrack.id;
+    const streamId = parts[1];
     // firefox will get streamId (pID|trackId) instead of (pID|streamId) as it doesn't support sync tracks by stream
     // and generates its own track id instead of infer from sdp track id.
-    if (streamId && streamId.startsWith('TR')) trackId = streamId;
+    let trackId = (_b = extractTrackSid(mediaTrack, stream)) !== null && _b !== void 0 ? _b : mediaTrack.id;
     if (participantSid === this.localParticipant.sid) {
       this.log.warn('tried to create RemoteParticipant for local participant');
       return;
@@ -33024,6 +34953,10 @@ class Room extends eventsExports.EventEmitter {
       this.emit(RoomEvent.EncryptionError, new Error("Encrypted ".concat(publication.source, " track received from participant ").concat(participant.sid, ", but room does not have encryption enabled!")));
     }
   }
+  cancelPendingTrackAdded(trackSid) {
+    var _a;
+    (_a = this.pendingTrackAddedCallbacks.get(trackSid)) === null || _a === void 0 ? void 0 : _a.forEach(cleanup => cleanup());
+  }
   handleLocalTrackSubscribed(subscribedSid) {
     const findPublication = () => this.localParticipant.getTrackPublications().find(_ref6 => {
       let trackSid = _ref6.trackSid;
@@ -33131,7 +35064,7 @@ class Room extends eventsExports.EventEmitter {
       this.emit(RoomEvent.Disconnected, reason);
     }
   }
-  handleParticipantDisconnected(identity, participant) {
+  handleParticipantDisconnected(identity, participant, disconnectReason) {
     // remove and send event
     this.remoteParticipants.delete(identity);
     if (!participant) {
@@ -33142,7 +35075,7 @@ class Room extends eventsExports.EventEmitter {
     participant.trackPublications.forEach(publication => {
       participant.unpublishTrack(publication.trackSid, true);
     });
-    this.emit(RoomEvent.ParticipantDisconnected, participant);
+    this.emit(RoomEvent.ParticipantDisconnected, participant, disconnectReason);
     participant.setDisconnected();
     this.rpcClientManager.handleParticipantDisconnected(participant.identity);
   }
@@ -33287,6 +35220,7 @@ class Room extends eventsExports.EventEmitter {
       }
       this.emitWhenConnected(RoomEvent.TrackSubscribed, track, publication, participant);
     }).on(ParticipantEvent.TrackUnpublished, publication => {
+      this.cancelPendingTrackAdded(publication.trackSid);
       this.emit(RoomEvent.TrackUnpublished, publication, participant);
     }).on(ParticipantEvent.TrackUnsubscribed, (track, publication) => {
       this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
@@ -33384,6 +35318,19 @@ class Room extends eventsExports.EventEmitter {
       }();
     }));
   }
+  setStatsLogging(enabled) {
+    if (enabled) {
+      if (!this.statsLogInterval) {
+        this.statsLogInterval = CriticalTimers.setInterval(() => {
+          // logWebRTCStats handles its own errors, nothing to await here
+          this.logWebRTCStats();
+        }, STATS_LOG_FREQUENCY_MS);
+      }
+    } else if (this.statsLogInterval) {
+      CriticalTimers.clearInterval(this.statsLogInterval);
+      this.statsLogInterval = undefined;
+    }
+  }
   registerConnectionReconcile() {
     this.clearConnectionReconcile();
     let consecutiveFailures = 0;
@@ -33404,8 +35351,17 @@ class Room extends eventsExports.EventEmitter {
           } : undefined
         });
         if (consecutiveFailures >= 3) {
-          this.recreateEngine();
-          this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, DisconnectReason.STATE_MISMATCH);
+          this.clearConnectionReconcile();
+          if (this.engine && !this.engine.isClosed) {
+            // The transport silently died while we still looked connected. Try a full reconnect
+            // (keeps the room alive; the engine falls back to Disconnected if it ultimately fails).
+            this.log.warn('detected connection state mismatch, attempting full reconnect');
+            this.engine.reconnect();
+          } else {
+            // No usable engine to reconnect with; tear down.
+            this.recreateEngine();
+            this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, DisconnectReason.STATE_MISMATCH);
+          }
         }
       } else {
         consecutiveFailures = 0;
@@ -33425,6 +35381,7 @@ class Room extends eventsExports.EventEmitter {
     this.log.info("connection state changed: ".concat(this.state, " -> ").concat(state));
     this.state = state;
     this.incomingDataStreamManager.setConnected(state === ConnectionState.Connected);
+    this.setStatsLogging(state === ConnectionState.Connected);
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
     return true;
   }
@@ -34597,15 +36554,22 @@ function isObject(input) {
 const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
 function isResponseTokenValid(response) {
   const jwtPayload = decodeTokenPayload(response.participantToken);
-  if (!(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.nbf) || !(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.exp)) {
-    return true;
+  // Missing exp: TokenSourceCached would otherwise return this response forever.
+  // nbf is optional (RFC 7519); do not skip the exp check when it is absent.
+  if (!(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.exp)) {
+    return false;
   }
   const now = new Date();
-  const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
-  const nbfDate = new Date(nbfInMilliseconds);
+  if (jwtPayload.nbf) {
+    const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
+    const nbfDate = new Date(nbfInMilliseconds);
+    if (nbfDate > now) {
+      return false;
+    }
+  }
   const expInMilliseconds = jwtPayload.exp * ONE_SECOND_IN_MILLISECONDS;
   const expDate = new Date(expInMilliseconds - ONE_MINUTE_IN_MILLISECONDS);
-  return nbfDate <= now && expDate > now;
+  return expDate > now;
 }
 /** Given a LiveKit generated participant token, decodes and returns the associated {@link TokenPayload} data. */
 function decodeTokenPayload(token) {
@@ -34802,24 +36766,26 @@ class TokenSourceEndpoint extends TokenSourceCached {
       const body = yield response.json();
       return TokenSourceResponse.fromJson(body, {
         // NOTE: it could be possible that the response body could contain more fields than just
-        // what's in TokenSourceResponse depending on the implementation (ie, SandboxTokenServer)
+        // what's in TokenSourceResponse depending on the implementation (ie, DevelopmentTokenServer)
         ignoreUnknownFields: true
       });
     });
   }
 }
-class TokenSourceSandboxTokenServer extends TokenSourceEndpoint {
-  constructor(sandboxId, options) {
+class TokenSourceDevelopmentTokenServer extends TokenSourceEndpoint {
+  constructor(tokenServerId, options) {
     const _options$baseUrl = options.baseUrl,
       baseUrl = _options$baseUrl === void 0 ? 'https://cloud-api.livekit.io' : _options$baseUrl,
       rest = __rest(options, ["baseUrl"]);
     super("".concat(baseUrl, "/api/v2/sandbox/connection-details"), Object.assign(Object.assign({}, rest), {
       headers: {
-        'X-Sandbox-ID': sandboxId
+        'X-Sandbox-ID': tokenServerId
       }
     }));
   }
 }
+/** @deprecated Use {@link TokenSourceDevelopmentTokenServer} instead */
+class TokenSourceSandboxTokenServer extends TokenSourceDevelopmentTokenServer {}
 const TokenSource = {
   /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
    * credentials, either provided directly or returned from a provided function. */
@@ -34838,24 +36804,31 @@ const TokenSource = {
   /**
    * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
    * the standard endpoint format:
-   * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+   * @see https://docs.livekit.io/frontends/build/authentication/endpoint/
    */
   endpoint(url) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return new TokenSourceEndpoint(url, options);
   },
   /**
-   * TokenSource.sandboxTokenServer queries a sandbox token server for credentials,
+   * @deprecated Use {@link TokenSource.developmentTokenServer} instead
+   */
+  sandboxTokenServer(sandboxId) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new TokenSourceSandboxTokenServer(sandboxId, options);
+  },
+  /**
+   * TokenSource.developmentTokenServer queries a development token server for credentials,
    * which supports quick prototyping / getting started types of use cases.
    *
    * This token provider is INSECURE and should NOT be used in production.
    *
    * For more info:
-   * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+   * @see https://docs.livekit.io/frontends/build/authentication/sandbox-token-server/
    */
-  sandboxTokenServer(sandboxId) {
+  developmentTokenServer(tokenServerId) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return new TokenSourceSandboxTokenServer(sandboxId, options);
+    return new TokenSourceDevelopmentTokenServer(tokenServerId, options);
   }
 };/**
  * Try to analyze the local track to determine the facing mode of a track.
@@ -34983,4 +36956,4 @@ const serializers = {
   json,
   raw,
   custom
-};export{AudioPresets,BackupCodecPolicy,BaseKeyProvider,CLIENT_PROTOCOL_DATA_STREAM_RPC,CLIENT_PROTOCOL_DATA_STREAM_V2,CLIENT_PROTOCOL_DEFAULT,CheckStatus,Checker,ConnectionCheck,ConnectionError,ConnectionErrorReason,ConnectionQuality,ConnectionState,CriticalTimers,CryptorError,CryptorErrorReason,CryptorEvent,DataPacket_Kind,DataStreamError,DataStreamErrorReason,DataTrackPacket,DefaultReconnectPolicy,DeviceUnsupportedError,DisconnectReason,EncryptionEvent,Encryption_Type,EngineEvent,ExternalE2EEKeyProvider,FrameMetadataManager,KeyHandlerEvent,KeyProviderEvent,LivekitError,LivekitReasonedError,LocalAudioTrack,LocalDataTrack,LocalParticipant,LocalTrack,LocalTrackPublication,LocalTrackRecorder,LocalVideoTrack,LogLevel,LoggerNames,MediaDeviceFailure,_ as Mutex,NegotiationError,PacketTrailerManager,Participant,ParticipantEvent,ParticipantInfo_Kind as ParticipantKind,PublishDataError,PublishTrackError,RemoteAudioTrack,RemoteDataTrack,RemoteParticipant,RemoteTrack,RemoteTrackPublication,RemoteVideoTrack,Room,RoomEvent,RpcError,ScreenSharePresets,SignalReconnectError,SignalRequestError,SimulatedError,SubscriptionError,TokenSource,TokenSourceConfigurable,TokenSourceFixed,Track,TrackEvent,TrackInvalidError,TrackPublication,TrackType,UnexpectedConnectionState,UnsupportedServer,VideoPreset,VideoPresets,VideoPresets43,VideoQuality,areTokenSourceFetchOptionsEqual,asEncryptablePacket,attachToElement,attributeTypings as attributes,audioCodecs,clientProtocol,compareVersions,createAudioAnalyser,createE2EEKey,createKeyMaterialFromBuffer,createKeyMaterialFromString,createLocalAudioTrack,createLocalScreenTracks,createLocalTracks,createLocalVideoTrack,decodeTokenPayload,deriveKeys,detachTrack,facingModeFromDeviceLabel,facingModeFromLocalTrack,getBrowser,getEmptyAudioStreamTrack,getEmptyVideoStreamTrack,getLogger,importKey,isAudioCodec,isAudioTrack,isBackupCodec,isBackupVideoCodec,isBrowserSupported,isE2EESupported,isInsertableStreamSupported,isLocalParticipant,isLocalTrack,isRemoteParticipant,isRemoteTrack,isScriptTransformSupported,isSerializer,isVideoCodec,isVideoFrame,isVideoTrack,needsRbspUnescaping,parseRbsp,protocolVersion,ratchet,serializers,setLogExtension,setLogLevel,supportsAV1,supportsAdaptiveStream,supportsAudioOutputSelection,supportsDynacast,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,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