agentglow 0.1.0 → 0.2.0

package/dist/chunks/index-Cyv7bII1.js

@@ -0,0 +1,818 @@
+import { jsxs as J, jsx as r } from "react/jsx-runtime";
+import { EffectComposer as Et, Bloom as Vt, Vignette as Ot, Noise as kt } from "@react-three/postprocessing";
+import { useThree as Wt, useFrame as le } from "@react-three/fiber";
+import { useMemo as i, useRef as _, useEffect as Ct, useState as Lt } from "react";
+import * as t from "three";
+import { B as ht, r as Bt, k as dt, w as Z, L as Ze, a as ie, d as Dt, T as Ke, q as Nt, x as Ue, l as Xt, e as qt, f as ze, S as Se, R as jt, g as Pt, b as ct, K as lt, m as Ht, G as Zt, n as Kt, j as $t } from "./KitScene-BuFtYuhc.js";
+import { Trail as Tt } from "@react-three/drei";
+const Ee = Bt ? 0.25 : 1, Yt = {
+  ...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 Ye = new t.Vector3(0.95, 0.75, 0.25), Ne = 1.15;
+function Xe(e, o) {
+  const n = dt.mcp.get(e);
+  if (!n) return;
+  const s = n.out.x > 0 ? -1 : 1;
+  return o.set(n.pos.x + Ye.x * s * Ne, n.pos.y + Ye.y * Ne, n.pos.z + Ye.z * Ne * s);
+}
+const ae = (e) => e < 0 ? 0 : e > 1 ? 1 : e, Jt = (e) => 1 - Math.pow(1 - e, 3), Qt = (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, m) {
+  Te.copy(e).add(o).multiplyScalar(0.5), Te.y += s;
+  const M = 1 - n;
+  return m.set(
+    M * M * e.x + 2 * M * n * Te.x + n * n * o.x,
+    M * M * e.y + 2 * M * n * Te.y + n * n * o.y,
+    M * M * e.z + 2 * M * n * Te.z + n * n * o.z
+  );
+}
+let ke = null;
+function Fe() {
+  if (ke) return ke;
+  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), ke = new t.CanvasTexture(e), ke;
+}
+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 en() {
+  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 tn() {
+  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 nn() {
+  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 Je = Bt ? 700 : 2200;
+function on() {
+  const e = Wt((p) => p.viewport.dpr), o = i(tn, []), n = i(nn, []), s = i(en, []), m = 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) }
+    ],
+    []
+  ), M = i(() => {
+    const p = new t.BufferGeometry(), v = new Float32Array(Je * 3), B = new Float32Array(Je);
+    for (let R = 0; R < Je; R++)
+      v[R * 3] = (Math.random() - 0.5) * 50, v[R * 3 + 1] = Math.random() * 24 - 10, v[R * 3 + 2] = Math.random() * 34 - 22, B[R] = Math.random();
+    return p.setAttribute("position", new t.BufferAttribute(v, 3)), p.setAttribute("aSeed", new t.BufferAttribute(B, 1)), p;
+  }, []), d = _(null), b = _(null), l = _(null);
+  return le(({ clock: p }) => {
+    var h, w, z;
+    const v = p.elapsedTime * Ee, B = dt.core;
+    (h = d.current) == null || h.position.set(0, -(B.hh + 4.4), -4);
+    const R = Math.max(1, B.hw / 9);
+    (w = b.current) == null || w.scale.set(R, Math.max(1, B.hh / 6), 1), (z = l.current) == null || z.scale.setScalar(Math.max(1, B.r / 11)), o.uniforms.uTime.value = v, n.uniforms.uTime.value = v, s.uniforms.uTime.value = v, s.uniforms.uPx.value = e;
+    for (const L of m) L.m.uniforms.uTime.value = v;
+  }), /* @__PURE__ */ J("group", { children: [
+    /* @__PURE__ */ r("mesh", { material: o, renderOrder: -10, children: /* @__PURE__ */ r("sphereGeometry", { args: [120, 32, 16] }) }),
+    /* @__PURE__ */ r("mesh", { ref: d, 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: b, children: m.map((p, v) => /* @__PURE__ */ r("mesh", { material: p.m, position: [p.x, 3.5, -3.5 - (v > 2 ? 4 : 0)], rotation: [0, 0, p.rz], children: /* @__PURE__ */ r("planeGeometry", { args: [p.w, 24] }) }, v)) }),
+    /* @__PURE__ */ r("group", { ref: l, children: /* @__PURE__ */ r("points", { geometry: M, material: s, frustumCulled: !1 }) })
+  ] });
+}
+const Mt = new t.Vector3(0.95, 0.75, 0.25);
+function rn({ mcp: e }) {
+  const o = e.srv, n = _(null), s = _(null), m = _(null), M = _(null), d = _(null), b = _(null), l = i(() => new t.Color(o.color), [o.color]), p = i(() => zt(o.color), [o.color]), v = i(() => new t.MeshBasicMaterial({ toneMapped: !1 }), []), B = i(() => new t.SpriteMaterial({ color: o.color, map: Fe(), transparent: !0, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1 }), [o.color]), R = i(() => new t.MeshBasicMaterial({ color: new t.Color(o.color).multiplyScalar(0.8), toneMapped: !1 }), [o.color]), h = i(() => new t.MeshBasicMaterial({ color: new t.Color(2.5, 2.5, 2.5), toneMapped: !1 }), []), w = i(() => new t.MeshBasicMaterial({ color: o.color, transparent: !0, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1, side: t.DoubleSide }), [o.color]), z = i(() => {
+    const F = new t.QuadraticBezierCurve3(new t.Vector3(0.55, 0.35, 0), new t.Vector3(0.75, 1.25, 0), Mt);
+    return new t.TubeGeometry(F, 16, 0.018, 4);
+  }, []), L = i(() => performance.now(), []);
+  return le(({ clock: F }) => {
+    var S;
+    const x = performance.now(), A = F.elapsedTime * Ee, G = Z.mcpServers.get(o.name) ?? o, g = G.inflight > 0, c = Math.exp(-(x - G.activeAt) / 500), U = Math.min(1, (x - L) / 1200), k = n.current, u = s.current;
+    if (!k || !u) return;
+    k.position.copy(e.pos), k.position.y += Math.sin(A * 0.45 + G.slot * 2) * 0.2, u.rotation.y = (e.out.x > 0 ? Math.PI : 0) + Math.sin(A * (g ? 2.4 : 0.6)) * (g ? 0.35 : 0.12), u.rotation.z = Math.sin(A * 0.5 + G.slot) * 0.08, u.scale.setScalar(Math.max(1e-3, U * Ne * (1 + c * 0.12))), p.uniforms.uIntensity.value = 0.16 + (g ? 0.18 : 0) + c * 0.45, p.uniforms.uOpacity.value = 0.7 * U;
+    const E = (g ? 2.4 + Math.sin(x / 110) * 0.9 : 1.2) + c * 4;
+    if (v.color.copy(l).multiplyScalar(E), m.current && m.current.scale.setScalar(1 + c * 0.5 + (g ? 0.15 * Math.sin(x / 110) : 0)), M.current && (M.current.scale.setScalar(1.6 + c * 2 + (g ? 0.8 : 0)), B.opacity = 0.35 + c * 0.4 + (g ? 0.2 : 0)), d.current) {
+      const P = (x - G.activeAt) / 1100;
+      d.current.visible = P < 1, d.current.scale.setScalar(0.3 + P * 2.4), w.opacity = Math.max(0, 1 - P) * 0.9;
+    }
+    (S = b.current) == null || S.setOpacity(U * (g ? 1 : 0.75));
+  }), /* @__PURE__ */ J("group", { ref: n, children: [
+    /* @__PURE__ */ J("group", { ref: s, children: [
+      /* @__PURE__ */ r("mesh", { material: p, scale: [0.95, 0.62, 0.55], children: /* @__PURE__ */ r("sphereGeometry", { args: [1, 28, 18] }) }),
+      /* @__PURE__ */ r("mesh", { material: p, 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: p, 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: R, geometry: z }),
+      /* @__PURE__ */ r("mesh", { material: h, position: [0.55, 0.12, 0.42], children: /* @__PURE__ */ r("sphereGeometry", { args: [0.05, 8, 6] }) }),
+      /* @__PURE__ */ J("group", { position: Mt, children: [
+        /* @__PURE__ */ r("mesh", { ref: m, material: v, children: /* @__PURE__ */ r("sphereGeometry", { args: [0.13, 16, 12] }) }),
+        /* @__PURE__ */ r("sprite", { ref: M, material: B }),
+        /* @__PURE__ */ r("mesh", { ref: d, material: w, visible: !1, children: /* @__PURE__ */ r("ringGeometry", { args: [0.92, 1, 48] }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ r(Ze, { ref: b, position: [0, -1.15, 0], text: `mcp · ${o.name}`, color: o.color, size: 0.3, opacity: 0, pxRange: [9, 13] })
+  ] });
+}
+function sn() {
+  const n = i(() => {
+    const p = new t.BufferGeometry();
+    return p.setAttribute("position", new t.BufferAttribute(new Float32Array(4032), 3)), p.setAttribute("color", new t.BufferAttribute(new Float32Array(4032), 3)), p;
+  }, []), s = i(() => new t.Vector3(), []), m = i(() => new t.Vector3(), []), M = i(() => new t.Color("#f59e0b"), []), d = i(() => new t.Color("#ef4444"), []), b = i(() => new t.Color(1, 1, 1), []), l = i(() => new t.Color(), []);
+  return le(({ clock: p }) => {
+    var x;
+    const v = performance.now(), B = p.elapsedTime, R = n.getAttribute("position"), h = n.getAttribute("color"), w = R.array, z = h.array;
+    let L = 0;
+    const F = (A, G, g) => {
+      for (let c = 0; c < 28; c++)
+        for (let U = 0; U < 2; U++) {
+          const k = (c + U) / 28, u = ((L * 28 + c) * 2 + U) * 3;
+          qe(A, G, k, 1.6, s);
+          const E = Math.sin(k * 14 - B * 5) * 0.05 * Math.sin(k * Math.PI);
+          w[u] = s.x, w[u + 1] = s.y + E, w[u + 2] = s.z;
+          const S = g(k);
+          z[u] = l.r * S, z[u + 1] = l.g * S, z[u + 2] = l.b * S;
+        }
+      L++;
+    };
+    for (const A of Z.mcpPending.values()) {
+      if (L >= 24) break;
+      const G = ie(A.instance), g = Xe(A.server, m);
+      if (!G || !g) continue;
+      const c = Dt(A, v), U = Z.mcpServers.get(A.server);
+      l.set((U == null ? void 0 : U.color) ?? "#94a3b8"), c < 1 ? l.lerp(M, c * 0.8) : l.copy(M).lerp(d, Math.min(1, (c - 1) / 1.2));
+      const k = 0.35 + Math.min(c, 3) * 0.35, u = Math.min(1, c * 4);
+      F(G, g, (E) => {
+        if (E > u) return 0;
+        const S = E * 6 - B * 1.8;
+        return k * (0.45 + Math.pow(S - Math.floor(S), 8) * 3);
+      });
+    }
+    for (const A of Z.mcpResolved) {
+      if (L >= 24) break;
+      const G = ie(A.instance), g = Xe(A.server, m);
+      if (!G || !g) continue;
+      const c = (v - A.resolvedAt) / 700;
+      l.set(((x = Z.mcpServers.get(A.server)) == null ? void 0 : x.color) ?? "#ffffff").lerp(b, 0.6);
+      const U = 1 - c * 1.15;
+      F(G, g, (k) => (1 - c) * (0.25 + Math.exp(-Math.pow((k - U) * 9, 2)) * 5));
+    }
+    n.setDrawRange(0, L * 28 * 2), R.needsUpdate = !0, h.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 We = 9, ge = 11, Le = 46, _t = 1500, De = new t.Vector3(), an = new t.SphereGeometry(1, 36, 18, 0, Math.PI * 2, 0, Math.PI / 2), cn = new t.SphereGeometry(1, 16, 12), vt = new t.Color();
+function ln({ agent: e, selected: o, onSelect: n }) {
+  const s = e.inst, m = s.id, M = e.depth > 0, d = M ? 0.42 : 0.62, b = Ut(m) % 1e3 / 1e3, l = Ke[s.type], p = _(null), v = _(null), B = _(null), R = _(null), h = _(null), w = _(null), z = _(null), L = _(b * 6), F = i(() => zt(l), [l]), x = i(() => new t.MeshBasicMaterial({ color: l, transparent: !0, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1 }), [l]), A = i(() => new t.SpriteMaterial({ color: l, map: Fe(), transparent: !0, opacity: 0.06, toneMapped: !1, blending: t.AdditiveBlending, depthWrite: !1 }), [l]), G = i(() => new t.Color(l), [l]), g = i(() => {
+    const S = new t.BufferGeometry(), P = We * ge * 2;
+    S.setAttribute("position", new t.BufferAttribute(new Float32Array(P * 3), 3));
+    const I = new Float32Array(P * 3), V = new t.Color(l);
+    for (let f = 0; f < We; f++)
+      for (let C = 0; C < ge; C++)
+        for (let W = 0; W < 2; W++) {
+          const j = 1 - (C + W) / ge, H = (f * ge + C) * 2 + W;
+          I[H * 3] = V.r * (0.4 + j * 1.8), I[H * 3 + 1] = V.g * (0.4 + j * 1.8), I[H * 3 + 2] = V.b * (0.4 + j * 1.8);
+        }
+    return S.setAttribute("color", new t.BufferAttribute(I, 3)), S;
+  }, [l]), c = i(() => new t.LineBasicMaterial({ vertexColors: !0, transparent: !0, opacity: 0.8, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }), []), U = i(() => {
+    const S = new Float32Array(Le * 4);
+    for (let I = 0; I < Le; I++) {
+      const V = Math.random() * Math.PI * 2, f = Math.random() * 1.4 - 0.4, C = Math.sqrt(1 - Math.min(1, f * f));
+      S[I * 4] = Math.cos(V) * C, S[I * 4 + 1] = f, S[I * 4 + 2] = Math.sin(V) * C, S[I * 4 + 3] = 0.5 + Math.random();
+    }
+    const P = new t.BufferGeometry();
+    return P.setAttribute("position", new t.BufferAttribute(new Float32Array(Le * 3), 3)), { dirs: S, g: P };
+  }, []), k = i(
+    () => new t.PointsMaterial({ color: new t.Color(l).multiplyScalar(2.2), size: M ? 0.16 : 0.22, map: Fe(), transparent: !0, depthWrite: !1, blending: t.AdditiveBlending, toneMapped: !1 }),
+    [l, M]
+  ), u = i(() => new t.Vector3(), []), E = _(!1);
+  return Ct(
+    () => () => {
+      F.dispose(), x.dispose(), A.dispose(), g.dispose(), U.g.dispose(), k.dispose();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  ), le(({ clock: S }, P) => {
+    var we;
+    const I = performance.now(), V = S.elapsedTime, f = e.inst;
+    if (!E.current) {
+      E.current = !0;
+      const Y = f.parent ? ie(f.parent) : void 0;
+      Y ? u.copy(Y) : Nt(e.run, Ue("planner"), Ft * ze.spread, u);
+    }
+    const C = 0.12 * Ee * Math.max(1, ze.spread);
+    De.copy(e.pos), De.x += Math.sin(V * 0.4 + b * 9) * C, De.y += Math.sin(V * 0.7 + b * 5) * C;
+    const W = ae((I - f.bornAt) / _t), j = Jt(ae(W / 0.8)), H = W < 0.32, K = H ? 0 : Qt(ae((W - 0.32) / 0.68)), Q = f.exitAt ? (I - f.exitAt) / Xt(f) : 0, y = f.exitAt > 0, D = y ? Math.max(0, 1 - Q * 1.25) : 1, a = y ? Math.exp(-(I - f.exitAt) / 220) : 0, T = f.status === "failed";
+    let O = !1;
+    for (const Y of Z.mcpPending.values()) Y.instance === m && (O = !0);
+    const q = (f.status === "thinking" || f.status === "spawning") && !O, N = qt(f, I), ee = o, X = ze.scale, ne = y ? 0.8 : q ? 4.6 : O ? 1.8 : 1.1;
+    L.current += P * ne;
+    const me = Math.pow(0.5 + 0.5 * Math.sin(L.current), 3), oe = q ? 1 : 0.45, Me = e.live;
+    Me.lerpVectors(u, De, j), Me.y += me * 0.12 * oe * X + (y ? Q * 1.2 * X : 0), p.current && (p.current.position.copy(Me), p.current.rotation.z = Math.sin(V * 0.5 + b * 7) * 0.12, p.current.rotation.x = Math.sin(V * 0.37 + b * 3) * 0.08);
+    const $ = d * X * K * (1 + N * 0.14) * (1 + (y ? Q * 0.6 : 0)) * (ee ? 1.12 : 1), re = 1 + me * 0.14 * oe, ve = 0.8 * (1 - me * 0.24 * oe);
+    v.current && (v.current.visible = !(y && D <= 1e-3)), (we = B.current) == null || we.scale.set(Math.max(1e-4, $ * re), Math.max(1e-4, $ * ve), Math.max(1e-4, $ * re));
+    const ue = q ? 1.25 : O ? 0.7 + 0.35 * Math.sin(V * 2.2) : 0.45;
+    if (F.uniforms.uIntensity.value = ue + N * 1.7 + a * 5 + (ee ? 0.7 : 0), F.uniforms.uOpacity.value = D * (0.4 + 0.6 * ae(K)), F.uniforms.uFlash.value = a, T && y && F.uniforms.uColor.value.set("#ef4444"), R.current) {
+      const Y = X * (H ? d * (0.32 + 0.08 * Math.sin(I / 50)) : d * (0.22 + N * 0.06) * Math.min(1, K + 0.3));
+      R.current.scale.setScalar(Math.max(1e-4, Y * (1 - (y ? Q : 0)))), R.current.position.y = H ? 0 : $ * ve * 0.35, vt.copy(G).multiplyScalar((H ? 5 : 1.6 + N * 3) * ue + a * 8), x.color.copy(vt), x.opacity = D;
+    }
+    h.current && (h.current.scale.setScalar(d * X * (H ? 3 : 4.2 + N * 2 + a * 4)), A.opacity = (0.12 + N * 0.16 + (H ? 0.5 : 0) + a * 0.6 + (ee ? 0.2 : 0)) * D);
+    const Ve = g.getAttribute("position"), de = Ve.array, ye = $ * re * 0.88, he = d * X * (M ? 3 : 3.6) * ae(K) * (0.85 + 0.15 * (1 - me)), fe = q ? 3.2 : 1.1, Oe = d * X * (q ? 0.55 : 0.35);
+    for (let Y = 0; Y < We; Y++) {
+      const be = Y / We * Math.PI * 2, xe = Math.cos(be), Pe = Math.sin(be), Ae = 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 * Ae * (1 - se * 0.4), $e = ((Y * ge + te) * 2 + pe) * 3;
+          de[$e] = xe * mt + Math.sin(ft) * Oe * se, de[$e + 1] = -se * he * (Ae < 1 ? 0.7 : 1), de[$e + 2] = Pe * mt + Math.cos(ft * 0.8) * Oe * se * 0.7;
+        }
+    }
+    if (Ve.needsUpdate = !0, c.opacity = D * (q ? 0.95 : 0.55) * ae(K * 1.5), z.current && (z.current.visible = y, y)) {
+      const Y = U.g.getAttribute("position"), be = Y.array, xe = (I - f.exitAt) / 1e3, Pe = 1 - Math.exp(-xe * 3.5), Ae = d * X;
+      for (let te = 0; te < Le; te++) {
+        const pe = U.dirs, se = pe[te * 4 + 3];
+        be[te * 3] = pe[te * 4] * Ae * 2.2 * Pe * se + Math.sin(xe * 2 + te) * 0.08, be[te * 3 + 1] = pe[te * 4 + 1] * Ae * 1.6 * Pe * se + xe * 0.9 * se, be[te * 3 + 2] = pe[te * 4 + 2] * Ae * 2.2 * Pe * se;
+      }
+      Y.needsUpdate = !0, k.opacity = Math.max(0, 1 - Q) * Math.min(1, xe * 6);
+    }
+  }), /* @__PURE__ */ J("group", { ref: p, children: [
+    /* @__PURE__ */ J("group", { ref: v, children: [
+      /* @__PURE__ */ r(
+        "mesh",
+        {
+          ref: B,
+          geometry: an,
+          material: F,
+          onClick: (S) => (S.stopPropagation(), n(m)),
+          onPointerOver: () => document.body.style.cursor = "pointer",
+          onPointerOut: () => document.body.style.cursor = ""
+        }
+      ),
+      /* @__PURE__ */ r("mesh", { ref: R, geometry: cn, material: x }),
+      /* @__PURE__ */ r("sprite", { ref: h, material: A }),
+      /* @__PURE__ */ r("lineSegments", { ref: w, geometry: g, material: c, frustumCulled: !1 })
+    ] }),
+    /* @__PURE__ */ r("points", { ref: z, geometry: U.g, material: k, frustumCulled: !1, visible: !1 })
+  ] });
+}
+const Ft = 1.25;
+function un() {
+  const n = i(() => {
+    const m = new t.BufferGeometry();
+    return m.setAttribute("position", new t.BufferAttribute(new Float32Array(3840), 3)), m.setAttribute("color", new t.BufferAttribute(new Float32Array(3840), 3)), m;
+  }, []), s = i(() => new t.Color(), []);
+  return le(({ clock: m }) => {
+    const M = performance.now(), d = m.elapsedTime, b = n.getAttribute("position"), l = n.getAttribute("color"), p = b.array, v = l.array, B = ze.scale;
+    let R = 0;
+    for (const h of dt.agents.values()) {
+      if (R >= 64) break;
+      const w = h.inst;
+      if (!w.parent) continue;
+      const z = ie(w.parent), L = h.live, F = Z.instances.get(w.parent);
+      if (!z || !F) continue;
+      const x = ae((M - w.bornAt) / _t), A = (w.exitAt ? Math.max(0, 1 - (M - w.exitAt) / 900) : 1) * (F.exitAt ? Math.max(0, 1 - (M - F.exitAt) / 900) : 1);
+      if (A <= 0) continue;
+      const G = (0.22 + Math.pow(1 - x, 2) * 2.2) * A;
+      s.set(Ke[w.type]);
+      for (let g = 0; g < 10; g++)
+        for (let c = 0; c < 2; c++) {
+          const U = (g + c) / 10, k = ((R * 10 + g) * 2 + c) * 3, u = Math.sin(U * Math.PI) * (0.35 + 0.1 * Math.sin(d * 1.3 + R)) * B;
+          p[k] = z.x + (L.x - z.x) * U, p[k + 1] = z.y - 0.25 * B + (L.y - z.y + 0.25 * B) * U - u, p[k + 2] = z.z + (L.z - z.z) * U;
+          const E = x < 1 ? Math.exp(-Math.pow((U - x * 1.1) * 7, 2)) * 3 : 0, S = G * (0.5 + U * 0.5) + E * A;
+          v[k] = s.r * S, v[k + 1] = s.g * S, v[k + 2] = s.b * S;
+        }
+      R++;
+    }
+    n.setDrawRange(0, R * 10 * 2), b.needsUpdate = !0, l.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 pn = { queued: "#1e3a5f", running: "#ffffff", done: "#5eead4", failed: "#ef4444" }, Qe = { plan: "planner", research: "researcher", write: "writer" }, je = 10, Ce = new t.Color(), ce = { u0: 0, u1: 1, mid: 0, half: 1, seed: 0 }, et = (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 dn({ run: e }) {
+  const o = i(() => Ut(e.id) % 997 / 97, [e.id]), n = _(null), s = _(null), m = _(null), M = _([]), d = _(null), b = _(null), { tube: l, glow: p } = i(() => {
+    const x = [];
+    for (let G = 0; G <= 48; G++) {
+      const g = -1 + 2 * G / 48;
+      x.push(new t.Vector3(g, Gt(g * je, o), Rt(g * je, o)));
+    }
+    const A = new t.CatmullRomCurve3(x);
+    return { tube: new t.TubeGeometry(A, 200, 0.05, 6), glow: new t.TubeGeometry(A, 120, 0.32, 8) };
+  }, [o]), v = i(() => gt(e.color), [e.color]), B = i(() => {
+    const x = gt(e.color);
+    return x.uniforms.uWidthGlow.value = 0.18, x;
+  }, [e.color]), R = i(() => [v, B], [v, B]), h = i(() => new t.Color(e.color), [e.color]), w = i(() => Se.map(() => new t.MeshBasicMaterial({ toneMapped: !1, transparent: !0 })), []), z = i(() => Se.map(() => new t.MeshBasicMaterial({ toneMapped: !1, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1 })), []), L = i(() => Se.map(() => new t.SpriteMaterial({ map: Fe(), toneMapped: !1, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1 })), []), F = i(() => new t.MeshBasicMaterial({ toneMapped: !1, transparent: !0 }), []);
+  return Ct(
+    () => () => {
+      l.dispose(), p.dispose(), v.dispose(), B.dispose(), [...w, ...z, ...L, F].forEach((x) => x.dispose());
+    },
+    [l, p, v, B, w, z, L, F]
+  ), le(({ clock: x }) => {
+    var K, Q;
+    const A = n.current;
+    if (!A) return;
+    const G = performance.now(), g = x.elapsedTime, c = e.run ?? Z.runs.get(e.id);
+    A.position.copy(e.origin).addScaledVector(e.side, -e.cu).addScaledVector(e.axis, -e.cv);
+    const U = ze.spread, k = 1.6 * U, u = ce;
+    u.u0 = e.cu - e.hu - k, u.u1 = e.cu + e.hu + k;
+    const E = u.mid = (u.u0 + u.u1) / 2, S = u.half = (u.u1 - u.u0) / 2;
+    u.seed = o;
+    const P = -Ft * U, I = s.current;
+    I && (I.position.set(E, P, 0), I.scale.set(S, 1, 1));
+    const V = c ? ae((G - c.startedAt) / 1600) * 1.1 : 1.1, f = c != null && c.endedAt ? Math.max(0, 1 - (G - c.endedAt) / jt) : 1;
+    let C = -1, W = 0;
+    const j = c ? (G - c.handoffAt) / 1300 : 9;
+    if (c && c.handoffAt && j < 1) {
+      const y = 1 - Math.pow(1 - j, 3), D = Ue(Qe[c.handoffFrom]), a = Ue(Qe[c.handoffTo]);
+      C = et(D + (a - D) * y), W = Math.sin(j * Math.PI) * 1.2 + 0.3;
+    } else if (c != null && c.endedAt && G - c.endedAt < 1400) {
+      const y = (G - c.endedAt) / 1400, D = Ue("writer");
+      C = et(D + (u.u1 - D) * y), W = (1 - y) * 0.45;
+    }
+    for (const y of R)
+      y.uniforms.uTime.value = g * Ee, y.uniforms.uReveal.value = V, y.uniforms.uFade.value = f, y.uniforms.uPulse.value = C, y.uniforms.uPulseAmp.value = W;
+    if (m.current && (m.current.visible = C >= 0, C >= 0)) {
+      const y = u.u0 + C * (u.u1 - u.u0);
+      m.current.position.set(y, P + yt(y), wt(y)), m.current.scale.setScalar(0.18 + W * 0.12), F.color.copy(bt).lerp(h, 0.3).multiplyScalar(4 * Math.max(0.3, W)), F.opacity = f;
+    }
+    const H = !!(c != null && c.hasSteps);
+    for (let y = 0; y < Se.length; y++) {
+      const D = Se[y], a = M.current[y];
+      if (!a || (a.visible = H, !c || !H)) continue;
+      const T = Ue(Qe[D]);
+      a.position.set(T, P + yt(T), wt(T));
+      const O = c.steps[D], q = ae((V - et(T)) * 6), N = O === "running", ee = N ? 0.5 + 0.5 * Math.sin(g * 5.5) : 0;
+      a.scale.setScalar(Math.max(1e-3, q * (N ? 1.15 + ee * 0.2 : O === "done" ? 0.9 : 0.75) * Math.max(0.9, U))), a.rotation.y += N ? 0.05 : 4e-3;
+      const X = w[y];
+      O === "queued" ? Ce.copy(h).multiplyScalar(0.35) : N ? Ce.copy(h).lerp(bt, 0.35).multiplyScalar(2.2 + ee * 2.2) : Ce.set(pn[O]).multiplyScalar(O === "done" ? 1.5 : 2.5), X.color.copy(Ce), X.opacity = f, z[y].color.copy(Ce).multiplyScalar(N ? 0.9 : 0.5), z[y].opacity = f * (O === "queued" ? 0.35 : 1), L[y].color.copy(N ? h : Ce), L[y].opacity = f * (N ? 0.45 + ee * 0.3 : O === "done" ? 0.18 : 0.05);
+    }
+    (K = d.current) == null || K.position.set(u.u0 + 0.3, e.hv - e.cv + 0.5, 0), (Q = b.current) == null || Q.setOpacity(f * ae(V * 2));
+  }), /* @__PURE__ */ J("group", { ref: n, children: [
+    /* @__PURE__ */ J("group", { ref: s, children: [
+      /* @__PURE__ */ r("mesh", { geometry: l, material: v }),
+      /* @__PURE__ */ r("mesh", { geometry: p, material: B })
+    ] }),
+    /* @__PURE__ */ r("mesh", { ref: m, material: F, visible: !1, children: /* @__PURE__ */ r("sphereGeometry", { args: [1, 16, 12] }) }),
+    Se.map((x, A) => /* @__PURE__ */ J("group", { ref: (G) => void (M.current[A] = G), visible: !1, children: [
+      /* @__PURE__ */ r("mesh", { material: w[A], children: /* @__PURE__ */ r("icosahedronGeometry", { args: [0.2, 2] }) }),
+      Array.from({ length: 8 }, (G, g) => {
+        const c = g / 8 * Math.PI * 2;
+        return /* @__PURE__ */ r("mesh", { material: z[A], position: [Math.cos(c) * 0.36, 0.1 + g % 2 * 0.08, Math.sin(c) * 0.36], children: /* @__PURE__ */ r("sphereGeometry", { args: [0.055, 8, 6] }) }, g);
+      }),
+      /* @__PURE__ */ r("mesh", { material: z[A], rotation: [Math.PI / 2, 0, 0], children: /* @__PURE__ */ r("torusGeometry", { args: [0.36, 0.012, 6, 40] }) }),
+      /* @__PURE__ */ r("sprite", { material: L[A], scale: 2.4 }),
+      /* @__PURE__ */ r(Ze, { position: [0, -0.75, 0], text: x, color: e.color, textColor: "#bae6fd", uppercase: !0, letterSpacing: 0.08, size: 0.22, opacity: 0.8, pxRange: [7.5, 10.5] })
+    ] }, x)),
+    /* @__PURE__ */ r("group", { ref: d, children: /* @__PURE__ */ r(fn, { runId: e.id, color: e.color, labelRef: b }) })
+  ] });
+}
+function fn({ runId: e, color: o, labelRef: n }) {
+  const s = Z.runs.get(e);
+  return /* @__PURE__ */ r(
+    Ze,
+    {
+      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 mn = new t.ConeGeometry(0.07, 0.34, 8).rotateX(Math.PI / 2), xt = new t.Vector3(), hn = new t.Vector3(), It = (e) => e < 0.5 ? 2 * e * e : 1 - Math.pow(-2 * e + 2, 2) / 2;
+function At(e) {
+  const [o, n] = Lt([]), s = _([]);
+  return le(() => {
+    const m = e(), M = s.current;
+    let d = M.length === m.length;
+    if (d)
+      for (let b = 0; b < m.length; b++) M[b] !== m[b].id && (d = !1);
+    d || (s.current = m.map((b) => b.id), n(m.slice()));
+  }), o;
+}
+function gn({ comet: e }) {
+  const o = _(null), n = Z.instances.get(e.from), s = n ? Ke[n.type] : "#a5f3fc", m = i(() => new t.MeshBasicMaterial({ color: new t.Color(s).multiplyScalar(4), toneMapped: !1 }), [s]), M = i(() => (ie(e.from) ?? new t.Vector3()).clone(), [e.from]);
+  return le(() => {
+    const d = o.current;
+    if (!d) return;
+    const b = Math.min(1, (performance.now() - e.start) / e.dur), l = ie(e.from), p = ie(e.to);
+    if (!l || !p) {
+      d.scale.setScalar(1e-3);
+      return;
+    }
+    qe(l, p, It(b), 1.1, d.position), d.scale.setScalar(b >= 1 ? 1e-3 : 1 + Math.sin(b * Math.PI) * 0.4);
+  }), /* @__PURE__ */ r(Tt, { width: 1.8, length: 6, color: s, attenuation: (d) => d * d, decay: 1.4, children: /* @__PURE__ */ r("mesh", { ref: o, position: M, material: m, children: /* @__PURE__ */ r("sphereGeometry", { args: [0.11, 12, 10] }) }) });
+}
+function Mn({ call: e }) {
+  const o = _(null), n = Z.mcpServers.get(e.server), s = (n == null ? void 0 : n.color) ?? "#94a3b8", m = i(() => new t.MeshBasicMaterial({ color: new t.Color(s).multiplyScalar(e.phase === "result" ? 5 : 3.5), toneMapped: !1 }), [s, e.phase]), M = i(() => ((e.phase === "call" ? ie(e.instance) : Xe(e.server, new t.Vector3())) ?? new t.Vector3()).clone(), [e]);
+  return le(() => {
+    const d = o.current;
+    if (!d) return;
+    const b = Math.min(1, (performance.now() - e.start) / e.dur), l = ie(e.instance), p = Xe(e.server, hn);
+    if (!l || !p) {
+      d.scale.setScalar(1e-3);
+      return;
+    }
+    const v = It(b), B = e.phase === "call" ? v : 1 - v;
+    qe(l, p, B, 1.6, d.position), qe(l, p, e.phase === "call" ? Math.min(1, B + 0.02) : Math.max(0, B - 0.02), 1.6, xt), d.lookAt(xt), d.scale.setScalar(b >= 1 ? 1e-3 : 1);
+  }), /* @__PURE__ */ r(Tt, { width: 1.4, length: 5, color: s, attenuation: (d) => d * d * d, decay: 1.6, children: /* @__PURE__ */ r("mesh", { ref: o, position: M, material: m, geometry: mn }) });
+}
+const tt = [], nt = [];
+function vn() {
+  if (!Pt.grouped) return Z.comets;
+  tt.length = 0;
+  for (const e of Z.comets) ct(e.from) && ct(e.to) && tt.push(e);
+  return tt;
+}
+function yn() {
+  if (!Pt.grouped) return Z.mcpCalls;
+  nt.length = 0;
+  for (const e of Z.mcpCalls) ct(e.instance) && nt.push(e);
+  return nt;
+}
+function wn() {
+  const e = At(vn), o = At(yn);
+  return /* @__PURE__ */ J("group", { children: [
+    e.map((n) => /* @__PURE__ */ r(gn, { comet: n }, n.id)),
+    o.map((n) => /* @__PURE__ */ r(Mn, { call: n }, n.id))
+  ] });
+}
+const ot = 60, bn = new t.Vector3(), rt = [0, 1], xn = 9, st = 180, at = 60, Be = 6, Ie = 4.2, _e = -1.15, He = 0.42, ut = Math.cos(He), pt = Math.sin(He), An = Object.keys(lt), it = 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 St(e, o, n, s, m) {
+  e[o * 3] = n, e[o * 3 + 1] = s * ut + m * pt, e[o * 3 + 2] = -s * pt + m * ut;
+}
+function Sn(e) {
+  const o = e.nodes.length, n = new Float32Array(o * 3), s = new Float32Array(o * 3), m = new Float32Array(o), M = new Int32Array(o), d = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
+  for (const l of e.nodes) b.set(l.kind, (b.get(l.kind) ?? 0) + 1);
+  return e.nodes.forEach((l, p) => {
+    let v = An.indexOf(l.kind);
+    v < 0 && (v = 8 + Math.floor(Re(l.kind, 3) * 8));
+    const B = (v + 0.5) / 12, R = v * 2.39996 + 0.6, h = Math.sqrt(B), w = Math.cos(R) * h * Ie * 0.82, z = Math.sin(R) * h * Ie * 0.42, L = 0.35 + Math.sqrt(b.get(l.kind) ?? 1) * 0.1;
+    d.has(l.kind) || d.set(l.kind, p), M[p] = d.get(l.kind);
+    const F = Re(l.id, 11) * Math.PI * 2, x = Math.pow(Re(l.id, 12), 0.7) * L, A = w + Math.cos(F) * x, G = z + Math.sin(F) * x * 0.8, g = (0.6 + Re(l.id, 13) * 1) * (1.5 - x / L * 0.8);
+    St(n, p, A, _e, G), St(s, p, A + Math.cos(F) * g * 0.35, _e + g, G + Math.sin(F) * g * 0.3), m[p] = Re(l.id, 14) * 6.28;
+  }), { base: n, head: s, phase: m, hub: M };
+}
+function Cn({ galaxy: e }) {
+  const o = i(() => {
+    const u = e.nodes.slice(0, it), E = new Set(u.map((S) => S.id));
+    return { nodes: u, links: e.links.filter((S) => E.has(S.source) && E.has(S.target)) };
+  }, [e]), n = o.nodes.length, s = i(() => Sn(o), [o]), m = i(() => o.nodes.map((u) => new t.Color(lt[u.kind] ?? "#94a3b8")), [o]), M = i(() => /* @__PURE__ */ new Map(), [o]), d = (u) => {
+    let E = M.get(u);
+    return E === void 0 && M.set(u, E = Kt(o, u) % Math.max(1, n)), E;
+  }, b = _(null), l = _(null), p = _(null), v = _(null), B = i(() => new Float32Array(n), [n]), R = i(() => new Float32Array(n), [n]), h = i(() => new t.Object3D(), []), w = i(() => new t.Color(), []), z = i(() => new t.Color(1, 1, 1), []), L = i(() => new t.Vector3(0, 1, 0), []), F = i(() => new t.Vector3(), []), x = i(() => new t.Vector3(), []), A = i(() => {
+    const u = new Map(o.nodes.map((f, C) => [f.id, C])), E = [], S = [], P = s.head, I = (f, C, W, j, H) => {
+      const K = m[f], Q = m[C];
+      for (let y = 0; y < H; y++)
+        for (let D = 0; D < 2; D++) {
+          const a = (y + D) / H;
+          E.push(P[f * 3] + (P[C * 3] - P[f * 3]) * a, P[f * 3 + 1] + (P[C * 3 + 1] - P[f * 3 + 1]) * a + Math.sin(a * Math.PI) * W, P[f * 3 + 2] + (P[C * 3 + 2] - P[f * 3 + 2]) * a), S.push((K.r + (Q.r - K.r) * a) * j, (K.g + (Q.g - K.g) * a) * j, (K.b + (Q.b - K.b) * a) * j);
+        }
+    };
+    s.hub.forEach((f, C) => f !== C && I(C, f, 0, 0.32, 1));
+    for (const f of o.links) {
+      const C = u.get(f.source), W = u.get(f.target);
+      if (C === void 0 || W === void 0 || C === W) continue;
+      const j = Math.hypot(P[C * 3] - P[W * 3], P[C * 3 + 2] - P[W * 3 + 2]);
+      I(C, W, Math.min(1.4, 0.15 + j * 0.09), 0.42, 10);
+    }
+    const V = new t.BufferGeometry();
+    return V.setAttribute("position", new t.Float32BufferAttribute(E, 3)), V.setAttribute("color", new t.Float32BufferAttribute(S, 3)), V;
+  }, [o, s, m]), G = _([]), g = _([]), c = _(["", ""]), U = i(() => {
+    const u = new t.BufferGeometry();
+    return u.setAttribute("position", new t.BufferAttribute(new Float32Array(at * Be * 2 * 3), 3)), u.setAttribute("color", new t.BufferAttribute(new Float32Array(at * Be * 2 * 3), 3)), u;
+  }, []);
+  le(({ clock: u }) => {
+    const E = performance.now(), S = u.elapsedTime * Ee;
+    B.fill(0), R.fill(0);
+    const P = b.current, I = l.current, V = p.current, f = v.current;
+    if (!P || !I || !V || !f) return;
+    let C = 0, W = 0, j = 0;
+    const H = U.getAttribute("position"), K = U.getAttribute("color"), Q = H.array, y = K.array;
+    for (const a of Z.flares) {
+      const T = d(a.node), O = (E - a.start) / 2600;
+      if (O < 0 || O >= 1) continue;
+      const q = a.op === "write", N = Math.exp(-O * 2.6) * Math.min(1, O * 20);
+      N > B[T] && (B[T] = N), q && (R[T] = Math.max(R[T], N));
+      const ee = s.base[T * 3], X = s.base[T * 3 + 1], ne = s.base[T * 3 + 2];
+      if (C < ot) {
+        h.position.set(ee, X + 0.03, ne), h.rotation.set(-Math.PI / 2 + He, 0, 0), h.scale.setScalar(0.12 + Math.sqrt(O) * (q ? 1.5 : 0.9)), h.updateMatrix(), V.setMatrixAt(C, h.matrix);
+        const $ = Math.pow(1 - O, 2) * (q ? 3 : 1.6);
+        q ? w.copy(z).multiplyScalar($) : w.copy(m[T]).multiplyScalar($), V.setColorAt(C, w), C++;
+      }
+      if (q)
+        for (let $ = 0; $ < xn && W < st; $++) {
+          const re = (a.id * 13 + $ * 7) % 97, ve = 1.4 + re % 10 * 0.18, ue = O * 2.6 - $ * 0.08;
+          ue < 0 || (h.position.set(
+            ee + Math.sin(re) * 0.35 + Math.sin(ue * 5 + $) * 0.1,
+            X + 0.3 + ue * ve * 0.6,
+            ne + Math.cos(re) * 0.35
+          ), h.rotation.set(0, 0, 0), h.scale.setScalar((0.05 + re % 5 * 0.015) * (1 + ue * 0.3)), h.updateMatrix(), f.setMatrixAt(W, h.matrix), w.setRGB(1, 1.5, 1.9).multiplyScalar(Math.pow(Math.max(0, 1 - O), 1.5)), f.setColorAt(W, w), W++);
+        }
+      const me = ie(a.instance), oe = me ? Ht(me, bn) : void 0, Me = Z.instances.get(a.instance);
+      if (oe && Me && j < at && O < 0.75) {
+        const $ = O / 0.75, re = Math.pow(1 - $, 1.5) * Math.min(1, $ * 12) * (q ? 2.4 : 1.6);
+        q ? w.copy(z) : w.set(Ke[Me.type]);
+        const ve = s.head[T * 3], ue = s.head[T * 3 + 1], Ve = s.head[T * 3 + 2];
+        for (let de = 0; de < Be; de++)
+          for (let ye = 0; ye < 2; ye++) {
+            const he = (de + ye) / Be, fe = ((j * Be + de) * 2 + ye) * 3;
+            Q[fe] = oe.x + (ve - oe.x) * he, Q[fe + 1] = oe.y + (ue - oe.y) * he, Q[fe + 2] = oe.z + (Ve - oe.z) * he;
+            const Oe = Math.exp(-Math.pow((he - Math.min(1, $ * 2.2)) * 6, 2)) * 2, we = re * (0.35 + he * 0.4 + Oe);
+            y[fe] = w.r * we, y[fe + 1] = w.g * we, y[fe + 2] = w.b * we;
+          }
+        j++;
+      }
+    }
+    for (let a = C; a < ot; a++)
+      h.scale.setScalar(0), h.updateMatrix(), V.setMatrixAt(a, h.matrix);
+    for (let a = W; a < st; a++)
+      h.scale.setScalar(0), h.updateMatrix(), f.setMatrixAt(a, h.matrix);
+    V.instanceMatrix.needsUpdate = !0, V.instanceColor && (V.instanceColor.needsUpdate = !0), f.instanceMatrix.needsUpdate = !0, f.instanceColor && (f.instanceColor.needsUpdate = !0), U.setDrawRange(0, j * Be * 2), H.needsUpdate = !0, K.needsUpdate = !0;
+    let D = 0;
+    for (let a = Z.flares.length - 1; a >= 0 && D < rt.length; a--) {
+      const T = Z.flares[a], O = (E - T.start) / 1e3;
+      if (O > 1.8) continue;
+      let q = !1;
+      for (let ne = 0; ne < D; ne++) c.current[ne] === T.node && (q = !0);
+      if (q) continue;
+      const N = d(T.node), ee = G.current[D], X = g.current[D];
+      ee && X && (ee.position.set(s.head[N * 3], s.head[N * 3 + 1] + 0.55 + O * 0.25, s.head[N * 3 + 2]), c.current[D] !== T.node && (X.setText((T.op === "write" ? "wrote · " : "") + T.node), X.setColor(T.op === "write" ? "#ffffff" : lt[o.nodes[N].kind] ?? "#94a3b8")), X.setOpacity(Math.min(1, (1.8 - O) * 2))), c.current[D] = T.node, D++;
+    }
+    for (let a = D; a < rt.length; a++) {
+      const T = g.current[a];
+      T == null || T.setOpacity(0), c.current[a] = "";
+    }
+    for (let a = 0; a < n; a++) {
+      const T = B[a], O = 0, q = 0, N = s.base[a * 3], ee = s.base[a * 3 + 1], X = s.base[a * 3 + 2];
+      x.set(s.head[a * 3] + O, s.head[a * 3 + 1], s.head[a * 3 + 2] + q), F.set(x.x - N, x.y - ee, x.z - X);
+      const ne = F.length();
+      F.multiplyScalar(1 / ne), h.position.set(N, ee, X), h.quaternion.setFromUnitVectors(L, F), h.scale.set(1 + T, ne, 1 + T), h.updateMatrix(), I.setMatrixAt(a, h.matrix), w.copy(m[a]).multiplyScalar(0.22 + T * 1.2), I.setColorAt(a, w), h.position.copy(x), h.quaternion.identity(), h.scale.setScalar(1 + T * 2.6), h.updateMatrix(), P.setMatrixAt(a, h.matrix), w.copy(m[a]).multiplyScalar(0.75 + 0.25 * Math.sin(S * 0.8 + s.phase[a] * 3) + T * 5), R[a] > 0.01 && (w.lerp(z.setScalar(6), R[a] * 0.7), z.setScalar(1)), P.setColorAt(a, w);
+    }
+    P.count = n, I.count = n, P.instanceMatrix.needsUpdate = !0, P.instanceColor && (P.instanceColor.needsUpdate = !0), I.instanceMatrix.needsUpdate = !0, I.instanceColor && (I.instanceColor.needsUpdate = !0);
+  });
+  const k = 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: l, args: [k, void 0, it], frustumCulled: !1, children: /* @__PURE__ */ r("meshBasicMaterial", { toneMapped: !1 }) }),
+    /* @__PURE__ */ J("instancedMesh", { ref: b, args: [void 0, void 0, it], frustumCulled: !1, children: [
+      /* @__PURE__ */ r("icosahedronGeometry", { args: [0.12, 1] }),
+      /* @__PURE__ */ r("meshBasicMaterial", { toneMapped: !1 })
+    ] }),
+    /* @__PURE__ */ r("lineSegments", { geometry: A, children: /* @__PURE__ */ r("lineBasicMaterial", { vertexColors: !0, transparent: !0, opacity: 0.9, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) }),
+    /* @__PURE__ */ J("instancedMesh", { ref: p, args: [void 0, void 0, ot], 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: v, args: [void 0, void 0, st], 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 * ut - 0.02, -_e * pt], 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(Zt, { position: [0, _e - 0.9, 0.6], color: "#2dd4bf", size: 0.3, pxRange: [9, 13] }),
+    rt.map((u) => /* @__PURE__ */ r("group", { ref: (E) => void (G.current[u] = E), children: /* @__PURE__ */ r(Ze, { ref: (E) => void (g.current[u] = E), text: "", size: 0.24, opacity: 0, pxRange: [8, 12] }) }, u))
+  ] });
+}
+function zn() {
+  return /* @__PURE__ */ J(
+    $t,
+    {
+      title: "Deep sea · bioluminescent agents",
+      subtitle: "jellyfish = agents · currents = Hatchet runs · coral reef = knowledge graph · anglerfish = MCP servers",
+      preset: Yt,
+      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(on, {}),
+      Agent: ln,
+      RunMarker: dn,
+      McpServer: rn,
+      GraphResource: Cn,
+      cluster: { radius: 1.25, variant: "swarm", pointSize: 0.9, labelBelow: 1.15 },
+      PostFX: /* @__PURE__ */ J(Et, { multisampling: 0, children: [
+        /* @__PURE__ */ r(Vt, { mipmapBlur: !0, intensity: 1.25, luminanceThreshold: 0.16, luminanceSmoothing: 0.25, radius: 0.78 }),
+        /* @__PURE__ */ r(Ot, { eskil: !1, offset: 0.22, darkness: 0.9 }),
+        /* @__PURE__ */ r(kt, { opacity: 0.03 })
+      ] }),
+      children: [
+        /* @__PURE__ */ r(un, {}),
+        /* @__PURE__ */ r(wn, {}),
+        /* @__PURE__ */ r(sn, {})
+      ]
+    }
+  );
+}
+export {
+  zn as default
+};