beam-alpha 0.1.0

package/dist/probe.js

@@ -0,0 +1,3084 @@
+"use strict";
+(() => {
+  // ../../node_modules/torph/dist/index.mjs
+  var _t = { locale: "en", duration: 400, ease: "cubic-bezier(0.19, 1, 0.22, 1)", disabled: false, respectReducedMotion: true };
+  function Dt(e, t, n) {
+    if (n < 1) {
+      let u = t * Math.sqrt(1 - n * n);
+      return 1 - Math.exp(-n * t * e) * (Math.cos(u * e) + n * t / u * Math.sin(u * e));
+    }
+    let i = Math.sqrt(n * n - 1), r = -t * (n + i), s = -t * (n - i), o = -r / (s - r);
+    return 1 - (1 - o) * Math.exp(r * e) - o * Math.exp(s * e);
+  }
+  function Ie(e, t, n) {
+    let s = 0;
+    for (let o = 0; o < 10; o += 1e-3) if (Math.abs(Dt(o, e, t) - 1) > n) s = 0;
+    else if (s += 1e-3, s > 0.1) return Math.ceil((o - s + 1e-3) * 1e3);
+    return Math.ceil(10 * 1e3);
+  }
+  function Ft(e, t) {
+    if (typeof e == "object") {
+      let n = Le(e);
+      return { ease: n.easing, duration: n.duration };
+    }
+    return { ease: e, duration: t };
+  }
+  var $t = /* @__PURE__ */ new Map();
+  function Le(e) {
+    let { stiffness: t = 100, damping: n = 10, mass: i = 1, precision: r = 1e-3 } = e ?? {}, s = `${t}:${n}:${i}:${r}`, o = $t.get(s);
+    if (o) return o;
+    let a = Math.sqrt(t / i), u = n / (2 * Math.sqrt(t * i)), c = Ie(a, u, r), f = Math.min(100, Math.max(32, Math.round(c / 15))), l = [];
+    for (let d = 0; d < f; d++) {
+      let h = d / (f - 1) * (c / 1e3), M = d === f - 1 ? 1 : Dt(h, a, u);
+      l.push(Math.round(M * 1e4) / 1e4 + "");
+    }
+    for (; l.length > 2 && l[l.length - 2] === "1"; ) l.splice(l.length - 2, 1);
+    let m = { easing: `linear(${l.join(", ")})`, duration: c };
+    return $t.set(s, m), m;
+  }
+  function G(e, t) {
+    let n = e.length, i = t.length, r = Array.from({ length: n + 1 }, () => Array(i + 1).fill(0));
+    for (let c = n - 1; c >= 0; c--) for (let f = i - 1; f >= 0; f--) r[c][f] = e[c] === t[f] ? r[c + 1][f + 1] + 1 : Math.max(r[c + 1][f], r[c][f + 1]);
+    let s = [], o = [], a = 0, u = 0;
+    for (; a < n && u < i; ) e[a] === t[u] ? (s.push(a), o.push(u), a++, u++) : r[a + 1][u] >= r[a][u + 1] ? a++ : u++;
+    return [s, o];
+  }
+  var Ne = "\0n";
+  var ke = 0;
+  function ht() {
+    return `${Ne}${ke++}`;
+  }
+  function k(e) {
+    return e >= "0" && e <= "9";
+  }
+  function q(e) {
+    for (let t of e) if (k(t)) return true;
+    return false;
+  }
+  function gt(e) {
+    let t = "";
+    for (let n of e) !k(n) && !bt.includes(n) && (t += n);
+    return t;
+  }
+  var bt = ".,'\xA0\u202F\u2009\u2007";
+  var He = "+-\u2212(#";
+  var Oe = `%.,!?:;)"'\u201D\u2019`;
+  var _e = new RegExp("\\p{Sc}", "u");
+  function Pt(e, t) {
+    return t.includes(e) || _e.test(e);
+  }
+  function J(e) {
+    let t = 0, n = e.length;
+    for (; t < n && Pt(e[t], He); ) t++;
+    for (; n > t && Pt(e[n - 1], Oe); ) n--;
+    if (t >= n || !k(e[t]) || !k(e[n - 1])) return false;
+    for (let i = t; i < n; i++) {
+      let r = e[i];
+      if (!k(r) && !bt.includes(r)) return false;
+    }
+    return true;
+  }
+  function at(e) {
+    return k(e) ? "digit" : "symbol";
+  }
+  var Ct = /* @__PURE__ */ new Map();
+  function xt(e) {
+    let t = String(e), n = Ct.get(t);
+    if (n) return n;
+    let i = ".";
+    try {
+      i = new Intl.NumberFormat(e).formatToParts(1.1).find((r) => r.type === "decimal")?.value ?? ".";
+    } catch {
+    }
+    return Ct.set(t, i), i;
+  }
+  function U(e, t, n, i = ".") {
+    let r = e.split("");
+    if (!t || t.length === 0) return $e(r);
+    let s = t.map((c) => c.string === "\xA0" ? " " : c.string), o = n != null ? De(s, r, n, i) : Fe(s, r, i), a = /* @__PURE__ */ new Set();
+    for (let [, c] of o) a.add(t[c].id);
+    let u = [];
+    for (let c = 0; c < r.length; c++) {
+      let f = r[c], l = at(f), m = f === " " ? "\xA0" : f;
+      if (o.has(c)) {
+        let d = o.get(c);
+        u.push({ id: t[d].id, string: m, kind: l });
+      } else {
+        let d = ht();
+        for (; a.has(d); ) d = ht();
+        a.add(d), u.push({ id: d, string: m, kind: l });
+      }
+    }
+    return u;
+  }
+  function $e(e) {
+    return e.map((t) => ({ id: ht(), string: t === " " ? "\xA0" : t, kind: at(t) }));
+  }
+  function De(e, t, n, i) {
+    let r = /* @__PURE__ */ new Map(), s = Xt(e, i), o = Xt(t, i), a = (m, d) => r.set(o[m], s[d]), u = 0;
+    for (; u < o.length && o[u] < n; ) u++;
+    let c = o.length - s.length;
+    if (c > 0) {
+      let m = u - c;
+      for (let d = 0; d < m && d < s.length; d++) a(d, d);
+      for (let d = u; d < o.length; d++) {
+        let h = d - c;
+        h >= 0 && h < s.length && a(d, h);
+      }
+    } else if (c < 0) {
+      for (let m = 0; m < u && m < o.length; m++) a(m, m);
+      for (let m = u; m < o.length; m++) {
+        let d = m - c;
+        d >= 0 && d < s.length && a(m, d);
+      }
+    } else for (let m = 0; m < o.length; m++) t[o[m]] === e[s[m]] && a(m, m);
+    let f = Bt(e, i), l = Bt(t, i);
+    for (let m = 1; m <= f.length && m <= l.length; m++) {
+      let d = f[f.length - m], h = l[l.length - m];
+      e[d] === t[h] && r.set(h, d);
+    }
+    return r;
+  }
+  function Kt(e, t) {
+    return e !== t && bt.includes(e);
+  }
+  function Xt(e, t) {
+    let n = [];
+    for (let i = 0; i < e.length; i++) Kt(e[i], t) || n.push(i);
+    return n;
+  }
+  function Bt(e, t) {
+    let n = [];
+    for (let i = 0; i < e.length; i++) Kt(e[i], t) && n.push(i);
+    return n;
+  }
+  function Fe(e, t, n) {
+    let i = /* @__PURE__ */ new Map(), r = 0;
+    for (; r < e.length && r < t.length && e[r] === t[r] && !k(e[r]); ) i.set(r, r), r++;
+    let s = e.length, o = t.length;
+    for (; s > r && o > r && e[s - 1] === t[o - 1] && !k(e[s - 1]); ) i.set(o - 1, s - 1), s--, o--;
+    let a = Ut(e, r, s, n), u = Ut(t, r, o, n), c = Gt(e, r, a), f = Gt(t, r, u);
+    if (c > 0 && f > 0 && Math.abs(c - f) >= Pe) return i;
+    if (!d(r, a, r, u, true)) for (let h = 1; a - h >= r && u - h >= r; h++) m(a - h, u - h);
+    if (a < s && u < o) {
+      i.set(u, a);
+      for (let h = 1; a + h < s && u + h < o; h++) m(a + h, u + h);
+      d(a + 1, s, u + 1, o, false);
+    }
+    function m(h, M) {
+      let x = e[h];
+      k(x) || x === t[M] && i.set(M, h);
+    }
+    function d(h, M, x, T, L) {
+      let E = Wt(e, h, M), N = Wt(t, x, T);
+      if (E.length === N.length || !L) {
+        let A = Math.min(E.length, N.length);
+        for (let _ = 0; _ < A; _++) {
+          let B = E[_], rt = N[_];
+          e[B] === t[rt] && i.set(rt, B);
+        }
+        return false;
+      }
+      let g = E.map((A) => e[A]).reverse(), v = N.map((A) => t[A]).reverse(), [R, O] = G(g, v);
+      for (let A = 0; A < R.length; A++) {
+        let _ = E[E.length - 1 - R[A]], B = N[N.length - 1 - O[A]];
+        i.set(B, _);
+      }
+      return R.length > 0;
+    }
+    return i;
+  }
+  function Wt(e, t, n) {
+    let i = [];
+    for (let r = t; r < n; r++) k(e[r]) && i.push(r);
+    return i;
+  }
+  var Pe = 3;
+  function Gt(e, t, n) {
+    let i = 0;
+    for (let r = t; r < n; r++) k(e[r]) && i++;
+    return i;
+  }
+  function Ut(e, t, n, i) {
+    for (let r = n - 1; r >= t; r--) if (e[r] === i) return r;
+    return n;
+  }
+  function yt() {
+    let e = /* @__PURE__ */ new Set();
+    return { reserve(t) {
+      e.add(t);
+    }, has(t) {
+      return e.has(t);
+    }, take(t) {
+      if (!e.has(t)) return e.add(t), t;
+      let n = 1;
+      for (; e.has(`${t}~${n}`); ) n++;
+      let i = `${t}~${n}`;
+      return e.add(i), i;
+    } };
+  }
+  function zt(e) {
+    let t = [], n = [], i = () => {
+      n.length !== 0 && (t.push({ word: n.map((r) => r.string).join(""), segments: n }), n = []);
+    };
+    for (let r of e) r.string === "\xA0" || r.string === `
+` ? i() : n.push(r);
+    return i(), t;
+  }
+  function Yt(e) {
+    let t = [], n = [], i = () => {
+      if (n.length === 0) return;
+      let r = n.map((s) => s.string).join("");
+      J(r) ? t.push(...U(r)) : t.push(...n), n = [];
+    };
+    for (let r of e) r.string === "\xA0" || r.string === `
+` ? (i(), t.push(r)) : n.push(r);
+    return i(), t;
+  }
+  function K(e, t, n = true) {
+    let i = e.includes(`
+`), r = e.includes(" ") || i, s = yt();
+    if (i) {
+      let a = e.split(`
+`), u = [], c = 0;
+      return a.forEach((f, l) => {
+        l > 0 && (u.push({ id: s.take(`newline-${c}`), string: `
+` }), c += 1), f.length > 0 && u.push(...jt(f, t, true, c, s)), c += f.length;
+      }), n ? Yt(u) : u;
+    }
+    let o = jt(e, t, r, 0, s);
+    return n ? Yt(o) : o;
+  }
+  function jt(e, t, n, i, r) {
+    if (typeof Intl.Segmenter < "u") {
+      let s = new Intl.Segmenter(t, { granularity: n ? "word" : "grapheme" });
+      return Ce(s.segment(e)[Symbol.iterator](), i, r);
+    }
+    return Xe(e, n, i, r);
+  }
+  function Ce(e, t, n) {
+    let i = [];
+    for (let r of Array.from(e)) {
+      let s = t + r.index;
+      r.segment === " " ? i.push({ id: n.take(`space-${s}`), string: "\xA0" }) : i.push({ id: qt(r.segment, s, n), string: r.segment });
+    }
+    return i;
+  }
+  function qt(e, t, n) {
+    return n.has(e) ? n.take(`${e}-${t}`) : n.take(e);
+  }
+  function Xe(e, t, n, i) {
+    let r = t ? e.split(" ") : e.split(""), s = [], o = n;
+    return r.forEach((a, u) => {
+      t && u > 0 && (s.push({ id: i.take(`space-${o}`), string: "\xA0" }), o += 1), s.push({ id: qt(a, o, i), string: a }), o += a.length;
+    }), s;
+  }
+  var Y = "torph-root";
+  var Q = "torph-item";
+  var w = "torph-id";
+  var V = "torph-kind";
+  var F = "torph-slot";
+  var H = "torph-exiting";
+  var P = "torph-sr";
+  var Z = "torph-debug";
+  var tt = "empty";
+  var Be = { linear: [0, 0, 1, 1], ease: [0.25, 0.1, 0.25, 1], "ease-in": [0.42, 0, 1, 1], "ease-out": [0, 0, 0.58, 1], "ease-in-out": [0.42, 0, 0.58, 1] };
+  var Jt = (e, t, n) => {
+    let i = 1 - n;
+    return 3 * i * i * n * e + 3 * i * n * n * t + n * n * n;
+  };
+  function Qt(e, t, n, i) {
+    return (r) => {
+      if (r <= 0) return 0;
+      if (r >= 1) return 1;
+      let s = 0, o = 1;
+      for (let a = 0; a < 24; a += 1) {
+        let u = (s + o) / 2;
+        Jt(e, n, u) < r ? s = u : o = u;
+      }
+      return Jt(t, i, (s + o) / 2);
+    };
+  }
+  function We(e) {
+    let t = [...e];
+    (t[0] === null || t[0] === void 0) && (t[0] = 0), t[t.length - 1] === null && (t[t.length - 1] = 1);
+    for (let n = 1; n < t.length; n += 1) {
+      if (t[n] !== null) continue;
+      let i = n;
+      for (; t[i] === null; ) i += 1;
+      let r = t[n - 1], s = (t[i] - r) / (i - n + 1);
+      for (let o = n; o < i; o += 1) t[o] = r + s * (o - n + 1);
+    }
+    return t.map((n, i, r) => i === 0 ? n : Math.max(n, r[i - 1]));
+  }
+  function Ge(e) {
+    let t = [], n = [];
+    for (let r of e.split(",")) {
+      let s = r.trim().split(/\s+/).filter(Boolean), o = Number(s[0]);
+      if (!Number.isFinite(o)) return null;
+      let a = s.slice(1);
+      if (a.length > 2) return null;
+      if (a.length === 0) {
+        t.push(o), n.push(null);
+        continue;
+      }
+      for (let u of a) {
+        if (!u.endsWith("%")) return null;
+        let c = Number(u.slice(0, -1));
+        if (!Number.isFinite(c)) return null;
+        t.push(o), n.push(c / 100);
+      }
+    }
+    if (t.length < 2) return null;
+    let i = We(n);
+    return (r) => {
+      if (r <= i[0]) return t[0];
+      let s = i.length - 1;
+      if (r >= i[s]) return t[s];
+      let o = 0;
+      for (; o < s && i[o + 1] < r; ) o += 1;
+      let a = i[o + 1] - i[o];
+      return a === 0 ? t[o + 1] : t[o] + (t[o + 1] - t[o]) * (r - i[o]) / a;
+    };
+  }
+  function Vt(e) {
+    let t = e.trim().toLowerCase(), n = Be[t];
+    if (n) return Qt(...n);
+    let i = /^cubic-bezier\(([^)]*)\)$/.exec(t);
+    if (i) {
+      let s = i[1].split(",").map((o) => Number(o.trim()));
+      return s.length !== 4 || s.some((o) => !Number.isFinite(o)) ? null : Qt(s[0], s[1], s[2], s[3]);
+    }
+    let r = /^linear\(([^)]*)\)$/.exec(t);
+    return r ? Ge(r[1]) : null;
+  }
+  var St = 1e-4;
+  function Mt(e, t) {
+    let n = Math.min(Math.max(t, 0), 1 - St);
+    return (e(n + St) - e(n)) / St;
+  }
+  function lt(e, t) {
+    return e * t;
+  }
+  function X(e) {
+    let t = getComputedStyle(e).transform;
+    if (!t || t === "none") return { tx: 0, ty: 0 };
+    let n = t.match(/matrix\(([^)]+)\)/);
+    if (!n) return { tx: 0, ty: 0 };
+    let i = n[1].split(",").map(Number);
+    return { tx: i[4] || 0, ty: i[5] || 0 };
+  }
+  function et(e) {
+    let t = getComputedStyle(e), n = parseFloat(t.width), i = parseFloat(t.height);
+    if (Number.isNaN(n) || Number.isNaN(i)) {
+      let r = e.getBoundingClientRect();
+      return { width: r.width, height: r.height };
+    }
+    return { width: n, height: i };
+  }
+  function j(e) {
+    let { tx: t, ty: n } = X(e), i = Number(getComputedStyle(e).opacity) || 1;
+    return e.getAnimations().forEach((r) => r.cancel()), { tx: t, ty: n, opacity: i };
+  }
+  var Ue = 8;
+  var Ke = 0.1;
+  var Ye = 0.5;
+  var je = 0.5;
+  var ee = () => performance.now();
+  function ze(e, t) {
+    let n = Math.max(0, Math.min(Ue, t) - Mt(e, 0));
+    if (!(n > 0)) return { curve: e, k: 0 };
+    let i = Math.max(3, Math.ceil(n / (Math.E * Ke)) - 1);
+    return { curve: (r) => r >= 1 ? 1 : e(r) + n * r * Math.pow(1 - r, i), k: n };
+  }
+  function qe(e, t) {
+    let n = Math.min(120, Math.max(32, Math.round(t / 8))), i = [];
+    for (let r = 0; r < n; r += 1) {
+      let s = r / (n - 1), o = r === n - 1 ? 1 : e(s);
+      i.push(`${Math.round(o * 1e4) / 1e4}`);
+    }
+    return `linear(${i.join(", ")})`;
+  }
+  function Zt(e, t, n, i, r, s, o, a) {
+    let u = (m, d, h, M, x) => {
+      let T = e.animate([{ [t]: `${m}px` }, { [t]: `${d}px` }], { duration: s, easing: h, fill: "both" });
+      return x !== void 0 && (T.currentTime = x), { anim: T, from: m, to: d, easing: h, curve: M, startedAt: ee() - (x ?? 0) };
+    };
+    if (r && r.elapsed !== null && Math.abs(r.to - i) < je) return u(r.from, r.to, r.easing, r.curve, r.elapsed);
+    let c = i - n, f = o, l = a;
+    if (a && Math.abs(c) > Ye) {
+      let m = ze(a, (r?.velocity ?? 0) * s / c);
+      m.k > 0 && (l = m.curve, f = qe(m.curve, s));
+    }
+    return u(n, i, f, l);
+  }
+  function te(e, t) {
+    let n = e.anim.currentTime === null, i = ee() - e.startedAt, s = n || !Number.isFinite(i) || i >= t || i < 0 ? null : i;
+    return { from: e.from, to: e.to, easing: e.easing, curve: e.curve, elapsed: s, velocity: s === null || !e.curve ? 0 : (e.to - e.from) * Mt(e.curve, s / t) / t };
+  }
+  var D = /* @__PURE__ */ new WeakMap();
+  function Je(e) {
+    return D.get(e)?.snapshot();
+  }
+  function ut(e) {
+    e.style.width = "", e.style.height = "", e.style.transitionProperty = "";
+  }
+  function ne(e) {
+    let t = D.get(e);
+    t && (D.delete(e), t.stop(), t.onCancel?.());
+  }
+  function re(e) {
+    let t = D.get(e);
+    t && (D.delete(e), t.stop()), ut(e);
+  }
+  function ie(e, t, n, i, r, s, o) {
+    let a = Je(e);
+    if (ne(e), t === 0 || n === 0) {
+      ut(e), o?.();
+      return;
+    }
+    e.style.transitionProperty = "none", e.style.width = "", e.style.height = "", e.offsetWidth;
+    let { width: u, height: c } = et(e), f = Vt(r), l = Zt(e, "width", t, u, a?.width, i, r, f), m = Zt(e, "height", n, c, a?.height, i, r, f), d = () => {
+      l.anim.cancel(), m.anim.cancel();
+    };
+    l.anim.onfinish = () => {
+      D.delete(e), d(), ut(e), s?.();
+    }, D.set(e, { stop: d, onCancel: o, snapshot: () => ({ width: te(l, i), height: te(m, i) }) });
+  }
+  function se(e, t, n, i, r, s) {
+    ne(e), e.style.transitionProperty = "none", e.style.width = `${t}px`, e.style.height = `${n}px`;
+    let o = setTimeout(() => {
+      D.delete(e), ut(e), r?.();
+    }, i), a = (u) => ({ from: u, to: u, easing: "linear", curve: null, elapsed: null, velocity: 0 });
+    D.set(e, { stop: () => clearTimeout(o), onCancel: s, snapshot: () => ({ width: a(t), height: a(n) }) });
+  }
+  function ct(e) {
+    let t = Array.from(e.children), n = {}, i = e.getBoundingClientRect();
+    return t.forEach((r, s) => {
+      if (r.hasAttribute(H) || r.hasAttribute(P) || r.tagName === "BR") return;
+      let o = r.getAttribute(w) || `child-${s}`, a = r.getBoundingClientRect(), { tx: u, ty: c } = X(r);
+      n[o] = { x: a.left - i.left - u, y: a.top - i.top - c };
+    }), n;
+  }
+  function Tt(e, t, n) {
+    let i = e[n], r = t[n];
+    return !i || !r ? { dx: 0, dy: 0 } : { dx: i.x - r.x, dy: i.y - r.y };
+  }
+  function Et(e, t, n, i = "backward-first") {
+    let [r, s] = i === "backward-first" ? ["backward", "forward"] : ["forward", "backward"], o = (a) => {
+      if (a === "backward") {
+        for (let u = e - 1; u >= 0; u--) if (n.has(t[u])) return t[u];
+      } else for (let u = e + 1; u < t.length; u++) if (n.has(t[u])) return t[u];
+      return null;
+    };
+    return o(r) ?? o(s);
+  }
+  function oe(e, t, n, i) {
+    let r = new Set(n.filter((o, a) => i.has(o) && !t.has(e[a]))), s = /* @__PURE__ */ new Map();
+    for (let o = 0; o < e.length; o++) {
+      let a = e[o];
+      t.has(a) && s.set(a, Et(o, n, r, "forward-first"));
+    }
+    return s;
+  }
+  function ae(e, t) {
+    let { dx: n, dy: i, duration: r, ease: s, scale: o } = t;
+    e.animate({ transform: o ? `translate(${n}px, ${i}px) scale(0.95)` : `translate(${n}px, ${i}px)`, offset: 1 }, { duration: r, easing: s, fill: "both" });
+    let a = e.animate({ opacity: 0, offset: 1 }, { duration: lt(r, 0.25), easing: "linear", fill: "both" });
+    a.onfinish = () => e.remove();
+  }
+  function ue(e, t) {
+    let { deltaX: n, deltaY: i, isNew: r, duration: s, ease: o } = t, a = j(e), u = n + a.tx, c = i + a.ty, f = r && a.opacity >= 1 ? 0 : a.opacity;
+    e.animate([{ transform: `translate(${u}px, ${c}px) scale(${r ? 0.95 : 1})` }, { transform: "none" }], { duration: s, easing: o, fill: "both" }), f < 1 && e.animate([{ opacity: f }, { opacity: 1 }], { duration: lt(s, r ? 0.5 : 0.25), delay: r ? lt(s, 0.25) : 0, easing: "linear", fill: "both" });
+  }
+  function Qe(e, t) {
+    let n = 0, i = 0;
+    for (let r = e; r && r !== t; r = r.offsetParent) n += r.offsetLeft, i += r.offsetTop;
+    return { x: n, y: i };
+  }
+  function At(e, t) {
+    let n = document.createElement(e);
+    return n.setAttribute(Q, ""), n.setAttribute(w, t), n.setAttribute("aria-hidden", "true"), n;
+  }
+  function le(e, t) {
+    let n = /* @__PURE__ */ new Map();
+    for (let i of t) {
+      if (i.tagName === "BR") continue;
+      let { x: r, y: s } = Qe(i, e), { tx: o, ty: a } = X(i), { width: u, height: c } = et(i), f = Number(getComputedStyle(i).opacity) || 1;
+      i.getAnimations().forEach((l) => l.cancel()), n.set(i, { left: r + o, top: s + a, width: u, height: c, opacity: f });
+    }
+    for (let i = t.length - 1; i >= 0; i--) t[i].tagName === "BR" && (t[i].remove(), t.splice(i, 1));
+    t.forEach((i) => {
+      let r = n.get(i);
+      i.setAttribute(H, ""), i.style.position = "absolute", i.style.pointerEvents = "none", i.style.left = `${r.left}px`, i.style.top = `${r.top}px`, i.style.width = `${r.width}px`, i.style.height = `${r.height}px`, i.style.opacity = String(r.opacity);
+    });
+  }
+  function ce(e, t) {
+    if (t.size === 0) return;
+    let n = Array.from(e.children), i = /* @__PURE__ */ new Set();
+    for (let r of n) {
+      if (r.hasAttribute(H)) continue;
+      let s = r.getAttribute(w);
+      if (!s || i.has(s)) continue;
+      let o = t.get(s);
+      if (o) {
+        i.add(s);
+        for (let a of o) {
+          let u = At("span", a.id);
+          wt(u, a), r.before(u);
+        }
+        r.remove();
+      }
+    }
+  }
+  function wt(e, t) {
+    if (!t.kind) {
+      e.removeAttribute(V), e.removeAttribute(F), e.textContent = t.string;
+      return;
+    }
+    e.setAttribute(V, t.kind), e.setAttribute(F, "");
+    let n = e.firstElementChild;
+    n || (e.textContent = "", n = document.createElement("span"), e.appendChild(n)), n.textContent = t.string;
+  }
+  function vt(e) {
+    return e.hasAttribute(F) ? e.firstElementChild ?? e : e;
+  }
+  function me(e, t, n, i) {
+    let r = /* @__PURE__ */ new Map();
+    t.forEach((s) => {
+      let o = s.getAttribute(w);
+      n.has(o) && !s.hasAttribute(H) && (r.set(o, s), s.remove());
+    }), Array.from(e.childNodes).forEach((s) => {
+      s.nodeType === Node.TEXT_NODE && s.remove();
+    }), i.forEach((s) => {
+      let o = r.get(s.id);
+      if (o && r.delete(s.id), s.string === `
+`) {
+        o && o.tagName === "BR" ? e.appendChild(o) : e.appendChild(At("br", s.id));
+        return;
+      }
+      if (o && o.tagName !== "BR") o.style.transformOrigin = "", wt(o, s), e.appendChild(o);
+      else {
+        let a = At("span", s.id);
+        wt(a, s), e.appendChild(a);
+      }
+    });
+  }
+  var Ve = 0.45;
+  var Ze = 0.25;
+  function pe(e, t) {
+    let { dx: n, dy: i, slideDistance: r, duration: s, ease: o } = t, a = vt(e);
+    e.animate({ transform: `translate(${n}px, ${i}px)`, offset: 1 }, { duration: s, easing: o, fill: "both" }), a.animate({ transform: `translate(0px, ${r}px)`, offset: 1 }, { duration: s, easing: o, fill: "both" });
+    let u = a.animate({ opacity: 0, offset: 1 }, { duration: s * Ve, easing: "linear", fill: "both" });
+    u.onfinish = () => e.remove();
+  }
+  function fe(e, t) {
+    let { deltaX: n, deltaY: i, slideDistance: r, kind: s, duration: o, ease: a } = t;
+    Rt(e, { deltaX: n, deltaY: i, duration: o, ease: a });
+    let u = vt(e), c = j(u), f = s === "digit" ? -r : r;
+    u.animate({ transform: `translate(0px, ${c.ty + f}px)`, offset: 0 }, { duration: o, easing: a, fill: "both" });
+    let l = c.opacity >= 1 ? 0 : c.opacity;
+    l < 1 && u.animate([{ opacity: l }, { opacity: 1 }], { duration: o * Ze, easing: "linear", fill: "both" });
+  }
+  function Rt(e, t) {
+    let { deltaX: n, deltaY: i, duration: r, ease: s } = t, { tx: o, ty: a } = X(e);
+    e.getAnimations().forEach((f) => f.cancel());
+    let u = n + o, c = i + a;
+    u === 0 && c === 0 || e.animate({ transform: `translate(${u}px, ${c}px)`, offset: 0 }, { duration: r, easing: s, fill: "both" });
+  }
+  var tn = 6;
+  var de = 0.8;
+  var en = 0.45;
+  var nn = 0.35;
+  function he(e) {
+    let t = e.map((u) => u.getBoundingClientRect()), n = Math.min(...t.map((u) => u.left)), i = Math.max(...t.map((u) => u.right)), r = Math.min(...t.map((u) => u.top)), s = Math.max(...t.map((u) => u.bottom)), o = (n + i) / 2, a = (r + s) / 2;
+    return t.map((u) => `${o - u.left}px ${a - u.top}px`);
+  }
+  function ge(e, t) {
+    let { duration: n, ease: i } = t, r = he(e);
+    e.forEach((s, o) => {
+      s.getAnimations().forEach((u) => u.cancel()), s.style.transformOrigin = r[o], s.animate({ transform: `scale(${de})`, offset: 1 }, { duration: n, easing: i, fill: "both" });
+      let a = s.animate({ opacity: 0, offset: 1 }, { duration: n * en, easing: "linear", fill: "both" });
+      a.onfinish = () => s.remove();
+    });
+  }
+  function be(e, t) {
+    let { duration: n, ease: i } = t, r = he(e);
+    e.forEach((s, o) => {
+      let a = j(s);
+      s.style.transformOrigin = r[o], s.animate({ transform: `scale(${de})`, offset: 0 }, { duration: n, easing: i, fill: "both" });
+      let u = a.opacity >= 1 ? 0 : a.opacity;
+      s.animate([{ opacity: u }, { opacity: 1 }], { duration: n * nn, easing: "linear", fill: "both" });
+    });
+  }
+  function It(e, t) {
+    let n = [], i = [], r = () => {
+      i.length >= tn && n.push(i), i = [];
+    };
+    for (let s of e) t.has(s) ? i.push(s) : r();
+    return r(), n;
+  }
+  var rn = "\0#";
+  function xe(e, t) {
+    if (e.segments.length !== 1 || e.word.length <= 1) return e.segments;
+    let n = e.segments[0], i = e.word.split("").map((r, s) => ({ id: `${n.id}:${s}`, string: r }));
+    return t.set(n.id, i), i;
+  }
+  function sn(e) {
+    return e.map((t) => ({ ...t, kind: t.kind ?? at(t.string) }));
+  }
+  function on(e, t) {
+    if (e.length === 0 || t.length === 0) return 0;
+    let [n] = G(e.split(""), t.split(""));
+    return n.length / Math.max(e.length, t.length);
+  }
+  function ye(e, t) {
+    let n = [], i = 0;
+    for (let r = 0; r < e; r++) n.push(i), t.has(r) && i++;
+    return n;
+  }
+  var an = 0.4;
+  function un(e, t) {
+    return (q(e) || q(t)) && gt(e) === gt(t) ? 1 : on(e, t);
+  }
+  var ln = 2500;
+  var cn = 1e6;
+  function Lt(e, t, n, i = {}) {
+    let r = t.includes(" "), s = t.includes(`
+`), o = zt(e), a = i.numbers !== false, u = (p) => a && J(p), c = (p) => u(p) ? rn : p, f = a && (q(t) || o.some((p) => q(p.word)));
+    if (o.length <= 1 && !r && !s && !f) return { segments: K(t, n, a), splits: /* @__PURE__ */ new Map() };
+    let l = [], m = [], d = t.split(/( |\n)/), h = [];
+    for (let p of d) p === " " || p === `
+` ? h.push(p) : p.length > 0 && (m.push(h), l.push(p), h = []);
+    let M = h, x = o.map((p) => p.word);
+    if (x.length * l.length > cn) return { segments: K(t, n, a), splits: /* @__PURE__ */ new Map() };
+    let [T, L] = G(x.map(c), l.map(c)), E = new Set(T), N = new Set(L), g = /* @__PURE__ */ new Map();
+    for (let p = 0; p < L.length; p++) g.set(L[p], T[p]);
+    let v = x.map((p, b) => b).filter((p) => !E.has(p)), R = l.map((p, b) => b).filter((p) => !N.has(p)), O = /* @__PURE__ */ new Set();
+    for (let p of R) for (let b of v) if (!O.has(b) && c(l[p]) === c(x[b])) {
+      g.set(p, b), O.add(b);
+      break;
+    }
+    O.size > 0 && (v = v.filter((p) => !O.has(p)), R = R.filter((p) => !g.has(p)));
+    let A = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Set(), B = ye(x.length, E), rt = ye(l.length, N);
+    if (v.length * R.length <= ln) for (let p of R) {
+      let b = -1, S = an;
+      for (let y of v) {
+        if (_.has(y) || B[y] !== rt[p]) continue;
+        let it = un(x[y], l[p]);
+        it > S && (S = it, b = y);
+      }
+      b >= 0 && (A.set(p, b), _.add(b));
+    }
+    let pt = l.map((p, b) => {
+      let S = g.get(b), y = S ?? A.get(b);
+      return y === void 0 ? { mode: "fresh" } : u(p) ? { mode: "number", oi: y } : S !== void 0 ? { mode: "reuse", oi: y } : { mode: "morph", oi: y };
+    }), kt = pt.filter((p) => p.mode === "number").length === 1 ? i.cursorIndex : void 0, Ae = xt(n), W = yt();
+    for (let p of pt) {
+      if (p.mode === "fresh") continue;
+      let b = o[p.oi];
+      if (p.mode !== "reuse" && b.segments.length === 1) {
+        let S = b.segments[0];
+        for (let y = 0; y < b.word.length; y++) W.reserve(`${S.id}:${y}`);
+      } else for (let S of b.segments) W.reserve(S.id);
+    }
+    let $ = [], ft = /* @__PURE__ */ new Map(), z = 0;
+    function Ht(p) {
+      for (let b of p) b === `
+` ? $.push({ id: W.take(`newline-${z}`), string: `
+` }) : $.push({ id: W.take(`space-${z}`), string: "\xA0" }), z++;
+    }
+    for (let p = 0; p < l.length; p++) {
+      Ht(m[p] ?? (p > 0 ? [" "] : []));
+      let b = pt[p], S = l[p];
+      if (b.mode === "reuse") for (let y of o[b.oi].segments) $.push(y);
+      else if (b.mode === "number") {
+        let y = o[b.oi];
+        $.push(...U(S, sn(xe(y, ft)), kt === void 0 ? void 0 : kt - z, Ae));
+      } else if (b.mode === "morph") {
+        let y = o[b.oi], it = y.word, we = xe(y, ft), ve = it.split(""), st = S.split(""), [Re, Ot] = G(ve, st), dt = /* @__PURE__ */ new Map();
+        for (let I = 0; I < Ot.length; I++) {
+          let ot = we[Re[I]];
+          ot && dt.set(Ot[I], ot);
+        }
+        for (let I = 0; I < st.length; I++) if (dt.has(I)) {
+          let ot = dt.get(I);
+          $.push({ id: ot.id, string: st[I] });
+        } else $.push({ id: W.take(`${S}~${I}`), string: st[I] });
+      } else u(S) ? $.push(...U(S)) : $.push({ id: W.take(S), string: S });
+      z += S.length;
+    }
+    return Ht(M), { segments: $, splits: ft };
+  }
+  var mn = `
+[${Y}] {
+  display: inline-block;
+  position: relative;
+  vertical-align: top;
+  will-change: width, height;
+  white-space: nowrap;
+  text-align: inherit;
+}
+
+[${Q}]:not(br) {
+  display: inline-block;
+  position: relative;
+  will-change: opacity, transform;
+  transform: none;
+  opacity: 1;
+}
+
+/*
+ * The value once as plain text \u2014 every other child is an aria-hidden fragment.
+ * Out of flow, because the engine measures every child of the root. Clipped
+ * rather than display: none, which would take it out of the a11y tree as well.
+ * user-select: none, or a copied selection pastes the value twice.
+ */
+[${P}] {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  border: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: pre;
+  -webkit-user-select: none;
+  user-select: none;
+}
+
+/*
+ * A digit slides a whole line box to arrive, so it needs its own box to hide
+ * behind. Not the root: that spans every line, so clipping there leaves a digit
+ * on a middle line sliding over its neighbour in view. The transform sits on the
+ * child, so the slide never touches the slot's rect and the FLIP pass stays
+ * oblivious. clip-path, not overflow \u2014 an inline-block whose overflow is
+ * anything but visible has its baseline synthesized to the bottom margin edge
+ * (CSS 2.1 \xA710.8.1), and engines disagree on whether overflow: clip counts.
+ * The inline axis stays open so glyph overhang is not shaved.
+ */
+[${F}] {
+  clip-path: inset(0 -100vw);
+}
+
+[${F}] > span {
+  display: inline-block;
+  will-change: opacity, transform;
+}
+
+/*
+ * Softens the clip above into a gradient, positionally rather than on a timer, so
+ * it stays in step with the slide at any duration. The band (--torph-fade, 0 for a
+ * hard edge) must eat into the box: the clip trims at the border box, so a ramp
+ * reaching past it sits in territory already removed and is never seen. no-clip
+ * plus repeat-x is what carries the profile across glyph overhang.
+ */
+@supports (mask-clip: no-clip) or (-webkit-mask-clip: no-clip) {
+  [${F}] {
+    --torph-mask: linear-gradient(
+      to bottom,
+      transparent,
+      #000 var(--torph-fade, 0.15em),
+      #000 calc(100% - var(--torph-fade, 0.15em)),
+      transparent
+    );
+    -webkit-mask-image: var(--torph-mask);
+    mask-image: var(--torph-mask);
+    -webkit-mask-repeat: repeat-x;
+    mask-repeat: repeat-x;
+    -webkit-mask-clip: no-clip;
+    mask-clip: no-clip;
+  }
+}
+
+[${Y}][${Z}] {
+  outline: 2px solid magenta;
+  [${Q}] {
+    outline: 2px solid cyan;
+    outline-offset: -4px;
+  }
+}`;
+  var C = null;
+  var Nt = 0;
+  function Se() {
+    Nt++, !C && (C = document.createElement("style"), C.dataset.torph = "true", C.textContent = mn, document.head.appendChild(C));
+  }
+  function Me() {
+    Nt--, !(Nt > 0 || !C) && (C.remove(), C = null);
+  }
+  function Te() {
+    if (typeof window > "u") return { prefersReducedMotion: false, destroy: () => {
+    } };
+    let e = window.matchMedia("(prefers-reduced-motion: reduce)"), t = { prefersReducedMotion: e.matches, destroy: i };
+    function n(r) {
+      t.prefersReducedMotion = r.matches;
+    }
+    function i() {
+      e.removeEventListener("change", n);
+    }
+    return e.addEventListener("change", n), t;
+  }
+  var Ee = { ..._t, debug: false, scale: true, numbers: true };
+  var nt = class {
+    element;
+    options = {};
+    data;
+    currentMeasures = {};
+    prevMeasures = {};
+    previousSegments = [];
+    isInitialRender = true;
+    reducedMotion = null;
+    srNode = null;
+    hasSetup = false;
+    constructor(t) {
+      let n = Object.fromEntries(Object.entries(t).filter(([, a]) => a !== void 0)), { ease: i, ...r } = { ...Ee, ...n }, { ease: s, duration: o } = Ft(i, r.duration);
+      this.options = { ...r, ease: s, duration: o }, this.element = t.element, this.options.respectReducedMotion && (this.reducedMotion = Te()), this.data = "", this.isDisabled() || this.setup();
+    }
+    setup() {
+      this.hasSetup || (this.hasSetup = true, this.element.setAttribute(Y, ""), this.options.debug && this.element.setAttribute(Z, ""), Se());
+    }
+    destroy() {
+      this.reducedMotion?.destroy(), re(this.element), this.element.getAnimations().forEach((t) => t.cancel()), this.srNode?.remove(), this.srNode = null, this.element.removeAttribute(Y), this.element.removeAttribute(Z), this.hasSetup && (this.hasSetup = false, Me());
+    }
+    isDisabled() {
+      return !!(this.options.disabled || this.reducedMotion?.prefersReducedMotion);
+    }
+    update(t, n) {
+      let i = typeof t == "number" ? t.toLocaleString(this.options.locale, { minimumFractionDigits: this.options.decimals, maximumFractionDigits: this.options.decimals }) : t;
+      if (i !== this.data) {
+        if (this.data = i, this.isDisabled()) {
+          typeof i == "string" && (this.srNode = null, this.element.textContent = i, this.previousSegments = [], this.isInitialRender = true);
+          return;
+        }
+        if (this.setup(), this.data instanceof HTMLElement) throw new Error("HTMLElement not yet supported");
+        this.options.onAnimationStart && !this.isInitialRender && this.options.onAnimationStart(), this.createTextGroup(this.data, this.element, n);
+      }
+    }
+    createTextGroup(t, n, i) {
+      let { width: r, height: s } = et(n), o = this.options.numbers !== false;
+      this.syncAccessibleText(t);
+      let a, u;
+      if (this.previousSegments.length > 0) {
+        let g = Lt(this.previousSegments, t, this.options.locale, { numbers: o, cursorIndex: i });
+        a = g.segments, u = g.splits;
+      } else a = K(t, this.options.locale, o), u = /* @__PURE__ */ new Map();
+      let c = a.length === 0;
+      c && (a = [{ id: tt, string: "\u200B" }]), ce(n, u), this.prevMeasures = ct(this.element);
+      let f = Array.from(n.children).filter((g) => !g.hasAttribute(P)), l = new Set(a.map((g) => g.id)), m = f.filter((g) => !l.has(g.getAttribute(w)) && !g.hasAttribute(H)), d = new Set(m), h = f.map((g) => g.getAttribute(w)), M = oe(f, d, h, l);
+      le(n, m), me(n, f, l, a), this.currentMeasures = ct(this.element);
+      let x = a.reduce((g, v) => v.string === `
+` ? g + 1 : g, 1), T = (n.offsetHeight || 20 * x) / x;
+      n.style.width = `${r}px`, n.offsetWidth;
+      let L = ct(this.element);
+      n.style.width = "", this.updateStyles(a, L, T);
+      let E = this.isInitialRender ? [] : It(f, new Set(m)), N = new Set(E.flat());
+      for (let g of E) ge(g, { duration: this.options.duration, ease: this.options.ease });
+      if (m.forEach((g) => {
+        if (this.isInitialRender || g.getAttribute(w) === tt) {
+          g.remove();
+          return;
+        }
+        if (N.has(g)) return;
+        let v = M.get(g), { dx: R, dy: O } = v ? Tt(this.currentMeasures, this.prevMeasures, v) : { dx: 0, dy: 0 };
+        g.hasAttribute(V) ? pe(g, { dx: R, dy: O, slideDistance: T, duration: this.options.duration, ease: this.options.ease }) : ae(g, { dx: R, dy: O, duration: this.options.duration, ease: this.options.ease, scale: this.options.scale });
+      }), this.previousSegments = a, this.isInitialRender) {
+        this.isInitialRender = false, n.style.width = "", n.style.height = "";
+        return;
+      }
+      c ? se(n, r, s, this.options.duration, this.options.onAnimationComplete, this.options.onAnimationCancel) : ie(n, r, s, this.options.duration, this.options.ease, this.options.onAnimationComplete, this.options.onAnimationCancel);
+    }
+    updateStyles(t, n, i) {
+      if (this.isInitialRender) return;
+      let r = Array.from(this.element.children).filter((l) => !l.hasAttribute(P)), s = t.map((l) => l.id), o = new Map(t.map((l) => [l.id, l.kind])), a = r.filter((l) => !l.hasAttribute(H) && l.tagName !== "BR" && l.getAttribute(w) !== tt), u = new Set(a.filter((l) => !this.prevMeasures[l.getAttribute(w)])), c = /* @__PURE__ */ new Set();
+      for (let l of It(a, u)) l.forEach((m) => c.add(m)), be(l, { duration: this.options.duration, ease: this.options.ease });
+      let f = new Set(s.filter((l) => this.prevMeasures[l]));
+      r.forEach((l, m) => {
+        if (l.hasAttribute(H) || l.tagName === "BR" || c.has(l)) return;
+        let d = l.getAttribute(w) || `child-${m}`;
+        if (d === tt) return;
+        let h = !this.prevMeasures[d], M = h ? Et(t.findIndex((E) => E.id === d), s, f) : d, { dx: x, dy: T } = M ? Tt(this.prevMeasures, n, M) : { dx: 0, dy: 0 }, L = o.get(d);
+        L && h ? fe(l, { deltaX: x, deltaY: T, slideDistance: i, kind: L, duration: this.options.duration, ease: this.options.ease }) : L ? Rt(l, { deltaX: x, deltaY: T, duration: this.options.duration, ease: this.options.ease }) : ue(l, { deltaX: x, deltaY: T, isNew: h, duration: this.options.duration, ease: this.options.ease });
+      });
+    }
+    syncAccessibleText(t) {
+      if (!this.srNode || this.srNode.parentNode !== this.element) {
+        let n = document.createElement("span");
+        n.setAttribute(P, ""), this.element.prepend(n), this.srNode = n;
+      }
+      this.srNode.textContent = t;
+    }
+  };
+
+  // ../probe/src/index.ts
+  var MAX_CANDIDATES = 4;
+  var SEL_ATTR = "data-bp-sel";
+  var OVERLAY_ID = "__bp_overlay__";
+  var SPOT_ATTR = "data-bp-spot";
+  var SPOT_STYLE_ID = "__bp_spotlight__";
+  var NON_VISUAL = /* @__PURE__ */ new Set(["head", "script", "style", "link", "meta", "title", "template", "noscript", "base"]);
+  var MAX_FIBER_WALK = 500;
+  var PORTAL_SCAN = 200;
+  var MAX_SCAN = 6e3;
+  var MAX_TREE = 800;
+  function emit(type, payload) {
+    try {
+      window.__bpEmit?.(JSON.stringify({ type, payload, t: performance.now() }));
+    } catch {
+    }
+  }
+  function mountRoot() {
+    return document.body ?? document.documentElement;
+  }
+  function pathOf(el) {
+    const mount = mountRoot();
+    const segments = [];
+    let node = el;
+    while (node && node !== mount) {
+      const parent = node.parentElement;
+      if (!parent) return null;
+      segments.unshift(Array.prototype.indexOf.call(parent.children, node));
+      node = parent;
+    }
+    return node === mount ? segments.join("/") : null;
+  }
+  function hasOwnText(el) {
+    for (const node of Array.from(el.childNodes)) {
+      if (node.nodeType === 3 && (node.nodeValue ?? "").trim() !== "") return true;
+    }
+    return false;
+  }
+  function elementAt(path) {
+    const mount = mountRoot();
+    if (path === "") return mount;
+    let node = mount;
+    for (const seg of path.split("/")) {
+      const next = node.children[Number(seg)];
+      if (!next) return null;
+      node = next;
+    }
+    return node;
+  }
+  function rectOf(el) {
+    const b = el.getBoundingClientRect();
+    return { x: b.left, y: b.top, w: b.width, h: b.height };
+  }
+  var RADIUS_PROPS = [
+    "borderTopLeftRadius",
+    "borderTopRightRadius",
+    "borderBottomRightRadius",
+    "borderBottomLeftRadius"
+  ];
+  function radiiOf(el, rect) {
+    if (!(el instanceof HTMLElement) || !el.isConnected) return [0, 0, 0, 0];
+    const cs = getComputedStyle(el);
+    const w2 = el.offsetWidth;
+    const h = el.offsetHeight;
+    if (w2 <= 0 || h <= 0) return [0, 0, 0, 0];
+    const r = RADIUS_PROPS.map((prop) => {
+      const v = cs[prop].split(" ")[0];
+      const n = parseFloat(v);
+      if (!(n > 0)) return 0;
+      return v.endsWith("%") ? n / 100 * w2 : n;
+    });
+    const [tl, tr, br, bl] = r;
+    const f = Math.min(1, w2 / (tl + tr || 1), w2 / (bl + br || 1), h / (tl + bl || 1), h / (tr + br || 1));
+    const k2 = rect.w / w2;
+    return r.map((v) => v * f * k2);
+  }
+  function targetOf(el) {
+    const rect = rectOf(el);
+    return { rect, radii: radiiOf(el, rect) };
+  }
+  var fiberKey = null;
+  function fiberOf(el) {
+    if (fiberKey !== null) {
+      const hit = el[fiberKey];
+      if (hit) return hit;
+    }
+    for (const key of Object.keys(el)) {
+      if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+        fiberKey = key;
+        return el[key];
+      }
+    }
+    return null;
+  }
+  function fiberName(type) {
+    if (typeof type === "function") {
+      const fn = type;
+      const name = fn.displayName || fn.name;
+      if (!name || name === "_c" || name.includes(".")) return null;
+      return name;
+    }
+    if (type && typeof type === "object") {
+      const o = type;
+      if (o.displayName && !o.displayName.includes(".")) return o.displayName;
+      if (o.render) return fiberName(o.render);
+      if (o.type) return fiberName(o.type);
+      if (o.displayName) return null;
+    }
+    return null;
+  }
+  function nearestComponent(el) {
+    let f = fiberOf(el);
+    while (f) {
+      const name = fiberName(f.type);
+      if (name) return { fiber: f, name };
+      f = f.return;
+    }
+    return null;
+  }
+  function componentFiber(el) {
+    let f = fiberOf(el);
+    while (f) {
+      if (fiberName(f.type)) return f;
+      f = f.return;
+    }
+    return null;
+  }
+  function componentRoot(el) {
+    const f = componentFiber(el);
+    if (!f) return null;
+    const mount = mountRoot();
+    let root = el;
+    while (root.parentElement && root.parentElement !== mount && componentFiber(root.parentElement) === f) {
+      root = root.parentElement;
+    }
+    return root;
+  }
+  function componentNameOf(el) {
+    return nearestComponent(el)?.name ?? void 0;
+  }
+  function identityOf(el) {
+    const near = nearestComponent(el);
+    if (!near) return void 0;
+    const root = componentRoot(el);
+    if (!root) return void 0;
+    const rootPath = pathOf(root);
+    if (rootPath === null) return void 0;
+    const owner = root.parentElement && mountRoot().contains(root.parentElement) ? root.parentElement : mountRoot();
+    const peers = [];
+    let ambiguous = false;
+    const firstType = componentFiber(root)?.type;
+    let scanned = 0;
+    const all = owner.querySelectorAll("*");
+    for (const node of Array.from(all)) {
+      if (++scanned > MAX_SCAN) break;
+      const nc = nearestComponent(node);
+      if (!nc || nc.name !== near.name) continue;
+      if (componentRoot(node) !== node) continue;
+      if (componentFiber(node)?.type !== firstType) ambiguous = true;
+      peers.push(node);
+    }
+    if (!peers.includes(root)) peers.push(root);
+    peers.sort((a, b) => comparePaths(pathOf(a) ?? "", pathOf(b) ?? ""));
+    const discriminant = discriminantOf(peers, root);
+    return {
+      key: `${near.name}@${pathOf(owner) ?? ""}`,
+      name: near.name,
+      kind: "component",
+      index: peers.indexOf(root),
+      count: peers.length,
+      rootPath,
+      ...ambiguous ? { ambiguous: true } : {},
+      ...discriminant ? { variant: discriminant.variant, variantCount: discriminant.count } : {}
+    };
+  }
+  var VARIANT_SKIP = ["children", "className", "class", "style", "key", "ref", "id"];
+  var VARIANT_PREFERRED = ["variant", "kind", "type", "mode", "appearance", "intent", "tone", "status", "state", "size", "color"];
+  function variantValue(v) {
+    if (typeof v === "string") return v.length > 0 && v.length <= 32 ? v : null;
+    if (typeof v === "number" || typeof v === "boolean") return String(v);
+    return null;
+  }
+  function propsOf(el) {
+    const props = componentFiber(el)?.memoizedProps;
+    return props && typeof props === "object" ? props : {};
+  }
+  function matchesVariant(root, variant) {
+    return variantValue(propsOf(root)[variant.prop]) === variant.value;
+  }
+  function discriminantOf(peers, root) {
+    if (peers.length < 2) return void 0;
+    const props = peers.map(propsOf);
+    const mine = props[peers.indexOf(root)];
+    if (!mine) return void 0;
+    const candidates = [];
+    for (const prop of Object.keys(mine)) {
+      if (VARIANT_SKIP.indexOf(prop) !== -1 || prop.slice(0, 2) === "on") continue;
+      const own = variantValue(mine[prop]);
+      if (own === null) continue;
+      const values = props.map((p) => variantValue(p[prop]));
+      if (values.some((v) => v === null)) continue;
+      const distinct = [];
+      for (const v of values) if (v !== null && distinct.indexOf(v) === -1) distinct.push(v);
+      if (distinct.length < 2) continue;
+      candidates.push({ prop, value: own });
+    }
+    if (candidates.length === 0) return void 0;
+    const rank = (prop) => {
+      const at2 = VARIANT_PREFERRED.indexOf(prop);
+      return at2 === -1 ? VARIANT_PREFERRED.length : at2;
+    };
+    candidates.sort((a, b) => rank(a.prop) - rank(b.prop) || (a.prop < b.prop ? -1 : 1));
+    const best = candidates[0];
+    let count = 0;
+    for (const p of props) if (variantValue(p[best.prop]) === best.value) count++;
+    return { variant: { prop: best.prop, value: best.value }, count };
+  }
+  function comparePaths(a, b) {
+    const l = a === "" ? [] : a.split("/").map(Number);
+    const r = b === "" ? [] : b.split("/").map(Number);
+    for (let i = 0; i < Math.max(l.length, r.length); i++) {
+      const x = l[i] ?? -1;
+      const y = r[i] ?? -1;
+      if (x !== y) return x - y;
+    }
+    return 0;
+  }
+  function describeValue(v) {
+    if (v === null) return "null";
+    if (Array.isArray(v)) return `[${v.length} items]`;
+    switch (typeof v) {
+      case "string":
+        return JSON.stringify(v.length > 60 ? `${v.slice(0, 60)}\u2026` : v);
+      case "number":
+      case "boolean":
+      case "undefined":
+        return String(v);
+      case "function":
+        return "fn";
+      case "object": {
+        const o = v;
+        if (o["$$typeof"]) return "<element>";
+        try {
+          const json = JSON.stringify(v);
+          return json && json.length <= 80 ? json : "{\u2026}";
+        } catch {
+          return "{\u2026}";
+        }
+      }
+      default:
+        return typeof v;
+    }
+  }
+  function summariseProps(props) {
+    const out = {};
+    if (!props || typeof props !== "object") return out;
+    let taken = 0;
+    for (const [key, value] of Object.entries(props)) {
+      if (taken >= 16) break;
+      if (key === "children" && typeof value !== "string") continue;
+      out[key] = describeValue(value);
+      taken++;
+    }
+    return out;
+  }
+  function labelParts(el) {
+    const comp = componentNameOf(el);
+    if (comp && componentRoot(el) === el) return { label: comp, componentName: comp };
+    const aria = el.getAttribute("aria-label");
+    if (aria) return { label: aria, componentName: comp };
+    const text = el.children.length === 0 ? (el.textContent ?? "").trim() : "";
+    if (text && text.length <= 24) return { label: text, componentName: comp };
+    if (comp) return { label: comp, componentName: comp };
+    const role = el.getAttribute("role");
+    return { label: role || el.tagName.toLowerCase(), componentName: comp };
+  }
+  function labelOf(el) {
+    return labelParts(el).label;
+  }
+  function crumbLite(el) {
+    const elementPath = pathOf(el);
+    if (elementPath === null) return null;
+    const source = el.getAttribute("data-bp-source");
+    const { label, componentName } = labelParts(el);
+    return {
+      elementPath,
+      tag: el.tagName.toLowerCase(),
+      classes: Array.from(el.classList),
+      label,
+      componentName,
+      ...source ? { source } : {},
+      rect: rectOf(el)
+    };
+  }
+  function crumbOf(el) {
+    const lite = crumbLite(el);
+    if (!lite) return null;
+    return { ...lite, identity: identityOf(el) };
+  }
+  function refOf(el) {
+    const self = crumbOf(el);
+    if (!self) return null;
+    const mount = mountRoot();
+    const ancestors = [];
+    let node = el.parentElement;
+    while (node && node !== mount) {
+      const crumb = crumbOf(node);
+      if (crumb) ancestors.unshift(crumb);
+      node = node.parentElement;
+    }
+    const rootCrumb = crumbOf(mount);
+    if (rootCrumb) ancestors.unshift(rootCrumb);
+    return { ...self, ancestors };
+  }
+  function elementAtPoint(x, y) {
+    const mount = mountRoot();
+    const stack = document.elementsFromPoint(x, y);
+    for (const el of stack) {
+      if (el.id === OVERLAY_ID || el.closest(`#${OVERLAY_ID}`)) continue;
+      if (el === mount || mount.contains(el)) return el;
+    }
+    return null;
+  }
+  var SELECTOR_MAX_DEPTH = 12;
+  var STABLE_ATTRS = ["data-testid", "data-test-id", "data-test", "data-cy", "data-qa", "data-component", "name"];
+  var OUR_ATTRS = /* @__PURE__ */ new Set([SEL_ATTR, SPOT_ATTR, "data-bp-source"]);
+  var PLAIN_NAME = /^[A-Za-z_-][-A-Za-z0-9_]*$/;
+  function quoteValue(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  function resolvesTo(selector, el) {
+    try {
+      const found = mountRoot().querySelectorAll(selector);
+      return found.length === 1 && found[0] === el;
+    } catch {
+      return false;
+    }
+  }
+  function anchorFor(el) {
+    const id = el.getAttribute("id");
+    if (id && PLAIN_NAME.test(id) && resolvesTo(`#${id}`, el)) return `#${id}`;
+    const tried = [];
+    for (const attr of STABLE_ATTRS) {
+      const value = el.getAttribute(attr);
+      if (value !== null && value.length <= 80) tried.push(`[${attr}=${quoteValue(value)}]`);
+    }
+    for (const attr of Array.from(el.attributes)) {
+      if (!attr.name.startsWith("data-") || OUR_ATTRS.has(attr.name)) continue;
+      if (STABLE_ATTRS.indexOf(attr.name) !== -1) continue;
+      if (attr.value.length > 80) continue;
+      tried.push(attr.value === "" ? `[${attr.name}]` : `[${attr.name}=${quoteValue(attr.value)}]`);
+    }
+    for (const selector of tried) if (resolvesTo(selector, el)) return selector;
+    return null;
+  }
+  function compoundFor(el) {
+    const tag = el.tagName.toLowerCase();
+    const classes = Array.from(el.classList).filter((c) => PLAIN_NAME.test(c)).slice(0, 3);
+    const base = tag + classes.map((c) => `.${c}`).join("");
+    const parent = el.parentElement;
+    if (!parent) return base;
+    const siblings = Array.from(parent.children);
+    let matches = 0;
+    for (const sibling of siblings) {
+      try {
+        if (sibling.matches(base)) matches++;
+      } catch {
+        matches = 2;
+        break;
+      }
+    }
+    if (matches === 1) return base;
+    return `${base}:nth-child(${siblings.indexOf(el) + 1})`;
+  }
+  function printSelector(el) {
+    const mount = mountRoot();
+    if (el === mount || !mount.contains(el) && el !== mount) return null;
+    const own = anchorFor(el);
+    if (own) return own;
+    const parts = [];
+    let node = el;
+    for (let depth = 0; node && node !== mount && depth < SELECTOR_MAX_DEPTH; depth++) {
+      const anchor = depth === 0 ? null : anchorFor(node);
+      parts.unshift(anchor ?? compoundFor(node));
+      const candidate = parts.join(" > ");
+      if (resolvesTo(candidate, el)) return candidate;
+      if (anchor) break;
+      node = node.parentElement;
+    }
+    return null;
+  }
+  var RING_STROKE = 2;
+  var TAB_RADIUS = 6;
+  var JOIN_RADIUS = 4;
+  var INNER_RADIUS = 4;
+  var BADGE_RADIUS = 6;
+  var MARKER_SIZE = 18;
+  var TAB_HEIGHT = 17;
+  var CHROME_FONT = "-apple-system,BlinkMacSystemFont,system-ui,sans-serif";
+  var POP_EASE = "cubic-bezier(0.34,1.45,0.64,1)";
+  var MARKER_MORPH_MS = 180;
+  var CURSOR_DX = 6;
+  var CURSOR_DY = 23;
+  var CURSOR_FLIP_DY = 6;
+  var CURSOR_FADE_MS = 140;
+  var POINTING_CSS = "*{cursor:crosshair!important}[data-bp-marker]{cursor:pointer!important}";
+  var POINTING_STYLE_ID = "__bp_cursor__";
+  var TAB_INTRO_MS = 240;
+  var TAB_INTRO_DELAY_MS = 60;
+  var TAB_BLEED = 6;
+  var DETACH_SETTLE_MS = 1200;
+  var MORPH_SPRING = { stiffness: 345, damping: 32, mass: 1.2, precision: 7e-3 };
+  var RING_COLOR_VAR = "--bp-ring-c";
+  var RING_JOIN_VAR = "--bp-ring-j";
+  var RECOLOR_MS = 320;
+  var RECOLOR_EASE = "cubic-bezier(0.23, 1, 0.32, 1)";
+  var colorPropsRegistered = false;
+  function registerRingColors() {
+    if (colorPropsRegistered) return;
+    colorPropsRegistered = true;
+    for (const name of [RING_COLOR_VAR, RING_JOIN_VAR]) {
+      try {
+        CSS.registerProperty({ name, syntax: "<color>", inherits: true, initialValue: "transparent" });
+      } catch {
+      }
+    }
+  }
+  var GLYPH_SIZE = 8;
+  var SPIN_MS = 900;
+  var GLYPH_TURN_MS = 200;
+  var SPIN_GLYPH = `<svg width="${GLYPH_SIZE}" height="${GLYPH_SIZE}" viewBox="0 0 8 8" fill="none" style="display:block"><path d="M8 4C8 6.20914 6.20914 8 4 8C1.79086 8 0 6.20914 0 4C0 1.79086 1.79086 0 4 0C6.20914 0 8 1.79086 8 4ZM1.69306 4C1.69306 5.27409 2.72591 6.30694 4 6.30694C5.27409 6.30694 6.30694 5.27409 6.30694 4C6.30694 2.72591 5.27409 1.69306 4 1.69306C2.72591 1.69306 1.69306 2.72591 1.69306 4Z" fill="currentColor" fill-opacity="0.4"/><path d="M7.15347 4C7.621 4 8.00896 3.61686 7.91076 3.15977C7.82445 2.75808 7.67642 2.37042 7.47045 2.01104C7.12346 1.40559 6.62412 0.901459 6.02202 0.548704C5.41991 0.195949 4.736 0.00684783 4.03821 0.000182513C3.624 -0.00377393 3.21346 0.0566317 2.82087 0.177743C2.37412 0.31556 2.22958 0.841322 2.45817 1.24915C2.68676 1.65699 3.20646 1.78396 3.66915 1.7169C3.78559 1.70003 3.90355 1.69203 4.02203 1.69316C4.42448 1.69701 4.81892 1.80607 5.16617 2.00951C5.51342 2.21296 5.80141 2.50371 6.00153 2.8529C6.06045 2.9557 6.11115 3.06251 6.15336 3.17233C6.32109 3.60873 6.68595 4 7.15347 4Z" fill="currentColor"/></svg>`;
+  var STROKE_GLYPH = (d) => `<svg width="${GLYPH_SIZE}" height="${GLYPH_SIZE}" viewBox="0 0 8 8" fill="none" style="display:block">${d}</svg>`;
+  var PAUSE_GLYPH = STROKE_GLYPH(
+    '<path d="M2 1.5V6.5" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/><path d="M6 1.5V6.5" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>'
+  );
+  var ALERT_GLYPH = STROKE_GLYPH(
+    '<path d="M4 1.25V3.75" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/><path d="M4 6.75V6.7501" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>'
+  );
+  var AGENT_TAB = {
+    working: { text: "Working...", glyph: SPIN_GLYPH, spin: true },
+    approval: { text: "Needs Approval", glyph: PAUSE_GLYPH, spin: false },
+    failed: { text: "Failed", glyph: ALERT_GLYPH, spin: false }
+  };
+  var AGENT_FALLBACK = {
+    working: "#f87bdf",
+    approval: "#fd8a44",
+    failed: "#e5484d"
+  };
+  var RESOLVED_FALLBACK = "#1d9c00";
+  var CHECK_GLYPH = '<svg width="10" height="10" viewBox="0 0 10 10" fill="none" style="display:block"><path d="M2.1 5.25L4.05 7.2L7.9 3" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+  function turnOver(el, html) {
+    if (typeof el.animate !== "function") {
+      el.innerHTML = html;
+      return;
+    }
+    for (const a of el.getAnimations?.() ?? []) {
+      if (a.id === "turn") a.cancel();
+    }
+    const half = GLYPH_TURN_MS / 2;
+    const out = el.animate([{ opacity: 1, scale: "1" }, { opacity: 0, scale: "0.4" }], {
+      duration: half,
+      easing: "ease-in",
+      id: "turn"
+    });
+    out.onfinish = () => {
+      el.innerHTML = html;
+      el.animate([{ opacity: 0, scale: "0.4" }, { opacity: 1, scale: "1" }], {
+        duration: half,
+        easing: POP_EASE,
+        fill: "backwards",
+        id: "turn"
+      });
+    };
+    out.oncancel = () => {
+      el.innerHTML = html;
+    };
+  }
+  var FRAME_PATH = "";
+  function frameBox() {
+    const s = RING_STROKE;
+    return { x: s, y: s, w: Math.max(0, window.innerWidth - 2 * s), h: Math.max(0, window.innerHeight - 2 * s) };
+  }
+  function markRect(path, el) {
+    return path === FRAME_PATH ? frameBox() : rectOf(el);
+  }
+  function markTarget(path, el) {
+    return path === FRAME_PATH ? { rect: frameBox(), radii: [0, 0, 0, 0] } : targetOf(el);
+  }
+  function filletBox(r) {
+    return `width:${r}px;height:${r}px;overflow:hidden;`;
+  }
+  function filletArc(r, hole, color) {
+    const left = hole === "tr" || hole === "br" ? 0 : -r;
+    const top = hole === "bl" || hole === "br" ? 0 : -r;
+    return `position:absolute;left:${left}px;top:${top}px;width:${2 * r}px;height:${2 * r}px;border-radius:50%;box-shadow:0 0 0 ${r}px ${color};`;
+  }
+  function dressFillet(f, position, r, hole, color) {
+    f.square.style.cssText = position + filletBox(r);
+    f.arc.style.cssText = filletArc(r, hole, color);
+  }
+  var Ring = class {
+    constructor(parent, fill, morphing = false) {
+      /** Styling caches — rewritten on change, never per frame. */
+      this.color = "";
+      this.textColor = "#ffffff";
+      this.joinColor = "";
+      this.label = "";
+      this.morph = null;
+      this.glyph = null;
+      this.spinning = false;
+      this.tabW = 0;
+      this.radius = "";
+      this.tucked = false;
+      this.tabShift = 0;
+      this.tabDress = "";
+      this.dropR = -1;
+      this.tabHidden = false;
+      this.hasTab = true;
+      this.geom = "";
+      this.fused = false;
+      this.shown = false;
+      this.rect = null;
+      this.fill = fill;
+      this.morphing = morphing;
+      const div = (css, into) => {
+        const d = document.createElement("div");
+        d.style.cssText = css;
+        into.appendChild(d);
+        return d;
+      };
+      registerRingColors();
+      this.rootEl = div(
+        "position:fixed;left:0;top:0;pointer-events:none;display:none;will-change:transform,width,height;",
+        parent
+      );
+      const fillet = (css, into) => {
+        const square = div(css, into);
+        return { square, arc: div("", square) };
+      };
+      this.box = div("position:absolute;inset:0;box-sizing:border-box;", this.rootEl);
+      this.inTL = fillet("position:absolute;left:0;top:0;", this.box);
+      this.inTR = fillet("position:absolute;right:0;top:0;display:none;", this.box);
+      this.inBR = fillet("position:absolute;right:0;bottom:0;display:none;", this.box);
+      this.tabRow = div("position:absolute;bottom:100%;left:0;overflow:hidden;white-space:nowrap;", this.rootEl);
+      this.tabSlide = div("position:relative;display:flex;align-items:flex-end;", this.tabRow);
+      this.tab = div(
+        `display:flex;align-items:center;gap:4px;padding:2px 6px 1px;font:600 11px/14px ${CHROME_FONT};letter-spacing:-0.08px;border-radius:${TAB_RADIUS}px ${TAB_RADIUS}px 0 0;`,
+        this.tabSlide
+      );
+      this.tabGlyph = div(`display:none;flex:none;width:${GLYPH_SIZE}px;height:${GLYPH_SIZE}px;`, this.tab);
+      this.tabText = div("", this.tab);
+      this.tabJoin = fillet("", this.tabSlide);
+      this.tabBleed = div(`position:absolute;left:0;right:0;top:100%;height:${TAB_BLEED}px;`, this.tabSlide);
+      this.tabDrop = fillet("position:absolute;left:100%;top:0;display:none;", this.rootEl);
+      this.markJoin = fillet(`position:absolute;top:100%;right:${MARKER_SIZE}px;display:none;`, this.rootEl);
+    }
+    /**
+     * Everything that only changes with color or fusion.
+     *
+     * The pieces are written once, against `var(--bp-ring-c)` (and the join's
+     * own variable), and the container holds the values. So a ring that
+     * *changes* color — an agent ring going from working to needs-approval —
+     * writes one property and the stroke, the tab, the bleed and every join
+     * fillet travel together, interpolated in oklab by the registered
+     * property. The very first color is written without the transition: a new
+     * ring appears in its color, it does not fade up out of transparent.
+     */
+    style(color, textColor, joinColor) {
+      if (color === this.color && textColor === this.textColor && joinColor === this.joinColor) return;
+      const first = this.color === "";
+      this.color = color;
+      this.textColor = textColor;
+      this.joinColor = joinColor;
+      if (first) {
+        const c2 = `var(${RING_COLOR_VAR})`;
+        this.box.style.border = `${RING_STROKE}px solid ${c2}`;
+        this.box.style.background = this.fill ? colorMix(c2, 0.08) : "transparent";
+        this.tab.style.background = c2;
+        this.tabBleed.style.background = c2;
+        dressFillet(this.tabJoin, "position:relative;", JOIN_RADIUS, "tr", c2);
+      }
+      this.tab.style.color = textColor;
+      this.rootEl.style.setProperty(RING_COLOR_VAR, color);
+      this.rootEl.style.setProperty(RING_JOIN_VAR, joinColor);
+      if (first) {
+        requestAnimationFrame(() => {
+          this.rootEl.style.transition = `${RING_COLOR_VAR} ${RECOLOR_MS}ms ${RECOLOR_EASE},${RING_JOIN_VAR} ${RECOLOR_MS}ms ${RECOLOR_EASE}`;
+        });
+      }
+      const c = `var(${RING_COLOR_VAR})`;
+      dressFillet(this.inTL, `position:absolute;left:0;top:0;display:${this.hasTab ? "block" : "none"};`, INNER_RADIUS, "br", c);
+      dressFillet(this.inBR, `position:absolute;right:0;bottom:0;display:${this.fused ? "block" : "none"};`, INNER_RADIUS, "tl", c);
+      dressFillet(
+        this.markJoin,
+        `position:absolute;top:100%;right:${MARKER_SIZE}px;display:${this.fused ? "block" : "none"};`,
+        JOIN_RADIUS,
+        "bl",
+        `var(${RING_JOIN_VAR})`
+      );
+      this.dropFillets(this.dropR, true);
+      this.radius = "";
+    }
+    /**
+     * The overhang's two fillets, sized to the room the tab actually leaves.
+     *
+     * `r` is the drop's radius — zero when the tab clears the box's right edge
+     * by less than the corner it is already rounding, in which case the tab's
+     * own curve lands on that edge and there is nothing left to round. The
+     * inner one is the box's, so it keeps the inner radius whenever the
+     * corner is squared at all.
+     */
+    dropFillets(r, force = false) {
+      if (r === this.dropR && !force) return;
+      this.dropR = r;
+      const c = `var(${RING_COLOR_VAR})`;
+      const drop = Math.max(r, 0);
+      dressFillet(this.tabDrop, `position:absolute;left:100%;top:0;display:${drop > 0 ? "block" : "none"};`, drop, "br", c);
+      dressFillet(this.inTR, `position:absolute;right:0;top:0;display:${r >= 0 ? "block" : "none"};`, INNER_RADIUS, "bl", c);
+    }
+    /** The tab's text — measured only when it changes (the old chip's trick). */
+    setLabel(label) {
+      if (label === this.label) return;
+      this.label = label;
+      if (this.morphing) {
+        if (!this.morph) {
+          this.morph = new nt({
+            element: this.tabText,
+            ease: MORPH_SPRING,
+            onAnimationComplete: () => {
+              if (this.hasTab) this.tabW = this.tab.offsetWidth;
+            }
+          });
+        }
+        this.morph.update(label);
+        if (this.hasTab) this.tabW = this.tab.offsetWidth;
+      } else {
+        this.tabText.textContent = label;
+      }
+      if (this.hasTab && !this.morphing) this.tabW = this.tab.offsetWidth;
+    }
+    /**
+     * The tab's leading glyph — the agent rings' spinner, pause and alert
+     * (`AGENT_TAB`); `null` for every other ring, which is the default. Only a
+     * change in *presence* re-measures the tab: the three glyphs are one size,
+     * so swapping one for another moves nothing.
+     *
+     * `spin` turns the glyph, which is the whole of what "Working…" claims —
+     * a partial ring standing still reads as broken, not busy. WAAPI so it
+     * survives the page's own stylesheets, and reduced motion leaves it still:
+     * the word beside it already says the fact.
+     */
+    setGlyph(svg, spin = false) {
+      if (svg !== this.glyph) {
+        const swap = svg !== null && this.glyph !== null;
+        const appeared = svg !== null !== (this.glyph !== null);
+        this.glyph = svg;
+        if (swap && !matchMedia("(prefers-reduced-motion: reduce)").matches) {
+          this.turnOver(svg);
+        } else {
+          this.tabGlyph.innerHTML = svg ?? "";
+        }
+        this.tabGlyph.style.display = svg === null ? "none" : "block";
+        if (appeared && this.hasTab) this.tabW = this.tab.offsetWidth;
+      }
+      if (spin === this.spinning) return;
+      this.spinning = spin;
+      for (const a of this.tabGlyph.getAnimations?.() ?? []) if (a.id === "spin") a.cancel();
+      if (!spin || matchMedia("(prefers-reduced-motion: reduce)").matches) return;
+      this.tabGlyph.animate?.([{ rotate: "0deg" }, { rotate: "360deg" }], {
+        duration: SPIN_MS,
+        iterations: Infinity,
+        easing: "linear",
+        id: "spin"
+      });
+    }
+    /** Half out, swap, half back — the glyph's own state change. */
+    turnOver(svg) {
+      turnOver(this.tabGlyph, svg);
+    }
+    /**
+     * Take the whole construction out of the page — a status ring whose turn
+     * ended. The pooled rings (hover, selection) never call it.
+     *
+     * It leaves rather than vanishing: the fused chip under it is already
+     * traveling back to annotate purple on the recolor clock, and a ring that
+     * cut out from around a chip mid-transition would read as two events. The
+     * caller has already dropped this ring, so a fading one is never redrawn.
+     */
+    destroy() {
+      for (const a of this.tabGlyph.getAnimations?.() ?? []) a.cancel();
+      this.morph?.destroy();
+      this.morph = null;
+      if (!this.shown || typeof this.rootEl.animate !== "function") {
+        this.rootEl.remove();
+        return;
+      }
+      const out = this.rootEl.animate([{ opacity: 1 }, { opacity: 0 }], {
+        duration: RECOLOR_MS,
+        easing: RECOLOR_EASE
+      });
+      out.onfinish = () => this.rootEl.remove();
+      out.oncancel = () => this.rootEl.remove();
+    }
+    /** Whether the construction carries its label tab at all. Pointer hover
+     *  hands the name to the cursor label, so its ring drops the tab and gets
+     *  all four corners back; path-driven hovers (the layers preview, a
+     *  hovered marker) keep it — there is no cursor there to follow. */
+    setTab(show) {
+      if (show === this.hasTab) return;
+      this.hasTab = show;
+      this.tabRow.style.display = show ? "block" : "none";
+      this.inTL.square.style.display = show ? "block" : "none";
+      if (show && this.label) this.tabW = this.tab.offsetWidth;
+      this.radius = "";
+    }
+    /** The select hand-off's second half: the tab pushes out of the box's
+     *  top-left edge (down out of it when tucked), clipped by `tabRow` so it
+     *  emerges from behind the ring rather than sliding over it. WAAPI so a
+     *  quick re-select restarts cleanly; the caller gates reduced motion. */
+    intro() {
+      if (!this.hasTab || typeof this.tabSlide.animate !== "function") return;
+      for (const a of this.tabSlide.getAnimations?.() ?? []) a.cancel();
+      this.tabSlide.animate(
+        [{ transform: this.tucked ? "translateY(-100%)" : "translateY(100%)" }, { transform: "translateY(0)" }],
+        { duration: TAB_INTRO_MS, delay: TAB_INTRO_DELAY_MS, easing: POP_EASE, fill: "backwards" }
+      );
+    }
+    /** During a parameter drag the label gets out of the way — the old chip's
+     *  suppression, inherited by the tab. The box stays, so the drag keeps its
+     *  bearings. */
+    setTabHidden(hidden) {
+      if (hidden === this.tabHidden) return;
+      this.tabHidden = hidden;
+      this.tabRow.style.visibility = hidden ? "hidden" : "visible";
+    }
+    /** A marker is fused at the box's bottom-right: that corner squares off,
+     *  the inner fillet rounds it from inside, and the join appears. */
+    setFused(fused) {
+      if (fused === this.fused) return;
+      this.fused = fused;
+      this.inBR.square.style.display = fused ? "block" : "none";
+      this.markJoin.square.style.display = fused ? "block" : "none";
+      this.radius = "";
+    }
+    /** Returns whether the ring's geometry actually changed this call — the
+     *  draw loop's own motion signal, free because the cache is already here. */
+    draw(target) {
+      if (!target) {
+        const moved2 = this.shown;
+        if (this.shown) this.rootEl.style.display = "none";
+        this.shown = false;
+        this.rect = null;
+        this.geom = "";
+        return moved2;
+      }
+      const { rect, radii } = target;
+      const s = RING_STROKE;
+      const geom = `${rect.x}|${rect.y}|${rect.w}|${rect.h}`;
+      const moved = geom !== this.geom;
+      if (moved) {
+        this.geom = geom;
+        this.rootEl.style.display = "block";
+        this.rootEl.style.transform = `translate(${rect.x - s}px,${rect.y - s}px)`;
+        this.rootEl.style.width = `${rect.w + 2 * s}px`;
+        this.rootEl.style.height = `${rect.h + 2 * s}px`;
+      }
+      this.shown = true;
+      this.rect = rect;
+      const tucked = rect.y - s < TAB_HEIGHT;
+      if (tucked !== this.tucked) {
+        this.tucked = tucked;
+        this.tabRow.style.bottom = tucked ? "auto" : "100%";
+        this.tabRow.style.top = tucked ? `${RING_STROKE}px` : "auto";
+        this.tabBleed.style.top = tucked ? "auto" : "100%";
+        this.tabBleed.style.bottom = tucked ? "100%" : "auto";
+      }
+      const past = rect.x - s + this.tabW + JOIN_RADIUS - window.innerWidth;
+      const shift = past > 0 ? -Math.min(past, Math.max(0, rect.x - s)) : 0;
+      if (shift !== this.tabShift) {
+        this.tabShift = shift;
+        this.tabRow.style.transform = shift === 0 ? "" : `translateX(${shift}px)`;
+      }
+      const width = rect.w + 2 * s;
+      const clear = this.hasTab && !tucked ? this.tabW + shift - width : -1;
+      const overhang = clear >= 0;
+      const tabR = overhang ? Math.min(TAB_RADIUS, clear) : 0;
+      this.dropFillets(overhang ? Math.min(JOIN_RADIUS, clear - tabR) : -1);
+      const joinFits = !tucked && clear + JOIN_RADIUS <= 0;
+      const dress = `${tucked ? "tucked" : tabR}|${joinFits}`;
+      if (dress !== this.tabDress) {
+        this.tabDress = dress;
+        this.tab.style.borderRadius = tucked ? `0 0 ${TAB_RADIUS}px ${TAB_RADIUS}px` : `${TAB_RADIUS}px ${TAB_RADIUS}px ${tabR}px 0`;
+        this.tabJoin.square.style.visibility = joinFits ? "visible" : "hidden";
+      }
+      const [tl, tr, br, bl] = radii;
+      const outer = (r) => `${Math.round((r + s) * 100) / 100}px`;
+      const radius = `${this.hasTab ? "0px" : outer(tl)} ${overhang ? "0px" : outer(tr)} ${this.fused ? "0px" : outer(br)} ${outer(bl)}`;
+      if (radius !== this.radius) {
+        this.radius = radius;
+        this.box.style.borderRadius = radius;
+      }
+      return moved;
+    }
+    tabState() {
+      if (!this.shown || this.tabHidden || !this.hasTab) return null;
+      const b = this.tab.getBoundingClientRect();
+      return { rect: { x: b.left, y: b.top, w: b.width, h: b.height }, text: this.label };
+    }
+  };
+  var Overlay = class {
+    constructor() {
+      this.root = null;
+      /** The cursor label: pointer hover's name, riding the pointer. */
+      this.cursorEl = null;
+      this.cursorLabel = "";
+      this.cursorW = 0;
+      this.cursorShown = false;
+      /** Standing ordinal markers, keyed by element path. */
+      this.markerEls = /* @__PURE__ */ new Map();
+      this.markerStyle = /* @__PURE__ */ new Map();
+      this.markerPos = /* @__PURE__ */ new Map();
+      /** Drawn marker geometry, for synthetic pointing — a wire host forwards
+       *  coordinates instead of real events, so the probe answers "was that a
+       *  marker?" itself and every host gets Beam's native behavior. */
+      this.markerXY = /* @__PURE__ */ new Map();
+      this.markersHidden = false;
+      this.lastMarkers = [];
+      /** The standing agent rings, one construction per decorated element path —
+       *  the markers' lifecycle, applied to a ring. */
+      this.statusRings = /* @__PURE__ */ new Map();
+      this.statusDress = /* @__PURE__ */ new Map();
+      this.lastStatus = [];
+      /** Hovering a marker points at its annotation: the hover construction
+       *  draws on its element in annotate's color, fused to the chip. */
+      this.hoverAnnotate = false;
+      /** Whether the annotation each ring is fused to is resolved — the one fact
+       *  that recolors the whole construction green, chip and ring together. */
+      this.hoverResolved = false;
+      this.selResolved = false;
+      this.markerHandler = null;
+      this.markerHover = null;
+      this.colors = { hover: "#32b2ed", selection: "#32b2ed", chipText: "#ffffff", annotate: "#bc5cf3" };
+      this.visible = false;
+      /** A pointing mode is up: the page wears the crosshair. Separate from
+       *  `visible` because interact keeps the rings while giving the page its
+       *  cursor back. */
+      this.pointing = false;
+      this.pointingStyle = null;
+      /** A parameter drag is in flight: the selection ring gets out of the way
+       *  so the change is readable. Hover stays live — this is not `visible`. */
+      this.suppressSelection = false;
+    }
+    ensure() {
+      if (this.root && this.root.isConnected) return true;
+      const host = document.documentElement;
+      if (!host) return false;
+      const root = document.createElement("div");
+      root.id = OVERLAY_ID;
+      root.setAttribute("aria-hidden", "true");
+      root.style.cssText = "position:fixed;inset:0;z-index:2147483646;pointer-events:none;contain:strict;";
+      this.hoverRing = new Ring(root, true);
+      this.selRing = new Ring(root, false);
+      const cursor = document.createElement("div");
+      cursor.style.cssText = `position:fixed;left:0;top:0;pointer-events:none;display:none;will-change:transform;padding:2px 6px 1px;font:600 11px/14px ${CHROME_FONT};letter-spacing:-0.08px;white-space:nowrap;border-radius:${BADGE_RADIUS}px;box-shadow:0 3px 8px rgba(0,0,0,0.18);opacity:0;transition:opacity ${CURSOR_FADE_MS}ms ease;`;
+      root.appendChild(cursor);
+      this.cursorEl = cursor;
+      host.appendChild(root);
+      this.root = root;
+      this.restyle();
+      return true;
+    }
+    setColors(c) {
+      this.colors = { ...this.colors, ...c };
+      if (!this.root) return;
+      this.restyle();
+      this.markerStyle.clear();
+      this.statusDress.clear();
+    }
+    /** The color one agent state paints with — the host's, else the token's
+     *  literal (`AGENT_FALLBACK`). */
+    statusColor(state) {
+      return this.colors[state] ?? AGENT_FALLBACK[state];
+    }
+    annotateColor() {
+      return this.colors.annotate ?? this.colors.selection;
+    }
+    resolvedColor() {
+      return this.colors.resolved ?? RESOLVED_FALLBACK;
+    }
+    /** What an annotation's construction paints with: purple while it is still
+     *  asking, green once it has been answered. One function, because the chip
+     *  and every ring that fuses to it must never disagree. */
+    annColor(resolved) {
+      return resolved ? this.resolvedColor() : this.annotateColor();
+    }
+    restyle() {
+      const hoverAnn = this.annColor(this.hoverResolved);
+      this.hoverRing.style(this.hoverAnnotate ? hoverAnn : this.colors.hover, this.colors.chipText, hoverAnn);
+      const selAnn = this.annColor(this.selResolved);
+      this.selRing.style(this.selRing.fused ? selAnn : this.colors.selection, this.colors.chipText, selAnn);
+      if (this.cursorEl) {
+        this.cursorEl.style.background = this.colors.hover;
+        this.cursorEl.style.color = this.colors.chipText;
+      }
+    }
+    /** Marker hover recolors the hover construction to the annotation's own
+     *  color — purple while it is still asking, the resolved green once it has
+     *  been answered. */
+    setHoverAccent(annotate, resolved = false) {
+      if (!this.ensure()) return;
+      if (annotate === this.hoverAnnotate && resolved === this.hoverResolved) return;
+      this.hoverAnnotate = annotate;
+      this.hoverResolved = resolved;
+      this.restyle();
+    }
+    setHoverFused(fused) {
+      if (this.ensure()) this.hoverRing.setFused(fused);
+    }
+    setSelectionLabel(label) {
+      if (this.ensure()) this.selRing.setLabel(label);
+    }
+    /** `resolved` is the fused mark's own state, not the selection's: a request
+     *  answered while its ring is standing recolors in place, on the same
+     *  clock the chip below it recolors on. */
+    setSelectionFused(fused, resolved = false) {
+      if (!this.ensure()) return;
+      const next = fused && !this.suppressSelection;
+      const done = next && resolved;
+      if (next === this.selRing.fused && done === this.selResolved) return;
+      this.selResolved = done;
+      this.selRing.setFused(next);
+      this.restyle();
+    }
+    drawHover(target, label) {
+      if (!this.ensure()) return false;
+      if (target && label !== null) this.hoverRing.setLabel(label);
+      this.hoverRing.setTabHidden(this.suppressSelection);
+      return this.hoverRing.draw(this.visible ? target : null);
+    }
+    /** Whether the hover construction carries its tab — off for pointer hover
+     *  (the cursor label owns the name), on for path-driven hovers. */
+    setHoverTab(show) {
+      if (this.ensure()) this.hoverRing.setTab(show);
+    }
+    /**
+     * The cursor label follows the pointer at its top-right — flipped below
+     * near the viewport top, pulled left of the pointer at the right edge, so
+     * the name is always beside the cursor and never clipped. Text is measured
+     * only when it changes; a move writes one transform.
+     */
+    drawCursor(x, y, label) {
+      if (!this.ensure() || !this.visible) return;
+      const el = this.cursorEl;
+      const showing = this.cursorShown;
+      if (!showing) {
+        this.cursorShown = true;
+        el.style.display = "block";
+      }
+      if (label !== this.cursorLabel) {
+        this.cursorLabel = label;
+        el.textContent = label;
+        this.cursorW = el.offsetWidth;
+      } else if (!showing) {
+        void el.offsetWidth;
+      }
+      let cx = x + CURSOR_DX;
+      if (cx + this.cursorW + 4 > window.innerWidth) cx = Math.max(4, x - CURSOR_DX - this.cursorW);
+      let cy = y - CURSOR_DY;
+      if (cy < 4) cy = y + CURSOR_FLIP_DY;
+      el.style.transform = `translate(${cx}px,${cy}px)`;
+      if (!showing) el.style.opacity = "1";
+    }
+    /** Take the cursor label down — fading in place (a click, the pointer
+     *  leaving) or instantly (scroll, teardown: a stale position must not
+     *  linger where the content used to be). */
+    hideCursor(fade) {
+      const el = this.cursorEl;
+      if (!el || !this.cursorShown) return;
+      this.cursorShown = false;
+      el.style.opacity = "0";
+      if (!fade) el.style.display = "none";
+    }
+    /** The crosshair sheet follows `pointing && visible` — installed under the
+     *  document root (the spotlight's pattern, page CSS can't outrank it),
+     *  removed the moment pointing ends so the page's own cursors return. */
+    syncCursorStyle() {
+      const want = this.pointing && this.visible;
+      if (want) {
+        if (this.pointingStyle && this.pointingStyle.isConnected) return;
+        const host = document.documentElement;
+        if (!host) return;
+        const style = document.createElement("style");
+        style.id = POINTING_STYLE_ID;
+        style.textContent = POINTING_CSS;
+        host.appendChild(style);
+        this.pointingStyle = style;
+      } else if (this.pointingStyle) {
+        this.pointingStyle.remove();
+        this.pointingStyle = null;
+      }
+    }
+    /** The click hand-off: the cursor label freezes and fades while the new
+     *  selection's tab pushes out of the ring — one name changing owners.
+     *  Reduced motion keeps the fade (it is one) and skips the push. */
+    handOff() {
+      if (!this.ensure()) return;
+      this.hideCursor(true);
+      if (matchMedia("(prefers-reduced-motion: reduce)").matches) return;
+      this.selRing.intro();
+    }
+    drawSelection(target) {
+      if (!this.ensure()) return false;
+      return this.selRing.draw(this.visible && !this.suppressSelection ? target : null);
+    }
+    /**
+     * The standing agent rings — the full construction on every element a
+     * managed turn is live on, redrawn every frame like the markers so they
+     * can't lag a scroll. Standing chrome: this draws with no selection, and
+     * only the host clears it.
+     *
+     * One ring per element and no more: the caller stands the selection and
+     * hover constructions down on these elements, because two rings on one
+     * element read as a bug rather than as two facts.
+     */
+    drawStatus(draws) {
+      if (!this.ensure()) return false;
+      this.lastStatus = draws;
+      let moved = false;
+      const keep = new Set(draws.map((d) => d.key));
+      for (const [key, ring] of this.statusRings) {
+        if (keep.has(key)) continue;
+        ring.destroy();
+        this.statusRings.delete(key);
+        this.statusDress.delete(key);
+        moved = true;
+      }
+      for (const d of draws) {
+        let ring = this.statusRings.get(d.key);
+        if (!ring) {
+          ring = new Ring(this.root, false, true);
+          this.statusRings.set(d.key, ring);
+          moved = true;
+        }
+        const dress = `${d.state}|${this.colors.chipText}|${this.statusColor(d.state)}`;
+        if (this.statusDress.get(d.key) !== dress) {
+          this.statusDress.set(d.key, dress);
+          const color = this.statusColor(d.state);
+          const tab = AGENT_TAB[d.state];
+          ring.style(color, this.colors.chipText, color);
+          ring.setLabel(tab.text);
+          ring.setGlyph(tab.glyph, tab.spin);
+        }
+        ring.setFused(d.fused);
+        if (ring.draw(d.target)) moved = true;
+      }
+      return moved;
+    }
+    /**
+     * The standing ordinal markers — annotation numbers at their elements'
+     * bottom-right, redrawn every frame like the rings so they can't lag a
+     * scroll. A marker on the selected element draws fused (square top, the
+     * ring's join beside it); the CSS transition is what makes ring dismissal
+     * a morph instead of a jump. Markers are the one pointer-active chrome:
+     * a click answers the host, never the page.
+     */
+    drawMarkers(draws) {
+      if (!this.ensure()) return false;
+      this.lastMarkers = draws;
+      let moved = false;
+      const born = [];
+      const keep = new Set(draws.map((d) => d.key));
+      for (const [key, el] of this.markerEls) {
+        if (!keep.has(key)) {
+          el.remove();
+          this.markerEls.delete(key);
+          this.markerStyle.delete(key);
+          this.markerPos.delete(key);
+          this.markerXY.delete(key);
+          moved = true;
+        }
+      }
+      for (const d of draws) {
+        let el = this.markerEls.get(d.key);
+        if (!el) {
+          el = document.createElement("div");
+          el.setAttribute("data-bp-marker", "");
+          el.style.cssText = `position:fixed;left:0;top:0;display:flex;align-items:center;justify-content:center;pointer-events:auto;cursor:pointer;z-index:1;width:${MARKER_SIZE}px;height:${MARKER_SIZE}px;box-sizing:border-box;font:600 11px/1 ${CHROME_FONT};letter-spacing:-0.4px;font-variant-numeric:tabular-nums;will-change:translate;border-radius:${BADGE_RADIUS}px;transition:border-radius ${MARKER_MORPH_MS}ms ${POP_EASE},box-shadow ${MARKER_MORPH_MS}ms ease,opacity 200ms ease,background-color ${RECOLOR_MS}ms ${RECOLOR_EASE};`;
+          const key = d.key;
+          const marker = el;
+          el.addEventListener("pointerdown", (e) => e.stopPropagation());
+          el.addEventListener("click", (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            const ordinal = Number(marker.dataset.ordinal ?? "0");
+            this.markerHandler?.(key, ordinal);
+            emit("markerClick", { path: key, ordinal });
+          });
+          el.addEventListener("pointerenter", () => this.markerHover?.(key));
+          el.addEventListener("pointerleave", () => this.markerHover?.(null));
+          this.root.appendChild(el);
+          this.markerEls.set(d.key, el);
+          born.push({ el, ordinal: d.ordinal });
+          moved = true;
+        }
+        if (this.markersHidden) el.style.display = "flex";
+        const s = RING_STROKE;
+        let x = d.rect.x + d.rect.w + s - MARKER_SIZE;
+        let y = d.rect.y + d.rect.h + s;
+        if (y + MARKER_SIZE > window.innerHeight) y = d.rect.y + d.rect.h - s - MARKER_SIZE;
+        x = Math.max(0, Math.min(x, window.innerWidth - MARKER_SIZE));
+        this.markerXY.set(d.key, { x, y, ordinal: d.ordinal });
+        const pos = `${x}px ${y}px`;
+        if (this.markerPos.get(d.key) !== pos) {
+          this.markerPos.set(d.key, pos);
+          el.style.translate = pos;
+          moved = true;
+        }
+        const style = `${d.ordinal}|${d.fused}|${d.status}|${d.detached}|${d.agent ?? ""}`;
+        const was = this.markerStyle.get(d.key);
+        if (was !== style) {
+          this.markerStyle.set(d.key, style);
+          const done = d.status === "resolved";
+          const mark = done ? CHECK_GLYPH : String(d.ordinal);
+          const turning = was !== void 0 && was.split("|")[2] !== d.status && !matchMedia("(prefers-reduced-motion: reduce)").matches;
+          if (turning) turnOver(el, mark);
+          else if (done) el.innerHTML = mark;
+          else el.textContent = mark;
+          el.dataset.ordinal = String(d.ordinal);
+          el.style.background = d.detached ? "#a9adb1" : d.agent ? this.statusColor(d.agent) : done ? this.resolvedColor() : this.annotateColor();
+          el.style.color = this.colors.chipText;
+          el.style.border = "none";
+          el.style.opacity = "1";
+          el.style.borderRadius = d.fused ? `0 0 ${BADGE_RADIUS}px ${BADGE_RADIUS}px` : `${BADGE_RADIUS}px`;
+          el.style.boxShadow = d.fused ? "0 1px 3px rgba(0,0,0,0.06)" : "0 3px 8px rgba(0,0,0,0.15)";
+        }
+      }
+      if (born.length > 0 && !matchMedia("(prefers-reduced-motion: reduce)").matches) {
+        born.sort((a, b) => a.ordinal - b.ordinal);
+        born.forEach(
+          (b, i) => b.el.animate([{ opacity: 0, scale: "0.25", offset: 0 }], {
+            duration: 280,
+            delay: Math.min(i * 45, 400),
+            easing: POP_EASE,
+            fill: "backwards"
+          })
+        );
+      }
+      this.markersHidden = false;
+      return moved;
+    }
+    /** The marker under a viewport point, for synthetic pointing. Only markers
+     *  actually drawn this session answer — hidden overlays have none. */
+    markerAtPoint(x, y) {
+      if (!this.visible || this.markersHidden) return null;
+      for (const [path, m] of this.markerXY) {
+        if (x >= m.x && x <= m.x + MARKER_SIZE && y >= m.y && y <= m.y + MARKER_SIZE)
+          return { path, ordinal: m.ordinal };
+      }
+      return null;
+    }
+    hideAll() {
+      if (!this.root) return;
+      this.hoverRing.draw(null);
+      this.selRing.draw(null);
+      for (const ring of this.statusRings.values()) ring.draw(null);
+      this.hideCursor(false);
+      for (const el of this.markerEls.values()) el.style.display = "none";
+      this.markersHidden = true;
+    }
+    /** What is actually painted right now — the conformance suite's read.
+     *  `hover` and `selection` stay the element rects (the construction paints
+     *  the stroke outside them); `hoverTab`, `cursorChip`, `tab`, `badge` and
+     *  `markers` are the chrome. Pointer hover names through `cursorChip`;
+     *  `hoverTab` stands only for path-driven hovers (layers preview, a
+     *  hovered marker). */
+    state() {
+      if (!this.root)
+        return {
+          hover: null,
+          hoverTab: null,
+          cursorChip: null,
+          selection: null,
+          tab: null,
+          badge: null,
+          markers: [],
+          status: []
+        };
+      const rect = (el) => {
+        const b = el.getBoundingClientRect();
+        return { x: b.left, y: b.top, w: b.width, h: b.height };
+      };
+      const markers = this.markersHidden ? [] : this.lastMarkers.map((d) => {
+        const el = this.markerEls.get(d.key);
+        return el ? { rect: rect(el), text: String(d.ordinal), fused: d.fused } : null;
+      }).filter((m) => m !== null);
+      const fused = markers.find((m) => m.fused);
+      return {
+        hover: this.hoverRing.shown ? this.hoverRing.rect : null,
+        hoverTab: this.hoverRing.tabState(),
+        cursorChip: this.cursorShown && this.cursorEl ? { rect: rect(this.cursorEl), text: this.cursorLabel } : null,
+        selection: this.selRing.shown ? this.selRing.rect : null,
+        tab: this.selRing.tabState(),
+        badge: fused ? { rect: fused.rect, text: fused.text } : null,
+        markers: markers.map((m) => ({ rect: m.rect, text: m.text })),
+        // Element rects, like `hover` and `selection`: the construction paints
+        // its stroke outside them. `text` is what the tab says.
+        status: this.lastStatus.map((d) => {
+          const ring = this.statusRings.get(d.key);
+          if (!ring?.shown || !ring.rect) return null;
+          return { rect: ring.rect, text: AGENT_TAB[d.state].text, state: d.state };
+        }).filter((r) => r !== null)
+      };
+    }
+  };
+  function colorMix(color, alpha) {
+    return `color-mix(in srgb, ${color} ${Math.round(alpha * 100)}%, transparent)`;
+  }
+  var SPOT_CSS = `[${SPOT_ATTR}="0"]{visibility:hidden!important}[${SPOT_ATTR}="1"]{visibility:visible!important}`;
+  var ARMED_CSS = `body{visibility:hidden!important}${SPOT_CSS}`;
+  var Spotlight = class {
+    constructor() {
+      this.style = null;
+      this.text = "";
+      this.path = null;
+      this.applied = false;
+      this.marked = /* @__PURE__ */ new Set();
+      /** `<body>`'s children the first time the element resolved. Without React
+       *  this is the only clue a node is a portal: it wasn't there before. */
+      this.baseline = null;
+      this.rootWatch = null;
+    }
+    /** Spotlight the element at `path`; `null` turns it off. */
+    set(path) {
+      if (path === this.path) return;
+      this.path = path;
+      this.applied = false;
+      this.baseline = null;
+      this.clearMarks();
+      if (path === null) {
+        this.write("");
+        this.emitState();
+        return;
+      }
+      this.write(ARMED_CSS);
+      this.emitState();
+      this.refresh();
+    }
+    /** Re-measure the kept set. Called on every coalesced content change. */
+    refresh() {
+      if (this.path === null) return;
+      if (!document.body) return;
+      const el = elementAt(this.path);
+      if (!el || !el.isConnected) {
+        if (!this.applied) return;
+        this.applied = false;
+        this.clearMarks();
+        this.write(ARMED_CSS);
+        this.emitState();
+        return;
+      }
+      const { hide, show } = this.compute(el);
+      this.mark(hide, show);
+      this.write(SPOT_CSS);
+      if (!this.applied) {
+        this.applied = true;
+        this.emitState();
+      }
+    }
+    state() {
+      let kept = 0;
+      for (const el of this.marked) if (el.getAttribute(SPOT_ATTR) === "1") kept++;
+      return { path: this.path, applied: this.applied, hidden: this.marked.size - kept, kept };
+    }
+    /** Is `el` marked hidden right now? Used by the tag/selection paths so the
+     *  spotlight and the overlay can't argue about one element. */
+    hidden(el) {
+      return el.getAttribute(SPOT_ATTR) === "0";
+    }
+    compute(el) {
+      const hide = [];
+      const show = [];
+      const body = document.body;
+      if (body && this.baseline === null) this.baseline = new Set(Array.from(body.children));
+      const chain = [];
+      for (let node = el; node; node = node.parentElement) chain.unshift(node);
+      const fiber = fiberOf(el);
+      const rect = el.getBoundingClientRect();
+      for (let i = 0; i < chain.length - 1; i++) {
+        for (const child of Array.from(chain[i].children)) {
+          if (child === chain[i + 1] || child.id === OVERLAY_ID) continue;
+          if (NON_VISUAL.has(child.tagName.toLowerCase())) continue;
+          if (this.owned(child, fiber, rect)) show.push(child);
+          else hide.push(child);
+        }
+      }
+      return { hide, show };
+    }
+    /** Did the focused element put this node on screen? */
+    owned(child, focus, rect) {
+      if (focus) {
+        if (this.ownedFiber(child, focus)) return true;
+        if (fiberOf(child) === null) {
+          let scanned = 0;
+          for (const node of Array.from(child.querySelectorAll("*"))) {
+            if (++scanned > PORTAL_SCAN) break;
+            if (this.ownedFiber(node, focus)) return true;
+          }
+        }
+        return false;
+      }
+      if (!this.baseline || child.parentElement !== document.body || this.baseline.has(child)) return false;
+      const b = child.getBoundingClientRect();
+      return b.width > 0 && b.height > 0 && b.left < rect.right && b.right > rect.left && b.top < rect.bottom && b.bottom > rect.top;
+    }
+    /** Does `node`'s fiber ancestry pass through the focused element's fiber? */
+    ownedFiber(node, focus) {
+      let f = fiberOf(node);
+      const alt = focus.alternate ?? null;
+      for (let steps = 0; f && steps < MAX_FIBER_WALK; steps++, f = f.return) {
+        if (f === focus || f === alt || (f.alternate ?? null) === focus) return true;
+      }
+      return false;
+    }
+    mark(hide, show) {
+      const next = new Set(hide);
+      for (const el of show) next.add(el);
+      for (const el of this.marked) if (!next.has(el)) el.removeAttribute(SPOT_ATTR);
+      for (const el of hide) if (el.getAttribute(SPOT_ATTR) !== "0") el.setAttribute(SPOT_ATTR, "0");
+      for (const el of show) if (el.getAttribute(SPOT_ATTR) !== "1") el.setAttribute(SPOT_ATTR, "1");
+      this.marked = next;
+    }
+    clearMarks() {
+      for (const el of this.marked) el.removeAttribute(SPOT_ATTR);
+      this.marked = /* @__PURE__ */ new Set();
+    }
+    write(text) {
+      this.text = text;
+      if (!this.ensureStyle()) return;
+      if (this.style.textContent !== text) this.style.textContent = text;
+    }
+    /**
+     * The sheet lives on `<html>`, not in the override stylesheet, so the two
+     * can never fight — and it has to exist before the document has a `<body>`,
+     * which is the whole point of arming.
+     */
+    ensureStyle() {
+      if (this.style && this.style.isConnected) return true;
+      const host = document.documentElement;
+      if (!host) {
+        this.waitForRoot();
+        return false;
+      }
+      const style = document.createElement("style");
+      style.id = SPOT_STYLE_ID;
+      style.textContent = this.text;
+      host.appendChild(style);
+      this.style = style;
+      return true;
+    }
+    waitForRoot() {
+      if (this.rootWatch || typeof MutationObserver === "undefined") return;
+      this.rootWatch = new MutationObserver(() => {
+        if (!document.documentElement) return;
+        this.rootWatch?.disconnect();
+        this.rootWatch = null;
+        this.write(this.text);
+        this.refresh();
+      });
+      this.rootWatch.observe(document, { childList: true, subtree: true });
+    }
+    emitState() {
+      emit("spotlight", this.state());
+    }
+  };
+  var RuntimeParams = class {
+    constructor() {
+      this.values = {};
+      this.subs = /* @__PURE__ */ new Set();
+      /** Channels the page has read at least once, this document. */
+      this.claimed = /* @__PURE__ */ new Set();
+      /** Before/after: suspended, every read falls through to the page's own value. */
+      this.enabled = true;
+    }
+    api() {
+      return {
+        get: (name, fallback) => {
+          if (!this.claimed.has(name)) {
+            this.claimed.add(name);
+            emit("claims", { channels: Array.from(this.claimed) });
+          }
+          if (!this.enabled) return fallback;
+          const v = this.values[name];
+          return v === void 0 ? fallback : v;
+        },
+        all: () => ({ ...this.values }),
+        subscribe: (fn) => {
+          this.subs.add(fn);
+          return () => this.subs.delete(fn);
+        }
+      };
+    }
+    set(values, enabled) {
+      this.values = values;
+      this.enabled = enabled;
+      this.notify();
+    }
+    claims() {
+      return Array.from(this.claimed);
+    }
+    // A page that reads parameters in render needs a nudge to render again, and
+    // there is no general way to ask a framework for one. So: tell subscribers,
+    // and dispatch a DOM event for anything that would rather listen than
+    // subscribe. Both carry the values, so neither has to read back.
+    notify() {
+      const snapshot = { ...this.values };
+      for (const fn of this.subs) {
+        try {
+          fn(snapshot);
+        } catch {
+        }
+      }
+      try {
+        window.dispatchEvent(new CustomEvent("bp:params", { detail: snapshot }));
+      } catch {
+      }
+    }
+  };
+  var SCROLL_SETTLE_MS = 150;
+  var LOOP_ACTIVE_MS = 500;
+  var LOOP_IDLE_MS = 250;
+  var Probe = class {
+    constructor() {
+      this.overlay = new Overlay();
+      this.params = new RuntimeParams();
+      this.spot = new Spotlight();
+      this.tagSeq = 0;
+      this.hoverEl = null;
+      this.hoverLabel = null;
+      /** How the hover landed: the pointer carries the cursor label, a path
+       *  (layers preview) keeps the ring's own tab — no cursor to follow. */
+      this.hoverVia = "pointer";
+      this.selEl = null;
+      this.rafId = null;
+      /** Standing annotation markers the host asked for — see `decorate`. */
+      this.decorations = [];
+      /** When each mark's path first failed to resolve — a mark only falls back
+       *  to its stored snapshot after a settle, so a booting document (elements
+       *  three renders away) never flashes gray markers at stale positions. */
+      this.unresolvedSince = /* @__PURE__ */ new Map();
+      /** The marker under the pointer, owning the hover construction. */
+      this.markerHoverPath = null;
+      this.mutationRaf = null;
+      this.declRaf = null;
+      /** When the last activity signal landed — the loop's full-rate window. */
+      this.lastActivityAt = 0;
+      /** Hover suppression window while the page scrolls. */
+      this.scrollingUntil = 0;
+      this.idleTimer = null;
+      this.activityAttached = false;
+      /**
+       * Tags someone *else* owns — an override stylesheet, a pin.
+       *
+       * The selection hands its tag back when it moves on; a held one never does,
+       * because the rule addressing it outlives the pick that wrote it. Without
+       * this, the tweak you just tuned came undone the moment you inspected the
+       * next element: `[data-bp-sel="7"]` stopped matching anything.
+       *
+       * Tag values, not elements: a page that re-renders the node away leaves a
+       * short dead string here rather than a detached `Element` this set would
+       * otherwise keep alive for the session.
+       */
+      this.heldTags = /* @__PURE__ */ new Set();
+      this.onScroll = () => {
+        this.scrollingUntil = performance.now() + SCROLL_SETTLE_MS;
+        if (this.hoverEl) {
+          this.hoverEl = null;
+          this.hoverLabel = null;
+          this.overlay.hideCursor(false);
+          this.overlay.drawHover(null, null);
+        }
+        this.wake();
+      };
+      this.onResize = () => this.wake();
+      this.onMotion = () => this.wake();
+      this.watch();
+      this.tick = this.tick.bind(this);
+      this.overlay.markerHover = (path) => {
+        this.markerHoverPath = path;
+        this.wake();
+      };
+      window.__bpParams = this.params.api();
+      if (typeof window.__bpSpot === "string") this.spot.set(window.__bpSpot);
+      window.addEventListener("bp:declare", () => this.emitDeclarations());
+      if (window.__bpDecl && window.__bpDecl.rev > 0) this.emitDeclarations();
+      emit("ready", { url: location.href });
+      const painted = () => {
+        requestAnimationFrame(
+          () => requestAnimationFrame(() => emit("painted", { url: location.href }))
+        );
+      };
+      if (document.readyState === "complete") painted();
+      else window.addEventListener("load", painted, { once: true });
+    }
+    /** The page's declared parameters, in registration order. */
+    declared() {
+      const reg = window.__bpDecl;
+      return reg ? Object.values(reg.params) : [];
+    }
+    // Coalesced to a frame: HMR replaces a module and every `useParam` in it
+    // re-registers in one burst, which must land as one event, not a storm.
+    emitDeclarations() {
+      if (this.declRaf !== null) return;
+      this.declRaf = requestAnimationFrame(() => {
+        this.declRaf = null;
+        emit("declarations", { params: this.declared() });
+      });
+    }
+    /** Push the card's runtime parameters. `enabled` is the before/after gate. */
+    setParams(values, enabled) {
+      this.params.set(values, enabled);
+    }
+    /** Which channels the page has read, this document. */
+    claimedChannels() {
+      return this.params.claims();
+    }
+    setOverlay(config) {
+      if (config.colors) this.overlay.setColors(config.colors);
+      if (config.suppressSelection !== void 0) {
+        this.overlay.suppressSelection = config.suppressSelection;
+        if (config.suppressSelection) this.overlay.drawSelection(null);
+      }
+      if (config.pointing !== void 0) this.overlay.pointing = config.pointing;
+      if (config.visible !== void 0) {
+        this.overlay.visible = config.visible;
+        if (!config.visible) {
+          this.hoverEl = null;
+          this.hoverLabel = null;
+          this.overlay.hideAll();
+          this.stopLoop();
+          this.detachActivity();
+        } else {
+          this.attachActivity();
+          this.wake();
+        }
+      }
+      if (config.pointing !== void 0 || config.visible !== void 0) this.overlay.syncCursorStyle();
+    }
+    /**
+     * Standing annotation markers: the ordinals the host says stand on these
+     * elements. Standing chrome — redrawn every frame with the rings, cleared
+     * only by the host (never by `clearSelection`), and the one pointer-active
+     * piece of the overlay: a marker click answers the host, not the page
+     * (`markerClick` emit for wire hosts, `onMarkerClick` for in-page ones).
+     */
+    decorate(marks) {
+      this.decorations = marks;
+      this.wake();
+    }
+    onMarkerClick(handler) {
+      this.overlay.markerHandler = handler;
+    }
+    hover(x, y) {
+      const mark = this.overlay.markerAtPoint(x, y);
+      if (mark) {
+        if (this.markerHoverPath !== mark.path) {
+          this.markerHoverPath = mark.path;
+          this.wake();
+        }
+        this.hoverEl = null;
+        this.hoverLabel = null;
+        this.overlay.hideCursor(false);
+        this.overlay.drawHover(null, null);
+        emit("hover", null);
+        return null;
+      }
+      if (this.markerHoverPath !== null) {
+        this.markerHoverPath = null;
+        this.wake();
+      }
+      const el = elementAtPoint(x, y);
+      this.hoverEl = el;
+      this.hoverVia = "pointer";
+      const crumb = el ? crumbLite(el) : null;
+      this.hoverLabel = crumb?.label ?? null;
+      const suppressed = performance.now() < this.scrollingUntil;
+      const shown = !suppressed && el !== null && el !== this.selEl;
+      this.overlay.setHoverTab(false);
+      this.overlay.drawHover(shown && el ? targetOf(el) : null, this.hoverLabel);
+      if (shown && this.hoverLabel) this.overlay.drawCursor(x, y, this.hoverLabel);
+      else this.overlay.hideCursor(!suppressed);
+      this.wake();
+      emit("hover", crumb);
+      return crumb;
+    }
+    hoverOff() {
+      this.hoverEl = null;
+      this.hoverLabel = null;
+      this.overlay.hideCursor(true);
+      this.overlay.drawHover(null, null);
+      emit("hover", null);
+    }
+    /** Draw the hover construction on the element at `path` — the layers
+     *  list's row preview. Draw-only: no `hover` emission, so the last pointer
+     *  crumb (what an annotate click places a pin from) is untouched. */
+    hoverPath(path) {
+      const el = elementAt(path);
+      this.hoverEl = el;
+      this.hoverVia = "path";
+      this.hoverLabel = el ? labelOf(el) : null;
+      this.overlay.hideCursor(false);
+      this.overlay.setHoverTab(true);
+      this.overlay.drawHover(el && el !== this.selEl ? targetOf(el) : null, this.hoverLabel);
+      this.wake();
+    }
+    select(x, y) {
+      const mark = this.overlay.markerAtPoint(x, y);
+      if (mark) {
+        this.overlay.markerHandler?.(mark.path, mark.ordinal);
+        emit("markerClick", { path: mark.path, ordinal: mark.ordinal });
+        return null;
+      }
+      const el = elementAtPoint(x, y);
+      if (!el) return null;
+      return this.commitSelection(el, true);
+    }
+    selectPath(path) {
+      const el = elementAt(path);
+      return el ? this.commitSelection(el) : null;
+    }
+    /** A stable, unique tag for an element, so `[data-bp-sel="v"]` matches
+     *  exactly one node — pins and the selection can coexist without collision. */
+    tag(el) {
+      const existing = el.getAttribute(SEL_ATTR);
+      if (existing) return existing;
+      const v = String(++this.tagSeq);
+      el.setAttribute(SEL_ATTR, v);
+      return v;
+    }
+    /** Whether the selection may reclaim this element's tag. */
+    tagHeld(el) {
+      const tag = el.getAttribute(SEL_ATTR);
+      return tag !== null && this.heldTags.has(tag);
+    }
+    commitSelection(el, viaPointer = false) {
+      const fresh = el !== this.selEl;
+      if (this.selEl && this.selEl !== el && this.selEl.getAttribute(SEL_ATTR) && !this.tagHeld(this.selEl)) {
+        this.selEl.removeAttribute(SEL_ATTR);
+      }
+      this.selEl = el;
+      this.tag(el);
+      const ref = refOf(el);
+      this.overlay.setSelectionLabel(labelOf(el));
+      this.overlay.drawSelection(targetOf(el));
+      this.overlay.drawHover(null, null);
+      if (viaPointer && fresh) this.overlay.handOff();
+      else this.overlay.hideCursor(viaPointer);
+      this.wake();
+      return ref;
+    }
+    clearSelection() {
+      if (this.selEl && !this.tagHeld(this.selEl)) this.selEl.removeAttribute(SEL_ATTR);
+      this.selEl = null;
+      this.overlay.drawSelection(null);
+      this.wake();
+    }
+    describe(path) {
+      const el = elementAt(path);
+      return el ? refOf(el) : null;
+    }
+    rects(paths) {
+      return paths.map((p) => {
+        const el = elementAt(p);
+        return el ? markRect(p, el) : null;
+      });
+    }
+    scope(scope) {
+      if (!scope.componentKey) return elementAt(scope.elementPath) ? [scope.elementPath] : [];
+      const [name, ownerPath = ""] = scope.componentKey.split("@");
+      const variant = scope.variant;
+      const find = (owner2) => {
+        const found = [];
+        let scanned = 0;
+        for (const node of Array.from(owner2.querySelectorAll("*"))) {
+          if (++scanned > MAX_SCAN) break;
+          const nc = nearestComponent(node);
+          if (nc?.name !== name || componentRoot(node) !== node) continue;
+          if (variant && !matchesVariant(node, variant)) continue;
+          found.push(node);
+        }
+        return found;
+      };
+      const mount = mountRoot();
+      const owner = elementAt(ownerPath) ?? mount;
+      let roots = find(owner);
+      if (roots.length === 0 && owner !== mount) roots = find(mount);
+      roots.sort((a, b) => comparePaths(pathOf(a) ?? "", pathOf(b) ?? ""));
+      const chosen = scope.instanceIndex === void 0 ? roots : roots.filter((_, i) => i === scope.instanceIndex);
+      const inner = scope.innerPath ?? "";
+      return chosen.map((root) => {
+        const rp = pathOf(root);
+        if (rp === null) return null;
+        const full = inner === "" ? rp : rp === "" ? inner : `${rp}/${inner}`;
+        return elementAt(full) ? full : null;
+      }).filter((p) => p !== null);
+    }
+    /** Ensure the element at `path` carries `data-bp-sel` so main can find its
+     *  CDP nodeId for pinning. Returns the selector value, or null. */
+    ensureTag(path) {
+      const el = elementAt(path);
+      if (!el) return null;
+      const tag = this.tag(el);
+      this.heldTags.add(tag);
+      return tag;
+    }
+    /**
+     * Hand held tags back — `null` releases every one (Reset, a host dropping
+     * its whole override sheet). The element the selection is still on keeps its
+     * attribute; every other loses it, so the page is left carrying nothing
+     * Blueprint put there.
+     */
+    releaseTags(paths) {
+      const tags = paths === null ? [...this.heldTags] : paths.map((p) => elementAt(p)?.getAttribute(SEL_ATTR) ?? null).filter((tag) => tag !== null);
+      for (const tag of tags) {
+        this.heldTags.delete(tag);
+        const el = document.querySelector(`[${SEL_ATTR}="${CSS.escape(tag)}"]`);
+        if (el && el !== this.selEl) el.removeAttribute(SEL_ATTR);
+      }
+      if (paths === null) this.heldTags.clear();
+    }
+    /** Computed style values for the element at `path` — the pin test reads the
+     *  forced :hover background here, and phase 3 derives parameters from it. */
+    /**
+     * A durable CSS selector for the element at `path` — the beam's own address.
+     *
+     * The inverse of `query`, and the reason a capture can cross a process
+     * boundary at all: a path is measured against one render, a selector is
+     * re-resolved against every later one. See `printSelector`.
+     */
+    selectorFor(path) {
+      const el = elementAt(path);
+      return el ? printSelector(el) : null;
+    }
+    /** Child-index path of the first element matching a CSS selector, or null.
+     *  Provenance (phase 3) and the conformance suite both address by selector. */
+    query(selector) {
+      let el = null;
+      try {
+        el = mountRoot().querySelector(selector);
+      } catch {
+        return null;
+      }
+      return el ? pathOf(el) : null;
+    }
+    computed(path, props) {
+      const el = elementAt(path);
+      if (!el) return null;
+      const cs = getComputedStyle(el);
+      const out = {};
+      for (const prop of props) out[prop] = cs.getPropertyValue(prop);
+      return out;
+    }
+    /** `computed`, for a whole subtree at once — see `PageProbe.sample`. */
+    sample(paths, props) {
+      return paths.map((path) => this.computed(path, props));
+    }
+    /**
+     * The page's color variables (mirrors `PageColorVariable`): every custom
+     * property declared on the root by the page's own stylesheets — Tailwind
+     * v4's `@theme` lands as `:root, :host { --color-…}` inside `@layer
+     * theme`, so grouping rules are walked — resolved off the root and kept
+     * where the value is a color. Cross-origin sheets can't be read and are
+     * skipped; a sheet Blueprint injected is the page's too, and harmless.
+     */
+    colorVariables() {
+      const names = /* @__PURE__ */ new Set();
+      const rootish = /(^|[\s,])(:root|html|:host)(\b|[\s,:])/;
+      const walk = (rules) => {
+        for (const rule of Array.from(rules)) {
+          if (rule instanceof CSSStyleRule) {
+            if (!rootish.test(rule.selectorText)) continue;
+            for (let i = 0; i < rule.style.length; i++) {
+              const prop = rule.style[i];
+              if (prop && prop.startsWith("--")) names.add(prop);
+            }
+          } else if ("cssRules" in rule) {
+            walk(rule.cssRules);
+          }
+          if (names.size > 600) return;
+        }
+      };
+      for (const sheet of Array.from(document.styleSheets)) {
+        try {
+          walk(sheet.cssRules);
+        } catch {
+        }
+      }
+      const cs = getComputedStyle(document.documentElement);
+      const out = [];
+      for (const name of [...names].sort()) {
+        const value = cs.getPropertyValue(name).trim();
+        if (value && CSS.supports("color", value)) out.push({ name, value });
+      }
+      return out;
+    }
+    /** What the overlay is drawing right now — a test/debug read, so the suite
+     *  can assert against the painted chrome rather than the element rects. */
+    overlayState() {
+      return this.overlay.state();
+    }
+    /**
+     * The component behind an element, described for a sandbox request: what
+     * it was rendered *with*, and what it was rendered *inside*.
+     *
+     * `wrappedBy` is every named component up the fiber tree, outermost first —
+     * the provider chain as Blueprint can see it. Blueprint doesn't try to guess
+     * which of them are providers; the agent knows the codebase and can.
+     */
+    describeComponent(path) {
+      const el = elementAt(path);
+      if (!el) return null;
+      const near = nearestComponent(el);
+      if (!near) return null;
+      const wrappedBy = [];
+      let f = near.fiber.return;
+      for (let i = 0; f && i < MAX_FIBER_WALK && wrappedBy.length < 12; i++, f = f.return) {
+        const name = fiberName(f.type);
+        if (name && wrappedBy[0] !== name) wrappedBy.unshift(name);
+      }
+      return { name: near.name, props: summariseProps(near.fiber.memoizedProps), wrappedBy };
+    }
+    /** What a sandbox page says about itself, or null on any other page.
+     *  The entry owns the fact; Blueprint owns the state drawn over the card. */
+    sandbox() {
+      return window.__bpSandbox ?? null;
+    }
+    /** Show only the element at `path`, its ancestors and what it opened;
+     *  `null` lifts it. See `Spotlight`. */
+    spotlight(path) {
+      this.spot.set(path);
+    }
+    /** Whether the spotlight is armed or applied, and how much it is hiding. */
+    spotlightState() {
+      return this.spot.state();
+    }
+    /**
+     * The element tree in document order, for the layers list. Depth-first from
+     * the mount root, capped at `maxNodes` with the cut declared — never silent.
+     * `name` is the component where the element is a component root (the unit a
+     * person thinks in), the DOM tag otherwise.
+     */
+    tree(maxNodes = MAX_TREE) {
+      const nodes = [];
+      let truncated = false;
+      const walk = (el, depth) => {
+        for (const child of Array.from(el.children)) {
+          if (child.id === OVERLAY_ID) continue;
+          if (nodes.length >= maxNodes) {
+            truncated = true;
+            return false;
+          }
+          const path = pathOf(child);
+          if (path === null) continue;
+          const comp = componentRoot(child) === child ? componentNameOf(child) : void 0;
+          nodes.push({
+            path,
+            tag: child.tagName.toLowerCase(),
+            name: comp ?? child.tagName.toLowerCase(),
+            component: comp !== void 0,
+            depth,
+            text: hasOwnText(child)
+          });
+          if (!walk(child, depth + 1)) return false;
+        }
+        return true;
+      };
+      walk(mountRoot(), 0);
+      return { nodes, truncated };
+    }
+    /**
+     * The element at `path`, as a live handle.
+     *
+     * Only ever useful to an **in-page** host: over CDP a DOM node cannot cross
+     * the wire, which is why every other method here answers in paths and rects.
+     * Beam's driver runs in the same document as the probe, so it can ask
+     * directly rather than re-implementing the walk — one addressing scheme, not
+     * two (`packages/probe/src/beam.ts`).
+     */
+    nodeAt(path) {
+      return elementAt(path);
+    }
+    /** Path for a live element handle — main resolves an animation's target
+     *  (`DOM.resolveNode` → `Runtime.callFunctionOn`) through this, so the
+     *  Live motion strip can scope itself with the same addressing scheme
+     *  selection uses. */
+    pathForElement(el) {
+      return el instanceof Element ? pathOf(el) : null;
+    }
+    /**
+     * The pseudo-states that are *live* around the element at `path` right now
+     * — candidates, not conclusions.
+     *
+     * A capture leaving this page (Beam's crossing, the beam driver) carries
+     * them so the card can try them once resolving the selector bare has
+     * failed; the cost of over-guessing is one retry rather than a static
+     * element arriving pinned. What earns a place is a signal that something is
+     * *held open*: an expanded trigger, a focused control, or the immediate
+     * ancestors the pointer is on (which is how `.parent:hover .child` and
+     * `group-hover` work). Deliberately short — a card wearing four pins that
+     * changed nothing is a lie about why it looks the way it does.
+     */
+    candidatePins(path) {
+      const el = elementAt(path);
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      const add = (node, states) => {
+        if (!node || out.length >= MAX_CANDIDATES || node === document.body || node === document.documentElement) return;
+        const selector = printSelector(node);
+        if (!selector || seen.has(selector)) return;
+        seen.add(selector);
+        out.push({ selector, states });
+      };
+      let expanded = 0;
+      for (const node of Array.from(document.querySelectorAll('[aria-expanded="true"]'))) {
+        if (++expanded > 2) break;
+        add(node, ["hover", "focus"]);
+      }
+      if (el) {
+        let node = el.parentElement;
+        for (let i = 0; node && i < 2; i++, node = node.parentElement) {
+          if (node.matches(":hover")) add(node, ["hover"]);
+        }
+      }
+      const active = document.activeElement;
+      if (active && active !== document.body && !(el && el.contains(active))) add(active, ["focus"]);
+      return out;
+    }
+    pauseAnimations() {
+      for (const anim of document.getAnimations?.() ?? []) anim.pause();
+    }
+    resumeAnimations() {
+      for (const anim of document.getAnimations?.() ?? []) anim.play();
+    }
+    // Re-measure while visible: the whole reason the rings live in the page.
+    // Frame rate while anything moves; `LOOP_IDLE_MS` sampling once everything
+    // drawn has held still past `LOOP_ACTIVE_MS`; parked outright with nothing
+    // drawn. Any activity signal (`wake`) restores frame rate.
+    startLoop() {
+      if (this.idleTimer !== null) {
+        clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+      }
+      if (this.rafId === null) this.rafId = requestAnimationFrame(this.tick);
+    }
+    stopLoop() {
+      if (this.rafId !== null) cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+      if (this.idleTimer !== null) clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    wake() {
+      this.lastActivityAt = performance.now();
+      if (this.overlay.visible) this.startLoop();
+    }
+    /** Scroll and resize can move what the rings track without a single DOM
+     *  mutation — listened only while the overlay is up. Capture, because
+     *  `scroll` doesn't bubble but does capture through the light tree. */
+    attachActivity() {
+      if (this.activityAttached) return;
+      this.activityAttached = true;
+      window.addEventListener("scroll", this.onScroll, { capture: true, passive: true });
+      window.addEventListener("resize", this.onResize, { passive: true });
+      window.addEventListener("animationstart", this.onMotion, { capture: true, passive: true });
+      window.addEventListener("transitionrun", this.onMotion, { capture: true, passive: true });
+    }
+    detachActivity() {
+      if (!this.activityAttached) return;
+      this.activityAttached = false;
+      window.removeEventListener("scroll", this.onScroll, true);
+      window.removeEventListener("resize", this.onResize);
+      window.removeEventListener("animationstart", this.onMotion, true);
+      window.removeEventListener("transitionrun", this.onMotion, true);
+    }
+    tick() {
+      this.rafId = null;
+      if (!this.overlay.visible) return;
+      const now = performance.now();
+      const scrolling = now < this.scrollingUntil;
+      const hoverMark = this.markerHoverPath;
+      const draws = [];
+      const status = [];
+      const ringed = /* @__PURE__ */ new Set();
+      let fused = false;
+      let fusedResolved = false;
+      let settling = false;
+      for (const d of this.decorations) {
+        const el = elementAt(d.path);
+        const alive = el !== null && el.isConnected;
+        if (alive) this.unresolvedSince.delete(d.path);
+        else {
+          const since = this.unresolvedSince.get(d.path) ?? now;
+          if (this.unresolvedSince.get(d.path) === void 0) this.unresolvedSince.set(d.path, now);
+          if (now - since < DETACH_SETTLE_MS) {
+            settling = true;
+            continue;
+          }
+          if (!d.fallbackRect) continue;
+        }
+        const onSelection = alive && el === this.selEl;
+        if (onSelection) {
+          fused = true;
+          fusedResolved = d.status === "resolved";
+        }
+        const agent = alive ? d.agent : void 0;
+        if (agent && el) {
+          ringed.add(el);
+          status.push({ key: d.path, state: agent, target: markTarget(d.path, el), fused: true });
+        }
+        draws.push({
+          key: d.path,
+          ordinal: d.ordinal,
+          rect: alive ? markRect(d.path, el) : d.fallbackRect,
+          fused: onSelection || agent !== void 0 || alive && d.path === hoverMark,
+          status: d.status ?? "sent",
+          detached: !alive,
+          ...agent ? { agent } : {}
+        });
+      }
+      const selTarget = this.selEl && this.selEl.isConnected ? targetOf(this.selEl) : null;
+      let hoverLost = false;
+      if (this.hoverEl && !this.hoverEl.isConnected) {
+        this.hoverEl = null;
+        this.hoverLabel = null;
+        hoverLost = true;
+      }
+      const hoverMarkEl = hoverMark ? elementAt(hoverMark) : null;
+      const markHover = hoverMark !== null && hoverMarkEl && hoverMarkEl.isConnected && !ringed.has(hoverMarkEl) ? {
+        target: hoverMarkEl !== this.selEl ? markTarget(hoverMark, hoverMarkEl) : null,
+        label: labelOf(hoverMarkEl),
+        resolved: draws.some((d) => d.key === hoverMark && d.status === "resolved")
+      } : null;
+      const hoverTarget = !markHover && this.hoverEl && this.hoverEl !== this.selEl && !ringed.has(this.hoverEl) ? targetOf(this.hoverEl) : null;
+      let movedAny = false;
+      if (this.overlay.drawStatus(status)) movedAny = true;
+      this.overlay.setSelectionFused(fused, fusedResolved);
+      if (this.selEl) {
+        if (selTarget) {
+          const standDown = ringed.has(this.selEl);
+          if (this.overlay.drawSelection(standDown ? null : selTarget)) movedAny = true;
+        } else {
+          this.clearSelection();
+          movedAny = true;
+        }
+      }
+      if (markHover) {
+        this.overlay.setHoverTab(true);
+        this.overlay.hideCursor(true);
+        this.overlay.setHoverAccent(true, markHover.resolved);
+        this.overlay.setHoverFused(true);
+        if (this.overlay.drawHover(scrolling ? null : markHover.target, markHover.label)) movedAny = true;
+      } else {
+        this.overlay.setHoverAccent(false);
+        this.overlay.setHoverFused(false);
+        this.overlay.setHoverTab(this.hoverVia === "path");
+        if (this.hoverEl) {
+          if (this.overlay.drawHover(scrolling ? null : hoverTarget, this.hoverLabel)) movedAny = true;
+        } else if (hoverMark || hoverLost) {
+          if (hoverLost) this.overlay.hideCursor(false);
+          if (this.overlay.drawHover(null, null)) movedAny = true;
+        }
+      }
+      if (this.overlay.drawMarkers(draws)) movedAny = true;
+      if (movedAny) this.lastActivityAt = now;
+      const nothingShown = draws.length === 0 && status.length === 0 && !settling && !this.selEl && !this.hoverEl && !hoverMark;
+      if (nothingShown) return;
+      if (scrolling || now - this.lastActivityAt < LOOP_ACTIVE_MS) {
+        this.startLoop();
+      } else {
+        this.idleTimer = setTimeout(() => {
+          this.idleTimer = null;
+          this.startLoop();
+        }, LOOP_IDLE_MS);
+      }
+    }
+    // Content shape changes re-anchor scoped params and pins on the host side.
+    watch() {
+      const ping = () => {
+        this.wake();
+        if (this.mutationRaf !== null) return;
+        this.mutationRaf = requestAnimationFrame(() => {
+          this.mutationRaf = null;
+          this.spot.refresh();
+          emit("contentChanged");
+        });
+      };
+      const ours = (r) => r.type === "attributes" && (r.attributeName === SPOT_ATTR || r.attributeName === SEL_ATTR);
+      const start = () => {
+        const mount = mountRoot();
+        const mo = new MutationObserver((records) => {
+          if (records.every(ours)) return;
+          ping();
+        });
+        mo.observe(mount, { childList: true, subtree: true, attributes: true, characterData: true });
+        if (typeof ResizeObserver !== "undefined") {
+          const ro = new ResizeObserver(ping);
+          ro.observe(mount);
+        }
+      };
+      if (document.body) start();
+      else document.addEventListener("DOMContentLoaded", start, { once: true });
+    }
+  };
+  var HOLD_KEYS = /* @__PURE__ */ new Set(["Meta", "Alt", "Shift", "Control"]);
+  var PRINTABLE_HOLDS = /* @__PURE__ */ new Set(["c", "`"]);
+  function typingHere(e) {
+    const target = e.composedPath()[0];
+    if (!(target instanceof HTMLElement)) return false;
+    return target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.tagName === "SELECT" || target.isContentEditable;
+  }
+  function forwardHolds() {
+    const send = (kind, e, key) => {
+      emit("keyHold", { kind, key, meta: e.metaKey, alt: e.altKey, ctrl: e.ctrlKey });
+    };
+    window.addEventListener(
+      "keydown",
+      (e) => {
+        if (!window.__bpEmit || e.repeat) return;
+        if (HOLD_KEYS.has(e.key)) {
+          send("down", e, e.key);
+          return;
+        }
+        if (e.metaKey || e.altKey) {
+          send("chord", e);
+          return;
+        }
+        const key = e.key.toLowerCase();
+        if (PRINTABLE_HOLDS.has(key) && !e.ctrlKey && !typingHere(e)) send("down", e, key);
+      },
+      true
+    );
+    window.addEventListener(
+      "keyup",
+      (e) => {
+        if (!window.__bpEmit) return;
+        const key = HOLD_KEYS.has(e.key) ? e.key : e.key.toLowerCase();
+        if (HOLD_KEYS.has(key) || PRINTABLE_HOLDS.has(key)) send("up", e, key);
+      },
+      true
+    );
+  }
+  function forwardZoom() {
+    window.addEventListener(
+      "wheel",
+      (e) => {
+        if (!window.__bpEmit || !window.__bpZoomToHost) return;
+        if (!e.ctrlKey && !e.metaKey) return;
+        e.preventDefault();
+        emit("wheelZoom", { deltaY: e.deltaY, deltaMode: e.deltaMode, x: e.clientX, y: e.clientY });
+      },
+      // Non-passive, or `preventDefault` is a no-op and the browser zooms
+      // anyway — the same lesson the canvas root's listener carries.
+      { passive: false, capture: true }
+    );
+  }
+  function install() {
+    if (window.__bp) return;
+    window.__bp = new Probe();
+    forwardHolds();
+    forwardZoom();
+  }
+  if (window.__bpDeferInstall) window.__bpInstall = install;
+  else install();
+})();