@pollen-robotics/reachy-mini-sdk 1.7.3-main.5cd69ad

package/host/dist/chunks/reachy-mini-sdk-eBYlC77N.js

@@ -0,0 +1,1719 @@
+var D = Object.defineProperty, $ = (r, e, t) => e in r ? D(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, k = (r, e, t) => ($(r, typeof e != "symbol" ? e + "" : e, t), t), L = "https://huggingface.co";
+async function C(r, e) {
+  var t, s;
+  const i = new P(r.url, r.status, (t = r.headers.get("X-Request-Id")) != null ? t : void 0);
+  i.message = `Api error with status ${i.statusCode}`;
+  const o = [`URL: ${i.url}`, i.requestId ? `Request ID: ${i.requestId}` : void 0].filter(Boolean).join(". ");
+  if ((s = r.headers.get("Content-Type")) != null && s.startsWith("application/json")) {
+    const n = await r.json();
+    i.message = n.error || n.message || i.message, i.data = n;
+  } else
+    i.data = { message: await r.text() };
+  throw i.message += `. ${o}`, i;
+}
+var P = class extends Error {
+  constructor(r, e, t, s) {
+    super(s), k(this, "statusCode"), k(this, "url"), k(this, "requestId"), k(this, "data"), this.statusCode = e, this.requestId = t, this.url = r;
+  }
+};
+new Promise((r) => {
+});
+function x(r) {
+  if (globalThis.Buffer)
+    return globalThis.Buffer.from(r).toString("base64");
+  {
+    const e = [];
+    return r.forEach((t) => {
+      e.push(String.fromCharCode(t));
+    }), globalThis.btoa(e.join(""));
+  }
+}
+async function M(r) {
+  var e, t;
+  if (typeof window > "u")
+    throw new Error("oauthHandleRedirect is only available in the browser");
+  const s = new URLSearchParams(window.location.search), [i, o] = [s.get("error"), s.get("error_description")];
+  if (i)
+    throw new Error(`${i}: ${o}`);
+  const n = s.get("code"), c = localStorage.getItem("huggingface.co:oauth:nonce");
+  if (!n)
+    throw new Error("Missing oauth code from query parameters in redirected URL");
+  if (!c)
+    throw new Error("Missing oauth nonce from localStorage");
+  const a = localStorage.getItem("huggingface.co:oauth:code_verifier");
+  if (!a)
+    throw new Error("Missing oauth code_verifier from localStorage");
+  const u = s.get("state");
+  if (!u)
+    throw new Error("Missing oauth state from query parameters in redirected URL");
+  let d;
+  try {
+    d = JSON.parse(u);
+  } catch {
+    throw new Error("Invalid oauth state in redirected URL, unable to parse JSON: " + u);
+  }
+  if (d.nonce !== c)
+    throw new Error("Invalid oauth state in redirected URL");
+  const l = L, p = `${new URL(l).origin}/.well-known/openid-configuration`, f = await fetch(p, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!f.ok)
+    throw await C(f);
+  const m = await f.json(), b = await fetch(m.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code: n,
+      redirect_uri: d.redirectUri,
+      code_verifier: a
+    }).toString()
+  });
+  if (localStorage.removeItem("huggingface.co:oauth:code_verifier"), localStorage.removeItem("huggingface.co:oauth:nonce"), !b.ok)
+    throw await C(b);
+  const w = await b.json(), g = new Date(Date.now() + w.expires_in * 1e3), R = await fetch(m.userinfo_endpoint, {
+    headers: {
+      Authorization: `Bearer ${w.access_token}`
+    }
+  });
+  if (!R.ok)
+    throw await C(R);
+  const h = await R.json();
+  return {
+    accessToken: w.access_token,
+    accessTokenExpiresAt: g,
+    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((_) => ({
+        id: _.sub,
+        name: _.name,
+        fullname: _.name,
+        isEnterprise: _.isEnterprise,
+        canPay: _.canPay,
+        avatarUrl: _.picture,
+        roleInOrg: _.roleInOrg
+      }))) != null ? t : []
+    },
+    state: d.state,
+    scope: w.scope
+  };
+}
+async function O(r) {
+  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(r) {
+  var e, t;
+  if (typeof window > "u")
+    throw new Error("oauthLogin is only available in the browser");
+  const s = r?.hubUrl || L, i = `${new URL(s).origin}/.well-known/openid-configuration`, o = await fetch(i, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!o.ok)
+    throw await C(o);
+  const n = await o.json(), c = globalThis.crypto.randomUUID(), a = globalThis.crypto.randomUUID() + globalThis.crypto.randomUUID();
+  localStorage.setItem("huggingface.co:oauth:nonce", c), localStorage.setItem("huggingface.co:oauth:code_verifier", a);
+  const u = r?.redirectUrl || window.location.href, d = JSON.stringify({
+    nonce: c,
+    redirectUri: u,
+    state: r?.state
+  }), l = (t = (e = window?.huggingface) == null ? void 0 : e.variables) != null ? t : null, p = r?.clientId || l?.OAUTH_CLIENT_ID;
+  if (!p)
+    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 f = x(
+    new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(a)))
+  ).replace(/[+]/g, "-").replace(/[/]/g, "_").replace(/=/g, "");
+  return `${n.authorization_endpoint}?${new URLSearchParams({
+    client_id: p,
+    scope: r?.scopes || l?.OAUTH_SCOPES || "openid profile",
+    response_type: "code",
+    redirect_uri: u,
+    state: d,
+    code_challenge: f,
+    code_challenge_method: "S256"
+  }).toString()}`;
+}
+function S(r) {
+  return r * Math.PI / 180;
+}
+function F(r, e, t) {
+  const s = S(r), i = S(e), o = S(t), n = Math.cos(o), c = Math.sin(o), a = Math.cos(i), u = Math.sin(i), d = Math.cos(s), l = Math.sin(s);
+  return [
+    [n * a, n * u * l - c * d, n * u * d + c * l, 0],
+    [c * a, c * u * l + n * d, c * u * d - n * l, 0],
+    [-u, a * l, a * d, 0],
+    [0, 0, 0, 1]
+  ];
+}
+function U(r) {
+  const e = Math.round(Number(r) || 0);
+  return Math.max(0, Math.min(100, e));
+}
+function B() {
+  if (typeof window > "u" || !window.location.hash) return;
+  const r = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+  let e;
+  try {
+    e = new URLSearchParams(r);
+  } catch {
+    return;
+  }
+  const t = e.get("hf_token");
+  if (!t) return;
+  const s = e.get("hf_username") || "user", i = e.get("hf_token_expires"), o = i && !Number.isNaN(new Date(i).getTime()) ? i : 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", o);
+  } catch (a) {
+    console.warn("[reachy-mini] could not persist pre-seeded HF credentials:", a);
+  }
+  e.delete("hf_token"), e.delete("hf_username"), e.delete("hf_token_expires");
+  const n = e.toString(), c = window.location.pathname + window.location.search + (n ? "#" + n : "");
+  try {
+    window.history.replaceState(null, "", c);
+  } catch {
+  }
+}
+function V() {
+  if (typeof window > "u") return null;
+  if (window.location.hash) {
+    const r = window.location.hash.startsWith("#") ? window.location.hash.slice(1) : window.location.hash;
+    try {
+      const t = new URLSearchParams(r).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(r) {
+  const e = r.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, E = 1 * 1024 * 1024, H = 512 * 1024;
+function W() {
+  return typeof CompressionStream < "u";
+}
+function j() {
+  return "u" + Math.random().toString(36).slice(2, 11) + Date.now().toString(36);
+}
+function A(r) {
+  let e = "";
+  for (let s = 0; s < r.length; s += 32768)
+    e += String.fromCharCode.apply(null, r.subarray(s, s + 32768));
+  return btoa(e);
+}
+async function z(r) {
+  const e = new TextEncoder().encode(r), t = await new Response(
+    new Blob([e]).stream().pipeThrough(new CompressionStream("gzip"))
+  ).arrayBuffer();
+  return A(new Uint8Array(t));
+}
+class J extends EventTarget {
+  /** @param {{ signalingUrl?: string, enableMicrophone?: boolean, clientId?: string, appName?: string, videoJitterBufferTargetMs?: number, autoStartFromUrl?: boolean }} [options] */
+  constructor(e = {}) {
+    super(), this._signalingUrl = e.signalingUrl || "https://pollen-robotics-reachy-mini-central.hf.space", this._enableMicrophone = e.enableMicrophone !== !1, this._clientId = e.clientId || null, this._appName = e.appName || "unknown", this._videoJitterBufferTargetMs = e.videoJitterBufferTargetMs ?? 0, this._autoStartFromUrl = e.autoStartFromUrl === !0, this._autoStartAttempted = !1, this._state = "disconnected", this._robots = [], this._robotState = {}, this._preselectedRobotId = V(), this._token = null, this._username = null, this._tokenExpires = null, this._peerId = null, this._sseAbortController = null, this._pc = null, this._dc = null, this._sessionId = null, this._selectedRobotId = null, this._micStream = null, this._micMuted = !0, this._audioMuted = !0, this._micSupported = !1, this._latencyMonitorId = null, this._stateRefreshInterval = null, this._versionResolve = null, this._hardwareIdResolve = null, this._volumeResolve = null, this._micVolumeResolve = null, this._logSubscribers = /* @__PURE__ */ new Set(), this._broadcastWaiters = [], this._activeMoveUploadId = null, this._activeAudioUploadId = null, this._sessionResolve = null, this._sessionReject = null, this._iceConnected = !1, this._dcOpen = !1, this._pendingMotionCompletions = {
+      wake_up: [],
+      goto_sleep: []
+    }, this._videoElement = null;
+  }
+  // ─── Read-only properties ────────────────────────────────────────────
+  /** @returns {"disconnected"|"connected"|"streaming"} */
+  get state() {
+    return this._state;
+  }
+  /** @returns {Array<{id: string, meta: {name: string}}>} */
+  get robots() {
+    return this._robots;
+  }
+  /**
+   * Latest robot state (same shape as the "state" event detail).
+   * Mirrors the daemon's wire format — fields appear only once the
+   * daemon has sent the corresponding source field. Use the exported
+   * math utilities (``matrixToRpy``, ``radToDeg``) for human units.
+   * @returns {{
+   *   head?: number[],
+   *   antennas?: number[],
+   *   body_yaw?: number,
+   *   motor_mode?: "enabled"|"disabled"|"gravity_compensation",
+   *   is_move_running?: boolean,
+   * }}
+   */
+  get robotState() {
+    return this._robotState;
+  }
+  /** @returns {string|null} HuggingFace username, set after authenticate(). */
+  get username() {
+    return this._username;
+  }
+  /** @returns {boolean} True if a valid HF token is available. */
+  get isAuthenticated() {
+    return !!this._token;
+  }
+  /** @returns {boolean} True if the robot's SDP offered bidirectional audio. */
+  get micSupported() {
+    return this._micSupported;
+  }
+  /** @returns {boolean} */
+  get micMuted() {
+    return this._micMuted;
+  }
+  /** @returns {boolean} */
+  get audioMuted() {
+    return this._audioMuted;
+  }
+  /**
+   * Peer id of the robot the embedding host wants this session to
+   * target, captured from the URL at construction time. Apps that
+   * want to support iframe-embedding without forcing the user to
+   * re-pick a robot read this and pass it straight to
+   * `startSession()` once `connect()` resolves:
+   *
+   *     await robot.connect();
+   *     await robot.startSession(robot.preselectedRobotId ?? pickedId);
+   *
+   * Returns `null` when the URL carries no `robot_peer_id` (typical
+   * standalone Space load). The value is also exposed on the
+   * "robotsChanged" payload via the `meta` sidecar for
+   * convenience, but the most direct read is right here.
+   *
+   * @returns {string|null}
+   */
+  get preselectedRobotId() {
+    return this._preselectedRobotId;
+  }
+  /**
+   * Convenience flag for apps that want to branch their UX on
+   * "am I embedded in a host shell?". True iff the URL carried a
+   * `robot_peer_id` hint at construction time (which only happens
+   * when a host iframe — mobile shell, vibe-coder preview, etc. —
+   * is the parent). Apps typically use it to skip their robot
+   * picker and their sign-in screen, since both are duplicated
+   * work the host has already done.
+   *
+   * @returns {boolean}
+   */
+  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.
+   * No-op unless `autoStartFromUrl` is set, the URL carries a
+   * preselect, the SDK is `connected`, the preselected robot is
+   * in the latest list, and we haven't already attempted in this
+   * page load. Errors are swallowed to a `console.warn` — the
+   * normal `startSession` rejection / `sessionRejected` event
+   * still fires for app-level handling.
+   *
+   * Defers the actual `startSession()` call by one macrotask
+   * (`setTimeout(..., 0)`) so it runs OUTSIDE the
+   * `_handleSignalingMessage` callstack that just processed the
+   * `'list'` message. Reproduced on Android WebView: firing
+   * `startSession` synchronously inside the SSE handler races the
+   * daemon's setup, leading to a connected-but-no-keyframe state
+   * where the receiver eternally NACKs and the iframe shows a
+   * black <video>. The macrotask-deferral is the minimum nudge
+   * that consistently resolves the race in our reproduction; if
+   * it ever proves insufficient on slower hardware, bump to
+   * a small explicit delay (e.g. 250 ms).
+   */
+  _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 ────────────────────────────────────────────────────────────
+  /**
+   * Check for a valid HuggingFace token.
+   *
+   * Resolution order:
+   *   1. URL fragment hand-off (`#hf_token=…&hf_username=…&hf_token_expires=…`).
+   *      A host iframe — typically the Reachy Mini mobile app or a
+   *      vibe-coder preview — can pass credentials through the URL
+   *      fragment to bypass HF's `X-Frame-Options: SAMEORIGIN` block
+   *      on `huggingface.co/login`. Seeded into `sessionStorage` and
+   *      then stripped from the address bar so a page reload does not
+   *      keep the credentials visible.
+   *   2. OAuth redirect callback (standalone Space, first sign-in).
+   *   3. `sessionStorage` cache (subsequent loads in any context).
+   *
+   * @returns {Promise<boolean>} true → token ready, false → call login()
+   */
+  async authenticate() {
+    try {
+      B();
+      const e = await O();
+      if (e)
+        return this._username = e.userInfo.preferred_username || e.userInfo.name, 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", this._tokenExpires), !0;
+      const t = sessionStorage.getItem("hf_token"), s = sessionStorage.getItem("hf_username"), i = sessionStorage.getItem("hf_token_expires");
+      return t && s && i && new Date(i) > /* @__PURE__ */ new Date() ? (this._token = t, this._username = s, this._tokenExpires = i, !0) : !1;
+    } catch (e) {
+      return console.error("Auth error:", e), !1;
+    }
+  }
+  /** Redirect the browser to the HuggingFace OAuth login page. */
+  async login() {
+    const e = {};
+    this._clientId && (e.clientId = this._clientId), window.location.href = await N(e);
+  }
+  /** Clear stored HF credentials and disconnect everything. */
+  logout() {
+    sessionStorage.removeItem("hf_token"), sessionStorage.removeItem("hf_username"), sessionStorage.removeItem("hf_token_expires"), this._username = null, this._tokenExpires = null, this.disconnect();
+  }
+  // ─── Lifecycle ───────────────────────────────────────────────────────
+  /**
+   * Open SSE signaling connection.  Resolves once the server sends `welcome`.
+   * Emits "robotsChanged" as robots come and go.
+   * @param {string} [token] — HF access token.  Omit to use the one from authenticate().
+   * @returns {Promise<void>}
+   */
+  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, i) => {
+      let o = !1;
+      const n = t.body.getReader(), c = new TextDecoder();
+      let a = "";
+      (async () => {
+        try {
+          for (; ; ) {
+            const { done: d, value: l } = await n.read();
+            if (d) break;
+            a += c.decode(l, { stream: !0 });
+            const p = a.split(`
+`);
+            a = p.pop();
+            for (const f of p)
+              if (f.startsWith("data:"))
+                try {
+                  const m = JSON.parse(f.slice(5).trim());
+                  !o && m.type === "welcome" && (o = !0, this._peerId = m.peerId, this._state = "connected", await this._sendToServer({
+                    type: "setPeerStatus",
+                    roles: ["listener"],
+                    meta: { name: this._appName }
+                  }), this._emit("connected", { peerId: m.peerId }), s()), this._handleSignalingMessage(m);
+                } catch {
+                }
+          }
+        } catch (d) {
+          if (d.name !== "AbortError" && this._emit("error", { source: "signaling", error: d }), !o) {
+            i(d);
+            return;
+          }
+        }
+        this._state !== "disconnected" && (this._state = "disconnected", this._emit("disconnected", { reason: "SSE closed" })), o || i(new Error("Connection closed before welcome"));
+      })();
+    });
+  }
+  /**
+   * One-shot bring-up: auth → SSE connect → robot selection → session →
+   * wake up. The all-in-one entry point that captures the common
+   * "embed *or* standalone, just get me streaming" flow so each
+   * consumer does not have to re-implement it.
+   *
+   * What it does, in order:
+   *   1. **Auth.** If `this._token` is not set, calls `authenticate()`
+   *      (which honours the iframe URL-fragment hand-off, the OAuth
+   *      redirect callback, and the `sessionStorage` cache). Throws if
+   *      none yield a token — the consumer should call `login()` and
+   *      retry after the redirect. Pass an explicit `token` to skip
+   *      `authenticate()` entirely.
+   *   2. **Connect.** If `state === 'disconnected'`, opens the SSE
+   *      signaling channel.
+   *   3. **Pick a robot.**
+   *      - **Embed mode** (`this.isEmbedded`): uses
+   *        `this._preselectedRobotId` from the URL. No picker callback
+   *        invoked; we briefly wait for that robot to appear in the
+   *        SSE list, then proceed.
+   *      - **Standalone**: GETs `/api/robot-status` for the owner's
+   *        robots with busy state, dedupes by `install_id`, sorts by
+   *        freshness. If `autoPickIfSingle` and exactly one free, picks
+   *        it. Else calls the consumer-supplied `pickRobot(robots)`
+   *        callback. Throws if neither yields an id.
+   *   4. **Start session.** Awaits `startSession(robotId)` (ICE + DC).
+   *   5. **Wake up.** Awaits `ensureAwake()` so sliders don't silently
+   *      no-op against a torque-off robot.
+   *
+   * @param {{
+   *   token?: string,                           // skip authenticate(); use this raw HF token
+   *   pickRobot?: (robots: Array<{
+   *     id: string,
+   *     name: string|null,
+   *     busy: boolean,
+   *     activeApp: string|null,
+   *     meta: object,
+   *     lastSeenAgeSeconds: number|null,
+   *   }>) => Promise<string|null>,              // called only in standalone, multi-robot case
+   *   autoPickIfSingle?: boolean,               // default true — skip the callback when 1 free robot
+   *   filterBusy?: boolean,                     // default true — hide busy robots from the picker
+   *   wakeOnConnect?: boolean,                  // default true — call ensureAwake() after startSession
+   * }} [options]
+   * @returns {Promise<{
+   *   robotId: string,
+   *   robotName: string|null,
+   *   isEmbedded: boolean,
+   *   alreadyStreaming?: boolean,
+   * }>}
+   */
+  async autoConnect(e = {}) {
+    const {
+      token: t = null,
+      pickRobot: s = null,
+      autoPickIfSingle: i = !0,
+      filterBusy: o = !0,
+      wakeOnConnect: n = !0
+    } = e;
+    if (this._state === "streaming") {
+      const a = this._robots?.find((u) => u.id === this._selectedRobotId);
+      return {
+        robotId: this._selectedRobotId,
+        robotName: a?.meta?.name ?? null,
+        isEmbedded: this.isEmbedded,
+        alreadyStreaming: !0
+      };
+    }
+    const c = 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 a, u = null;
+      if (this.isEmbedded) {
+        a = this._preselectedRobotId;
+        try {
+          await this._waitForRobotInList(a, 5e3);
+        } catch {
+        }
+        u = this._robots?.find((l) => l.id === a)?.meta?.name ?? null;
+      } else {
+        const d = await this._fetchOwnedRobots({ filterBusy: o });
+        if (d.length === 0)
+          throw new Error("No reachable robots");
+        if (i && d.length === 1 && !d[0].busy)
+          a = d[0].id, u = d[0].name;
+        else if (s) {
+          const l = await s(d);
+          if (!l) throw new Error("Robot selection cancelled");
+          a = l, u = d.find((p) => p.id === l)?.name ?? null;
+        } else
+          throw new Error(
+            "Multiple robots available — pass a pickRobot callback to autoConnect()"
+          );
+      }
+      if (await this.startSession(a), n && typeof this.ensureAwake == "function")
+        try {
+          await this.ensureAwake();
+        } catch (d) {
+          console.warn("[reachy-mini] autoConnect: ensureAwake failed:", d);
+        }
+      return { robotId: a, robotName: u, isEmbedded: this.isEmbedded };
+    } finally {
+      this._autoStartFromUrl = c;
+    }
+  }
+  /**
+   * Fetch the caller's robots with busy state, deduped + sorted.
+   * One-shot snapshot — no live subscription. Falls back to the SSE
+   * `_robots` cache if `/api/robot-status` is unavailable (older
+   * central deployments don't expose it).
+   *
+   * Dedup: same physical robot can appear twice transiently after a
+   * daemon reinstall (new peerId, same install_id). Last-writer-wins
+   * on `install_id`, then `hardware_id`, then `peerId` (= no dedup).
+   *
+   * @returns {Promise<Array<{
+   *   id: string,
+   *   name: string|null,
+   *   busy: boolean,
+   *   activeApp: string|null,
+   *   meta: object,
+   *   lastSeenAgeSeconds: number|null,
+   * }>>}
+   */
+  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(), i = /* @__PURE__ */ new Map();
+      for (const o of s.robots || []) {
+        if (e && o.busy) continue;
+        const n = o.meta?.install_id ?? o.meta?.hardware_id ?? o.peerId;
+        i.set(n, {
+          id: o.peerId,
+          name: o.robotName ?? o.meta?.name ?? null,
+          busy: !!o.busy,
+          activeApp: o.activeApp ?? null,
+          meta: o.meta ?? {},
+          lastSeenAgeSeconds: o.last_seen_age_seconds ?? null
+        });
+      }
+      return Array.from(i.values()).sort(
+        (o, n) => (o.lastSeenAgeSeconds ?? 1 / 0) - (n.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,
+        // unknown — SSE list does not carry busy state
+        activeApp: null,
+        meta: s.meta ?? {},
+        lastSeenAgeSeconds: null
+      }));
+    }
+  }
+  /**
+   * Resolve once `robotId` appears in `_robots`, or reject after
+   * `timeoutMs`. Used by `autoConnect()`'s embed branch so the preselected
+   * robot has a chance to surface from the first SSE `list` push before
+   * `startSession()` is fired.
+   */
+  _waitForRobotInList(e, t) {
+    return this._robots?.find((s) => s.id === e) ? Promise.resolve() : new Promise((s, i) => {
+      const o = () => {
+        this._robots?.find((c) => c.id === e) && (this.removeEventListener("robotsChanged", o), clearTimeout(n), s());
+      }, n = setTimeout(() => {
+        this.removeEventListener("robotsChanged", o), i(new Error(`Timeout waiting for robot ${e} in list`));
+      }, t);
+      this.addEventListener("robotsChanged", o);
+    });
+  }
+  /**
+   * Start a WebRTC session with the given robot.
+   * Acquires the microphone (if enabled), negotiates SDP, and waits for
+   * both ICE connection and data channel to be ready before resolving.
+   * Emits "videoTrack" when the robot's camera stream arrives.
+   * Emits "micSupported" once SDP negotiation reveals whether the robot
+   * accepts bidirectional audio.
+   * @param {string} robotId — one of the ids from the robots list
+   * @returns {Promise<void>}
+   */
+  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 = new (window.AudioContext || window.webkitAudioContext)(), s = t.createMediaStreamDestination(), i = t.createOscillator(), o = t.createGain();
+      o.gain.value = 0, i.connect(o).connect(s), i.start(), this._micStream = s.stream, this._micStream.getAudioTracks().forEach((n) => {
+        n.enabled = !1;
+      }), this._micMuted = !0, this._silentMicFallback = { ctx: t, osc: i };
+    } 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 = (i) => {
+        if (i.track.kind === "video") {
+          const o = this._videoJitterBufferTargetMs;
+          try {
+            i.receiver.jitterBufferTarget = o;
+          } catch {
+          }
+          try {
+            i.receiver.playoutDelayHint = o / 1e3;
+          } catch {
+          }
+          this._emit("videoTrack", { track: i.track, stream: i.streams[0] });
+        }
+      }, this._pc.onicecandidate = async (i) => {
+        i.candidate && this._sessionId && await this._sendToServer({
+          type: "peer",
+          sessionId: this._sessionId,
+          ice: {
+            candidate: i.candidate.candidate,
+            sdpMLineIndex: i.candidate.sdpMLineIndex,
+            sdpMid: i.candidate.sdpMid
+          }
+        });
+      }, this._pc.oniceconnectionstatechange = () => {
+        const i = this._pc?.iceConnectionState;
+        if (i)
+          if (i === "connected" || i === "completed")
+            this._iceConnected = !0, this._checkSessionReady();
+          else if (i === "failed") {
+            const o = new Error("ICE connection failed");
+            this._sessionReject && (this._sessionReject(o), this._sessionResolve = null, this._sessionReject = null), this._emit("error", { source: "webrtc", error: o });
+          } else i === "disconnected" && this._emit("error", { source: "webrtc", error: new Error("ICE disconnected") });
+      }, this._pc.ondatachannel = (i) => {
+        this._dc = i.channel, 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((i) => {
+        if (i?.type === "sessionRejected") {
+          this._failSessionRejected(i);
+          return;
+        }
+        i?.sessionId && (this._sessionId = i.sessionId);
+      });
+    });
+  }
+  /**
+   * Internal: handle a sessionRejected response from central.
+   * Releases resources allocated by startSession() (RTCPeerConnection,
+   * microphone stream) and rejects the pending startSession() promise
+   * with an Error carrying `.reason` and `.activeApp`.
+   *
+   * Called from both the POST-response path (primary) and the SSE
+   * handler (defensive, in case the server changes).
+   */
+  _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, t.activeApp = e.activeApp, 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);
+    }
+  }
+  /**
+   * End the WebRTC session.  Returns to "connected" state so you can
+   * startSession() again with the same or a different robot.
+   * @returns {Promise<void>}
+   */
+  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._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" }));
+  }
+  /**
+   * Full teardown — abort SSE, close WebRTC.
+   * Auth state is preserved (call logout() to also clear credentials).
+   */
+  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._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._peerId = null, this._robots = [], this._state = "disconnected", this._emit("disconnected", { reason: "user" });
+  }
+  // ─── Commands ────────────────────────────────────────────────────────
+  // All return false if the data channel is not open, true if sent.
+  /**
+   * Send a target pose to the robot. Wire-shape, raw units only —
+   * single source of truth for motion commands. Every field is
+   * optional; omitted fields leave the daemon's previous target
+   * unchanged, so partial updates compose naturally.
+   *
+   * For human units (degrees), use the ``setHeadRpyDeg`` /
+   * ``setAntennasDeg`` / ``setBodyYawDeg`` thin wrappers below.
+   *
+   * @param {object} [target]
+   * @param {number[]} [target.head] 16-element flat row-major 4×4
+   *   matrix (full SE(3); preserves translation, no XYZ loss).
+   * @param {number[]} [target.antennas] ``[rightRad, leftRad]``.
+   * @param {number} [target.body_yaw] Body yaw in radians.
+   * @returns {boolean} false if the data channel is not open.
+   * @throws {TypeError} if any provided field has the wrong shape or
+   *   contains a non-finite value (NaN, Infinity). Validation runs at
+   *   the JS boundary so caller mistakes surface with a stack trace
+   *   pointing to the call site, not as a confusing daemon-side error.
+   */
+  setTarget({ head: e, antennas: t, body_yaw: s } = {}) {
+    const i = { type: "set_full_target" };
+    if (e !== void 0) {
+      if (!Array.isArray(e) || e.length !== 16 || !e.every((o) => Number.isFinite(o)))
+        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}`
+        );
+      i.head = e;
+    }
+    if (t !== void 0) {
+      if (!Array.isArray(t) || t.length !== 2 || !t.every((o) => Number.isFinite(o)))
+        throw new TypeError(
+          `setTarget: 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(
+          `setTarget: body_yaw must be a finite number (radians); got ${s}`
+        );
+      i.body_yaw = s;
+    }
+    return this._sendCommand(i);
+  }
+  /**
+   * Smooth daemon-side interpolation to a target pose over
+   * ``duration`` seconds. Mirrors ``setTarget``'s wire shape (head
+   * is a 16-element flat row-major 4×4, antennas are
+   * ``[rightRad, leftRad]``, body_yaw is radians) and adds a
+   * required ``duration`` field. The daemon dispatches the command
+   * to its lerp planner instead of jumping to the target.
+   *
+   * Use this for one-shot smooth approaches to an arbitrary pose
+   * (e.g. soft-return-to-base after recording, or pre-positioning
+   * before a streamed playback). For continuous streamed motion,
+   * use ``setTarget`` and lerp client-side.
+   *
+   * @param {{head?: number[], antennas?: number[], body_yaw?: number, duration: number}} args
+   * @returns {boolean} false if the data channel is not open.
+   * @throws {TypeError} if any provided field has the wrong shape
+   *   or contains a non-finite value (NaN, Infinity), or if
+   *   ``duration`` is missing or non-positive.
+   */
+  gotoTarget({ head: e, antennas: t, body_yaw: s, duration: i } = {}) {
+    const o = { type: "goto_target" };
+    if (e !== void 0) {
+      if (!Array.isArray(e) || e.length !== 16 || !e.every((n) => Number.isFinite(n)))
+        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}`
+        );
+      o.head = e;
+    }
+    if (t !== void 0) {
+      if (!Array.isArray(t) || t.length !== 2 || !t.every((n) => Number.isFinite(n)))
+        throw new TypeError(
+          `gotoTarget: 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(
+          `gotoTarget: body_yaw must be a finite number (radians); got ${s}`
+        );
+      o.body_yaw = s;
+    }
+    if (!Number.isFinite(i) || i <= 0)
+      throw new TypeError(
+        `gotoTarget: duration must be a positive finite number (seconds); got ${i}`
+      );
+    return o.duration = i, this._sendCommand(o);
+  }
+  /**
+   * Set head orientation from roll/pitch/yaw in degrees.
+   * Convenience wrapper over ``setTarget``.
+   * @param {number} rollDeg @param {number} pitchDeg @param {number} yawDeg
+   * @returns {boolean}
+   */
+  setHeadRpyDeg(e, t, s) {
+    return this.setTarget({ head: F(e, t, s).flat() });
+  }
+  /**
+   * Set antenna positions from degrees.
+   * Convenience wrapper over ``setTarget``.
+   * @param {number} rightDeg @param {number} leftDeg
+   * @returns {boolean}
+   */
+  setAntennasDeg(e, t) {
+    return this.setTarget({ antennas: [S(e), S(t)] });
+  }
+  /**
+   * Set body yaw from degrees.
+   * Convenience wrapper over ``setTarget``.
+   * @param {number} yawDeg
+   * @returns {boolean}
+   */
+  setBodyYawDeg(e) {
+    return this.setTarget({ body_yaw: S(e) });
+  }
+  /**
+   * Play a sound file on the robot.
+   * @param {string} file — filename available on the robot (e.g. "wake_up.wav")
+   * @returns {boolean}
+   */
+  playSound(e) {
+    return this._sendCommand({ type: "play_sound", file: e });
+  }
+  /**
+   * Set the motor control mode.
+   *
+   * @param {"enabled"|"disabled"|"gravity_compensation"} mode
+   *   - "enabled"              torque on, position-controlled.
+   *   - "disabled"             torque off; the robot is backdrivable
+   *                            and will not hold any pose.
+   *   - "gravity_compensation" torque on in current-control mode;
+   *                            motors actively cancel gravity so the
+   *                            robot is easy to move by hand.
+   * @returns {boolean} false if the data channel is not open.
+   */
+  setMotorMode(e) {
+    return this._sendCommand({ type: "set_motor_mode", mode: e });
+  }
+  /**
+   * Toggle torque on/off, optionally per-motor.
+   *
+   * @param {boolean} on
+   * @param {string[]} [ids]  motor names (e.g. ["left_antenna"]). When
+   *   omitted, applies globally — equivalent to setMotorMode("enabled"
+   *   | "disabled").
+   * @returns {boolean} false if the data channel is not open.
+   */
+  setMotorTorque(e, t = null) {
+    return this._sendCommand({ type: "set_torque", on: e, ids: t });
+  }
+  /**
+   * Play the wake-up animation (full head/antennas trajectory on the
+   * robot, ~1-3 s depending on the starting head pose) and resolve
+   * when the daemon reports the trajectory player has actually
+   * finished.
+   *
+   * This helper sends a ``set_motor_mode: "enabled"`` command *before*
+   * the ``wake_up`` command so the animation actually moves the motors.
+   * The robot's ``wake_up`` handler does not touch motor mode itself;
+   * if torque is off when the trajectory runs, the commanded positions
+   * are silently ignored and the robot stays limp. Both commands
+   * travel over the same data channel so ordering at the backend is
+   * preserved.
+   *
+   * The returned promise resolves on the daemon's
+   * ``{command: "wake_up", completed: true}`` response (sent after
+   * the trajectory player is fully done, not just when the command
+   * is enqueued). Lets a UI overlay (e.g. the host's "Wake-up" step)
+   * stay up for exactly the right duration, and lets callers chain
+   * setup that depends on the head being in the awake pose without
+   * racing the trajectory.
+   *
+   * Semantics match the REST endpoint ``POST /api/move/play/wake_up``
+   * plus the LAN convention of enabling motors before playing motion
+   * trajectories.
+   *
+   * @param {object} [options]
+   * @param {number} [options.timeoutMs=8000] hard upper bound; the
+   *   promise rejects with a TimeoutError-shaped Error if the daemon
+   *   stops responding (e.g. data channel went down mid-animation
+   *   without firing close events).
+   * @returns {Promise<void>}
+   */
+  wakeUp({ timeoutMs: e = 8e3 } = {}) {
+    return this._sendCommand({ type: "set_motor_mode", mode: "enabled" }), this._sendCommandAwaitCompletion("wake_up", e);
+  }
+  /**
+   * Play the goto-sleep animation and resolve when the daemon reports
+   * the trajectory player has finished. See ``wakeUp`` for the
+   * completion-signal rationale.
+   *
+   * Does NOT touch motor mode: the daemon's ``goto_sleep`` handler
+   * manages the transition out of torque on its own (motors must stay
+   * powered during the trajectory to move into the sleep pose, then
+   * are typically disabled by the daemon once the pose is reached).
+   *
+   * The awaitable form lets callers chain ``setMotorMode('disabled')``
+   * AFTER the trajectory lands instead of racing it, which previously
+   * caused the head to drop mid-animation when consumers tore down
+   * too eagerly.
+   *
+   * Semantics match ``POST /api/move/play/goto_sleep`` and the
+   * ``"goto_sleep"`` WebRTC command.
+   *
+   * @param {object} [options]
+   * @param {number} [options.timeoutMs=8000]
+   * @returns {Promise<void>}
+   */
+  gotoSleep({ timeoutMs: e = 8e3 } = {}) {
+    return this._sendCommandAwaitCompletion("goto_sleep", e);
+  }
+  /**
+   * Internal: send a motion command and resolve when the daemon's
+   * matching ``{command, completed: true}`` response lands.
+   *
+   * Pushes one entry onto ``_pendingMotionCompletions[command]``; the
+   * data-channel reader (``_handleRobotMessage``) shifts the oldest
+   * entry off the queue when a response arrives, which preserves the
+   * FIFO matching that the daemon's serialised dispatcher relies on.
+   *
+   * Rejects immediately if the data channel is not open; the underlying
+   * ``_sendCommand`` returns false in that case and we never enqueue an
+   * awaiter that the daemon could never reach.
+   *
+   * @param {"wake_up"|"goto_sleep"} command
+   * @param {number} timeoutMs
+   * @returns {Promise<void>}
+   */
+  _sendCommandAwaitCompletion(e, t) {
+    return this._sendCommand({ type: e }) ? new Promise((s, i) => {
+      const o = {
+        resolve: s,
+        reject: i,
+        timer: setTimeout(() => {
+          const n = this._pendingMotionCompletions[e], c = n.indexOf(o);
+          c !== -1 && n.splice(c, 1), i(new Error(`${e} timed out after ${t}ms`));
+        }, t)
+      };
+      this._pendingMotionCompletions[e].push(o);
+    }) : Promise.reject(new Error(`${e}: data channel not open`));
+  }
+  /**
+   * Internal: drain every pending motion-completion resolver with the
+   * given error. Called by ``stopSession()`` and ``disconnect()`` so a
+   * teardown that interrupts an in-flight ``gotoSleep`` does not leave
+   * the caller awaiting forever.
+   */
+  _rejectPendingMotionCompletions(e) {
+    for (const t of Object.keys(this._pendingMotionCompletions)) {
+      const s = this._pendingMotionCompletions[t];
+      for (; s.length; ) {
+        const i = s.shift();
+        clearTimeout(i.timer), i.reject(e);
+      }
+    }
+  }
+  /**
+   * Whether the robot's motors are currently powered (the "awake" state).
+   *
+   * Reads ``motor_mode`` from the last state event. Both ``"enabled"``
+   * and ``"gravity_compensation"`` count as awake: in gravity-comp the
+   * motors are actively holding the arm against gravity, so the robot
+   * is *not* limp and playing wake_up on top would fight the user.
+   * Only ``"disabled"`` (true sleep) is considered not-awake.
+   *
+   * Returns ``false`` before the first state event arrives (typical
+   * right after ``startSession()``). Use ``ensureAwake()`` if you want
+   * to wait for the first state before deciding.
+   *
+   * @returns {boolean}
+   */
+  isAwake() {
+    const e = this._robotState?.motor_mode;
+    return e === "enabled" || e === "gravity_compensation";
+  }
+  /**
+   * Wake the robot up if it is currently asleep, otherwise no-op.
+   *
+   * Intended as the first line of any app after ``startSession()``
+   * resolves — robots are often left in the sleep pose (torque off,
+   * head resting on the base) and commanded positions are silently
+   * ignored in that state.
+   *
+   * If no state event has arrived yet, waits up to ``timeoutMs`` for
+   * one before deciding. If still no state, falls back to sending
+   * ``wakeUp()`` (safe: the daemon's wake_up handler is idempotent
+   * at the motion level — it moves to the awake pose from wherever
+   * the head currently is).
+   *
+   * @param {number} [timeoutMs=1000] how long to wait for the first
+   *   state event before falling through to wakeUp().
+   * @returns {Promise<boolean>} true if the robot is awake afterwards.
+   */
+  async ensureAwake(e = 1e3) {
+    return this._robotState?.motor_mode === void 0 && await new Promise((t) => {
+      const s = () => {
+        this.removeEventListener("state", s), clearTimeout(i), t();
+      }, i = setTimeout(s, e);
+      this.addEventListener("state", s), this.requestState();
+    }), this.isAwake() || this.wakeUp().catch(() => {
+    }), !0;
+  }
+  /**
+   * Request the daemon version.
+   * Resolves with the version string (or null if unavailable).
+   * @returns {Promise<string|null>}
+   */
+  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" });
+    });
+  }
+  /**
+   * Request the robot's unique hardware ID — the Pollen audio device's
+   * USB serial. Same value across Lite and Wireless variants, stable
+   * across reboots and OS reinstalls. Useful for fleet management,
+   * per-robot calibration cache keys, or identifying which physical
+   * robot a session is bound to.
+   * Resolves with the hardware ID string (or null if no robot is
+   * attached, e.g. the daemon is running on a developer machine).
+   * @returns {Promise<string|null>}
+   */
+  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" });
+    });
+  }
+  /**
+   * Query the current speaker volume (0-100).
+   * Resolves with null if volume control is unavailable (platform unsupported
+   * or audio stack down).
+   * @returns {Promise<number|null>}
+   */
+  getVolume() {
+    return this._volumeRoundtrip({ type: "get_volume" }, "_volumeResolve");
+  }
+  /**
+   * Set the speaker volume (0-100). Persists for the next connection
+   * (same semantics as the REST /api/volume/set endpoint).
+   * Resolves with the applied volume, or null on failure.
+   * @param {number} volume 0-100
+   * @returns {Promise<number|null>}
+   */
+  setVolume(e) {
+    return this._volumeRoundtrip(
+      { type: "set_volume", volume: U(e) },
+      "_volumeResolve"
+    );
+  }
+  /**
+   * Query the current microphone input volume (0-100).
+   * @returns {Promise<number|null>}
+   */
+  getMicrophoneVolume() {
+    return this._volumeRoundtrip(
+      { type: "get_microphone_volume" },
+      "_micVolumeResolve"
+    );
+  }
+  /**
+   * Set the microphone input volume (0-100). Persists across sessions.
+   * @param {number} volume 0-100
+   * @returns {Promise<number|null>}
+   */
+  setMicrophoneVolume(e) {
+    return this._volumeRoundtrip(
+      { type: "set_microphone_volume", volume: U(e) },
+      "_micVolumeResolve"
+    );
+  }
+  /**
+   * Internal: send a volume command and await the single-slot response.
+   * The slot name selects which resolver (speaker vs mic) owns the
+   * pending request so the two can be in-flight concurrently without
+   * collision.
+   */
+  _volumeRoundtrip(e, t) {
+    return new Promise((s, i) => {
+      if (!this._dc || this._dc.readyState !== "open") {
+        i(new Error("Data channel not open"));
+        return;
+      }
+      this[t] && this[t](null), this[t] = s, this._sendCommand(e);
+    });
+  }
+  /**
+   * Send an arbitrary JSON command over the data channel.
+   * @param {object} data  @returns {boolean}
+   */
+  sendRaw(e) {
+    return this._sendCommand(e);
+  }
+  /**
+   * Subscribe to the daemon's `journalctl -u reachy-mini-daemon`
+   * stream over the WebRTC data channel.
+   *
+   * One daemon-side subprocess is shared across all local subscribers:
+   * the first call sends `subscribe_logs`, removing the last subscriber
+   * sends `unsubscribe_logs`. Calling the returned `unsubscribe()`
+   * twice is a no-op.
+   *
+   * @param {{
+   *   onLine: (entry: { timestamp: string, line: string }) => void,
+   *   onError?: (error: string) => void,
+   * }} options
+   * @returns {() => void} unsubscribe
+   */
+  subscribeLogs({ onLine: e, onError: t } = {}) {
+    if (typeof e != "function")
+      throw new TypeError("subscribeLogs: onLine callback is required");
+    const s = { onLine: e, onError: t }, i = this._logSubscribers.size === 0;
+    this._logSubscribers.add(s), i && this._sendCommand({ type: "subscribe_logs" });
+    let o = !1;
+    return () => {
+      o || (o = !0, this._logSubscribers.delete(s), this._logSubscribers.size === 0 && this._sendCommand({ type: "unsubscribe_logs" }));
+    };
+  }
+  /**
+   * Request a state snapshot.  The response arrives as a "state" event.
+   * Called automatically every 500 ms while streaming.
+   *
+   * Safe to call at a higher rate if you need faster telemetry: e.g.
+   * ``setInterval(() => robot.requestState(), 20)`` for ~50 Hz, or drive
+   * it from a ``requestAnimationFrame`` loop for display-rate updates.
+   * On LAN the daemon can sustain ~90-100 Hz round-trips over the
+   * datachannel; over the internet expect the WebRTC path's RTT to
+   * dominate. The built-in 500 ms poll keeps running in parallel — it
+   * is harmless, as state responses are idempotent.
+   *
+   * @returns {boolean}
+   */
+  requestState() {
+    return this._sendCommand({ type: "get_state" });
+  }
+  // ─── Audio ───────────────────────────────────────────────────────────
+  /**
+   * Mute/unmute the robot's audio playback (speaker) locally.
+   * Audio is muted by default — browsers require a user gesture to unmute.
+   * @param {boolean} muted
+   */
+  setAudioMuted(e) {
+    this._audioMuted = e, this._videoElement && (this._videoElement.muted = e);
+  }
+  /**
+   * Mute/unmute your microphone.  Only works if micSupported is true.
+   * Mic is muted by default even after acquisition.
+   * @param {boolean} muted
+   */
+  setMicMuted(e) {
+    this._micMuted = e, this._micStream && this._micStream.getAudioTracks().forEach((t) => {
+      t.enabled = !e;
+    });
+  }
+  // ─── Video helper ────────────────────────────────────────────────────
+  /**
+   * Bind a `<video>` element to this robot's stream.
+   * Call before startSession().  Sets srcObject when the video track arrives,
+   * applies audio mute state, and runs a latency monitor that snaps to the
+   * live edge if the buffer grows > 0.5 s.
+   *
+   * @param {HTMLVideoElement} videoElement
+   * @returns {() => void} cleanup function — call to detach video and stop monitoring
+   */
+  attachVideo(e) {
+    this._videoElement = e, e.muted = this._audioMuted;
+    const t = (i) => {
+      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 ──────────────────────────────
+  //
+  // These methods talk to the daemon's `feature/daemon-side-move-upload`
+  // protocol: motion (and optional audio) are uploaded once over the
+  // data channel, then the daemon's play_move loop runs at the requested
+  // frequency server-side — no per-frame WebRTC round-trip, smooth on
+  // wireless robots. Audio, when present, plays on the same daemon-side
+  // GStreamer pipeline so motion and sound share a single clock.
+  //
+  // For record-time flows that need the SAME audio pipeline at capture
+  // and replay (so pipeline latency cancels), use uploadAudio +
+  // playUploadedAudio to play audio standalone with a sync anchor.
+  /**
+   * Upload a recorded move (and optionally its audio) and play it on
+   * the daemon's local clock. Resolves when playback ends with the
+   * daemon's final broadcast — `{finished: true}`, `{cancelled: true}`,
+   * or `{error: string}`.
+   *
+   * `audioLeadMs` shifts audio relative to motion:
+   *  - Positive: audio fires N ms BEFORE motion (compensates motor pickup).
+   *  - Negative: motion fires N ms BEFORE audio (compensates pipeline warmup).
+   *  - Default `-100` is the empirically-measured system-wide constant
+   *    (combined motor + GStreamer playbin warmup); tune per setup only
+   *    if you've measured a different value.
+   *
+   * @param {{ time: number[], set_target_data: object[] }} motion
+   * @param {object} [opts]
+   * @param {Blob}    [opts.audioBlob]            - canonical 16 kHz mono PCM WAV
+   * @param {number}  [opts.audioLeadMs=-100]
+   * @param {string}  [opts.description="move"]
+   * @param {"gzip+base64"|"json"} [opts.encoding="gzip+base64"]
+   * @param {number}  [opts.playFrequency=100]
+   * @param {number}  [opts.initialGotoDuration=0]
+   * @param {number}  [opts.startTimeoutMs=8000]
+   * @param {(p: { phase: string, sent?: number, total?: number,
+   *               bytes?: number, encoding?: string,
+   *               duration_s?: number }) => void} [opts.onProgress]
+   * @param {(s: { duration_s: number, has_audio: boolean }) => void} [opts.onStarted]
+   * @returns {Promise<{ finished?: boolean, cancelled?: boolean,
+   *                     error?: string, has_audio?: boolean }>}
+   */
+  async playMove(e, {
+    audioBlob: t = null,
+    audioLeadMs: s = -100,
+    description: i = "move",
+    encoding: o = "gzip+base64",
+    playFrequency: n = 100,
+    initialGotoDuration: c = 0,
+    startTimeoutMs: a = 8e3,
+    onProgress: u = () => {
+    },
+    onStarted: d = () => {
+    }
+  } = {}) {
+    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 = j();
+    this._activeMoveUploadId = l;
+    const p = {
+      description: i,
+      time: e.time,
+      set_target_data: e.set_target_data
+    }, f = JSON.stringify(p);
+    let m, b;
+    o === "gzip+base64" && W() ? (m = await z(f), b = "gzip+base64") : (m = f, b = "json");
+    const w = Math.ceil(m.length / y) || 1;
+    u({
+      phase: "starting",
+      sent: 0,
+      total: w,
+      bytes: m.length,
+      encoding: b
+    }), this._sendCommand({
+      type: "upload_move_start",
+      upload_id: l,
+      total_chunks: w,
+      description: i,
+      encoding: b
+    });
+    for (let h = 0; h < w; h++) {
+      this._dc.bufferedAmount > E && await this._awaitDataChannelDrain();
+      const _ = h * y;
+      this._sendCommand({
+        type: "upload_move_chunk",
+        upload_id: l,
+        chunk_index: h,
+        chunk: m.slice(_, _ + y)
+      }), u({ phase: "upload", sent: h + 1, total: w });
+    }
+    if (this._sendCommand({ type: "upload_move_finish", upload_id: l }), u({ phase: "uploaded", sent: w, total: w }), t) {
+      const h = new Uint8Array(await t.arrayBuffer()), _ = A(h), v = Math.ceil(_.length / y) || 1;
+      u({
+        phase: "audio-starting",
+        sent: 0,
+        total: v,
+        bytes: _.length
+      }), this._sendCommand({
+        type: "upload_audio_start",
+        upload_id: l,
+        total_chunks: v,
+        encoding: "wav-base64",
+        description: i
+      });
+      for (let I = 0; I < v; I++) {
+        this._dc.bufferedAmount > E && await this._awaitDataChannelDrain();
+        const T = I * y;
+        this._sendCommand({
+          type: "upload_audio_chunk",
+          upload_id: l,
+          chunk_index: I,
+          chunk: _.slice(T, T + y)
+        }), u({ phase: "audio-upload", sent: I + 1, total: v });
+      }
+      this._sendCommand({ type: "upload_audio_finish", upload_id: l }), u({ phase: "audio-uploaded", sent: v, total: v });
+    }
+    this._sendCommand({
+      type: "play_uploaded_move",
+      upload_id: l,
+      play_frequency: n,
+      initial_goto_duration: c,
+      audio_lead_ms: s
+    });
+    let g;
+    try {
+      g = await this._waitForBroadcast(
+        (h) => h?.type === "play_uploaded_move" && h?.upload_id === l && (h.started === !0 || typeof h.error == "string"),
+        { timeoutMs: a, 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 g.error == "string")
+      throw new Error(`play_uploaded_move: ${g.error}`);
+    try {
+      d({
+        duration_s: g.duration_s,
+        has_audio: g.has_audio === !0
+      });
+    } catch (h) {
+      console.warn("playMove.onStarted threw:", h);
+    }
+    u({ phase: "playing", duration_s: g.duration_s });
+    const R = await this._waitForBroadcast(
+      (h) => h?.type === "play_uploaded_move" && h?.upload_id === l && (h.finished === !0 || h.cancelled === !0 || typeof h.error == "string"),
+      {
+        timeoutMs: (g.duration_s + 30) * 1e3,
+        debugLabel: "play_uploaded_move final"
+      }
+    );
+    return this._activeMoveUploadId === l && (this._activeMoveUploadId = null), R;
+  }
+  /**
+   * Cancel an in-flight `playMove`. Fire-and-forget; the daemon
+   * broadcasts the cancelled event which `playMove` resolves with.
+   *
+   * Pass `uploadId` explicitly to target a specific run; defaults to
+   * the most recent in-flight `playMove`. The daemon now scopes
+   * cancels by upload_id so two back-to-back plays can't cross-cancel
+   * each other — a cancel with no live target is a no-op.
+   *
+   * @param {string} [uploadId] - optional; defaults to the active playMove id
+   * @returns {boolean} false if the data channel isn't open or no run to target
+   */
+  cancelMove(e = null) {
+    const t = e ?? this._activeMoveUploadId;
+    return t ? this._sendCommand({ type: "cancel_move", upload_id: t }) : !1;
+  }
+  /**
+   * Upload audio to the daemon as a standalone slot (no motion attached).
+   * Used by recording flows that want the SAME audio pipeline at record
+   * time and play time — pipeline latency cancels, so a single per-system
+   * `audioLeadMs` is enough for sync.
+   *
+   * @param {Blob} audioBlob - canonical 16 kHz mono PCM WAV
+   * @param {object} [opts]
+   * @param {string} [opts.description="audio"]
+   * @param {(p: { phase: string, sent?: number, total?: number,
+   *               bytes?: number }) => void} [opts.onProgress]
+   * @returns {Promise<string>} uploadId — pair with playUploadedAudio
+   */
+  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 i = j(), o = new Uint8Array(await e.arrayBuffer()), n = A(o), c = Math.ceil(n.length / y) || 1;
+    s({ phase: "audio-starting", sent: 0, total: c, bytes: n.length }), this._sendCommand({
+      type: "upload_audio_start",
+      upload_id: i,
+      total_chunks: c,
+      encoding: "wav-base64",
+      description: t
+    });
+    for (let a = 0; a < c; a++) {
+      this._dc.bufferedAmount > E && await this._awaitDataChannelDrain();
+      const u = a * y;
+      this._sendCommand({
+        type: "upload_audio_chunk",
+        upload_id: i,
+        chunk_index: a,
+        chunk: n.slice(u, u + y)
+      }), s({ phase: "audio-upload", sent: a + 1, total: c });
+    }
+    return this._sendCommand({ type: "upload_audio_finish", upload_id: i }), s({ phase: "audio-uploaded", sent: c, total: c }), i;
+  }
+  /**
+   * Trigger daemon-side playback of a previously-uploaded audio.
+   * Resolves when the daemon broadcasts the "started" event — this is
+   * the sync anchor callers use as t=0 for related capture.
+   *
+   * The daemon does NOT emit a finished event for standalone audio;
+   * callers know the duration from the WAV header and send
+   * `cancelAudio()` when they're done (e.g. recording stopped).
+   *
+   * @param {string} uploadId
+   * @param {object} [opts]
+   * @param {number} [opts.timeoutMs=8000]
+   * @returns {Promise<{ started: true }>}
+   */
+  async playUploadedAudio(e, { timeoutMs: t = 8e3 } = {}) {
+    if (!this._dc || this._dc.readyState !== "open")
+      throw new Error("data channel not open");
+    const s = this._waitForBroadcast(
+      (o) => o?.type === "play_uploaded_audio" && o?.upload_id === e && (o.started === !0 || typeof o.error == "string"),
+      { timeoutMs: t, debugLabel: "play_uploaded_audio started" }
+    );
+    this._sendCommand({ type: "play_uploaded_audio", upload_id: e });
+    const i = await s;
+    if (typeof i.error == "string") throw new Error(i.error);
+    return this._activeAudioUploadId = e, i;
+  }
+  /**
+   * Cancel an in-flight `playUploadedAudio`. Fire-and-forget.
+   *
+   * Pass `uploadId` explicitly to target a specific run; defaults
+   * to the most recent `playUploadedAudio`. The daemon scopes
+   * cancels by upload_id so a stale cancel won't kill the audio
+   * attached to a concurrently-running `playMove`.
+   *
+   * @param {string} [uploadId] - optional; defaults to the active playUploadedAudio id
+   * @returns {boolean} false if the data channel isn't open or no run to target
+   */
+  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 }));
+  }
+  /**
+   * Register a one-shot waiter for a daemon broadcast event. Resolves
+   * with the matching payload, rejects on `timeoutMs`. Used internally
+   * by `playMove` / `playUploadedAudio`.
+   */
+  _waitForBroadcast(e, { timeoutMs: t = 5e3, debugLabel: s = "" } = {}) {
+    return new Promise((i, o) => {
+      const n = { predicate: e, resolve: i };
+      n.timer = setTimeout(() => {
+        const c = this._broadcastWaiters.indexOf(n);
+        c !== -1 && this._broadcastWaiters.splice(c, 1), o(new Error(`broadcast timeout (${t} ms): ${s}`));
+      }, t), this._broadcastWaiters.push(n);
+    });
+  }
+  /**
+   * Wait until `_dc.bufferedAmount` drops below the low watermark. Polls
+   * at ~30 ms; browsers don't expose a uniform event for SCTP data channels
+   * (`onbufferedamountlow` is patchy across engines).
+   */
+  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);
+  }
+  /** Resolves the startSession() promise once both ICE and datachannel are ready. */
+  _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;
+      // handled in connect()
+      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;
+        break;
+      case "sessionRejected":
+        this._failSessionRejected(e);
+        break;
+      case "endSession":
+        this._handleEndSession(e);
+        break;
+      case "peer":
+        this._handlePeerMessage(e);
+        break;
+    }
+  }
+  /**
+   * Internal: handle an endSession pushed from central.
+   *
+   * Two user-visible scenarios converge here:
+   *
+   * 1. Pending startSession — central accepted our request but the
+   *    robot-side relay then refused (e.g. a local Python app holds
+   *    the daemon's robot lock). Without this handler, the client's
+   *    startSession() promise would hang forever because ICE/datachannel
+   *    never come up.
+   * 2. Streaming was evicted — a local Python app started on the robot
+   *    while we were connected, so the relay tore down our session.
+   *
+   * The ``reason`` is forwarded verbatim from the relay through central:
+   * - "robot_busy_local_app": daemon lock held by a local Python app
+   *   (refused before any media negotiation).
+   * - "local_app_started": a local Python app started mid-session and
+   *   evicted us.
+   * - "robot_busy_local": relay's safety-net for stale/concurrent
+   *   sessions (should be rare).
+   */
+  _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 i = new Error(
+        s || `Session ended before it could start: ${t || "unknown reason"}`
+      );
+      i.reason = t, this._emit("sessionRejected", { reason: t, activeApp: null }), this._pc && (this._pc.close(), this._pc = null), this._micStream && (this._micStream.getTracks().forEach((n) => n.stop()), this._micStream = null), this._iceConnected = !1, this._dcOpen = !1, this._micMuted = !0, this._micSupported = !1;
+      const o = this._sessionReject;
+      this._sessionResolve = null, this._sessionReject = null, o(i);
+      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 i = q(t.sdp);
+            if (this._micSupported = i, this._emit("micSupported", { supported: i }), i && this._micStream)
+              for (const n of this._micStream.getAudioTracks())
+                this._pc.addTrack(n, this._micStream);
+            await this._pc.setRemoteDescription(new RTCSessionDescription(t));
+            const o = await this._pc.createAnswer();
+            await this._pc.setLocalDescription(o), await this._sendToServer({
+              type: "peer",
+              sessionId: this._sessionId,
+              sdp: { type: "answer", sdp: o.sdp }
+            });
+          } else
+            await this._pc.setRemoteDescription(new RTCSessionDescription(t));
+          const s = this._pendingRemoteIce;
+          if (s && s.length) {
+            this._pendingRemoteIce = [];
+            for (const i of s)
+              try {
+                await this._pc.addIceCandidate(new RTCIceCandidate(i));
+              } catch (o) {
+                console.warn("[reachy-mini] buffered ICE candidate rejected:", o);
+              }
+          }
+        }
+        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 });
+      }
+  }
+  /** Parse robot messages and dispatch. */
+  _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 === "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), i = s - e.currentTime;
+        i > 0.5 && (console.log(`Latency correction: was ${i.toFixed(2)}s behind`), e.currentTime = s - 0.1);
+      }
+    }, 2e3);
+  }
+}
+export {
+  J as R
+};
+//# sourceMappingURL=reachy-mini-sdk-eBYlC77N.js.map