@pollen-robotics/reachy-mini-sdk 1.7.3 → 1.8.0-main.54c2dcd

package/host/dist/chunks/reachy-mini-BV9nAnC1.js

@@ -0,0 +1,1283 @@
+var L = Object.defineProperty, D = (n, e, t) => e in n ? L(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, A = (n, e, t) => (D(n, typeof e != "symbol" ? e + "" : e, t), t), P = "https://huggingface.co";
+async function C(n, e) {
+  var t, s;
+  const o = new $(n.url, n.status, (t = n.headers.get("X-Request-Id")) != null ? t : void 0);
+  o.message = `Api error with status ${o.statusCode}`;
+  const i = [`URL: ${o.url}`, o.requestId ? `Request ID: ${o.requestId}` : void 0].filter(Boolean).join(". ");
+  if ((s = n.headers.get("Content-Type")) != null && s.startsWith("application/json")) {
+    const r = await n.json();
+    o.message = r.error || r.message || o.message, o.data = r;
+  } else
+    o.data = { message: await n.text() };
+  throw o.message += `. ${i}`, o;
+}
+var $ = class extends Error {
+  constructor(n, e, t, s) {
+    super(s), A(this, "statusCode"), A(this, "url"), A(this, "requestId"), A(this, "data"), this.statusCode = e, this.requestId = t, this.url = n;
+  }
+};
+new Promise((n) => {
+});
+function x(n) {
+  if (globalThis.Buffer)
+    return globalThis.Buffer.from(n).toString("base64");
+  {
+    const e = [];
+    return n.forEach((t) => {
+      e.push(String.fromCharCode(t));
+    }), globalThis.btoa(e.join(""));
+  }
+}
+async function M(n) {
+  var e, t;
+  if (typeof window > "u")
+    throw new Error("oauthHandleRedirect is only available in the browser");
+  const s = new URLSearchParams(window.location.search), [o, i] = [s.get("error"), s.get("error_description")];
+  if (o)
+    throw new Error(`${o}: ${i}`);
+  const r = s.get("code"), a = localStorage.getItem("huggingface.co:oauth:nonce");
+  if (!r)
+    throw new Error("Missing oauth code from query parameters in redirected URL");
+  if (!a)
+    throw new Error("Missing oauth nonce from localStorage");
+  const l = localStorage.getItem("huggingface.co:oauth:code_verifier");
+  if (!l)
+    throw new Error("Missing oauth code_verifier from localStorage");
+  const c = s.get("state");
+  if (!c)
+    throw new Error("Missing oauth state from query parameters in redirected URL");
+  let h;
+  try {
+    h = JSON.parse(c);
+  } catch {
+    throw new Error("Invalid oauth state in redirected URL, unable to parse JSON: " + c);
+  }
+  if (h.nonce !== a)
+    throw new Error("Invalid oauth state in redirected URL");
+  const d = P, m = `${new URL(d).origin}/.well-known/openid-configuration`, f = await fetch(m, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!f.ok)
+    throw await C(f);
+  const p = await f.json(), v = await fetch(p.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code: r,
+      redirect_uri: h.redirectUri,
+      code_verifier: l
+    }).toString()
+  });
+  if (localStorage.removeItem("huggingface.co:oauth:code_verifier"), localStorage.removeItem("huggingface.co:oauth:nonce"), !v.ok)
+    throw await C(v);
+  const w = await v.json(), g = new Date(Date.now() + w.expires_in * 1e3), S = await fetch(p.userinfo_endpoint, {
+    headers: {
+      Authorization: `Bearer ${w.access_token}`
+    }
+  });
+  if (!S.ok)
+    throw await C(S);
+  const u = await S.json();
+  return {
+    accessToken: w.access_token,
+    accessTokenExpiresAt: g,
+    userInfo: {
+      id: u.sub,
+      name: u.name,
+      fullname: u.preferred_username,
+      email: u.email,
+      emailVerified: u.email_verified,
+      avatarUrl: u.picture,
+      websiteUrl: u.website,
+      isPro: u.isPro,
+      orgs: (t = (e = u.orgs) == null ? void 0 : e.map((_) => ({
+        id: _.sub,
+        name: _.name,
+        fullname: _.name,
+        isEnterprise: _.isEnterprise,
+        canPay: _.canPay,
+        avatarUrl: _.picture,
+        roleInOrg: _.roleInOrg
+      }))) != null ? t : []
+    },
+    state: h.state,
+    scope: w.scope
+  };
+}
+async function O(n) {
+  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") ? M() : e.has("code") ? localStorage.getItem("huggingface.co:oauth:nonce") ? M() : (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 N(n) {
+  var e, t;
+  if (typeof window > "u")
+    throw new Error("oauthLogin is only available in the browser");
+  const s = n?.hubUrl || P, o = `${new URL(s).origin}/.well-known/openid-configuration`, i = await fetch(o, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!i.ok)
+    throw await C(i);
+  const r = await i.json(), a = globalThis.crypto.randomUUID(), l = globalThis.crypto.randomUUID() + globalThis.crypto.randomUUID();
+  localStorage.setItem("huggingface.co:oauth:nonce", a), localStorage.setItem("huggingface.co:oauth:code_verifier", l);
+  const c = n?.redirectUrl || window.location.href, h = JSON.stringify({
+    nonce: a,
+    redirectUri: c,
+    state: n?.state
+  }), d = (t = (e = window?.huggingface) == null ? void 0 : e.variables) != null ? t : null, m = n?.clientId || d?.OAUTH_CLIENT_ID;
+  if (!m)
+    throw d ? new Error("Missing clientId, please add hf_oauth: true to the README.md's metadata in your static Space") : new Error("Missing clientId");
+  const f = x(
+    new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(l)))
+  ).replace(/[+]/g, "-").replace(/[/]/g, "_").replace(/=/g, "");
+  return `${r.authorization_endpoint}?${new URLSearchParams({
+    client_id: m,
+    scope: n?.scopes || d?.OAUTH_SCOPES || "openid profile",
+    response_type: "code",
+    redirect_uri: c,
+    state: h,
+    code_challenge: f,
+    code_challenge_method: "S256"
+  }).toString()}`;
+}
+function R(n) {
+  return n * Math.PI / 180;
+}
+function F(n, e, t) {
+  const s = R(n), o = R(e), i = R(t), r = Math.cos(i), a = Math.sin(i), l = Math.cos(o), c = Math.sin(o), h = Math.cos(s), d = Math.sin(s);
+  return [
+    [r * l, r * c * d - a * h, r * c * h + a * d, 0],
+    [a * l, a * c * d + r * h, a * c * h - r * d, 0],
+    [-c, l * d, l * h, 0],
+    [0, 0, 0, 1]
+  ];
+}
+function B() {
+  if (typeof window > "u" || !window.location.hash) return;
+  const n = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+  let e;
+  try {
+    e = new URLSearchParams(n);
+  } catch {
+    return;
+  }
+  const t = e.get("hf_token");
+  if (!t) return;
+  const s = e.get("hf_username") || "user", o = e.get("hf_token_expires"), i = o && !Number.isNaN(new Date(o).getTime()) ? o : new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3).toISOString();
+  try {
+    sessionStorage.setItem("hf_token", t), sessionStorage.setItem("hf_username", s), sessionStorage.setItem("hf_token_expires", i);
+  } catch (l) {
+    console.warn("[reachy-mini] could not persist pre-seeded HF credentials:", l);
+  }
+  e.delete("hf_token"), e.delete("hf_username"), e.delete("hf_token_expires");
+  const r = e.toString(), a = window.location.pathname + window.location.search + (r ? "#" + r : "");
+  try {
+    window.history.replaceState(null, "", a);
+  } catch {
+  }
+}
+function V() {
+  if (typeof window > "u") return null;
+  if (window.location.hash) {
+    const n = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+    try {
+      const t = new URLSearchParams(n).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 q(n) {
+  const e = n.split(`\r
+`);
+  let t = !1;
+  for (const s of e)
+    if (s.startsWith("m=audio") ? t = !0 : s.startsWith("m=") && (t = !1), t && s === "a=sendrecv") return !0;
+  return !1;
+}
+const y = 12 * 1024, k = 1 * 1024 * 1024, H = 512 * 1024;
+function W() {
+  return typeof CompressionStream < "u";
+}
+function U() {
+  return "u" + Math.random().toString(36).slice(2, 11) + Date.now().toString(36);
+}
+function E(n) {
+  let e = "";
+  for (let s = 0; s < n.length; s += 32768)
+    e += String.fromCharCode.apply(
+      null,
+      Array.from(n.subarray(s, s + 32768))
+    );
+  return btoa(e);
+}
+async function z(n) {
+  const e = new TextEncoder().encode(n), t = await new Response(
+    new Blob([e]).stream().pipeThrough(new CompressionStream("gzip"))
+  ).arrayBuffer();
+  return E(new Uint8Array(t));
+}
+function j(n) {
+  const e = Math.round(Number(n) || 0);
+  return Math.max(0, Math.min(100, e));
+}
+class J extends EventTarget {
+  // ─── Config ──────────────────────────────────────────────────────────
+  _signalingUrl;
+  _clientId;
+  _appName;
+  _videoJitterBufferTargetMs;
+  _autoStartFromUrl;
+  _autoStartAttempted;
+  // ─── Public-ish state mirrors ────────────────────────────────────────
+  _state = "disconnected";
+  _robots = [];
+  _robotState = {};
+  _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;
+  // ─── Single-slot promise resolvers ───────────────────────────────────
+  _versionResolve = null;
+  _hardwareIdResolve = null;
+  _volumeResolve = null;
+  _micVolumeResolve = null;
+  // applyAudioConfig() / readAudioParameter() share the same single-slot
+  // pattern as the volume helpers. Separate slots so the two can be
+  // in-flight concurrently without collision.
+  _applyAudioConfigResolve = null;
+  _readAudioParameterResolve = null;
+  // ─── Log subscribers ─────────────────────────────────────────────────
+  _logSubscribers = /* @__PURE__ */ new Set();
+  // ─── Broadcast waiters (playMove / playUploadedAudio) ────────────────
+  _broadcastWaiters = [];
+  // ─── Active upload ids for no-arg cancels ────────────────────────────
+  _activeMoveUploadId = null;
+  _activeAudioUploadId = null;
+  // ─── Session promise plumbing ────────────────────────────────────────
+  _sessionResolve = null;
+  _sessionReject = null;
+  _iceConnected = !1;
+  _dcOpen = !1;
+  // ─── Motion completion plumbing (wake_up / goto_sleep) ───────────────
+  _pendingMotionCompletions = {
+    wake_up: [],
+    goto_sleep: []
+  };
+  // ─── 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 = V();
+  }
+  // ─── 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;
+  }
+  /**
+   * 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((s) => s.id === this._preselectedRobotId)) return;
+    this._autoStartAttempted = !0;
+    const t = this._preselectedRobotId;
+    setTimeout(() => {
+      this._state === "connected" && this.startSession(t).catch((s) => {
+        console.warn("[reachy-mini] autoStartFromUrl: startSession rejected:", s);
+      });
+    }, 0);
+  }
+  // ─── Auth ────────────────────────────────────────────────────────────
+  async authenticate() {
+    try {
+      B();
+      const e = await O();
+      if (e)
+        return this._username = e.userInfo.preferred_username || e.userInfo.name || null, this._token = e.accessToken, this._tokenExpires = e.accessTokenExpiresAt, sessionStorage.setItem("hf_token", this._token), sessionStorage.setItem("hf_username", this._username ?? ""), sessionStorage.setItem(
+          "hf_token_expires",
+          typeof this._tokenExpires == "string" ? this._tokenExpires : this._tokenExpires.toISOString()
+        ), !0;
+      const t = sessionStorage.getItem("hf_token"), s = sessionStorage.getItem("hf_username"), o = sessionStorage.getItem("hf_token_expires");
+      return t && s && o && new Date(o) > /* @__PURE__ */ new Date() ? (this._token = t, this._username = s, this._tokenExpires = o, !0) : !1;
+    } catch (e) {
+      return console.error("Auth error:", e), !1;
+    }
+  }
+  async login() {
+    const e = {};
+    this._clientId && (e.clientId = this._clientId), window.location.href = await N(e);
+  }
+  logout() {
+    sessionStorage.removeItem("hf_token"), sessionStorage.removeItem("hf_username"), sessionStorage.removeItem("hf_token_expires"), 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 (s) {
+      throw this._sseAbortController = null, s;
+    }
+    if (!t.ok)
+      throw this._sseAbortController = null, new Error(`HTTP ${t.status}`);
+    return new Promise((s, o) => {
+      let i = !1;
+      const r = t.body.getReader(), a = new TextDecoder();
+      let l = "";
+      (async () => {
+        try {
+          for (; ; ) {
+            const { done: h, value: d } = await r.read();
+            if (h) break;
+            l += a.decode(d, { stream: !0 });
+            const m = l.split(`
+`);
+            l = m.pop() ?? "";
+            for (const f of m)
+              if (f.startsWith("data:"))
+                try {
+                  const p = JSON.parse(f.slice(5).trim());
+                  !i && p.type === "welcome" && p.peerId && (i = !0, this._state = "connected", await this._sendToServer({
+                    type: "setPeerStatus",
+                    roles: ["listener"],
+                    meta: { name: this._appName }
+                  }), this._emit("connected", { peerId: p.peerId }), s()), this._handleSignalingMessage(p);
+                } catch {
+                }
+          }
+        } catch (h) {
+          if (h.name !== "AbortError" && this._emit("error", { source: "signaling", error: h }), !i) {
+            o(h);
+            return;
+          }
+        }
+        this._state !== "disconnected" && (this._state = "disconnected", this._emit("disconnected", { reason: "SSE closed" })), i || o(new Error("Connection closed before welcome"));
+      })();
+    });
+  }
+  async autoConnect(e = {}) {
+    const {
+      token: t,
+      pickRobot: s,
+      autoPickIfSingle: o = !0,
+      filterBusy: i = !0,
+      wakeOnConnect: r = !0
+    } = e;
+    if (this._state === "streaming") {
+      const l = this._robots?.find((c) => c.id === this._selectedRobotId);
+      return {
+        robotId: this._selectedRobotId,
+        robotName: l?.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 l, c = null;
+      if (this.isEmbedded) {
+        l = this._preselectedRobotId;
+        try {
+          await this._waitForRobotInList(l, 5e3);
+        } catch {
+        }
+        c = this._robots?.find((d) => d.id === l)?.meta?.name ?? null;
+      } else {
+        const h = await this._fetchOwnedRobots({ filterBusy: i });
+        if (h.length === 0)
+          throw new Error("No reachable robots");
+        if (o && h.length === 1 && !h[0].busy)
+          l = h[0].id, c = h[0].name;
+        else if (s) {
+          const d = await s(h);
+          if (!d) throw new Error("Robot selection cancelled");
+          l = d, c = h.find((m) => m.id === d)?.name ?? null;
+        } else
+          throw new Error(
+            "Multiple robots available — pass a pickRobot callback to autoConnect()"
+          );
+      }
+      if (await this.startSession(l), r && typeof this.ensureAwake == "function")
+        try {
+          await this.ensureAwake();
+        } catch (h) {
+          console.warn("[reachy-mini] autoConnect: ensureAwake failed:", h);
+        }
+      return { robotId: l, robotName: c, 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 s = await t.json(), o = /* @__PURE__ */ new Map();
+      for (const i of s.robots || []) {
+        if (e && i.busy) continue;
+        const r = i.meta?.install_id ?? i.meta?.hardware_id ?? i.peerId;
+        o.set(r, {
+          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(o.values()).sort(
+        (i, r) => (i.lastSeenAgeSeconds ?? 1 / 0) - (r.lastSeenAgeSeconds ?? 1 / 0)
+      );
+    } catch (t) {
+      return console.warn("[reachy-mini] /api/robot-status unavailable, using SSE list:", t), (this._robots || []).map((s) => ({
+        id: s.id,
+        name: s.meta?.name ?? null,
+        busy: !1,
+        activeApp: null,
+        meta: s.meta ?? {},
+        lastSeenAgeSeconds: null
+      }));
+    }
+  }
+  _waitForRobotInList(e, t) {
+    return this._robots?.find((s) => s.id === e) ? Promise.resolve() : new Promise((s, o) => {
+      const i = () => {
+        this._robots?.find((a) => a.id === e) && (this.removeEventListener("robotsChanged", i), clearTimeout(r), s());
+      }, r = setTimeout(() => {
+        this.removeEventListener("robotsChanged", i), o(new Error(`Timeout waiting for robot ${e} in list`));
+      }, t);
+      this.addEventListener("robotsChanged", i);
+    });
+  }
+  async startSession(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, s = t.AudioContext ?? t.webkitAudioContext;
+      if (!s) throw new Error("AudioContext not supported");
+      const o = new s(), i = o.createMediaStreamDestination(), r = o.createOscillator(), a = o.createGain();
+      a.gain.value = 0, r.connect(a).connect(i), r.start();
+      const l = i.stream;
+      l.getAudioTracks().forEach((c) => {
+        c.enabled = !1;
+      }), this._micStream = l, this._micMuted = !0;
+    } catch (t) {
+      console.warn("Audio sender placeholder setup failed:", t), this._micStream = null;
+    }
+    return this._pc = new RTCPeerConnection({
+      iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+    }), new Promise((t, s) => {
+      this._sessionResolve = t, this._sessionReject = s, this._pc.ontrack = (o) => {
+        if (o.track.kind === "video") {
+          const i = this._videoJitterBufferTargetMs;
+          try {
+            o.receiver.jitterBufferTarget = i;
+          } catch {
+          }
+          try {
+            o.receiver.playoutDelayHint = i / 1e3;
+          } catch {
+          }
+          this._emit("videoTrack", { track: o.track, stream: o.streams[0] });
+        }
+      }, this._pc.onicecandidate = async (o) => {
+        o.candidate && this._sessionId && await this._sendToServer({
+          type: "peer",
+          sessionId: this._sessionId,
+          ice: {
+            candidate: o.candidate.candidate,
+            sdpMLineIndex: o.candidate.sdpMLineIndex,
+            sdpMid: o.candidate.sdpMid
+          }
+        });
+      }, this._pc.oniceconnectionstatechange = () => {
+        const o = this._pc?.iceConnectionState;
+        if (o)
+          if (o === "connected" || o === "completed")
+            this._iceConnected = !0, this._checkSessionReady();
+          else if (o === "failed") {
+            const i = new Error("ICE connection failed");
+            this._sessionReject && (this._sessionReject(i), this._sessionResolve = null, this._sessionReject = null), this._emit("error", { source: "webrtc", error: i });
+          } else o === "disconnected" && this._emit("error", { source: "webrtc", error: new Error("ICE disconnected") });
+      }, this._pc.ondatachannel = (o) => {
+        this._dc = o.channel, this._dc.onopen = () => {
+          this._dcOpen = !0, this._checkSessionReady();
+        }, this._dc.onmessage = (i) => this._handleRobotMessage(JSON.parse(i.data));
+      }, this._sendToServer({ type: "startSession", peerId: e }).then((o) => {
+        if (o?.type === "sessionRejected") {
+          this._failSessionRejected(o);
+          return;
+        }
+        o?.sessionId && (this._sessionId = o.sessionId);
+      });
+    });
+  }
+  _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"}`
+    );
+    if (t.reason = e.reason ?? null, t.activeApp = e.activeApp ?? null, this._pc && (this._pc.close(), this._pc = null), this._micStream && (this._micStream.getTracks().forEach((s) => s.stop()), this._micStream = null), this._iceConnected = !1, this._dcOpen = !1, this._micMuted = !0, this._micSupported = !1, this._emit("sessionRejected", { reason: e.reason, activeApp: e.activeApp }), this._sessionReject) {
+      const s = this._sessionReject;
+      this._sessionResolve = null, this._sessionReject = null, s(t);
+    }
+  }
+  async stopSession() {
+    this._versionResolve && (this._versionResolve(null), this._versionResolve = null), this._hardwareIdResolve && (this._hardwareIdResolve(null), this._hardwareIdResolve = null), this._volumeResolve && (this._volumeResolve(null), this._volumeResolve = null), this._micVolumeResolve && (this._micVolumeResolve(null), this._micVolumeResolve = null), this._applyAudioConfigResolve && (this._applyAudioConfigResolve(!1), this._applyAudioConfigResolve = null), this._readAudioParameterResolve && (this._readAudioParameterResolve(null), this._readAudioParameterResolve = null), this._logSubscribers.clear(), this._rejectPendingMotionCompletions(new Error("Session stopped")), this._sessionReject && (this._sessionReject(new Error("Session stopped")), this._sessionResolve = null, this._sessionReject = null), this._stateRefreshInterval && (clearInterval(this._stateRefreshInterval), this._stateRefreshInterval = null), this._latencyMonitorId && (clearInterval(this._latencyMonitorId), this._latencyMonitorId = null), this._sessionId && await this._sendToServer({ type: "endSession", sessionId: this._sessionId }), this._micStream && (this._micStream.getTracks().forEach((t) => t.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._sessionId = null, this._iceConnected = !1, this._dcOpen = !1, this._state === "streaming" && (this._state = "connected", this._emit("sessionStopped", { reason: "user" }));
+  }
+  disconnect() {
+    this._sseAbortController && (this._sseAbortController.abort(), this._sseAbortController = null), this._versionResolve && (this._versionResolve(null), this._versionResolve = null), this._hardwareIdResolve && (this._hardwareIdResolve(null), this._hardwareIdResolve = null), this._volumeResolve && (this._volumeResolve(null), this._volumeResolve = null), this._micVolumeResolve && (this._micVolumeResolve(null), this._micVolumeResolve = null), this._applyAudioConfigResolve && (this._applyAudioConfigResolve(!1), this._applyAudioConfigResolve = null), this._readAudioParameterResolve && (this._readAudioParameterResolve(null), this._readAudioParameterResolve = null), this._logSubscribers.clear(), this._rejectPendingMotionCompletions(new Error("Disconnected")), this._sessionReject && (this._sessionReject(new Error("Disconnected")), this._sessionResolve = null, this._sessionReject = null), this._stateRefreshInterval && (clearInterval(this._stateRefreshInterval), this._stateRefreshInterval = null), this._latencyMonitorId && (clearInterval(this._latencyMonitorId), this._latencyMonitorId = null), this._sessionId && this._token && this._sendToServer({ type: "endSession", sessionId: this._sessionId }), this._micStream && (this._micStream.getTracks().forEach((e) => e.stop()), this._micStream = null), this._pc && (this._pc.close(), this._pc = null), this._dc && (this._dc.close(), this._dc = null), this._sessionId = null, this._micMuted = !0, this._micSupported = !1, this._iceConnected = !1, this._dcOpen = !1, this._robots = [], this._state = "disconnected", this._emit("disconnected", { reason: "user" });
+  }
+  // ─── 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: s } = {}) {
+    const o = { 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}`
+        );
+      o.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}`
+        );
+      o.antennas = t;
+    }
+    if (s !== void 0) {
+      if (!Number.isFinite(s))
+        throw new TypeError(
+          `setTarget: body_yaw must be a finite number (radians); got ${s}`
+        );
+      o.body_yaw = s;
+    }
+    return this._sendCommand(o);
+  }
+  gotoTarget({ head: e, antennas: t, body_yaw: s, duration: o }) {
+    const i = { type: "goto_target" };
+    if (e !== void 0) {
+      if (!Array.isArray(e) || e.length !== 16 || !e.every((r) => Number.isFinite(r)))
+        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((r) => Number.isFinite(r)))
+        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 (s !== void 0) {
+      if (!Number.isFinite(s))
+        throw new TypeError(
+          `gotoTarget: body_yaw must be a finite number (radians); got ${s}`
+        );
+      i.body_yaw = s;
+    }
+    if (!Number.isFinite(o) || o <= 0)
+      throw new TypeError(
+        `gotoTarget: duration must be a positive finite number (seconds); got ${o}`
+      );
+    return i.duration = o, this._sendCommand(i);
+  }
+  setHeadRpyDeg(e, t, s) {
+    return this.setTarget({ head: F(e, t, s).flat() });
+  }
+  setAntennasDeg(e, t) {
+    return this.setTarget({ antennas: [R(e), R(t)] });
+  }
+  setBodyYawDeg(e) {
+    return this.setTarget({ body_yaw: R(e) });
+  }
+  playSound(e) {
+    return this._sendCommand({ type: "play_sound", file: 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 }) ? new Promise((s, o) => {
+      const i = {
+        resolve: s,
+        reject: o,
+        timer: setTimeout(() => {
+          const r = this._pendingMotionCompletions[e], a = r.indexOf(i);
+          a !== -1 && r.splice(a, 1), o(new Error(`${e} timed out after ${t}ms`));
+        }, t)
+      };
+      this._pendingMotionCompletions[e].push(i);
+    }) : Promise.reject(new Error(`${e}: data channel not open`));
+  }
+  _rejectPendingMotionCompletions(e) {
+    for (const t of Object.keys(this._pendingMotionCompletions)) {
+      const s = this._pendingMotionCompletions[t];
+      for (; s.length; ) {
+        const o = s.shift();
+        clearTimeout(o.timer), o.reject(e);
+      }
+    }
+  }
+  isAwake() {
+    const e = this._robotState?.motor_mode;
+    return e === "enabled" || e === "gravity_compensation";
+  }
+  async ensureAwake(e = 1e3) {
+    return this._robotState?.motor_mode === void 0 && await new Promise((t) => {
+      const s = () => {
+        this.removeEventListener("state", s), clearTimeout(o), t();
+      }, o = setTimeout(s, e);
+      this.addEventListener("state", s), this.requestState();
+    }), this.isAwake() || this.wakeUp().catch(() => {
+    }), !0;
+  }
+  getVersion() {
+    return new Promise((e, t) => {
+      if (!this._dc || this._dc.readyState !== "open") {
+        t(new Error("Data channel not open"));
+        return;
+      }
+      this._versionResolve && this._versionResolve(null), this._versionResolve = e, this._sendCommand({ type: "get_version" });
+    });
+  }
+  getHardwareId() {
+    return new Promise((e, t) => {
+      if (!this._dc || this._dc.readyState !== "open") {
+        t(new Error("Data channel not open"));
+        return;
+      }
+      this._hardwareIdResolve && this._hardwareIdResolve(null), this._hardwareIdResolve = e, this._sendCommand({ type: "get_hardware_id" });
+    });
+  }
+  getVolume() {
+    return this._slotRoundtrip(
+      () => this._volumeResolve,
+      (e) => {
+        this._volumeResolve = e;
+      },
+      { type: "get_volume" }
+    );
+  }
+  setVolume(e) {
+    return this._slotRoundtrip(
+      () => this._volumeResolve,
+      (t) => {
+        this._volumeResolve = t;
+      },
+      { type: "set_volume", volume: j(e) }
+    );
+  }
+  getMicrophoneVolume() {
+    return this._slotRoundtrip(
+      () => this._micVolumeResolve,
+      (e) => {
+        this._micVolumeResolve = e;
+      },
+      { type: "get_microphone_volume" }
+    );
+  }
+  setMicrophoneVolume(e) {
+    return this._slotRoundtrip(
+      () => this._micVolumeResolve,
+      (t) => {
+        this._micVolumeResolve = t;
+      },
+      { type: "set_microphone_volume", volume: j(e) }
+    );
+  }
+  applyAudioConfig(e, { verify: t = !0 } = {}) {
+    return this._slotRoundtrip(
+      () => this._applyAudioConfigResolve,
+      (s) => {
+        this._applyAudioConfigResolve = s;
+      },
+      { type: "apply_audio_config", config: e, verify: t }
+    ).then((s) => s === !0);
+  }
+  readAudioParameter(e) {
+    return this._slotRoundtrip(
+      () => this._readAudioParameterResolve,
+      (t) => {
+        this._readAudioParameterResolve = t;
+      },
+      { type: "read_audio_parameter", name: e }
+    );
+  }
+  /**
+   * Internal: send a command and await the matching daemon response in a
+   * named single-resolver slot. Used by the volume helpers and the
+   * XVF3800 audio-config helpers — every one of them has a strict
+   * request/response shape where a single in-flight call per slot is
+   * sufficient. 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.
+   *
+   * Slot access is passed in as getter/setter closures rather than a
+   * key into `this`: that keeps the helper fully generic-checked (T is
+   * inferred from the slot's resolver type at each call site) with no
+   * indexed-property casts.
+   */
+  _slotRoundtrip(e, t, s) {
+    return new Promise((o, i) => {
+      if (!this._dc || this._dc.readyState !== "open") {
+        i(new Error("Data channel not open"));
+        return;
+      }
+      const r = e();
+      r && r(null), t(o), this._sendCommand(s);
+    });
+  }
+  sendRaw(e) {
+    return this._sendCommand(e);
+  }
+  subscribeLogs({ onLine: e, onError: t }) {
+    if (typeof e != "function")
+      throw new TypeError("subscribeLogs: onLine callback is required");
+    const s = { onLine: e, onError: t }, o = this._logSubscribers.size === 0;
+    this._logSubscribers.add(s), o && this._sendCommand({ type: "subscribe_logs" });
+    let i = !1;
+    return () => {
+      i || (i = !0, this._logSubscribers.delete(s), this._logSubscribers.size === 0 && this._sendCommand({ type: "unsubscribe_logs" }));
+    };
+  }
+  requestState() {
+    return this._sendCommand({ type: "get_state" });
+  }
+  // ─── 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 = (o) => {
+      const i = o;
+      e.srcObject = i.detail.stream, e.playsInline = !0, "requestVideoFrameCallback" in e && this._startLatencyMonitor(e);
+    }, s = () => {
+      e.srcObject = null;
+    };
+    return this.addEventListener("videoTrack", t), this.addEventListener("sessionStopped", s), () => {
+      this.removeEventListener("videoTrack", t), this.removeEventListener("sessionStopped", s), 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: s = -100,
+    description: o = "move",
+    encoding: i = "gzip+base64",
+    playFrequency: r = 100,
+    initialGotoDuration: a = 0,
+    startTimeoutMs: l = 8e3,
+    onProgress: c = () => {
+    },
+    onStarted: h = () => {
+    }
+  } = {}) {
+    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 d = U();
+    this._activeMoveUploadId = d;
+    const m = {
+      description: o,
+      time: e.time,
+      set_target_data: e.set_target_data
+    }, f = JSON.stringify(m);
+    let p, v;
+    i === "gzip+base64" && W() ? (p = await z(f), v = "gzip+base64") : (p = f, v = "json");
+    const w = Math.ceil(p.length / y) || 1;
+    c({
+      phase: "starting",
+      sent: 0,
+      total: w,
+      bytes: p.length,
+      encoding: v
+    }), this._sendCommand({
+      type: "upload_move_start",
+      upload_id: d,
+      total_chunks: w,
+      description: o,
+      encoding: v
+    });
+    for (let u = 0; u < w; u++) {
+      this._dc.bufferedAmount > k && await this._awaitDataChannelDrain();
+      const _ = u * y;
+      this._sendCommand({
+        type: "upload_move_chunk",
+        upload_id: d,
+        chunk_index: u,
+        chunk: p.slice(_, _ + y)
+      }), c({ phase: "upload", sent: u + 1, total: w });
+    }
+    if (this._sendCommand({ type: "upload_move_finish", upload_id: d }), c({ phase: "uploaded", sent: w, total: w }), t) {
+      const u = new Uint8Array(await t.arrayBuffer()), _ = E(u), b = Math.ceil(_.length / y) || 1;
+      c({
+        phase: "audio-starting",
+        sent: 0,
+        total: b,
+        bytes: _.length
+      }), this._sendCommand({
+        type: "upload_audio_start",
+        upload_id: d,
+        total_chunks: b,
+        encoding: "wav-base64",
+        description: o
+      });
+      for (let I = 0; I < b; I++) {
+        this._dc.bufferedAmount > k && await this._awaitDataChannelDrain();
+        const T = I * y;
+        this._sendCommand({
+          type: "upload_audio_chunk",
+          upload_id: d,
+          chunk_index: I,
+          chunk: _.slice(T, T + y)
+        }), c({ phase: "audio-upload", sent: I + 1, total: b });
+      }
+      this._sendCommand({ type: "upload_audio_finish", upload_id: d }), c({ phase: "audio-uploaded", sent: b, total: b });
+    }
+    this._sendCommand({
+      type: "play_uploaded_move",
+      upload_id: d,
+      play_frequency: r,
+      initial_goto_duration: a,
+      audio_lead_ms: s
+    });
+    let g;
+    try {
+      g = await this._waitForBroadcast(
+        (u) => u?.type === "play_uploaded_move" && u?.upload_id === d && (u.started === !0 || typeof u.error == "string"),
+        { timeoutMs: l, debugLabel: "play_uploaded_move started" }
+      );
+    } catch (u) {
+      throw new Error(
+        `Daemon did not respond to play_uploaded_move (requires the reachy_mini daemon with feature/daemon-side-move-upload). Underlying: ${u.message}`
+      );
+    }
+    if (typeof g.error == "string")
+      throw new Error(`play_uploaded_move: ${g.error}`);
+    try {
+      h({
+        duration_s: g.duration_s,
+        has_audio: g.has_audio === !0
+      });
+    } catch (u) {
+      console.warn("playMove.onStarted threw:", u);
+    }
+    c({ phase: "playing", duration_s: g.duration_s });
+    const S = await this._waitForBroadcast(
+      (u) => u?.type === "play_uploaded_move" && u?.upload_id === d && (u.finished === !0 || u.cancelled === !0 || typeof u.error == "string"),
+      {
+        timeoutMs: (g.duration_s + 30) * 1e3,
+        debugLabel: "play_uploaded_move final"
+      }
+    );
+    return this._activeMoveUploadId === d && (this._activeMoveUploadId = null), S;
+  }
+  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: s = () => {
+  } } = {}) {
+    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 o = U(), i = new Uint8Array(await e.arrayBuffer()), r = E(i), a = Math.ceil(r.length / y) || 1;
+    s({ phase: "audio-starting", sent: 0, total: a, bytes: r.length }), this._sendCommand({
+      type: "upload_audio_start",
+      upload_id: o,
+      total_chunks: a,
+      encoding: "wav-base64",
+      description: t
+    });
+    for (let l = 0; l < a; l++) {
+      this._dc.bufferedAmount > k && await this._awaitDataChannelDrain();
+      const c = l * y;
+      this._sendCommand({
+        type: "upload_audio_chunk",
+        upload_id: o,
+        chunk_index: l,
+        chunk: r.slice(c, c + y)
+      }), s({ phase: "audio-upload", sent: l + 1, total: a });
+    }
+    return this._sendCommand({ type: "upload_audio_finish", upload_id: o }), s({ phase: "audio-uploaded", sent: a, total: a }), o;
+  }
+  async playUploadedAudio(e, { timeoutMs: t = 8e3 } = {}) {
+    if (!this._dc || this._dc.readyState !== "open")
+      throw new Error("data channel not open");
+    const s = 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 o = await s;
+    if (typeof o.error == "string") throw new Error(o.error);
+    return this._activeAudioUploadId = e, o;
+  }
+  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, { timeoutMs: t = 5e3, debugLabel: s = "" } = {}) {
+    return new Promise((o, i) => {
+      const r = {
+        predicate: e,
+        resolve: o,
+        timer: setTimeout(() => {
+          const a = this._broadcastWaiters.indexOf(r);
+          a !== -1 && this._broadcastWaiters.splice(a, 1), i(new Error(`broadcast timeout (${t} ms): ${s}`));
+        }, t)
+      };
+      this._broadcastWaiters.push(r);
+    });
+  }
+  async _awaitDataChannelDrain() {
+    for (; this._dc && this._dc.bufferedAmount > H; )
+      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 s = "";
+        try {
+          s = await t.text();
+        } catch {
+        }
+        return console.warn(
+          `[reachy-mini] /send rejected (${t.status}) for type=${e?.type}; body=${s || "<empty>"}`
+        ), null;
+      }
+      return await t.json();
+    } catch (t) {
+      return console.error("Send error:", t), null;
+    }
+  }
+  _sendCommand(e) {
+    return !this._dc || this._dc.readyState !== "open" ? !1 : (this._dc.send(JSON.stringify(e)), !0);
+  }
+  _checkSessionReady() {
+    this._iceConnected && this._dcOpen && this._sessionResolve && (this._state = "streaming", this.requestState(), this._stateRefreshInterval = setInterval(() => this.requestState(), 500), 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, s = 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 o = new Error(
+        s || `Session ended before it could start: ${t || "unknown reason"}`
+      );
+      o.reason = t ?? null, this._emit("sessionRejected", { reason: t, activeApp: null }), this._pc && (this._pc.close(), this._pc = null), this._micStream && (this._micStream.getTracks().forEach((r) => r.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(o);
+      return;
+    }
+    this._state === "streaming" && (this._emit("sessionStopped", {
+      reason: t || "remote_end",
+      message: s
+    }), this.stopSession().catch(() => {
+    }));
+  }
+  async _handlePeerMessage(e) {
+    if (this._pc)
+      try {
+        if (e.sdp) {
+          const t = e.sdp;
+          if (t.type === "offer") {
+            const o = q(t.sdp);
+            if (this._micSupported = o, this._emit("micSupported", { supported: o }), o && this._micStream)
+              for (const r of this._micStream.getAudioTracks())
+                this._pc.addTrack(r, 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 s = this._pendingRemoteIce;
+          if (s && s.length) {
+            this._pendingRemoteIce = [];
+            for (const o of s)
+              try {
+                await this._pc.addIceCandidate(new RTCIceCandidate(o));
+              } catch (i) {
+                console.warn("[reachy-mini] 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) {
+        console.error("WebRTC error:", t), this._emit("error", { source: "webrtc", error: t });
+      }
+  }
+  _handleRobotMessage(e) {
+    if ("version" in e && this._versionResolve) {
+      this._versionResolve(e.version), this._versionResolve = null;
+      return;
+    }
+    if ("hardware_id" in e && this._hardwareIdResolve) {
+      this._hardwareIdResolve(e.hardware_id), this._hardwareIdResolve = null;
+      return;
+    }
+    if (e.command === "get_volume" || e.command === "set_volume") {
+      this._volumeResolve && (this._volumeResolve(e.status === "error" ? null : e.volume), this._volumeResolve = null);
+      return;
+    }
+    if (e.command === "get_microphone_volume" || e.command === "set_microphone_volume") {
+      this._micVolumeResolve && (this._micVolumeResolve(e.status === "error" ? null : e.volume), this._micVolumeResolve = null);
+      return;
+    }
+    if (e.command === "apply_audio_config") {
+      this._applyAudioConfigResolve && (this._applyAudioConfigResolve(e.error ? !1 : !!e.applied), this._applyAudioConfigResolve = null);
+      return;
+    }
+    if (e.command === "read_audio_parameter") {
+      this._readAudioParameterResolve && (this._readAudioParameterResolve(
+        e.error ? null : e.values ?? null
+      ), this._readAudioParameterResolve = null);
+      return;
+    }
+    if ((e.command === "wake_up" || e.command === "goto_sleep") && this._pendingMotionCompletions && this._pendingMotionCompletions[e.command]) {
+      const t = this._pendingMotionCompletions[e.command];
+      if (e.completed === !0 && t.length > 0) {
+        const s = t.shift();
+        clearTimeout(s.timer), s.resolve();
+        return;
+      }
+      if (e.error && t.length > 0) {
+        const s = t.shift();
+        clearTimeout(s.timer), s.reject(new Error(`${e.command}: ${e.error}`));
+        return;
+      }
+    }
+    if (e.type === "log_line") {
+      for (const t of this._logSubscribers)
+        try {
+          t.onLine({ timestamp: e.timestamp, line: e.line });
+        } catch (s) {
+          console.error("subscribeLogs onLine threw:", s);
+        }
+      return;
+    }
+    if (e.type === "log_stream_error") {
+      for (const t of this._logSubscribers)
+        if (typeof t.onError == "function")
+          try {
+            t.onError(e.error);
+          } catch (s) {
+            console.error("subscribeLogs onError threw:", s);
+          }
+      return;
+    }
+    if (e.state) {
+      const t = e.state;
+      t.head_pose && (this._robotState.head = t.head_pose.flat()), t.antennas && (this._robotState.antennas = [t.antennas[0], t.antennas[1]]), typeof t.body_yaw == "number" && (this._robotState.body_yaw = t.body_yaw), t.motor_mode && (this._robotState.motor_mode = t.motor_mode), typeof t.is_move_running == "boolean" && (this._robotState.is_move_running = t.is_move_running), this._emit("state", { ...this._robotState });
+    }
+    if (e.error && this._emit("error", { source: "robot", error: e.error }), this._broadcastWaiters.length > 0)
+      for (let t = this._broadcastWaiters.length - 1; t >= 0; t--) {
+        const s = this._broadcastWaiters[t];
+        if (s.predicate(e)) {
+          this._broadcastWaiters.splice(t, 1), clearTimeout(s.timer), s.resolve(e);
+          return;
+        }
+      }
+  }
+  /** 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 s = t.end(t.length - 1), o = s - e.currentTime;
+        o > 0.5 && (console.log(`Latency correction: was ${o.toFixed(2)}s behind`), e.currentTime = s - 0.1);
+      }
+    }, 2e3);
+  }
+}
+export {
+  J as R
+};