agentglow 0.1.0 → 0.2.0

package/dist/chunks/index-D733n3Hf.js

@@ -0,0 +1,1086 @@
+var Rt = Object.defineProperty;
+var Vt = (e, a, t) => a in e ? Rt(e, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[a] = t;
+var me = (e, a, t) => Vt(e, typeof a != "symbol" ? a + "" : a, t);
+import { jsxs as H, Fragment as de, jsx as w } from "react/jsx-runtime";
+import { EffectComposer as _t, Bloom as Ot, Vignette as Et } from "@react-three/postprocessing";
+import { useFrame as fe, useThree as pt } from "@react-three/fiber";
+import { useMemo as R, useRef as F, useState as mt, useEffect as Lt } from "react";
+import * as n from "three";
+import { T as dt, k as ge, h as Ie, w as W, L as Re, d as It, a as We, c as Wt, K as Xt, m as kt, G as Dt, n as Yt, C as Ht, p as Nt, e as Kt, s as jt, q as Ut, f as nt, R as qt, u as $t, o as Zt, j as Jt } from "./KitScene-BuFtYuhc.js";
+var ft;
+const ne = typeof window < "u" && !!((ft = window.matchMedia) != null && ft.call(window, "(prefers-reduced-motion: reduce)").matches), vt = new n.Color("#a855f7"), Ye = new n.Color("#2dd4bf"), ue = new n.Color(1, 1, 1), ht = new n.Color("#fbbf24"), gt = new n.Color("#ff3b5c"), Qt = new n.Color("#3b3346"), Pe = Object.fromEntries(
+  Object.entries(dt).map(([e, a]) => {
+    const t = new n.Color(a);
+    return [e, t.lerp(e === "graph_scout" || e === "writer" ? Ye : vt, 0.18)];
+  })
+), re = (e) => e < 0 ? 0 : e > 1 ? 1 : e, ye = (e) => 1 - Math.pow(1 - re(e), 3), He = (e) => (e = re(e), e < 0.5 ? 4 * e * e * e : 1 - Math.pow(-2 * e + 2, 3) / 2), eo = (e) => {
+  e = re(e);
+  const a = 1.9;
+  return 1 + (a + 1) * Math.pow(e - 1, 3) + a * Math.pow(e - 1, 2);
+};
+function at(e, a, t) {
+  return e.r += a.r * t, e.g += a.g * t, e.b += a.b * t, e;
+}
+let Oe = null;
+function wt() {
+  if (Oe) return Oe;
+  const e = document.createElement("canvas");
+  e.width = e.height = 128;
+  const a = e.getContext("2d"), t = a.createRadialGradient(64, 64, 0, 64, 64, 64);
+  return t.addColorStop(0, "rgba(255,255,255,1)"), t.addColorStop(0.18, "rgba(255,255,255,0.55)"), t.addColorStop(0.5, "rgba(255,255,255,0.12)"), t.addColorStop(1, "rgba(255,255,255,0)"), a.fillStyle = t, a.fillRect(0, 0, 128, 128), Oe = new n.CanvasTexture(e), Oe;
+}
+function Fe(e = "#fff") {
+  return new n.SpriteMaterial({ map: wt(), color: e, blending: n.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function et(e = "#fff") {
+  return new n.MeshBasicMaterial({ map: wt(), color: e, blending: n.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function Xe(e = "#fff") {
+  return new n.MeshBasicMaterial({ color: e, blending: n.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+const tt = new n.PlaneGeometry(1, 1).rotateX(-Math.PI / 2);
+new n.SphereGeometry(1, 24, 16);
+const yt = new n.ConeGeometry(1, 1, 12).translate(0, 0.5, 0), bt = new n.RingGeometry(0.86, 1, 64, 1).rotateX(-Math.PI / 2), rt = new n.LatheGeometry(
+  [
+    [0.86, -0.07],
+    [0.97, -0.02],
+    [1, 0.06],
+    [0.96, 0.18],
+    [0.86, 0.31],
+    [0.7, 0.43],
+    [0.5, 0.51],
+    [0.27, 0.555],
+    [0, 0.57]
+  ].map(([e, a]) => new n.Vector2(e, a)),
+  48
+), to = new n.RingGeometry(0.1, 0.9, 64, 3).rotateX(Math.PI / 2).translate(0, -0.035, 0), st = new n.LatheGeometry(
+  [
+    [0, 0],
+    [0.26, 0],
+    [0.19, 0.05],
+    [0.14, 0.18],
+    [0.115, 0.45],
+    [0.1, 0.75],
+    [0.095, 1],
+    [0, 1]
+  ].map(([e, a]) => new n.Vector2(e, a)),
+  20
+);
+function oo(e = 72, a = 6) {
+  const t = [], o = [];
+  for (let r = 0; r <= e; r++) {
+    const u = r / e;
+    for (let m = 0; m < a; m++) {
+      const f = m / a * Math.PI * 2;
+      t.push(u, Math.cos(f), Math.sin(f));
+    }
+  }
+  for (let r = 0; r < e; r++)
+    for (let u = 0; u < a; u++) {
+      const m = r * a + u, f = r * a + (u + 1) % a, g = (r + 1) * a + u, v = (r + 1) * a + (u + 1) % a;
+      o.push(m, g, f, f, g, v);
+    }
+  const s = new n.BufferGeometry();
+  return s.setAttribute("position", new n.Float32BufferAttribute(t, 3)), s.setIndex(o), s.boundingSphere = new n.Sphere(new n.Vector3(), 1e4), s;
+}
+const Ne = oo(), no = (
+  /* glsl */
+  `
+uniform vec3 uP0; uniform vec3 uP1; uniform vec3 uP2; uniform float uWob; uniform float uSeed;
+vec3 hyphaAt(float t){
+  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);
+  vec3 side = normalize(vec3(-tg.z, 0.0, tg.x) + vec3(1e-5));
+  float w = sin(t * 9.0 + uSeed * 6.283) * 0.6 + sin(t * 17.0 + uSeed * 3.1) * 0.4;
+  return p + side * w * uWob * sin(3.14159 * t);
+}`
+), je = new n.Vector3();
+function Ge(e, a, t, o, s, r, u) {
+  const m = 1 - r;
+  if (u.set(m * m * e.x + 2 * m * r * a.x + r * r * t.x, m * m * e.y + 2 * m * r * a.y + r * r * t.y, m * m * e.z + 2 * m * r * a.z + r * r * t.z), o === 0) return u;
+  je.set(2 * m * (a.x - e.x) + 2 * r * (t.x - a.x), 0, 2 * m * (a.z - e.z) + 2 * r * (t.z - a.z));
+  const f = -je.z + 1e-5, g = je.x + 1e-5, v = Math.hypot(f, 1e-5, g) || 1, i = (Math.sin(r * 9 + s * 6.283) * 0.6 + Math.sin(r * 17 + s * 3.1) * 0.4) * o * Math.sin(Math.PI * r);
+  return u.x += f / v * i, u.z += g / v * i, u;
+}
+const ao = (
+  /* glsl */
+  `
+uniform float uRadius; uniform float uTaper;
+varying float vT; varying float vRim;
+${no}
+void main(){
+  float t = position.x;
+  vec3 p = hyphaAt(t);
+  vec3 tg = hyphaAt(min(1.0, t + 0.01)) - hyphaAt(max(0.0, t - 0.01));
+  tg = length(tg) > 1e-6 ? 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;
+  float r = uRadius * mix(1.0, uTaper, t) * (0.85 + 0.15 * sin(t * 40.0 + uSeed * 9.0));
+  vec4 mv = modelViewMatrix * vec4(p + off * r, 1.0);
+  vRim = abs(dot(normalize(normalMatrix * off), normalize(-mv.xyz)));
+  vT = t;
+  gl_Position = projectionMatrix * mv;
+}`
+), ro = (
+  /* glsl */
+  `
+uniform vec3 uColor; uniform float uOpacity; uniform float uGrow; uniform float uStart; uniform float uTime;
+uniform float uFlow; uniform float uFlowDir; uniform float uBeads; uniform float uSpeed;
+uniform float uHead; uniform float uTail; uniform vec3 uHeadColor;
+varying float vT; varying float vRim;
+void main(){
+  if (vT > uGrow || vT < uStart) discard;
+  float core = 0.3 + 0.7 * vRim * vRim;
+  float tip = smoothstep(uGrow - 0.06, uGrow, vT) * step(uGrow, 0.995);
+  // nutrient beads travelling along the hypha (uFlowDir +1: start → end)
+  float ph = vT * uBeads - uTime * uSpeed * uFlowDir;
+  float beads = uFlow * pow(max(0.0, sin(ph * 3.14159)), 22.0);
+  float head = 0.0;
+  if (uHead >= 0.0) {
+    float d = vT - uHead;
+    head = d > 0.0 ? exp(-d * d / 0.0008) : exp(d / max(uTail, 0.001));
+  }
+  float endFade = smoothstep(0.0, 0.03, vT - uStart);
+  vec3 col = uColor * uOpacity * endFade * (core + tip * 3.0 + beads * 3.2) + uHeadColor * head * (0.5 + vRim);
+  gl_FragColor = vec4(col, 1.0);
+}`
+);
+function Ke(e = "#fff", a = 0.06, t = 0.45, o = 0, s = 0.25) {
+  return new n.ShaderMaterial({
+    uniforms: {
+      uP0: { value: new n.Vector3() },
+      uP1: { value: new n.Vector3() },
+      uP2: { value: new n.Vector3() },
+      uWob: { value: s },
+      uSeed: { value: o },
+      uRadius: { value: a },
+      uTaper: { value: t },
+      uColor: { value: new n.Color(e) },
+      uOpacity: { value: 1 },
+      uGrow: { value: 1 },
+      uStart: { value: 0 },
+      uTime: { value: 0 },
+      uFlow: { value: 0 },
+      uFlowDir: { value: 1 },
+      uBeads: { value: 6 },
+      uSpeed: { value: 1.1 },
+      uHead: { value: -1 },
+      uTail: { value: 0.12 },
+      uHeadColor: { value: new n.Color(3, 3, 3) }
+    },
+    vertexShader: ao,
+    fragmentShader: ro,
+    transparent: !0,
+    depthWrite: !1,
+    blending: n.AdditiveBlending
+  });
+}
+function so() {
+  return new n.ShaderMaterial({
+    uniforms: {
+      uColor: { value: new n.Color() },
+      uGlow: { value: 0.5 },
+      uOpacity: { value: 1 },
+      uSpots: { value: 0 }
+    },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec3 vN; varying vec3 vV; varying vec3 vP;
+      void main(){
+        vec4 mv = modelViewMatrix * vec4(position, 1.0);
+        vN = normalize(normalMatrix * normal); vV = normalize(-mv.xyz); vP = position;
+        gl_Position = projectionMatrix * mv;
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 uColor; uniform float uGlow; uniform float uOpacity; uniform float uSpots;
+      varying vec3 vN; varying vec3 vV; varying vec3 vP;
+      void main(){
+        float f = 1.0 - abs(dot(normalize(vN), normalize(vV)));
+        float rim = pow(f, 2.2);
+        float h = clamp(vP.y / 0.57, 0.0, 1.0);
+        float ang = atan(vP.z, vP.x);
+        float ribs = 0.88 + 0.12 * sin(ang * 26.0);
+        float lip = smoothstep(0.25, 0.0, h);                       // the rim edge glows strongest
+        // soft round spots on the crown (seeded by uSpots)
+        vec2 q = vec2(ang * 2.2 + uSpots * 7.0, h * 5.0);
+        vec2 cell = fract(q) - 0.5;
+        float spots = smoothstep(0.22, 0.08, length(cell)) * step(0.35, h) * step(0.5, fract(sin(dot(floor(q), vec2(12.9898, 78.233)) + uSpots) * 43758.5453));
+        vec3 body = uColor * (0.12 + 0.22 * (1.0 - h)) * ribs;
+        vec3 col = body + uColor * (rim * 1.3 + lip * 0.9) * uGlow + vec3(0.85, 0.95, 1.0) * spots * 0.35 * uGlow;
+        gl_FragColor = vec4(col, uOpacity * (0.82 + 0.18 * rim));
+      }`
+    ),
+    transparent: !0
+  });
+}
+function io() {
+  return new n.ShaderMaterial({
+    uniforms: { uColor: { value: new n.Color() }, uGlow: { value: 0.5 }, uTime: { value: 0 } },
+    vertexShader: (
+      /* glsl */
+      `
+      varying vec3 vP;
+      void main(){ vP = position; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 uColor; uniform float uGlow; uniform float uTime;
+      varying vec3 vP;
+      void main(){
+        float r = length(vP.xz);
+        float a = atan(vP.z, vP.x);
+        float lam = pow(abs(sin(a * 34.0)), 6.0);
+        float wave = 0.75 + 0.25 * sin(r * 14.0 - uTime * 3.0);
+        float fall = smoothstep(0.9, 0.55, r) * smoothstep(0.08, 0.2, r);
+        gl_FragColor = vec4(uColor * uGlow * (0.25 + lam * 1.4) * wave * fall, 1.0);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    side: n.DoubleSide,
+    blending: n.AdditiveBlending
+  });
+}
+function lo() {
+  return new n.ShaderMaterial({
+    uniforms: { uColor: { value: new n.Color() }, uGlow: { value: 0.5 }, uOpacity: { value: 1 }, uBend: { value: 0 } },
+    vertexShader: (
+      /* glsl */
+      `
+      uniform float uBend;
+      varying vec3 vN; varying vec3 vV; varying float vY;
+      void main(){
+        vec3 p = position;
+        p.x += uBend * p.y * p.y;
+        vec4 mv = modelViewMatrix * vec4(p, 1.0);
+        vN = normalize(normalMatrix * normal); vV = normalize(-mv.xyz); vY = position.y;
+        gl_Position = projectionMatrix * mv;
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 uColor; uniform float uGlow; uniform float uOpacity;
+      varying vec3 vN; varying vec3 vV; varying float vY;
+      void main(){
+        float f = 1.0 - abs(dot(normalize(vN), normalize(vV)));
+        vec3 pale = mix(uColor, vec3(0.92, 0.9, 1.0), 0.45);
+        float fibre = 0.9 + 0.1 * sin(vY * 60.0);
+        vec3 col = pale * (0.1 + 0.3 * vY + pow(f, 2.0) * 0.9) * uGlow * fibre;
+        gl_FragColor = vec4(col, uOpacity);
+      }`
+    ),
+    transparent: !0
+  });
+}
+const he = 3.8, Mt = 1.75, St = new n.Vector3();
+function xt(e, a = St) {
+  const t = ge.agents.get(e);
+  if (t)
+    return a.copy(t.live), a.y += (Mt + 0.12) * t.scale, Ue.p = a, Ue.r = t.scale, Ue;
+}
+const Ue = { p: St, r: 0 }, De = class De {
+  constructor(a) {
+    me(this, "mesh");
+    me(this, "colors");
+    me(this, "n", 0);
+    me(this, "max");
+    me(this, "o", new n.Object3D());
+    me(this, "a", new n.Vector3());
+    me(this, "b", new n.Vector3());
+    this.max = a, this.colors = new Float32Array(a * 3), this.mesh = new n.InstancedMesh(yt, new n.MeshBasicMaterial({ blending: n.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 }), a), this.mesh.instanceColor = new n.InstancedBufferAttribute(this.colors, 3), this.mesh.frustumCulled = !1, this.mesh.count = 0;
+  }
+  begin() {
+    this.n = 0;
+  }
+  /** Arrow at curve parameter t, pointing toward the end (dir=+1) or the start (dir=-1). */
+  add(a, t, o, s, r, u, m, f, g, v = 1) {
+    this.n >= this.max || v <= 0.01 || (Ge(a, t, o, s, r, u, this.a), Ge(a, t, o, s, r, Math.min(1, Math.max(0, u + 0.025 * m)), this.b), this.b.sub(this.a), !(this.b.lengthSq() < 1e-8) && (this.o.position.copy(this.a), this.o.quaternion.setFromUnitVectors(De.UP, this.b.normalize()), this.o.scale.set(f * 0.42, f, f * 0.42), this.o.updateMatrix(), this.mesh.setMatrixAt(this.n, this.o.matrix), this.colors[this.n * 3] = g.r * v, this.colors[this.n * 3 + 1] = g.g * v, this.colors[this.n * 3 + 2] = g.b * v, this.n++));
+  }
+  end() {
+    this.mesh.count = this.n, this.mesh.instanceMatrix.needsUpdate = !0, this.mesh.instanceColor && (this.mesh.instanceColor.needsUpdate = !0);
+  }
+};
+me(De, "UP", new n.Vector3(0, 1, 0));
+let ke = De;
+function At() {
+  return new n.ShaderMaterial({
+    uniforms: { uScale: { value: 400 } },
+    vertexShader: (
+      /* glsl */
+      `
+      attribute float aSize; attribute vec3 aColor; varying vec3 vC; uniform float uScale;
+      void main(){
+        vec4 mv = modelViewMatrix * vec4(position, 1.0);
+        gl_PointSize = aSize * uScale / -mv.z; vC = aColor; gl_Position = projectionMatrix * mv;
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      varying vec3 vC;
+      void main(){
+        float r = length(gl_PointCoord - 0.5) * 2.0; if (r > 1.0) discard;
+        float core = smoothstep(0.42, 0.0, r); float halo = pow(1.0 - r, 2.4);
+        gl_FragColor = vec4(vC * (core * 1.25 + halo * 0.5), 1.0);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    blending: n.AdditiveBlending
+  });
+}
+function Pt(e, a, t) {
+  return e * a / (2 * Math.tan(t * Math.PI / 360));
+}
+const Ct = 0.9, it = 0.7, be = new ke(64);
+function co(e, a) {
+  const t = new n.IcosahedronGeometry(e, 3), o = t.getAttribute("position"), s = new n.Vector3();
+  for (let r = 0; r < o.count; r++) {
+    s.fromBufferAttribute(o, r);
+    const u = s.clone().normalize(), m = 1 + 0.13 * Math.sin(u.x * 5 + a) * Math.cos(u.y * 4 + a * 2) + 0.07 * Math.sin(u.z * 9 + a * 3);
+    s.multiplyScalar(m), o.setXYZ(r, s.x, s.y * 0.85, s.z);
+  }
+  return t.computeVertexNormals(), t;
+}
+const uo = co(0.85, 1.7);
+function fo(e) {
+  return new n.ShaderMaterial({
+    uniforms: { uColor: { value: e.clone() }, uK: { value: 1 } },
+    vertexShader: (
+      /* glsl */
+      `varying vec3 vN; varying vec3 vV; varying vec3 vP;
+      void main(){ vec4 mv = modelViewMatrix * vec4(position, 1.0); vN = normalize(normalMatrix * normal); vV = normalize(-mv.xyz); vP = position;
+        gl_Position = projectionMatrix * mv; }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `uniform vec3 uColor; uniform float uK; varying vec3 vN; varying vec3 vV; varying vec3 vP;
+      void main(){ float f = 1.0 - abs(dot(normalize(vN), normalize(vV)));
+        float veins = 0.7 + 0.3 * sin(vP.x * 11.0 + sin(vP.y * 7.0) * 2.0) * sin(vP.z * 9.0);
+        gl_FragColor = vec4(uColor * uK * (0.12 + pow(f, 2.0) * 1.5) * veins, 1.0); }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    blending: n.AdditiveBlending
+  });
+}
+const lt = /* @__PURE__ */ new Map();
+function po(e) {
+  const a = lt.get(e);
+  if (a) return a;
+  const t = (s, r, u) => ({ geo: s, edges: new n.EdgesGeometry(s, 25), pos: r, rot: u });
+  let o;
+  switch (e) {
+    case "db":
+      o = [t(new n.CylinderGeometry(0.42, 0.42, 0.75, 28)), t(new n.TorusGeometry(0.42, 0.015, 6, 40), [0, 0.13, 0], [Math.PI / 2, 0, 0]), t(new n.TorusGeometry(0.42, 0.015, 6, 40), [0, -0.13, 0], [Math.PI / 2, 0, 0])];
+      break;
+    case "warehouse":
+      o = [-0.3, 0, 0.3].map((s) => t(new n.BoxGeometry(0.95, 0.2, 0.6), [0, s, 0]));
+      break;
+    case "spark": {
+      o = [{ geo: new n.SphereGeometry(0.18, 16, 12) }];
+      for (let s = 0; s < 6; s++) {
+        const r = s / 6 * Math.PI * 2;
+        o.push({ geo: new n.SphereGeometry(0.1, 12, 10), pos: [Math.cos(r) * 0.46, Math.sin(r) * 0.46, (s % 2 ? 1 : -1) * 0.12] });
+      }
+      break;
+    }
+    case "api":
+      o = [t(new n.TorusGeometry(0.4, 0.1, 10, 36))];
+      break;
+    case "storage":
+      o = [t(new n.BoxGeometry(0.7, 0.7, 0.7), void 0, [0.4, 0.6, 0])];
+      break;
+    case "queue":
+      o = [t(new n.CapsuleGeometry(0.2, 0.75, 6, 16), void 0, [0, 0, Math.PI / 2])];
+      break;
+  }
+  return lt.set(e, o), o;
+}
+function zt(e, a) {
+  let t = null;
+  for (const o of W.mcpCalls) o.server === e && (a === void 0 || o.resource === a) && (!t || o.start > t.start) && (t = o);
+  return t;
+}
+function Gt(e, a, t, o, s, r, u) {
+  if (e.uTime.value = r, t < 1) {
+    const m = He(t);
+    e.uFlow.value = 0, e.uHead.value = 1 - m, e.uTail.value = 0.18, e.uHeadColor.value.copy(s).lerp(ue, 0.4).multiplyScalar(3), e.uOpacity.value = 0.9 * (1 - t * 0.5);
+  } else a ? (e.uFlow.value = 1, e.uFlowDir.value = 1, e.uHead.value = -1, e.uOpacity.value = 0.6) : (e.uFlow.value = o * 0.6, e.uFlowDir.value = 1, e.uHead.value = -1, e.uOpacity.value = u + o * 0.4);
+}
+function mo({ mcp: e, backend: a }) {
+  const t = e.srv, o = a.res, s = R(() => po(o.kind), [o.kind]), r = R(() => new n.Color(t.color).lerp(Ye, 0.2).lerp(ue, 0.25), [t.color]), u = R(() => Ie(`${t.name}:${o.name}`, 3), [t.name, o.name]), m = R(() => {
+    const h = Ke(t.color, 0.1, 0.55, u, 0.3);
+    return h.uniforms.uBeads.value = 4, { edge: h, fill: Xe(r), line: new n.LineBasicMaterial({ color: r, transparent: !0, blending: n.AdditiveBlending, depthWrite: !1, toneMapped: !1 }), halo: Fe(r) };
+  }, [t.color, r, u]), f = F(null), g = F(null), v = F(null), i = F(null), y = F("");
+  return fe(({ clock: h }) => {
+    var _, V;
+    const c = m.edge.uniforms;
+    c.uP0.value.copy(e.pos).setY(Ct), c.uP2.value.copy(a.pos).setY(it), c.uP1.value.copy(c.uP0.value).add(c.uP2.value).multiplyScalar(0.5).setY(0.2), (_ = f.current) == null || _.position.set(a.pos.x, it, a.pos.z);
+    const p = performance.now(), l = ne ? 0 : h.elapsedTime, b = o.inflight > 0, M = Math.exp(-((p - o.activeAt) / 1e3) * 1.5), d = b ? 0.5 + 0.5 * Math.sin(h.elapsedTime * 5) : 0, S = b ? 1.6 + d * 0.9 : 0.14 + M * 0.9;
+    m.fill.color.copy(r).multiplyScalar(S * 0.5), m.line.color.copy(r).multiplyScalar(S * 1.5), m.halo.color.copy(r).multiplyScalar(b ? 0.4 + d * 0.2 : 0.03 + M * 0.25), (V = v.current) == null || V.scale.setScalar(b ? 4 + d * 0.8 : 2.4 + M * 1.2), g.current && (g.current.scale.setScalar(b ? 1.18 + d * 0.08 : 1 + M * 0.1), g.current.rotation.y = o.kind === "spark" || o.kind === "api" ? l * (b ? 0.6 : 0.15) : Math.sin(l * 0.2 + u) * 0.3);
+    const C = zt(t.name, o.name), ee = C && C.phase === "result" ? (p - C.start) / C.dur : 9;
+    Gt(m.edge.uniforms, b, ee, M, r, l, 0.22);
+    const O = m.edge.uniforms;
+    ee < 1 ? be.add(O.uP0.value, O.uP1.value, O.uP2.value, O.uWob.value, u, 0.1, -1, 0.5, r, 2 * (1 - ee * 0.7)) : b && be.add(O.uP0.value, O.uP1.value, O.uP2.value, O.uWob.value, u, 0.86, 1, 0.42, r, 1.2);
+    let j = o.name;
+    if (b) {
+      let L = "";
+      for (const E of W.mcpPending.values()) E.server === t.name && E.resource === o.name && (L = E.tool);
+      j = `${o.name} ▶ ${L || "query"}()`;
+    } else C && C.phase === "result" && p - C.start < 1800 && (j = `${o.name} ✓ returned`);
+    i.current && (j !== y.current && (i.current.setText(j), y.current = j), i.current.setOpacity(b ? 1 : 0.6 + M * 0.4), i.current.setEmphasis(b));
+  }), /* @__PURE__ */ H(de, { children: [
+    /* @__PURE__ */ w("mesh", { geometry: Ne, material: m.edge, frustumCulled: !1 }),
+    /* @__PURE__ */ H("group", { ref: f, children: [
+      /* @__PURE__ */ w("sprite", { ref: v, material: m.halo }),
+      /* @__PURE__ */ w("group", { ref: g, children: s.map((h, c) => /* @__PURE__ */ H("group", { position: h.pos, rotation: h.rot, children: [
+        /* @__PURE__ */ w("mesh", { geometry: h.geo, material: m.fill }),
+        h.edges && /* @__PURE__ */ w("lineSegments", { geometry: h.edges, material: m.line })
+      ] }, c)) }),
+      /* @__PURE__ */ w(Re, { ref: i, position: [0, -0.95, 0], text: o.name, color: t.color, size: 0.2, opacity: 0.6, pxRange: [7.5, 11.5] })
+    ] })
+  ] });
+}
+const Te = new n.Vector3();
+function vo({ mcp: e }) {
+  const a = e.srv, t = R(() => new n.Color(a.color).lerp(Ye, 0.15), [a.color]), o = R(() => Ie(a.name, 5), [a.name]), s = R(() => {
+    const g = Ke(t, 0.17, 0.5, o, 0.6);
+    return g.uniforms.uBeads.value = 9, g.uniforms.uSpeed.value = 0.8, { body: fo(t), core: Fe(t), halo: Fe(t), trunk: g };
+  }, [t, o]), r = F(null), u = F(null), m = F(null), f = F(performance.now());
+  return fe(({ clock: g }) => {
+    var C, ee;
+    const v = e.pos;
+    (C = r.current) == null || C.position.set(v.x, Ct, v.z);
+    const i = s.trunk.uniforms;
+    Te.set(v.x, 0, v.z);
+    const y = Te.length();
+    y > 1e-3 && Te.multiplyScalar(1 / y);
+    const h = Math.max(0, Math.min(y - 2.5, ge.core.r * 0.8));
+    i.uP0.value.set(Te.x * h, 0.08, Te.z * h), i.uP2.value.set(v.x, 0.15, v.z), i.uP1.value.copy(i.uP0.value).add(i.uP2.value).multiplyScalar(0.5).setY(0.1), i.uBeads.value = Math.max(4, (y - h) / 1.2);
+    const c = performance.now(), p = ne ? 0 : g.elapsedTime, l = a.inflight > 0, b = Math.exp(-((c - a.activeAt) / 1e3) * 1.5), M = 0.5 + 0.5 * Math.sin(g.elapsedTime * (l ? 4 : 1.2) + o * 5);
+    s.body.uniforms.uK.value = (l ? 1.1 + M * 0.4 : 0.5 + M * 0.1) + b * 0.5, s.core.color.copy(t).lerp(ue, 0.4).multiplyScalar((l ? 0.55 : 0.18) + b * 0.3), s.halo.color.copy(t).multiplyScalar((l ? 0.22 : 0.07) + b * 0.12), (ee = m.current) == null || ee.scale.setScalar(5.2 + (l ? M * 0.8 : 0)), u.current && (u.current.rotation.y = p * (l ? 0.5 : 0.1), u.current.scale.setScalar(ye((c - f.current) / 1200) * (1 + (l ? M * 0.06 : 0))));
+    const d = zt(a.name), S = d && d.phase === "result" ? (c - d.start) / d.dur : 9;
+    Gt(i, l, 9, b, t, p, 0.3), i.uGrow.value = ye((c - f.current) / 2e3), S < 1 && (i.uOpacity.value = 0.5 + (1 - S) * 0.4);
+  }), /* @__PURE__ */ H(de, { children: [
+    /* @__PURE__ */ w("mesh", { geometry: Ne, material: s.trunk, frustumCulled: !1 }),
+    /* @__PURE__ */ H("group", { ref: r, children: [
+      /* @__PURE__ */ w("sprite", { ref: m, material: s.halo }),
+      /* @__PURE__ */ H("group", { ref: u, children: [
+        /* @__PURE__ */ w("mesh", { geometry: uo, material: s.body }),
+        /* @__PURE__ */ w("sprite", { material: s.core, scale: 1.6 })
+      ] }),
+      /* @__PURE__ */ w(Re, { position: [0, 1.55, 0], text: `MCP · ${a.name}`, color: a.color, size: 0.28, pxRange: [9, 13] })
+    ] })
+  ] });
+}
+const qe = 20;
+function ho() {
+  const e = F([]), a = R(() => Array.from({ length: qe }, (o, s) => Ke("#fff", 0.07, 0.6, s * 0.173, 0.45)), []), t = R(() => ({ col: new n.Color(), sp: new n.Vector3() }), []);
+  return fe(({ clock: o }) => {
+    const s = performance.now(), r = ne ? 0 : o.elapsedTime;
+    let u = 0;
+    const m = (f, g, v, i) => {
+      if (u >= qe) return;
+      const y = We(f), h = W.mcpServers.get(g), c = Wt(g), p = e.current[u];
+      if (!y || !h || !c || !p) return;
+      const l = a[u].uniforms;
+      t.sp.copy(c), l.uP0.value.copy(y).setY(0.06), l.uP2.value.copy(t.sp).setY(0.35), l.uP1.value.copy(l.uP0.value).add(l.uP2.value).multiplyScalar(0.5), l.uP1.value.y = 0.9;
+      const b = l.uP0.value.distanceTo(l.uP2.value);
+      l.uBeads.value = b / 1.3, l.uTime.value = r, t.col.set(h.color), v === 0 ? (t.col.lerp(ht, re(i / 1.2)), i > 1.2 && t.col.lerp(gt, re((i - 1.2) / 1.2)), l.uColor.value.copy(t.col), l.uGrow.value = ye(i / 0.45), l.uHead.value = i < 0.45 ? l.uGrow.value : -1, l.uHeadColor.value.copy(t.col).multiplyScalar(2.5), l.uFlow.value = 1, l.uFlowDir.value = 1, l.uSpeed.value = 1.6, l.uOpacity.value = 0.45 + Math.min(0.4, i * 0.15), be.add(l.uP0.value, l.uP1.value, l.uP2.value, l.uWob.value, l.uSeed.value, 0.9, 1, 0.42, t.col, 0.5 + Math.min(1, i * 0.5))) : (t.col.lerp(ue, 0.3), l.uColor.value.copy(t.col), l.uGrow.value = 1, l.uFlow.value = 0, l.uHead.value = 1 - He(i / 0.8), l.uTail.value = 0.2, l.uHeadColor.value.copy(t.col).multiplyScalar(3.2), l.uOpacity.value = 0.7 * (1 - i), be.add(l.uP0.value, l.uP1.value, l.uP2.value, l.uWob.value, l.uSeed.value, 0.08, -1, 0.55, t.col, 1.8 * (1 - i))), p.visible = !0, u++;
+    };
+    for (const f of W.mcpPending.values()) m(f.instance, f.server, 0, It(f, s));
+    for (const f of W.mcpCalls) f.phase === "result" && m(f.instance, f.server, 1, re((s - f.start) / f.dur));
+    for (let f = u; f < qe; f++) {
+      const g = e.current[f];
+      g && (g.visible = !1);
+    }
+  }), /* @__PURE__ */ w(de, { children: a.map((o, s) => /* @__PURE__ */ w("mesh", { ref: (r) => void (e.current[s] = r), geometry: Ne, material: o, frustumCulled: !1, visible: !1 }, s)) });
+}
+function go() {
+  return /* @__PURE__ */ H(de, { children: [
+    /* @__PURE__ */ w(ho, {}),
+    /* @__PURE__ */ w(wo, {}),
+    /* @__PURE__ */ w("primitive", { object: be.mesh })
+  ] });
+}
+function wo() {
+  return fe(() => {
+    be.end(), be.begin();
+  }, 0.5), null;
+}
+const Ce = 36, yo = (
+  /* glsl */
+  `
+uniform float uTime;
+varying vec2 vXZ;
+float h(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+float n2(vec2 p){ vec2 i = floor(p), f = fract(p); f = f*f*(3.0-2.0*f);
+  return mix(mix(h(i), h(i+vec2(1,0)), f.x), mix(h(i+vec2(0,1)), h(i+vec2(1,1)), f.x), f.y); }
+float fbm(vec2 p){ float s = 0.0, a = 0.5; for (int i = 0; i < 5; i++){ s += a * n2(p); p *= 2.03; a *= 0.5; } return s; }
+void main(){
+  float r = length(vXZ);
+  float m = fbm(vXZ * 0.22) * 0.6 + fbm(vXZ * 0.9 + 7.0) * 0.4;           // static mottling (leaf litter / soil)
+  vec3 soil = mix(vec3(0.010, 0.008, 0.020), vec3(0.030, 0.020, 0.050), m);
+  vec3 col = soil;
+  col += vec3(0.20, 0.08, 0.36) * exp(-r * r / 60.0) * 0.32;              // violet heart under the mat
+  col += vec3(0.03, 0.16, 0.16) * exp(-pow((r - 15.0) / 7.0, 2.0)) * 0.10;  // teal haze toward the edge
+  float edge = smoothstep(${Ce.toFixed(1)}, ${(Ce * 0.55).toFixed(1)}, r);
+  gl_FragColor = vec4(col, edge);
+}`
+);
+function bo(e = 110, a = 9e3) {
+  let t = 1337;
+  const o = () => (t = t * 16807 % 2147483647) / 2147483647, s = [], r = [], u = [], m = [], f = [];
+  for (let i = 0; i < e; i++) {
+    const y = i / e * Math.PI * 2 + o() * 0.2, h = he * (0.7 + o() * 0.3);
+    f.push({ x: Math.cos(y) * h, z: Math.sin(y) * h, h: y + (o() - 0.5) * 0.6, d: h, w: 1, sd: o(), life: 40 + o() * 60 });
+  }
+  let g = 0;
+  for (; f.length && g < a; ) {
+    const i = f.shift();
+    for (let y = 0; y < i.life && g < a; y++) {
+      const h = 0.32 + o() * 0.18, c = Math.atan2(i.z, i.x);
+      let p = i.h - c;
+      p = Math.atan2(Math.sin(p), Math.cos(p)), i.h += (o() - 0.5) * 0.55 - p * 0.05;
+      const l = i.x + Math.cos(i.h) * h, b = i.z + Math.sin(i.h) * h, M = i.d + h;
+      if (s.push(i.x, 0.02, i.z, l, 0.02, b), r.push(i.d, M), u.push(i.sd, i.sd), m.push(i.w, i.w), g++, i.x = l, i.z = b, i.d = M, Math.hypot(l, b) > Ce * 0.8) break;
+      o() < 0.055 && i.w > 0.3 && f.push({ x: l, z: b, h: i.h + (o() < 0.5 ? 1 : -1) * (0.5 + o() * 0.6), d: M, w: i.w * 0.72, sd: o(), life: (i.life - y) * (0.5 + o() * 0.5) });
+    }
+  }
+  const v = new n.BufferGeometry();
+  return v.setAttribute("position", new n.Float32BufferAttribute(s, 3)), v.setAttribute("aDist", new n.Float32BufferAttribute(r, 1)), v.setAttribute("aSeed", new n.Float32BufferAttribute(u, 1)), v.setAttribute("aW", new n.Float32BufferAttribute(m, 1)), v.boundingSphere = new n.Sphere(new n.Vector3(), 1e4), v;
+}
+function Mo() {
+  const e = R(
+    () => new n.ShaderMaterial({
+      uniforms: { uTime: { value: 0 } },
+      vertexShader: (
+        /* glsl */
+        "varying vec2 vXZ; void main(){ vXZ = position.xz; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }"
+      ),
+      fragmentShader: yo,
+      transparent: !0,
+      depthWrite: !1
+    }),
+    []
+  ), a = R(() => new n.CircleGeometry(Ce, 96).rotateX(-Math.PI / 2), []), t = R(() => bo(), []), o = R(
+    () => new n.ShaderMaterial({
+      uniforms: { uTime: { value: 0 }, uAct: { value: 0 } },
+      vertexShader: (
+        /* glsl */
+        `
+          attribute float aDist; attribute float aSeed; attribute float aW;
+          varying float vD; varying float vS; varying float vW; varying float vR;
+          void main(){ vD = aDist; vS = aSeed; vW = aW; vR = length(position.xz);
+            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+          uniform float uTime; uniform float uAct;
+          varying float vD; varying float vS; varying float vW; varying float vR;
+          void main(){
+            vec3 base = mix(vec3(0.55, 0.30, 0.95), vec3(0.18, 0.85, 0.78), smoothstep(0.25, 0.85, vS));
+            float fade = smoothstep(${(Ce * 0.72).toFixed(1)}, 5.0, vR);
+            float pulse = pow(max(0.0, sin(vD * 0.55 - uTime * (0.9 + uAct * 0.8) + vS * 6.283)), 26.0);
+            float k = (0.035 + 0.045 * vW) + pulse * (0.35 + 0.45 * uAct) * vW;
+            gl_FragColor = vec4(base * k * fade, 1.0);
+          }`
+      ),
+      transparent: !0,
+      depthWrite: !1,
+      blending: n.AdditiveBlending
+    }),
+    []
+  ), s = F(null);
+  return fe(({ clock: r }) => {
+    var f;
+    (f = s.current) == null || f.scale.setScalar(Math.max(1, (ge.core.r + 12) / (Ce * 0.62)));
+    let u = 0;
+    for (const g of W.instances.values()) !g.exitAt && g.status === "thinking" && u++;
+    const m = o.uniforms;
+    m.uAct.value += (Math.min(1, u / 5) - m.uAct.value) * 0.03, m.uTime.value = ne ? 0 : r.elapsedTime;
+  }), /* @__PURE__ */ H("group", { ref: s, children: [
+    /* @__PURE__ */ w("mesh", { geometry: a, material: e, position: [0, -0.02, 0], renderOrder: -10 }),
+    /* @__PURE__ */ w("lineSegments", { geometry: t, material: o, frustumCulled: !1 })
+  ] });
+}
+const So = 260, Ee = 40, xe = 20, $e = 10, Le = 3;
+function xo(e) {
+  const a = e.nodes.slice(0, So), t = new Set(a.map((o) => o.id));
+  return { nodes: a, links: e.links.filter((o) => t.has(o.source) && t.has(o.target)) };
+}
+const Ao = (e) => 0.42 * Math.max(0, 1 - (e / he) ** 2) + 0.06, Po = 64;
+function Co({ galaxy: e }) {
+  const [a, t] = mt("center"), o = R(() => xo(e), [e]), s = o.nodes.length, { size: r, gl: u, camera: m } = pt(), f = F([]), g = F([]), v = F(Array(Le).fill("")), i = F([]), y = R(() => {
+    const M = new Float32Array(s * 3), d = Math.PI * (3 - Math.sqrt(5));
+    let S = 91;
+    const C = () => (S = S * 16807 % 2147483647) / 2147483647;
+    for (let x = 0; x < s; x++) {
+      const z = he * Math.sqrt((x + 0.5) / s) * (0.94 + C() * 0.08), G = x * d + (C() - 0.5) * 0.25;
+      M.set([Math.cos(G) * z, Ao(z) + (C() - 0.5) * 0.05, Math.sin(G) * z], x * 3);
+    }
+    const ee = o.nodes.map((x, z) => new n.Color(Xt[x.kind] ?? "#94a3b8").lerp(z % 3 ? vt : Ye, 0.45).multiplyScalar(0.5)), O = new n.BufferGeometry();
+    O.setAttribute("position", new n.BufferAttribute(M, 3)), O.setAttribute("aSize", new n.BufferAttribute(new Float32Array(s), 1)), O.setAttribute("aColor", new n.BufferAttribute(new Float32Array(s * 3), 3));
+    const j = (x, z) => (M[x * 3] - M[z * 3]) ** 2 + (M[x * 3 + 2] - M[z * 3 + 2]) ** 2, _ = [], V = /* @__PURE__ */ new Set(), L = (x, z, G) => {
+      const J = Math.min(x, z) * 4096 + Math.max(x, z);
+      x === z || V.has(J) || (V.add(J), _.push([x, z, G]));
+    }, E = new Map(o.nodes.map((x, z) => [x.id, z]));
+    for (const x of o.links) {
+      const z = E.get(x.source), G = E.get(x.target);
+      z !== void 0 && G !== void 0 && j(z, G) < 2.2 * 2.2 && L(z, G, 1);
+    }
+    for (let x = 0; x < s; x++) {
+      const z = [];
+      for (let G = 0; G < s; G++) G !== x && z.push([j(x, G), G]);
+      z.sort((G, J) => G[0] - J[0]);
+      for (let G = 0; G < 3 && G < z.length; G++) L(x, z[G][1], 0);
+    }
+    const N = 3, U = new Float32Array(_.length * N * 2 * 3), we = new Float32Array(_.length * N * 2 * 3), pe = new Int32Array(_.length * 2), q = new Uint8Array(_.length);
+    _.forEach(([x, z, G], J) => {
+      pe[J * 2] = x, pe[J * 2 + 1] = z, q[J] = G;
+      for (let se = 0; se < N; se++)
+        for (let k = 0; k < 2; k++) {
+          const A = (se + k) / N, P = (J * N + se) * 2 + k;
+          for (let B = 0; B < 3; B++) U[P * 3 + B] = M[x * 3 + B] * (1 - A) + M[z * 3 + B] * A;
+          U[P * 3 + 1] -= Math.sin(Math.PI * A) * 0.05;
+        }
+    });
+    const X = new n.BufferGeometry();
+    X.setAttribute("position", new n.BufferAttribute(U, 3)), X.setAttribute("color", new n.BufferAttribute(we, 3));
+    const Z = new n.BufferGeometry();
+    return Z.setAttribute("position", new n.BufferAttribute(new Float32Array(Ee * xe * 2 * 3), 3)), Z.setAttribute("color", new n.BufferAttribute(new Float32Array(Ee * xe * 2 * 3), 3)), Z.boundingSphere = new n.Sphere(new n.Vector3(), 1e4), { pos: M, base: ee, ngeo: O, ageo: X, bgeo: Z, owner: pe, strong: q, nPairs: _.length, SEG: N, fire: new Float32Array(s), white: new Float32Array(s), fireC: Array.from({ length: s }, () => new n.Color()) };
+  }, [o, s]), h = R(
+    () => ({
+      nodes: At(),
+      arcs: new n.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: n.AdditiveBlending, depthWrite: !1, toneMapped: !1 }),
+      beam: new n.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: n.AdditiveBlending, depthWrite: !1, toneMapped: !1 }),
+      pool: et(new n.Color("#7c3aed").multiplyScalar(0.55)),
+      core: et(new n.Color("#c4b5fd").multiplyScalar(0.25)),
+      ripple: Array.from({ length: $e }, () => Xe("#ffffff"))
+    }),
+    []
+  ), c = R(() => /* @__PURE__ */ new Map(), [o]), p = R(() => new ke(Ee), []), l = R(() => ({ v: new n.Vector3(), v2: new n.Vector3(), mid: new n.Vector3(), sp: new n.Vector3(), c: new n.Color(), c2: new n.Color() }), []), b = (M) => {
+    let d = c.get(M);
+    return d === void 0 && c.set(M, d = Yt(o, M)), d;
+  };
+  return fe(({ clock: M }) => {
+    const d = ge.graph.out.x < -0.5 ? "left" : "center";
+    d !== a && t(d);
+    const S = performance.now(), { pos: C, base: ee, fire: O, white: j, fireC: _ } = y;
+    h.nodes.uniforms.uScale.value = Pt(r.height, u.getPixelRatio(), m.fov) * ge.graph.scale, O.fill(0), j.fill(0);
+    const { v: V, v2: L, mid: E, c: N, c2: U } = l, we = y.bgeo.getAttribute("position"), pe = y.bgeo.getAttribute("color");
+    let q = 0, X = 0;
+    p.begin();
+    const Z = W.flares;
+    for (let A = Math.max(0, Z.length - Po); A < Z.length; A++) {
+      const P = Z[A], B = b(P.node), I = (S - P.start) / 1e3, te = W.instances.get(P.instance), K = te ? Pe[te.type] : ue, D = P.op === "write", $ = I < 0.3 ? I / 0.3 : Math.exp(-(I - 0.3) * 1.3);
+      if ($ > O[B] && (O[B] = $, _[B].copy(D ? ue : K), j[B] = D ? 1 : 0), D && I < 1.6 && X < $e) {
+        const T = i.current[X];
+        if (T) {
+          T.visible = !0, T.position.set(C[B * 3], C[B * 3 + 1] + 0.02, C[B * 3 + 2]);
+          const Y = I / 1.6;
+          T.scale.setScalar(0.15 + Y * 1.6), h.ripple[X].color.setScalar((1 - Y) * (1 - Y) * 0.9);
+        }
+        X++;
+      }
+      const ie = xt(P.instance), le = ie ? kt(ie.p, l.sp) : void 0;
+      if (le && I < 2.2 && q < Ee) {
+        V.set(C[B * 3], C[B * 3 + 1], C[B * 3 + 2]), E.copy(le).add(V).multiplyScalar(0.5), E.y += 1.6;
+        const T = Math.min(1, I / 0.25) * (1 - I / 2.2) ** 1.5, Y = D ? Math.min(1, I * 0.9) : 1 - Math.min(1, I * 0.9);
+        for (let ve = 0; ve < xe; ve++)
+          for (let Me = 0; Me < 2; Me++) {
+            const Q = (ve + Me) / xe, ae = 1 - Q;
+            L.set(ae * ae * le.x + 2 * ae * Q * E.x + Q * Q * V.x, ae * ae * le.y + 2 * ae * Q * E.y + Q * Q * V.y, ae * ae * le.z + 2 * ae * Q * E.z + Q * Q * V.z);
+            const Ve = (q * xe + ve) * 2 + Me;
+            we.setXYZ(Ve, L.x, L.y, L.z);
+            const _e = Math.exp(-(((Q - Y) / 0.08) ** 2)) * 1.5;
+            U.copy(D ? ue : K).multiplyScalar(T * ((D ? 0.35 : 0.16) + _e) * 0.8), pe.setXYZ(Ve, U.r, U.g, U.b);
+          }
+        D ? p.add(le, E, V, 0, 0, 0.9, 1, 0.34, ue, T * 1.1) : p.add(le, E, V, 0, 0, 0.1, -1, 0.34, K, T * 1.3), q++;
+      }
+    }
+    for (let A = X; A < $e; A++) {
+      const P = i.current[A];
+      P && (P.visible = !1);
+    }
+    y.bgeo.setDrawRange(0, q * xe * 2), we.needsUpdate = !0, pe.needsUpdate = !0, p.end();
+    const x = ne ? 0 : M.elapsedTime, z = y.ngeo.getAttribute("aSize"), G = y.ngeo.getAttribute("aColor");
+    for (let A = 0; A < s; A++) {
+      const P = O[A], B = 0.85 + 0.15 * Math.sin(x * 0.8 + A * 1.7);
+      z.setX(A, 0.17 + P * (0.42 + j[A] * 0.22)), N.copy(ee[A]).multiplyScalar(B), P > 0.01 && at(at(N, _[A], P * 1.7), ue, P * (0.25 + j[A] * 1.1)), G.setXYZ(A, N.r, N.g, N.b);
+    }
+    z.needsUpdate = !0, G.needsUpdate = !0;
+    const J = y.ageo.getAttribute("color"), se = y.SEG * 2;
+    for (let A = 0; A < y.nPairs; A++) {
+      const P = Math.max(O[y.owner[A * 2]], O[y.owner[A * 2 + 1]]), B = y.strong[A] ? 0.2 : 0.11, I = 0.55 * B + P * 0.35, te = 0.4 * B + P * 0.45, K = 0.95 * B + P * 0.5;
+      for (let D = 0; D < se; D++) J.setXYZ(A * se + D, I, te, K);
+    }
+    J.needsUpdate = !0;
+    let k = 0;
+    for (let A = W.flares.length - 1; A >= 0 && k < Le; A--) {
+      const P = W.flares[A];
+      if (S - P.start > 2200) break;
+      let B = !1;
+      for (let $ = 0; $ < k; $++) v.current[$] === P.node && (B = !0);
+      if (B) continue;
+      const I = b(P.node);
+      let te = !1;
+      for (let $ = 0; $ < k; $++) {
+        const ie = g.current[$];
+        ie && Math.abs(ie.position.z - C[I * 3 + 2]) * ge.graph.scale < 1.1 && Math.abs(ie.position.x - C[I * 3]) * ge.graph.scale < 4 && (te = !0);
+      }
+      if (te) continue;
+      const K = f.current[k], D = g.current[k];
+      K && D && (D.position.set(C[I * 3], C[I * 3 + 1] + 0.35, C[I * 3 + 2]), v.current[k] !== P.node && (K.setText(`${P.op === "write" ? "wrote" : "read"} · ${P.node}`), K.setColor(P.op === "write" ? "#ffffff" : "#5eead4")), K.setOpacity(1)), v.current[k] = P.node, k++;
+    }
+    for (let A = k; A < Le; A++) {
+      const P = f.current[A];
+      P == null || P.setOpacity(0), v.current[A] = "";
+    }
+  }), /* @__PURE__ */ H(de, { children: [
+    /* @__PURE__ */ w("mesh", { geometry: tt, material: h.pool, scale: he * 3.2, position: [0, 0.01, 0] }),
+    /* @__PURE__ */ w("mesh", { geometry: tt, material: h.core, scale: he * 1.8, position: [0, 0.03, 0] }),
+    /* @__PURE__ */ w("lineSegments", { geometry: y.ageo, material: h.arcs, frustumCulled: !1 }),
+    /* @__PURE__ */ w("points", { geometry: y.ngeo, material: h.nodes, frustumCulled: !1 }),
+    /* @__PURE__ */ w("lineSegments", { geometry: y.bgeo, material: h.beam, frustumCulled: !1 }),
+    /* @__PURE__ */ w("primitive", { object: p.mesh }),
+    h.ripple.map((M, d) => /* @__PURE__ */ w("mesh", { ref: (S) => void (i.current[d] = S), geometry: bt, material: M, visible: !1 }, d)),
+    Array.from({ length: Le }, (M, d) => /* @__PURE__ */ w("group", { ref: (S) => void (g.current[d] = S), children: /* @__PURE__ */ w(Re, { ref: (S) => void (f.current[d] = S), text: "", offset: [0, 0.34], anchorX: a, size: 0.24, opacity: 0, fadeMs: 250, pxRange: [8, 12] }) }, d)),
+    /* @__PURE__ */ w(Dt, { position: [a === "left" ? -he : 0, 0.2, -he - 0.7], anchorX: a, suffix: " · mycelial mat", color: "#c084fc", size: 0.28, opacity: 0.75, pxRange: [8, 12] })
+  ] });
+}
+const Be = /* @__PURE__ */ new Map(), zo = new n.Vector3(0, 1, 0), Ze = new n.Vector3(), ct = new n.Vector3(), Je = [
+  // angle, distance (x size), scale (x size)
+  [2.2, 0.62, 0.26],
+  [3.6, 0.5, 0.18],
+  [4.9, 0.7, 0.21]
+];
+function Go({ agent: e, onSelect: a }) {
+  const t = e.inst, o = F(null), s = F(null), r = F(null), u = F(null), m = F(null), f = F(null), g = F(null), v = F(null), i = F(null), y = F([]), h = R(() => Ie(t.id, 21), [t.id]), c = Pe[t.type], p = Ht(t), l = Mt * p, b = F(null), M = R(() => {
+    const _ = e.target.x - e.run.target.x, V = e.target.z - e.run.target.z;
+    return (_ * _ + V * V > 0.01 ? -Math.atan2(V, _) : -Math.PI / 2) + (Ie(t.id, 22) - 0.5) * 1.6;
+  }, [e, t.id]), d = R(
+    () => ({
+      cap: so(),
+      gill: io(),
+      stem: lo(),
+      pool: et("#000"),
+      halo: Fe("#000"),
+      sel: Xe("#ffffff"),
+      arrow: Xe(c),
+      hypha: Ke(c, t.parent ? t.subagent ? 0.06 : 0.085 : 0.075, 0.42, h, 0.35)
+    }),
+    [c, t.parent, t.subagent, h]
+  );
+  d.cap.uniforms.uSpots.value = h * 10;
+  const S = R(() => ({ c: new n.Color(), parentK: 0, ringK: 0, open: 0, curve: { p0: new n.Vector3(), p1: new n.Vector3(), p2: new n.Vector3(), wob: 0.35, seed: h } }), [h]);
+  Lt(() => (Be.set(t.id, S.curve), () => {
+    Be.get(t.id) === S.curve && Be.delete(t.id);
+  }), [t.id, S]), fe(({ clock: _ }) => {
+    var _e;
+    const V = performance.now(), L = ne ? 0 : _.elapsedTime, E = (V - t.bornAt) / 1e3, N = t.parent ? 0.9 : 0.75, U = ye(E / N), we = ye((E - N + 0.12) / 0.6), pe = eo((E - N - 0.2) / 0.75), q = t.exitAt ? (V - t.exitAt) / 1e3 : -1, X = q >= 0 ? re(q / 2.2) : 0, Z = Nt(t, V), x = Kt(t, V);
+    let z = !1;
+    for (const oe of W.mcpPending.values()) oe.instance === t.id && (z = !0);
+    const G = q < 0 && (t.status === "thinking" || t.status === "spawning"), J = 0.5 + 0.5 * Math.sin(L * 2.2 + h * 9), se = 0.5 + 0.5 * Math.sin(L * 0.9 + h * 5);
+    S.ringK += ((z && q < 0 ? 1 : 0) - S.ringK) * 0.08, S.open += ((G ? 1 : 0) - S.open) * 0.05;
+    const k = Math.max(1e-3, l * we * (1 - X * 0.4)), A = ne ? 0 : Math.sin(L * 0.7 + h * 12) * 0.035, P = 0.07 + h * 0.08 + A + X * X * 1.05, B = P * p, I = Math.atan(2 * P * p / Math.max(k, 0.3));
+    s.current && (s.current.scale.set(p * (1 + x * 0.04), k, p * (1 + x * 0.04)), d.stem.uniforms.uBend.value = P);
+    const te = p * Math.max(1e-4, pe) * (1 + x * 0.07 + (G ? J * 0.025 : se * 0.02));
+    r.current && (r.current.position.set(B, k - 0.05 * p, 0), r.current.rotation.z = -(I + X * 0.75), r.current.scale.set(te * (0.94 + S.open * 0.08), te * (1.18 - S.open * 0.25) * (1 - X * 0.35), te * (0.94 + S.open * 0.08))), o.current && (o.current.rotation.y = M);
+    const K = e.live, D = e.scale / p;
+    b.current && (b.current.position.copy(K), b.current.scale.setScalar(Math.max(1e-4, D))), S.c.copy(c), q >= 0 && S.c.lerp(t.status === "failed" ? gt : Qt, X * 0.85);
+    const $ = ((G ? 0.95 + J * 0.3 : 0.42 + se * 0.12) + x * 0.45) * (1 - X * 0.7);
+    d.cap.uniforms.uColor.value.copy(S.c), d.cap.uniforms.uGlow.value = $, d.cap.uniforms.uOpacity.value = Z, d.stem.uniforms.uColor.value.copy(S.c), d.stem.uniforms.uGlow.value = 0.55 + $ * 0.45, d.stem.uniforms.uOpacity.value = Z, d.gill.uniforms.uColor.value.copy(S.c).lerp(ht, S.ringK * 0.75), d.gill.uniforms.uGlow.value = ($ * 1.1 + x * 0.9) * Z, d.gill.uniforms.uTime.value = L, u.current && (u.current.scale.setScalar(Math.max(1e-4, p * (3.2 + $ * 1.2) * we)), d.pool.color.copy(S.c).multiplyScalar((0.06 + $ * 0.1 + x * 0.07) * Z)), m.current && (m.current.position.copy(r.current ? r.current.position : m.current.position), m.current.scale.setScalar(Math.max(1e-4, te * (2.6 + x * 0.6))), d.halo.color.copy(S.c).multiplyScalar((G ? 0.13 : 0.05) * Z + x * 0.05));
+    for (let oe = 0; oe < Je.length; oe++) {
+      const Se = y.current[oe];
+      if (!Se) continue;
+      const Ft = Je[oe][2] * p * ye((E - N - 0.6 - oe * 0.25) / 0.8) * (1 - X * 0.6);
+      Se.scale.setScalar(Math.max(1e-4, Ft));
+    }
+    if (f.current) {
+      const oe = W.selected === t.id;
+      f.current.visible = oe, oe && (f.current.scale.setScalar(p * (1.25 + 0.08 * Math.sin(L * 3))), d.sel.color.setScalar(0.7 * Z));
+    }
+    v.current && v.current.position.set(K.x + B * Math.cos(M) * D, K.y + (k + te * 0.75) * D + 0.32, K.z - B * Math.sin(M) * D), (_e = i.current) == null || _e.setOpacity(jt(t.id) ? re(pe) * (1 - X) * 0.95 : 0);
+    const ie = t.parent ? W.instances.get(t.parent) : void 0, le = t.parent ? We(t.parent) : void 0, T = S.curve;
+    le && ie ? T.p0.copy(le) : t.parent ? T.p0.lengthSq() === 0 && T.p0.copy(K) : Ut(e.run, 0, -2.4 * nt.spread, T.p0).setY(0.05), T.p2.copy(K), T.p1.copy(T.p0).add(T.p2).multiplyScalar(0.5), T.p1.y += 0.35;
+    const Y = d.hypha.uniforms;
+    Y.uP0.value.copy(T.p0), Y.uP1.value.copy(T.p1), Y.uP2.value.copy(T.p2);
+    const ve = !!t.parent && !!ie, Me = ve && !ie.exitAt, Q = q < 0 && (!t.parent || Me) ? 1 : 0;
+    S.parentK += (Q - S.parentK) * (Q ? 0.08 : 0.035);
+    const ae = q >= 0 ? He(q / 1.6) : 0;
+    Y.uGrow.value = U * (1 - ae), Y.uHead.value = U < 1 ? U : -1, Y.uTail.value = 0.12, Y.uHeadColor.value.copy(c).multiplyScalar(2.2);
+    const Ve = T.p0.distanceTo(T.p2);
+    if (Y.uBeads.value = Math.max(2, Ve / 1.1), Y.uTime.value = L, Y.uFlow.value = U >= 1 ? S.parentK * (G ? 1 : 0.45) : 0, Y.uOpacity.value = (ve ? G ? 0.85 : 0.55 : 0.38) * Math.max(S.parentK, U < 1 ? 1 : 0) + (U < 1 ? 0.3 : 0), g.current) {
+      const oe = ve && U >= 1 && S.parentK > 0.05 && Y.uGrow.value > 0.95;
+      if (g.current.visible = oe, oe) {
+        Ge(T.p0, T.p1, T.p2, T.wob, T.seed, 0.8, Ze), Ge(T.p0, T.p1, T.p2, T.wob, T.seed, 0.83, ct), g.current.position.copy(Ze), g.current.quaternion.setFromUnitVectors(zo, ct.sub(Ze).normalize());
+        const Se = (t.subagent ? 0.8 : 1) * Math.min(1.3, nt.scale);
+        g.current.scale.set(0.13 * Se, 0.36 * Se, 0.13 * Se), d.arrow.color.copy(c).multiplyScalar(1.5 * S.parentK);
+      }
+    }
+  });
+  const C = (_) => {
+    _.stopPropagation(), a(t.id);
+  }, ee = () => document.body.style.cursor = "pointer", O = () => document.body.style.cursor = "", j = t.id.split(":")[2];
+  return /* @__PURE__ */ H(de, { children: [
+    /* @__PURE__ */ w("mesh", { geometry: Ne, material: d.hypha, frustumCulled: !1 }),
+    /* @__PURE__ */ w("mesh", { ref: g, geometry: yt, material: d.arrow, visible: !1 }),
+    /* @__PURE__ */ H("group", { ref: b, children: [
+      /* @__PURE__ */ w("mesh", { ref: u, geometry: tt, material: d.pool, position: [0, 0.04, 0], scale: 1e-4 }),
+      /* @__PURE__ */ w("mesh", { ref: f, geometry: bt, material: d.sel, position: [0, 0.06, 0], visible: !1 }),
+      /* @__PURE__ */ H("group", { ref: o, children: [
+        /* @__PURE__ */ w("mesh", { ref: s, geometry: st, material: d.stem, scale: 1e-4, onClick: C, onPointerOver: ee, onPointerOut: O }),
+        /* @__PURE__ */ H("group", { ref: r, scale: 1e-4, children: [
+          /* @__PURE__ */ w("mesh", { geometry: rt, material: d.cap, onClick: C, onPointerOver: ee, onPointerOut: O }),
+          /* @__PURE__ */ w("mesh", { geometry: to, material: d.gill })
+        ] }),
+        /* @__PURE__ */ w("sprite", { ref: m, material: d.halo }),
+        !t.subagent && Je.map(([_, V], L) => /* @__PURE__ */ H("group", { ref: (E) => void (y.current[L] = E), position: [Math.cos(_) * V * p, 0, Math.sin(_) * V * p], scale: 1e-4, children: [
+          /* @__PURE__ */ w("mesh", { geometry: st, material: d.stem, scale: [1, 1.5, 1] }),
+          /* @__PURE__ */ w("mesh", { geometry: rt, material: d.cap, position: [0.08, 1.45, 0], scale: [0.75, 0.95, 0.75] })
+        ] }, L))
+      ] })
+    ] }),
+    /* @__PURE__ */ w("group", { ref: v, children: /* @__PURE__ */ w(
+      Re,
+      {
+        ref: i,
+        offset: [0, 0.22],
+        text: `${t.name}${j !== void 0 ? ` ${Number(j) + 1}` : ""}`,
+        color: dt[t.type],
+        size: t.subagent ? 0.22 : 0.28,
+        opacity: 0,
+        fit: !0,
+        pxRange: t.subagent ? [8, 11.5] : [9, 13.5]
+      }
+    ) })
+  ] });
+}
+const Qe = 24, Ae = 3;
+function To() {
+  const e = F([]), a = R(() => Array.from({ length: Qe * Ae }, () => Fe("#fff")), []), t = R(() => ({ a: new n.Vector3(), b: new n.Vector3(), c: new n.Vector3(), p: new n.Vector3(), col: new n.Color() }), []);
+  return fe(() => {
+    const o = performance.now();
+    let s = 0;
+    for (const r of W.comets) {
+      if (s >= Qe) break;
+      const u = W.instances.get(r.from), m = W.instances.get(r.to), f = We(r.from), g = We(r.to);
+      if (!u || !m || !f || !g) continue;
+      const v = re((o - r.start) / r.dur);
+      if (v >= 1) continue;
+      let i, y = !0;
+      m.parent === r.from ? i = Be.get(r.to) : u.parent === r.to && (i = Be.get(r.from), y = !1), t.col.copy(Pe[u.type]).multiplyScalar(1.6).addScalar(0.25);
+      for (let h = 0; h < Ae; h++) {
+        const c = e.current[s * Ae + h];
+        if (!c) continue;
+        const p = re(He(v) - h * 0.035), l = y ? p : 1 - p;
+        i ? Ge(i.p0, i.p1, i.p2, i.wob, i.seed, l, t.p) : (t.c.copy(f).add(g).multiplyScalar(0.5), t.c.y += 2.4, Ge(f, t.c, g, 0, 0, l, t.p)), c.visible = !0, c.position.set(t.p.x, t.p.y + 0.12, t.p.z), c.scale.setScalar((h === 0 ? 1 : 0.7 - h * 0.15) * (0.6 + 0.4 * Math.sin(Math.PI * v))), a[s * Ae + h].color.copy(t.col).multiplyScalar(h === 0 ? 1 : 0.5 / h);
+      }
+      s++;
+    }
+    for (let r = s * Ae; r < Qe * Ae; r++) {
+      const u = e.current[r];
+      u && (u.visible = !1);
+    }
+  }), /* @__PURE__ */ w(de, { children: a.map((o, s) => /* @__PURE__ */ w("sprite", { ref: (r) => void (e.current[s] = r), material: o, visible: !1 }, s)) });
+}
+const Bo = new n.RingGeometry(0.88, 1.12, 160, 1).rotateX(-Math.PI / 2), ut = 1.1, Fo = 0.9;
+function Tt(e, a) {
+  return a.a = e.hu * 1.12 + ut, a.b = Math.max(a.a * 0.45, e.hv * 1.12 + ut), a;
+}
+const ze = { a: 0, b: 0 }, ot = (e) => e.target.z < -0.5 ? -1 : 1;
+function Bt(e, a, t = ot(e)) {
+  Tt(e, ze);
+  const o = Math.abs(e.side.z) * ze.a + Math.abs(e.axis.z) * ze.b;
+  return a.set(e.origin.x, 0.3, e.origin.z + t * (o + Fo));
+}
+const Ro = new n.Vector3();
+function Vo(e) {
+  for (const a of ge.runs.values()) e(Bt(a, Ro), 1.6);
+}
+function _o(e) {
+  return new n.ShaderMaterial({
+    uniforms: { uColor: { value: e.clone() }, uK: { value: 0 }, uSweep: { value: 0 }, uStart: { value: 0 }, uSteps: { value: new n.Vector3(1, 1, 1) }, uTime: { value: 0 }, uGaps: { value: 0 } },
+    vertexShader: (
+      /* glsl */
+      "varying vec3 vP; void main(){ vP = position; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }"
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      uniform vec3 uColor; uniform float uK; uniform float uSweep; uniform float uStart; uniform vec3 uSteps; uniform float uTime; uniform float uGaps;
+      varying vec3 vP;
+      void main(){
+        float r = length(vP.xz);
+        float a = fract((atan(vP.z, vP.x) - uStart) / 6.28318 + 1.0);
+        if (a > uSweep) discard;
+        float band = exp(-pow((r - 1.0) / 0.05, 2.0));
+        float caps = pow(max(0.0, sin(a * 6.28318 * 30.0)), 10.0) * exp(-pow((r - 1.0) / 0.035, 2.0));
+        float seg = a * 3.0;
+        float s = seg < 1.0 ? uSteps.x : seg < 2.0 ? uSteps.y : uSteps.z;
+        float gap = smoothstep(0.0, 0.015, fract(seg)) * smoothstep(1.0, 0.985, fract(seg));
+        float k = (band * 0.25 + caps * 1.6) * s * mix(1.0, gap, uGaps);
+        gl_FragColor = vec4(uColor * k * uK, 1.0);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    blending: n.AdditiveBlending
+  });
+}
+function Oo({ run: e }) {
+  const a = R(() => new n.Color(e.color), [e.color]), t = R(() => _o(a), [a]), o = F(null), s = F(null), [r, u] = mt(() => ot(e));
+  return fe(({ clock: m }) => {
+    const f = performance.now(), g = ne ? 0 : m.elapsedTime, v = e.run ?? W.runs.get(e.id), i = v != null && v.endedAt ? re(1 - (f - v.endedAt - (qt - 2500)) / 2500) : 1, y = t.uniforms;
+    if (y.uSweep.value = v ? ye((f - v.startedAt) / 1800) : 1, y.uK.value = 0.55 * i * (!v || v.status === "started" ? 1 : 0.6), v != null && v.hasSteps) {
+      const c = (p) => p === "running" ? 1.5 + 0.5 * Math.sin(g * 3) : p === "done" ? 0.9 : p === "failed" ? 0.5 : 0.22;
+      y.uSteps.value.set(c(v.steps.plan), c(v.steps.research), c(v.steps.write));
+    } else y.uSteps.value.set(1, 1, 1);
+    y.uGaps.value = v != null && v.hasSteps ? 1 : 0, y.uStart.value = Math.atan2(-e.axis.z, -e.axis.x) - Math.atan2(e.side.z, e.side.x), o.current && (Tt(e, ze), o.current.position.set(e.origin.x, 0.05, e.origin.z), o.current.rotation.set(0, Math.atan2(-e.side.z, e.side.x), 0), o.current.scale.set(ze.a, 1, ze.b));
+    const h = ot(e);
+    h !== r && u(h), s.current && Bt(e, s.current.position, r);
+  }), /* @__PURE__ */ H(de, { children: [
+    /* @__PURE__ */ w("mesh", { ref: o, geometry: Bo, material: t }),
+    /* @__PURE__ */ w("group", { ref: s, children: e.run && /* @__PURE__ */ w(Eo, { run: e.run, anchorY: r > 0 ? "top" : "bottom" }) })
+  ] });
+}
+function Eo({ run: e, anchorY: a }) {
+  $t();
+  const t = e.status !== "started";
+  return /* @__PURE__ */ w(
+    Re,
+    {
+      text: e.topic,
+      secondary: Zt(e, { base: "#a1a1c2", current: "#f5d0fe", done: "#cbd5e1" }, ["colony growing…", "colony complete"]),
+      color: e.color,
+      size: 0.34,
+      maxWidth: 9,
+      opacity: t ? 0.5 : 0.95,
+      fadeMs: 400,
+      anchorY: a,
+      pxRange: [10, 14.5]
+    }
+  );
+}
+const ce = 2600;
+function Lo() {
+  const { size: e, gl: a, camera: t } = pt(), o = R(() => {
+    const u = new n.BufferGeometry(), m = new Float32Array(ce * 3);
+    return u.setAttribute("position", new n.BufferAttribute(m, 3)), u.setAttribute("aSize", new n.BufferAttribute(new Float32Array(ce), 1)), u.setAttribute("aColor", new n.BufferAttribute(new Float32Array(ce * 3), 3)), u.boundingSphere = new n.Sphere(new n.Vector3(), 1e4), {
+      geo: u,
+      pos: m,
+      vel: new Float32Array(ce * 3),
+      life: new Float32Array(ce),
+      // remaining seconds (<=0 = free)
+      max: new Float32Array(ce),
+      sz: new Float32Array(ce),
+      col: new Float32Array(ce * 3),
+      next: 0,
+      seenLlm: /* @__PURE__ */ new Map(),
+      seenExit: /* @__PURE__ */ new Set(),
+      acc: /* @__PURE__ */ new Map(),
+      c: new n.Color()
+    };
+  }, []), s = R(() => At(), []), r = (u, m, f, g, v, i, y, h, c, p) => {
+    for (let l = 0; l < v; l++) {
+      const b = o.next;
+      o.next = (o.next + 1) % ce;
+      const M = Math.random() * Math.PI * 2, d = g * (0.2 + Math.random() * 0.75);
+      o.pos[b * 3] = u + Math.cos(M) * d, o.pos[b * 3 + 1] = m - 0.08, o.pos[b * 3 + 2] = f + Math.sin(M) * d;
+      const S = y * (0.4 + Math.random() * 0.8);
+      o.vel[b * 3] = Math.cos(M) * S, o.vel[b * 3 + 1] = p * (0.3 + Math.random() * 0.9) - 0.15, o.vel[b * 3 + 2] = Math.sin(M) * S, o.life[b] = o.max[b] = c * (0.6 + Math.random() * 0.6), o.sz[b] = i * (0.55 + Math.random() * 0.8);
+      const C = Math.random() * 0.45;
+      o.col[b * 3] = h.r * (1 - C) + C, o.col[b * 3 + 1] = h.g * (1 - C) + C, o.col[b * 3 + 2] = h.b * (1 - C) + C;
+    }
+  };
+  return fe(({ clock: u }, m) => {
+    const f = Math.min(0.05, m);
+    s.uniforms.uScale.value = Pt(e.height, a.getPixelRatio(), t.fov);
+    for (const c of W.instances.values()) {
+      const p = xt(c.id);
+      if (!p || p.r < 0.05) continue;
+      const l = p.p, b = p.r, M = o.seenLlm.get(c.id);
+      if (M === void 0) o.seenLlm.set(c.id, c.llmCalls);
+      else if (c.llmCalls !== M) {
+        o.seenLlm.set(c.id, c.llmCalls);
+        const d = c.pulse;
+        r(l.x, l.y, l.z, b, Math.round((ne ? 6 : 16) + d * (ne ? 8 : 34)), 0.12 + d * 0.09, 0.9 + d * 0.5, Pe[c.type], 2.6 + d * 0.5, 0.9);
+      }
+      if (c.exitAt)
+        o.seenExit.has(c.id) || (o.seenExit.add(c.id), o.c.copy(Pe[c.type]).multiplyScalar(0.45), r(l.x, l.y, l.z, b, ne ? 6 : 22, 0.1, 0.35, o.c, 2.2, -0.2));
+      else if (!ne && c.status === "thinking") {
+        const d = (o.acc.get(c.id) ?? 0) + f * 5 * (c.subagent ? 0.6 : 1);
+        d >= 1 && r(l.x, l.y, l.z, b, 1, 0.08, 0.25, o.c.copy(Pe[c.type]).lerp(ue, 0.2), 3.2, 0.7), o.acc.set(c.id, d % 1);
+      }
+    }
+    if (o.seenLlm.size > W.instances.size + 64)
+      for (const c of o.seenLlm.keys()) W.instances.has(c) || (o.seenLlm.delete(c), o.seenExit.delete(c), o.acc.delete(c));
+    const g = o.geo.getAttribute("position"), v = o.geo.getAttribute("aSize"), i = o.geo.getAttribute("aColor"), y = u.elapsedTime, h = Math.pow(0.35, f);
+    for (let c = 0; c < ce; c++) {
+      if (o.life[c] <= 0) {
+        v.array[c] !== 0 && v.setX(c, 0);
+        continue;
+      }
+      o.life[c] -= f;
+      const p = c * 3, l = o.pos[p], b = o.pos[p + 2];
+      o.vel[p] = o.vel[p] * h + Math.sin(b * 0.9 + y * 0.7) * 0.25 * f, o.vel[p + 1] = o.vel[p + 1] * h + 0.32 * f, o.vel[p + 2] = o.vel[p + 2] * h + Math.cos(l * 0.9 + y * 0.6) * 0.25 * f, o.pos[p] += o.vel[p] * f, o.pos[p + 1] += o.vel[p + 1] * f, o.pos[p + 2] += o.vel[p + 2] * f;
+      const M = o.life[c] / o.max[c], d = Math.min(1, (1 - M) * 8) * M;
+      g.setXYZ(c, o.pos[p], o.pos[p + 1], o.pos[p + 2]), v.setX(c, o.sz[c] * (0.6 + 0.4 * M)), i.setXYZ(c, o.col[p] * d * 1.3, o.col[p + 1] * d * 1.3, o.col[p + 2] * d * 1.3);
+    }
+    g.needsUpdate = !0, v.needsUpdate = !0, i.needsUpdate = !0;
+  }), /* @__PURE__ */ w("points", { geometry: o.geo, material: s, frustumCulled: !1 });
+}
+const Io = ["#a855f7", "#2dd4bf"], Wo = { radius: 1.4, variant: "swarm", color: (e) => Io[e % 2] }, Xo = [0, 1.6, 0], ko = /* @__PURE__ */ H(de, { children: [
+  /* @__PURE__ */ w("fog", { attach: "fog", args: ["#040309", 55, 140] }),
+  /* @__PURE__ */ w(Mo, {})
+] });
+function Uo() {
+  return /* @__PURE__ */ H(
+    Jt,
+    {
+      title: "mycelium · fungal network",
+      subtitle: "Agents bloom as mushrooms (big cap = parent) on hyphae grown from their parent · spores = LLM calls (sized by tokens) · MCP servers + backends feed the network's edge · the mat on the side is graph memory",
+      preset: "radial",
+      plane: "xz",
+      camera: { position: [0, 34, 29], fov: 46 },
+      controls: { minPolarAngle: 0.25, maxPolarAngle: 1.38 },
+      bg: "#040309",
+      fit: { nRef: 4, min: 0.62, max: 1.6, minRadius: 5.5 },
+      agentRadius: 1.5,
+      graph: { natural: he + 0.4, radius: 2.6 },
+      peripheryGap: 3.8,
+      Background: ko,
+      Agent: Go,
+      RunMarker: Oo,
+      McpServer: vo,
+      Backend: mo,
+      GraphResource: Co,
+      cluster: Wo,
+      clusterOffset: Xo,
+      extents: Vo,
+      PostFX: /* @__PURE__ */ H(_t, { multisampling: 0, children: [
+        /* @__PURE__ */ w(Ot, { mipmapBlur: !0, intensity: 1.15, luminanceThreshold: 0.18, luminanceSmoothing: 0.3, radius: 0.78 }),
+        /* @__PURE__ */ w(Et, { eskil: !1, offset: 0.2, darkness: 0.92 })
+      ] }),
+      children: [
+        /* @__PURE__ */ w(To, {}),
+        /* @__PURE__ */ w(go, {}),
+        /* @__PURE__ */ w(Lo, {})
+      ]
+    }
+  );
+}
+export {
+  Uo as default
+};