agentglow 0.2.10 → 0.2.11

package/dist/chunks/index-CeiIEWek.js

@@ -0,0 +1,818 @@
+import { jsxs as J, jsx as r } from "react/jsx-runtime";
+import { EffectComposer as Et, Bloom as Ot, Vignette as Vt, Noise as Wt } from "@react-three/postprocessing";
+import { useThree as Lt, useFrame as le } from "@react-three/fiber";
+import { useMemo as i, useRef as U, useEffect as Ct, useState as kt } from "react";
+import * as t from "three";
+import { F as ht, r as Bt, n as pt, w as Z, L as dt, a as ie, d as Dt, T as Ze, v as Nt, z as Ue, l as Xt, e as qt, f as ze, S as Pe, R as jt, j as Ht, A as Zt, g as Pt, b as it, K as ct, o as Kt, G as $t, q as Yt, m as Jt } from "./KitScene-DG_pcnWW.js";
+import { Trail as Tt } from "@react-three/drei";
+const Ee = Bt ? 0.25 : 1, Qt = {
+  ...ht,
+  name: "ocean-drift",
+  run(e, o, n) {
+    ht.run(e, o, n), n.angle = -Math.PI / 2;
+  }
+}, Gt = (e, o) => Math.sin(e * 0.32 + o * 1.9) * 0.45 + Math.sin(e * 0.11 + o) * 0.3, Rt = (e, o) => Math.sin(e * 0.2 + o * 0.7) * 0.35;
+function Ut(e) {
+  let o = 7;
+  for (let n = 0; n < e.length; n++) o = o * 31 + e.charCodeAt(n) >>> 0;
+  return o;
+}
+const $e = new t.Vector3(0.95, 0.75, 0.25), Ne = 1.15;
+function Xe(e, o) {
+  const n = pt.mcp.get(e);
+  if (!n) return;
+  const s = n.out.x > 0 ? -1 : 1;
+  return o.set(n.pos.x + $e.x * s * Ne, n.pos.y + $e.y * Ne, n.pos.z + $e.z * Ne * s);
+}
+const ae = (e) => e < 0 ? 0 : e > 1 ? 1 : e, en = (e) => 1 - Math.pow(1 - e, 3), tn = (e) => 1 + 2.9 * Math.pow(e - 1, 3) + 1.9 * Math.pow(e - 1, 2), Te = new t.Vector3();
+function qe(e, o, n, s, d) {
+  Te.copy(e).add(o).multiplyScalar(0.5), Te.y += s;
+  const y = 1 - n;
+  return d.set(
+    y * y * e.x + 2 * y * n * Te.x + n * n * o.x,
+    y * y * e.y + 2 * y * n * Te.y + n * n * o.y,
+    y * y * e.z + 2 * y * n * Te.z + n * n * o.z
+  );
+}
+let We = null;
+function Fe() {
+  if (We) return We;
+  const e = document.createElement("canvas");
+  e.width = e.height = 64;
+  const o = e.getContext("2d"), n = o.createRadialGradient(32, 32, 0, 32, 32, 32);
+  return n.addColorStop(0, "rgba(255,255,255,1)"), n.addColorStop(0.35, "rgba(255,255,255,0.55)"), n.addColorStop(1, "rgba(255,255,255,0)"), o.fillStyle = n, o.fillRect(0, 0, 64, 64), We = new t.CanvasTexture(e), We;
+}
+function zt(e) {
+  return new t.ShaderMaterial({
+    uniforms: {
+      uColor: { value: new t.Color(e) },
+      uIntensity: { value: 1 },
+      uOpacity: { value: 1 },
+      uFlash: { value: 0 }
+    },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec3 vN; varying vec3 vV; varying vec3 vP;
+      void main() {
+        vP = position;
+        vec4 mv = modelViewMatrix * vec4(position, 1.0);
+        vN = normalize(normalMatrix * normal);
+        vV = normalize(-mv.xyz);
+        gl_Position = projectionMatrix * mv;
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 uColor; uniform float uIntensity; uniform float uOpacity; uniform float uFlash;
+      varying vec3 vN; varying vec3 vV; varying vec3 vP;
+      void main() {
+        float f = pow(1.0 - abs(dot(normalize(vN), normalize(vV))), 2.2);
+        float margin = 1.0 - smoothstep(0.0, 0.22, vP.y);
+        float canals = pow(abs(sin(atan(vP.z, vP.x) * 4.0)), 18.0) * smoothstep(0.05, 0.6, vP.y);
+        float top = smoothstep(0.75, 1.0, vP.y);
+        float b = 0.10 + f * 1.5 + margin * 1.1 + canals * 0.6 + top * 0.25;
+        vec3 c = mix(uColor, vec3(1.0), clamp(uFlash * 0.7 + margin * 0.15, 0.0, 1.0)) * b * uIntensity;
+        float a = clamp((0.18 + f * 0.9 + margin * 0.7) * uOpacity, 0.0, 1.0);
+        gl_FragColor = vec4(c, a);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    side: t.DoubleSide,
+    blending: t.AdditiveBlending
+  });
+}
+function gt(e) {
+  return new t.ShaderMaterial({
+    uniforms: {
+      uColor: { value: new t.Color(e) },
+      uTime: { value: 0 },
+      uReveal: { value: 0 },
+      uFade: { value: 1 },
+      uPulse: { value: -1 },
+      uPulseAmp: { value: 0 },
+      uWidthGlow: { value: 1 }
+    },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec2 vUv;
+      void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 uColor; uniform float uTime; uniform float uReveal; uniform float uFade; uniform float uPulse; uniform float uPulseAmp; uniform float uWidthGlow;
+      varying vec2 vUv;
+      void main() {
+        float u = vUv.x;
+        float flow = pow(0.5 + 0.5 * sin(u * 70.0 - uTime * 2.4), 8.0);
+        float pulse = exp(-pow((u - uPulse) * 22.0, 2.0)) * uPulseAmp;
+        float ends = smoothstep(0.0, 0.07, u) * smoothstep(1.0, 0.93, u);
+        float rev = smoothstep(uReveal, uReveal - 0.04, u);
+        float b = (0.32 + flow * 0.7) * uWidthGlow + pulse * 5.0;
+        vec3 c = mix(uColor, vec3(1.0), clamp(pulse * 0.6, 0.0, 1.0)) * b;
+        float a = ends * rev * uFade;
+        gl_FragColor = vec4(c, a);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    blending: t.AdditiveBlending
+  });
+}
+function nn() {
+  return new t.ShaderMaterial({
+    uniforms: { uTime: { value: 0 }, uPx: { value: 1 } },
+    vertexShader: (
+      /* glsl */
+      `
+      attribute float aSeed;
+      uniform float uTime; uniform float uPx;
+      varying float vA;
+      void main() {
+        vec3 p = position;
+        float H = 24.0;
+        p.y = mod(p.y - uTime * (0.18 + aSeed * 0.25) + 12.0, H) - 10.0;
+        p.x += sin(uTime * 0.3 + aSeed * 40.0) * 0.4;
+        p.z += cos(uTime * 0.23 + aSeed * 23.0) * 0.3;
+        vec4 mv = modelViewMatrix * vec4(p, 1.0);
+        gl_PointSize = (0.5 + aSeed * 1.5) * uPx * (28.0 / -mv.z);
+        vA = (0.12 + aSeed * 0.4) * smoothstep(-10.0, -7.0, p.y) * smoothstep(14.0, 10.0, p.y);
+        gl_Position = projectionMatrix * mv;
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      varying float vA;
+      void main() {
+        float d = length(gl_PointCoord - 0.5);
+        float a = smoothstep(0.5, 0.0, d) * vA;
+        gl_FragColor = vec4(vec3(0.55, 0.8, 1.0), a);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    blending: t.AdditiveBlending
+  });
+}
+function Ge(e) {
+  return new t.ShaderMaterial({
+    uniforms: { uTime: { value: 0 }, uStrength: { value: e }, uSeed: { value: Math.random() * 10 } },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec2 vUv;
+      void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform float uTime; uniform float uStrength; uniform float uSeed;
+      varying vec2 vUv;
+      void main() {
+        float across = exp(-pow((vUv.x - 0.5) * 3.2, 2.0));
+        float down = pow(vUv.y, 1.6);
+        float shimmer = 0.75 + 0.25 * sin(uTime * 0.6 + uSeed + vUv.y * 6.0);
+        float a = across * down * shimmer * uStrength;
+        gl_FragColor = vec4(vec3(0.35, 0.65, 1.0), a);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    side: t.DoubleSide,
+    blending: t.AdditiveBlending
+  });
+}
+function on() {
+  return new t.ShaderMaterial({
+    uniforms: { uTime: { value: 0 } },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec3 vDir;
+      void main() { vDir = normalize(position); gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform float uTime;
+      varying vec3 vDir;
+      void main() {
+        float y = vDir.y;
+        vec3 deep = vec3(0.002, 0.006, 0.014);
+        vec3 mid = vec3(0.006, 0.026, 0.05);
+        vec3 top = vec3(0.02, 0.09, 0.15);
+        vec3 c = mix(deep, mid, smoothstep(-0.35, 0.15, y));
+        c = mix(c, top, smoothstep(0.2, 0.85, y));
+        float caust = pow(0.5 + 0.5 * sin(vDir.x * 18.0 + uTime * 0.4) * sin(vDir.z * 15.0 - uTime * 0.3), 6.0);
+        c += vec3(0.03, 0.08, 0.12) * caust * smoothstep(0.55, 0.95, y);
+        gl_FragColor = vec4(c, 1.0);
+      }`
+    ),
+    side: t.BackSide,
+    depthWrite: !1
+  });
+}
+function rn() {
+  return new t.ShaderMaterial({
+    uniforms: { uTime: { value: 0 } },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec2 vXZ;
+      void main() { vec4 w = modelMatrix * vec4(position, 1.0); vXZ = w.xz; gl_Position = projectionMatrix * viewMatrix * w; }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform float uTime;
+      varying vec2 vXZ;
+      void main() {
+        vec2 p = vXZ;
+        float c1 = sin(p.x * 0.9 + uTime * 0.5 + sin(p.y * 0.7 + uTime * 0.3) * 1.5);
+        float c2 = sin(p.y * 1.1 - uTime * 0.4 + sin(p.x * 0.6 - uTime * 0.2) * 1.7);
+        float caust = pow(0.5 + 0.25 * (c1 + c2), 5.0);
+        float d = length(vec2(p.x * 0.6, (p.y + 3.0)));
+        float fade = smoothstep(22.0, 4.0, d);
+        vec3 sand = vec3(0.012, 0.03, 0.045);
+        vec3 c = sand + vec3(0.05, 0.13, 0.17) * caust;
+        gl_FragColor = vec4(c, fade);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1
+  });
+}
+const Ye = Bt ? 700 : 2200;
+function sn() {
+  const e = Lt((l) => l.viewport.dpr), o = i(on, []), n = i(rn, []), s = i(nn, []), d = i(
+    () => [
+      { x: -7.5, w: 4.5, rz: 0.08, m: Ge(0.07) },
+      { x: 0, w: 6, rz: 0.03, m: Ge(0.09) },
+      { x: 7.5, w: 4.5, rz: -0.06, m: Ge(0.07) },
+      { x: -15, w: 8, rz: 0.15, m: Ge(0.035) },
+      { x: 14, w: 7, rz: -0.12, m: Ge(0.035) }
+    ],
+    []
+  ), y = i(() => {
+    const l = new t.BufferGeometry(), w = new Float32Array(Ye * 3), T = new Float32Array(Ye);
+    for (let G = 0; G < Ye; G++)
+      w[G * 3] = (Math.random() - 0.5) * 50, w[G * 3 + 1] = Math.random() * 24 - 10, w[G * 3 + 2] = Math.random() * 34 - 22, T[G] = Math.random();
+    return l.setAttribute("position", new t.BufferAttribute(w, 3)), l.setAttribute("aSeed", new t.BufferAttribute(T, 1)), l;
+  }, []), p = U(null), A = U(null), c = U(null);
+  return le(({ clock: l }) => {
+    var m, S, I;
+    const w = l.elapsedTime * Ee, T = pt.core;
+    (m = p.current) == null || m.position.set(0, -(T.hh + 4.4), -4);
+    const G = Math.max(1, T.hw / 9);
+    (S = A.current) == null || S.scale.set(G, Math.max(1, T.hh / 6), 1), (I = c.current) == null || I.scale.setScalar(Math.max(1, T.r / 11)), o.uniforms.uTime.value = w, n.uniforms.uTime.value = w, s.uniforms.uTime.value = w, s.uniforms.uPx.value = e;
+    for (const k of d) k.m.uniforms.uTime.value = w;
+  }), /* @__PURE__ */ J("group", { children: [
+    /* @__PURE__ */ r("mesh", { material: o, renderOrder: -10, children: /* @__PURE__ */ r("sphereGeometry", { args: [120, 32, 16] }) }),
+    /* @__PURE__ */ r("mesh", { ref: p, material: n, rotation: [-Math.PI / 2, 0, 0], position: [0, -7.2, -4], children: /* @__PURE__ */ r("planeGeometry", { args: [160, 90, 1, 1] }) }),
+    /* @__PURE__ */ r("group", { ref: A, children: d.map((l, w) => /* @__PURE__ */ r("mesh", { material: l.m, position: [l.x, 3.5, -3.5 - (w > 2 ? 4 : 0)], rotation: [0, 0, l.rz], children: /* @__PURE__ */ r("planeGeometry", { args: [l.w, 24] }) }, w)) }),
+    /* @__PURE__ */ r("group", { ref: c, children: /* @__PURE__ */ r("points", { geometry: y, material: s, frustumCulled: !1 }) })
+  ] });
+}
+const vt = new t.Vector3(0.95, 0.75, 0.25);
+function an({ mcp: e }) {
+  const o = e.srv, n = U(null), s = U(null), d = U(null), y = U(null), p = U(null), A = U(null), c = i(() => new t.Color(o.color), [o.color]), l = i(() => zt(o.color), [o.color]), w = i(() => new t.MeshBasicMaterial({ toneMapped: !1 }), []), T = i(() => new t.SpriteMaterial({ color: o.color, map: Fe(), transparent: !0, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1 }), [o.color]), G = i(() => new t.MeshBasicMaterial({ color: new t.Color(o.color).multiplyScalar(0.8), toneMapped: !1 }), [o.color]), m = i(() => new t.MeshBasicMaterial({ color: new t.Color(2.5, 2.5, 2.5), toneMapped: !1 }), []), S = i(() => new t.MeshBasicMaterial({ color: o.color, transparent: !0, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1, side: t.DoubleSide }), [o.color]), I = i(() => {
+    const z = new t.QuadraticBezierCurve3(new t.Vector3(0.55, 0.35, 0), new t.Vector3(0.75, 1.25, 0), vt);
+    return new t.TubeGeometry(z, 16, 0.018, 4);
+  }, []), k = i(() => performance.now(), []);
+  return le(({ clock: z }) => {
+    var C;
+    const _ = performance.now(), g = z.elapsedTime * Ee, E = Z.mcpServers.get(o.name) ?? o, h = E.inflight > 0, b = Math.exp(-(_ - E.activeAt) / 500), u = Math.min(1, (_ - k) / 1200), O = n.current, v = s.current;
+    if (!O || !v) return;
+    O.position.copy(e.pos), O.position.y += Math.sin(g * 0.45 + E.slot * 2) * 0.2, v.rotation.y = (e.out.x > 0 ? Math.PI : 0) + Math.sin(g * (h ? 2.4 : 0.6)) * (h ? 0.35 : 0.12), v.rotation.z = Math.sin(g * 0.5 + E.slot) * 0.08, v.scale.setScalar(Math.max(1e-3, u * Ne * (1 + b * 0.12))), l.uniforms.uIntensity.value = 0.16 + (h ? 0.18 : 0) + b * 0.45, l.uniforms.uOpacity.value = 0.7 * u;
+    const x = (h ? 2.4 + Math.sin(_ / 110) * 0.9 : 1.2) + b * 4;
+    if (w.color.copy(c).multiplyScalar(x), d.current && d.current.scale.setScalar(1 + b * 0.5 + (h ? 0.15 * Math.sin(_ / 110) : 0)), y.current && (y.current.scale.setScalar(1.6 + b * 2 + (h ? 0.8 : 0)), T.opacity = 0.35 + b * 0.4 + (h ? 0.2 : 0)), p.current) {
+      const R = (_ - E.activeAt) / 1100;
+      p.current.visible = R < 1, p.current.scale.setScalar(0.3 + R * 2.4), S.opacity = Math.max(0, 1 - R) * 0.9;
+    }
+    (C = A.current) == null || C.setOpacity(u * (h ? 1 : 0.75));
+  }), /* @__PURE__ */ J("group", { ref: n, children: [
+    /* @__PURE__ */ J("group", { ref: s, children: [
+      /* @__PURE__ */ r("mesh", { material: l, scale: [0.95, 0.62, 0.55], children: /* @__PURE__ */ r("sphereGeometry", { args: [1, 28, 18] }) }),
+      /* @__PURE__ */ r("mesh", { material: l, position: [0.62, -0.28, 0], rotation: [0, 0, -0.5], scale: [0.5, 0.18, 0.42], children: /* @__PURE__ */ r("sphereGeometry", { args: [1, 16, 10] }) }),
+      /* @__PURE__ */ r("mesh", { material: l, position: [-1.15, 0.05, 0], rotation: [0, 0, Math.PI / 2], scale: [0.6, 0.45, 0.12], children: /* @__PURE__ */ r("coneGeometry", { args: [0.7, 0.9, 12] }) }),
+      /* @__PURE__ */ r("mesh", { material: G, geometry: I }),
+      /* @__PURE__ */ r("mesh", { material: m, position: [0.55, 0.12, 0.42], children: /* @__PURE__ */ r("sphereGeometry", { args: [0.05, 8, 6] }) }),
+      /* @__PURE__ */ J("group", { position: vt, children: [
+        /* @__PURE__ */ r("mesh", { ref: d, material: w, children: /* @__PURE__ */ r("sphereGeometry", { args: [0.13, 16, 12] }) }),
+        /* @__PURE__ */ r("sprite", { ref: y, material: T }),
+        /* @__PURE__ */ r("mesh", { ref: p, material: S, visible: !1, children: /* @__PURE__ */ r("ringGeometry", { args: [0.92, 1, 48] }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ r(dt, { ref: A, position: [0, -1.15, 0], text: `mcp · ${o.name}`, color: o.color, size: 0.3, opacity: 0, pxRange: [9, 13] })
+  ] });
+}
+function cn() {
+  const n = i(() => {
+    const l = new t.BufferGeometry();
+    return l.setAttribute("position", new t.BufferAttribute(new Float32Array(4032), 3)), l.setAttribute("color", new t.BufferAttribute(new Float32Array(4032), 3)), l;
+  }, []), s = i(() => new t.Vector3(), []), d = i(() => new t.Vector3(), []), y = i(() => new t.Color("#f59e0b"), []), p = i(() => new t.Color("#ef4444"), []), A = i(() => new t.Color(1, 1, 1), []), c = i(() => new t.Color(), []);
+  return le(({ clock: l }) => {
+    var _;
+    const w = performance.now(), T = l.elapsedTime, G = n.getAttribute("position"), m = n.getAttribute("color"), S = G.array, I = m.array;
+    let k = 0;
+    const z = (g, E, h) => {
+      for (let b = 0; b < 28; b++)
+        for (let u = 0; u < 2; u++) {
+          const O = (b + u) / 28, v = ((k * 28 + b) * 2 + u) * 3;
+          qe(g, E, O, 1.6, s);
+          const x = Math.sin(O * 14 - T * 5) * 0.05 * Math.sin(O * Math.PI);
+          S[v] = s.x, S[v + 1] = s.y + x, S[v + 2] = s.z;
+          const C = h(O);
+          I[v] = c.r * C, I[v + 1] = c.g * C, I[v + 2] = c.b * C;
+        }
+      k++;
+    };
+    for (const g of Z.mcpPending.values()) {
+      if (k >= 24) break;
+      const E = ie(g.instance), h = Xe(g.server, d);
+      if (!E || !h) continue;
+      const b = Dt(g, w), u = Z.mcpServers.get(g.server);
+      c.set((u == null ? void 0 : u.color) ?? "#94a3b8"), b < 1 ? c.lerp(y, b * 0.8) : c.copy(y).lerp(p, Math.min(1, (b - 1) / 1.2));
+      const O = 0.35 + Math.min(b, 3) * 0.35, v = Math.min(1, b * 4);
+      z(E, h, (x) => {
+        if (x > v) return 0;
+        const C = x * 6 - T * 1.8;
+        return O * (0.45 + Math.pow(C - Math.floor(C), 8) * 3);
+      });
+    }
+    for (const g of Z.mcpResolved) {
+      if (k >= 24) break;
+      const E = ie(g.instance), h = Xe(g.server, d);
+      if (!E || !h) continue;
+      const b = (w - g.resolvedAt) / 700;
+      c.set(((_ = Z.mcpServers.get(g.server)) == null ? void 0 : _.color) ?? "#ffffff").lerp(A, 0.6);
+      const u = 1 - b * 1.15;
+      z(E, h, (O) => (1 - b) * (0.25 + Math.exp(-Math.pow((O - u) * 9, 2)) * 5));
+    }
+    n.setDrawRange(0, k * 28 * 2), G.needsUpdate = !0, m.needsUpdate = !0;
+  }), /* @__PURE__ */ r("lineSegments", { geometry: n, frustumCulled: !1, children: /* @__PURE__ */ r("lineBasicMaterial", { vertexColors: !0, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) });
+}
+const Le = 9, ge = 11, ke = 46, _t = 1500, De = new t.Vector3(), ln = new t.SphereGeometry(1, 36, 18, 0, Math.PI * 2, 0, Math.PI / 2), un = new t.SphereGeometry(1, 16, 12), Mt = new t.Color();
+function pn({ agent: e, selected: o, onSelect: n }) {
+  const s = e.inst, d = s.id, y = e.depth > 0, p = y ? 0.42 : 0.62, A = Ut(d) % 1e3 / 1e3, c = Ze[s.type], l = U(null), w = U(null), T = U(null), G = U(null), m = U(null), S = U(null), I = U(null), k = U(A * 6), z = i(() => zt(c), [c]), _ = i(() => new t.MeshBasicMaterial({ color: c, transparent: !0, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1 }), [c]), g = i(() => new t.SpriteMaterial({ color: c, map: Fe(), transparent: !0, opacity: 0.06, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1 }), [c]), E = i(() => new t.Color(c), [c]), h = i(() => {
+    const C = new t.BufferGeometry(), R = Le * ge * 2;
+    C.setAttribute("position", new t.BufferAttribute(new Float32Array(R * 3), 3));
+    const F = new Float32Array(R * 3), V = new t.Color(c);
+    for (let f = 0; f < Le; f++)
+      for (let B = 0; B < ge; B++)
+        for (let W = 0; W < 2; W++) {
+          const N = 1 - (B + W) / ge, H = (f * ge + B) * 2 + W;
+          F[H * 3] = V.r * (0.4 + N * 1.8), F[H * 3 + 1] = V.g * (0.4 + N * 1.8), F[H * 3 + 2] = V.b * (0.4 + N * 1.8);
+        }
+    return C.setAttribute("color", new t.BufferAttribute(F, 3)), C;
+  }, [c]), b = i(() => new t.LineBasicMaterial({ vertexColors: !0, transparent: !0, opacity: 0.8, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }), []), u = i(() => {
+    const C = new Float32Array(ke * 4);
+    for (let F = 0; F < ke; F++) {
+      const V = Math.random() * Math.PI * 2, f = Math.random() * 1.4 - 0.4, B = Math.sqrt(1 - Math.min(1, f * f));
+      C[F * 4] = Math.cos(V) * B, C[F * 4 + 1] = f, C[F * 4 + 2] = Math.sin(V) * B, C[F * 4 + 3] = 0.5 + Math.random();
+    }
+    const R = new t.BufferGeometry();
+    return R.setAttribute("position", new t.BufferAttribute(new Float32Array(ke * 3), 3)), { dirs: C, g: R };
+  }, []), O = i(
+    () => new t.PointsMaterial({ color: new t.Color(c).multiplyScalar(2.2), size: y ? 0.16 : 0.22, map: Fe(), transparent: !0, depthWrite: !1, blending: t.AdditiveBlending, toneMapped: !1 }),
+    [c, y]
+  ), v = i(() => new t.Vector3(), []), x = U(!1);
+  return Ct(
+    () => () => {
+      z.dispose(), _.dispose(), g.dispose(), h.dispose(), u.g.dispose(), O.dispose();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  ), le(({ clock: C }, R) => {
+    var we;
+    const F = performance.now(), V = C.elapsedTime, f = e.inst;
+    if (!x.current) {
+      x.current = !0;
+      const Y = f.parent ? ie(f.parent) : void 0;
+      Y ? v.copy(Y) : Nt(e.run, Ue("planner"), Ft * ze.spread, v);
+    }
+    const B = 0.12 * Ee * Math.max(1, ze.spread);
+    De.copy(e.pos), De.x += Math.sin(V * 0.4 + A * 9) * B, De.y += Math.sin(V * 0.7 + A * 5) * B;
+    const W = ae((F - f.bornAt) / _t), N = en(ae(W / 0.8)), H = W < 0.32, K = H ? 0 : tn(ae((W - 0.32) / 0.68)), Q = f.exitAt ? (F - f.exitAt) / Xt(f) : 0, q = f.exitAt > 0, M = q ? Math.max(0, 1 - Q * 1.25) : 1, a = q ? Math.exp(-(F - f.exitAt) / 220) : 0, P = f.status === "failed";
+    let L = !1;
+    for (const Y of Z.mcpPending.values()) Y.instance === d && (L = !0);
+    const j = (f.status === "thinking" || f.status === "spawning") && !L, D = qt(f, F), ee = o, X = ze.scale, ne = q ? 0.8 : j ? 4.6 : L ? 1.8 : 1.1;
+    k.current += R * ne;
+    const me = Math.pow(0.5 + 0.5 * Math.sin(k.current), 3), oe = j ? 1 : 0.45, ve = e.live;
+    ve.lerpVectors(v, De, N), ve.y += me * 0.12 * oe * X + (q ? Q * 1.2 * X : 0), l.current && (l.current.position.copy(ve), l.current.rotation.z = Math.sin(V * 0.5 + A * 7) * 0.12, l.current.rotation.x = Math.sin(V * 0.37 + A * 3) * 0.08);
+    const $ = p * X * K * (1 + D * 0.14) * (1 + (q ? Q * 0.6 : 0)) * (ee ? 1.12 : 1), re = 1 + me * 0.14 * oe, Me = 0.8 * (1 - me * 0.24 * oe);
+    w.current && (w.current.visible = !(q && M <= 1e-3)), (we = T.current) == null || we.scale.set(Math.max(1e-4, $ * re), Math.max(1e-4, $ * Me), Math.max(1e-4, $ * re));
+    const ue = j ? 1.25 : L ? 0.7 + 0.35 * Math.sin(V * 2.2) : 0.45;
+    if (z.uniforms.uIntensity.value = ue + D * 1.7 + a * 5 + (ee ? 0.7 : 0), z.uniforms.uOpacity.value = M * (0.4 + 0.6 * ae(K)), z.uniforms.uFlash.value = a, P && q && z.uniforms.uColor.value.set("#ef4444"), G.current) {
+      const Y = X * (H ? p * (0.32 + 0.08 * Math.sin(F / 50)) : p * (0.22 + D * 0.06) * Math.min(1, K + 0.3));
+      G.current.scale.setScalar(Math.max(1e-4, Y * (1 - (q ? Q : 0)))), G.current.position.y = H ? 0 : $ * Me * 0.35, Mt.copy(E).multiplyScalar((H ? 5 : 1.6 + D * 3) * ue + a * 8), _.color.copy(Mt), _.opacity = M;
+    }
+    m.current && (m.current.scale.setScalar(p * X * (H ? 3 : 4.2 + D * 2 + a * 4)), g.opacity = (0.12 + D * 0.16 + (H ? 0.5 : 0) + a * 0.6 + (ee ? 0.2 : 0)) * M);
+    const Oe = h.getAttribute("position"), de = Oe.array, ye = $ * re * 0.88, he = p * X * (y ? 3 : 3.6) * ae(K) * (0.85 + 0.15 * (1 - me)), fe = j ? 3.2 : 1.1, Ve = p * X * (j ? 0.55 : 0.35);
+    for (let Y = 0; Y < Le; Y++) {
+      const be = Y / Le * Math.PI * 2, xe = Math.cos(be), Be = Math.sin(be), Se = Y % 3 === 0 ? 0.35 : 1;
+      for (let te = 0; te < ge; te++)
+        for (let pe = 0; pe < 2; pe++) {
+          const se = (te + pe) / ge, ft = V * fe * (0.85 + Y % 4 * 0.08) - se * 5 + Y * 1.7, mt = ye * Se * (1 - se * 0.4), Ke = ((Y * ge + te) * 2 + pe) * 3;
+          de[Ke] = xe * mt + Math.sin(ft) * Ve * se, de[Ke + 1] = -se * he * (Se < 1 ? 0.7 : 1), de[Ke + 2] = Be * mt + Math.cos(ft * 0.8) * Ve * se * 0.7;
+        }
+    }
+    if (Oe.needsUpdate = !0, b.opacity = M * (j ? 0.95 : 0.55) * ae(K * 1.5), I.current && (I.current.visible = q, q)) {
+      const Y = u.g.getAttribute("position"), be = Y.array, xe = (F - f.exitAt) / 1e3, Be = 1 - Math.exp(-xe * 3.5), Se = p * X;
+      for (let te = 0; te < ke; te++) {
+        const pe = u.dirs, se = pe[te * 4 + 3];
+        be[te * 3] = pe[te * 4] * Se * 2.2 * Be * se + Math.sin(xe * 2 + te) * 0.08, be[te * 3 + 1] = pe[te * 4 + 1] * Se * 1.6 * Be * se + xe * 0.9 * se, be[te * 3 + 2] = pe[te * 4 + 2] * Se * 2.2 * Be * se;
+      }
+      Y.needsUpdate = !0, O.opacity = Math.max(0, 1 - Q) * Math.min(1, xe * 6);
+    }
+  }), /* @__PURE__ */ J("group", { ref: l, children: [
+    /* @__PURE__ */ J("group", { ref: w, children: [
+      /* @__PURE__ */ r(
+        "mesh",
+        {
+          ref: T,
+          geometry: ln,
+          material: z,
+          onClick: (C) => (C.stopPropagation(), n(d)),
+          onPointerOver: () => document.body.style.cursor = "pointer",
+          onPointerOut: () => document.body.style.cursor = ""
+        }
+      ),
+      /* @__PURE__ */ r("mesh", { ref: G, geometry: un, material: _ }),
+      /* @__PURE__ */ r("sprite", { ref: m, material: g }),
+      /* @__PURE__ */ r("lineSegments", { ref: S, geometry: h, material: b, frustumCulled: !1 })
+    ] }),
+    /* @__PURE__ */ r("points", { ref: I, geometry: u.g, material: O, frustumCulled: !1, visible: !1 })
+  ] });
+}
+const Ft = 1.25;
+function dn() {
+  const n = i(() => {
+    const d = new t.BufferGeometry();
+    return d.setAttribute("position", new t.BufferAttribute(new Float32Array(3840), 3)), d.setAttribute("color", new t.BufferAttribute(new Float32Array(3840), 3)), d;
+  }, []), s = i(() => new t.Color(), []);
+  return le(({ clock: d }) => {
+    const y = performance.now(), p = d.elapsedTime, A = n.getAttribute("position"), c = n.getAttribute("color"), l = A.array, w = c.array, T = ze.scale;
+    let G = 0;
+    for (const m of pt.agents.values()) {
+      if (G >= 64) break;
+      const S = m.inst;
+      if (!S.parent) continue;
+      const I = ie(S.parent), k = m.live, z = Z.instances.get(S.parent);
+      if (!I || !z) continue;
+      const _ = ae((y - S.bornAt) / _t), g = (S.exitAt ? Math.max(0, 1 - (y - S.exitAt) / 900) : 1) * (z.exitAt ? Math.max(0, 1 - (y - z.exitAt) / 900) : 1);
+      if (g <= 0) continue;
+      const E = (0.22 + Math.pow(1 - _, 2) * 2.2) * g;
+      s.set(Ze[S.type]);
+      for (let h = 0; h < 10; h++)
+        for (let b = 0; b < 2; b++) {
+          const u = (h + b) / 10, O = ((G * 10 + h) * 2 + b) * 3, v = Math.sin(u * Math.PI) * (0.35 + 0.1 * Math.sin(p * 1.3 + G)) * T;
+          l[O] = I.x + (k.x - I.x) * u, l[O + 1] = I.y - 0.25 * T + (k.y - I.y + 0.25 * T) * u - v, l[O + 2] = I.z + (k.z - I.z) * u;
+          const x = _ < 1 ? Math.exp(-Math.pow((u - _ * 1.1) * 7, 2)) * 3 : 0, C = E * (0.5 + u * 0.5) + x * g;
+          w[O] = s.r * C, w[O + 1] = s.g * C, w[O + 2] = s.b * C;
+        }
+      G++;
+    }
+    n.setDrawRange(0, G * 10 * 2), A.needsUpdate = !0, c.needsUpdate = !0;
+  }), /* @__PURE__ */ r("lineSegments", { geometry: n, frustumCulled: !1, children: /* @__PURE__ */ r("lineBasicMaterial", { vertexColors: !0, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) });
+}
+const fn = { queued: "#1e3a5f", running: "#ffffff", done: "#5eead4", failed: "#ef4444" }, Je = ["planner", "researcher", "writer"], je = 10, Ae = new t.Color(), ce = { u0: 0, u1: 1, mid: 0, half: 1, seed: 0 }, Qe = (e) => (e - ce.u0) / (ce.u1 - ce.u0), yt = (e) => Gt((e - ce.mid) / ce.half * je, ce.seed), wt = (e) => Rt((e - ce.mid) / ce.half * je, ce.seed), bt = new t.Color("#ffffff");
+function mn({ run: e }) {
+  const o = i(() => Ut(e.id) % 997 / 97, [e.id]), n = U(null), s = U(null), d = U(null), y = U([]), p = U(null), A = U(null), { tube: c, glow: l } = i(() => {
+    const g = [];
+    for (let h = 0; h <= 48; h++) {
+      const b = -1 + 2 * h / 48;
+      g.push(new t.Vector3(b, Gt(b * je, o), Rt(b * je, o)));
+    }
+    const E = new t.CatmullRomCurve3(g);
+    return { tube: new t.TubeGeometry(E, 200, 0.05, 6), glow: new t.TubeGeometry(E, 120, 0.32, 8) };
+  }, [o]), w = i(() => gt(e.color), [e.color]), T = i(() => {
+    const g = gt(e.color);
+    return g.uniforms.uWidthGlow.value = 0.18, g;
+  }, [e.color]), G = i(() => [w, T], [w, T]), m = e.run ?? Z.runs.get(e.id), S = i(() => new t.Color(e.color), [e.color]), I = i(() => Pe.map(() => new t.MeshBasicMaterial({ toneMapped: !1, transparent: !0 })), []), k = i(() => Pe.map(() => new t.MeshBasicMaterial({ toneMapped: !1, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1 })), []), z = i(() => Pe.map(() => new t.SpriteMaterial({ map: Fe(), toneMapped: !1, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1 })), []), _ = i(() => new t.MeshBasicMaterial({ toneMapped: !1, transparent: !0 }), []);
+  return Ct(
+    () => () => {
+      c.dispose(), l.dispose(), w.dispose(), T.dispose(), [...I, ...k, ...z, _].forEach((g) => g.dispose());
+    },
+    [c, l, w, T, I, k, z, _]
+  ), le(({ clock: g }) => {
+    var Q, q;
+    const E = n.current;
+    if (!E) return;
+    const h = performance.now(), b = g.elapsedTime, u = e.run ?? Z.runs.get(e.id);
+    E.position.copy(e.origin).addScaledVector(e.side, -e.cu).addScaledVector(e.axis, -e.cv);
+    const O = ze.spread, v = 1.6 * O, x = ce;
+    x.u0 = e.cu - e.hu - v, x.u1 = e.cu + e.hu + v;
+    const C = x.mid = (x.u0 + x.u1) / 2, R = x.half = (x.u1 - x.u0) / 2;
+    x.seed = o;
+    const F = -Ft * O, V = s.current;
+    V && (V.position.set(C, F, 0), V.scale.set(R, 1, 1));
+    const f = u ? ae((h - u.startedAt) / 1600) * 1.1 : 1.1, B = u != null && u.endedAt ? Math.max(0, 1 - (h - u.endedAt) / jt) : 1;
+    let W = -1, N = 0;
+    const H = u ? (h - u.handoffAt) / 1300 : 9;
+    if (u && u.handoffAt && H < 1) {
+      const M = 1 - Math.pow(1 - H, 3), a = Ue(Je[u.handoffFrom]), P = Ue(Je[u.handoffTo]);
+      W = Qe(a + (P - a) * M), N = Math.sin(H * Math.PI) * 1.2 + 0.3;
+    } else if (u != null && u.endedAt && h - u.endedAt < 1400) {
+      const M = (h - u.endedAt) / 1400, a = Ue("writer");
+      W = Qe(a + (x.u1 - a) * M), N = (1 - M) * 0.45;
+    }
+    for (const M of G)
+      M.uniforms.uTime.value = b * Ee, M.uniforms.uReveal.value = f, M.uniforms.uFade.value = B, M.uniforms.uPulse.value = W, M.uniforms.uPulseAmp.value = N;
+    if (d.current && (d.current.visible = W >= 0, W >= 0)) {
+      const M = x.u0 + W * (x.u1 - x.u0);
+      d.current.position.set(M, F + yt(M), wt(M)), d.current.scale.setScalar(0.18 + N * 0.12), _.color.copy(bt).lerp(S, 0.3).multiplyScalar(4 * Math.max(0.3, N)), _.opacity = B;
+    }
+    const K = !!(u != null && u.hasSteps);
+    for (let M = 0; M < Pe.length; M++) {
+      const a = y.current[M];
+      if (!a || (a.visible = K, !u || !K)) continue;
+      const P = Ue(Je[M]);
+      a.position.set(P, F + yt(P), wt(P));
+      const L = Ht(u, M), j = ae((f - Qe(P)) * 6), D = L === "running", ee = D ? 0.5 + 0.5 * Math.sin(b * 5.5) : 0;
+      a.scale.setScalar(Math.max(1e-3, j * (D ? 1.15 + ee * 0.2 : L === "done" ? 0.9 : 0.75) * Math.max(0.9, O))), a.rotation.y += D ? 0.05 : 4e-3;
+      const X = I[M];
+      L === "queued" ? Ae.copy(S).multiplyScalar(0.35) : D ? Ae.copy(S).lerp(bt, 0.35).multiplyScalar(2.2 + ee * 2.2) : Ae.set(fn[L]).multiplyScalar(L === "done" ? 1.5 : 2.5), X.color.copy(Ae), X.opacity = B, k[M].color.copy(Ae).multiplyScalar(D ? 0.9 : 0.5), k[M].opacity = B * (L === "queued" ? 0.35 : 1), z[M].color.copy(D ? S : Ae), z[M].opacity = B * (D ? 0.45 + ee * 0.3 : L === "done" ? 0.18 : 0.05);
+    }
+    (Q = p.current) == null || Q.position.set(x.u0 + 0.3, e.hv - e.cv + 0.5, 0), (q = A.current) == null || q.setOpacity(B * ae(f * 2));
+  }), /* @__PURE__ */ J("group", { ref: n, children: [
+    /* @__PURE__ */ J("group", { ref: s, children: [
+      /* @__PURE__ */ r("mesh", { geometry: c, material: w }),
+      /* @__PURE__ */ r("mesh", { geometry: l, material: T })
+    ] }),
+    /* @__PURE__ */ r("mesh", { ref: d, material: _, visible: !1, children: /* @__PURE__ */ r("sphereGeometry", { args: [1, 16, 12] }) }),
+    Pe.map((g) => /* @__PURE__ */ J("group", { ref: (E) => void (y.current[g] = E), visible: !1, children: [
+      /* @__PURE__ */ r("mesh", { material: I[g], children: /* @__PURE__ */ r("icosahedronGeometry", { args: [0.2, 2] }) }),
+      Array.from({ length: 8 }, (E, h) => {
+        const b = h / 8 * Math.PI * 2;
+        return /* @__PURE__ */ r("mesh", { material: k[g], position: [Math.cos(b) * 0.36, 0.1 + h % 2 * 0.08, Math.sin(b) * 0.36], children: /* @__PURE__ */ r("sphereGeometry", { args: [0.055, 8, 6] }) }, h);
+      }),
+      /* @__PURE__ */ r("mesh", { material: k[g], rotation: [Math.PI / 2, 0, 0], children: /* @__PURE__ */ r("torusGeometry", { args: [0.36, 0.012, 6, 40] }) }),
+      /* @__PURE__ */ r("sprite", { material: z[g], scale: 2.4 }),
+      m && /* @__PURE__ */ r(Zt, { run: m, slot: g, position: [0, -0.75, 0], color: e.color, textColor: "#bae6fd", uppercase: !0, letterSpacing: 0.08, size: 0.22, opacity: 0.8, pxRange: [7.5, 10.5] })
+    ] }, g)),
+    /* @__PURE__ */ r("group", { ref: p, children: /* @__PURE__ */ r(hn, { runId: e.id, color: e.color, labelRef: A }) })
+  ] });
+}
+function hn({ runId: e, color: o, labelRef: n }) {
+  const s = Z.runs.get(e);
+  return /* @__PURE__ */ r(
+    dt,
+    {
+      ref: n,
+      anchorX: "left",
+      anchorY: "bottom",
+      textAlign: "left",
+      text: `${s != null && s.hasSteps ? "hatchet · " : ""}${(s == null ? void 0 : s.topic) ?? "run"}`,
+      color: o,
+      size: 0.3,
+      maxWidth: 10,
+      opacity: 0,
+      pxRange: [9.5, 14]
+    }
+  );
+}
+const gn = new t.ConeGeometry(0.07, 0.34, 8).rotateX(Math.PI / 2), xt = new t.Vector3(), vn = new t.Vector3(), It = (e) => e < 0.5 ? 2 * e * e : 1 - Math.pow(-2 * e + 2, 2) / 2;
+function St(e) {
+  const [o, n] = kt([]), s = U([]);
+  return le(() => {
+    const d = e(), y = s.current;
+    let p = y.length === d.length;
+    if (p)
+      for (let A = 0; A < d.length; A++) y[A] !== d[A].id && (p = !1);
+    p || (s.current = d.map((A) => A.id), n(d.slice()));
+  }), o;
+}
+function Mn({ comet: e }) {
+  const o = U(null), n = Z.instances.get(e.from), s = n ? Ze[n.type] : "#a5f3fc", d = i(() => new t.MeshBasicMaterial({ color: new t.Color(s).multiplyScalar(4), toneMapped: !1 }), [s]), y = i(() => (ie(e.from) ?? new t.Vector3()).clone(), [e.from]);
+  return le(() => {
+    const p = o.current;
+    if (!p) return;
+    const A = Math.min(1, (performance.now() - e.start) / e.dur), c = ie(e.from), l = ie(e.to);
+    if (!c || !l) {
+      p.scale.setScalar(1e-3);
+      return;
+    }
+    qe(c, l, It(A), 1.1, p.position), p.scale.setScalar(A >= 1 ? 1e-3 : 1 + Math.sin(A * Math.PI) * 0.4);
+  }), /* @__PURE__ */ r(Tt, { width: 1.8, length: 6, color: s, attenuation: (p) => p * p, decay: 1.4, children: /* @__PURE__ */ r("mesh", { ref: o, position: y, material: d, children: /* @__PURE__ */ r("sphereGeometry", { args: [0.11, 12, 10] }) }) });
+}
+function yn({ call: e }) {
+  const o = U(null), n = Z.mcpServers.get(e.server), s = (n == null ? void 0 : n.color) ?? "#94a3b8", d = i(() => new t.MeshBasicMaterial({ color: new t.Color(s).multiplyScalar(e.phase === "result" ? 5 : 3.5), toneMapped: !1 }), [s, e.phase]), y = i(() => ((e.phase === "call" ? ie(e.instance) : Xe(e.server, new t.Vector3())) ?? new t.Vector3()).clone(), [e]);
+  return le(() => {
+    const p = o.current;
+    if (!p) return;
+    const A = Math.min(1, (performance.now() - e.start) / e.dur), c = ie(e.instance), l = Xe(e.server, vn);
+    if (!c || !l) {
+      p.scale.setScalar(1e-3);
+      return;
+    }
+    const w = It(A), T = e.phase === "call" ? w : 1 - w;
+    qe(c, l, T, 1.6, p.position), qe(c, l, e.phase === "call" ? Math.min(1, T + 0.02) : Math.max(0, T - 0.02), 1.6, xt), p.lookAt(xt), p.scale.setScalar(A >= 1 ? 1e-3 : 1);
+  }), /* @__PURE__ */ r(Tt, { width: 1.4, length: 5, color: s, attenuation: (p) => p * p * p, decay: 1.6, children: /* @__PURE__ */ r("mesh", { ref: o, position: y, material: d, geometry: gn }) });
+}
+const et = [], tt = [];
+function wn() {
+  if (!Pt.grouped) return Z.comets;
+  et.length = 0;
+  for (const e of Z.comets) it(e.from) && it(e.to) && et.push(e);
+  return et;
+}
+function bn() {
+  if (!Pt.grouped) return Z.mcpCalls;
+  tt.length = 0;
+  for (const e of Z.mcpCalls) it(e.instance) && tt.push(e);
+  return tt;
+}
+function xn() {
+  const e = St(wn), o = St(bn);
+  return /* @__PURE__ */ J("group", { children: [
+    e.map((n) => /* @__PURE__ */ r(Mn, { comet: n }, n.id)),
+    o.map((n) => /* @__PURE__ */ r(yn, { call: n }, n.id))
+  ] });
+}
+const nt = 60, Sn = new t.Vector3(), ot = [0, 1], An = 9, rt = 180, st = 60, Ce = 6, Ie = 4.2, _e = -1.15, He = 0.42, lt = Math.cos(He), ut = Math.sin(He), Cn = Object.keys(ct), at = 200;
+function Re(e, o) {
+  let n = 2166136261 ^ o;
+  for (let s = 0; s < e.length; s++) n = Math.imul(n ^ e.charCodeAt(s), 16777619);
+  return (n >>> 0) % 1e5 / 1e5;
+}
+function At(e, o, n, s, d) {
+  e[o * 3] = n, e[o * 3 + 1] = s * lt + d * ut, e[o * 3 + 2] = -s * ut + d * lt;
+}
+function Bn(e) {
+  const o = e.nodes.length, n = new Float32Array(o * 3), s = new Float32Array(o * 3), d = new Float32Array(o), y = new Int32Array(o), p = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map();
+  for (const c of e.nodes) A.set(c.kind, (A.get(c.kind) ?? 0) + 1);
+  return e.nodes.forEach((c, l) => {
+    let w = Cn.indexOf(c.kind);
+    w < 0 && (w = 8 + Math.floor(Re(c.kind, 3) * 8));
+    const T = (w + 0.5) / 12, G = w * 2.39996 + 0.6, m = Math.sqrt(T), S = Math.cos(G) * m * Ie * 0.82, I = Math.sin(G) * m * Ie * 0.42, k = 0.35 + Math.sqrt(A.get(c.kind) ?? 1) * 0.1;
+    p.has(c.kind) || p.set(c.kind, l), y[l] = p.get(c.kind);
+    const z = Re(c.id, 11) * Math.PI * 2, _ = Math.pow(Re(c.id, 12), 0.7) * k, g = S + Math.cos(z) * _, E = I + Math.sin(z) * _ * 0.8, h = (0.6 + Re(c.id, 13) * 1) * (1.5 - _ / k * 0.8);
+    At(n, l, g, _e, E), At(s, l, g + Math.cos(z) * h * 0.35, _e + h, E + Math.sin(z) * h * 0.3), d[l] = Re(c.id, 14) * 6.28;
+  }), { base: n, head: s, phase: d, hub: y };
+}
+function Pn({ galaxy: e }) {
+  const o = i(() => {
+    const v = e.nodes.slice(0, at), x = new Set(v.map((C) => C.id));
+    return { nodes: v, links: e.links.filter((C) => x.has(C.source) && x.has(C.target)) };
+  }, [e]), n = o.nodes.length, s = i(() => Bn(o), [o]), d = i(() => o.nodes.map((v) => new t.Color(ct[v.kind] ?? "#94a3b8")), [o]), y = i(() => /* @__PURE__ */ new Map(), [o]), p = (v) => {
+    let x = y.get(v);
+    return x === void 0 && y.set(v, x = Yt(o, v) % Math.max(1, n)), x;
+  }, A = U(null), c = U(null), l = U(null), w = U(null), T = i(() => new Float32Array(n), [n]), G = i(() => new Float32Array(n), [n]), m = i(() => new t.Object3D(), []), S = i(() => new t.Color(), []), I = i(() => new t.Color(1, 1, 1), []), k = i(() => new t.Vector3(0, 1, 0), []), z = i(() => new t.Vector3(), []), _ = i(() => new t.Vector3(), []), g = i(() => {
+    const v = new Map(o.nodes.map((f, B) => [f.id, B])), x = [], C = [], R = s.head, F = (f, B, W, N, H) => {
+      const K = d[f], Q = d[B];
+      for (let q = 0; q < H; q++)
+        for (let M = 0; M < 2; M++) {
+          const a = (q + M) / H;
+          x.push(R[f * 3] + (R[B * 3] - R[f * 3]) * a, R[f * 3 + 1] + (R[B * 3 + 1] - R[f * 3 + 1]) * a + Math.sin(a * Math.PI) * W, R[f * 3 + 2] + (R[B * 3 + 2] - R[f * 3 + 2]) * a), C.push((K.r + (Q.r - K.r) * a) * N, (K.g + (Q.g - K.g) * a) * N, (K.b + (Q.b - K.b) * a) * N);
+        }
+    };
+    s.hub.forEach((f, B) => f !== B && F(B, f, 0, 0.32, 1));
+    for (const f of o.links) {
+      const B = v.get(f.source), W = v.get(f.target);
+      if (B === void 0 || W === void 0 || B === W) continue;
+      const N = Math.hypot(R[B * 3] - R[W * 3], R[B * 3 + 2] - R[W * 3 + 2]);
+      F(B, W, Math.min(1.4, 0.15 + N * 0.09), 0.42, 10);
+    }
+    const V = new t.BufferGeometry();
+    return V.setAttribute("position", new t.Float32BufferAttribute(x, 3)), V.setAttribute("color", new t.Float32BufferAttribute(C, 3)), V;
+  }, [o, s, d]), E = U([]), h = U([]), b = U(["", ""]), u = i(() => {
+    const v = new t.BufferGeometry();
+    return v.setAttribute("position", new t.BufferAttribute(new Float32Array(st * Ce * 2 * 3), 3)), v.setAttribute("color", new t.BufferAttribute(new Float32Array(st * Ce * 2 * 3), 3)), v;
+  }, []);
+  le(({ clock: v }) => {
+    const x = performance.now(), C = v.elapsedTime * Ee;
+    T.fill(0), G.fill(0);
+    const R = A.current, F = c.current, V = l.current, f = w.current;
+    if (!R || !F || !V || !f) return;
+    let B = 0, W = 0, N = 0;
+    const H = u.getAttribute("position"), K = u.getAttribute("color"), Q = H.array, q = K.array;
+    for (const a of Z.flares) {
+      const P = p(a.node), L = (x - a.start) / 2600;
+      if (L < 0 || L >= 1) continue;
+      const j = a.op === "write", D = Math.exp(-L * 2.6) * Math.min(1, L * 20);
+      D > T[P] && (T[P] = D), j && (G[P] = Math.max(G[P], D));
+      const ee = s.base[P * 3], X = s.base[P * 3 + 1], ne = s.base[P * 3 + 2];
+      if (B < nt) {
+        m.position.set(ee, X + 0.03, ne), m.rotation.set(-Math.PI / 2 + He, 0, 0), m.scale.setScalar(0.12 + Math.sqrt(L) * (j ? 1.5 : 0.9)), m.updateMatrix(), V.setMatrixAt(B, m.matrix);
+        const $ = Math.pow(1 - L, 2) * (j ? 3 : 1.6);
+        j ? S.copy(I).multiplyScalar($) : S.copy(d[P]).multiplyScalar($), V.setColorAt(B, S), B++;
+      }
+      if (j)
+        for (let $ = 0; $ < An && W < rt; $++) {
+          const re = (a.id * 13 + $ * 7) % 97, Me = 1.4 + re % 10 * 0.18, ue = L * 2.6 - $ * 0.08;
+          ue < 0 || (m.position.set(
+            ee + Math.sin(re) * 0.35 + Math.sin(ue * 5 + $) * 0.1,
+            X + 0.3 + ue * Me * 0.6,
+            ne + Math.cos(re) * 0.35
+          ), m.rotation.set(0, 0, 0), m.scale.setScalar((0.05 + re % 5 * 0.015) * (1 + ue * 0.3)), m.updateMatrix(), f.setMatrixAt(W, m.matrix), S.setRGB(1, 1.5, 1.9).multiplyScalar(Math.pow(Math.max(0, 1 - L), 1.5)), f.setColorAt(W, S), W++);
+        }
+      const me = ie(a.instance), oe = me ? Kt(me, Sn) : void 0, ve = Z.instances.get(a.instance);
+      if (oe && ve && N < st && L < 0.75) {
+        const $ = L / 0.75, re = Math.pow(1 - $, 1.5) * Math.min(1, $ * 12) * (j ? 2.4 : 1.6);
+        j ? S.copy(I) : S.set(Ze[ve.type]);
+        const Me = s.head[P * 3], ue = s.head[P * 3 + 1], Oe = s.head[P * 3 + 2];
+        for (let de = 0; de < Ce; de++)
+          for (let ye = 0; ye < 2; ye++) {
+            const he = (de + ye) / Ce, fe = ((N * Ce + de) * 2 + ye) * 3;
+            Q[fe] = oe.x + (Me - oe.x) * he, Q[fe + 1] = oe.y + (ue - oe.y) * he, Q[fe + 2] = oe.z + (Oe - oe.z) * he;
+            const Ve = Math.exp(-Math.pow((he - Math.min(1, $ * 2.2)) * 6, 2)) * 2, we = re * (0.35 + he * 0.4 + Ve);
+            q[fe] = S.r * we, q[fe + 1] = S.g * we, q[fe + 2] = S.b * we;
+          }
+        N++;
+      }
+    }
+    for (let a = B; a < nt; a++)
+      m.scale.setScalar(0), m.updateMatrix(), V.setMatrixAt(a, m.matrix);
+    for (let a = W; a < rt; a++)
+      m.scale.setScalar(0), m.updateMatrix(), f.setMatrixAt(a, m.matrix);
+    V.instanceMatrix.needsUpdate = !0, V.instanceColor && (V.instanceColor.needsUpdate = !0), f.instanceMatrix.needsUpdate = !0, f.instanceColor && (f.instanceColor.needsUpdate = !0), u.setDrawRange(0, N * Ce * 2), H.needsUpdate = !0, K.needsUpdate = !0;
+    let M = 0;
+    for (let a = Z.flares.length - 1; a >= 0 && M < ot.length; a--) {
+      const P = Z.flares[a], L = (x - P.start) / 1e3;
+      if (L > 1.8) continue;
+      let j = !1;
+      for (let ne = 0; ne < M; ne++) b.current[ne] === P.node && (j = !0);
+      if (j) continue;
+      const D = p(P.node), ee = E.current[M], X = h.current[M];
+      ee && X && (ee.position.set(s.head[D * 3], s.head[D * 3 + 1] + 0.55 + L * 0.25, s.head[D * 3 + 2]), b.current[M] !== P.node && (X.setText((P.op === "write" ? "wrote · " : "") + P.node), X.setColor(P.op === "write" ? "#ffffff" : ct[o.nodes[D].kind] ?? "#94a3b8")), X.setOpacity(Math.min(1, (1.8 - L) * 2))), b.current[M] = P.node, M++;
+    }
+    for (let a = M; a < ot.length; a++) {
+      const P = h.current[a];
+      P == null || P.setOpacity(0), b.current[a] = "";
+    }
+    for (let a = 0; a < n; a++) {
+      const P = T[a], L = 0, j = 0, D = s.base[a * 3], ee = s.base[a * 3 + 1], X = s.base[a * 3 + 2];
+      _.set(s.head[a * 3] + L, s.head[a * 3 + 1], s.head[a * 3 + 2] + j), z.set(_.x - D, _.y - ee, _.z - X);
+      const ne = z.length();
+      z.multiplyScalar(1 / ne), m.position.set(D, ee, X), m.quaternion.setFromUnitVectors(k, z), m.scale.set(1 + P, ne, 1 + P), m.updateMatrix(), F.setMatrixAt(a, m.matrix), S.copy(d[a]).multiplyScalar(0.22 + P * 1.2), F.setColorAt(a, S), m.position.copy(_), m.quaternion.identity(), m.scale.setScalar(1 + P * 2.6), m.updateMatrix(), R.setMatrixAt(a, m.matrix), S.copy(d[a]).multiplyScalar(0.75 + 0.25 * Math.sin(C * 0.8 + s.phase[a] * 3) + P * 5), G[a] > 0.01 && (S.lerp(I.setScalar(6), G[a] * 0.7), I.setScalar(1)), R.setColorAt(a, S);
+    }
+    R.count = n, F.count = n, R.instanceMatrix.needsUpdate = !0, R.instanceColor && (R.instanceColor.needsUpdate = !0), F.instanceMatrix.needsUpdate = !0, F.instanceColor && (F.instanceColor.needsUpdate = !0);
+  });
+  const O = i(() => new t.CylinderGeometry(0.03, 0.065, 1, 5, 1, !0).translate(0, 0.5, 0), []);
+  return /* @__PURE__ */ J("group", { children: [
+    /* @__PURE__ */ r("instancedMesh", { ref: c, args: [O, void 0, at], frustumCulled: !1, children: /* @__PURE__ */ r("meshBasicMaterial", { toneMapped: !1 }) }),
+    /* @__PURE__ */ J("instancedMesh", { ref: A, args: [void 0, void 0, at], frustumCulled: !1, children: [
+      /* @__PURE__ */ r("icosahedronGeometry", { args: [0.12, 1] }),
+      /* @__PURE__ */ r("meshBasicMaterial", { toneMapped: !1 })
+    ] }),
+    /* @__PURE__ */ r("lineSegments", { geometry: g, children: /* @__PURE__ */ r("lineBasicMaterial", { vertexColors: !0, transparent: !0, opacity: 0.9, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) }),
+    /* @__PURE__ */ J("instancedMesh", { ref: l, args: [void 0, void 0, nt], frustumCulled: !1, children: [
+      /* @__PURE__ */ r("ringGeometry", { args: [0.86, 1, 48] }),
+      /* @__PURE__ */ r("meshBasicMaterial", { toneMapped: !1, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, side: t.DoubleSide })
+    ] }),
+    /* @__PURE__ */ J("instancedMesh", { ref: w, args: [void 0, void 0, rt], frustumCulled: !1, children: [
+      /* @__PURE__ */ r("sphereGeometry", { args: [1, 10, 8] }),
+      /* @__PURE__ */ r("meshBasicMaterial", { toneMapped: !1, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1 })
+    ] }),
+    /* @__PURE__ */ r("lineSegments", { geometry: u, frustumCulled: !1, children: /* @__PURE__ */ r("lineBasicMaterial", { vertexColors: !0, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) }),
+    /* @__PURE__ */ J("mesh", { position: [0, _e * lt - 0.02, -_e * ut], rotation: [-Math.PI / 2 + He, 0, 0], scale: [Ie * 1.05, Ie * 0.62, 1], renderOrder: -1, children: [
+      /* @__PURE__ */ r("circleGeometry", { args: [1, 48] }),
+      /* @__PURE__ */ r("meshBasicMaterial", { map: Fe(), color: new t.Color("#0f766e").multiplyScalar(0.55), transparent: !0, depthWrite: !1, blending: t.AdditiveBlending, toneMapped: !1 })
+    ] }),
+    /* @__PURE__ */ r($t, { position: [0, _e - 0.9, 0.6], color: "#2dd4bf", size: 0.3, pxRange: [9, 13] }),
+    ot.map((v) => /* @__PURE__ */ r("group", { ref: (x) => void (E.current[v] = x), children: /* @__PURE__ */ r(dt, { ref: (x) => void (h.current[v] = x), text: "", size: 0.24, opacity: 0, pxRange: [8, 12] }) }, v))
+  ] });
+}
+function Fn() {
+  return /* @__PURE__ */ J(
+    Jt,
+    {
+      title: "Deep sea · bioluminescent agents",
+      subtitle: "jellyfish = agents · currents = Hatchet runs · coral reef = knowledge graph · anglerfish = MCP servers",
+      preset: Qt,
+      plane: "xy",
+      camera: { position: [0, 2.4, 21], fov: 50, far: 300 },
+      controls: { minPolarAngle: Math.PI * 0.3, maxPolarAngle: Math.PI * 0.58, minAzimuthAngle: -0.8, maxAzimuthAngle: 0.8 },
+      bg: "#010409",
+      fit: { nRef: 4, min: 0.62, max: 1.6, minRadius: 5.5 },
+      agentRadius: 1.4,
+      graph: { natural: Ie, radius: 3.6 },
+      peripheryGap: 4,
+      Background: /* @__PURE__ */ r(sn, {}),
+      Agent: pn,
+      RunMarker: mn,
+      McpServer: an,
+      GraphResource: Pn,
+      cluster: { radius: 1.25, variant: "swarm", pointSize: 0.9, labelBelow: 1.15 },
+      PostFX: /* @__PURE__ */ J(Et, { multisampling: 0, children: [
+        /* @__PURE__ */ r(Ot, { mipmapBlur: !0, intensity: 1.25, luminanceThreshold: 0.16, luminanceSmoothing: 0.25, radius: 0.78 }),
+        /* @__PURE__ */ r(Vt, { eskil: !1, offset: 0.22, darkness: 0.9 }),
+        /* @__PURE__ */ r(Wt, { opacity: 0.03 })
+      ] }),
+      children: [
+        /* @__PURE__ */ r(dn, {}),
+        /* @__PURE__ */ r(xn, {}),
+        /* @__PURE__ */ r(cn, {})
+      ]
+    }
+  );
+}
+export {
+  Fn as default
+};