@pollen-robotics/reachy-mini-sdk 1.10.0-dev.0.main.b50d97e → 1.10.0-dev.0.main.c8367cd

package/host/dist/chunks/centralRest-uXNMidlL.js

@@ -0,0 +1,2315 @@
+var re = Object.defineProperty, se = (s, e, t) => e in s ? re(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, A = (s, e, t) => (se(s, typeof e != "symbol" ? e + "" : e, t), t), Z = "https://huggingface.co";
+async function D(s, e) {
+  var t, n;
+  const r = new ie(s.url, s.status, (t = s.headers.get("X-Request-Id")) != null ? t : void 0);
+  r.message = `Api error with status ${r.statusCode}`;
+  const i = [`URL: ${r.url}`, r.requestId ? `Request ID: ${r.requestId}` : void 0].filter(Boolean).join(". ");
+  if ((n = s.headers.get("Content-Type")) != null && n.startsWith("application/json")) {
+    const o = await s.json();
+    r.message = o.error || o.message || r.message, r.data = o;
+  } else
+    r.data = { message: await s.text() };
+  throw r.message += `. ${i}`, r;
+}
+var ie = class extends Error {
+  constructor(s, e, t, n) {
+    super(n), A(this, "statusCode"), A(this, "url"), A(this, "requestId"), A(this, "data"), this.statusCode = e, this.requestId = t, this.url = s;
+  }
+};
+new Promise((s) => {
+});
+function oe(s) {
+  if (globalThis.Buffer)
+    return globalThis.Buffer.from(s).toString("base64");
+  {
+    const e = [];
+    return s.forEach((t) => {
+      e.push(String.fromCharCode(t));
+    }), globalThis.btoa(e.join(""));
+  }
+}
+async function B(s) {
+  var e, t;
+  if (typeof window > "u")
+    throw new Error("oauthHandleRedirect is only available in the browser");
+  const n = new URLSearchParams(window.location.search), [r, i] = [n.get("error"), n.get("error_description")];
+  if (r)
+    throw new Error(`${r}: ${i}`);
+  const o = n.get("code"), a = localStorage.getItem("huggingface.co:oauth:nonce");
+  if (!o)
+    throw new Error("Missing oauth code from query parameters in redirected URL");
+  if (!a)
+    throw new Error("Missing oauth nonce from localStorage");
+  const c = localStorage.getItem("huggingface.co:oauth:code_verifier");
+  if (!c)
+    throw new Error("Missing oauth code_verifier from localStorage");
+  const d = n.get("state");
+  if (!d)
+    throw new Error("Missing oauth state from query parameters in redirected URL");
+  let u;
+  try {
+    u = JSON.parse(d);
+  } catch {
+    throw new Error("Invalid oauth state in redirected URL, unable to parse JSON: " + d);
+  }
+  if (u.nonce !== a)
+    throw new Error("Invalid oauth state in redirected URL");
+  const l = Z, m = `${new URL(l).origin}/.well-known/openid-configuration`, g = await fetch(m, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!g.ok)
+    throw await D(g);
+  const f = await g.json(), v = await fetch(f.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code: o,
+      redirect_uri: u.redirectUri,
+      code_verifier: c
+    }).toString()
+  });
+  if (localStorage.removeItem("huggingface.co:oauth:code_verifier"), localStorage.removeItem("huggingface.co:oauth:nonce"), !v.ok)
+    throw await D(v);
+  const w = await v.json(), b = new Date(Date.now() + w.expires_in * 1e3), E = await fetch(f.userinfo_endpoint, {
+    headers: {
+      Authorization: `Bearer ${w.access_token}`
+    }
+  });
+  if (!E.ok)
+    throw await D(E);
+  const h = await E.json();
+  return {
+    accessToken: w.access_token,
+    accessTokenExpiresAt: b,
+    userInfo: {
+      id: h.sub,
+      name: h.name,
+      fullname: h.preferred_username,
+      email: h.email,
+      emailVerified: h.email_verified,
+      avatarUrl: h.picture,
+      websiteUrl: h.website,
+      isPro: h.isPro,
+      orgs: (t = (e = h.orgs) == null ? void 0 : e.map((p) => ({
+        id: p.sub,
+        name: p.name,
+        fullname: p.name,
+        isEnterprise: p.isEnterprise,
+        canPay: p.canPay,
+        avatarUrl: p.picture,
+        roleInOrg: p.roleInOrg
+      }))) != null ? t : []
+    },
+    state: u.state,
+    scope: w.scope
+  };
+}
+async function ae(s) {
+  if (typeof window > "u")
+    throw new Error("oauthHandleRedirect is only available in the browser");
+  const e = new URLSearchParams(window.location.search);
+  return e.has("error") ? B() : e.has("code") ? localStorage.getItem("huggingface.co:oauth:nonce") ? B() : (console.warn(
+    "Missing oauth nonce from localStorage. This can happen when the user refreshes the page after logging in, without changing the URL."
+  ), !1) : !1;
+}
+async function ce(s) {
+  var e, t;
+  if (typeof window > "u")
+    throw new Error("oauthLogin is only available in the browser");
+  const n = s?.hubUrl || Z, r = `${new URL(n).origin}/.well-known/openid-configuration`, i = await fetch(r, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!i.ok)
+    throw await D(i);
+  const o = await i.json(), a = globalThis.crypto.randomUUID(), c = globalThis.crypto.randomUUID() + globalThis.crypto.randomUUID();
+  localStorage.setItem("huggingface.co:oauth:nonce", a), localStorage.setItem("huggingface.co:oauth:code_verifier", c);
+  const d = s?.redirectUrl || window.location.href, u = JSON.stringify({
+    nonce: a,
+    redirectUri: d,
+    state: s?.state
+  }), l = (t = (e = window?.huggingface) == null ? void 0 : e.variables) != null ? t : null, m = s?.clientId || l?.OAUTH_CLIENT_ID;
+  if (!m)
+    throw l ? new Error("Missing clientId, please add hf_oauth: true to the README.md's metadata in your static Space") : new Error("Missing clientId");
+  const g = oe(
+    new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(c)))
+  ).replace(/[+]/g, "-").replace(/[/]/g, "_").replace(/=/g, "");
+  return `${o.authorization_endpoint}?${new URLSearchParams({
+    client_id: m,
+    scope: s?.scopes || l?.OAUTH_SCOPES || "openid profile",
+    response_type: "code",
+    redirect_uri: d,
+    state: u,
+    code_challenge: g,
+    code_challenge_method: "S256"
+  }).toString()}`;
+}
+const S = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+}, le = "reachy-log";
+function de() {
+  try {
+    const s = globalThis.localStorage?.getItem(le);
+    if (s && s in S) return s;
+  } catch {
+  }
+  return "info";
+}
+let C = de();
+function O(s) {
+  const e = `[reachy:${s}]`;
+  return {
+    debug: (...t) => {
+      S[C] <= S.debug && console.debug(e, ...t);
+    },
+    info: (...t) => {
+      S[C] <= S.info && console.info(e, ...t);
+    },
+    warn: (...t) => {
+      S[C] <= S.warn && console.warn(e, ...t);
+    },
+    error: (...t) => {
+      S[C] <= S.error && console.error(e, ...t);
+    }
+  };
+}
+function I(s) {
+  return s * Math.PI / 180;
+}
+function ue(s, e, t) {
+  const n = I(s), r = I(e), i = I(t), o = Math.cos(i), a = Math.sin(i), c = Math.cos(r), d = Math.sin(r), u = Math.cos(n), l = Math.sin(n);
+  return [
+    [o * c, o * d * l - a * u, o * d * u + a * l, 0],
+    [a * c, a * d * l + o * u, a * d * u - o * l, 0],
+    [-d, c * l, c * u, 0],
+    [0, 0, 0, 1]
+  ];
+}
+const ee = 4e3;
+class P extends Error {
+}
+class he {
+  _replySlots = /* @__PURE__ */ new Map();
+  _rpcCounter = 0;
+  _pendingRpc = /* @__PURE__ */ new Map();
+  _pendingMotion = {
+    wake_up: [],
+    goto_sleep: []
+  };
+  _broadcastWaiters = [];
+  /* ─── Reply slots ────────────────────────────────────────────────── */
+  /**
+   * Register a slot waiter, run `send`, and await the matching daemon
+   * response. If a previous request on the same slot is still pending
+   * when a new one comes in, the older promise is resolved to `null`
+   * so its caller doesn't hang forever.
+   */
+  slotRoundtrip(e, t) {
+    return new Promise((n) => {
+      const r = this._replySlots.get(e);
+      r && r(null);
+      let i;
+      const o = (a) => {
+        i !== void 0 && (clearTimeout(i), i = void 0), this._replySlots.get(e) === o && this._replySlots.delete(e), n(a);
+      };
+      this._replySlots.set(e, o), i = setTimeout(() => o(null), ee), t();
+    });
+  }
+  /**
+   * Deliver a daemon reply to the pending waiter for `slot`, if any.
+   * Returns `true` when a waiter consumed the value — some message-handler
+   * branches use that to decide whether the message was theirs to swallow.
+   */
+  settleReplySlot(e, t) {
+    const n = this._replySlots.get(e);
+    return n ? (n(t), !0) : !1;
+  }
+  /* ─── JSON-RPC ───────────────────────────────────────────────────── */
+  /**
+   * One JSON-RPC round-trip: mint the correlation id, hand it to
+   * `send` (which reports `false` when the channel isn't open — the
+   * promise then rejects immediately), and await the matching
+   * response; rejects on timeout. Same shape as `slotRoundtrip`.
+   */
+  rpcRoundtrip(e, t, n) {
+    const r = `rpc-${++this._rpcCounter}`;
+    return n(r) ? new Promise((i, o) => {
+      const a = setTimeout(() => {
+        this._pendingRpc.delete(r), o(new Error(`rpcCall(${e}) timed out after ${t}ms`));
+      }, t);
+      this._pendingRpc.set(r, { resolve: i, reject: o, timer: a });
+    }) : Promise.reject(new Error(`rpcCall(${e}): data channel not open`));
+  }
+  /**
+   * Route a JSON-RPC RESPONSE (id + result/error) to its waiter.
+   * Returns `true` when the message was response-shaped — even if the
+   * waiter already timed out — so the caller can stop processing it;
+   * `false` for notifications and anything else.
+   */
+  settleRpcResponse(e) {
+    if (!("id" in e) || e.id == null || !("result" in e || "error" in e))
+      return !1;
+    const t = this._pendingRpc.get(e.id);
+    if (!t) return !0;
+    if (this._pendingRpc.delete(e.id), clearTimeout(t.timer), "error" in e && e.error) {
+      const n = e.error, r = new Error(n.message ?? "rpc error");
+      r.reason = n.data?.reason, t.reject(r);
+    } else
+      t.resolve(e.result);
+    return !0;
+  }
+  /* ─── Motion completions (wake_up / goto_sleep) ──────────────────── */
+  /** FIFO waiter for one `wake_up` / `goto_sleep` ack; rejects on timeout. */
+  awaitMotion(e, t) {
+    return new Promise((n, r) => {
+      const i = {
+        resolve: n,
+        reject: r,
+        timer: setTimeout(() => {
+          const o = this._pendingMotion[e], a = o.indexOf(i);
+          a !== -1 && o.splice(a, 1), r(new Error(`${e} timed out after ${t}ms`));
+        }, t)
+      };
+      this._pendingMotion[e].push(i);
+    });
+  }
+  /**
+   * Deliver a `wake_up` / `goto_sleep` reply to the oldest waiter.
+   * Returns `true` when a waiter consumed it; `false` when nothing was
+   * pending or the reply is neither a completion nor an error (the
+   * message then falls through to the caller's other branches).
+   */
+  settleMotion(e, t) {
+    const n = this._pendingMotion[e];
+    if (t.completed === !0 && n.length > 0) {
+      const r = n.shift();
+      return clearTimeout(r.timer), r.resolve(), !0;
+    }
+    if (t.error && n.length > 0) {
+      const r = n.shift();
+      return clearTimeout(r.timer), r.reject(new Error(`${e}: ${t.error}`)), !0;
+    }
+    return !1;
+  }
+  /* ─── Broadcast waiters ──────────────────────────────────────────── */
+  /** Await the first broadcast matching `predicate`; rejects on timeout. */
+  awaitBroadcast(e, { timeoutMs: t = 5e3, debugLabel: n = "" } = {}) {
+    return new Promise((r, i) => {
+      const o = {
+        predicate: e,
+        resolve: r,
+        reject: i,
+        timer: setTimeout(() => {
+          const a = this._broadcastWaiters.indexOf(o);
+          a !== -1 && this._broadcastWaiters.splice(a, 1), i(new P(`broadcast timeout (${t} ms): ${n}`));
+        }, t)
+      };
+      this._broadcastWaiters.push(o);
+    });
+  }
+  /**
+   * Offer a broadcast to the waiters; the first (most recent) matching
+   * waiter consumes it. Returns `true` when one did.
+   */
+  matchBroadcast(e) {
+    for (let t = this._broadcastWaiters.length - 1; t >= 0; t--) {
+      const n = this._broadcastWaiters[t];
+      if (n.predicate(e))
+        return this._broadcastWaiters.splice(t, 1), clearTimeout(n.timer), n.resolve(e), !0;
+    }
+    return !1;
+  }
+  /* ─── Teardown ───────────────────────────────────────────────────── */
+  /**
+   * Settle the whole ledger against a dead channel: reply slots
+   * resolve `null` (the "no answer" value all slot callers handle;
+   * public wrappers coerce where needed, e.g. `applyAudioConfig` maps
+   * it to `false`), everything else rejects with `err`. Called from
+   * every session-teardown path.
+   */
+  settleAll(e) {
+    for (const t of [...this._replySlots.values()])
+      t(null);
+    this._replySlots.clear();
+    for (const t of this._pendingRpc.values())
+      clearTimeout(t.timer), t.reject(e);
+    this._pendingRpc.clear();
+    for (const t of Object.keys(this._pendingMotion)) {
+      const n = this._pendingMotion[t];
+      for (; n.length; ) {
+        const r = n.shift();
+        clearTimeout(r.timer), r.reject(e);
+      }
+    }
+    for (const t of this._broadcastWaiters)
+      clearTimeout(t.timer), t.reject(e);
+    this._broadcastWaiters = [];
+  }
+}
+const M = O("session"), q = 3e3, G = 1e3, _e = 6e4, V = [0, 2e3, 4e3, 8e3, 8e3], pe = 15e3, J = 1e3, fe = 2500, me = 8e3;
+class ge {
+  _deps;
+  // ICE-blip debounce. All handler slots are scoped to the lifetime
+  // of a live session (armed from the pc's state handler, cleared by
+  // every teardown path via `clearIceGrace`).
+  _iceGraceTimer = null;
+  _iceGraceReason = null;
+  _pendingVisibilityHandler = null;
+  // Network awareness (installed in startSession, removed on teardown).
+  _onlineHandler = null;
+  _offlineHandler = null;
+  _connectionChangeHandler = null;
+  // Automatic re-dial. Mutable via `setAutoReconnect()` so flows that
+  // EXPECT a transport death (the daemon self-update reboot) can stand
+  // the machinery down.
+  _autoReconnect;
+  _redialing = !1;
+  _redialWake = null;
+  // Data-channel silence watchdog.
+  _dcWatchdogId = null;
+  _lastDcInboundAt = 0;
+  _dcWatchdogLastTickAt = 0;
+  _dcSilenceNudged = !1;
+  constructor(e, t) {
+    this._deps = e, this._autoReconnect = t.autoReconnect;
+  }
+  /** True while the re-dial loop is running. */
+  get redialing() {
+    return this._redialing;
+  }
+  /**
+   * Enable/disable the automatic session re-dial at runtime.
+   * Disabling also aborts any re-dial already in flight.
+   */
+  setAutoReconnect(e) {
+    this._autoReconnect = e, e || this.cancelRedial();
+  }
+  /** Fatal errors carry the classic webrtc `error` payload shape. */
+  _emitError(e) {
+    this._deps.emit("error", { source: "webrtc", error: e });
+  }
+  /* ─── ICE-blip debounce + network awareness ──────────────────────
+   *
+   * Both halves below are intentionally generic (they don't know
+   * about motion, audio, or the FSM): they just smooth out
+   * browser-level events so the consumer's own state machine doesn't
+   * get torn down by routine WiFi/4G/screen-off noise.
+   */
+  /** ICE healed back to `connected`/`completed`. */
+  onIceHealed() {
+    this.clearIceGrace();
+  }
+  /**
+   * ICE hit `disconnected` — TRANSIENT per spec, debounce before
+   * escalating. If the tab is hidden, JS timers are throttled and
+   * would fire unpredictably late, so defer the grace window to the
+   * next foreground frame.
+   */
+  onIceDisconnected() {
+    typeof document < "u" && document.hidden ? this._armIceGraceOnVisibility() : this._scheduleIceGrace(q, "disconnected");
+  }
+  /**
+   * ICE hit `failed` — terminal per spec, but in practice we've seen
+   * `failed → connected` on rapid AP roams / BT route changes on iOS.
+   * Give the ICE agent a short window to surprise us before rejecting
+   * the session.
+   */
+  onIceFailed() {
+    this._scheduleIceGrace(G, "failed");
+  }
+  /**
+   * Cancel any pending ICE grace timer and visibility handler. Called
+   * on a healed `connected`/`completed` transition AND from the
+   * lifecycle teardown paths so a callback can't fire after the pc
+   * is closed.
+   */
+  clearIceGrace() {
+    this._iceGraceTimer !== null && (clearTimeout(this._iceGraceTimer), this._iceGraceTimer = null), this._iceGraceReason = null, this._pendingVisibilityHandler && typeof document < "u" && document.removeEventListener("visibilitychange", this._pendingVisibilityHandler), this._pendingVisibilityHandler = null;
+  }
+  /**
+   * Start a grace window. After `ms`, re-check the live ICE state:
+   *   - If we healed back to `connected`/`completed`, the timer was
+   *     already cancelled in the pc's state handler, so we never get
+   *     here.
+   *   - If we're still in the originally-observed bad state (or
+   *     worse), surface the error and reject any pending session
+   *     promise. The original code path is preserved verbatim so
+   *     downstream consumers see the same `error` payload shape.
+   */
+  _scheduleIceGrace(e, t) {
+    if (this._iceGraceTimer !== null) {
+      if (this._iceGraceReason === t) return;
+      clearTimeout(this._iceGraceTimer);
+    }
+    this._iceGraceReason = t, this._iceGraceTimer = setTimeout(() => {
+      this._iceGraceTimer = null;
+      const n = this._iceGraceReason;
+      this._iceGraceReason = null;
+      const r = this._deps.iceState();
+      if (!(r === "connected" || r === "completed")) {
+        if (n === "disconnected" && r === "disconnected") {
+          if (this.maybeBeginRedial(`ICE stuck in 'disconnected' for > ${e}ms`)) return;
+          this._emitError(new Error(`ICE stuck in 'disconnected' for > ${e}ms`));
+          return;
+        }
+        if (n === "failed" || r === "failed") {
+          const i = new Error("ICE connection failed");
+          if (this._deps.rejectPendingSession(i)) {
+            this._redialing || this._emitError(i);
+            return;
+          }
+          if (this.maybeBeginRedial("ICE connection failed")) return;
+          this._emitError(i);
+        }
+      }
+    }, e);
+  }
+  /**
+   * `disconnected` while the tab is hidden. JS timers are throttled
+   * in background tabs (Chrome clamps to ~1 Hz, Safari can pause
+   * altogether), so a foreground grace timer would either miss the
+   * window or fire long after the connection healed. Wait for the
+   * tab to come back, then re-evaluate.
+   */
+  _armIceGraceOnVisibility() {
+    if (this._pendingVisibilityHandler) return;
+    const e = Date.now(), t = () => {
+      if (typeof document < "u" && document.hidden || (document.removeEventListener("visibilitychange", t), this._pendingVisibilityHandler = null, !this._deps.hasPc())) return;
+      const n = this._deps.iceState();
+      if (!(n === "connected" || n === "completed")) {
+        if (Date.now() - e > _e) {
+          const r = new Error("Session expired while tab was backgrounded");
+          if (this._deps.rejectPendingSession(r)) {
+            this._redialing || this._emitError(r);
+            return;
+          }
+          if (this.maybeBeginRedial("Session expired while tab was backgrounded")) return;
+          this._emitError(r);
+          return;
+        }
+        if (n === "failed") {
+          this._scheduleIceGrace(G, "failed");
+          return;
+        }
+        this._scheduleIceGrace(q, "disconnected");
+      }
+    };
+    document.addEventListener("visibilitychange", t), this._pendingVisibilityHandler = t;
+  }
+  /**
+   * Install browser-level network listeners and forward them as
+   * public `networkOnline` / `networkOffline` / `networkChange`
+   * events on the instance. Idempotent: called from `startSession()`,
+   * removed by `uninstallNetworkListeners` on teardown. Reachable
+   * only when there's a live `window` (defensive guard for SSR /
+   * test environments).
+   *
+   * `online` / `offline` are semantically about CONNECTIVITY:
+   * "does the OS think we can reach the internet". They flip
+   * symmetrically.
+   *
+   * `connection.change` (NetworkInformation API, Chrome / Android
+   * WebView only) is semantically about the TRANSPORT: it fires
+   * on Wi-Fi → 4G swaps, AP roams, etc. without necessarily going
+   * through `offline`. We forward it as its own `networkChange`
+   * event rather than aliasing it onto `networkOnline`, so
+   * consumers don't have to guess whether they're seeing a real
+   * connectivity recovery or a silent transport swap.
+   */
+  installNetworkListeners() {
+    if (this._onlineHandler || typeof window > "u") return;
+    const e = () => this._deps.emit("networkOnline", {}), t = () => this._deps.emit("networkOffline", {});
+    window.addEventListener("online", e), window.addEventListener("offline", t), this._onlineHandler = e, this._offlineHandler = t;
+    const n = navigator.connection;
+    if (n && typeof n.addEventListener == "function") {
+      const r = () => this._deps.emit("networkChange", {
+        effectiveType: n.effectiveType,
+        downlink: n.downlink,
+        rtt: n.rtt,
+        saveData: n.saveData
+      });
+      n.addEventListener("change", r), this._connectionChangeHandler = r;
+    }
+  }
+  /** Counterpart to `installNetworkListeners`. */
+  uninstallNetworkListeners() {
+    typeof window < "u" && (this._onlineHandler && window.removeEventListener("online", this._onlineHandler), this._offlineHandler && window.removeEventListener("offline", this._offlineHandler));
+    const e = navigator.connection;
+    e && this._connectionChangeHandler && typeof e.removeEventListener == "function" && e.removeEventListener("change", this._connectionChangeHandler), this._onlineHandler = null, this._offlineHandler = null, this._connectionChangeHandler = null;
+  }
+  /* ─── Automatic session re-dial ─────────────────────────────────── */
+  /**
+   * Escalation funnel for dead-transport signals. Returns `true` when
+   * the failure is being handled by a re-dial (callers should then skip
+   * their fatal `error` emit). Only fires for an ESTABLISHED session:
+   * mid-setup failures keep rejecting the startSession() promise so the
+   * original caller stays in charge of retries.
+   */
+  maybeBeginRedial(e) {
+    if (!this._autoReconnect) return !1;
+    if (this._redialing) return !0;
+    if (this._deps.isMidSetup()) return !1;
+    const t = this._deps.selectedRobotId();
+    return !t || !this._deps.hasPc() ? !1 : (this._redialing = !0, M.info(`auto-reconnect: ${e} - re-dialing ${t}`), this._runRedialLoop(t, e), !0);
+  }
+  /**
+   * The re-dial loop. One teardown, then up to REDIAL_BACKOFF_MS.length
+   * attempts, each preceded by its backoff slot. Every attempt re-runs
+   * the normal startSession() flow (and connect() first if the SSE feed
+   * died with the network), so a success is indistinguishable from a
+   * fresh session: `streaming` re-fires, videoTrack re-attaches, the
+   * pose subscription is re-asserted by the session-ready path.
+   *
+   * Exits early — without emitting anything further — when the user
+   * calls stopSession()/disconnect() or dials another robot, all of
+   * which flip `_redialing` off via `cancelRedial`.
+   */
+  async _runRedialLoop(e, t) {
+    const n = V.length;
+    this._deps.teardownForRedial();
+    for (let i = 1; i <= n; i++) {
+      if (!this._redialing || (this._deps.emit("sessionReconnecting", { attempt: i, maxAttempts: n, cause: t }), await this._redialSleep(V[i - 1]), !this._redialing)) return;
+      try {
+        if (this._deps.isSignalingDown() && await this._deps.reconnectSignaling(), !this._redialing || (await we(
+          this._deps.dial(e),
+          pe,
+          "auto-reconnect dial timed out"
+        ), !this._redialing)) return;
+        this._redialing = !1, M.info(`auto-reconnect: recovered on attempt ${i}`), this._deps.emit("sessionReconnected", { attempt: i });
+        return;
+      } catch (o) {
+        M.warn(
+          `auto-reconnect attempt ${i}/${n} failed:`,
+          o
+        ), this._redialing && this._deps.teardownForRedial();
+      }
+    }
+    if (!this._redialing) return;
+    this._redialing = !1;
+    const r = `Auto-reconnect gave up after ${n} attempts (${t})`;
+    M.warn(r), this._deps.emit("sessionStopped", { reason: "reconnect_failed", message: r }), this._emitError(new Error(r));
+  }
+  /**
+   * Cancellable backoff sleep — `cancelRedial` wakes it immediately.
+   * A timer firing after a cancel is harmless: the loop re-checks
+   * `_redialing` right after every sleep.
+   */
+  _redialSleep(e) {
+    return e <= 0 ? Promise.resolve() : new Promise((t) => {
+      this._redialWake = t, setTimeout(() => {
+        this._redialWake === t && (this._redialWake = null), t();
+      }, e);
+    });
+  }
+  /**
+   * Abort a pending re-dial. Called from stopSession(), disconnect()
+   * and an external startSession() — every path where the user (or the
+   * consumer app) takes over the session lifecycle.
+   */
+  cancelRedial() {
+    if (!(!this._redialing && !this._redialWake) && (this._redialing = !1, this._redialWake)) {
+      const e = this._redialWake;
+      this._redialWake = null, e();
+    }
+  }
+  /* ─── Data-channel silence watchdog ─────────────────────────────── */
+  /** (Re)start the watchdog. Called when a session reaches ready. */
+  startDcWatchdog() {
+    this.stopDcWatchdog();
+    const e = Date.now();
+    this._lastDcInboundAt = e, this._dcWatchdogLastTickAt = e, this._dcSilenceNudged = !1, this._dcWatchdogId = setInterval(() => this._dcWatchdogTick(), J);
+  }
+  stopDcWatchdog() {
+    this._dcWatchdogId !== null && (clearInterval(this._dcWatchdogId), this._dcWatchdogId = null);
+  }
+  /**
+   * Liveness stamp: every inbound data-channel message — control
+   * replies, broadcasts, pose frames — proves the transport is alive.
+   */
+  stampDcInbound() {
+    this._lastDcInboundAt = Date.now(), this._dcSilenceNudged = !1;
+  }
+  _dcWatchdogTick() {
+    const e = Date.now(), t = e - this._dcWatchdogLastTickAt;
+    if (this._dcWatchdogLastTickAt = e, !this._deps.isStreaming()) return;
+    if (t > J * 3) {
+      this._lastDcInboundAt = e, this._dcSilenceNudged = !1;
+      return;
+    }
+    if (typeof document < "u" && document.hidden) {
+      this._lastDcInboundAt = e, this._dcSilenceNudged = !1;
+      return;
+    }
+    const n = e - this._lastDcInboundAt;
+    if (n < fe) return;
+    if (!this._dcSilenceNudged) {
+      this._dcSilenceNudged = !0, this._deps.nudgeState();
+      return;
+    }
+    if (n < me) return;
+    this._dcSilenceNudged = !1;
+    const r = `No data-channel traffic for ${n}ms`;
+    this.maybeBeginRedial(r) || (this.stopDcWatchdog(), this._emitError(new Error(r)));
+  }
+}
+function we(s, e, t) {
+  return Promise.race([
+    s,
+    new Promise((n, r) => setTimeout(() => r(new Error(t)), e))
+  ]);
+}
+const z = "0.0.0-managed-by-ci", be = O("sdk");
+function ye() {
+  if (typeof window > "u" || !window.location.hash) return;
+  const s = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+  let e;
+  try {
+    e = new URLSearchParams(s);
+  } catch {
+    return;
+  }
+  const t = e.get("hf_token");
+  if (!t) return;
+  const n = e.get("hf_username") || "user", r = e.get("hf_token_expires"), i = r && !Number.isNaN(new Date(r).getTime()) ? r : new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3).toISOString();
+  try {
+    sessionStorage.setItem("hf_token", t), sessionStorage.setItem("hf_username", n), sessionStorage.setItem("hf_token_expires", i);
+  } catch (c) {
+    be.warn("could not persist pre-seeded HF credentials:", c);
+  }
+  e.delete("hf_token"), e.delete("hf_username"), e.delete("hf_token_expires");
+  const o = e.toString(), a = window.location.pathname + window.location.search + (o ? "#" + o : "");
+  try {
+    window.history.replaceState(null, "", a);
+  } catch {
+  }
+}
+function Se() {
+  if (typeof window > "u") return null;
+  if (window.location.hash) {
+    const s = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+    try {
+      const t = new URLSearchParams(s).get("robot_peer_id");
+      if (t) return t;
+    } catch {
+    }
+  }
+  if (window.location.search)
+    try {
+      const e = new URLSearchParams(window.location.search).get("robot_peer_id");
+      if (e) return e;
+    } catch {
+    }
+  return null;
+}
+function ve(s) {
+  const e = s.split(`\r
+`);
+  let t = !1;
+  for (const n of e)
+    if (n.startsWith("m=audio") ? t = !0 : n.startsWith("m=") && (t = !1), t && n === "a=sendrecv") return !0;
+  return !1;
+}
+const j = "hf_token", F = "hf_username", x = "hf_token_expires", L = "hf_token_last_seen", Re = 1440 * 60 * 1e3;
+function Ie(s) {
+  try {
+    sessionStorage.setItem(j, s.token), sessionStorage.setItem(F, s.username), sessionStorage.setItem(x, s.expires), sessionStorage.setItem(L, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function ke(s = Date.now()) {
+  try {
+    const e = sessionStorage.getItem(j), t = sessionStorage.getItem(F), n = sessionStorage.getItem(x);
+    if (!e || !n) return null;
+    if (new Date(n).getTime() <= s)
+      return $(), null;
+    const r = sessionStorage.getItem(L);
+    if (r !== null) {
+      const i = new Date(r).getTime();
+      if (!Number.isFinite(i) || s - i > Re)
+        return $(), null;
+    }
+    return sessionStorage.setItem(L, new Date(s).toISOString()), { token: e, username: t ?? "", expires: n };
+  } catch {
+    return null;
+  }
+}
+function $() {
+  try {
+    sessionStorage.removeItem(j), sessionStorage.removeItem(F), sessionStorage.removeItem(x), sessionStorage.removeItem(L);
+  } catch {
+  }
+}
+const Ee = /* @__PURE__ */ new Set([
+  "login_required",
+  "consent_required",
+  "interaction_required",
+  "access_denied"
+]);
+function Te() {
+  try {
+    const s = new URL(window.location.href), e = s.searchParams.get("error");
+    return e === null || !Ee.has(e) ? null : (s.searchParams.delete("error"), s.searchParams.delete("error_description"), s.searchParams.delete("state"), window.history.replaceState(null, "", s.toString()), e);
+  } catch {
+    return null;
+  }
+}
+const y = 12 * 1024, U = 1 * 1024 * 1024, Ae = 512 * 1024;
+function Ce() {
+  return typeof CompressionStream < "u";
+}
+function K() {
+  return "u" + Math.random().toString(36).slice(2, 11) + Date.now().toString(36);
+}
+function N(s) {
+  let e = "";
+  for (let n = 0; n < s.length; n += 32768)
+    e += String.fromCharCode.apply(
+      null,
+      Array.from(s.subarray(n, n + 32768))
+    );
+  return btoa(e);
+}
+async function Me(s) {
+  const e = new TextEncoder().encode(s), t = await new Response(
+    new Blob([e]).stream().pipeThrough(new CompressionStream("gzip"))
+  ).arrayBuffer();
+  return N(new Uint8Array(t));
+}
+function Y(s) {
+  const e = Math.round(Number(s) || 0);
+  return Math.max(0, Math.min(100, e));
+}
+function X(s) {
+  switch ((s.type || "").toLowerCase().split(";")[0]?.trim() ?? "") {
+    case "audio/ogg":
+    case "application/ogg":
+      return "ogg-base64";
+    case "audio/opus":
+      return "opus-base64";
+    case "audio/mpeg":
+    case "audio/mp3":
+      return "mp3-base64";
+    case "audio/flac":
+    case "audio/x-flac":
+      return "flac-base64";
+    case "audio/mp4":
+    case "audio/m4a":
+    case "audio/x-m4a":
+      return "m4a-base64";
+    case "audio/aac":
+      return "aac-base64";
+    default:
+      return "wav-base64";
+  }
+}
+const _ = O("sdk"), Q = 750, De = 5e3;
+class He extends EventTarget {
+  // ─── Config ──────────────────────────────────────────────────────────
+  _signalingUrl;
+  _clientId;
+  _appName;
+  _videoJitterBufferTargetMs;
+  _autoStartFromUrl;
+  _autoStartAttempted;
+  // ─── Public-ish state mirrors ────────────────────────────────────────
+  _state = "disconnected";
+  _robots = [];
+  _robotState = {};
+  // Highest `seq` seen on the unordered `pose` channel. Frames that arrive
+  // out of order (older seq) are dropped so a late packet can't rewind the
+  // live mirror. `null` until the first pose frame.
+  _lastPoseSeq = null;
+  // When the last pushed pose frame was applied, used to park the periodic
+  // `get_state` poll while the stream is live (see POSE_STREAM_FRESH_MS).
+  _lastPoseFrameAt = 0;
+  // Local refcount of pose-stream consumers (the 3D mirror, the wizard's
+  // move-end watcher, ...). The daemon's subscription is a per-peer boolean
+  // (not refcounted), so we only send `unsubscribe_pose` once the LAST local
+  // consumer releases - otherwise one consumer's cleanup would kill the
+  // stream for the others.
+  _poseSubRefs = 0;
+  _preselectedRobotId;
+  // ─── Auth ────────────────────────────────────────────────────────────
+  _token = null;
+  _username = null;
+  _tokenExpires = null;
+  // ─── Signaling ───────────────────────────────────────────────────────
+  _sseAbortController = null;
+  // ─── WebRTC ──────────────────────────────────────────────────────────
+  _pc = null;
+  _dc = null;
+  _sessionId = null;
+  _selectedRobotId = null;
+  _pendingRemoteIce = [];
+  // ─── Audio ───────────────────────────────────────────────────────────
+  _micStream = null;
+  _micMuted = !0;
+  _audioMuted = !0;
+  _micSupported = !1;
+  // ─── Timers ──────────────────────────────────────────────────────────
+  _latencyMonitorId = null;
+  _stateRefreshInterval = null;
+  // ─── Pending replies (reply slots / JSON-RPC / motion / broadcast) ───
+  // All request/response waiters on the data channel live in one
+  // ledger so every teardown path settles them in a single call.
+  _pending = new he();
+  // ─── Log subscribers ─────────────────────────────────────────────────
+  _logSubscribers = /* @__PURE__ */ new Set();
+  _updateProgressSubscribers = /* @__PURE__ */ new Set();
+  // ─── JSON-RPC notification listeners (one-way events, no id) ─────────
+  // onNotification() subscribes to events the robot/app pushes
+  // (conversation.phase/turn/transcript, ...).
+  _rpcListeners = /* @__PURE__ */ new Map();
+  // ─── Active upload ids for no-arg cancels ────────────────────────────
+  _activeMoveUploadId = null;
+  _activeAudioUploadId = null;
+  // ─── Session promise plumbing ────────────────────────────────────────
+  _sessionResolve = null;
+  _sessionReject = null;
+  _iceConnected = !1;
+  _dcOpen = !1;
+  // ─── Resilience ──────────────────────────────────────────────────────
+  // ICE-blip debounce, network awareness, automatic session re-dial and
+  // the data-channel silence watchdog all live in the supervisor; the
+  // class forwards pc/browser events to it and implements its deps as
+  // closures over the private state below (see the constructor).
+  _supervisor;
+  // ─── Video element ───────────────────────────────────────────────────
+  _videoElement = null;
+  constructor(e = {}) {
+    super(), this._signalingUrl = e.signalingUrl || "https://pollen-robotics-reachy-mini-central.hf.space", this._clientId = e.clientId || null, this._appName = e.appName || "unknown", this._videoJitterBufferTargetMs = e.videoJitterBufferTargetMs ?? 0, this._autoStartFromUrl = e.autoStartFromUrl === !0, this._autoStartAttempted = !1, this._preselectedRobotId = Se(), this._supervisor = new ge({
+      iceState: () => this._pc?.iceConnectionState ?? null,
+      hasPc: () => !!this._pc,
+      isStreaming: () => this._state === "streaming",
+      isMidSetup: () => !!(this._sessionResolve || this._sessionReject),
+      isSignalingDown: () => this._state === "disconnected",
+      selectedRobotId: () => this._selectedRobotId,
+      rejectPendingSession: (t) => {
+        if (!this._sessionReject) return !1;
+        const n = this._sessionReject;
+        return this._sessionResolve = null, this._sessionReject = null, n(t), !0;
+      },
+      reconnectSignaling: () => this.connect(),
+      // The private dial skips the public startSession()'s
+      // cancelRedial, so the loop's own attempts don't cancel it.
+      dial: (t) => this._startSessionInternal(t),
+      teardownForRedial: () => this._teardownForRedial(),
+      nudgeState: () => {
+        this.requestState();
+      },
+      emit: (t, n) => this._emit(t, n)
+    }, { autoReconnect: e.autoReconnect !== !1 });
+  }
+  // ─── Read-only properties ────────────────────────────────────────────
+  get state() {
+    return this._state;
+  }
+  get robots() {
+    return this._robots;
+  }
+  get robotState() {
+    return this._robotState;
+  }
+  get username() {
+    return this._username;
+  }
+  get isAuthenticated() {
+    return !!this._token;
+  }
+  get micSupported() {
+    return this._micSupported;
+  }
+  get micMuted() {
+    return this._micMuted;
+  }
+  get audioMuted() {
+    return this._audioMuted;
+  }
+  get preselectedRobotId() {
+    return this._preselectedRobotId;
+  }
+  get isEmbedded() {
+    return this._preselectedRobotId !== null;
+  }
+  /**
+   * Live RTCPeerConnection, or `null` between sessions. Read-only escape
+   * hatch for stats sampling (`getStats()`); mutating it is unsupported.
+   * Auto-reconnect re-dials REPLACE this object, so re-read it on every
+   * use — never capture it across ticks.
+   */
+  get peerConnection() {
+    return this._pc;
+  }
+  /**
+   * Build version of this SDK (npm package `version`), injected from
+   * package.json at build time. This is the JS SDK's OWN version and is
+   * distinct from `getVersion()`, which asks the DAEMON its version over
+   * the data channel. `0.0.0-managed-by-ci` means an unreleased/branch
+   * build (npm releases carry a real semver).
+   */
+  get sdkVersion() {
+    return z;
+  }
+  /** Same value as the instance `sdkVersion`, reachable without an
+   *  instance: `ReachyMini.version`. */
+  static get version() {
+    return z;
+  }
+  /**
+   * Internal: try to honour the `autoStartFromUrl` constructor
+   * option. Called from the signaling-message handler after every
+   * `robotsChanged` emit, so a robot that comes online after the
+   * SDK is already `connected` still triggers the auto-start.
+   */
+  _maybeAutoStart() {
+    if (!this._autoStartFromUrl || this._autoStartAttempted || !this._preselectedRobotId || this._state !== "connected" || !this._robots.find((n) => n.id === this._preselectedRobotId)) return;
+    this._autoStartAttempted = !0;
+    const t = this._preselectedRobotId;
+    setTimeout(() => {
+      this._state === "connected" && this.startSession(t).catch((n) => {
+        _.warn("autoStartFromUrl: startSession rejected:", n);
+      });
+    }, 0);
+  }
+  // ─── Auth ────────────────────────────────────────────────────────────
+  async authenticate() {
+    try {
+      ye();
+      const e = Te();
+      e && _.info("silent sign-in declined:", e);
+      const t = await ae();
+      if (t)
+        return this._username = t.userInfo.preferred_username || t.userInfo.name || null, this._token = t.accessToken, this._tokenExpires = t.accessTokenExpiresAt, Ie({
+          token: this._token,
+          username: this._username ?? "",
+          expires: typeof this._tokenExpires == "string" ? this._tokenExpires : this._tokenExpires.toISOString()
+        }), !0;
+      const n = ke();
+      return n && n.username ? (this._token = n.token, this._username = n.username, this._tokenExpires = n.expires, !0) : !1;
+    } catch (e) {
+      return _.error("authenticate failed:", e), !1;
+    }
+  }
+  async login(e) {
+    const t = {};
+    this._clientId && (t.clientId = this._clientId);
+    let n = await ce(t);
+    if (e?.prompt) {
+      const r = new URL(n);
+      r.searchParams.set("prompt", e.prompt), n = r.toString();
+    }
+    window.location.href = n;
+  }
+  logout() {
+    $(), this._username = null, this._tokenExpires = null, this.disconnect();
+  }
+  // ─── Lifecycle ───────────────────────────────────────────────────────
+  async connect(e) {
+    if (this._state !== "disconnected") throw new Error("Already connected");
+    if (e && (this._token = e), !this._token) throw new Error("No token — call authenticate() first or pass a token");
+    this._sseAbortController = new AbortController();
+    let t;
+    try {
+      t = await fetch(
+        `${this._signalingUrl}/events`,
+        {
+          signal: this._sseAbortController.signal,
+          headers: { Authorization: `Bearer ${this._token}` }
+        }
+      );
+    } catch (n) {
+      throw this._sseAbortController = null, n;
+    }
+    if (!t.ok)
+      throw this._sseAbortController = null, new Error(`HTTP ${t.status}`);
+    return new Promise((n, r) => {
+      let i = !1;
+      const o = t.body.getReader(), a = new TextDecoder();
+      let c = "";
+      (async () => {
+        try {
+          for (; ; ) {
+            const { done: u, value: l } = await o.read();
+            if (u) break;
+            c += a.decode(l, { stream: !0 });
+            const m = c.split(`
+`);
+            c = m.pop() ?? "";
+            for (const g of m)
+              if (g.startsWith("data:"))
+                try {
+                  const f = JSON.parse(g.slice(5).trim());
+                  !i && f.type === "welcome" && f.peerId && (i = !0, this._state = "connected", await this._sendToServer({
+                    type: "setPeerStatus",
+                    roles: ["listener"],
+                    meta: { name: this._appName }
+                  }), this._emit("connected", { peerId: f.peerId }), n()), this._handleSignalingMessage(f);
+                } catch {
+                }
+          }
+        } catch (u) {
+          if (u.name !== "AbortError" && this._emit("error", { source: "signaling", error: u }), !i) {
+            r(u);
+            return;
+          }
+        }
+        this._state !== "disconnected" && (this._state = "disconnected", this._emit("disconnected", { reason: "SSE closed" })), i || r(new Error("Connection closed before welcome"));
+      })();
+    });
+  }
+  async autoConnect(e = {}) {
+    const {
+      token: t,
+      pickRobot: n,
+      autoPickIfSingle: r = !0,
+      filterBusy: i = !0,
+      wakeOnConnect: o = !0
+    } = e;
+    if (this._state === "streaming") {
+      const c = this._robots?.find((d) => d.id === this._selectedRobotId);
+      return {
+        robotId: this._selectedRobotId,
+        robotName: c?.meta?.name ?? null,
+        isEmbedded: this.isEmbedded,
+        alreadyStreaming: !0
+      };
+    }
+    const a = this._autoStartFromUrl;
+    this._autoStartFromUrl = !1;
+    try {
+      if (t)
+        this._token = t;
+      else if (!this._token && !await this.authenticate())
+        throw new Error("Not authenticated — call login() or pass a token");
+      this._state === "disconnected" && await this.connect();
+      let c, d = null;
+      if (this.isEmbedded) {
+        c = this._preselectedRobotId;
+        try {
+          await this._waitForRobotInList(c, 5e3);
+        } catch {
+        }
+        d = this._robots?.find((l) => l.id === c)?.meta?.name ?? null;
+      } else {
+        const u = await this._fetchOwnedRobots({ filterBusy: i });
+        if (u.length === 0)
+          throw new Error("No reachable robots");
+        if (r && u.length === 1 && !u[0].busy)
+          c = u[0].id, d = u[0].name;
+        else if (n) {
+          const l = await n(u);
+          if (!l) throw new Error("Robot selection cancelled");
+          c = l, d = u.find((m) => m.id === l)?.name ?? null;
+        } else
+          throw new Error(
+            "Multiple robots available — pass a pickRobot callback to autoConnect()"
+          );
+      }
+      if (await this.startSession(c), o && typeof this.ensureAwake == "function")
+        try {
+          await this.ensureAwake();
+        } catch (u) {
+          _.warn("autoConnect: ensureAwake failed:", u);
+        }
+      return { robotId: c, robotName: d, isEmbedded: this.isEmbedded };
+    } finally {
+      this._autoStartFromUrl = a;
+    }
+  }
+  async _fetchOwnedRobots({ filterBusy: e = !0 } = {}) {
+    try {
+      const t = await fetch(`${this._signalingUrl}/api/robot-status`, {
+        headers: { Authorization: `Bearer ${this._token}` }
+      });
+      if (!t.ok) throw new Error(`HTTP ${t.status}`);
+      const n = await t.json(), r = /* @__PURE__ */ new Map();
+      for (const i of n.robots || []) {
+        if (e && i.busy) continue;
+        const o = i.meta?.install_id ?? i.meta?.hardware_id ?? i.peerId;
+        r.set(o, {
+          id: i.peerId,
+          name: i.robotName ?? i.meta?.name ?? null,
+          busy: !!i.busy,
+          activeApp: i.activeApp ?? null,
+          meta: i.meta ?? {},
+          lastSeenAgeSeconds: i.last_seen_age_seconds ?? null
+        });
+      }
+      return Array.from(r.values()).sort(
+        (i, o) => (i.lastSeenAgeSeconds ?? 1 / 0) - (o.lastSeenAgeSeconds ?? 1 / 0)
+      );
+    } catch (t) {
+      return _.warn("/api/robot-status unavailable, using SSE list:", t), (this._robots || []).map((n) => ({
+        id: n.id,
+        name: n.meta?.name ?? null,
+        busy: !1,
+        activeApp: null,
+        meta: n.meta ?? {},
+        lastSeenAgeSeconds: null
+      }));
+    }
+  }
+  _waitForRobotInList(e, t) {
+    return this._robots?.find((n) => n.id === e) ? Promise.resolve() : new Promise((n, r) => {
+      const i = () => {
+        this._robots?.find((a) => a.id === e) && (this.removeEventListener("robotsChanged", i), clearTimeout(o), n());
+      }, o = setTimeout(() => {
+        this.removeEventListener("robotsChanged", i), r(new Error(`Timeout waiting for robot ${e} in list`));
+      }, t);
+      this.addEventListener("robotsChanged", i);
+    });
+  }
+  async startSession(e) {
+    return this._supervisor.cancelRedial(), this._startSessionInternal(e);
+  }
+  async _startSessionInternal(e) {
+    if (this._state !== "connected") throw new Error("Not connected");
+    this._selectedRobotId = e, this._iceConnected = !1, this._dcOpen = !1, this._micSupported = !1, this._pendingRemoteIce = [];
+    try {
+      const t = window, n = t.AudioContext ?? t.webkitAudioContext;
+      if (!n) throw new Error("AudioContext not supported");
+      const r = new n(), i = r.createMediaStreamDestination(), o = r.createOscillator(), a = r.createGain();
+      a.gain.value = 0, o.connect(a).connect(i), o.start();
+      const c = i.stream;
+      c.getAudioTracks().forEach((d) => {
+        d.enabled = !1;
+      }), this._micStream = c, this._micMuted = !0;
+    } catch (t) {
+      _.warn("audio sender placeholder setup failed:", t), this._micStream = null;
+    }
+    return this._pc = new RTCPeerConnection({
+      iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+    }), this._supervisor.installNetworkListeners(), new Promise((t, n) => {
+      this._sessionResolve = t, this._sessionReject = n, this._pc.ontrack = (r) => {
+        if (r.track.kind === "video") {
+          const i = this._videoJitterBufferTargetMs;
+          try {
+            r.receiver.jitterBufferTarget = i;
+          } catch {
+          }
+          try {
+            r.receiver.playoutDelayHint = i / 1e3;
+          } catch {
+          }
+          this._emit("videoTrack", { track: r.track, stream: r.streams[0] });
+        }
+      }, this._pc.onicecandidate = async (r) => {
+        r.candidate && this._sessionId && await this._sendToServer({
+          type: "peer",
+          sessionId: this._sessionId,
+          ice: {
+            candidate: r.candidate.candidate,
+            sdpMLineIndex: r.candidate.sdpMLineIndex,
+            sdpMid: r.candidate.sdpMid
+          }
+        });
+      }, this._pc.oniceconnectionstatechange = () => {
+        const r = this._pc?.iceConnectionState;
+        if (r) {
+          if (this._emit("iceStateChange", { state: r }), r === "connected" || r === "completed") {
+            this._supervisor.onIceHealed(), this._iceConnected = !0, this._checkSessionReady();
+            return;
+          }
+          if (r === "disconnected") {
+            this._supervisor.onIceDisconnected();
+            return;
+          }
+          if (r === "failed") {
+            this._supervisor.onIceFailed();
+            return;
+          }
+        }
+      }, this._pc.ondatachannel = (r) => {
+        const i = r.channel;
+        if (i.label === "pose") {
+          this._lastPoseSeq = null, i.onmessage = (o) => {
+            const a = JSON.parse(o.data);
+            if (typeof a.seq == "number") {
+              if (this._lastPoseSeq !== null && a.seq <= this._lastPoseSeq) return;
+              this._lastPoseSeq = a.seq;
+            }
+            this._lastPoseFrameAt = Date.now(), this._handleRobotMessage(a, !0);
+          };
+          return;
+        }
+        this._dc = i, this._dc.onopen = () => {
+          this._dcOpen = !0, this._checkSessionReady();
+        }, this._dc.onmessage = (o) => this._handleRobotMessage(JSON.parse(o.data));
+      }, this._sendToServer({ type: "startSession", peerId: e }).then((r) => {
+        if (r?.type === "sessionRejected") {
+          this._failSessionRejected(r);
+          return;
+        }
+        r?.sessionId && (this._sessionId = r.sessionId);
+      });
+    });
+  }
+  /**
+   * Common transport teardown shared by every session-ending path
+   * (stopSession, disconnect, the auto-redial, a session rejection):
+   * settle the pending-reply ledger and the startSession() resolvers
+   * with `settleErr`, stand the resilience plumbing down, stop the
+   * session-scoped timers, release the mic placeholder and close the
+   * pc/dc. Returns the session id (already cleared on the instance)
+   * so each caller decides whether and how to send `endSession`.
+   * What else differs — events, subscriber wipes, where `_state`
+   * lands — stays with the callers.
+   */
+  _closeTransport(e) {
+    if (this._pending.settleAll(e), this._sessionReject) {
+      const n = this._sessionReject;
+      this._sessionResolve = null, this._sessionReject = null, n(e);
+    }
+    this._sessionResolve = null, this._supervisor.clearIceGrace(), this._supervisor.uninstallNetworkListeners(), this._supervisor.stopDcWatchdog(), this._stateRefreshInterval && (clearInterval(this._stateRefreshInterval), this._stateRefreshInterval = null), this._latencyMonitorId && (clearInterval(this._latencyMonitorId), this._latencyMonitorId = null), this._micStream && (this._micStream.getTracks().forEach((n) => n.stop()), this._micStream = null), this._micMuted = !0, this._micSupported = !1, this._pc && (this._pc.close(), this._pc = null), this._dc && (this._dc.close(), this._dc = null), this._iceConnected = !1, this._dcOpen = !1;
+    const t = this._sessionId;
+    return this._sessionId = null, t;
+  }
+  _failSessionRejected(e) {
+    const t = new Error(
+      e.reason === "robot_busy" ? `Robot is busy: "${e.activeApp || "another app"}" is already connected` : `Session rejected: ${e.reason || "unknown reason"}`
+    );
+    t.reason = e.reason ?? null, t.activeApp = e.activeApp ?? null, this._closeTransport(t), this._supervisor.redialing || this._emit("sessionRejected", { reason: e.reason, activeApp: e.activeApp });
+  }
+  async stopSession() {
+    this._supervisor.cancelRedial(), this._logSubscribers.clear(), this._updateProgressSubscribers.clear();
+    const e = this._closeTransport(new Error("Session stopped"));
+    e && await this._sendToServer({ type: "endSession", sessionId: e }), this._state === "streaming" && (this._state = "connected", this._emit("sessionStopped", { reason: "user" }));
+  }
+  disconnect() {
+    this._supervisor.cancelRedial(), this._sseAbortController && (this._sseAbortController.abort(), this._sseAbortController = null), this._logSubscribers.clear(), this._updateProgressSubscribers.clear();
+    const e = this._closeTransport(new Error("Disconnected"));
+    e && this._token && this._sendToServer({ type: "endSession", sessionId: e }), this._robots = [], this._state = "disconnected", this._emit("disconnected", { reason: "user" });
+  }
+  // ─── Resilience: supervisor delegation ───────────────────────────────
+  // The policy lives in `session-supervisor.ts`; only the transport
+  // teardown below stays here because it manipulates the class's own
+  // private state.
+  /**
+   * Enable/disable the automatic session re-dial at runtime.
+   * Disabling also aborts any re-dial already in flight. Used by
+   * flows that EXPECT the transport to die — e.g. the daemon
+   * self-update, whose `systemctl restart` teardown must surface as
+   * `sessionStopped` immediately (it's the "install done, rebooting"
+   * signal), not get absorbed by ~22 s of doomed reconnect attempts
+   * against a robot that is rebooting anyway.
+   *
+   * Sharp edge: cancelling an in-flight re-dial leaves the session
+   * torn down without emitting `sessionStopped` or `error` — the
+   * caller owns the terminal event (see `ReachyMiniInstance`).
+   */
+  setAutoReconnect(e) {
+    this._supervisor.setAutoReconnect(e);
+  }
+  /**
+   * Transport-only teardown: everything stopSession() does EXCEPT the
+   * user-facing state flip (`sessionStopped` is not emitted, `_state`
+   * falls back to 'connected' so the re-dial can start a session).
+   * Pending promises that ride the dead channel are settled just like
+   * stopSession() settles them — callers see the same failure shape a
+   * manual stop would produce; that includes a timed-out dial
+   * attempt's own startSession() promise (its resolvers were left
+   * armed, and a late signaling reply could otherwise settle them
+   * against a closed pc).
+   */
+  _teardownForRedial() {
+    const e = this._closeTransport(new Error("Session reconnecting"));
+    e && this._token && this._sendToServer({ type: "endSession", sessionId: e }), this._state === "streaming" && (this._state = "connected");
+  }
+  // ─── Commands ────────────────────────────────────────────────────────
+  /**
+   * Atomic raw-units pose update over the data channel. Channels you
+   * omit are held at their last commanded value (per-axis, independent).
+   *
+   * **Head pose is in the WORLD frame.** The daemon's IK splits the
+   * requested head world-yaw between body rotation and the stewart
+   * platform, subject to the mechanical limit
+   * `|head_yaw_world − body_yaw| ≤ 65°`.
+   *
+   * **If you want the head to FOLLOW the body** (tank-style rotation):
+   * a `setTarget({ body_yaw })` on its own does NOT rotate the head —
+   * the head's commanded world yaw is unchanged, so its gaze stays
+   * pinned in world frame while the body turns under it. To make the
+   * head turn with the body, include a `head` matrix in the SAME call
+   * with the body-yaw delta added to the head RPY's yaw:
+   *
+   * ```ts
+   * // Body-yaw drag handler: tank-couple the head so it follows.
+   * const delta = newBodyDeg - lastCommandedBodyDeg;
+   * const nextHeadYaw = lastCommandedHeadYawDeg + delta;
+   * robot.setTarget({
+   *   head: rpyToMatrix(headRoll, headPitch, nextHeadYaw).flat(),
+   *   body_yaw: degToRad(newBodyDeg),
+   * });
+   * lastCommandedHeadYawDeg = nextHeadYaw;
+   * lastCommandedBodyDeg    = newBodyDeg;
+   * ```
+   *
+   * **Baseline must be the last COMMANDED value, not telemetry.** For
+   * continuous-input controllers (slider drag, joystick), do not use
+   * `state.head` from the `state` event as the baseline for incremental
+   * commands — telemetry lags one WebRTC round-trip, so cumulative
+   * deltas computed against it stall (every iteration in a rapid drag
+   * adds the same `delta` to the same stale baseline → the head fails
+   * to keep up). Track the last-commanded RPY in your own buffer.
+   *
+   * @param head      Flat row-major 4×4 matrix (16 finite numbers) in
+   *                  the world frame. Omit to hold the previous head target.
+   * @param antennas  `[rightRad, leftRad]` (radians). Omit to hold.
+   * @param body_yaw  Signed radians. Omit to hold.
+   * @returns `true` if the command was queued on the data channel,
+   *          `false` if the channel is not open.
+   */
+  setTarget({ head: e, antennas: t, body_yaw: n } = {}) {
+    const r = { type: "set_full_target" };
+    if (e !== void 0) {
+      if (!Array.isArray(e) || e.length !== 16 || !e.every((i) => Number.isFinite(i)))
+        throw new TypeError(
+          `setTarget: head must be a 16-element flat row-major 4×4 matrix of finite numbers; got ${Array.isArray(e) ? `Array(${e.length})` : typeof e}`
+        );
+      r.head = e;
+    }
+    if (t !== void 0) {
+      if (!Array.isArray(t) || t.length !== 2 || !t.every((i) => Number.isFinite(i)))
+        throw new TypeError(
+          `setTarget: antennas must be [rightRad, leftRad] (2 finite numbers); got ${Array.isArray(t) ? `Array(${t.length})` : typeof t}`
+        );
+      r.antennas = t;
+    }
+    if (n !== void 0) {
+      if (!Number.isFinite(n))
+        throw new TypeError(
+          `setTarget: body_yaw must be a finite number (radians); got ${n}`
+        );
+      r.body_yaw = n;
+    }
+    return this._sendCommand(r);
+  }
+  gotoTarget({ head: e, antennas: t, body_yaw: n, duration: r }) {
+    const i = { type: "goto_target" };
+    if (e !== void 0) {
+      if (!Array.isArray(e) || e.length !== 16 || !e.every((o) => Number.isFinite(o)))
+        throw new TypeError(
+          `gotoTarget: head must be a 16-element flat row-major 4×4 matrix of finite numbers; got ${Array.isArray(e) ? `Array(${e.length})` : typeof e}`
+        );
+      i.head = e;
+    }
+    if (t !== void 0) {
+      if (!Array.isArray(t) || t.length !== 2 || !t.every((o) => Number.isFinite(o)))
+        throw new TypeError(
+          `gotoTarget: antennas must be [rightRad, leftRad] (2 finite numbers); got ${Array.isArray(t) ? `Array(${t.length})` : typeof t}`
+        );
+      i.antennas = t;
+    }
+    if (n !== void 0) {
+      if (!Number.isFinite(n))
+        throw new TypeError(
+          `gotoTarget: body_yaw must be a finite number (radians); got ${n}`
+        );
+      i.body_yaw = n;
+    }
+    if (!Number.isFinite(r) || r <= 0)
+      throw new TypeError(
+        `gotoTarget: duration must be a positive finite number (seconds); got ${r}`
+      );
+    return i.duration = r, this._sendCommand(i);
+  }
+  setHeadRpyDeg(e, t, n) {
+    return this.setTarget({ head: ue(e, t, n).flat() });
+  }
+  setAntennasDeg(e, t) {
+    return this.setTarget({ antennas: [I(e), I(t)] });
+  }
+  setBodyYawDeg(e) {
+    return this.setTarget({ body_yaw: I(e) });
+  }
+  playSound(e) {
+    return this._sendCommand({ type: "play_sound", file: e });
+  }
+  playRecordedMove(e, {
+    dataset: t,
+    initialGotoDuration: n
+  } = {}) {
+    return this._sendCommand({
+      type: "play_recorded_move",
+      move_name: e,
+      ...t ? { dataset_name: t } : {},
+      ...n && n > 0 ? { initial_goto_duration: n } : {}
+    });
+  }
+  /**
+   * Stop whatever move is currently playing on the daemon (recorded move,
+   * uploaded move, goto). Fire-and-forget and idempotent: the daemon acks
+   * ok with `stopped: false` when nothing was running. Returns `false` if
+   * the data channel is not open.
+   */
+  stopMove() {
+    return this._sendCommand({ type: "stop_move" });
+  }
+  preloadDataset(e) {
+    return this._sendCommand({ type: "preload_dataset", dataset_name: e });
+  }
+  /**
+   * Like `preloadDataset()`, but resolves once the daemon acks the preload
+   * (`{command: "preload_dataset", ...}` on the data channel), i.e. when the
+   * dataset is actually in the local HF cache. Resolves `true` on success,
+   * `false` when the daemon reports a download failure, and `null` on the
+   * fail-open timeout (download slower than `timeoutMs`, or a daemon that
+   * predates the command and never replies) - callers should proceed in all
+   * three cases, `playRecordedMove` still downloads on demand. Rejects when
+   * the data channel isn't open or the session tears down mid-flight.
+   */
+  preloadDatasetAndWait(e, { timeoutMs: t = 12e4 } = {}) {
+    return this.preloadDataset(e) ? this._pending.awaitBroadcast(
+      (n) => n.command === "preload_dataset" && n.dataset_name === e,
+      { timeoutMs: t, debugLabel: `preload_dataset(${e})` }
+    ).then((n) => n.status === "ok").catch((n) => {
+      if (n instanceof P) return null;
+      throw n;
+    }) : Promise.reject(new Error("Data channel not open"));
+  }
+  clearIncomingAudio() {
+    return this._sendCommand({ type: "clear_incoming_audio" });
+  }
+  startHeadTracking(e = 1) {
+    if (!Number.isFinite(e))
+      throw new TypeError(`startHeadTracking: weight must be a finite number; got ${e}`);
+    const t = Math.min(Math.max(e, 0), 1);
+    return this._sendCommand({
+      type: "set_head_tracking",
+      enabled: !0,
+      weight: t
+    });
+  }
+  stopHeadTracking() {
+    return this._sendCommand({ type: "set_head_tracking", enabled: !1 });
+  }
+  getTrackedFace() {
+    return this._slotRoundtrip("tracked_face", { type: "get_tracked_face" });
+  }
+  /**
+   * Trigger a PyPI update of the daemon over the data channel. Remote
+   * counterpart of `POST /update/start`. The daemon acks then restarts
+   * itself once the install finishes, which tears this session down -
+   * the caller is expected to reconnect afterwards.
+   *
+   * Pass `onProgress` to receive `update_progress` events (one per log
+   * line of the update job). A *successful* update restarts the daemon
+   * before a `done` event can arrive, so treat the session teardown +
+   * a successful reconnect as the success signal; `onProgress` will fire
+   * with `status: 'failed'` if the install errors before the restart.
+   *
+   * Returns `false` if the data channel isn't open.
+   */
+  startDaemonUpdate({ preRelease: e = !1, onProgress: t } = {}) {
+    return t && this._updateProgressSubscribers.add(t), this._sendCommand({ type: "start_update", pre_release: e });
+  }
+  setMotorMode(e) {
+    return this._sendCommand({ type: "set_motor_mode", mode: e });
+  }
+  setMotorTorque(e, t = null) {
+    return this._sendCommand({ type: "set_torque", on: e, ids: t });
+  }
+  wakeUp({ timeoutMs: e = 8e3 } = {}) {
+    return this._sendCommand({ type: "set_motor_mode", mode: "enabled" }), this._sendCommandAwaitCompletion("wake_up", e);
+  }
+  gotoSleep({ timeoutMs: e = 8e3 } = {}) {
+    return this._sendCommandAwaitCompletion("goto_sleep", e);
+  }
+  _sendCommandAwaitCompletion(e, t) {
+    return this._sendCommand({ type: e }) ? this._pending.awaitMotion(e, t) : Promise.reject(new Error(`${e}: data channel not open`));
+  }
+  isAwake() {
+    const e = this._robotState?.motor_mode;
+    return e === "enabled" || e === "gravity_compensation";
+  }
+  async ensureAwake(e = 1e3) {
+    if (this._robotState?.motor_mode === void 0 && await new Promise((n) => {
+      const r = () => {
+        this.removeEventListener("state", r), clearTimeout(i), n();
+      }, i = setTimeout(r, e);
+      this.addEventListener("state", r), this.requestState();
+    }), this._robotState?.motor_mode === "gravity_compensation")
+      return _.info("ensureAwake: gravity compensation inherited, flipping to enabled (no emote)"), this.setMotorMode("enabled"), this.requestState(), !0;
+    if (this.isAwake())
+      return _.info("ensureAwake: already awake, nothing to do"), !0;
+    _.info(`ensureAwake: robot asleep (motor_mode=${this._robotState?.motor_mode ?? "unknown"}), playing wake-up`);
+    const t = Date.now();
+    try {
+      await this.wakeUp({ timeoutMs: De }), _.info(`ensureAwake: wake-up trajectory done in ${Date.now() - t}ms`);
+    } catch (n) {
+      _.warn(`ensureAwake: wake-up not confirmed after ${Date.now() - t}ms (continuing):`, n);
+    }
+    return !0;
+  }
+  /**
+   * Query the daemon version. Resolves `null` when the daemon predates
+   * `get_version` (fail-open on the shared slot timeout) or the reply is
+   * superseded by session teardown.
+   */
+  getVersion() {
+    return this._slotRoundtrip("version", { type: "get_version" });
+  }
+  getHardwareId() {
+    return this._slotRoundtrip("hardware_id", { type: "get_hardware_id" });
+  }
+  /**
+   * One-shot IMU reading (BMI088, wireless version only). Resolves `null`
+   * when the robot has no IMU (Lite, simulation) or the daemon predates
+   * the `get_imu` command (fail-open on the shared slot timeout).
+   */
+  getImu() {
+    return this._slotRoundtrip("imu", { type: "get_imu" });
+  }
+  getVolume() {
+    return this._slotRoundtrip("volume", { type: "get_volume" });
+  }
+  setVolume(e) {
+    return this._slotRoundtrip("volume", { type: "set_volume", volume: Y(e) });
+  }
+  getMicrophoneVolume() {
+    return this._slotRoundtrip("mic_volume", { type: "get_microphone_volume" });
+  }
+  setMicrophoneVolume(e) {
+    return this._slotRoundtrip("mic_volume", { type: "set_microphone_volume", volume: Y(e) });
+  }
+  /**
+   * Query whether the first wake-up setup wizard has been completed.
+   * Robot-wide, persisted on the robot. Resolves `false` when pending,
+   * `true` when done, or `null` when the channel isn't open / the daemon
+   * predates the `get_first_wake_up` command (callers should fail-open
+   * and skip the wizard on `null`).
+   */
+  getFirstWakeUp() {
+    return !this._dc || this._dc.readyState !== "open" ? Promise.resolve(null) : this._slotRoundtrip("first_wake_up", { type: "get_first_wake_up" });
+  }
+  /**
+   * Persist the first wake-up wizard completion flag on the robot.
+   * Resolves with the stored value (or `null` on channel-closed).
+   */
+  setFirstWakeUp(e) {
+    return !this._dc || this._dc.readyState !== "open" ? Promise.resolve(null) : this._slotRoundtrip("first_wake_up", { type: "set_first_wake_up", is_completed: e });
+  }
+  /**
+   * Query the persisted robot display name. Resolves the stored name,
+   * `null` when none is set / the channel isn't open / the daemon predates
+   * the `get_robot_name` command.
+   */
+  getRobotName() {
+    return this._slotRoundtrip("robot_name", { type: "get_robot_name" });
+  }
+  /**
+   * Set and persist the robot display name on the robot. Resolves with the
+   * stored (trimmed) name, or `null` on error / channel-closed. Applied live
+   * by the daemon (status + central relay + mDNS), so it takes effect right
+   * away without a restart; the persisted name also overrides --robot-name
+   * on the next start.
+   */
+  setRobotName(e) {
+    return this._slotRoundtrip("robot_name", { type: "set_robot_name", name: e });
+  }
+  /**
+   * Sign this robot out of Hugging Face: asks the daemon to delete its
+   * stored HF token, which de-registers the robot from the central
+   * signaling relay (it disappears from its owner's robot list until it
+   * is set up again). Works over the WebRTC data channel, so it reaches
+   * the robot remotely (no LAN HTTP path required).
+   *
+   * Resolves `true` when the daemon acked success, `false` on a daemon
+   * error, or `null` when no ack arrives before the timeout (e.g. a
+   * daemon that predates the `delete_hf_token` command silently drops
+   * it). Rejects if the data channel isn't open. Note the sign-out
+   * drops the central relay, so the session may tear down right after
+   * the ack - callers should treat a post-call session drop as expected,
+   * and a successful sign-out may surface as `null` if teardown races
+   * ahead of the ack.
+   */
+  signOut() {
+    return this._slotRoundtrip("delete_hf_token", { type: "delete_hf_token" });
+  }
+  applyAudioConfig(e, { verify: t = !0 } = {}) {
+    return this._slotRoundtrip("apply_audio_config", { type: "apply_audio_config", config: e, verify: t }).then((n) => n === !0);
+  }
+  readAudioParameter(e) {
+    return this._slotRoundtrip("read_audio_parameter", { type: "read_audio_parameter", name: e });
+  }
+  /**
+   * Internal: send a command and await the matching daemon response in a
+   * named single-resolver slot (see `PendingReplies.slotRoundtrip`).
+   * Every caller has a strict request/response shape where a single
+   * in-flight call per slot is sufficient.
+   */
+  _slotRoundtrip(e, t) {
+    return !this._dc || this._dc.readyState !== "open" ? Promise.reject(new Error("Data channel not open")) : this._pending.slotRoundtrip(e, () => {
+      this._sendCommand(t);
+    });
+  }
+  sendRaw(e) {
+    return this._sendCommand(e);
+  }
+  /**
+   * Generic command round-trip for daemon commands the SDK has no typed
+   * wrapper for (yet). Escape hatch so an app can use a newer daemon
+   * feature without waiting for an SDK release: sends `command` and
+   * resolves with the first robot message whose `command` field equals
+   * the sent `type` - the daemon's reply convention - or with `null` on
+   * the fail-open timeout (daemon predates the command, or the command
+   * is fire-and-forget and never replies).
+   *
+   * Rejects when the data channel isn't open or the session tears down
+   * mid-flight, mirroring the typed wrappers.
+   *
+   * Replies the SDK already consumes internally (`get_imu`,
+   * `get_volume`, ...) are swallowed by their own handlers and never
+   * reach this matcher - use the typed wrappers for those. Pass `match`
+   * for replies that don't follow the `command` echo convention.
+   */
+  request(e, { timeoutMs: t = ee, match: n } = {}) {
+    if (!this._sendCommand(e))
+      return Promise.reject(new Error("Data channel not open"));
+    const r = n ?? ((i) => i.command === e.type);
+    return this._pending.awaitBroadcast(r, { timeoutMs: t, debugLabel: `request(${e.type})` }).catch((i) => {
+      if (i instanceof P) return null;
+      throw i;
+    });
+  }
+  subscribeLogs({ onLine: e, onError: t }) {
+    if (typeof e != "function")
+      throw new TypeError("subscribeLogs: onLine callback is required");
+    const n = { onLine: e, onError: t }, r = this._logSubscribers.size === 0;
+    this._logSubscribers.add(n), r && this._sendCommand({ type: "subscribe_logs" });
+    let i = !1;
+    return () => {
+      i || (i = !0, this._logSubscribers.delete(n), this._logSubscribers.size === 0 && this._sendCommand({ type: "unsubscribe_logs" }));
+    };
+  }
+  requestState() {
+    return this._sendCommand({ type: "get_state" });
+  }
+  /**
+   * Ask the daemon to *push* the robot state (~30 Hz) over the dedicated
+   * unreliable/unordered `pose` data channel instead of polling get_state.
+   * Fires `state` events as frames arrive. No-op against an older daemon (no
+   * pose channel) - fall back to `requestState()` polling there.
+   *
+   * Refcounted: pair every `subscribePose()` with exactly one
+   * `unsubscribePose()`. Multiple consumers share a single daemon-side
+   * subscription; the daemon only stops pushing once the last one releases.
+   * If the channel isn't open yet (or the session later reconnects), the
+   * subscription is (re-)asserted from `_checkSessionReady`.
+   */
+  subscribePose() {
+    return this._poseSubRefs++, this._sendCommand({ type: "subscribe_pose" });
+  }
+  /** Release one pose-stream consumer; sends `unsubscribe_pose` on the last. */
+  unsubscribePose() {
+    return this._poseSubRefs > 0 && this._poseSubRefs--, this._poseSubRefs > 0 ? !0 : this._sendCommand({ type: "unsubscribe_pose" });
+  }
+  // ─── Audio ───────────────────────────────────────────────────────────
+  setAudioMuted(e) {
+    this._audioMuted = e, this._videoElement && (this._videoElement.muted = e);
+  }
+  setMicMuted(e) {
+    this._micMuted = e, this._micStream && this._micStream.getAudioTracks().forEach((t) => {
+      t.enabled = !e;
+    });
+  }
+  // ─── Video helper ────────────────────────────────────────────────────
+  attachVideo(e) {
+    this._videoElement = e, e.muted = this._audioMuted;
+    const t = (r) => {
+      const i = r;
+      e.srcObject = i.detail.stream, e.playsInline = !0, "requestVideoFrameCallback" in e && this._startLatencyMonitor(e);
+    }, n = () => {
+      e.srcObject = null;
+    };
+    return this.addEventListener("videoTrack", t), this.addEventListener("sessionStopped", n), () => {
+      this.removeEventListener("videoTrack", t), this.removeEventListener("sessionStopped", n), this._latencyMonitorId && (clearInterval(this._latencyMonitorId), this._latencyMonitorId = null), e.srcObject = null, this._videoElement = null;
+    };
+  }
+  // ─── Daemon-side recorded-move playback ──────────────────────────────
+  async playMove(e, {
+    audioBlob: t = null,
+    audioLeadMs: n = -100,
+    description: r = "move",
+    encoding: i = "gzip+base64",
+    playFrequency: o = 100,
+    initialGotoDuration: a = 0,
+    startTimeoutMs: c = 8e3,
+    onProgress: d = () => {
+    },
+    onStarted: u = () => {
+    }
+  } = {}) {
+    if (!this._dc || this._dc.readyState !== "open")
+      throw new Error("data channel not open");
+    if (!e?.time?.length || !e?.set_target_data?.length)
+      throw new Error("playMove: motion must have time + set_target_data");
+    const l = K();
+    this._activeMoveUploadId = l;
+    const m = {
+      description: r,
+      time: e.time,
+      set_target_data: e.set_target_data
+    }, g = JSON.stringify(m);
+    let f, v;
+    i === "gzip+base64" && Ce() ? (f = await Me(g), v = "gzip+base64") : (f = g, v = "json");
+    const w = Math.ceil(f.length / y) || 1;
+    d({
+      phase: "starting",
+      sent: 0,
+      total: w,
+      bytes: f.length,
+      encoding: v
+    }), this._sendCommand({
+      type: "upload_move_start",
+      upload_id: l,
+      total_chunks: w,
+      description: r,
+      encoding: v
+    });
+    for (let h = 0; h < w; h++) {
+      this._dc.bufferedAmount > U && await this._awaitDataChannelDrain();
+      const p = h * y;
+      this._sendCommand({
+        type: "upload_move_chunk",
+        upload_id: l,
+        chunk_index: h,
+        chunk: f.slice(p, p + y)
+      }), d({ phase: "upload", sent: h + 1, total: w });
+    }
+    if (this._sendCommand({ type: "upload_move_finish", upload_id: l }), d({ phase: "uploaded", sent: w, total: w }), t) {
+      const h = new Uint8Array(await t.arrayBuffer()), p = N(h), R = Math.ceil(p.length / y) || 1;
+      d({
+        phase: "audio-starting",
+        sent: 0,
+        total: R,
+        bytes: p.length
+      }), this._sendCommand({
+        type: "upload_audio_start",
+        upload_id: l,
+        total_chunks: R,
+        encoding: X(t),
+        description: r
+      });
+      for (let T = 0; T < R; T++) {
+        this._dc.bufferedAmount > U && await this._awaitDataChannelDrain();
+        const W = T * y;
+        this._sendCommand({
+          type: "upload_audio_chunk",
+          upload_id: l,
+          chunk_index: T,
+          chunk: p.slice(W, W + y)
+        }), d({ phase: "audio-upload", sent: T + 1, total: R });
+      }
+      this._sendCommand({ type: "upload_audio_finish", upload_id: l }), d({ phase: "audio-uploaded", sent: R, total: R });
+    }
+    this._sendCommand({
+      type: "play_uploaded_move",
+      upload_id: l,
+      play_frequency: o,
+      initial_goto_duration: a,
+      audio_lead_ms: n
+    });
+    let b;
+    try {
+      b = await this._waitForBroadcast(
+        (h) => h?.type === "play_uploaded_move" && h?.upload_id === l && (h.started === !0 || typeof h.error == "string"),
+        { timeoutMs: c, debugLabel: "play_uploaded_move started" }
+      );
+    } catch (h) {
+      throw new Error(
+        `Daemon did not respond to play_uploaded_move (requires the reachy_mini daemon with feature/daemon-side-move-upload). Underlying: ${h.message}`
+      );
+    }
+    if (typeof b.error == "string")
+      throw new Error(`play_uploaded_move: ${b.error}`);
+    try {
+      u({
+        duration_s: b.duration_s,
+        has_audio: b.has_audio === !0
+      });
+    } catch (h) {
+      _.warn("playMove.onStarted threw:", h);
+    }
+    d({ phase: "playing", duration_s: b.duration_s });
+    const E = await this._waitForBroadcast(
+      (h) => h?.type === "play_uploaded_move" && h?.upload_id === l && (h.finished === !0 || h.cancelled === !0 || typeof h.error == "string"),
+      {
+        timeoutMs: (b.duration_s + 30) * 1e3,
+        debugLabel: "play_uploaded_move final"
+      }
+    );
+    return this._activeMoveUploadId === l && (this._activeMoveUploadId = null), E;
+  }
+  cancelMove(e = null) {
+    const t = e ?? this._activeMoveUploadId;
+    return t ? this._sendCommand({ type: "cancel_move", upload_id: t }) : !1;
+  }
+  async uploadAudio(e, { description: t = "audio", onProgress: n = () => {
+  } } = {}) {
+    if (!this._dc || this._dc.readyState !== "open")
+      throw new Error("data channel not open");
+    if (!(e instanceof Blob))
+      throw new TypeError("uploadAudio: expected a Blob");
+    const r = K(), i = new Uint8Array(await e.arrayBuffer()), o = N(i), a = Math.ceil(o.length / y) || 1;
+    n({ phase: "audio-starting", sent: 0, total: a, bytes: o.length }), this._sendCommand({
+      type: "upload_audio_start",
+      upload_id: r,
+      total_chunks: a,
+      encoding: X(e),
+      description: t
+    });
+    for (let c = 0; c < a; c++) {
+      this._dc.bufferedAmount > U && await this._awaitDataChannelDrain();
+      const d = c * y;
+      this._sendCommand({
+        type: "upload_audio_chunk",
+        upload_id: r,
+        chunk_index: c,
+        chunk: o.slice(d, d + y)
+      }), n({ phase: "audio-upload", sent: c + 1, total: a });
+    }
+    return this._sendCommand({ type: "upload_audio_finish", upload_id: r }), n({ phase: "audio-uploaded", sent: a, total: a }), r;
+  }
+  async playUploadedAudio(e, { timeoutMs: t = 8e3 } = {}) {
+    if (!this._dc || this._dc.readyState !== "open")
+      throw new Error("data channel not open");
+    const n = this._waitForBroadcast(
+      (i) => i?.type === "play_uploaded_audio" && i?.upload_id === e && (i.started === !0 || typeof i.error == "string"),
+      { timeoutMs: t, debugLabel: "play_uploaded_audio started" }
+    );
+    this._sendCommand({ type: "play_uploaded_audio", upload_id: e });
+    const r = await n;
+    if (typeof r.error == "string") throw new Error(r.error);
+    return this._activeAudioUploadId = e, r;
+  }
+  cancelAudio(e = null) {
+    const t = e ?? this._activeAudioUploadId;
+    return t ? (this._activeAudioUploadId === t && (this._activeAudioUploadId = null), this._sendCommand({ type: "cancel_audio", upload_id: t })) : !1;
+  }
+  // ─── Private ─────────────────────────────────────────────────────────
+  _emit(e, t) {
+    this.dispatchEvent(new CustomEvent(e, { detail: t }));
+  }
+  _waitForBroadcast(e, t = {}) {
+    return this._pending.awaitBroadcast(e, t);
+  }
+  async _awaitDataChannelDrain() {
+    for (; this._dc && this._dc.bufferedAmount > Ae; )
+      if (await new Promise((e) => setTimeout(e, 30)), !this._dc || this._dc.readyState !== "open")
+        throw new Error("data channel closed mid-upload");
+  }
+  async _sendToServer(e) {
+    if (!this._token) throw new Error("No token — authenticate() first");
+    try {
+      const t = await fetch(`${this._signalingUrl}/send`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this._token}`
+        },
+        body: JSON.stringify(e)
+      });
+      if (!t.ok) {
+        let n = "";
+        try {
+          n = await t.text();
+        } catch {
+        }
+        return _.warn(
+          `/send rejected (${t.status}) for type=${e?.type}; body=${n || "<empty>"}`
+        ), null;
+      }
+      return await t.json();
+    } catch (t) {
+      return _.error("signaling /send failed:", t), null;
+    }
+  }
+  _sendCommand(e) {
+    return !this._dc || this._dc.readyState !== "open" ? !1 : (this._dc.send(JSON.stringify(e)), !0);
+  }
+  /**
+   * Call a JSON-RPC method on the robot/app over the DataChannel and await
+   * its result. This is the one way to drive an on-robot app (start/stop it
+   * via `apps.*`, or drive a running app via its own namespace, e.g.
+   * `conversation.say`). Rejects on the JSON-RPC error, a closed channel, or
+   * timeout.
+   */
+  rpcCall(e, t = {}, n = {}) {
+    const r = n.timeoutMs ?? 2e4;
+    return this._pending.rpcRoundtrip(
+      e,
+      r,
+      (i) => this._sendCommand({ jsonrpc: "2.0", id: i, method: e, params: t })
+    );
+  }
+  /**
+   * Subscribe to a JSON-RPC notification (one-way event) pushed by the
+   * robot/app, e.g. `conversation.turn`. Returns an unsubscribe function.
+   */
+  onNotification(e, t) {
+    let n = this._rpcListeners.get(e);
+    return n || (n = /* @__PURE__ */ new Set(), this._rpcListeners.set(e, n)), n.add(t), () => {
+      this._rpcListeners.get(e)?.delete(t);
+    };
+  }
+  _handleRpcMessage(e) {
+    if (!this._pending.settleRpcResponse(e) && typeof e.method == "string") {
+      const t = e.params ?? {};
+      for (const n of this._rpcListeners.get(e.method) ?? [])
+        try {
+          n(t);
+        } catch (r) {
+          _.error(`onNotification(${e.method}) threw:`, r);
+        }
+    }
+  }
+  _checkSessionReady() {
+    this._iceConnected && this._dcOpen && this._sessionResolve && (this._state = "streaming", this.requestState(), this._poseSubRefs > 0 && this._sendCommand({ type: "subscribe_pose" }), this._lastPoseFrameAt = 0, this._stateRefreshInterval = setInterval(() => {
+      Date.now() - this._lastPoseFrameAt < Q || this.requestState();
+    }, 500), this._supervisor.startDcWatchdog(), this._emit("streaming", { sessionId: this._sessionId, robotId: this._selectedRobotId }), this._sessionResolve(), this._sessionResolve = null, this._sessionReject = null);
+  }
+  async _handleSignalingMessage(e) {
+    switch (e.type) {
+      case "welcome":
+        break;
+      case "list":
+        this._robots = e.producers || [], this._emit("robotsChanged", { robots: this._robots }), this._maybeAutoStart();
+        break;
+      case "peerStatusChanged": {
+        const t = await this._sendToServer({ type: "list" });
+        t?.producers && (this._robots = t.producers, this._emit("robotsChanged", { robots: this._robots }), this._maybeAutoStart());
+        break;
+      }
+      case "sessionStarted":
+        this._sessionId = e.sessionId ?? null;
+        break;
+      case "sessionRejected":
+        this._failSessionRejected(e);
+        break;
+      case "endSession":
+        this._handleEndSession(e);
+        break;
+      case "peer":
+        this._handlePeerMessage(e);
+        break;
+    }
+  }
+  _handleEndSession(e) {
+    const t = e.reason, n = t === "robot_busy_local_app" ? "Robot is busy: a local Python app is running" : t === "local_app_started" ? "Disconnected: a local Python app started on the robot" : t === "robot_busy_local" ? "Robot is busy: another session is already active" : null;
+    if (this._sessionReject) {
+      const r = new Error(
+        n || `Session ended before it could start: ${t || "unknown reason"}`
+      );
+      r.reason = t ?? null, this._supervisor.redialing || this._emit("sessionRejected", { reason: t, activeApp: null }), this._supervisor.clearIceGrace(), this._supervisor.uninstallNetworkListeners(), this._pc && (this._pc.close(), this._pc = null), this._micStream && (this._micStream.getTracks().forEach((o) => o.stop()), this._micStream = null), this._iceConnected = !1, this._dcOpen = !1, this._micMuted = !0, this._micSupported = !1;
+      const i = this._sessionReject;
+      this._sessionResolve = null, this._sessionReject = null, i(r);
+      return;
+    }
+    this._state === "streaming" && (this._emit("sessionStopped", {
+      reason: t || "remote_end",
+      message: n
+    }), this.stopSession().catch(() => {
+    }));
+  }
+  async _handlePeerMessage(e) {
+    if (this._pc)
+      try {
+        if (e.sdp) {
+          const t = e.sdp;
+          if (t.type === "offer") {
+            const r = ve(t.sdp);
+            if (this._micSupported = r, this._emit("micSupported", { supported: r }), r && this._micStream)
+              for (const o of this._micStream.getAudioTracks())
+                this._pc.addTrack(o, this._micStream);
+            await this._pc.setRemoteDescription(new RTCSessionDescription(t));
+            const i = await this._pc.createAnswer();
+            await this._pc.setLocalDescription(i), await this._sendToServer({
+              type: "peer",
+              sessionId: this._sessionId,
+              sdp: { type: "answer", sdp: i.sdp }
+            });
+          } else
+            await this._pc.setRemoteDescription(new RTCSessionDescription(t));
+          const n = this._pendingRemoteIce;
+          if (n && n.length) {
+            this._pendingRemoteIce = [];
+            for (const r of n)
+              try {
+                await this._pc.addIceCandidate(new RTCIceCandidate(r));
+              } catch (i) {
+                _.warn("buffered ICE candidate rejected:", i);
+              }
+          }
+        }
+        if (e.ice) {
+          if (!e.ice.candidate) return;
+          this._pc.remoteDescription ? await this._pc.addIceCandidate(new RTCIceCandidate(e.ice)) : (this._pendingRemoteIce || (this._pendingRemoteIce = []), this._pendingRemoteIce.push(e.ice));
+        }
+      } catch (t) {
+        _.error("webrtc signaling failed:", t), this._emit("error", { source: "webrtc", error: t });
+      }
+  }
+  /**
+   * @param fromPoseStream Frame came from the pushed `pose` channel rather
+   *   than the reliable control channel. Only those may refresh the state
+   *   mirror while the stream is live (see the `data.state` branch).
+   */
+  _handleRobotMessage(e, t = !1) {
+    if (this._supervisor.stampDcInbound(), e.jsonrpc === "2.0") {
+      this._handleRpcMessage(e);
+      return;
+    }
+    if (!("version" in e && this._pending.settleReplySlot("version", e.version ?? null)) && !("hardware_id" in e && this._pending.settleReplySlot("hardware_id", e.hardware_id ?? null))) {
+      if (e.command === "get_volume" || e.command === "set_volume") {
+        this._pending.settleReplySlot("volume", e.status === "error" ? null : e.volume);
+        return;
+      }
+      if (e.command === "get_microphone_volume" || e.command === "set_microphone_volume") {
+        this._pending.settleReplySlot("mic_volume", e.status === "error" ? null : e.volume);
+        return;
+      }
+      if (e.command === "get_first_wake_up" || e.command === "set_first_wake_up") {
+        this._pending.settleReplySlot(
+          "first_wake_up",
+          e.status === "error" ? null : !!e.is_completed
+        );
+        return;
+      }
+      if (e.command === "get_robot_name" || e.command === "set_robot_name") {
+        this._pending.settleReplySlot(
+          "robot_name",
+          e.status === "error" ? null : e.name ?? null
+        );
+        return;
+      }
+      if (e.command === "delete_hf_token") {
+        this._pending.settleReplySlot("delete_hf_token", e.status !== "error");
+        return;
+      }
+      if (e.command === "apply_audio_config") {
+        this._pending.settleReplySlot("apply_audio_config", e.error ? !1 : !!e.applied);
+        return;
+      }
+      if (e.command === "read_audio_parameter") {
+        this._pending.settleReplySlot(
+          "read_audio_parameter",
+          e.error ? null : e.values ?? null
+        );
+        return;
+      }
+      if (e.command === "get_tracked_face") {
+        this._pending.settleReplySlot("tracked_face", e.face_target ?? null);
+        return;
+      }
+      if (e.command === "get_imu") {
+        this._pending.settleReplySlot("imu", e.imu ?? null);
+        return;
+      }
+      if (!((e.command === "wake_up" || e.command === "goto_sleep") && this._pending.settleMotion(e.command, e))) {
+        if (e.type === "log_line") {
+          for (const n of this._logSubscribers)
+            try {
+              n.onLine({ timestamp: e.timestamp, line: e.line });
+            } catch (r) {
+              _.error("subscribeLogs onLine threw:", r);
+            }
+          return;
+        }
+        if (e.type === "log_stream_error") {
+          for (const n of this._logSubscribers)
+            if (typeof n.onError == "function")
+              try {
+                n.onError(e.error);
+              } catch (r) {
+                _.error("subscribeLogs onError threw:", r);
+              }
+          return;
+        }
+        if (e.command === "start_update") {
+          if (typeof e.error == "string") {
+            const n = { status: "failed", error: e.error };
+            for (const r of this._updateProgressSubscribers)
+              try {
+                r(n);
+              } catch (i) {
+                _.error("startDaemonUpdate onProgress threw:", i);
+              }
+          }
+          return;
+        }
+        if (e.type === "update_progress") {
+          const n = {
+            status: e.status,
+            line: typeof e.line == "string" ? e.line : void 0,
+            error: typeof e.error == "string" ? e.error : void 0
+          };
+          for (const r of this._updateProgressSubscribers)
+            try {
+              r(n);
+            } catch (i) {
+              _.error("startDaemonUpdate onProgress threw:", i);
+            }
+          return;
+        }
+        if (e.state && (t || Date.now() - this._lastPoseFrameAt >= Q)) {
+          const n = e.state;
+          n.head_pose && (this._robotState.head = n.head_pose.flat()), n.antennas && (this._robotState.antennas = [n.antennas[0], n.antennas[1]]), n.head_joint_positions && (this._robotState.head_joint_positions = n.head_joint_positions), typeof n.body_yaw == "number" && (this._robotState.body_yaw = n.body_yaw), n.motor_mode && (this._robotState.motor_mode = n.motor_mode), typeof n.is_move_running == "boolean" && (this._robotState.is_move_running = n.is_move_running), n.face_target && (this._robotState.face_target = n.face_target), "doa" in n && (this._robotState.doa = n.doa ?? void 0), this._emit("state", { ...this._robotState });
+        }
+        e.error && this._emit("error", { source: "robot", error: e.error }), this._pending.matchBroadcast(e);
+      }
+    }
+  }
+  /** Snap video playback to live edge if buffered lag exceeds 0.5 s. */
+  _startLatencyMonitor(e) {
+    this._latencyMonitorId && clearInterval(this._latencyMonitorId), this._latencyMonitorId = setInterval(() => {
+      if (!e.srcObject || e.paused) return;
+      const t = e.buffered;
+      if (t.length > 0) {
+        const n = t.end(t.length - 1), r = n - e.currentTime;
+        r > 0.5 && (_.debug(`video latency correction: was ${r.toFixed(2)}s behind`), e.currentTime = n - 0.1);
+      }
+    }, 2e3);
+  }
+}
+const Le = "pollen-robotics/reachy_mini", Ue = `https://api.github.com/repos/${Le}/releases/latest`, te = "reachy.daemonLatestRelease.v1", Pe = 360 * 60 * 1e3, ne = "1.8.2";
+function k(s) {
+  if (typeof s != "string") return null;
+  const e = s.trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  return e ? {
+    major: Number(e[1]),
+    minor: Number(e[2]),
+    patch: Number(e[3])
+  } : null;
+}
+function H(s, e) {
+  return s.major - e.major || s.minor - e.minor || s.patch - e.patch;
+}
+function $e(s, e) {
+  const t = k(s), n = k(e);
+  return !t || !n ? !1 : H(t, n) < 0;
+}
+function We(s, e) {
+  const t = k(s);
+  if (!t) return null;
+  const n = k(ne);
+  return n && H(t, n) < 0 ? "block" : $e(s, e) ? "notice" : null;
+}
+function Be(s) {
+  const e = k(s), t = k(ne);
+  return !!e && !!t && H(e, t) >= 0;
+}
+function Ne() {
+  try {
+    const s = localStorage.getItem(te);
+    if (!s) return null;
+    const e = JSON.parse(s);
+    return typeof e.at != "number" ? null : {
+      value: typeof e.value == "string" ? e.value : null,
+      at: e.at
+    };
+  } catch {
+    return null;
+  }
+}
+async function qe() {
+  const s = Ne();
+  if (s && Date.now() - s.at < Pe) return s.value;
+  try {
+    const e = await fetch(Ue, {
+      headers: { Accept: "application/vnd.github+json" }
+    });
+    if (!e.ok)
+      return s?.value ?? null;
+    const t = await e.json(), n = typeof t.tag_name == "string" ? t.tag_name : null, r = n ? n.replace(/^v/i, "") : null;
+    try {
+      localStorage.setItem(te, JSON.stringify({ value: r, at: Date.now() }));
+    } catch {
+    }
+    return r;
+  } catch {
+    return s?.value ?? null;
+  }
+}
+const Oe = 8e3;
+function je(s) {
+  if (!s) return null;
+  const e = s.id ?? s.peerId ?? s.peer_id;
+  return typeof e == "string" && e.length > 0 ? e : null;
+}
+function Fe(s) {
+  const e = je(s);
+  if (!e) return null;
+  const t = s.meta?.name ?? s.name, n = typeof s.meta?.transport == "string" && s.meta.transport.length > 0 ? s.meta.transport : null, r = typeof s.meta?.hardware_id == "string" && s.meta.hardware_id.length > 0 ? s.meta.hardware_id : null;
+  return {
+    id: e,
+    meta: t ? { name: t } : void 0,
+    busy: s.busy === !0,
+    activeApp: typeof s.activeApp == "string" && s.activeApp.trim().length > 0 ? s.activeApp : null,
+    transport: n,
+    hardwareId: r
+  };
+}
+async function Ge(s) {
+  const { signalingUrl: e, hfToken: t } = s;
+  if (!t) return { ok: !1, robots: [], reason: "No HF token" };
+  if (!e)
+    return { ok: !1, robots: [], reason: "No signaling URL" };
+  const n = `${e.replace(/\/$/, "")}/api/robot-status`, r = new AbortController(), i = setTimeout(() => r.abort(), Oe), o = s.signal ? xe([r.signal, s.signal]) : r.signal;
+  try {
+    const a = await fetch(n, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${t}`,
+        Accept: "application/json"
+      },
+      signal: o
+    });
+    if (a.status === 401 || a.status === 403)
+      return { ok: !1, robots: [], reason: "Token rejected by Hugging Face" };
+    if (!a.ok)
+      return {
+        ok: !1,
+        robots: [],
+        reason: `Central returned HTTP ${a.status}`
+      };
+    const c = await a.json();
+    return { ok: !0, robots: (Array.isArray(c.robots) ? c.robots : []).map(Fe).filter((l) => l != null) };
+  } catch (a) {
+    if (a instanceof DOMException && a.name === "AbortError")
+      return { ok: !1, robots: [], reason: "Central request timed out" };
+    const c = a instanceof Error ? a.message : String(a);
+    return { ok: !1, robots: [], reason: `Network error: ${c}` };
+  } finally {
+    clearTimeout(i);
+  }
+}
+function xe(s) {
+  const e = new AbortController();
+  for (const t of s) {
+    if (t.aborted)
+      return e.abort(), e.signal;
+    t.addEventListener("abort", () => e.abort(), { once: !0 });
+  }
+  return e.signal;
+}
+export {
+  ne as M,
+  He as R,
+  Ge as a,
+  O as c,
+  We as d,
+  qe as f,
+  k as p,
+  Be as s
+};