agentglow 0.4.1 → 0.4.2

package/dist/chunks/index-BxZgELLY.js

@@ -0,0 +1,590 @@
+var Ye = Object.defineProperty;
+var $e = (e, o, n) => o in e ? Ye(e, o, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[o] = n;
+var ee = (e, o, n) => $e(e, typeof o != "symbol" ? o + "" : o, n);
+import { jsxs as ne, Fragment as he, jsx as f } from "react/jsx-runtime";
+import { Stars as Ze } from "@react-three/drei";
+import { EffectComposer as Qe, Bloom as Je, Vignette as et } from "@react-three/postprocessing";
+import { useFrame as ie, useThree as tt } from "@react-three/fiber";
+import { useRef as L, useMemo as B, useEffect as nt, useState as Le } from "react";
+import * as t from "three";
+import { T as Ne, w as H, a as de, p as ot, e as rt, s as st, y as fe, f as ke, L as Ee, j as at, n as it, o as ct, l as lt, m as ut, c as je, g as pt, z as ft, K as dt, A as mt, B as ht, G as gt, C as vt, R as wt, u as yt, D as bt, E as Mt, d as De, k as St, x as At } from "./KitScene-D8qiflCw.js";
+const oe = (e) => e < 0 ? 0 : e > 1 ? 1 : e, Fe = (e) => 1 - Math.pow(1 - oe(e), 3), ze = (e) => (e = oe(e), e < 0.5 ? 4 * e * e * e : 1 - Math.pow(-2 * e + 2, 3) / 2), Ct = (e) => {
+  e = oe(e);
+  const o = 2.2;
+  return 1 + (o + 1) * Math.pow(e - 1, 3) + o * Math.pow(e - 1, 2);
+}, Ve = Object.fromEntries(Object.entries(Ne).map(([e, o]) => [e, new t.Color(o)])), Be = (e) => e === "graph_scout" || e === "records_scout" || e === "data_scout";
+let Se = null;
+function xt() {
+  if (Se) return Se;
+  const e = document.createElement("canvas");
+  e.width = e.height = 128;
+  const o = e.getContext("2d"), n = o.createRadialGradient(64, 64, 0, 64, 64, 64);
+  return n.addColorStop(0, "rgba(255,255,255,1)"), n.addColorStop(0.15, "rgba(255,255,255,0.6)"), n.addColorStop(0.45, "rgba(255,255,255,0.14)"), n.addColorStop(1, "rgba(255,255,255,0)"), o.fillStyle = n, o.fillRect(0, 0, 128, 128), Se = new t.CanvasTexture(e), Se;
+}
+function me(e = "#fff") {
+  return new t.SpriteMaterial({ map: xt(), color: e, blending: t.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function ge(e = "#fff") {
+  return new t.MeshBasicMaterial({ color: e, blending: t.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function Vt(e = 64, o = 7) {
+  const n = [], r = [];
+  for (let s = 0; s <= e; s++) {
+    const u = s / e;
+    for (let l = 0; l < o; l++) {
+      const h = l / o * Math.PI * 2;
+      n.push(u, Math.cos(h), Math.sin(h));
+    }
+  }
+  for (let s = 0; s < e; s++)
+    for (let u = 0; u < o; u++) {
+      const l = s * o + u, h = s * o + (u + 1) % o, m = (s + 1) * o + u, x = (s + 1) * o + (u + 1) % o;
+      r.push(l, m, h, h, m, x);
+    }
+  const a = new t.BufferGeometry();
+  return a.setAttribute("position", new t.Float32BufferAttribute(n, 3)), a.setIndex(r), a.boundingSphere = new t.Sphere(new t.Vector3(), 1e4), a;
+}
+const Rt = Vt(), Ge = new t.SphereGeometry(1, 32, 24);
+new t.SphereGeometry(1, 40, 28);
+new t.IcosahedronGeometry(1, 1);
+const He = new t.ConeGeometry(1, 1, 14).translate(0, 0.5, 0), Tt = new t.ConeGeometry(1, 1, 6, 1, !0).translate(0, 0.5, 0), zt = (
+  /* glsl */
+  `
+uniform vec3 uP0; uniform vec3 uP1; uniform vec3 uP2; uniform float uRadius; uniform float uTaper;
+varying float vT; varying float vRim;
+void main(){
+  float t = position.x; float a = 1.0 - t;
+  vec3 p = a*a*uP0 + 2.0*a*t*uP1 + t*t*uP2;
+  vec3 tg = 2.0*a*(uP1-uP0) + 2.0*t*(uP2-uP1);
+  tg = length(tg) > 1e-5 ? normalize(tg) : vec3(1.0,0.0,0.0);
+  vec3 up = abs(tg.y) > 0.92 ? vec3(1.0,0.0,0.0) : vec3(0.0,1.0,0.0);
+  vec3 n = normalize(cross(tg, up)); vec3 b = cross(tg, n);
+  vec3 off = n*position.y + b*position.z;
+  vec4 mv = modelViewMatrix * vec4(p + off * uRadius * mix(1.0, uTaper, t), 1.0);
+  vec3 vn = normalize(normalMatrix * off);
+  vRim = abs(dot(vn, normalize(-mv.xyz)));
+  vT = t;
+  gl_Position = projectionMatrix * mv;
+}`
+), Pt = (
+  /* glsl */
+  `
+uniform vec3 uColor; uniform float uOpacity; uniform float uGrow; uniform float uTime; uniform float uSpark; uniform float uFlow;
+uniform float uHead; uniform float uTail; uniform vec3 uHeadColor;
+varying float vT; varying float vRim;
+void main(){
+  if (vT > uGrow) discard;
+  float core = 0.25 + 0.75 * vRim * vRim;
+  float tip = smoothstep(uGrow - 0.1, uGrow, vT) * step(uGrow, 0.995);
+  float spark = uSpark * pow(max(0.0, sin(vT * 16.0 - uTime * 10.0)), 14.0);
+  float head = 0.0;
+  if (uHead >= 0.0) {
+    float d = vT - uHead;
+    head = d > 0.0 ? exp(-d * d / 0.0006) : exp(d / max(uTail, 0.001));
+  }
+  // directional flow: soft dashes travelling from start (parent, vT=0) to end (child, vT=1)
+  float flow = uFlow * pow(max(0.0, sin((vT * 7.0 - uTime * 0.9) * 3.14159)), 6.0);
+  vec3 col = uColor * uOpacity * (core + spark * 3.5 + tip * 3.0 + flow * 2.2) + uHeadColor * head * (0.6 + vRim);
+  gl_FragColor = vec4(col, 1.0);
+}`
+);
+function Bt(e = "#fff", o = 0.06, n = 0.4) {
+  return new t.ShaderMaterial({
+    uniforms: {
+      uP0: { value: new t.Vector3() },
+      uP1: { value: new t.Vector3() },
+      uP2: { value: new t.Vector3() },
+      uRadius: { value: o },
+      uTaper: { value: n },
+      uColor: { value: new t.Color(e) },
+      uOpacity: { value: 1 },
+      uGrow: { value: 1 },
+      uTime: { value: 0 },
+      uFlow: { value: 0 },
+      uSpark: { value: 0 },
+      uHead: { value: -1 },
+      uTail: { value: 0.12 },
+      uHeadColor: { value: new t.Color(4, 4, 4) }
+    },
+    vertexShader: zt,
+    fragmentShader: Pt,
+    transparent: !0,
+    depthWrite: !1,
+    blending: t.AdditiveBlending
+  });
+}
+function ae(e, o, n, r, a) {
+  const s = 1 - r;
+  return a.set(s * s * e.x + 2 * s * r * o.x + r * r * n.x, s * s * e.y + 2 * s * r * o.y + r * r * n.y, s * s * e.z + 2 * s * r * o.z + r * r * n.z);
+}
+function Pe(e, o, n, r) {
+  r.copy(e).add(o).multiplyScalar(0.5);
+  const a = Math.hypot(r.x, r.y) || 1;
+  return r.x += r.x / a * n, r.y += r.y / a * n, r.z += n * 0.9, r;
+}
+function Ie(e, o, n) {
+  return e.r += o.r * n, e.g += o.g * n, e.b += o.b * n, e;
+}
+const Te = class Te {
+  constructor(o) {
+    ee(this, "mesh");
+    ee(this, "colors");
+    ee(this, "n", 0);
+    ee(this, "max");
+    ee(this, "o", new t.Object3D());
+    ee(this, "a", new t.Vector3());
+    ee(this, "b", new t.Vector3());
+    ee(this, "d", new t.Vector3());
+    this.max = o, this.colors = new Float32Array(o * 3), this.mesh = new t.InstancedMesh(He, new t.MeshBasicMaterial({ blending: t.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 }), o), this.mesh.instanceColor = new t.InstancedBufferAttribute(this.colors, 3), this.mesh.frustumCulled = !1, this.mesh.count = 0;
+  }
+  begin() {
+    this.n = 0;
+  }
+  /** Arrow at curve parameter t, pointing toward p2 (dir=+1) or toward p0 (dir=-1). */
+  add(o, n, r, a, s, u, l, h = 1) {
+    this.n >= this.max || (ae(o, n, r, a, this.a), ae(o, n, r, Math.min(1, Math.max(0, a + 0.02 * s)), this.b), this.d.subVectors(this.b, this.a), !(this.d.lengthSq() < 1e-8) && (this.o.position.copy(this.a), this.o.quaternion.setFromUnitVectors(Te.UP, this.d.normalize()), this.o.scale.set(u * 0.4, u, u * 0.4), this.o.updateMatrix(), this.mesh.setMatrixAt(this.n, this.o.matrix), this.colors[this.n * 3] = l.r * h, this.colors[this.n * 3 + 1] = l.g * h, this.colors[this.n * 3 + 2] = l.b * h, this.n++));
+  }
+  end() {
+    this.mesh.count = this.n, this.mesh.instanceMatrix.needsUpdate = !0, this.mesh.instanceColor && (this.mesh.instanceColor.needsUpdate = !0);
+  }
+};
+ee(Te, "UP", new t.Vector3(0, 1, 0));
+let Re = Te;
+new t.Vector3();
+new t.Vector3();
+new t.Vector3(0, 1, 0);
+const Ot = new t.Color("#4b4a63"), Ke = new t.Color("#fbbf24"), ye = /* @__PURE__ */ new Map();
+function Gt(e) {
+  const o = [], n = new t.Vector3(0, 1, 0), r = 10;
+  for (let a = 0; a < r; a++) {
+    const s = 1 - 2 * (a + 0.5) / r, u = Math.sqrt(1 - s * s), l = a * 2.39996 + e * 6.28;
+    o.push(new t.Quaternion().setFromUnitVectors(n, new t.Vector3(Math.cos(l) * u, s, Math.sin(l) * u)));
+  }
+  return o;
+}
+const Et = new t.TorusGeometry(1.25, 0.05, 8, 64);
+function Ft({ agent: e, onSelect: o }) {
+  const n = e.inst, r = L(null), a = L(null), s = L(null), u = L(null), l = L(null), h = L(null), m = L(null), x = L(null), S = B(() => [...n.id].reduce((E, A) => (E * 31 + A.charCodeAt(0)) % 9973, 7) / 9973, [n.id]), q = B(() => Gt(S), [S]), V = Ve[n.type], w = B(
+    () => ({
+      core: ge(V),
+      hot: ge("#ffffff"),
+      spike: ge(V),
+      ring: ge(Ke),
+      halo: me(V),
+      syn: Bt(V, Be(n.type) ? 0.08 : 0.11, 0.8),
+      arrow: ge(V)
+    }),
+    [V, n.type]
+  ), i = B(() => ({ p0: new t.Vector3(), p1: new t.Vector3(), seedP: new t.Vector3(), p0set: !1, labelK: 1, spik: 0, ringK: 0, parentK: 1, c: new t.Color() }), []);
+  nt(() => (ye.set(n.id, i.p1), () => {
+    ye.get(n.id) === i.p1 && ye.delete(n.id);
+  }), [n.id, i]), ie(({ clock: E }) => {
+    var _, Y, $;
+    const A = performance.now(), O = E.elapsedTime, Z = fe ? 0 : 0.08 * ke.spread;
+    e.live.set(e.pos.x + Math.sin(O * 0.35 + S * 20) * Z, e.pos.y + Math.cos(O * 0.3 + S * 13) * Z, e.pos.z);
+    const F = e.live, G = n.parent ? H.instances.get(n.parent) : void 0, j = n.parent ? de(n.parent) : void 0;
+    j ? (i.p0.copy(j), i.p0set = !0) : i.p0set || (i.p0.copy(F), i.p0set = !0), Pe(i.p0, F, Be(n.type) || n.subagent ? 0.25 : 0.6, i.p1);
+    const R = (A - n.bornAt) / 1e3, T = n.parent ? Fe(R / 0.9) : 1, I = Ct((R - (n.parent ? 0.85 : 0.1)) / 0.7), N = n.exitAt ? (A - n.exitAt) / 1e3 : -1, X = lt(n) / 1e3, K = N >= 0 ? oe(N / (X * 0.92)) : 0, Q = ot(n, A);
+    let D = !1;
+    for (const k of H.mcpPending.values()) k.instance === n.id && (D = !0);
+    const C = N < 0 && (n.status === "thinking" || n.status === "spawning"), W = rt(n, A), d = fe ? 0 : 1, y = 0.5 + 0.5 * Math.sin(O * 2 + S * 9) * d, z = 0.5 + 0.5 * Math.sin(O * 1 + S * 5) * d;
+    i.spik += ((C ? 1 : 0) - i.spik) * 0.06, i.ringK += ((D && N < 0 ? 1 : 0) - i.ringK) * 0.08, r.current && (T < 1 ? r.current.position.copy(ae(i.p0, i.p1, F, T, i.seedP)) : r.current.position.copy(F));
+    const M = T < 1 ? 0.18 : 0, c = Math.max(M, 0.18 + 0.82 * I) * (1 - K * K * 0.95) * e.scale;
+    (_ = a.current) == null || _.scale.setScalar(Math.max(1e-4, c * (0.55 + W * 0.06 + (C ? y * 0.05 : z * 0.04)))), (Y = s.current) == null || Y.scale.setScalar(Math.max(1e-4, i.spik * (0.85 + y * 0.15)));
+    const p = C ? 0.75 + y * 0.35 : 0.3 + z * 0.15;
+    if (i.c.copy(V).multiplyScalar(p + W * 0.35), N >= 0 && i.c.lerp(Ot, K).multiplyScalar(1 - K * 0.75), w.core.color.copy(i.c), w.spike.color.copy(i.c).multiplyScalar(0.9), w.hot.color.setScalar((C ? 0.35 + y * 0.25 : 0.08) * (1 - K) + W * 0.2), u.current && (u.current.visible = i.ringK > 0.02, u.current.rotation.z = O * 0.9, u.current.rotation.x = 1.1 + Math.sin(O * 0.5) * 0.2, u.current.scale.setScalar(Math.max(1e-4, c * 0.55 * i.ringK)), w.ring.color.copy(Ke).multiplyScalar(0.9 * i.ringK * (0.75 + z * 0.25))), h.current && (h.current.scale.setScalar(Math.max(1e-4, c * (C ? 2.3 + y * 0.3 : 1.6) + W * 0.35)), w.halo.color.copy(V).multiplyScalar((C ? 0.22 : 0.09) * (1 - K) + W * 0.06)), ($ = x.current) == null || $.position.set(0, -0.78 * e.scale - 0.25, 0), m.current) {
+      const k = st(n.id);
+      i.labelK += ((k ? 1 : 0) - i.labelK) * 0.12, m.current.setOpacity(oe(I) * (1 - K) * 0.95 * i.labelK);
+    }
+    const v = !!G && !G.exitAt;
+    i.parentK += ((n.parent && !n.exitAt && v ? 1 : 0) - i.parentK) * (v ? 0.05 : 0.035);
+    const g = w.syn.uniforms;
+    g.uP0.value.copy(i.p0), g.uP1.value.copy(i.p1), g.uP2.value.copy(F);
+    const U = N >= 0 ? ze(N / (X * 0.64)) : 0;
+    if (g.uGrow.value = n.parent ? T * (1 - U) : 0, g.uSpark.value = 0, g.uHead.value = T < 1 ? T : -1, g.uTail.value = 0.1, g.uHeadColor.value.copy(V).multiplyScalar(1.5), g.uOpacity.value = (C ? 1.1 : 0.75) * Math.max(0, Math.min(i.parentK, Q > 0 ? 1 : 0)) + (T < 1 ? 0.4 : 0), g.uTime.value = fe ? 0 : O, g.uFlow.value = T >= 1 ? i.parentK : 0, l.current) {
+      const k = n.parent && T >= 1 && i.parentK > 0.05 && g.uGrow.value > 0.9;
+      if (l.current.visible = !!k, k) {
+        ae(i.p0, i.p1, F, 0.8, Oe), ae(i.p0, i.p1, F, 0.86, We), l.current.position.copy(Oe), Ue.subVectors(We, Oe).normalize(), l.current.quaternion.setFromUnitVectors(_t, Ue);
+        const ce = (Be(n.type) ? 0.75 : 1) * Math.min(1.3, ke.scale);
+        l.current.scale.set(0.16 * ce, 0.42 * ce, 0.16 * ce), w.arrow.color.copy(V).multiplyScalar(1.6 * i.parentK);
+      }
+    }
+  });
+  const b = (E) => {
+    E.stopPropagation(), o(n.id);
+  }, P = n.id.split(":")[2];
+  return /* @__PURE__ */ ne(he, { children: [
+    /* @__PURE__ */ f("mesh", { geometry: Rt, material: w.syn, frustumCulled: !1 }),
+    /* @__PURE__ */ f("mesh", { ref: l, geometry: He, material: w.arrow, visible: !1 }),
+    /* @__PURE__ */ ne("group", { ref: r, children: [
+      /* @__PURE__ */ ne("group", { ref: a, scale: 1e-4, children: [
+        /* @__PURE__ */ f("mesh", { geometry: Ge, material: w.core, onClick: b, onPointerOver: () => document.body.style.cursor = "pointer", onPointerOut: () => document.body.style.cursor = "" }),
+        /* @__PURE__ */ f("mesh", { geometry: Ge, material: w.hot, scale: 0.5 }),
+        /* @__PURE__ */ f("group", { ref: s, scale: 1e-4, children: q.map((E, A) => /* @__PURE__ */ f("mesh", { geometry: Tt, material: w.spike, quaternion: E, scale: [0.2, 1.9, 0.2] }, A)) })
+      ] }),
+      /* @__PURE__ */ f("mesh", { ref: u, geometry: Et, material: w.ring, visible: !1 }),
+      /* @__PURE__ */ f("sprite", { ref: h, material: w.halo }),
+      /* @__PURE__ */ f("group", { ref: x, children: /* @__PURE__ */ f(
+        Ee,
+        {
+          ref: m,
+          text: `${n.name}${P !== void 0 ? ` ${Number(P) + 1}` : ""}`,
+          live: n.job ? () => at(n) : null,
+          color: Ne[n.type],
+          size: n.subagent ? 0.22 : 0.3,
+          opacity: 0,
+          fit: !0,
+          pxRange: n.subagent ? [8, 12] : [9, 14]
+        }
+      ) })
+    ] })
+  ] });
+}
+const Oe = new t.Vector3(), We = new t.Vector3(), Ue = new t.Vector3(), _t = new t.Vector3(0, 1, 0);
+function kt({ comet: e }) {
+  const o = L(null), n = H.instances.get(e.from), r = n ? Ve[n.type] : Ve.planner, a = B(() => me(new t.Color(r).multiplyScalar(1.8).addScalar(0.3)), [r]), s = B(() => ({ a: new t.Vector3(), b: new t.Vector3(), c: new t.Vector3(), h: new t.Vector3() }), []);
+  return ie(() => {
+    const u = de(e.from), l = de(e.to);
+    if (!u || !l || !o.current) {
+      o.current && (o.current.visible = !1);
+      return;
+    }
+    const h = H.instances.get(e.to), m = (h == null ? void 0 : h.parent) === e.from ? ye.get(e.to) : (n == null ? void 0 : n.parent) === e.to ? ye.get(e.from) : void 0;
+    s.a.copy(u), s.b.copy(l), m ? s.c.copy(m) : Pe(s.a, s.b, 1.2, s.c);
+    const x = it(e);
+    ae(s.a, s.c, s.b, ze(x), s.h), o.current.visible = ct(e), o.current.position.copy(s.h), o.current.scale.setScalar(1.1);
+  }), /* @__PURE__ */ f("sprite", { ref: o, material: a, visible: !1 });
+}
+function jt() {
+  const [e, o] = Le([]), n = L({ n: -1, last: -1, first: -1 });
+  return ie(() => {
+    const r = H.comets, a = n.current, s = r.length ? r[0].id : -1, u = r.length ? r[r.length - 1].id : -1;
+    (r.length !== a.n || s !== a.first || u !== a.last) && (a.n = r.length, a.first = s, a.last = u, o(r.filter((l) => !(l.from.startsWith("svc:") && l.to.startsWith("svc:") && !l.failed) && (!ut.grouped || je(l.from) && je(l.to)))));
+  }), /* @__PURE__ */ f(he, { children: e.map((r) => /* @__PURE__ */ f(kt, { comet: r }, r.id)) });
+}
+const te = 3.3, It = 200, se = 14, Ae = 48, ue = 16, le = 8, Ce = 4, ve = new t.Color(1, 1, 1), Kt = new t.Color("#a78bfa"), Wt = (
+  /* glsl */
+  `
+attribute float aSize; attribute vec3 aColor; varying vec3 vC; varying float vFacing; uniform float uScale;
+void main(){
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  vec3 n = normalize(normalMatrix * normalize(position));
+  vFacing = 0.35 + 0.65 * smoothstep(-0.4, 0.5, dot(n, normalize(-mv.xyz)));   // back side dimmer → depth
+  gl_PointSize = aSize * uScale / -mv.z; vC = aColor; gl_Position = projectionMatrix * mv; }`
+), Ut = (
+  /* glsl */
+  `
+varying vec3 vC; varying float vFacing;
+void main(){ float r = length(gl_PointCoord - 0.5) * 2.0; if (r > 1.0) discard;
+  float core = smoothstep(0.45, 0.0, r); float halo = pow(1.0 - r, 2.2);
+  gl_FragColor = vec4(vC * vFacing * (core * 1.2 + halo * 0.45), 1.0); }`
+), Lt = (
+  /* glsl */
+  `
+varying vec3 vN; varying vec3 vV; varying vec3 vObj;
+void main(){ vec4 mv = modelViewMatrix * vec4(position, 1.0); vN = normalize(normalMatrix * normal); vV = normalize(-mv.xyz); vObj = normalize(position);
+  gl_Position = projectionMatrix * mv; }`
+), Nt = (
+  /* glsl */
+  `
+uniform vec3 uRim; uniform vec3 uInner; uniform float uTime;
+uniform vec3 uRipC[${le}]; uniform float uRipA[${le}];
+varying vec3 vN; varying vec3 vV; varying vec3 vObj;
+void main(){
+  float f = 1.0 - abs(dot(normalize(vN), normalize(vV)));
+  float rim = pow(f, 3.0);
+  float body = pow(1.0 - f, 2.0) * 0.12;                         // faint glassy fill toward the center
+  float shimmer = 0.92 + 0.08 * sin(uTime * 0.25 + vObj.y * 3.0 + vObj.x * 2.0);
+  vec3 col = uRim * rim * 1.1 * shimmer + uInner * body;
+  float rip = 0.0;
+  for (int i = 0; i < ${le}; i++) {
+    float a = uRipA[i];
+    if (a < 0.0 || a > 1.0) continue;
+    float d = acos(clamp(dot(vObj, uRipC[i]), -1.0, 1.0));
+    float ring = a * 2.2;
+    rip += exp(-pow((d - ring) / 0.06, 2.0)) * (1.0 - a) * (1.0 - a);
+  }
+  col += vec3(1.0) * rip * 0.6;
+  gl_FragColor = vec4(col, 1.0);
+}`
+);
+function Dt({ galaxy: e }) {
+  const o = B(() => pt(e, It), [e]), n = o.nodes.length, { size: r, gl: a, camera: s } = tt(), u = L([]), l = L([]), h = L(Array(Ce).fill("")), m = B(() => {
+    const i = new Float32Array(n * 3), b = [], P = Math.PI * (3 - Math.sqrt(5)), E = o.ns, A = [0, 0, 0];
+    for (let d = 0; d < n; d++) {
+      const y = 1 - 2 * (d + 0.5) / Math.max(1, E), z = Math.sqrt(Math.max(0, 1 - y * y)), M = d < E ? new t.Vector3(Math.cos(d * P) * z, y, Math.sin(d * P) * z) : new t.Vector3(...ft(o.nodes[d].id, A));
+      b.push(M), i.set([M.x * te, M.y * te, M.z * te], d * 3);
+    }
+    const O = o.nodes.map((d) => new t.Color(dt[d.kind] ?? "#94a3b8").lerp(Kt, 0.2).multiplyScalar(0.62)), Z = new Float32Array(n), F = new Float32Array(n * 3), G = new t.BufferGeometry();
+    G.setAttribute("position", new t.BufferAttribute(i, 3)), G.setAttribute("aSize", new t.BufferAttribute(Z, 1)), G.setAttribute("aColor", new t.BufferAttribute(F, 3));
+    const j = new Map(o.nodes.map((d, y) => [d.id, y])), R = [], T = [];
+    for (const d of o.links) {
+      const y = j.get(d.source), z = j.get(d.target);
+      y !== void 0 && z !== void 0 && y !== z && b[y].angleTo(b[z]) < 1.25 && (R.push([y, z]), T.push(1));
+    }
+    for (let d = 0; d < n; d++) {
+      let y = -1, z = -1, M = 9, c = 9;
+      for (let p = 0; p < n; p++) {
+        if (p === d) continue;
+        const v = b[d].distanceToSquared(b[p]);
+        v < M ? (z = y, c = M, y = p, M = v) : v < c && (z = p, c = v);
+      }
+      y > d && (R.push([d, y]), T.push(0)), z > d && (R.push([d, z]), T.push(0));
+    }
+    const I = new Float32Array(R.length * se * 2 * 3), N = new Float32Array(R.length * se * 2 * 3), X = new Int32Array(R.length * se * 2 * 2), K = new Uint8Array(R.length * se * 2), Q = new t.Quaternion(), D = new t.Vector3();
+    R.forEach(([d, y], z) => {
+      const M = b[d], c = b[y], p = M.angleTo(c), v = new t.Vector3().crossVectors(M, c);
+      v.lengthSq() < 1e-6 && v.set(0, 1, 0), v.normalize();
+      for (let g = 0; g < se; g++)
+        for (let U = 0; U < 2; U++) {
+          const _ = (g + U) / se;
+          Q.setFromAxisAngle(v, p * _), D.copy(M).applyQuaternion(Q).multiplyScalar(te * (1 + 0.06 * Math.sin(Math.PI * _) * Math.min(1, p)));
+          const Y = (z * se + g) * 2 + U;
+          I.set([D.x, D.y, D.z], Y * 3), X[Y * 2] = d, X[Y * 2 + 1] = y, K[Y] = T[z];
+        }
+    });
+    const C = new t.BufferGeometry();
+    C.setAttribute("position", new t.BufferAttribute(I, 3)), C.setAttribute("color", new t.BufferAttribute(N, 3));
+    const W = new t.BufferGeometry();
+    return W.setAttribute("position", new t.BufferAttribute(new Float32Array(Ae * ue * 2 * 3), 3)), W.setAttribute("color", new t.BufferAttribute(new Float32Array(Ae * ue * 2 * 3), 3)), W.boundingSphere = new t.Sphere(new t.Vector3(), 1e4), { pos: i, unit: b, base: O, ngeo: G, ageo: C, owner: X, kindOf: K, nArcV: R.length * se * 2, bgeo: W, fire: new Float32Array(n), white: new Float32Array(n), fireC: Array.from({ length: n }, () => new t.Color()) };
+  }, [o, n]), x = B(
+    () => ({
+      nodes: new t.ShaderMaterial({ uniforms: { uScale: { value: 400 } }, vertexShader: Wt, fragmentShader: Ut, transparent: !0, depthWrite: !1, blending: t.AdditiveBlending }),
+      arcs: new t.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }),
+      beam: new t.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }),
+      orb: new t.ShaderMaterial({
+        uniforms: {
+          uRim: { value: new t.Color("#8b7cff").multiplyScalar(0.7) },
+          uInner: { value: new t.Color("#5b8cff").multiplyScalar(0.6) },
+          uTime: { value: 0 },
+          uRipC: { value: Array.from({ length: le }, () => new t.Vector3(0, 1, 0)) },
+          uRipA: { value: new Array(le).fill(-1) }
+        },
+        vertexShader: Lt,
+        fragmentShader: Nt,
+        transparent: !0,
+        depthWrite: !1,
+        blending: t.AdditiveBlending
+      }),
+      core: me(new t.Color("#8b7cff").multiplyScalar(0.22)),
+      aura: me(new t.Color("#4c1d95").multiplyScalar(0.28))
+    }),
+    []
+  ), S = B(() => /* @__PURE__ */ new Map(), [o]), q = B(() => new Re(Ae), []), V = B(() => ({ v: new t.Vector3(), v2: new t.Vector3(), mid: new t.Vector3(), sp: new t.Vector3(), c: new t.Color(), c2: new t.Color() }), []), w = (i) => {
+    let b = S.get(i);
+    return b === void 0 && S.set(i, b = vt(o, i)), b;
+  };
+  return ie(({ clock: i }) => {
+    const b = performance.now(), { pos: P, base: E, fire: A, white: O, fireC: Z, unit: F } = m;
+    x.nodes.uniforms.uScale.value = r.height * a.getPixelRatio() / (2 * Math.tan(s.fov * Math.PI / 360)) * mt.graph.scale, x.orb.uniforms.uTime.value = fe ? 0 : i.elapsedTime, A.fill(0), O.fill(0);
+    const { v: G, v2: j, mid: R, c: T, c2: I } = V, N = m.bgeo.getAttribute("position"), X = m.bgeo.getAttribute("color"), K = x.orb.uniforms.uRipC.value, Q = x.orb.uniforms.uRipA.value;
+    let D = 0;
+    q.begin();
+    let C = 0;
+    for (const c of H.flares) {
+      const p = w(c.node), v = (b - c.start) / 1e3, g = H.instances.get(c.instance), U = g ? Ve[g.type] : ve, _ = c.op === "write", Y = v < 0.35 ? v / 0.35 : Math.exp(-(v - 0.35) * 1.2);
+      Y > A[p] && (A[p] = Y, Z[p].copy(_ ? ve : U), O[p] = _ ? 1 : 0), _ && v < 1.8 && C < le && (K[C].copy(F[p]), Q[C] = v / 1.8, C++);
+      const $ = de(c.instance), k = $ ? ht($, V.sp) : void 0;
+      if (k && v < 2.2 && D < Ae) {
+        G.set(P[p * 3], P[p * 3 + 1], P[p * 3 + 2]), R.copy(k).add(G).multiplyScalar(0.5), R.z += 1;
+        const ce = Math.min(1, v / 0.3) * (1 - v / 2.2) ** 1.5, Xe = _ ? Math.min(1, v * 0.85) : 1 - Math.min(1, v * 0.85);
+        for (let be = 0; be < ue; be++)
+          for (let Me = 0; Me < 2; Me++) {
+            const J = (be + Me) / ue, re = 1 - J;
+            j.set(re * re * k.x + 2 * re * J * R.x + J * J * G.x, re * re * k.y + 2 * re * J * R.y + J * J * G.y, re * re * k.z + 2 * re * J * R.z + J * J * G.z);
+            const _e = (D * ue + be) * 2 + Me;
+            N.setXYZ(_e, j.x, j.y, j.z);
+            const qe = Math.exp(-(((J - Xe) / 0.1) ** 2)) * 1.3;
+            I.copy(_ ? ve : U).multiplyScalar(ce * ((_ ? 0.5 : 0.2) + qe) * 0.75), X.setXYZ(_e, I.r, I.g, I.b);
+          }
+        _ ? q.add(k, R, G, 0.9, 1, 0.42, ve, ce * 1.1) : q.add(k, R, G, 0.1, -1, 0.42, U, ce * 1.3), D++;
+      }
+    }
+    for (let c = C; c < le; c++) Q[c] = -1;
+    m.bgeo.setDrawRange(0, D * ue * 2), q.end(), N.needsUpdate = !0, X.needsUpdate = !0;
+    const W = m.ngeo.getAttribute("aSize"), d = m.ngeo.getAttribute("aColor");
+    for (let c = 0; c < n; c++) {
+      const p = A[c];
+      W.setX(c, 0.21 + p * (0.55 + O[c] * 0.25)), T.copy(E[c]), p > 0.01 && Ie(Ie(T, Z[c], p * 1.6), ve, p * (0.3 + O[c] * 1.2)), d.setXYZ(c, T.r, T.g, T.b);
+    }
+    W.needsUpdate = !0, d.needsUpdate = !0;
+    const y = m.ageo.getAttribute("color"), z = m.owner;
+    for (let c = 0; c < m.nArcV; c++) {
+      const p = z[c * 2], v = z[c * 2 + 1], g = Math.max(A[p], A[v]), U = m.kindOf[c] ? 0.16 : 0.07;
+      y.setXYZ(c, 0.42 * U + g * 0.3, 0.36 * U + g * 0.3, 0.85 * U + g * 0.4);
+    }
+    y.needsUpdate = !0;
+    let M = 0;
+    for (let c = H.flares.length - 1; c >= 0 && M < Ce; c--) {
+      const p = H.flares[c];
+      if (b - p.start > 2200) break;
+      if (p.area) continue;
+      let v = !1;
+      for (let $ = 0; $ < M; $++) h.current[$] === p.node && (v = !0);
+      if (v) continue;
+      const g = w(p.node);
+      let U = !1;
+      for (let $ = 0; $ < M; $++) {
+        const k = l.current[$];
+        k && Math.abs(k.position.y - P[g * 3 + 1]) < 0.55 && Math.abs(k.position.x - P[g * 3]) < 3.2 && (U = !0);
+      }
+      if (U) continue;
+      const _ = u.current[M], Y = l.current[M];
+      _ && Y && (Y.position.set(P[g * 3], P[g * 3 + 1], P[g * 3 + 2]), h.current[M] !== p.node && (_.setText(`${p.op === "write" ? "wrote" : "read"} · ${p.node}`), _.setColor(p.op === "write" ? "#ffffff" : "#22d3ee")), _.setOpacity(1)), h.current[M] = p.node, M++;
+    }
+    for (let c = M; c < Ce; c++) {
+      const p = u.current[c];
+      p == null || p.setOpacity(0), h.current[c] = "";
+    }
+  }), /* @__PURE__ */ ne(he, { children: [
+    /* @__PURE__ */ ne("group", { children: [
+      /* @__PURE__ */ f("sprite", { material: x.aura, scale: te * 4.2, position: [0, 0, -te] }),
+      /* @__PURE__ */ f("sprite", { material: x.core, scale: te * 1.5 }),
+      /* @__PURE__ */ f("mesh", { geometry: Ge, material: x.orb, scale: te * 1.02 }),
+      /* @__PURE__ */ f("lineSegments", { geometry: m.ageo, material: x.arcs, frustumCulled: !1 }),
+      /* @__PURE__ */ f("points", { geometry: m.ngeo, material: x.nodes, frustumCulled: !1 })
+    ] }),
+    /* @__PURE__ */ f("lineSegments", { geometry: m.bgeo, material: x.beam, frustumCulled: !1 }),
+    /* @__PURE__ */ f("primitive", { object: q.mesh }),
+    Array.from({ length: Ce }, (i, b) => /* @__PURE__ */ f("group", { ref: (P) => void (l.current[b] = P), children: /* @__PURE__ */ f(Ee, { ref: (P) => void (u.current[b] = P), text: "", offset: [0, 0.42], size: 0.24, opacity: 0, fadeMs: 250, pxRange: [8, 12] }) }, b)),
+    /* @__PURE__ */ f(gt, { position: [0, -te - 0.9, 0], color: "#a78bfa", size: 0.28, opacity: 0.7, pxRange: [8, 12] })
+  ] });
+}
+function Ht({ run: e }) {
+  const o = B(() => new t.Color(e.color), [e.color]), n = B(() => me("#000"), []), r = L(null), a = L(null);
+  return ie(({ clock: s }) => {
+    var V;
+    const u = performance.now(), l = e.run ?? H.runs.get(e.id), h = l ? Fe((u - l.startedAt) / 1200) : 1, m = l != null && l.endedAt ? oe(1 - (u - l.endedAt - (wt - 2500)) / 2500) : 1, x = 0.9 + 0.1 * Math.sin(s.elapsedTime * 0.6 + e.index);
+    n.color.copy(o).multiplyScalar(0.16 * h * m * x);
+    const S = Math.abs(e.side.x) * e.hu + Math.abs(e.axis.x) * e.hv, q = Math.abs(e.side.y) * e.hu + Math.abs(e.axis.y) * e.hv;
+    r.current && (r.current.position.set(e.origin.x, e.origin.y, -1.5), r.current.scale.set(S * 2.6 + 3, q * 2.6 + 3, 1)), (V = a.current) == null || V.position.set(e.origin.x, e.origin.y + q + 0.6, 0.5);
+  }), /* @__PURE__ */ ne(he, { children: [
+    /* @__PURE__ */ f("sprite", { ref: r, material: n }),
+    /* @__PURE__ */ f("group", { ref: a, children: e.run && /* @__PURE__ */ f(Xt, { run: e.run }) })
+  ] });
+}
+function Xt({ run: e }) {
+  yt();
+  const o = e.status !== "started" || bt(e);
+  return /* @__PURE__ */ f(
+    Ee,
+    {
+      text: e.topic,
+      secondary: Mt(e, { base: "#94a3b8", current: "#fde68a", done: "#cbd5e1" }, ["running…", "run complete"]),
+      color: e.color,
+      size: 0.34,
+      maxWidth: 10,
+      opacity: o ? 0.5 : 1,
+      fadeMs: 400,
+      anchorY: "bottom",
+      pxRange: [10, 15]
+    }
+  );
+}
+const qt = new t.Color("#fbbf24"), Yt = new t.Color("#ff2d3d"), $t = new t.Color(1, 1, 1), Zt = new t.OctahedronGeometry(0.8, 0);
+new t.EdgesGeometry(Zt);
+function Qt({ call: e }) {
+  const o = H.mcpServers.get(e.server), n = B(() => new t.Color((o == null ? void 0 : o.color) ?? "#fff"), [o]), r = B(() => me(n.clone().multiplyScalar(1.8).addScalar(0.3)), [n]), a = L(null), s = B(() => ({ a: new t.Vector3(), b: new t.Vector3(), c: new t.Vector3(), h: new t.Vector3() }), []);
+  return ie(() => {
+    const u = de(e.instance), l = De(e.server);
+    if (!a.current) return;
+    if (!u || !o || !l) {
+      a.current.visible = !1;
+      return;
+    }
+    s.a.copy(u), s.b.copy(l), Pe(s.a, s.b, 1, s.c);
+    const h = oe((performance.now() - e.start) / (e.phase === "call" ? e.dur : e.dur * 0.75)), m = ze(h);
+    ae(s.a, s.c, s.b, e.phase === "call" ? m : 1 - m, s.h), a.current.visible = h < 1, a.current.position.copy(s.h), a.current.scale.setScalar(1);
+  }), /* @__PURE__ */ f("sprite", { ref: a, material: r, visible: !1 });
+}
+const xe = 24, pe = 40, we = 3;
+function Jt() {
+  const e = B(() => {
+    const a = new t.BufferGeometry();
+    return a.setAttribute("position", new t.BufferAttribute(new Float32Array(xe * we * pe * 2 * 3), 3)), a.setAttribute("color", new t.BufferAttribute(new Float32Array(xe * we * pe * 2 * 3), 3)), a.boundingSphere = new t.Sphere(new t.Vector3(), 1e4), a;
+  }, []), o = B(() => new t.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: t.AdditiveBlending, depthWrite: !1, toneMapped: !1 }), []), n = B(() => new Re(xe), []), r = B(() => ({ a: new t.Vector3(), b: new t.Vector3(), c: new t.Vector3(), p: new t.Vector3(), col: new t.Color(), k: new t.Color() }), []);
+  return ie(({ clock: a }) => {
+    const s = performance.now(), u = fe ? 0 : a.elapsedTime, l = e.getAttribute("position"), h = e.getAttribute("color");
+    let m = 0;
+    n.begin();
+    const x = (S, q, V, w) => {
+      if (m >= xe) return;
+      const i = de(S), b = H.mcpServers.get(q), P = De(q);
+      if (!i || !b || !P) return;
+      const { a: E, b: A, c: O, p: Z, col: F, k: G } = r;
+      E.copy(i), A.copy(P), Pe(E, A, 1, O), F.set(b.color);
+      let j;
+      V === 0 ? (F.lerp(qt, oe(w / 1.2)), w > 1.2 && F.lerp(Yt, oe((w - 1.2) / 1)), j = (0.22 + Math.min(0.6, w * 0.25)) * Fe(w / 0.3)) : (G.copy(F).lerp($t, 0.35), j = 1.3 * (w < 0.75 ? 1 : 1 - (w - 0.75) / 0.25));
+      const R = 1 - ze(w / 0.75), T = V === 0 ? 0.025 : 0.07;
+      for (let I = 0; I < we; I++) {
+        const N = (I - 1) * T;
+        for (let X = 0; X < pe; X++)
+          for (let K = 0; K < 2; K++) {
+            const Q = (X + K) / pe;
+            ae(E, O, A, Q, Z);
+            const D = ((m * we + I) * pe + X) * 2 + K;
+            l.setXYZ(D, Z.x + N, Z.y - N, Z.z + N * 0.5);
+            let C;
+            if (V === 0) {
+              const d = Math.pow(Math.max(0, Math.sin(Q * 20 - u * 2.2)), 8);
+              C = j * (0.3 + d * 1.5) * (I === 1 ? 1 : 0.25);
+            } else
+              C = j * (0.3 + Math.exp(-(((Q - R) / 0.07) ** 2)) * 3.2 * (w < 0.8 ? 1 : 0)) * (I === 1 ? 1 : 0.65);
+            const W = V === 0 ? F : G;
+            h.setXYZ(D, W.r * C, W.g * C, W.b * C);
+          }
+      }
+      V === 0 ? n.add(E, O, A, 0.92, 1, 0.48, F, 0.4 + j * 1.4) : n.add(E, O, A, 0.08, -1, 0.66, G, j * 1.6), m++;
+    };
+    for (const S of H.mcpPending.values()) x(S.instance, S.server, 0, St(S, s));
+    for (const S of H.mcpCalls) S.phase === "result" && x(S.instance, S.server, 1, oe((s - S.start) / S.dur));
+    e.setDrawRange(0, m * we * pe * 2), l.needsUpdate = !0, h.needsUpdate = !0, n.end();
+  }), /* @__PURE__ */ ne(he, { children: [
+    /* @__PURE__ */ f("lineSegments", { geometry: e, material: o, frustumCulled: !1 }),
+    /* @__PURE__ */ f("primitive", { object: n.mesh })
+  ] });
+}
+function en() {
+  const [e, o] = Le([]), n = L({ n: -1, first: -1, last: -1 });
+  return ie(() => {
+    const r = n.current, a = H.mcpCalls, s = a.length ? a[0].id : -1, u = a.length ? a[a.length - 1].id : -1;
+    (a.length !== r.n || s !== r.first || u !== r.last) && (r.n = a.length, r.first = s, r.last = u, o(a.slice()));
+  }), /* @__PURE__ */ ne(he, { children: [
+    e.map((r) => /* @__PURE__ */ f(Qt, { call: r }, r.id)),
+    /* @__PURE__ */ f(Jt, {})
+  ] });
+}
+const tn = { tint: "#c084fc", tintAmt: 0.2, gain: 0.9 };
+function un() {
+  return /* @__PURE__ */ ne(
+    At,
+    {
+      title: "neural · living brain",
+      subtitle: "Agents are neurons (spiky = thinking, smooth = waiting, amber ring = waiting on MCP) · ⬢ MCP servers wire to their backends · graph memory lights up on reads/writes",
+      preset: "radial",
+      plane: "xy",
+      camera: { position: [0, -0.2, 31], fov: 47 },
+      bg: "#030208",
+      fit: { nRef: 4, min: 0.62, max: 1.6, minRadius: 5.5 },
+      agentRadius: 1.25,
+      graph: { natural: te * 1.08, radius: 2.1 },
+      Background: /* @__PURE__ */ f(Ze, { radius: 80, depth: 40, count: fe ? 1200 : 3500, factor: 2.6, saturation: 0.6, fade: !0, speed: 0.4 }),
+      Agent: Ft,
+      RunMarker: Ht,
+      mcpStyle: tn,
+      GraphResource: Dt,
+      cluster: { radius: 1.45, variant: "orb" },
+      PostFX: /* @__PURE__ */ ne(Qe, { multisampling: 0, children: [
+        /* @__PURE__ */ f(Je, { mipmapBlur: !0, intensity: 1.1, luminanceThreshold: 0.2, luminanceSmoothing: 0.3, radius: 0.75 }),
+        /* @__PURE__ */ f(et, { eskil: !1, offset: 0.22, darkness: 0.9 })
+      ] }),
+      children: [
+        /* @__PURE__ */ f(jt, {}),
+        /* @__PURE__ */ f(en, {})
+      ]
+    }
+  );
+}
+export {
+  un as default
+};