agentglow 0.1.0

package/dist/chunks/index-K__sPGRy.js

@@ -0,0 +1,1134 @@
+var kt = Object.defineProperty;
+var Ot = (e, n, o) => n in e ? kt(e, n, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[n] = o;
+var ve = (e, n, o) => Ot(e, typeof n != "symbol" ? n + "" : n, o);
+import { jsx as v, Fragment as ne, jsxs as N } from "react/jsx-runtime";
+import { OrbitControls as Et } from "@react-three/drei";
+import { useFrame as J, useThree as wt, Canvas as It } from "@react-three/fiber";
+import { EffectComposer as Lt, Bloom as Wt, Vignette as Dt } from "@react-three/postprocessing";
+import { useState as Re, useRef as B, useMemo as z, useEffect as Xt } from "react";
+import { T as yt, l as Me, m as Nt, j as Ht, w as R, h as he, v as Yt, q as Kt, L as Fe, c as Ut, K as jt, G as qt, n as $t, i as Je, r as Zt, p as Jt, e as Qt, s as eo, b as to, d as oo, R as no, u as ao, k as ro, f as so, H as io, t as lo, g as co } from "./ClusterBall-CPsd6JvJ.js";
+import * as a from "three";
+import { s as it, a as lt } from "./spread-CWdeDFd9.js";
+var gt;
+const oe = typeof window < "u" && !!((gt = window.matchMedia) != null && gt.call(window, "(prefers-reduced-motion: reduce)").matches), Mt = new a.Color("#a855f7"), De = new a.Color("#2dd4bf"), fe = new a.Color(1, 1, 1), bt = new a.Color("#fbbf24"), St = new a.Color("#ff3b5c"), uo = new a.Color("#3b3346"), Pe = Object.fromEntries(
+  Object.entries(yt).map(([e, n]) => {
+    const o = new a.Color(n);
+    return [e, o.lerp(e === "graph_scout" || e === "writer" ? De : Mt, 0.18)];
+  })
+), re = (e) => e < 0 ? 0 : e > 1 ? 1 : e, ye = (e) => 1 - Math.pow(1 - re(e), 3), Xe = (e) => (e = re(e), e < 0.5 ? 4 * e * e * e : 1 - Math.pow(-2 * e + 2, 3) / 2), fo = (e) => {
+  e = re(e);
+  const n = 1.9;
+  return 1 + (n + 1) * Math.pow(e - 1, 3) + n * Math.pow(e - 1, 2);
+};
+function ct(e, n, o) {
+  return e.r += n.r * o, e.g += n.g * o, e.b += n.b * o, e;
+}
+let Ve = null;
+function xt() {
+  if (Ve) return Ve;
+  const e = document.createElement("canvas");
+  e.width = e.height = 128;
+  const n = e.getContext("2d"), o = n.createRadialGradient(64, 64, 0, 64, 64, 64);
+  return o.addColorStop(0, "rgba(255,255,255,1)"), o.addColorStop(0.18, "rgba(255,255,255,0.55)"), o.addColorStop(0.5, "rgba(255,255,255,0.12)"), o.addColorStop(1, "rgba(255,255,255,0)"), n.fillStyle = o, n.fillRect(0, 0, 128, 128), Ve = new a.CanvasTexture(e), Ve;
+}
+function Te(e = "#fff") {
+  return new a.SpriteMaterial({ map: xt(), color: e, blending: a.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function Qe(e = "#fff") {
+  return new a.MeshBasicMaterial({ map: xt(), color: e, blending: a.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function Oe(e = "#fff") {
+  return new a.MeshBasicMaterial({ color: e, blending: a.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+const et = new a.PlaneGeometry(1, 1).rotateX(-Math.PI / 2);
+new a.SphereGeometry(1, 24, 16);
+const Pt = new a.ConeGeometry(1, 1, 12).translate(0, 0.5, 0), At = new a.RingGeometry(0.86, 1, 64, 1).rotateX(-Math.PI / 2), ut = new a.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, n]) => new a.Vector2(e, n)),
+  48
+), po = new a.RingGeometry(0.1, 0.9, 64, 3).rotateX(Math.PI / 2).translate(0, -0.035, 0), ft = new a.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, n]) => new a.Vector2(e, n)),
+  20
+);
+function mo(e = 72, n = 6) {
+  const o = [], t = [];
+  for (let r = 0; r <= e; r++) {
+    const i = r / e;
+    for (let c = 0; c < n; c++) {
+      const d = c / n * Math.PI * 2;
+      o.push(i, Math.cos(d), Math.sin(d));
+    }
+  }
+  for (let r = 0; r < e; r++)
+    for (let i = 0; i < n; i++) {
+      const c = r * n + i, d = r * n + (i + 1) % n, h = (r + 1) * n + i, u = (r + 1) * n + (i + 1) % n;
+      t.push(c, h, d, d, h, u);
+    }
+  const s = new a.BufferGeometry();
+  return s.setAttribute("position", new a.Float32BufferAttribute(o, 3)), s.setIndex(t), s.boundingSphere = new a.Sphere(new a.Vector3(), 1e4), s;
+}
+const Ne = mo(), vo = (
+  /* 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);
+}`
+), Ke = new a.Vector3();
+function Ae(e, n, o, t, s, r, i) {
+  const c = 1 - r;
+  if (i.set(c * c * e.x + 2 * c * r * n.x + r * r * o.x, c * c * e.y + 2 * c * r * n.y + r * r * o.y, c * c * e.z + 2 * c * r * n.z + r * r * o.z), t === 0) return i;
+  Ke.set(2 * c * (n.x - e.x) + 2 * r * (o.x - n.x), 0, 2 * c * (n.z - e.z) + 2 * r * (o.z - n.z));
+  const d = -Ke.z + 1e-5, h = Ke.x + 1e-5, u = Math.hypot(d, 1e-5, h) || 1, f = (Math.sin(r * 9 + s * 6.283) * 0.6 + Math.sin(r * 17 + s * 3.1) * 0.4) * t * Math.sin(Math.PI * r);
+  return i.x += d / u * f, i.z += h / u * f, i;
+}
+const ho = (
+  /* glsl */
+  `
+uniform float uRadius; uniform float uTaper;
+varying float vT; varying float vRim;
+${vo}
+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;
+}`
+), go = (
+  /* 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 He(e = "#fff", n = 0.06, o = 0.45, t = 0, s = 0.25) {
+  return new a.ShaderMaterial({
+    uniforms: {
+      uP0: { value: new a.Vector3() },
+      uP1: { value: new a.Vector3() },
+      uP2: { value: new a.Vector3() },
+      uWob: { value: s },
+      uSeed: { value: t },
+      uRadius: { value: n },
+      uTaper: { value: o },
+      uColor: { value: new a.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 a.Color(3, 3, 3) }
+    },
+    vertexShader: ho,
+    fragmentShader: go,
+    transparent: !0,
+    depthWrite: !1,
+    blending: a.AdditiveBlending
+  });
+}
+function wo() {
+  return new a.ShaderMaterial({
+    uniforms: {
+      uColor: { value: new a.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 yo() {
+  return new a.ShaderMaterial({
+    uniforms: { uColor: { value: new a.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: a.DoubleSide,
+    blending: a.AdditiveBlending
+  });
+}
+function Mo() {
+  return new a.ShaderMaterial({
+    uniforms: { uColor: { value: new a.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 pe = 3.8, Ee = 6.9, bo = 14.4, So = 17.4;
+function ot(e) {
+  var n;
+  return Me.grouped ? Nt(e) + 6 * Ht(e) : ((n = R.runs.get(e)) == null ? void 0 : n.slot) ?? 0;
+}
+function Ie(e, n) {
+  return e % 6 * (Math.PI / 3) + Math.PI / 6 + (he(n, 1) - 0.5) * 0.26 + Math.floor(e / 6) * 0.45;
+}
+function pt(e, n, o, t) {
+  const s = Ie(e, n);
+  return t.set(Math.cos(s) * o, 0, Math.sin(s) * o);
+}
+const ge = /* @__PURE__ */ new Map(), Ce = /* @__PURE__ */ new Map(), ze = /* @__PURE__ */ new Map(), tt = /* @__PURE__ */ new Map(), xo = { planner: -2.4, researcher: 0, writer: 2.4, graph_scout: 0, records_scout: 0, data_scout: 0 }, Po = { planner: "myc:planner", researcher: "myc:researcher", writer: "myc:writer", graph_scout: "myc:root", records_scout: "myc:root", data_scout: "myc:root" }, mt = /* @__PURE__ */ new Map();
+function Ct(e) {
+  const n = ot(e.run);
+  let o = ge.get(e.id);
+  if (o && Ce.get(e.id) === n) return o;
+  if (o = new a.Vector3(), Ce.set(e.id, n), Ce.size > 600)
+    for (const r of Ce.keys()) R.instances.has(r) || Ce.delete(r);
+  const t = e.parent ? R.instances.get(e.parent) : void 0, s = t && ge.has(t.id) ? Ct(t) : void 0;
+  if (s && t) {
+    let r = mt.get(e.parent);
+    r || mt.set(e.parent, r = `myc:kids:${e.parent}`);
+    const i = it(e, r), c = Math.atan2(s.z, s.x), d = Math.floor(i / 5), h = Math.max(-1.45, Math.min(1.45, lt(i % 5) * 0.5)) + (he(e.id, 7) - 0.5) * 0.28 + (d ? 0.31 : 0), f = (Ao(e) ? 2.3 : 3.15) * (0.92 + 0.22 * he(e.id, 8)) + d * 1.7;
+    o.set(s.x + Math.cos(c + h) * f, 0, s.z + Math.sin(c + h) * f);
+  } else {
+    const r = Ie(n, e.run), i = it(e, Po[e.type]), c = -Math.sin(r), d = Math.cos(r), h = xo[e.type] + lt(i) * 1.5, u = Ee + (i ? Math.ceil(i / 2) * 1.2 : 0) + (he(e.id, 9) - 0.5) * 0.8;
+    o.set(Math.cos(r) * u + c * h, 0, Math.sin(r) * u + d * h);
+  }
+  return o.x += (he(e.id, 10) - 0.5) * 0.5, o.z += (he(e.id, 11) - 0.5) * 0.5, ge.set(e.id, o), o;
+}
+function Ao(e) {
+  const n = e.parent ? R.instances.get(e.parent) : void 0;
+  return !!(n != null && n.subagent);
+}
+function nt(e, n) {
+  const o = Math.floor(e / 6), t = e % 6 * (Math.PI / 3) + o * (Math.PI / 6), s = bo + o * 2.6;
+  return n.set(Math.cos(t) * s, 0.9, Math.sin(t) * s);
+}
+function Co(e, n, o, t) {
+  const s = Math.floor(e / 6), r = e % 6 * (Math.PI / 3) + s * (Math.PI / 6) + (n - (o - 1) / 2) * 0.2, i = So + s * 2.6 + (o > 2 && n % 2 ? 1.1 : 0);
+  return t.set(Math.cos(r) * i, 0.7, Math.sin(r) * i);
+}
+const We = class We {
+  constructor(n) {
+    ve(this, "mesh");
+    ve(this, "colors");
+    ve(this, "n", 0);
+    ve(this, "max");
+    ve(this, "o", new a.Object3D());
+    ve(this, "a", new a.Vector3());
+    ve(this, "b", new a.Vector3());
+    this.max = n, this.colors = new Float32Array(n * 3), this.mesh = new a.InstancedMesh(Pt, new a.MeshBasicMaterial({ blending: a.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 }), n), this.mesh.instanceColor = new a.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(n, o, t, s, r, i, c, d, h, u = 1) {
+    this.n >= this.max || u <= 0.01 || (Ae(n, o, t, s, r, i, this.a), Ae(n, o, t, s, r, Math.min(1, Math.max(0, i + 0.025 * c)), this.b), this.b.sub(this.a), !(this.b.lengthSq() < 1e-8) && (this.o.position.copy(this.a), this.o.quaternion.setFromUnitVectors(We.UP, this.b.normalize()), this.o.scale.set(d * 0.42, d, d * 0.42), this.o.updateMatrix(), this.mesh.setMatrixAt(this.n, this.o.matrix), this.colors[this.n * 3] = h.r * u, this.colors[this.n * 3 + 1] = h.g * u, this.colors[this.n * 3 + 2] = h.b * u, this.n++));
+  }
+  end() {
+    this.mesh.count = this.n, this.mesh.instanceMatrix.needsUpdate = !0, this.mesh.instanceColor && (this.mesh.instanceColor.needsUpdate = !0);
+  }
+};
+ve(We, "UP", new a.Vector3(0, 1, 0));
+let Le = We;
+function zt() {
+  return new a.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: a.AdditiveBlending
+  });
+}
+function Gt(e, n, o) {
+  return e * n / (2 * Math.tan(o * Math.PI / 360));
+}
+const zo = ["#a855f7", "#2dd4bf"], Go = Array.from({ length: Kt }, (e, n) => n);
+function To(e, n) {
+  const o = Me.laneExpanded[e] > 0, t = e * (Math.PI / 3) + Math.PI / 6 + (o ? -0.5 : 0), s = Ee + (o ? 4.2 : 1.6);
+  return n.set(Math.cos(t) * s, 1.6, Math.sin(t) * s);
+}
+function Bo() {
+  return /* @__PURE__ */ v(ne, { children: Go.map((e) => /* @__PURE__ */ v(Yt, { cluster: Me.clusters[e], place: To, radius: 1.4, variant: "swarm", color: zo[e % 2] }, e)) });
+}
+function Ro(e, n) {
+  const o = new a.IcosahedronGeometry(e, 3), t = o.getAttribute("position"), s = new a.Vector3();
+  for (let r = 0; r < t.count; r++) {
+    s.fromBufferAttribute(t, r);
+    const i = s.clone().normalize(), c = 1 + 0.13 * Math.sin(i.x * 5 + n) * Math.cos(i.y * 4 + n * 2) + 0.07 * Math.sin(i.z * 9 + n * 3);
+    s.multiplyScalar(c), t.setXYZ(r, s.x, s.y * 0.85, s.z);
+  }
+  return o.computeVertexNormals(), o;
+}
+const Fo = Ro(0.85, 1.7);
+function Vo(e) {
+  return new a.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: a.AdditiveBlending
+  });
+}
+const dt = /* @__PURE__ */ new Map();
+function _o(e) {
+  const n = dt.get(e);
+  if (n) return n;
+  const o = (s, r, i) => ({ geo: s, edges: new a.EdgesGeometry(s, 25), pos: r, rot: i });
+  let t;
+  switch (e) {
+    case "db":
+      t = [o(new a.CylinderGeometry(0.42, 0.42, 0.75, 28)), o(new a.TorusGeometry(0.42, 0.015, 6, 40), [0, 0.13, 0], [Math.PI / 2, 0, 0]), o(new a.TorusGeometry(0.42, 0.015, 6, 40), [0, -0.13, 0], [Math.PI / 2, 0, 0])];
+      break;
+    case "warehouse":
+      t = [-0.3, 0, 0.3].map((s) => o(new a.BoxGeometry(0.95, 0.2, 0.6), [0, s, 0]));
+      break;
+    case "spark": {
+      t = [{ geo: new a.SphereGeometry(0.18, 16, 12) }];
+      for (let s = 0; s < 6; s++) {
+        const r = s / 6 * Math.PI * 2;
+        t.push({ geo: new a.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":
+      t = [o(new a.TorusGeometry(0.4, 0.1, 10, 36))];
+      break;
+    case "storage":
+      t = [o(new a.BoxGeometry(0.7, 0.7, 0.7), void 0, [0.4, 0.6, 0])];
+      break;
+    case "queue":
+      t = [o(new a.CapsuleGeometry(0.2, 0.75, 6, 16), void 0, [0, 0, Math.PI / 2])];
+      break;
+  }
+  return dt.set(e, t), t;
+}
+function Tt(e, n) {
+  let o = null;
+  for (const t of R.mcpCalls) t.server === e && (n === void 0 || t.resource === n) && (!o || t.start > o.start) && (o = t);
+  return o;
+}
+function Bt(e, n, o, t, s, r, i) {
+  if (e.uTime.value = r, o < 1) {
+    const c = Xe(o);
+    e.uFlow.value = 0, e.uHead.value = 1 - c, e.uTail.value = 0.18, e.uHeadColor.value.copy(s).lerp(fe, 0.4).multiplyScalar(3), e.uOpacity.value = 0.9 * (1 - o * 0.5);
+  } else n ? (e.uFlow.value = 1, e.uFlowDir.value = 1, e.uHead.value = -1, e.uOpacity.value = 0.6) : (e.uFlow.value = t * 0.6, e.uFlowDir.value = 1, e.uHead.value = -1, e.uOpacity.value = i + t * 0.4);
+}
+function ko({ srv: e, res: n, k: o, n: t, arrows: s }) {
+  const r = z(() => Co(e.slot, o, t, new a.Vector3()), [e.slot, o, t]), i = z(() => nt(e.slot, new a.Vector3()), [e.slot]), c = z(() => _o(n.kind), [n.kind]), d = z(() => new a.Color(e.color).lerp(De, 0.2).lerp(fe, 0.25), [e.color]), h = z(() => (e.slot * 7 + o * 3) * 0.137, [e.slot, o]), u = z(() => {
+    const p = He(e.color, 0.1, 0.55, h, 0.3);
+    return p.uniforms.uP0.value.copy(i), p.uniforms.uP2.value.copy(r), p.uniforms.uP1.value.copy(i).add(r).multiplyScalar(0.5).setY(0.2), p.uniforms.uBeads.value = 4, { edge: p, fill: Oe(d), line: new a.LineBasicMaterial({ color: d, transparent: !0, blending: a.AdditiveBlending, depthWrite: !1, toneMapped: !1 }), halo: Te(d) };
+  }, [e.color, i, r, d, h]), f = B(null), w = B(null), M = B(null), m = B("");
+  return J(({ clock: p }) => {
+    var H;
+    const l = performance.now(), g = oe ? 0 : p.elapsedTime, y = n.inflight > 0, F = Math.exp(-((l - n.activeAt) / 1e3) * 1.5), S = y ? 0.5 + 0.5 * Math.sin(p.elapsedTime * 5) : 0, b = y ? 1.6 + S * 0.9 : 0.14 + F * 0.9;
+    u.fill.color.copy(d).multiplyScalar(b * 0.5), u.line.color.copy(d).multiplyScalar(b * 1.5), u.halo.color.copy(d).multiplyScalar(y ? 0.4 + S * 0.2 : 0.03 + F * 0.25), (H = w.current) == null || H.scale.setScalar(y ? 4 + S * 0.8 : 2.4 + F * 1.2), f.current && (f.current.scale.setScalar(y ? 1.18 + S * 0.08 : 1 + F * 0.1), f.current.rotation.y = n.kind === "spark" || n.kind === "api" ? g * (y ? 0.6 : 0.15) : Math.sin(g * 0.2 + h) * 0.3);
+    const K = Tt(e.name, n.name), k = K && K.phase === "result" ? (l - K.start) / K.dur : 9;
+    Bt(u.edge.uniforms, y, k, F, d, g, 0.22);
+    const L = u.edge.uniforms;
+    k < 1 ? s.add(L.uP0.value, L.uP1.value, L.uP2.value, L.uWob.value, h, 0.1, -1, 0.5, d, 2 * (1 - k * 0.7)) : y && s.add(L.uP0.value, L.uP1.value, L.uP2.value, L.uWob.value, h, 0.86, 1, 0.42, d, 1.2);
+    let W = n.name;
+    if (y) {
+      let O = "";
+      for (const I of R.mcpPending.values()) I.server === e.name && I.resource === n.name && (O = I.tool);
+      W = `${n.name} ▶ ${O || "query"}()`;
+    } else K && K.phase === "result" && l - K.start < 1800 && (W = `${n.name} ✓ returned`);
+    M.current && (W !== m.current && (M.current.setText(W), m.current = W), M.current.setOpacity(y ? 1 : 0.6 + F * 0.4), M.current.setEmphasis(y));
+  }), /* @__PURE__ */ N(ne, { children: [
+    /* @__PURE__ */ v("mesh", { geometry: Ne, material: u.edge, frustumCulled: !1 }),
+    /* @__PURE__ */ N("group", { position: r, children: [
+      /* @__PURE__ */ v("sprite", { ref: w, material: u.halo }),
+      /* @__PURE__ */ v("group", { ref: f, children: c.map((p, l) => /* @__PURE__ */ N("group", { position: p.pos, rotation: p.rot, children: [
+        /* @__PURE__ */ v("mesh", { geometry: p.geo, material: u.fill }),
+        p.edges && /* @__PURE__ */ v("lineSegments", { geometry: p.edges, material: u.line })
+      ] }, l)) }),
+      /* @__PURE__ */ v(Fe, { ref: M, position: [0, -0.95, 0], text: n.name, color: e.color, size: 0.2, opacity: 0.6, pxRange: [7.5, 11.5] })
+    ] })
+  ] });
+}
+function Oo({ srv: e, arrows: n }) {
+  const o = z(() => nt(e.slot, new a.Vector3()), [e.slot]), t = z(() => new a.Color(e.color).lerp(De, 0.15), [e.color]), s = z(() => e.slot * 0.31 + 0.2, [e.slot]), r = z(() => {
+    const w = He(t, 0.17, 0.5, s, 0.6), M = Math.hypot(o.x, o.z);
+    return w.uniforms.uP0.value.set(o.x / M * pe * 0.9, 0.08, o.z / M * pe * 0.9), w.uniforms.uP2.value.copy(o).setY(0.15), w.uniforms.uP1.value.copy(w.uniforms.uP0.value).add(w.uniforms.uP2.value).multiplyScalar(0.5).setY(0.1), w.uniforms.uBeads.value = 9, w.uniforms.uSpeed.value = 0.8, { body: Vo(t), core: Te(t), halo: Te(t), trunk: w };
+  }, [t, o, s]), i = B(null), c = B(null), [d, h] = Re([]), u = B(0), f = B(performance.now());
+  return J(({ clock: w }) => {
+    var S;
+    e.resources.size !== u.current && (u.current = e.resources.size, h([...e.resources.values()]));
+    const M = performance.now(), m = oe ? 0 : w.elapsedTime, p = e.inflight > 0, l = Math.exp(-((M - e.activeAt) / 1e3) * 1.5), g = 0.5 + 0.5 * Math.sin(w.elapsedTime * (p ? 4 : 1.2) + s * 5);
+    r.body.uniforms.uK.value = (p ? 1.1 + g * 0.4 : 0.5 + g * 0.1) + l * 0.5, r.core.color.copy(t).lerp(fe, 0.4).multiplyScalar((p ? 0.55 : 0.18) + l * 0.3), r.halo.color.copy(t).multiplyScalar((p ? 0.22 : 0.07) + l * 0.12), (S = c.current) == null || S.scale.setScalar(5.2 + (p ? g * 0.8 : 0)), i.current && (i.current.rotation.y = m * (p ? 0.5 : 0.1), i.current.scale.setScalar(ye((M - f.current) / 1200) * (1 + (p ? g * 0.06 : 0))));
+    const y = Tt(e.name), F = y && y.phase === "result" ? (M - y.start) / y.dur : 9;
+    Bt(r.trunk.uniforms, p, 9, l, t, m, 0.3), r.trunk.uniforms.uGrow.value = ye((M - f.current) / 2e3), F < 1 && (r.trunk.uniforms.uOpacity.value = 0.5 + (1 - F) * 0.4);
+  }), /* @__PURE__ */ N(ne, { children: [
+    /* @__PURE__ */ v("mesh", { geometry: Ne, material: r.trunk, frustumCulled: !1 }),
+    /* @__PURE__ */ N("group", { position: o, children: [
+      /* @__PURE__ */ v("sprite", { ref: c, material: r.halo }),
+      /* @__PURE__ */ N("group", { ref: i, children: [
+        /* @__PURE__ */ v("mesh", { geometry: Fo, material: r.body }),
+        /* @__PURE__ */ v("sprite", { material: r.core, scale: 1.6 })
+      ] }),
+      /* @__PURE__ */ v(Fe, { position: [0, 1.55, 0], text: `MCP · ${e.name}`, color: e.color, size: 0.28, pxRange: [9, 13] })
+    ] }),
+    d.map((w, M) => /* @__PURE__ */ v(ko, { srv: e, res: w, k: M, n: d.length, arrows: n }, w.name))
+  ] });
+}
+const Ue = 20;
+function Eo({ arrows: e }) {
+  const n = B([]), o = z(() => Array.from({ length: Ue }, (s, r) => He("#fff", 0.07, 0.6, r * 0.173, 0.45)), []), t = z(() => ({ col: new a.Color(), sp: new a.Vector3() }), []);
+  return J(({ clock: s }) => {
+    const r = performance.now(), i = oe ? 0 : s.elapsedTime;
+    let c = 0;
+    const d = (h, u, f, w) => {
+      if (c >= Ue) return;
+      const M = ge.get(h), m = R.mcpServers.get(u), p = n.current[c];
+      if (!M || !m || !p) return;
+      const l = o[c].uniforms;
+      nt(m.slot, t.sp), l.uP0.value.copy(M).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 g = l.uP0.value.distanceTo(l.uP2.value);
+      l.uBeads.value = g / 1.3, l.uTime.value = i, t.col.set(m.color), f === 0 ? (t.col.lerp(bt, re(w / 1.2)), w > 1.2 && t.col.lerp(St, re((w - 1.2) / 1.2)), l.uColor.value.copy(t.col), l.uGrow.value = ye(w / 0.45), l.uHead.value = w < 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, w * 0.15), e.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, w * 0.5))) : (t.col.lerp(fe, 0.3), l.uColor.value.copy(t.col), l.uGrow.value = 1, l.uFlow.value = 0, l.uHead.value = 1 - Xe(w / 0.8), l.uTail.value = 0.2, l.uHeadColor.value.copy(t.col).multiplyScalar(3.2), l.uOpacity.value = 0.7 * (1 - w), e.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 - w))), p.visible = !0, c++;
+    };
+    for (const h of R.mcpPending.values()) d(h.instance, h.server, 0, Ut(h, r));
+    for (const h of R.mcpCalls) h.phase === "result" && d(h.instance, h.server, 1, re((r - h.start) / h.dur));
+    for (let h = c; h < Ue; h++) {
+      const u = n.current[h];
+      u && (u.visible = !1);
+    }
+  }), /* @__PURE__ */ v(ne, { children: o.map((s, r) => /* @__PURE__ */ v("mesh", { ref: (i) => void (n.current[r] = i), geometry: Ne, material: s, frustumCulled: !1, visible: !1 }, r)) });
+}
+function Io() {
+  const [e, n] = Re([]), o = B(-1), t = z(() => new Le(64), []);
+  return J(() => {
+    R.mcpServers.size !== o.current && (o.current = R.mcpServers.size, n([...R.mcpServers.values()]));
+  }), /* @__PURE__ */ N(ne, { children: [
+    e.map((s) => /* @__PURE__ */ v(Oo, { srv: s, arrows: t }, s.name)),
+    /* @__PURE__ */ v(Eo, { arrows: t }),
+    /* @__PURE__ */ v(Lo, { arrows: t }),
+    /* @__PURE__ */ v("primitive", { object: t.mesh })
+  ] });
+}
+function Lo({ arrows: e }) {
+  return J(() => {
+    e.end(), e.begin();
+  }, 0.5), null;
+}
+const Be = 36, Wo = (
+  /* 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(${Be.toFixed(1)}, ${(Be * 0.55).toFixed(1)}, r);
+  gl_FragColor = vec4(col, edge);
+}`
+);
+function Do(e = 110, n = 9e3) {
+  let o = 1337;
+  const t = () => (o = o * 16807 % 2147483647) / 2147483647, s = [], r = [], i = [], c = [], d = [];
+  for (let f = 0; f < e; f++) {
+    const w = f / e * Math.PI * 2 + t() * 0.2, M = pe * (0.7 + t() * 0.3);
+    d.push({ x: Math.cos(w) * M, z: Math.sin(w) * M, h: w + (t() - 0.5) * 0.6, d: M, w: 1, sd: t(), life: 40 + t() * 60 });
+  }
+  let h = 0;
+  for (; d.length && h < n; ) {
+    const f = d.shift();
+    for (let w = 0; w < f.life && h < n; w++) {
+      const M = 0.32 + t() * 0.18, m = Math.atan2(f.z, f.x);
+      let p = f.h - m;
+      p = Math.atan2(Math.sin(p), Math.cos(p)), f.h += (t() - 0.5) * 0.55 - p * 0.05;
+      const l = f.x + Math.cos(f.h) * M, g = f.z + Math.sin(f.h) * M, y = f.d + M;
+      if (s.push(f.x, 0.02, f.z, l, 0.02, g), r.push(f.d, y), i.push(f.sd, f.sd), c.push(f.w, f.w), h++, f.x = l, f.z = g, f.d = y, Math.hypot(l, g) > Be * 0.8) break;
+      t() < 0.055 && f.w > 0.3 && d.push({ x: l, z: g, h: f.h + (t() < 0.5 ? 1 : -1) * (0.5 + t() * 0.6), d: y, w: f.w * 0.72, sd: t(), life: (f.life - w) * (0.5 + t() * 0.5) });
+    }
+  }
+  const u = new a.BufferGeometry();
+  return u.setAttribute("position", new a.Float32BufferAttribute(s, 3)), u.setAttribute("aDist", new a.Float32BufferAttribute(r, 1)), u.setAttribute("aSeed", new a.Float32BufferAttribute(i, 1)), u.setAttribute("aW", new a.Float32BufferAttribute(c, 1)), u.boundingSphere = new a.Sphere(new a.Vector3(), 1e4), u;
+}
+function Xo() {
+  const e = z(
+    () => new a.ShaderMaterial({
+      uniforms: { uTime: { value: 0 } },
+      vertexShader: (
+        /* glsl */
+        "varying vec2 vXZ; void main(){ vXZ = position.xz; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }"
+      ),
+      fragmentShader: Wo,
+      transparent: !0,
+      depthWrite: !1
+    }),
+    []
+  ), n = z(() => new a.CircleGeometry(Be, 96).rotateX(-Math.PI / 2), []), o = z(() => Do(), []), t = z(
+    () => new a.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(${(Be * 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: a.AdditiveBlending
+    }),
+    []
+  );
+  return J(({ clock: s }) => {
+    let r = 0;
+    for (const c of R.instances.values()) !c.exitAt && c.status === "thinking" && r++;
+    const i = t.uniforms;
+    i.uAct.value += (Math.min(1, r / 5) - i.uAct.value) * 0.03, i.uTime.value = oe ? 0 : s.elapsedTime;
+  }), /* @__PURE__ */ N(ne, { children: [
+    /* @__PURE__ */ v("mesh", { geometry: n, material: e, position: [0, -0.02, 0], renderOrder: -10 }),
+    /* @__PURE__ */ v("lineSegments", { geometry: o, material: t, frustumCulled: !1 })
+  ] });
+}
+const No = 260, _e = 40, Se = 20, je = 10, ke = 4;
+function Ho(e) {
+  const n = e.nodes.slice(0, No), o = new Set(n.map((t) => t.id));
+  return { nodes: n, links: e.links.filter((t) => o.has(t.source) && o.has(t.target)) };
+}
+const Yo = (e) => 0.42 * Math.max(0, 1 - (e / pe) ** 2) + 0.06, Ko = 64;
+function Uo({ galaxy: e }) {
+  const n = z(() => Ho(e), [e]), o = n.nodes.length, { size: t, gl: s, camera: r } = wt(), i = B([]), c = B([]), d = B(Array(ke).fill("")), h = B([]), u = z(() => {
+    const l = new Float32Array(o * 3), g = Math.PI * (3 - Math.sqrt(5));
+    let y = 91;
+    const F = () => (y = y * 16807 % 2147483647) / 2147483647;
+    for (let P = 0; P < o; P++) {
+      const A = pe * Math.sqrt((P + 0.5) / o) * (0.94 + F() * 0.08), G = P * g + (F() - 0.5) * 0.25;
+      l.set([Math.cos(G) * A, Yo(A) + (F() - 0.5) * 0.05, Math.sin(G) * A], P * 3);
+    }
+    const S = n.nodes.map((P, A) => new a.Color(jt[P.kind] ?? "#94a3b8").lerp(A % 3 ? Mt : De, 0.45).multiplyScalar(0.5)), b = new a.BufferGeometry();
+    b.setAttribute("position", new a.BufferAttribute(l, 3)), b.setAttribute("aSize", new a.BufferAttribute(new Float32Array(o), 1)), b.setAttribute("aColor", new a.BufferAttribute(new Float32Array(o * 3), 3));
+    const K = (P, A) => (l[P * 3] - l[A * 3]) ** 2 + (l[P * 3 + 2] - l[A * 3 + 2]) ** 2, k = [], L = /* @__PURE__ */ new Set(), W = (P, A, G) => {
+      const E = Math.min(P, A) * 4096 + Math.max(P, A);
+      P === A || L.has(E) || (L.add(E), k.push([P, A, G]));
+    }, H = new Map(n.nodes.map((P, A) => [P.id, A]));
+    for (const P of n.links) {
+      const A = H.get(P.source), G = H.get(P.target);
+      A !== void 0 && G !== void 0 && K(A, G) < 2.2 * 2.2 && W(A, G, 1);
+    }
+    for (let P = 0; P < o; P++) {
+      const A = [];
+      for (let G = 0; G < o; G++) G !== P && A.push([K(P, G), G]);
+      A.sort((G, E) => G[0] - E[0]);
+      for (let G = 0; G < 3 && G < A.length; G++) W(P, A[G][1], 0);
+    }
+    const O = 3, I = new Float32Array(k.length * O * 2 * 3), ae = new Float32Array(k.length * O * 2 * 3), Q = new Int32Array(k.length * 2), U = new Uint8Array(k.length);
+    k.forEach(([P, A, G], E) => {
+      Q[E * 2] = P, Q[E * 2 + 1] = A, U[E] = G;
+      for (let Y = 0; Y < O; Y++)
+        for (let x = 0; x < 2; x++) {
+          const C = (Y + x) / O, V = (E * O + Y) * 2 + x;
+          for (let T = 0; T < 3; T++) I[V * 3 + T] = l[P * 3 + T] * (1 - C) + l[A * 3 + T] * C;
+          I[V * 3 + 1] -= Math.sin(Math.PI * C) * 0.05;
+        }
+    });
+    const se = new a.BufferGeometry();
+    se.setAttribute("position", new a.BufferAttribute(I, 3)), se.setAttribute("color", new a.BufferAttribute(ae, 3));
+    const me = new a.BufferGeometry();
+    return me.setAttribute("position", new a.BufferAttribute(new Float32Array(_e * Se * 2 * 3), 3)), me.setAttribute("color", new a.BufferAttribute(new Float32Array(_e * Se * 2 * 3), 3)), me.boundingSphere = new a.Sphere(new a.Vector3(), 1e4), { pos: l, base: S, ngeo: b, ageo: se, bgeo: me, owner: Q, strong: U, nPairs: k.length, SEG: O, fire: new Float32Array(o), white: new Float32Array(o), fireC: Array.from({ length: o }, () => new a.Color()) };
+  }, [n, o]), f = z(
+    () => ({
+      nodes: zt(),
+      arcs: new a.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: a.AdditiveBlending, depthWrite: !1, toneMapped: !1 }),
+      beam: new a.LineBasicMaterial({ vertexColors: !0, transparent: !0, blending: a.AdditiveBlending, depthWrite: !1, toneMapped: !1 }),
+      pool: Qe(new a.Color("#7c3aed").multiplyScalar(0.55)),
+      core: Qe(new a.Color("#c4b5fd").multiplyScalar(0.25)),
+      ripple: Array.from({ length: je }, () => Oe("#ffffff"))
+    }),
+    []
+  ), w = z(() => /* @__PURE__ */ new Map(), [n]), M = z(() => new Le(_e), []), m = z(() => ({ v: new a.Vector3(), v2: new a.Vector3(), mid: new a.Vector3(), c: new a.Color(), c2: new a.Color() }), []), p = (l) => {
+    let g = w.get(l);
+    return g === void 0 && w.set(l, g = $t(n, l)), g;
+  };
+  return J(({ clock: l }) => {
+    const g = performance.now(), { pos: y, base: F, fire: S, white: b, fireC: K } = u;
+    f.nodes.uniforms.uScale.value = Gt(t.height, s.getPixelRatio(), r.fov), S.fill(0), b.fill(0);
+    const { v: k, v2: L, mid: W, c: H, c2: O } = m, I = u.bgeo.getAttribute("position"), ae = u.bgeo.getAttribute("color");
+    let Q = 0, U = 0;
+    M.begin();
+    const se = R.flares;
+    for (let x = Math.max(0, se.length - Ko); x < se.length; x++) {
+      const C = se[x], V = p(C.node), T = (g - C.start) / 1e3, de = R.instances.get(C.instance), $ = de ? Pe[de.type] : fe, D = C.op === "write", ee = T < 0.3 ? T / 0.3 : Math.exp(-(T - 0.3) * 1.3);
+      if (ee > S[V] && (S[V] = ee, K[V].copy(D ? fe : $), b[V] = D ? 1 : 0), D && T < 1.6 && U < je) {
+        const ie = h.current[U];
+        if (ie) {
+          ie.visible = !0, ie.position.set(y[V * 3], y[V * 3 + 1] + 0.02, y[V * 3 + 2]);
+          const we = T / 1.6;
+          ie.scale.setScalar(0.15 + we * 1.6), f.ripple[U].color.setScalar((1 - we) * (1 - we) * 0.9);
+        }
+        U++;
+      }
+      const X = ze.get(C.instance);
+      if (X && T < 2.2 && Q < _e) {
+        k.set(y[V * 3], y[V * 3 + 1], y[V * 3 + 2]), W.copy(X).add(k).multiplyScalar(0.5), W.y += 1.6;
+        const ie = Math.min(1, T / 0.25) * (1 - T / 2.2) ** 1.5, we = D ? Math.min(1, T * 0.9) : 1 - Math.min(1, T * 0.9);
+        for (let le = 0; le < Se; le++)
+          for (let ce = 0; ce < 2; ce++) {
+            const q = (le + ce) / Se, te = 1 - q;
+            L.set(te * te * X.x + 2 * te * q * W.x + q * q * k.x, te * te * X.y + 2 * te * q * W.y + q * q * k.y, te * te * X.z + 2 * te * q * W.z + q * q * k.z);
+            const _ = (Q * Se + le) * 2 + ce;
+            I.setXYZ(_, L.x, L.y, L.z);
+            const Z = Math.exp(-(((q - we) / 0.08) ** 2)) * 1.5;
+            O.copy(D ? fe : $).multiplyScalar(ie * ((D ? 0.35 : 0.16) + Z) * 0.8), ae.setXYZ(_, O.r, O.g, O.b);
+          }
+        D ? M.add(X, W, k, 0, 0, 0.9, 1, 0.34, fe, ie * 1.1) : M.add(X, W, k, 0, 0, 0.1, -1, 0.34, $, ie * 1.3), Q++;
+      }
+    }
+    for (let x = U; x < je; x++) {
+      const C = h.current[x];
+      C && (C.visible = !1);
+    }
+    u.bgeo.setDrawRange(0, Q * Se * 2), I.needsUpdate = !0, ae.needsUpdate = !0, M.end();
+    const me = oe ? 0 : l.elapsedTime, P = u.ngeo.getAttribute("aSize"), A = u.ngeo.getAttribute("aColor");
+    for (let x = 0; x < o; x++) {
+      const C = S[x], V = 0.85 + 0.15 * Math.sin(me * 0.8 + x * 1.7);
+      P.setX(x, 0.17 + C * (0.42 + b[x] * 0.22)), H.copy(F[x]).multiplyScalar(V), C > 0.01 && ct(ct(H, K[x], C * 1.7), fe, C * (0.25 + b[x] * 1.1)), A.setXYZ(x, H.r, H.g, H.b);
+    }
+    P.needsUpdate = !0, A.needsUpdate = !0;
+    const G = u.ageo.getAttribute("color"), E = u.SEG * 2;
+    for (let x = 0; x < u.nPairs; x++) {
+      const C = Math.max(S[u.owner[x * 2]], S[u.owner[x * 2 + 1]]), V = u.strong[x] ? 0.2 : 0.11, T = 0.55 * V + C * 0.35, de = 0.4 * V + C * 0.45, $ = 0.95 * V + C * 0.5;
+      for (let D = 0; D < E; D++) G.setXYZ(x * E + D, T, de, $);
+    }
+    G.needsUpdate = !0;
+    let Y = 0;
+    for (let x = R.flares.length - 1; x >= 0 && Y < ke; x--) {
+      const C = R.flares[x];
+      if (g - C.start > 2200) break;
+      let V = !1;
+      for (let ee = 0; ee < Y; ee++) d.current[ee] === C.node && (V = !0);
+      if (V) continue;
+      const T = p(C.node);
+      let de = !1;
+      for (let ee = 0; ee < Y; ee++) {
+        const X = c.current[ee];
+        X && Math.abs(X.position.z - y[T * 3 + 2]) < 0.9 && Math.abs(X.position.x - y[T * 3]) < 3.2 && (de = !0);
+      }
+      if (de) continue;
+      const $ = i.current[Y], D = c.current[Y];
+      $ && D && (D.position.set(y[T * 3], y[T * 3 + 1] + 0.35, y[T * 3 + 2]), d.current[Y] !== C.node && ($.setText(`${C.op === "write" ? "wrote" : "read"} · ${C.node}`), $.setColor(C.op === "write" ? "#ffffff" : "#5eead4")), $.setOpacity(1)), d.current[Y] = C.node, Y++;
+    }
+    for (let x = Y; x < ke; x++) {
+      const C = i.current[x];
+      C == null || C.setOpacity(0), d.current[x] = "";
+    }
+  }), /* @__PURE__ */ N(ne, { children: [
+    /* @__PURE__ */ v("mesh", { geometry: et, material: f.pool, scale: pe * 4.2, position: [0, 0.01, 0] }),
+    /* @__PURE__ */ v("mesh", { geometry: et, material: f.core, scale: pe * 1.8, position: [0, 0.03, 0] }),
+    /* @__PURE__ */ v("lineSegments", { geometry: u.ageo, material: f.arcs, frustumCulled: !1 }),
+    /* @__PURE__ */ v("points", { geometry: u.ngeo, material: f.nodes, frustumCulled: !1 }),
+    /* @__PURE__ */ v("lineSegments", { geometry: u.bgeo, material: f.beam, frustumCulled: !1 }),
+    /* @__PURE__ */ v("primitive", { object: M.mesh }),
+    f.ripple.map((l, g) => /* @__PURE__ */ v("mesh", { ref: (y) => void (h.current[g] = y), geometry: At, material: l, visible: !1 }, g)),
+    Array.from({ length: ke }, (l, g) => /* @__PURE__ */ v("group", { ref: (y) => void (c.current[g] = y), children: /* @__PURE__ */ v(Fe, { ref: (y) => void (i.current[g] = y), text: "", offset: [0, 0.34], size: 0.24, opacity: 0, fadeMs: 250, pxRange: [8, 12] }) }, g)),
+    /* @__PURE__ */ v(qt, { position: [0, 0.2, -pe - 0.7], suffix: " · mycelial mat", color: "#c084fc", size: 0.28, opacity: 0.75, pxRange: [8, 12] })
+  ] });
+}
+const Ge = /* @__PURE__ */ new Map(), jo = new a.Vector3(0, 1, 0), qe = new a.Vector3(), vt = new a.Vector3(), $e = [
+  // angle, distance (× size), scale (× size)
+  [2.2, 0.62, 0.26],
+  [3.6, 0.5, 0.18],
+  [4.9, 0.7, 0.21]
+];
+function qo({ inst: e, onSelect: n }) {
+  const o = B(null), t = B(null), s = B(null), r = B(null), i = B(null), c = B(null), d = B(null), h = B(null), u = B(null), f = B([]), w = z(() => he(e.id, 21), [e.id]), M = Pe[e.type], m = Zt(e), p = 1.75 * m, l = ot(e.run), g = z(() => Ct(e), [e, l]), y = B(null), F = z(() => -Math.atan2(g.z, g.x) + (he(e.id, 22) - 0.5) * 1.6, [g, e.id]), S = z(
+    () => ({
+      cap: wo(),
+      gill: yo(),
+      stem: Mo(),
+      pool: Qe("#000"),
+      halo: Te("#000"),
+      sel: Oe("#ffffff"),
+      arrow: Oe(M),
+      hypha: He(M, e.parent ? e.subagent ? 0.06 : 0.085 : 0.075, 0.42, w, 0.35)
+    }),
+    [M, e.parent, e.subagent, w]
+  );
+  S.cap.uniforms.uSpots.value = w * 10;
+  const b = z(() => ({ live: new a.Vector3(), c: new a.Color(), parentK: 0, ringK: 0, open: 0, curve: { p0: new a.Vector3(), p1: new a.Vector3(), p2: new a.Vector3(), wob: 0.35, seed: w }, p0set: !1 }), [w]);
+  Xt(() => (ze.set(e.id, b.live), Ge.set(e.id, b.curve), () => {
+    ze.get(e.id) === b.live && ze.delete(e.id), Ge.get(e.id) === b.curve && Ge.delete(e.id), tt.delete(e.id), window.setTimeout(() => !R.instances.has(e.id) && ge.delete(e.id), 0);
+  }), [e.id, b]), J(({ clock: H }) => {
+    var rt, st;
+    const O = performance.now(), I = oe ? 0 : H.elapsedTime, ae = (O - e.bornAt) / 1e3, Q = e.parent ? 0.9 : 0.75, U = ye(ae / Q), se = ye((ae - Q + 0.12) / 0.6), me = fo((ae - Q - 0.2) / 0.75), P = e.exitAt ? (O - e.exitAt) / 1e3 : -1, A = P >= 0 ? re(P / 2.2) : 0, G = Jt(e, O), E = Qt(e, O);
+    let Y = !1;
+    for (const j of R.mcpPending.values()) j.instance === e.id && (Y = !0);
+    const x = P < 0 && (e.status === "thinking" || e.status === "spawning"), C = 0.5 + 0.5 * Math.sin(I * 2.2 + w * 9), V = 0.5 + 0.5 * Math.sin(I * 0.9 + w * 5);
+    b.ringK += ((Y && P < 0 ? 1 : 0) - b.ringK) * 0.08, b.open += ((x ? 1 : 0) - b.open) * 0.05;
+    const T = Math.max(1e-3, p * se * (1 - A * 0.4)), de = oe ? 0 : Math.sin(I * 0.7 + w * 12) * 0.035, $ = 0.07 + w * 0.08 + de + A * A * 1.05, D = $ * m, ee = Math.atan(2 * $ * m / Math.max(T, 0.3));
+    t.current && (t.current.scale.set(m * (1 + E * 0.04), T, m * (1 + E * 0.04)), S.stem.uniforms.uBend.value = $);
+    const X = m * Math.max(1e-4, me) * (1 + E * 0.07 + (x ? C * 0.025 : V * 0.02));
+    s.current && (s.current.position.set(D, T - 0.05 * m, 0), s.current.rotation.z = -(ee + A * 0.75), s.current.scale.set(X * (0.94 + b.open * 0.08), X * (1.18 - b.open * 0.25) * (1 - A * 0.35), X * (0.94 + b.open * 0.08))), o.current && (o.current.rotation.y = F);
+    const ie = Math.cos(F), we = Math.sin(F), le = to();
+    (rt = y.current) == null || rt.scale.setScalar(le), b.live.set(g.x + D * ie * le, g.y + (T + 0.15 * X) * le, g.z - D * we * le), tt.set(e.id, X * le), b.c.copy(M), P >= 0 && b.c.lerp(e.status === "failed" ? St : uo, A * 0.85);
+    const ce = ((x ? 0.95 + C * 0.3 : 0.42 + V * 0.12) + E * 0.45) * (1 - A * 0.7);
+    S.cap.uniforms.uColor.value.copy(b.c), S.cap.uniforms.uGlow.value = ce, S.cap.uniforms.uOpacity.value = G, S.stem.uniforms.uColor.value.copy(b.c), S.stem.uniforms.uGlow.value = 0.55 + ce * 0.45, S.stem.uniforms.uOpacity.value = G, S.gill.uniforms.uColor.value.copy(b.c).lerp(bt, b.ringK * 0.75), S.gill.uniforms.uGlow.value = (ce * 1.1 + E * 0.9) * G, S.gill.uniforms.uTime.value = I, r.current && (r.current.scale.setScalar(Math.max(1e-4, m * (3.2 + ce * 1.2) * se)), S.pool.color.copy(b.c).multiplyScalar((0.06 + ce * 0.1 + E * 0.07) * G)), i.current && (i.current.position.copy(s.current ? s.current.position : i.current.position), i.current.scale.setScalar(Math.max(1e-4, X * (2.6 + E * 0.6))), S.halo.color.copy(b.c).multiplyScalar((x ? 0.13 : 0.05) * G + E * 0.05));
+    for (let j = 0; j < $e.length; j++) {
+      const be = f.current[j];
+      if (!be) continue;
+      const _t = $e[j][2] * m * ye((ae - Q - 0.6 - j * 0.25) / 0.8) * (1 - A * 0.6);
+      be.scale.setScalar(Math.max(1e-4, _t));
+    }
+    if (c.current) {
+      const j = R.selected === e.id;
+      c.current.visible = j, j && (c.current.scale.setScalar(m * (1.25 + 0.08 * Math.sin(I * 3))), S.sel.color.setScalar(0.7 * G));
+    }
+    h.current && h.current.position.set(D, T + X * 0.75 + 0.32, 0), (st = u.current) == null || st.setOpacity(eo(e.id) ? re(me) * (1 - A) * 0.95 : 0);
+    const q = e.parent ? R.instances.get(e.parent) : void 0, te = e.parent ? ge.get(e.parent) : void 0, _ = b.curve;
+    if (te && q) _.p0.copy(te);
+    else if (!b.p0set) {
+      const j = Math.hypot(g.x, g.z) || 1;
+      _.p0.set(g.x / j * pe * 0.92, 0.05, g.z / j * pe * 0.92);
+    }
+    b.p0set = !0, _.p2.copy(g), _.p1.copy(_.p0).add(_.p2).multiplyScalar(0.5), _.p1.y += 0.35;
+    const Z = S.hypha.uniforms;
+    Z.uP0.value.copy(_.p0), Z.uP1.value.copy(_.p1), Z.uP2.value.copy(_.p2);
+    const Ye = !!e.parent && !!q, Rt = Ye && !q.exitAt, at = P < 0 && (!e.parent || Rt) ? 1 : 0;
+    b.parentK += (at - b.parentK) * (at ? 0.08 : 0.035);
+    const Ft = P >= 0 ? Xe(P / 1.6) : 0;
+    Z.uGrow.value = U * (1 - Ft), Z.uHead.value = U < 1 ? U : -1, Z.uTail.value = 0.12, Z.uHeadColor.value.copy(M).multiplyScalar(2.2);
+    const Vt = _.p0.distanceTo(_.p2);
+    if (Z.uBeads.value = Math.max(2, Vt / 1.1), Z.uTime.value = I, Z.uFlow.value = U >= 1 ? b.parentK * (x ? 1 : 0.45) : 0, Z.uOpacity.value = (Ye ? x ? 0.85 : 0.55 : 0.38) * Math.max(b.parentK, U < 1 ? 1 : 0) + (U < 1 ? 0.3 : 0), d.current) {
+      const j = Ye && U >= 1 && b.parentK > 0.05 && Z.uGrow.value > 0.95;
+      if (d.current.visible = j, j) {
+        Ae(_.p0, _.p1, _.p2, _.wob, _.seed, 0.8, qe), Ae(_.p0, _.p1, _.p2, _.wob, _.seed, 0.83, vt), d.current.position.copy(qe), d.current.quaternion.setFromUnitVectors(jo, vt.sub(qe).normalize());
+        const be = e.subagent ? 0.8 : 1;
+        d.current.scale.set(0.13 * be, 0.36 * be, 0.13 * be), S.arrow.color.copy(M).multiplyScalar(1.5 * b.parentK);
+      }
+    }
+  });
+  const K = (H) => {
+    H.stopPropagation(), n(e.id);
+  }, k = () => document.body.style.cursor = "pointer", L = () => document.body.style.cursor = "", W = e.id.split(":")[2];
+  return /* @__PURE__ */ N(ne, { children: [
+    /* @__PURE__ */ v("mesh", { geometry: Ne, material: S.hypha, frustumCulled: !1 }),
+    /* @__PURE__ */ v("mesh", { ref: d, geometry: Pt, material: S.arrow, visible: !1 }),
+    /* @__PURE__ */ N("group", { ref: y, position: g, children: [
+      /* @__PURE__ */ v("mesh", { ref: r, geometry: et, material: S.pool, position: [0, 0.04, 0], scale: 1e-4 }),
+      /* @__PURE__ */ v("mesh", { ref: c, geometry: At, material: S.sel, position: [0, 0.06, 0], visible: !1 }),
+      /* @__PURE__ */ N("group", { ref: o, children: [
+        /* @__PURE__ */ v("mesh", { ref: t, geometry: ft, material: S.stem, scale: 1e-4, onClick: K, onPointerOver: k, onPointerOut: L }),
+        /* @__PURE__ */ N("group", { ref: s, scale: 1e-4, children: [
+          /* @__PURE__ */ v("mesh", { geometry: ut, material: S.cap, onClick: K, onPointerOver: k, onPointerOut: L }),
+          /* @__PURE__ */ v("mesh", { geometry: po, material: S.gill })
+        ] }),
+        /* @__PURE__ */ v("sprite", { ref: i, material: S.halo }),
+        !e.subagent && $e.map(([H, O], I) => /* @__PURE__ */ N("group", { ref: (ae) => void (f.current[I] = ae), position: [Math.cos(H) * O * m, 0, Math.sin(H) * O * m], scale: 1e-4, children: [
+          /* @__PURE__ */ v("mesh", { geometry: ft, material: S.stem, scale: [1, 1.5, 1] }),
+          /* @__PURE__ */ v("mesh", { geometry: ut, material: S.cap, position: [0.08, 1.45, 0], scale: [0.75, 0.95, 0.75] })
+        ] }, I)),
+        /* @__PURE__ */ v("group", { ref: h, children: /* @__PURE__ */ v(
+          Fe,
+          {
+            ref: u,
+            offset: [0, 0.22],
+            text: `${e.name}${W !== void 0 ? ` ${Number(W) + 1}` : ""}`,
+            color: yt[e.type],
+            size: e.subagent ? 0.22 : 0.28,
+            opacity: 0,
+            pxRange: e.subagent ? [8, 11.5] : [9, 13.5]
+          }
+        ) })
+      ] })
+    ] })
+  ] });
+}
+function $o({ onSelect: e }) {
+  const [n, o] = Re([]), t = B(/* @__PURE__ */ new Set()), s = B(-1);
+  return J(() => {
+    const r = R.instances;
+    let i = r.size !== t.current.size || s.current !== Me.version;
+    if (!i)
+      for (const c of r.keys()) t.current.has(c) || (i = !0);
+    i && (t.current = new Set(r.keys()), s.current = Me.version, o([...r.values()].filter(Je).sort((c, d) => c.bornAt - d.bornAt)));
+  }), /* @__PURE__ */ v(ne, { children: n.map((r) => /* @__PURE__ */ v(qo, { inst: r, onSelect: e }, r.id)) });
+}
+const Ze = 24, xe = 3;
+function Zo() {
+  const e = B([]), n = z(() => Array.from({ length: Ze * xe }, () => Te("#fff")), []), o = z(() => ({ a: new a.Vector3(), b: new a.Vector3(), c: new a.Vector3(), p: new a.Vector3(), col: new a.Color() }), []);
+  return J(() => {
+    const t = performance.now();
+    let s = 0;
+    for (const r of R.comets) {
+      if (s >= Ze) break;
+      const i = R.instances.get(r.from), c = R.instances.get(r.to), d = ge.get(r.from), h = ge.get(r.to);
+      if (!i || !c || !d || !h || !Je(i) || !Je(c)) continue;
+      const u = re((t - r.start) / r.dur);
+      if (u >= 1) continue;
+      let f, w = !0;
+      c.parent === r.from ? f = Ge.get(r.to) : i.parent === r.to && (f = Ge.get(r.from), w = !1), o.col.copy(Pe[i.type]).multiplyScalar(1.6).addScalar(0.25);
+      for (let M = 0; M < xe; M++) {
+        const m = e.current[s * xe + M];
+        if (!m) continue;
+        const p = re(Xe(u) - M * 0.035), l = w ? p : 1 - p;
+        f ? Ae(f.p0, f.p1, f.p2, f.wob, f.seed, l, o.p) : (o.c.copy(d).add(h).multiplyScalar(0.5), o.c.y += 2.4, Ae(d, o.c, h, 0, 0, l, o.p)), m.visible = !0, m.position.set(o.p.x, o.p.y + 0.12, o.p.z), m.scale.setScalar((M === 0 ? 1 : 0.7 - M * 0.15) * (0.6 + 0.4 * Math.sin(Math.PI * u))), n[s * xe + M].color.copy(o.col).multiplyScalar(M === 0 ? 1 : 0.5 / M);
+      }
+      s++;
+    }
+    for (let r = s * xe; r < Ze * xe; r++) {
+      const i = e.current[r];
+      i && (i.visible = !1);
+    }
+  }), /* @__PURE__ */ v(ne, { children: n.map((t, s) => /* @__PURE__ */ v("sprite", { ref: (r) => void (e.current[s] = r), material: t, visible: !1 }, s)) });
+}
+const Jo = new a.RingGeometry(0.88, 1.12, 160, 1).rotateX(-Math.PI / 2), ht = 3.7;
+function Qo(e) {
+  return new a.ShaderMaterial({
+    uniforms: { uColor: { value: e.clone() }, uK: { value: 0 }, uSweep: { value: 0 }, uStart: { value: 0 }, uSteps: { value: new a.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: a.AdditiveBlending
+  });
+}
+function en({ run: e }) {
+  const n = z(() => new a.Color(e.color), [e.color]), o = z(() => Qo(n), [n]), t = ot(e.id), s = z(() => pt(t, e.id, Ee + 1.2, new a.Vector3()).setY(0.05), [t, e.id]), r = z(() => {
+    const i = Ie(t, e.id), c = Math.sin(i) < 0;
+    return pt(t, e.id, Ee + 1.2 + ht + (c ? 1.9 : 0.7), new a.Vector3()).setY(0.3);
+  }, [t, e.id]);
+  return o.uniforms.uStart.value = Ie(t, e.id) + Math.PI * 0.5, J(({ clock: i }) => {
+    const c = performance.now(), d = oe ? 0 : i.elapsedTime, h = e.endedAt ? re(1 - (c - e.endedAt - (no - 2500)) / 2500) : 1, u = o.uniforms;
+    if (u.uSweep.value = ye((c - e.startedAt) / 1800), u.uK.value = 0.55 * h * (e.status === "started" ? 1 : 0.6), e.hasSteps) {
+      const f = (w) => w === "running" ? 1.5 + 0.5 * Math.sin(d * 3) : w === "done" ? 0.9 : w === "failed" ? 0.5 : 0.22;
+      u.uSteps.value.set(f(e.steps.plan), f(e.steps.research), f(e.steps.write));
+    } else u.uSteps.value.set(1, 1, 1);
+    u.uGaps.value = e.hasSteps ? 1 : 0;
+  }), /* @__PURE__ */ N(ne, { children: [
+    /* @__PURE__ */ v("mesh", { geometry: Jo, material: o, position: s, scale: ht }),
+    /* @__PURE__ */ v(tn, { run: e, pos: r })
+  ] });
+}
+function tn({ run: e, pos: n }) {
+  ao();
+  const o = e.status !== "started";
+  return /* @__PURE__ */ v(
+    Fe,
+    {
+      position: n,
+      text: e.topic,
+      secondary: ro(e, { base: "#a1a1c2", current: "#f5d0fe", done: "#cbd5e1" }, ["colony growing…", "colony complete"]),
+      color: e.color,
+      size: 0.34,
+      maxWidth: 9,
+      opacity: o ? 0.5 : 0.95,
+      fadeMs: 400,
+      pxRange: [10, 14.5]
+    }
+  );
+}
+function on() {
+  const [e, n] = Re([]), o = B(/* @__PURE__ */ new Set()), t = B(-1);
+  return J(() => {
+    const s = R.runs;
+    let r = s.size !== o.current.size || t.current !== Me.version;
+    if (!r)
+      for (const i of s.keys()) o.current.has(i) || (r = !0);
+    r && (o.current = new Set(s.keys()), t.current = Me.version, n([...s.values()].filter((i) => oo(i.id))));
+  }), /* @__PURE__ */ v(ne, { children: e.map((s) => /* @__PURE__ */ v(en, { run: s }, s.id)) });
+}
+const ue = 2600;
+function nn() {
+  const { size: e, gl: n, camera: o } = wt(), t = z(() => {
+    const i = new a.BufferGeometry(), c = new Float32Array(ue * 3);
+    return i.setAttribute("position", new a.BufferAttribute(c, 3)), i.setAttribute("aSize", new a.BufferAttribute(new Float32Array(ue), 1)), i.setAttribute("aColor", new a.BufferAttribute(new Float32Array(ue * 3), 3)), i.boundingSphere = new a.Sphere(new a.Vector3(), 1e4), {
+      geo: i,
+      pos: c,
+      vel: new Float32Array(ue * 3),
+      life: new Float32Array(ue),
+      // remaining seconds (<=0 = free)
+      max: new Float32Array(ue),
+      sz: new Float32Array(ue),
+      col: new Float32Array(ue * 3),
+      next: 0,
+      seenLlm: /* @__PURE__ */ new Map(),
+      seenExit: /* @__PURE__ */ new Set(),
+      acc: /* @__PURE__ */ new Map(),
+      c: new a.Color()
+    };
+  }, []), s = z(() => zt(), []), r = (i, c, d, h, u, f, w, M, m, p) => {
+    for (let l = 0; l < u; l++) {
+      const g = t.next;
+      t.next = (t.next + 1) % ue;
+      const y = Math.random() * Math.PI * 2, F = h * (0.2 + Math.random() * 0.75);
+      t.pos[g * 3] = i + Math.cos(y) * F, t.pos[g * 3 + 1] = c - 0.08, t.pos[g * 3 + 2] = d + Math.sin(y) * F;
+      const S = w * (0.4 + Math.random() * 0.8);
+      t.vel[g * 3] = Math.cos(y) * S, t.vel[g * 3 + 1] = p * (0.3 + Math.random() * 0.9) - 0.15, t.vel[g * 3 + 2] = Math.sin(y) * S, t.life[g] = t.max[g] = m * (0.6 + Math.random() * 0.6), t.sz[g] = f * (0.55 + Math.random() * 0.8);
+      const b = Math.random() * 0.45;
+      t.col[g * 3] = M.r * (1 - b) + b, t.col[g * 3 + 1] = M.g * (1 - b) + b, t.col[g * 3 + 2] = M.b * (1 - b) + b;
+    }
+  };
+  return J(({ clock: i }, c) => {
+    const d = Math.min(0.05, c);
+    s.uniforms.uScale.value = Gt(e.height, n.getPixelRatio(), o.fov);
+    for (const m of R.instances.values()) {
+      const p = ze.get(m.id), l = tt.get(m.id) ?? 0;
+      if (!p || l < 0.05) continue;
+      const g = t.seenLlm.get(m.id);
+      if (g === void 0) t.seenLlm.set(m.id, m.llmCalls);
+      else if (m.llmCalls !== g) {
+        t.seenLlm.set(m.id, m.llmCalls);
+        const y = m.pulse;
+        r(p.x, p.y, p.z, l, Math.round((oe ? 6 : 16) + y * (oe ? 8 : 34)), 0.12 + y * 0.09, 0.9 + y * 0.5, Pe[m.type], 2.6 + y * 0.5, 0.9);
+      }
+      if (m.exitAt)
+        t.seenExit.has(m.id) || (t.seenExit.add(m.id), t.c.copy(Pe[m.type]).multiplyScalar(0.45), r(p.x, p.y, p.z, l, oe ? 6 : 22, 0.1, 0.35, t.c, 2.2, -0.2));
+      else if (!oe && m.status === "thinking") {
+        const y = (t.acc.get(m.id) ?? 0) + d * 5 * (m.subagent ? 0.6 : 1);
+        y >= 1 && r(p.x, p.y, p.z, l, 1, 0.08, 0.25, t.c.copy(Pe[m.type]).lerp(fe, 0.2), 3.2, 0.7), t.acc.set(m.id, y % 1);
+      }
+    }
+    if (t.seenLlm.size > R.instances.size + 64)
+      for (const m of t.seenLlm.keys()) R.instances.has(m) || (t.seenLlm.delete(m), t.seenExit.delete(m), t.acc.delete(m));
+    const h = t.geo.getAttribute("position"), u = t.geo.getAttribute("aSize"), f = t.geo.getAttribute("aColor"), w = i.elapsedTime, M = Math.pow(0.35, d);
+    for (let m = 0; m < ue; m++) {
+      if (t.life[m] <= 0) {
+        u.array[m] !== 0 && u.setX(m, 0);
+        continue;
+      }
+      t.life[m] -= d;
+      const p = m * 3, l = t.pos[p], g = t.pos[p + 2];
+      t.vel[p] = t.vel[p] * M + Math.sin(g * 0.9 + w * 0.7) * 0.25 * d, t.vel[p + 1] = t.vel[p + 1] * M + 0.32 * d, t.vel[p + 2] = t.vel[p + 2] * M + Math.cos(l * 0.9 + w * 0.6) * 0.25 * d, t.pos[p] += t.vel[p] * d, t.pos[p + 1] += t.vel[p + 1] * d, t.pos[p + 2] += t.vel[p + 2] * d;
+      const y = t.life[m] / t.max[m], F = Math.min(1, (1 - y) * 8) * y;
+      h.setXYZ(m, t.pos[p], t.pos[p + 1], t.pos[p + 2]), u.setX(m, t.sz[m] * (0.6 + 0.4 * y)), f.setXYZ(m, t.col[p] * F * 1.3, t.col[p + 1] * F * 1.3, t.col[p + 2] * F * 1.3);
+    }
+    h.needsUpdate = !0, u.needsUpdate = !0, f.needsUpdate = !0;
+  }), /* @__PURE__ */ v("points", { geometry: t.geo, material: s, frustumCulled: !1 });
+}
+function an() {
+  return J(() => {
+    lo(), co();
+  }), null;
+}
+function rn({ children: e }) {
+  return /* @__PURE__ */ v("group", { position: [-1.6, 0, 0], children: e });
+}
+function vn() {
+  const e = so(), [n, o] = Re(null);
+  return /* @__PURE__ */ N("div", { className: "scene-root", style: { background: "#040309" }, children: [
+    /* @__PURE__ */ N(It, { camera: { position: [0, 34, 29], fov: 46 }, dpr: [1, 2], gl: { antialias: !1, powerPreference: "high-performance" }, onPointerMissed: () => o(null), children: [
+      /* @__PURE__ */ v("color", { attach: "background", args: ["#040309"] }),
+      /* @__PURE__ */ v("fog", { attach: "fog", args: ["#040309", 42, 78] }),
+      /* @__PURE__ */ v(an, {}),
+      /* @__PURE__ */ N(rn, { children: [
+        /* @__PURE__ */ v(Xo, {}),
+        /* @__PURE__ */ v(Uo, { galaxy: e }),
+        /* @__PURE__ */ v(on, {}),
+        /* @__PURE__ */ v($o, { onSelect: o }),
+        /* @__PURE__ */ v(Zo, {}),
+        /* @__PURE__ */ v(Io, {}),
+        /* @__PURE__ */ v(nn, {}),
+        /* @__PURE__ */ v(Bo, {})
+      ] }),
+      /* @__PURE__ */ v(Et, { makeDefault: !0, enablePan: !1, enableDamping: !0, dampingFactor: 0.06, minDistance: 12, maxDistance: 64, minPolarAngle: 0.25, maxPolarAngle: 1.38, target: [0, 0, 2.6] }),
+      /* @__PURE__ */ N(Lt, { multisampling: 0, children: [
+        /* @__PURE__ */ v(Wt, { mipmapBlur: !0, intensity: 1.15, luminanceThreshold: 0.18, luminanceSmoothing: 0.3, radius: 0.78 }),
+        /* @__PURE__ */ v(Dt, { eskil: !1, offset: 0.2, darkness: 0.92 })
+      ] })
+    ] }),
+    /* @__PURE__ */ v(
+      io,
+      {
+        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 at the heart is graph memory",
+        selected: n,
+        onClose: () => o(null)
+      }
+    )
+  ] });
+}
+export {
+  vn as default
+};