@strevokit/meeting-sdk 0.6.0 → 0.8.0

package/dist/index.js

@@ -1,4 +1,19 @@
 // src/internal/env.ts
+function subscribeNetworkChange(callback) {
+  const scope = globalThis;
+  const targets = [];
+  if (typeof scope.addEventListener === "function") {
+    targets.push({ target: globalThis, type: "online" });
+  }
+  const connection = scope.navigator?.connection;
+  if (connection && typeof connection.addEventListener === "function" && typeof connection.removeEventListener === "function") {
+    targets.push({ target: connection, type: "change" });
+  }
+  for (const { target, type } of targets) target.addEventListener(type, callback);
+  return () => {
+    for (const { target, type } of targets) target.removeEventListener(type, callback);
+  };
+}
 var override;
 function defaultEnvironment() {
   const scope = globalThis;
@@ -9,7 +24,8 @@ function defaultEnvironment() {
     MediaStream: typeof scope.MediaStream === "function" ? scope.MediaStream : void 0,
     setTimeout: (callback, ms) => globalThis.setTimeout(callback, ms),
     clearTimeout: (handle) => globalThis.clearTimeout(handle),
-    now: () => Date.now()
+    now: () => Date.now(),
+    onNetworkChange: subscribeNetworkChange
   };
 }
 function currentEnvironment() {
@@ -37,6 +53,9 @@ var MAX_ICE_SERVER_URLS = 4;
 var MAX_ICE_SERVER_URL_LENGTH = 256;
 var MAX_ICE_SERVER_USERNAME_LENGTH = 256;
 var MAX_ICE_SERVER_CREDENTIAL_LENGTH = 256;
+var MAX_QUALITY_CODEC_LENGTH = 64;
+var MAX_QUALITY_CANDIDATE_TYPE_LENGTH = 32;
+var MAX_QUALITY_FRAME_DIMENSION = 16384;
 
 // ../signaling-protocol/dist/rejection.js
 var REJECTION_CODES = Object.freeze([
@@ -185,6 +204,7 @@ var CATALOG = {
   "webrtc.connected": { family: "webrtc", direction: "client_to_server" },
   "webrtc.disconnected": { family: "webrtc", direction: "client_to_server" },
   "webrtc.failed": { family: "webrtc", direction: "client_to_server" },
+  "webrtc.quality_sample": { family: "webrtc", direction: "client_to_server" },
   "webrtc.ice_restart": { family: "webrtc", direction: "both" },
   "webrtc.ice_restart_result": { family: "webrtc", direction: "client_to_server" },
   "media.camera.started": { family: "media", direction: "both" },
@@ -417,6 +437,99 @@ function sessionWelcome(p) {
   }
   return value;
 }
+function optionalNonNegativeNumber(obj, key, path, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (raw < 0)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function optionalUnitInterval(obj, key, path, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (raw < 0 || raw > 1)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function optionalNonNegativeInt(obj, key, path, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (!Number.isInteger(raw) || raw < 0)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function optionalPositiveInt(obj, key, path, max, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    fail("wrong_type", path);
+  if (!Number.isInteger(raw) || raw < 1 || raw > max)
+    fail("out_of_range", path);
+  value[key] = raw;
+}
+function looksLikeSdpOrCandidateDump(value) {
+  if (value.includes("\r\n") || value.includes("\n"))
+    return true;
+  if (/^v=0/i.test(value))
+    return true;
+  if (/^candidate:/i.test(value))
+    return true;
+  if (/\bIN IP[46]\b/i.test(value))
+    return true;
+  return false;
+}
+function optionalShortToken(obj, key, path, maxLength, value) {
+  if (!hasOwn(obj, key))
+    return;
+  const raw = obj[key];
+  if (typeof raw !== "string")
+    fail("wrong_type", path);
+  if (raw.length === 0 || raw.length > maxLength)
+    fail(raw.length === 0 ? "invalid_format" : "too_long", path);
+  if (looksLikeSdpOrCandidateDump(raw))
+    fail("invalid_format", path);
+  if (!/^[a-zA-Z0-9._+/-]+$/.test(raw))
+    fail("invalid_format", path);
+  value[key] = raw;
+}
+var qualitySample = (p, ctx) => {
+  const value = {
+    ...peer(p, ctx),
+    connectionState: reasonCode(p, "connectionState", "payload.connectionState"),
+    sampledAt: timestamp(p, "sampledAt", "payload.sampledAt")
+  };
+  optionalNonNegativeNumber(p, "rttMs", "payload.rttMs", value);
+  optionalNonNegativeNumber(p, "jitterMs", "payload.jitterMs", value);
+  optionalUnitInterval(p, "packetLossRatio", "payload.packetLossRatio", value);
+  optionalNonNegativeNumber(p, "sendBitrateBps", "payload.sendBitrateBps", value);
+  optionalNonNegativeNumber(p, "receiveBitrateBps", "payload.receiveBitrateBps", value);
+  optionalShortToken(p, "iceLocalCandidateType", "payload.iceLocalCandidateType", MAX_QUALITY_CANDIDATE_TYPE_LENGTH, value);
+  optionalShortToken(p, "iceRemoteCandidateType", "payload.iceRemoteCandidateType", MAX_QUALITY_CANDIDATE_TYPE_LENGTH, value);
+  for (const key of ["path", "localPath", "remotePath"]) {
+    if (hasOwn(p, key))
+      value[key] = reasonCode(p, key, `payload.${key}`);
+  }
+  optionalNonNegativeInt(p, "framesDropped", "payload.framesDropped", value);
+  optionalPositiveInt(p, "frameWidth", "payload.frameWidth", MAX_QUALITY_FRAME_DIMENSION, value);
+  optionalPositiveInt(p, "frameHeight", "payload.frameHeight", MAX_QUALITY_FRAME_DIMENSION, value);
+  optionalShortToken(p, "codec", "payload.codec", MAX_QUALITY_CODEC_LENGTH, value);
+  if (hasOwn(p, "incomplete")) {
+    if (typeof p.incomplete !== "boolean")
+      fail("wrong_type", "payload.incomplete");
+    value.incomplete = p.incomplete;
+  }
+  return value;
+};
 var VALIDATORS = {
   "participant.join": empty,
   "participant.joined": (p) => optionalDisplayName(p, { role: role(p) }),
@@ -442,6 +555,7 @@ var VALIDATORS = {
     ...peer(p, ctx),
     reason: reasonCode(p, "reason", "payload.reason")
   }),
+  "webrtc.quality_sample": qualitySample,
   "webrtc.ice_restart": (p, ctx) => ({
     targetParticipantId: participantRef(p, "targetParticipantId", "payload.targetParticipantId", ctx, false)
   }),
@@ -948,10 +1062,14 @@ var LocalMediaController = class {
       throw mapped;
     }
   }
-  /** A capture the browser or device ended (unplugged, revoked, "Stop sharing") turns that kind off and is announced. */
+  /**
+   * A capture the browser or device ended. A live camera or unmuted microphone continues on another listed
+   * device of that kind when one can be opened. Otherwise the kind turns off and is announced. Screen share
+   * always turns off. A muted microphone is dropped and is not replaced.
+   */
   #watchEnded(kind, stream) {
     const onEnded = () => {
-      if (this.#streams[kind] !== stream) return;
+      if (this.#released || this.#streams[kind] !== stream) return;
       if (!this.#state[kind]) {
         if (kind === "microphone") {
           this.#streams.microphone = null;
@@ -959,11 +1077,78 @@ var LocalMediaController = class {
         }
         return;
       }
-      this.#log.info(kind === "screen" ? "screen share ended by the browser" : "capture ended", { kind });
-      this.set(kind, false).catch(() => void 0);
+      if (kind === "screen") {
+        this.#log.info("screen share ended by the browser", { kind });
+        this.set(kind, false).catch(() => void 0);
+        return;
+      }
+      const generation = this.#generation;
+      const scheduled = this.#tails[kind].then(() => this.#continueOnAnotherDevice(kind, stream, generation));
+      this.#tails[kind] = scheduled.then(
+        () => void 0,
+        () => void 0
+      );
     };
     for (const track of stream.getTracks()) track.addEventListener("ended", onEnded, { once: true });
   }
+  /** The capture that just ended is still the one in use, and the meeting has not been released. */
+  #stillCurrent(kind, stream, generation) {
+    return !this.#released && this.#generation === generation && this.#state[kind] && this.#streams[kind] === stream;
+  }
+  /**
+   * Opens the first remaining device of `kind` and installs it the same way as a live switch. When none can be
+   * opened, turns `kind` off. A release or a newer capture during the attempt stops the new stream and emits nothing.
+   */
+  async #continueOnAnotherDevice(kind, endedStream, generation) {
+    if (!this.#stillCurrent(kind, endedStream, generation)) return;
+    const endedId = this.#devices[kind] ?? deviceOf(endedStream, void 0);
+    const candidates = await this.#otherDevices(kind, endedId);
+    if (!this.#stillCurrent(kind, endedStream, generation)) return;
+    for (const deviceId of candidates) {
+      if (!this.#stillCurrent(kind, endedStream, generation)) return;
+      let stream;
+      try {
+        stream = await this.#capture(kind, deviceId);
+      } catch {
+        continue;
+      }
+      if (!this.#stillCurrent(kind, endedStream, generation)) {
+        stopTracks(stream);
+        return;
+      }
+      this.#streams[kind] = stream;
+      this.#devices[kind] = deviceOf(stream, deviceId);
+      this.#watchEnded(kind, stream);
+      this.#hooks.changed(kind, true, stream);
+      stopTracks(endedStream);
+      this.#log.info("capture continued on another device", { kind, reason: "capture_fallback" });
+      return;
+    }
+    if (!this.#stillCurrent(kind, endedStream, generation)) return;
+    this.#log.info("capture ended", { kind });
+    try {
+      this.#turnOff(kind, true);
+    } catch {
+    }
+  }
+  /** Listed devices of `kind`, excluding the one that just ended and any empty id. */
+  async #otherDevices(kind, endedId) {
+    const devices = this.#env.mediaDevices;
+    if (typeof devices?.enumerateDevices !== "function") return [];
+    let listed;
+    try {
+      listed = await devices.enumerateDevices();
+    } catch {
+      return [];
+    }
+    const wanted = kind === "camera" ? "videoinput" : "audioinput";
+    const ids = [];
+    for (const device of listed) {
+      if (device.kind !== wanted || !device.deviceId || device.deviceId === endedId || ids.includes(device.deviceId)) continue;
+      ids.push(device.deviceId);
+    }
+    return ids;
+  }
 };
 
 // src/internal/log.ts
@@ -980,7 +1165,17 @@ var ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "attempt",
   "path",
   "localPath",
-  "remotePath"
+  "remotePath",
+  "trigger",
+  "elapsedMs",
+  "requestId",
+  "correlationId",
+  "rttMs",
+  "jitterMs",
+  "packetLossRatio",
+  "sendBitrateBps",
+  "receiveBitrateBps",
+  "incomplete"
 ]);
 var JWT_SHAPE = /[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*/;
 var NEGOTIATION_CONTENT = /sdp|candidate/i;
@@ -1062,6 +1257,233 @@ var SignalingOnlyMediaDelivery = class {
   }
 };
 
+// src/internal/reconnect/backoff.ts
+var RECONNECT_BACKOFF_BASE_MS = 500;
+var RECONNECT_BACKOFF_FACTOR = 2;
+var RECONNECT_BACKOFF_CAP_MS = 8e3;
+var RECONNECT_BACKOFF_JITTER = 0.2;
+function reconnectBackoffMs(attempt, clock = Math) {
+  const n = Math.max(1, Math.floor(attempt));
+  const raw = Math.min(RECONNECT_BACKOFF_CAP_MS, RECONNECT_BACKOFF_BASE_MS * RECONNECT_BACKOFF_FACTOR ** (n - 1));
+  const jitter = 1 + (clock.random() * 2 - 1) * RECONNECT_BACKOFF_JITTER;
+  return Math.max(0, Math.round(raw * jitter));
+}
+
+// src/internal/reconnect/recoveryWindow.ts
+var DEFAULT_RECONNECT_WINDOW_MS = 12e4;
+var MIN_RECONNECT_WINDOW_MS = 1e3;
+var MAX_RECONNECT_WINDOW_MS = 6e5;
+function clampReconnectWindowMs(value) {
+  if (value === void 0) return DEFAULT_RECONNECT_WINDOW_MS;
+  if (typeof value !== "number" || !Number.isInteger(value) || !Number.isFinite(value)) {
+    return DEFAULT_RECONNECT_WINDOW_MS;
+  }
+  if (value < MIN_RECONNECT_WINDOW_MS) return MIN_RECONNECT_WINDOW_MS;
+  if (value > MAX_RECONNECT_WINDOW_MS) return MAX_RECONNECT_WINDOW_MS;
+  return value;
+}
+function markRecoveryWindowStart(state, nowMs) {
+  if (state.windowStartedAtMs === void 0) state.windowStartedAtMs = nowMs;
+}
+function resetRecoveryWindow(state) {
+  state.windowStartedAtMs = void 0;
+}
+function isRecoveryWindowExhausted(state, nowMs) {
+  if (state.windowStartedAtMs === void 0) return false;
+  return nowMs - state.windowStartedAtMs >= state.windowMs;
+}
+
+// src/internal/reconnect/reasons.ts
+var REASON_CLASSES = /* @__PURE__ */ new Set([
+  "token_refresh_failed",
+  "admission_refused",
+  "recovery_window_exhausted",
+  "meeting_ended",
+  "session_replaced",
+  "left",
+  "hard_failure"
+]);
+var TRIGGERS = /* @__PURE__ */ new Set(["meeting_service", "media", "network", "visibility"]);
+var FORBIDDEN_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "joinToken",
+  "join_token",
+  "authorization",
+  "Authorization",
+  "password",
+  "credential",
+  "sdp",
+  "candidate",
+  "ice"
+]);
+function isReconnectReasonClass(value) {
+  return REASON_CLASSES.has(value);
+}
+function isReconnectTrigger(value) {
+  return TRIGGERS.has(value);
+}
+function reconnectLogFields(input) {
+  const out = {};
+  const attempt = Math.max(1, Math.floor(input.attempt));
+  out.attempt = attempt;
+  if (input.trigger !== void 0 && isReconnectTrigger(input.trigger)) out.trigger = input.trigger;
+  if (typeof input.elapsedMs === "number" && Number.isFinite(input.elapsedMs) && input.elapsedMs >= 0) {
+    out.elapsedMs = Math.floor(input.elapsedMs);
+  }
+  if (input.reason !== void 0 && isReconnectReasonClass(input.reason)) out.reason = input.reason;
+  for (const key of ["meetingId", "participantId", "requestId", "correlationId"]) {
+    const value = input[key];
+    if (typeof value === "string" && value.length > 0) out[key] = value;
+  }
+  for (const key of Object.keys(input)) {
+    if (FORBIDDEN_FIELD_KEYS.has(key)) {
+    }
+  }
+  return out;
+}
+
+// src/internal/reconnect/reconnectController.ts
+var ReconnectController = class {
+  #env;
+  #logger;
+  #open;
+  #onAbandoned;
+  #clock;
+  #window;
+  #active = false;
+  #attempt = 0;
+  #trigger = "meeting_service";
+  #timer;
+  #generation = 0;
+  #inFlight = false;
+  constructor(deps) {
+    this.#env = deps.env;
+    this.#logger = deps.logger;
+    this.#open = deps.open;
+    this.#onAbandoned = deps.onAbandoned;
+    this.#clock = { random: deps.random ?? (() => Math.random()) };
+    this.#window = { windowMs: deps.windowMs, windowStartedAtMs: void 0 };
+  }
+  get active() {
+    return this.#active;
+  }
+  get attempt() {
+    return this.#attempt;
+  }
+  /**
+   * Starts (or continues) a single active reconnect chain.
+   * Overlapping starts while already active are ignored.
+   */
+  start(trigger = "meeting_service") {
+    if (this.#active) return;
+    this.#active = true;
+    this.#trigger = trigger;
+    this.#attempt = 0;
+    markRecoveryWindowStart(this.#window, this.#env.now());
+    this.#scheduleNext(0);
+  }
+  /** Cancels further opens and clears timers. Safe to call when idle. */
+  cancel(reason = "left") {
+    if (!this.#active && this.#timer === void 0) return;
+    const attempt = Math.max(1, this.#attempt);
+    const started = this.#window.windowStartedAtMs;
+    const elapsedMs = started === void 0 ? 0 : Math.max(0, this.#env.now() - started);
+    this.#clearTimer();
+    this.#generation += 1;
+    this.#active = false;
+    this.#inFlight = false;
+    resetRecoveryWindow(this.#window);
+    this.#log("info", "reconnect cancelled", {
+      attempt,
+      elapsedMs,
+      reason,
+      trigger: this.#trigger
+    });
+  }
+  #scheduleNext(delayMs) {
+    this.#clearTimer();
+    const generation = this.#generation;
+    const run = () => {
+      if (generation !== this.#generation) return;
+      void this.#runAttempt();
+    };
+    if (delayMs <= 0) {
+      queueMicrotask(run);
+      return;
+    }
+    this.#timer = this.#env.setTimeout(run, delayMs);
+  }
+  async #runAttempt() {
+    if (!this.#active || this.#inFlight) return;
+    const now = this.#env.now();
+    if (isRecoveryWindowExhausted(this.#window, now)) {
+      this.#abandon("recovery_window_exhausted");
+      return;
+    }
+    this.#attempt += 1;
+    const attempt = this.#attempt;
+    const generation = this.#generation;
+    this.#inFlight = true;
+    this.#log("info", "reconnect attempt started", { attempt, trigger: this.#trigger });
+    let result = "failed";
+    try {
+      result = await this.#open(attempt);
+    } catch {
+      result = "failed";
+    }
+    if (generation !== this.#generation) return;
+    this.#inFlight = false;
+    const started = this.#window.windowStartedAtMs;
+    const elapsedMs = started === void 0 ? 0 : Math.max(0, this.#env.now() - started);
+    if (result === "recovered") {
+      this.#active = false;
+      resetRecoveryWindow(this.#window);
+      this.#log("info", "reconnect succeeded", { attempt, elapsedMs, trigger: this.#trigger });
+      return;
+    }
+    if (result === "cancelled") {
+      this.cancel("left");
+      return;
+    }
+    if (result === "failed") {
+      this.#abandon("hard_failure");
+      return;
+    }
+    if (isRecoveryWindowExhausted(this.#window, this.#env.now())) {
+      this.#abandon("recovery_window_exhausted");
+      return;
+    }
+    const delay = reconnectBackoffMs(attempt + 1, this.#clock);
+    this.#scheduleNext(delay);
+  }
+  #abandon(reason) {
+    const attempt = Math.max(1, this.#attempt);
+    const started = this.#window.windowStartedAtMs;
+    const elapsedMs = started === void 0 ? 0 : Math.max(0, this.#env.now() - started);
+    this.#clearTimer();
+    this.#generation += 1;
+    this.#active = false;
+    this.#inFlight = false;
+    resetRecoveryWindow(this.#window);
+    this.#log("warn", "reconnect failed", { attempt, elapsedMs, reason, trigger: this.#trigger });
+    this.#onAbandoned?.(reason);
+  }
+  #clearTimer() {
+    if (this.#timer !== void 0) this.#env.clearTimeout(this.#timer);
+    this.#timer = void 0;
+  }
+  #log(level, message, fields) {
+    const logger = this.#logger;
+    if (!logger) return;
+    const method = logger[level];
+    if (typeof method !== "function") return;
+    try {
+      method.call(logger, message, reconnectLogFields(fields));
+    } catch {
+    }
+  }
+};
+
 // src/internal/roster.ts
 function snapshot(entry) {
   const media = Object.freeze({ ...entry.media });
@@ -1131,6 +1553,11 @@ var Roster = class {
     this.#entries.clear();
     this.#cache = void 0;
   }
+  /** Clears participants and returns to the uncommitted (joining) buffer state. */
+  reset() {
+    this.clear();
+    this.#committed = false;
+  }
 };
 
 // src/internal/signalingSession.ts
@@ -1155,6 +1582,7 @@ var PEER_OUTBOUND_TYPES = Object.freeze([
   "webrtc.connected",
   "webrtc.disconnected",
   "webrtc.failed",
+  "webrtc.quality_sample",
   "webrtc.ice_restart",
   "webrtc.ice_restart_result"
 ]);
@@ -1294,6 +1722,49 @@ var SignalingSession = class {
   }
 };
 
+// src/internal/token.ts
+var TOKEN_EXPIRY_SKEW_MS = 3e4;
+var BASE64URL = /^[A-Za-z0-9_-]+$/;
+function decodeSegment(segment) {
+  if (!BASE64URL.test(segment)) throw new MeetingError("join_token_invalid");
+  const padded = segment.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(segment.length / 4) * 4, "=");
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+function decodeClaims(token) {
+  const segments = token.split(".");
+  if (segments.length !== 3) throw new MeetingError("join_token_invalid");
+  let claims;
+  try {
+    claims = decodeSegment(segments[1] ?? "");
+  } catch {
+    throw new MeetingError("join_token_invalid");
+  }
+  if (typeof claims !== "object" || claims === null || Array.isArray(claims)) {
+    throw new MeetingError("join_token_invalid");
+  }
+  return claims;
+}
+function decodeAddressing(token) {
+  const claims = decodeClaims(token);
+  const { meeting_id: meetingId, participant_id: participantId } = claims;
+  if (!isCanonicalUlid(meetingId) || !isCanonicalUlid(participantId)) {
+    throw new MeetingError("join_token_invalid");
+  }
+  return { meetingId, participantId };
+}
+function isJoinTokenUsable(token, nowMs, skewMs = TOKEN_EXPIRY_SKEW_MS) {
+  try {
+    const claims = decodeClaims(token);
+    const exp = claims.exp;
+    if (typeof exp !== "number" || !Number.isFinite(exp)) return false;
+    return exp * 1e3 > nowMs + skewMs;
+  } catch {
+    return false;
+  }
+}
+
 // src/internal/engine.ts
 var LEAVE_FALLBACK_MS = 5e3;
 var RESTRICTED_PENDING_MS = 2e3;
@@ -1319,6 +1790,9 @@ var MeetingEngineImpl = class {
   #addressing;
   #env;
   #createDelivery;
+  #getJoinToken;
+  #reconnectWindowMs;
+  #logger;
   #delivery = new SignalingOnlyMediaDelivery();
   #log;
   #emitter;
@@ -1337,6 +1811,12 @@ var MeetingEngineImpl = class {
   #endMeeting;
   #endMeetingTimer;
   #pendingRestricted;
+  #reconnect;
+  #reconnectOpen;
+  #reconnectOutcome;
+  #preRecoveryParticipants;
+  #pendingAbandonReason;
+  #onVisibility;
   constructor(config) {
     this.#token = config.token;
     this.#realtimeUrl = config.realtimeUrl;
@@ -1344,6 +1824,9 @@ var MeetingEngineImpl = class {
     this.#addressing = config.addressing;
     this.#env = config.env;
     this.#createDelivery = config.createMediaDelivery;
+    this.#getJoinToken = config.getJoinToken;
+    this.#reconnectWindowMs = config.reconnectWindowMs ?? 12e4;
+    this.#logger = config.logger;
     this.#log = new Log(config.logger);
     this.#emitter = new Emitter(this.#log);
     this.#media = new LocalMediaController(
@@ -1357,6 +1840,7 @@ var MeetingEngineImpl = class {
       },
       this.#log
     );
+    this.#installVisibilityListener();
   }
   get state() {
     return this.#state;
@@ -1383,27 +1867,13 @@ var MeetingEngineImpl = class {
     if (this.#state === "closed") return Promise.reject(new MeetingError("engine_closed"));
     if (this.#state !== "idle") return Promise.reject(new MeetingError("already_joined"));
     const token = this.#token;
-    this.#token = void 0;
     if (!this.#env.WebSocket || token === void 0) return Promise.reject(new MeetingError("unsupported_environment"));
     const join = deferred();
     this.#join = join;
     this.#setState("connecting");
     if (!this.#is("connecting")) return join.promise;
     this.#joinTimer = this.#env.setTimeout(() => this.#failJoin(new MeetingError("join_timeout")), this.#joinTimeoutMs);
-    const session = new SignalingSession({
-      env: this.#env,
-      realtimeUrl: this.#realtimeUrl,
-      token,
-      addressing: this.#addressing,
-      log: this.#log,
-      callbacks: {
-        onMessage: (message) => this.#onMessage(message),
-        onProtocolError: () => this.#onProtocolError(),
-        onClose: (code) => this.#onClose(session, code)
-      }
-    });
-    this.#session = session;
-    session.open();
+    this.#openSession(token);
     return join.promise;
   }
   leave() {
@@ -1417,6 +1887,10 @@ var MeetingEngineImpl = class {
       case "joining":
         this.#failJoin(new MeetingError("join_cancelled"));
         return Promise.resolve();
+      case "reconnecting":
+        this.#cancelReconnect("left");
+        this.#finish("left");
+        return Promise.resolve();
       case "joined":
         break;
     }
@@ -1476,9 +1950,11 @@ var MeetingEngineImpl = class {
   dispose() {
     if (this.#disposed) return;
     this.#disposed = true;
+    this.#removeVisibilityListener();
     this.#emitter.clear();
     const end = this.#endMeeting;
     this.#endMeeting = void 0;
+    this.#cancelReconnect("hard_failure");
     this.#teardown();
     this.#state = "closed";
     const join = this.#join;
@@ -1529,34 +2005,45 @@ var MeetingEngineImpl = class {
     const isSelf = from === this.#addressing.participantId;
     switch (message.type) {
       case "session.authenticated": {
-        if (state !== "connecting") return;
-        this.#role = message.payload.role;
-        this.#setState("joining");
-        if (!this.#is("joining")) return;
-        if (!this.#session?.send("participant.join")) this.#failJoin(new MeetingError("connection_failed"));
+        if (state === "connecting") {
+          this.#role = message.payload.role;
+          this.#setState("joining");
+          if (!this.#is("joining")) return;
+          if (!this.#session?.send("participant.join")) this.#failJoin(new MeetingError("connection_failed"));
+          return;
+        }
+        if (state === "reconnecting") {
+          this.#role = message.payload.role;
+          if (!this.#session?.send("participant.join")) this.#failReconnectOpen(new MeetingError("connection_failed"));
+        }
         return;
       }
       case "session.welcome": {
-        if (state !== "joining") return;
-        this.#clearTimer("join");
-        this.#roster.commit();
-        const payload = message.payload;
-        const self = {
-          id: this.#addressing.participantId,
-          role: payload.role,
-          joinedAt: payload.joinedAt
-        };
-        if (payload.displayName !== void 0) self.displayName = payload.displayName;
-        this.#self = Object.freeze(self);
-        this.#role = payload.role;
-        const join = this.#join;
-        this.#join = void 0;
-        this.#setState("joined");
-        this.#emit("joined", { self: this.#self, participants: this.#roster.list() });
-        join?.resolve();
-        if (this.#is("joined")) {
-          const expiresAt = payload.iceServersExpireAt !== void 0 ? Date.parse(payload.iceServersExpireAt) : NaN;
-          this.#startDelivery(payload.mediaMode, payload.iceServers ?? [], Number.isFinite(expiresAt) ? expiresAt : null);
+        if (state === "joining") {
+          this.#clearTimer("join");
+          this.#roster.commit();
+          const payload = message.payload;
+          const self = {
+            id: this.#addressing.participantId,
+            role: payload.role,
+            joinedAt: payload.joinedAt
+          };
+          if (payload.displayName !== void 0) self.displayName = payload.displayName;
+          this.#self = Object.freeze(self);
+          this.#role = payload.role;
+          const join = this.#join;
+          this.#join = void 0;
+          this.#setState("joined");
+          this.#emit("joined", { self: this.#self, participants: this.#roster.list() });
+          join?.resolve();
+          if (this.#is("joined")) {
+            const expiresAt = payload.iceServersExpireAt !== void 0 ? Date.parse(payload.iceServersExpireAt) : NaN;
+            this.#startDelivery(payload.mediaMode, payload.iceServers ?? [], Number.isFinite(expiresAt) ? expiresAt : null);
+          }
+          return;
+        }
+        if (state === "reconnecting") {
+          this.#completeReconnectWelcome(message);
         }
         return;
       }
@@ -1572,6 +2059,7 @@ var MeetingEngineImpl = class {
       case "participant.joined": {
         if (isSelf || state === "connecting") return;
         const result = this.#roster.upsertJoined(from, message.payload.role, message.payload.displayName);
+        if (state === "reconnecting") return;
         const participant = this.#roster.get(from);
         if (result === "added" && participant) {
           this.#emit("participant_joined", { participant });
@@ -1581,7 +2069,7 @@ var MeetingEngineImpl = class {
         return;
       }
       case "participant.left": {
-        if (isSelf || state === "connecting") return;
+        if (isSelf || state === "connecting" || state === "reconnecting") return;
         if (this.#roster.remove(from) && this.#roster.committed) {
           this.#delivery.peerLeft(from);
           this.#emit("participant_left", { participantId: from, reason: mapLeftReason(message.payload.reason) });
@@ -1590,6 +2078,11 @@ var MeetingEngineImpl = class {
       }
       case "participant.reconnected": {
         if (isSelf || !this.#roster.committed) return;
+        if (!this.#roster.get(from)) {
+          this.#roster.upsertJoined(from, "participant");
+          const restored = this.#roster.get(from);
+          if (restored && this.#is("joined")) this.#delivery.peerPresent(from, restored.media);
+        }
         this.#delivery.peerReconnected(from);
         this.#emit("participant_reconnected", { participantId: from });
         return;
@@ -1612,20 +2105,23 @@ var MeetingEngineImpl = class {
       case "meeting.terminated": {
         this.#log.info("meeting ended", { messageType: message.type });
         if (state === "connecting" || state === "joining") this.#failJoin(new MeetingError("meeting_ended"));
-        else this.#finish("meeting_ended");
+        else {
+          this.#cancelReconnect("meeting_ended");
+          this.#finish("meeting_ended");
+        }
         return;
       }
       case "session.rejected": {
         const payload = message.payload;
         const isEndMeetingRejection = payload.ref_type === "meeting.end" || payload.refType === "meeting.end" || this.#endMeeting !== void 0;
         if (this.#endMeeting && isEndMeetingRejection) {
-          const deferred2 = this.#endMeeting;
+          const pending = this.#endMeeting;
           this.#clearEndMeetingTimer();
           this.#endMeeting = void 0;
           let mappedCode = "service_unavailable";
           if (payload.code === "role_not_allowed") mappedCode = "not_permitted";
           else if (payload.code === "rate_limited") mappedCode = "rate_limited";
-          deferred2.reject(new MeetingError(mappedCode));
+          pending.reject(new MeetingError(mappedCode));
           return;
         }
         this.#onRejected(payload.code);
@@ -1681,6 +2177,13 @@ var MeetingEngineImpl = class {
       this.#failJoin(error);
       return;
     }
+    if (this.#state === "reconnecting" && this.#reconnectOpen) {
+      const session = this.#session;
+      this.#session = void 0;
+      session?.close();
+      this.#failReconnectOpen(error, error.retryable);
+      return;
+    }
     if (code === "role_not_allowed") {
       const pending = this.#pendingRestricted;
       this.#clearPendingRestricted();
@@ -1706,9 +2209,35 @@ var MeetingEngineImpl = class {
       }
       case "joined": {
         const { reason, error } = mapClose(code, "after_joined");
+        if (reason === "left" || reason === "meeting_ended" || reason === "session_replaced") {
+          this.#finish(reason, error);
+          return;
+        }
+        if (this.#isRecoverableClose(reason, error)) {
+          this.#beginRecovery("meeting_service");
+          return;
+        }
         this.#finish(reason, error);
         return;
       }
+      case "reconnecting": {
+        const { reason, error } = mapClose(code, "after_joined");
+        if (reason === "meeting_ended" || reason === "session_replaced") {
+          this.#cancelReconnect(reason === "meeting_ended" ? "meeting_ended" : "session_replaced");
+          this.#finish(reason, error);
+          return;
+        }
+        if (reason === "left") {
+          this.#cancelReconnect("left");
+          this.#finish("left");
+          return;
+        }
+        const tokenFailure = error?.code === "join_token_expired" || error?.code === "join_token_invalid";
+        if (tokenFailure) this.#token = void 0;
+        const retry = tokenFailure || this.#isRecoverableClose(reason, error);
+        this.#failReconnectOpen(error ?? new MeetingError("connection_lost"), retry);
+        return;
+      }
       case "leaving":
         this.#finish("left");
         return;
@@ -1730,6 +2259,9 @@ var MeetingEngineImpl = class {
     if (this.#state === "closed") return;
     const end = this.#endMeeting;
     this.#endMeeting = void 0;
+    this.#cancelReconnect(
+      reason === "meeting_ended" ? "meeting_ended" : reason === "session_replaced" ? "session_replaced" : reason === "left" ? "left" : "hard_failure"
+    );
     this.#teardown();
     this.#setState("closed");
     this.#emit("closed", error ? { reason, error } : { reason });
@@ -1750,6 +2282,222 @@ var MeetingEngineImpl = class {
     this.#session = void 0;
     session?.close();
     this.#roster.clear();
+    this.#reconnectOpen = void 0;
+    this.#reconnectOutcome = void 0;
+    this.#preRecoveryParticipants = void 0;
+  }
+  #isRecoverableClose(reason, error) {
+    if (reason === "connection_lost") return true;
+    if (reason === "error" && error?.code === "service_unavailable") return true;
+    return false;
+  }
+  #beginRecovery(trigger) {
+    if (this.#state !== "joined" && this.#state !== "reconnecting") return;
+    if (this.#endMeeting) {
+      const end = this.#endMeeting;
+      this.#endMeeting = void 0;
+      this.#clearEndMeetingTimer();
+      end.reject(new MeetingError("connection_lost"));
+    }
+    if (this.#state === "joined") this.#preRecoveryParticipants = this.#roster.list();
+    this.#pauseDeliveryForRecovery();
+    this.#setState("reconnecting");
+    if (!this.#is("reconnecting")) return;
+    if (!this.#reconnect) {
+      this.#reconnect = new ReconnectController({
+        env: this.#env,
+        logger: this.#logger,
+        windowMs: this.#reconnectWindowMs,
+        open: () => this.#reconnectOpenAttempt(),
+        onAbandoned: (reason) => this.#onReconnectAbandoned(reason)
+      });
+    }
+    this.#reconnect.start(trigger);
+  }
+  #pauseDeliveryForRecovery() {
+    const delivery = this.#delivery;
+    for (const participant of this.#roster.list()) {
+      const media = delivery.remoteMedia(participant.id);
+      for (const kind of MEDIA_KINDS) {
+        if (media[kind]) this.#emit("remote_media_changed", { participantId: participant.id, kind, stream: null });
+      }
+      if (delivery.connectionStatus(participant.id) !== null) {
+        this.#emit("media_connection_changed", { participantId: participant.id, status: null });
+      }
+    }
+    delivery.close();
+    this.#delivery = new SignalingOnlyMediaDelivery();
+  }
+  async #reconnectOpenAttempt() {
+    if (this.#state !== "reconnecting" || this.#disposed) return "cancelled";
+    let token;
+    try {
+      token = await this.#resolveReconnectToken();
+    } catch (error) {
+      const meetingError = error instanceof MeetingError ? error : new MeetingError("join_token_invalid");
+      this.#log.warn("reconnect token refresh failed", { code: meetingError.code });
+      this.#pendingAbandonReason = "token_refresh_failed";
+      return "failed";
+    }
+    this.#roster.reset();
+    this.#reconnectOutcome = void 0;
+    const open = deferred();
+    this.#reconnectOpen = open;
+    const attemptTimer = this.#env.setTimeout(() => {
+      if (this.#reconnectOpen !== open) return;
+      const session = this.#session;
+      this.#session = void 0;
+      session?.close();
+      this.#failReconnectOpen(new MeetingError("join_timeout"), true);
+    }, this.#joinTimeoutMs);
+    this.#openSession(token);
+    try {
+      await open.promise;
+    } catch {
+    } finally {
+      this.#env.clearTimeout(attemptTimer);
+    }
+    if (this.#state !== "reconnecting" && this.#state !== "joined") {
+      return this.#reconnectOutcome ?? "cancelled";
+    }
+    return this.#reconnectOutcome ?? "failed";
+  }
+  async #resolveReconnectToken() {
+    const current = this.#token;
+    if (current !== void 0 && isJoinTokenUsable(current, this.#env.now())) return current;
+    const refresh = this.#getJoinToken;
+    if (!refresh) throw new MeetingError("join_token_expired");
+    const next = await refresh();
+    if (typeof next !== "string" || next.length === 0) throw new MeetingError("join_token_invalid");
+    const addressing = decodeAddressing(next);
+    if (addressing.meetingId !== this.#addressing.meetingId || addressing.participantId !== this.#addressing.participantId) {
+      throw new MeetingError("join_token_invalid");
+    }
+    this.#token = next;
+    return next;
+  }
+  #openSession(token) {
+    const session = new SignalingSession({
+      env: this.#env,
+      realtimeUrl: this.#realtimeUrl,
+      token,
+      addressing: this.#addressing,
+      log: this.#log,
+      callbacks: {
+        onMessage: (message) => this.#onMessage(message),
+        onProtocolError: () => this.#onProtocolError(),
+        onClose: (code) => this.#onClose(session, code)
+      }
+    });
+    this.#session = session;
+    session.open();
+  }
+  #completeReconnectWelcome(message) {
+    const payload = message.payload;
+    if (message.participantId !== this.#addressing.participantId) {
+      this.#failReconnectOpen(new MeetingError("protocol_error"));
+      return;
+    }
+    this.#roster.commit();
+    const self = {
+      id: this.#addressing.participantId,
+      role: payload.role,
+      joinedAt: payload.joinedAt
+    };
+    if (payload.displayName !== void 0) self.displayName = payload.displayName;
+    this.#self = Object.freeze(self);
+    this.#role = payload.role;
+    this.#reconnectOutcome = "recovered";
+    const open = this.#reconnectOpen;
+    this.#reconnectOpen = void 0;
+    this.#setState("joined");
+    open?.resolve();
+    if (!this.#is("joined")) {
+      this.#preRecoveryParticipants = void 0;
+      return;
+    }
+    this.#emitRecoveryRosterDiff();
+    if (!this.#is("joined")) return;
+    const expiresAt = payload.iceServersExpireAt !== void 0 ? Date.parse(payload.iceServersExpireAt) : NaN;
+    this.#startDelivery(payload.mediaMode, payload.iceServers ?? [], Number.isFinite(expiresAt) ? expiresAt : null);
+  }
+  /** Announce peers who joined or left during the outage; leave survivors quiet (no join/leave flash). */
+  #emitRecoveryRosterDiff() {
+    const previous = this.#preRecoveryParticipants ?? [];
+    this.#preRecoveryParticipants = void 0;
+    const previousIds = new Set(previous.map((participant) => participant.id));
+    const next = this.#roster.list();
+    const nextIds = new Set(next.map((participant) => participant.id));
+    for (const id of previousIds) {
+      if (!nextIds.has(id)) this.#emit("participant_left", { participantId: id, reason: "disconnected" });
+    }
+    for (const participant of next) {
+      if (!previousIds.has(participant.id)) this.#emit("participant_joined", { participant });
+    }
+  }
+  #failReconnectOpen(error, retry = false) {
+    const open = this.#reconnectOpen;
+    if (!open) return;
+    this.#reconnectOpen = void 0;
+    this.#reconnectOutcome = retry ? "retry" : "failed";
+    if (!retry) this.#log.warn("reconnect open failed", { code: error.code });
+    open.resolve();
+  }
+  #onReconnectAbandoned(reason) {
+    if (this.#state === "closed") return;
+    const actual = this.#pendingAbandonReason ?? reason;
+    this.#pendingAbandonReason = void 0;
+    this.#preRecoveryParticipants = void 0;
+    this.#reconnect = void 0;
+    if (actual === "meeting_ended") {
+      this.#finish("meeting_ended");
+      return;
+    }
+    if (actual === "session_replaced") {
+      this.#finish("session_replaced", new MeetingError("session_replaced"));
+      return;
+    }
+    if (actual === "left") {
+      this.#finish("left");
+      return;
+    }
+    const error = actual === "token_refresh_failed" ? new MeetingError("join_token_expired") : new MeetingError("connection_lost");
+    this.#finish("connection_lost", error);
+  }
+  #cancelReconnect(reason) {
+    const controller = this.#reconnect;
+    this.#reconnect = void 0;
+    this.#preRecoveryParticipants = void 0;
+    if (this.#reconnectOpen) {
+      this.#reconnectOutcome = "cancelled";
+      const open = this.#reconnectOpen;
+      this.#reconnectOpen = void 0;
+      open.resolve();
+    }
+    controller?.cancel(reason);
+  }
+  #installVisibilityListener() {
+    const doc = globalThis.document;
+    if (!doc || typeof doc.addEventListener !== "function") return;
+    this.#onVisibility = () => {
+      if (doc.visibilityState !== "visible" || this.#disposed) return;
+      if (this.#state === "reconnecting") {
+        if (this.#reconnect && !this.#reconnect.active) this.#reconnect.start("visibility");
+        return;
+      }
+      if (this.#state === "joined" && this.#session === void 0) {
+        this.#beginRecovery("visibility");
+      }
+    };
+    doc.addEventListener("visibilitychange", this.#onVisibility);
+  }
+  #removeVisibilityListener() {
+    const doc = globalThis.document;
+    const handler = this.#onVisibility;
+    this.#onVisibility = void 0;
+    if (doc && handler && typeof doc.removeEventListener === "function") {
+      doc.removeEventListener("visibilitychange", handler);
+    }
   }
   #clearEndMeetingTimer() {
     if (this.#endMeetingTimer !== void 0) this.#env.clearTimeout(this.#endMeetingTimer);
@@ -1778,13 +2526,17 @@ var MeetingEngineImpl = class {
 };
 
 // src/internal/selectedPair.ts
+function selectedCandidatePairReport(reports) {
+  const byId = new Map(reports.map((report) => [report.id, report]));
+  const selectedId = reports.find((r) => r.type === "transport" && r.selectedCandidatePairId)?.selectedCandidatePairId;
+  return (selectedId ? byId.get(selectedId) : void 0) ?? reports.find((r) => r.type === "candidate-pair" && r.state === "succeeded" && r.nominated === true);
+}
 async function selectedPair(pc) {
   const reports = await statsOf(pc);
   if (!reports) return null;
-  const byId = new Map(reports.map((report) => [report.id, report]));
-  const selectedId = reports.find((r) => r.type === "transport" && r.selectedCandidatePairId)?.selectedCandidatePairId;
-  const pair = (selectedId ? byId.get(selectedId) : void 0) ?? reports.find((r) => r.type === "candidate-pair" && r.state === "succeeded" && r.nominated === true);
+  const pair = selectedCandidatePairReport(reports);
   if (!pair?.localCandidateId || !pair.remoteCandidateId) return null;
+  const byId = new Map(reports.map((report) => [report.id, report]));
   const localType = byId.get(pair.localCandidateId)?.candidateType;
   const remoteType = byId.get(pair.remoteCandidateId)?.candidateType;
   if (!localType || !remoteType) return null;
@@ -1817,6 +2569,179 @@ function kindOf(candidateType) {
   return candidateType === "relay" ? "relayed" : "direct";
 }
 
+// src/internal/qualitySample.ts
+var QUALITY_SAMPLE_INTERVAL_MS = 5e3;
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function nonNegative(value) {
+  return value !== void 0 && value >= 0 ? value : void 0;
+}
+async function collectReports(pc) {
+  try {
+    const collection = await pc.getStats();
+    const reports = [];
+    collection.forEach((report) => reports.push(report));
+    return reports;
+  } catch {
+    return null;
+  }
+}
+function pickRttMs(reports) {
+  const pair = selectedCandidatePairReport(reports);
+  if (pair) {
+    const seconds = finiteNumber(pair.currentRoundTripTime);
+    if (seconds !== void 0) return nonNegative(seconds * 1e3);
+  }
+  for (const report of reports) {
+    if (report.type === "remote-inbound-rtp") {
+      const seconds = finiteNumber(report.roundTripTime);
+      if (seconds !== void 0) return nonNegative(seconds * 1e3);
+    }
+  }
+  return void 0;
+}
+function pickJitterMs(reports) {
+  for (const report of reports) {
+    if (report.type === "inbound-rtp") {
+      const seconds = finiteNumber(report.jitter);
+      if (seconds !== void 0) return nonNegative(seconds * 1e3);
+    }
+  }
+  return void 0;
+}
+function pickPacketLossRatio(reports) {
+  let lost = 0;
+  let received = 0;
+  let saw = false;
+  for (const report of reports) {
+    if (report.type !== "inbound-rtp") continue;
+    const packetsLost = finiteNumber(report.packetsLost);
+    const packetsReceived = finiteNumber(report.packetsReceived);
+    if (packetsLost === void 0 && packetsReceived === void 0) continue;
+    saw = true;
+    lost += Math.max(0, packetsLost ?? 0);
+    received += Math.max(0, packetsReceived ?? 0);
+  }
+  if (!saw) return void 0;
+  const total = lost + received;
+  if (total <= 0) return 0;
+  return Math.min(1, lost / total);
+}
+function sumBytes(reports, type, key) {
+  let total = 0;
+  let saw = false;
+  for (const report of reports) {
+    if (report.type !== type) continue;
+    const value = finiteNumber(report[key]);
+    if (value === void 0) continue;
+    saw = true;
+    total += Math.max(0, value);
+  }
+  return saw ? total : void 0;
+}
+function bitrateBps(current, previous, elapsedMs) {
+  if (current === void 0 || previous === void 0 || elapsedMs <= 0) return void 0;
+  const delta = current - previous;
+  if (delta < 0) return void 0;
+  return delta * 8 * 1e3 / elapsedMs;
+}
+function pickFrames(reports) {
+  let framesDropped;
+  let frameWidth;
+  let frameHeight;
+  for (const report of reports) {
+    if (report.type !== "inbound-rtp") continue;
+    const dropped = finiteNumber(report.framesDropped);
+    if (dropped !== void 0 && dropped >= 0) framesDropped = (framesDropped ?? 0) + dropped;
+    const width = finiteNumber(report.frameWidth);
+    const height = finiteNumber(report.frameHeight);
+    if (width !== void 0 && width > 0) frameWidth = width;
+    if (height !== void 0 && height > 0) frameHeight = height;
+  }
+  return {
+    ...framesDropped !== void 0 ? { framesDropped } : {},
+    ...frameWidth !== void 0 ? { frameWidth } : {},
+    ...frameHeight !== void 0 ? { frameHeight } : {}
+  };
+}
+function isQualityCodecToken(value) {
+  if (value.length === 0 || value.length > MAX_QUALITY_CODEC_LENGTH) return false;
+  if (value.includes("\r\n") || value.includes("\n")) return false;
+  if (/^v=0/i.test(value) || /^candidate:/i.test(value) || /\bIN IP[46]\b/i.test(value)) return false;
+  return /^[a-zA-Z0-9._+/-]+$/.test(value);
+}
+function pickCodec(reports) {
+  const byId = new Map(reports.map((report) => [report.id, report]));
+  for (const report of reports) {
+    if (report.type !== "inbound-rtp" && report.type !== "outbound-rtp") continue;
+    const codecId = report.codecId;
+    if (!codecId) continue;
+    const mime = byId.get(codecId)?.mimeType;
+    if (typeof mime === "string" && isQualityCodecToken(mime)) return mime;
+  }
+  for (const report of reports) {
+    if (report.type === "codec" && typeof report.mimeType === "string" && isQualityCodecToken(report.mimeType)) {
+      return report.mimeType;
+    }
+  }
+  return void 0;
+}
+async function buildQualitySample(pc, options) {
+  const sampledAt = new Date(options.nowMs).toISOString();
+  const base = {
+    connectionState: options.connectionState,
+    sampledAt
+  };
+  const reports = await collectReports(pc);
+  if (!reports) {
+    return { sample: { ...base, incomplete: true }, bytes: options.previous ?? null };
+  }
+  const rttMs = pickRttMs(reports);
+  const jitterMs = pickJitterMs(reports);
+  const packetLossRatio = pickPacketLossRatio(reports);
+  const bytesSent = sumBytes(reports, "outbound-rtp", "bytesSent");
+  const bytesReceived = sumBytes(reports, "inbound-rtp", "bytesReceived");
+  const elapsedMs = options.previous ? Math.max(0, options.nowMs - options.previous.atMs) : 0;
+  const sendBitrateBps = bitrateBps(bytesSent, options.previous?.sent, elapsedMs);
+  const receiveBitrateBps = bitrateBps(bytesReceived, options.previous?.received, elapsedMs);
+  const frames = pickFrames(reports);
+  const codec = pickCodec(reports);
+  let iceLocalCandidateType;
+  let iceRemoteCandidateType;
+  let pathFields = {};
+  try {
+    const pair = await selectedPair(pc);
+    if (pair) {
+      iceLocalCandidateType = pair.localType;
+      iceRemoteCandidateType = pair.remoteType;
+      pathFields = pathReport(pair);
+    }
+  } catch {
+  }
+  const hasCore = rttMs !== void 0 && jitterMs !== void 0 && packetLossRatio !== void 0 && sendBitrateBps !== void 0 && receiveBitrateBps !== void 0 && iceLocalCandidateType !== void 0;
+  const sample = {
+    ...base,
+    ...rttMs !== void 0 ? { rttMs } : {},
+    ...jitterMs !== void 0 ? { jitterMs } : {},
+    ...packetLossRatio !== void 0 ? { packetLossRatio } : {},
+    ...sendBitrateBps !== void 0 ? { sendBitrateBps } : {},
+    ...receiveBitrateBps !== void 0 ? { receiveBitrateBps } : {},
+    ...iceLocalCandidateType ? { iceLocalCandidateType } : {},
+    ...iceRemoteCandidateType ? { iceRemoteCandidateType } : {},
+    ...pathFields,
+    ...frames,
+    ...codec ? { codec } : {},
+    ...!hasCore ? { incomplete: true } : {}
+  };
+  const bytes = bytesSent !== void 0 || bytesReceived !== void 0 ? {
+    sent: bytesSent ?? options.previous?.sent ?? 0,
+    received: bytesReceived ?? options.previous?.received ?? 0,
+    atMs: options.nowMs
+  } : options.previous ?? null;
+  return { sample, bytes };
+}
+
 // src/internal/peerLink.ts
 var MAX_QUEUED_CANDIDATES = 64;
 var CONNECTION_TIMEOUT_MS = 3e4;
@@ -1825,6 +2750,7 @@ var SWITCH_RETRY_DELAYS_MS = [5e3, 1e4, 2e4];
 var SWITCH_DEADLINE_MARGIN_MS = 5e3;
 var SWITCH_POLL_MS = 1e3;
 var SWITCH_INTERRUPTION_HOLD_MS = 5e3;
+var INTERRUPTION_RESTART_HOLD_MS = 3e3;
 var PATH_RECHECK_DELAYS_MS = [2e3, 1e4];
 var PATH_RECHECK_INTERVAL_MS = 3e4;
 function copyServers(iceServers2) {
@@ -1877,8 +2803,15 @@ var PeerLink = class {
   #switch = null;
   #restarting = false;
   #interruptionHold;
+  #restartHold;
+  /** Local candidates gathered while an offer is being created; sent after it so the other side sees it first. */
+  #heldLocal = null;
+  #remoteOrigin;
   #lastReport = null;
   #recheckTimer;
+  #qualityTimer;
+  #qualityBytes = null;
+  #qualityRunning = false;
   /** Throws when the connection cannot be created; the owner treats that as a negotiation failure. */
   constructor(options) {
     this.peerId = options.peerId;
@@ -1926,10 +2859,10 @@ var PeerLink = class {
       this.#bindStreams();
       await this.#attachAll();
       const offer = await this.#pc.createOffer();
+      this.#heldLocal = [];
       await this.#pc.setLocalDescription(offer);
       if (this.#closed) return;
-      const sdp2 = this.#pc.localDescription?.sdp ?? offer.sdp ?? "";
-      this.#callbacks.sendOffer({ targetParticipantId: this.peerId, sdp: sdp2 });
+      this.#sendOffer(this.#pc.localDescription?.sdp ?? offer.sdp ?? "");
     });
   }
   /**
@@ -1946,6 +2879,7 @@ var PeerLink = class {
       return;
     }
     this.#offerHandled = true;
+    this.#remoteOrigin = sessionOrigin(sdp2);
     this.#run(async () => {
       await this.#pc.setRemoteDescription({ type: "offer", sdp: sdp2 });
       this.#remoteDescriptionSet = true;
@@ -1966,6 +2900,14 @@ var PeerLink = class {
       await this.#flushCandidates();
     });
   }
+  /**
+   * Answerer: whether `sdp` comes from a different connection than the one this link answered first, as when the
+   * other side replaced its connection. Such an offer needs a fresh link; a restart keeps the same origin.
+   */
+  startsNewSession(sdp2) {
+    const origin = sessionOrigin(sdp2);
+    return this.#offerHandled && this.#remoteOrigin !== void 0 && origin !== void 0 && origin !== this.#remoteOrigin;
+  }
   /** Offerer: applies the answer while an offer is outstanding; otherwise ignored. */
   acceptAnswer(sdp2) {
     if (this.role !== "offerer") {
@@ -1988,9 +2930,11 @@ var PeerLink = class {
         await this.#pc.setRemoteDescription({ type: "answer", sdp: sdp2 });
       } catch {
         this.#restartFailed();
+        this.#rescheduleInterruptionRestartIfNeeded();
         return;
       }
       await this.#flushCandidates();
+      this.#rescheduleInterruptionRestartIfNeeded();
     });
   }
   /** Replaces the server list for future candidate gathering. The current connection is untouched. */
@@ -2033,22 +2977,32 @@ var PeerLink = class {
    * another; a restart that already finished may predate the other side's fresh servers, so it does not count.
    */
   restart(reason) {
-    if (this.role !== "offerer" || this.#closed || this.#restarting) return;
+    if (this.role !== "offerer" || this.#closed || this.#restarting) return false;
     this.#restarting = true;
     this.#log.debug("media connection restart", { participantId: this.peerId, reason });
     this.#chain = this.#chain.then(async () => {
       if (this.#closed) return;
       try {
         const offer = await this.#pc.createOffer({ iceRestart: true });
+        this.#heldLocal = [];
         await this.#pc.setLocalDescription(offer);
         if (this.#closed) return;
-        const sdp2 = this.#pc.localDescription?.sdp ?? offer.sdp ?? "";
-        this.#callbacks.sendOffer({ targetParticipantId: this.peerId, sdp: sdp2 });
+        this.#sendOffer(this.#pc.localDescription?.sdp ?? offer.sdp ?? "");
       } catch {
+        this.#heldLocal = null;
         this.#restarting = false;
         this.#restartFailed();
+        this.#rescheduleInterruptionRestartIfNeeded();
       }
     });
+    return true;
+  }
+  /** The browser regained connectivity or changed networks: an offerer restarts an interrupted connection now. */
+  networkChanged() {
+    if (this.#closed || this.#status !== "interrupted" || this.role !== "offerer") return;
+    this.#clearRestartHold();
+    if (this.restart("network")) this.#callbacks.recoveryStarted("network");
+    else this.#scheduleInterruptionRestart();
   }
   addRemoteCandidate(candidate) {
     if (this.#closed) return;
@@ -2085,7 +3039,9 @@ var PeerLink = class {
     this.#clearTimer();
     this.#endSwitch();
     this.#clearInterruptionHold();
+    this.#clearRestartHold();
     this.#clearRecheck();
+    this.#stopQualitySampler();
     this.#pc.onicecandidate = null;
     this.#pc.onconnectionstatechange = null;
     this.#pc.oniceconnectionstatechange = null;
@@ -2179,6 +3135,7 @@ var PeerLink = class {
     if (this.#switch !== current || this.#closed) return;
     this.#clearSwitchTimers(current);
     this.#restarting = false;
+    this.#rescheduleInterruptionRestartIfNeeded();
     this.#log.debug("media path switch attempt failed", { participantId: this.peerId, attempt: current.attempt });
     this.#callbacks.switchResult("failed");
     if (this.#switch !== current || this.#closed) return;
@@ -2211,6 +3168,25 @@ var PeerLink = class {
     if (this.#interruptionHold !== void 0) this.#env.clearTimeout(this.#interruptionHold);
     this.#interruptionHold = void 0;
   }
+  #clearRestartHold() {
+    if (this.#restartHold !== void 0) this.#env.clearTimeout(this.#restartHold);
+    this.#restartHold = void 0;
+  }
+  /** When a concurrent restart ends and the link is still interrupted, arm another recovery. */
+  #rescheduleInterruptionRestartIfNeeded() {
+    if (this.#closed || this.#status !== "interrupted") return;
+    this.#scheduleInterruptionRestart();
+  }
+  /** Offerer: restarts the connection when an interruption outlasts the hold, without waiting for it to fail. */
+  #scheduleInterruptionRestart() {
+    if (this.role !== "offerer" || this.#restartHold !== void 0) return;
+    this.#restartHold = this.#env.setTimeout(() => {
+      this.#restartHold = void 0;
+      if (this.#closed || this.#status !== "interrupted" || coarseState(this.#pc) === "connected") return;
+      if (this.restart("interruption")) this.#callbacks.recoveryStarted("media");
+      else this.#scheduleInterruptionRestart();
+    }, INTERRUPTION_RESTART_HOLD_MS);
+  }
   #bindStreams() {
     const Stream = this.#env.MediaStream;
     if (!Stream) return;
@@ -2239,6 +3215,13 @@ var PeerLink = class {
       this.#log.debug("late candidate dropped", { participantId: this.peerId, reason: "rejected" });
     }
   }
+  /** Sends the offer, then the candidates gathered while it was being created. */
+  #sendOffer(sdp2) {
+    this.#callbacks.sendOffer({ targetParticipantId: this.peerId, sdp: sdp2 });
+    const held = this.#heldLocal;
+    this.#heldLocal = null;
+    for (const candidate of held ?? []) this.#callbacks.sendCandidate({ targetParticipantId: this.peerId, candidate });
+  }
   #onLocalCandidate(candidate) {
     if (this.#closed || !candidate || candidate.candidate === "") return;
     const payload = {
@@ -2247,7 +3230,8 @@ var PeerLink = class {
       sdpMLineIndex: candidate.sdpMLineIndex ?? null
     };
     if (typeof candidate.usernameFragment === "string") payload.usernameFragment = candidate.usernameFragment;
-    this.#callbacks.sendCandidate({ targetParticipantId: this.peerId, candidate: payload });
+    if (this.#heldLocal) this.#heldLocal.push(payload);
+    else this.#callbacks.sendCandidate({ targetParticipantId: this.peerId, candidate: payload });
   }
   #onStateChange() {
     if (this.#closed || this.#status === "failed") return;
@@ -2259,6 +3243,7 @@ var PeerLink = class {
         this.#clearTimer();
         this.#clearInterruptionHold();
         if (this.#setStatus("connected")) void this.#reportPath();
+        this.#startQualitySampler();
         return;
       case "disconnected":
         if (!this.#everConnected) return;
@@ -2270,6 +3255,7 @@ var PeerLink = class {
           return;
         }
         this.#setStatus("interrupted");
+        this.#startQualitySampler();
         return;
       case "failed":
         this.#fail("connection_failed");
@@ -2278,10 +3264,62 @@ var PeerLink = class {
         return;
     }
   }
+  #qualityConnectionState() {
+    if (this.#status === "interrupted") return "interrupted";
+    if (this.#status === "failed") return "failed";
+    if (this.#status === "connected") return "connected";
+    return "connecting";
+  }
+  #startQualitySampler() {
+    if (this.#closed || this.#qualityRunning) return;
+    this.#qualityRunning = true;
+    this.#scheduleQualitySample();
+  }
+  #stopQualitySampler() {
+    this.#qualityRunning = false;
+    if (this.#qualityTimer !== void 0) this.#env.clearTimeout(this.#qualityTimer);
+    this.#qualityTimer = void 0;
+    this.#qualityBytes = null;
+  }
+  #scheduleQualitySample() {
+    if (!this.#qualityRunning || this.#closed) return;
+    this.#qualityTimer = this.#env.setTimeout(() => {
+      this.#qualityTimer = void 0;
+      void this.#emitQualitySample();
+    }, QUALITY_SAMPLE_INTERVAL_MS);
+  }
+  async #emitQualitySample() {
+    if (!this.#qualityRunning || this.#closed) return;
+    try {
+      const result = await buildQualitySample(this.#pc, {
+        connectionState: this.#qualityConnectionState(),
+        nowMs: this.#env.now(),
+        previous: this.#qualityBytes
+      });
+      if (this.#closed || !this.#qualityRunning) return;
+      this.#qualityBytes = result.bytes;
+      this.#log.debug("webrtc quality sample", {
+        participantId: this.peerId,
+        state: result.sample.connectionState,
+        ...result.sample.rttMs !== void 0 ? { rttMs: result.sample.rttMs } : {},
+        ...result.sample.jitterMs !== void 0 ? { jitterMs: result.sample.jitterMs } : {},
+        ...result.sample.packetLossRatio !== void 0 ? { packetLossRatio: result.sample.packetLossRatio } : {},
+        ...result.sample.sendBitrateBps !== void 0 ? { sendBitrateBps: result.sample.sendBitrateBps } : {},
+        ...result.sample.receiveBitrateBps !== void 0 ? { receiveBitrateBps: result.sample.receiveBitrateBps } : {},
+        ...result.sample.path ? { path: result.sample.path } : {},
+        ...result.sample.incomplete ? { incomplete: true } : {}
+      });
+      this.#callbacks.qualitySample(result.sample);
+    } catch {
+    }
+    if (!this.#closed && this.#qualityRunning) this.#scheduleQualitySample();
+  }
   /** True when the status changed. */
   #setStatus(status, reason) {
     if (this.#status === status) return false;
     this.#status = status;
+    if (status === "interrupted") this.#scheduleInterruptionRestart();
+    else this.#clearRestartHold();
     this.#callbacks.statusChanged(status, reason);
     return true;
   }
@@ -2337,6 +3375,12 @@ var PeerLink = class {
     this.#timer = void 0;
   }
 };
+function sessionOrigin(sdp2) {
+  for (const line of sdp2.split(/\r?\n/)) {
+    if (line.startsWith("o=")) return line.split(" ")[1];
+  }
+  return void 0;
+}
 
 // src/internal/remoteMedia.ts
 var KINDS2 = ["camera", "microphone", "screen"];
@@ -2375,6 +3419,9 @@ var PeerMediaDelivery = class {
   #env;
   #log;
   #timeoutMs;
+  #recoveryWindowMs;
+  #episode = null;
+  #unsubscribeNetwork;
   #context;
   /** The latest server list; links created later use it. */
   #iceServers = [];
@@ -2395,6 +3442,7 @@ var PeerMediaDelivery = class {
     this.#env = options.env;
     this.#log = options.log;
     this.#timeoutMs = options.connectionTimeoutMs ?? CONNECTION_TIMEOUT_MS;
+    this.#recoveryWindowMs = options.recoveryWindowMs ?? DEFAULT_RECONNECT_WINDOW_MS;
   }
   attach(context) {
     if (this.#closed || this.#context) return;
@@ -2405,7 +3453,9 @@ var PeerMediaDelivery = class {
       this.#inert = true;
       this.#log.warn("media connections unsupported");
       this.#emit("error", { error: new MeetingError("unsupported_environment") });
+      return;
     }
+    this.#unsubscribeNetwork = this.#env.onNetworkChange?.(() => this.#link?.networkChanged());
   }
   peersPresent(entries) {
     if (!this.#active()) return;
@@ -2513,6 +3563,9 @@ var PeerMediaDelivery = class {
   close() {
     if (this.#closed) return;
     this.#closed = true;
+    this.#unsubscribeNetwork?.();
+    this.#unsubscribeNetwork = void 0;
+    this.#episode = null;
     const link = this.#link;
     this.#link = null;
     link?.close();
@@ -2571,10 +3624,19 @@ var PeerMediaDelivery = class {
       this.#log.debug("frame ignored", { messageType: "webrtc.offer", reason: "offerer" });
       return;
     }
-    const link = this.#link ?? this.#createLink(from);
+    let link = this.#link;
+    if (link?.startsNewSession(sdp2)) {
+      const interrupted = link.everConnected;
+      this.#link = null;
+      link.close();
+      if (interrupted) this.#openEpisode("media").replaced = true;
+      link = this.#createLink(from, interrupted ? "interrupted" : "connecting");
+      this.#refreshRemote(from);
+    }
+    link ??= this.#createLink(from);
     link?.acceptOffer(sdp2);
   }
-  #createLink(peerId) {
+  #createLink(peerId, initialStatus = "connecting") {
     const context = this.#context;
     if (!context) return null;
     let link;
@@ -2604,10 +3666,20 @@ var PeerMediaDelivery = class {
             if (this.#link === link) context.send("webrtc.connected", { peerParticipantId: peerId, ...report });
           },
           requestRestart: () => this.#link === link && this.#serverSupportsRestart && context.send("webrtc.ice_restart", { targetParticipantId: peerId }),
+          recoveryStarted: (trigger) => {
+            if (this.#link === link) this.#recoveryStarted(trigger);
+          },
           switchResult: (outcome) => {
             if (this.#link === link && this.#serverSupportsRestart) {
               context.send("webrtc.ice_restart_result", { peerParticipantId: peerId, outcome });
             }
+          },
+          qualitySample: (sample) => {
+            if (this.#link !== link) return;
+            try {
+              context.send("webrtc.quality_sample", { peerParticipantId: peerId, ...sample });
+            } catch {
+            }
           }
         }
       });
@@ -2617,7 +3689,7 @@ var PeerMediaDelivery = class {
       return null;
     }
     this.#link = link;
-    this.#setStatus(peerId, "connecting");
+    this.#setStatus(peerId, initialStatus);
     const early = this.#early.get(peerId);
     if (early) {
       this.#dropEarly(peerId);
@@ -2629,23 +3701,89 @@ var PeerMediaDelivery = class {
     const peerParticipantId = link.peerId;
     switch (status) {
       case "connected":
+        this.#recovered(peerParticipantId);
         this.#setStatus(peerParticipantId, "connected");
         this.#refreshRemote(peerParticipantId);
         return;
       case "interrupted":
+        this.#openEpisode("media");
         this.#context?.send("webrtc.disconnected", { peerParticipantId });
         this.#setStatus(peerParticipantId, "interrupted");
         return;
       case "failed":
         this.#link = null;
         link.close();
+        if (this.#replaceFailedLink(link)) return;
+        this.#giveUp(peerParticipantId);
         this.#reportFailure(peerParticipantId, reason ?? "connection_failed");
         return;
       default:
         return;
     }
   }
-  /** Reports a failed link. The pair stays as it is; nothing is retried until the peer reconnects or rejoins. */
+  #openEpisode(trigger) {
+    this.#episode ??= { startedAt: this.#env.now(), attempts: 0, trigger, replaced: false };
+    return this.#episode;
+  }
+  #recoveryStarted(trigger) {
+    const episode = this.#openEpisode(trigger);
+    episode.attempts += 1;
+    episode.trigger = trigger;
+    this.#log.info("reconnect attempt started", reconnectLogFields({ attempt: episode.attempts, trigger }));
+  }
+  /** The connection is carrying media again after a drop. */
+  #recovered(peerParticipantId) {
+    const episode = this.#episode;
+    if (!episode) return;
+    this.#episode = null;
+    this.#log.info(
+      "reconnect succeeded",
+      reconnectLogFields({
+        attempt: Math.max(1, episode.attempts),
+        trigger: episode.trigger,
+        elapsedMs: Math.max(0, this.#env.now() - episode.startedAt),
+        participantId: peerParticipantId
+      })
+    );
+  }
+  /** Recovery is over without media coming back. */
+  #giveUp(peerParticipantId) {
+    const episode = this.#episode;
+    if (!episode) return;
+    this.#episode = null;
+    const elapsedMs = Math.max(0, this.#env.now() - episode.startedAt);
+    this.#log.warn(
+      "reconnect failed",
+      reconnectLogFields({
+        attempt: Math.max(1, episode.attempts),
+        elapsedMs,
+        reason: elapsedMs >= this.#recoveryWindowMs ? "recovery_window_exhausted" : "hard_failure",
+        participantId: peerParticipantId
+      })
+    );
+  }
+  /**
+   * A connection that carried media and then failed is replaced once, within the recovery window, before media is
+   * given up. The meeting connection is untouched. False when no replacement is allowed or it could not be made.
+   */
+  #replaceFailedLink(failed) {
+    const peerId = failed.peerId;
+    if (!failed.everConnected || peerId !== this.#activeId || !this.#present.has(peerId)) return false;
+    const episode = this.#openEpisode("media");
+    if (episode.replaced || this.#env.now() - episode.startedAt >= this.#recoveryWindowMs) return false;
+    episode.replaced = true;
+    episode.attempts += 1;
+    this.#log.info("reconnect attempt started", reconnectLogFields({ attempt: episode.attempts, trigger: episode.trigger }));
+    const next = this.#createLink(peerId, "interrupted");
+    if (!next) {
+      this.#episode = null;
+      return true;
+    }
+    this.#refreshRemote(peerId);
+    next.start();
+    return true;
+  }
+  /** Reports a failed link. The pair stays as it is; nothing more is tried until the peer reconnects or rejoins. */
   #reportFailure(peerParticipantId, reason) {
     this.#log.warn("media connection failed", { participantId: peerParticipantId, reason });
     this.#context?.send("webrtc.failed", { peerParticipantId, reason });
@@ -2658,6 +3796,7 @@ var PeerMediaDelivery = class {
     const link = this.#link;
     if (!link) return;
     this.#link = null;
+    this.#episode = null;
     link.close();
     this.#refreshRemote(link.peerId);
   }
@@ -2734,34 +3873,6 @@ var PeerMediaDelivery = class {
   }
 };
 
-// src/internal/token.ts
-var BASE64URL = /^[A-Za-z0-9_-]+$/;
-function decodeSegment(segment) {
-  if (!BASE64URL.test(segment)) throw new MeetingError("join_token_invalid");
-  const padded = segment.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(segment.length / 4) * 4, "=");
-  const binary = atob(padded);
-  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
-  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-}
-function decodeAddressing(token) {
-  const segments = token.split(".");
-  if (segments.length !== 3) throw new MeetingError("join_token_invalid");
-  let claims;
-  try {
-    claims = decodeSegment(segments[1] ?? "");
-  } catch {
-    throw new MeetingError("join_token_invalid");
-  }
-  if (typeof claims !== "object" || claims === null || Array.isArray(claims)) {
-    throw new MeetingError("join_token_invalid");
-  }
-  const { meeting_id: meetingId, participant_id: participantId } = claims;
-  if (!isCanonicalUlid(meetingId) || !isCanonicalUlid(participantId)) {
-    throw new MeetingError("join_token_invalid");
-  }
-  return { meetingId, participantId };
-}
-
 // src/createMeetingEngine.ts
 var DEFAULT_JOIN_TIMEOUT_MS = 15e3;
 var MIN_JOIN_TIMEOUT_MS = 1e3;
@@ -2800,6 +3911,11 @@ function createMeetingEngine(options) {
   const env = currentEnvironment();
   if (!env.WebSocket) throw new MeetingError("unsupported_environment");
   const addressing = decodeAddressing(token);
+  const getJoinToken = options.getJoinToken;
+  if (getJoinToken !== void 0 && typeof getJoinToken !== "function") {
+    throw new TypeError("getJoinToken must be a function when provided.");
+  }
+  const reconnectWindowMs = clampReconnectWindowMs(options.reconnectWindowMs);
   return new MeetingEngineImpl({
     token,
     realtimeUrl,
@@ -2807,7 +3923,9 @@ function createMeetingEngine(options) {
     logger: options.logger,
     addressing,
     env,
-    createMediaDelivery: (mediaMode, deps) => mediaMode === "p2p" ? new PeerMediaDelivery(deps) : new SignalingOnlyMediaDelivery()
+    getJoinToken: typeof getJoinToken === "function" ? getJoinToken : void 0,
+    reconnectWindowMs,
+    createMediaDelivery: (mediaMode, deps) => mediaMode === "p2p" ? new PeerMediaDelivery({ ...deps, recoveryWindowMs: reconnectWindowMs }) : new SignalingOnlyMediaDelivery()
   });
 }
 export {