agentglow 0.4.1 → 0.4.3

package/dist/chunks/index-s99mYaJ9.js

@@ -0,0 +1,941 @@
+var Ge = Object.defineProperty;
+var ke = (t, e, s) => e in t ? Ge(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var k = (t, e, s) => ke(t, typeof e != "symbol" ? e + "" : e, s);
+import { jsxs as lt, Fragment as Kt, jsx as b } from "react/jsx-runtime";
+import { EffectComposer as Le, Bloom as Oe, Vignette as Ee } from "@react-three/postprocessing";
+import * as r from "three";
+import { useFrame as ht, useThree as Fe } from "@react-three/fiber";
+import { useMemo as D, useRef as I, useEffect as ce } from "react";
+import { T as le, h as et, f as Rt, K as je, w as L, F as qe, a as St, P as We, L as Bt, C as Ke, u as _e, A as st, d as ve, k as Ue, H as Ne, R as Xe, E as $e, W as He, e as Ze, s as Ye, j as Qe, n as Je, o as to, x as eo } from "./KitScene-DsZmpTf7.js";
+var Pe;
+const nt = typeof window < "u" && !!((Pe = window.matchMedia) != null && Pe.call(window, "(prefers-reduced-motion: reduce)").matches), rt = (t) => t < 0 ? 0 : t > 1 ? 1 : t, jt = (t) => 1 - Math.pow(1 - rt(t), 3), ne = (t) => (t = rt(t), t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2), pt = () => performance.now() / 1e3, N = new r.Color(1, 1, 1), X = new r.Color("#bff3ff");
+new r.Color("#2dd4bf");
+const Xt = new r.Color("#fbbf24"), _t = new r.Color("#ff3048"), It = Object.fromEntries(Object.entries(le).map(([t, e]) => [t, new r.Color(e).lerp(X, 0.38)])), oo = Object.fromEntries(Object.entries(le).map(([t, e]) => [t, new r.Color(e)]));
+let Dt = null;
+function no() {
+  if (Dt) return Dt;
+  const t = document.createElement("canvas");
+  t.width = t.height = 128;
+  const e = t.getContext("2d"), s = e.createRadialGradient(64, 64, 0, 64, 64, 64);
+  return s.addColorStop(0, "rgba(255,255,255,1)"), s.addColorStop(0.1, "rgba(255,255,255,0.7)"), s.addColorStop(0.35, "rgba(255,255,255,0.14)"), s.addColorStop(1, "rgba(255,255,255,0)"), e.fillStyle = s, e.fillRect(0, 0, 128, 128), Dt = new r.CanvasTexture(t), Dt.colorSpace = r.SRGBColorSpace, Dt;
+}
+function se(t = "#fff") {
+  return new r.SpriteMaterial({ map: no(), color: t, blending: r.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1 });
+}
+function so(t = "#fff") {
+  return new r.MeshBasicMaterial({ color: t, blending: r.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1, side: r.DoubleSide });
+}
+function ot(t) {
+  return new r.LineBasicMaterial({ color: t ?? "#fff", vertexColors: t === void 0, transparent: !0, blending: r.AdditiveBlending, depthWrite: !1, toneMapped: !1 });
+}
+const be = (() => {
+  const t = [];
+  for (let s = 0; s < 48; s++) {
+    const o = s / 48 * Math.PI * 2, d = (s + 0.55) / 48 * Math.PI * 2;
+    t.push(Math.cos(o), Math.sin(o), 0, Math.cos(d), Math.sin(d), 0);
+  }
+  return new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(t, 3));
+})(), ro = new r.SphereGeometry(1, 12, 8);
+function Ut(t, e, s, o, d) {
+  const c = 1 - o;
+  return d.set(c * c * t.x + 2 * c * o * e.x + o * o * s.x, c * c * t.y + 2 * c * o * e.y + o * o * s.y, c * c * t.z + 2 * c * o * e.z + o * o * s.z);
+}
+function qt(t, e, s, o) {
+  const d = e.x - t.x, c = e.y - t.y;
+  return o.copy(t).add(e).multiplyScalar(0.5), o.x += -c * s, o.y += d * s, o;
+}
+const ao = (
+  /* glsl */
+  `
+attribute vec4 aData; attribute vec3 aColor;
+uniform float uTime; uniform float uScale; uniform float uMinPx;
+varying vec3 vC; varying float vKind;
+void main(){
+  float age = uTime - aData.x;
+  float u = age / aData.y;
+  if (age < 0.0 || u >= 1.0) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; return; }
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  float kind = aData.w;
+  float sz; float a;
+  if (kind < 0.5) {
+    sz = aData.z * (0.6 + 0.4 * smoothstep(0.0, 0.08, u));
+    a = (1.0 - smoothstep(0.3, 1.0, u)) * (1.0 + 1.6 * exp(-age * 7.0));
+  } else if (kind < 1.5) {
+    sz = aData.z * (0.55 + 0.9 * sqrt(u));
+    a = (1.0 - u) * (1.0 - u);
+  } else {
+    sz = aData.z * (0.15 + 1.6 * sqrt(u));
+    a = (1.0 - u) * (1.0 - u) * 1.2;
+  }
+  vC = aColor * a; vKind = kind;
+  float px = sz * uScale / -mv.z;
+  // tiny far bubbles keep a readable dot (a little dimmer instead of vanishing)
+  if (kind < 0.5 && px < uMinPx) { vC *= 0.55 + 0.45 * px / uMinPx; px = uMinPx; }
+  gl_PointSize = clamp(px, 0.0, 256.0);
+  gl_Position = projectionMatrix * mv;
+}`
+), io = (
+  /* glsl */
+  `
+varying vec3 vC; varying float vKind;
+void main(){
+  vec2 p = gl_PointCoord - 0.5;
+  float r = length(p) * 2.0;
+  if (r > 1.0) discard;
+  float k;
+  if (vKind < 0.5) {
+    // a bubble: bright core with a faint refracting rim
+    k = smoothstep(1.0, 0.15, r) * 0.9 + smoothstep(0.55, 0.8, r) * smoothstep(1.0, 0.82, r) * 0.45;
+  } else if (vKind < 1.5) {
+    k = exp(-r * r * 9.0) * 1.5 + pow(1.0 - r, 3.0) * 0.4;
+  } else {
+    k = smoothstep(0.72, 0.9, r) * smoothstep(1.0, 0.92, r) * 1.6;
+  }
+  gl_FragColor = vec4(vC * k, 1.0);
+}`
+), co = 32768;
+class lo {
+  constructor(e = co) {
+    k(this, "geo", new r.BufferGeometry());
+    k(this, "mat", new r.ShaderMaterial({ uniforms: { uTime: { value: 0 }, uScale: { value: 400 }, uMinPx: { value: 2.4 } }, vertexShader: ao, fragmentShader: io, transparent: !0, depthWrite: !1, blending: r.AdditiveBlending }));
+    k(this, "obj");
+    k(this, "P");
+    k(this, "D");
+    k(this, "C");
+    k(this, "head", 0);
+    k(this, "lo", -1);
+    k(this, "n", 0);
+    this.max = e, this.P = new r.BufferAttribute(new Float32Array(e * 3), 3).setUsage(r.DynamicDrawUsage);
+    const s = new Float32Array(e * 4);
+    for (let o = 0; o < e; o++) s[o * 4 + 1] = 1e-3;
+    this.D = new r.BufferAttribute(s, 4).setUsage(r.DynamicDrawUsage), this.C = new r.BufferAttribute(new Float32Array(e * 3), 3).setUsage(r.DynamicDrawUsage), this.geo.setAttribute("position", this.P), this.geo.setAttribute("aData", this.D), this.geo.setAttribute("aColor", this.C), this.geo.boundingSphere = new r.Sphere(new r.Vector3(), 1e5), this.obj = new r.Points(this.geo, this.mat), this.obj.frustumCulled = !1, this.obj.renderOrder = 2;
+  }
+  /** one bubble/flash; `birth` in nowS() seconds (future = drawn later), colour premultiplied by `k` */
+  emit(e, s, o, d, c, a, l, f, u = 0) {
+    const i = this.head;
+    this.head = (i + 1) % this.max, this.lo < 0 && (this.lo = i), this.n++;
+    const p = this.P.array, h = this.D.array, m = this.C.array;
+    p[i * 3] = e, p[i * 3 + 1] = s, p[i * 3 + 2] = o, h[i * 4] = f, h[i * 4 + 1] = l, h[i * 4 + 2] = d, h[i * 4 + 3] = u, m[i * 3] = c.r * a, m[i * 3 + 1] = c.g * a, m[i * 3 + 2] = c.b * a;
+  }
+  /** upload the slots written since the last flush (one or two ranges) */
+  flush() {
+    if (this.lo < 0) return;
+    const e = [this.P, this.D, this.C];
+    for (const s of e) {
+      s.clearUpdateRanges();
+      const o = s.itemSize;
+      this.n >= this.max ? s.addUpdateRange(0, this.max * o) : this.lo + this.n <= this.max ? s.addUpdateRange(this.lo * o, this.n * o) : (s.addUpdateRange(this.lo * o, (this.max - this.lo) * o), s.addUpdateRange(0, (this.lo + this.n - this.max) * o)), s.needsUpdate = !0;
+    }
+    this.lo = -1, this.n = 0;
+  }
+  setScale(e, s, o) {
+    this.mat.uniforms.uScale.value = e * s / (2 * Math.tan(o * Math.PI / 360)), this.mat.uniforms.uMinPx.value = 2.4 * s;
+  }
+}
+let fo = null;
+const Z = () => fo ?? (fo = new lo());
+function re(t, e, s, o, d, c, a, l) {
+  const f = Z();
+  for (let u = 0; u < e; u++) {
+    const i = Math.random() * 2 - 1, p = Math.random() * Math.PI * 2, h = Math.sqrt(1 - i * i), m = s * Math.cbrt(Math.random());
+    f.emit(t.x + Math.cos(p) * h * m, t.y + Math.sin(p) * h * m, t.z + i * m, o * (0.7 + Math.random() * 0.7), d, c * (0.7 + Math.random() * 0.5), a * (0.8 + Math.random() * 0.4), l + Math.random() * 0.08, 0);
+  }
+}
+function Re(t, e, s, o, d, c, a, l, f, u, i, p = 0) {
+  const h = Z(), m = t.x + Math.cos(e + i * Math.PI * 0.5) * s, w = t.y + Math.sin(e + i * Math.PI * 0.5) * s, n = e - i * Math.PI * 0.5;
+  for (let y = 0; y < d; y++) {
+    const v = y / (d - 1), x = n + i * v * o * Math.PI * 2, B = s * (1 - 0.82 * v);
+    h.emit(m + Math.cos(x) * B, w + Math.sin(x) * B, t.z + p * Math.sqrt(v), c * (1 - 0.35 * v), a, l, f, u + v * 0.35, 0);
+  }
+}
+class Yt {
+  constructor(e, s = 32) {
+    k(this, "geo", new r.BufferGeometry());
+    k(this, "obj");
+    k(this, "P");
+    k(this, "C");
+    k(this, "n", 0);
+    k(this, "p", new r.Vector3());
+    this.max = e, this.seg = s, this.P = new r.BufferAttribute(new Float32Array(e * s * 6), 3).setUsage(r.DynamicDrawUsage), this.C = new r.BufferAttribute(new Float32Array(e * s * 6), 3).setUsage(r.DynamicDrawUsage), this.geo.setAttribute("position", this.P), this.geo.setAttribute("color", this.C), this.geo.boundingSphere = new r.Sphere(new r.Vector3(), 1e5), this.obj = new r.LineSegments(this.geo, ot()), this.obj.frustumCulled = !1;
+  }
+  begin() {
+    this.n = 0;
+  }
+  add(e, s, o, d, c, a, l, f, u, i, p) {
+    if (this.n >= this.max || l <= a || c < 3e-3 && p < 3e-3) return;
+    const h = this.seg, m = this.P, w = this.C;
+    for (let n = 0; n < h; n++) {
+      const y = a + (l - a) * (n + 0.5) / h;
+      let v = 1;
+      f > 0 && (v = Math.sin((y * f - u) * Math.PI * 2) > -0.1 ? 1 : 0);
+      for (let x = 0; x < 2; x++) {
+        const B = a + (l - a) * (n + x) / h;
+        Ut(e, s, o, B, this.p);
+        const A = (this.n * h + n) * 2 + x;
+        m.setXYZ(A, this.p.x, this.p.y, this.p.z);
+        let S = c * v;
+        i >= 0 && (S += p * Math.exp(-(((B - i) / 0.05) ** 2))), w.setXYZ(A, d.r * S, d.g * S, d.b * S);
+      }
+    }
+    this.n++;
+  }
+  end() {
+    this.geo.setDrawRange(0, this.n * this.seg * 2), this.P.needsUpdate = !0, this.C.needsUpdate = !0;
+  }
+}
+class fe {
+  constructor() {
+    k(this, "x", 0);
+    k(this, "y", 0);
+    k(this, "z", 0);
+    k(this, "acc", 0);
+    k(this, "started", !1);
+  }
+  reset() {
+    this.started = !1, this.acc = 0;
+  }
+  step(e, s, o, d, c, a, l, f = 8) {
+    if (!this.started) {
+      this.started = !0, this.x = e.x, this.y = e.y, this.z = e.z;
+      return;
+    }
+    const u = e.x - this.x, i = e.y - this.y, p = e.z - this.z, h = Math.sqrt(u * u + i * i + p * p);
+    if (h > s * 40) {
+      this.x = e.x, this.y = e.y, this.z = e.z, this.acc = 0;
+      return;
+    }
+    this.acc += h;
+    const m = Z();
+    let w = 0;
+    for (; this.acc >= s && w < f; ) {
+      this.acc -= s;
+      const n = h > 1e-6 ? 1 - this.acc / h : 1, y = (Math.random() - 0.5) * s * 0.35;
+      m.emit(this.x + u * n + y, this.y + i * n - y, this.z + p * n, o * (0.65 + Math.random() * 0.7), d, c * (0.75 + Math.random() * 0.4), a, l, 0), w++;
+    }
+    this.acc > s && (this.acc = s), this.x = e.x, this.y = e.y, this.z = e.z;
+  }
+}
+const Ht = /* @__PURE__ */ new Map();
+function te(t, e, s, o, d = performance.now()) {
+  let c = Ht.get(t);
+  c || Ht.set(t, c = { x: 0, y: 0, z: 0, at: -1e9 }), c.x = e, c.y = s, c.z = o, c.at = d;
+}
+const uo = (t) => t < 0 ? 0 : t < 50 ? t / 50 : Math.exp(-(t - 50) / 260), xt = /* @__PURE__ */ new Map(), R = { rx: 9, ry: 6, hz: 5 }, $t = /* @__PURE__ */ new Map();
+function ho(t, e) {
+  if (e < 2) return 0;
+  const s = Math.min(2 * (R.hz - 2.6), (e - 1) * 5);
+  return ((t % 2 === 0 ? t / 2 : e - 1 - (t - 1) / 2) / (e - 1) - 0.5) * s;
+}
+function Ie(t) {
+  var a;
+  const e = ((a = $t.get(t.run.id)) == null ? void 0 : a.z) ?? 0, s = et(t.id, 77) - 0.5, o = Math.max(t.inst.parent ? 2 : 1.2, R.hz * (t.inst.parent ? 0.34 + 0.05 * Math.min(2, t.depth - 1) : 0.14)), d = e + s * 2 * o * Math.max(0.85, Math.min(1.2, Rt.spread)), c = Math.max(0.5, R.hz - 1.1);
+  return d < -c ? -c : d > c ? c : d;
+}
+const zt = 7, Wt = 8, ue = 5, ft = 6.2, ut = 3.5, he = 0.08, Be = 0.92, Te = 0.52, po = 0.09, mo = 1.15, Et = Wt * ue, at = zt * Et, de = ft / Wt, pe = ut / ue, De = (zt - 1) / 2 * Be + ut / 2 * Math.sin(Te), Mo = Math.hypot(ft / 2 + 0.6, De + 0.4), go = 32, Nt = 3, Ve = new r.BoxGeometry(ft, he, ut), yo = new r.EdgesGeometry(Ve), wo = (() => {
+  const t = [], e = he / 2 + 4e-3;
+  for (let s = 1; s < Wt; s++) {
+    const o = -ft / 2 + s * de;
+    t.push(o, e, -ut / 2, o, e, ut / 2);
+  }
+  for (let s = 1; s < ue; s++) {
+    const o = -ut / 2 + s * pe;
+    t.push(-ft / 2, e, o, ft / 2, e, o);
+  }
+  return t.push(-ft / 2 + 0.15, e, ut / 2 - 0.14, -ft / 2 + 1.4, e, ut / 2 - 0.14), new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(t, 3));
+})(), vo = new r.PlaneGeometry(1, 1).rotateX(-Math.PI / 2), bo = (t, e, s) => {
+  e.set(0, (t - (zt - 1) / 2) * Be, 0), ze.set(Te, (t - (zt - 1) / 2) * po, 0, "YXZ"), s.setFromEuler(ze);
+}, xe = (t, e) => {
+  const s = t % Et;
+  return e.set(-ft / 2 + (s % Wt + 0.5) * de, he / 2 + 0.01, -ut / 2 + (Math.floor(s / Wt) + 0.5) * pe);
+}, ze = new r.Euler();
+function xo({ galaxy: t }) {
+  const e = t.nodes.length, s = D(() => {
+    const y = new Int32Array(e), v = new Float32Array(at), x = Array.from({ length: at }, () => new r.Color(0, 0, 0)), B = new r.Color();
+    t.nodes.forEach((A, S) => {
+      const z = Math.floor(et(A.id, 9) * at) % at;
+      y[S] = z, v[z]++, x[z].add(B.set(je[A.kind] ?? "#94a3b8"));
+    });
+    for (let A = 0; A < at; A++) v[A] && x[A].multiplyScalar(1 / v[A]).lerp(X, 0.35);
+    return { cellOf: y, occ: v, base: x, dep: new Float32Array(at), white: new Float32Array(at), depC: Array.from({ length: at }, () => new r.Color()) };
+  }, [t, e]), o = D(
+    () => Array.from({ length: zt }, () => ({
+      fill: so("#000"),
+      edge: ot("#000"),
+      grid: ot("#000"),
+      m: new r.Matrix4(),
+      pos: new r.Vector3(),
+      q: new r.Quaternion(),
+      slide: 0,
+      act: 0,
+      read: 0,
+      tint: new r.Color(),
+      want: new r.Color()
+    })),
+    []
+  ), d = I([]), c = D(() => new r.MeshBasicMaterial({ blending: r.AdditiveBlending, depthWrite: !1, transparent: !0, toneMapped: !1, side: r.DoubleSide }), []), a = D(() => {
+    const y = new r.InstancedMesh(vo, c, at);
+    return y.instanceColor = new r.InstancedBufferAttribute(new Float32Array(at * 3), 3), y.frustumCulled = !1, y.renderOrder = 3, y;
+  }, [c]), l = D(() => new Yt(go, 24), []), f = D(() => /* @__PURE__ */ new Map(), [t]), u = D(() => /* @__PURE__ */ new Set(), []), i = I([]), p = I([]), h = I(Array(Nt).fill("")), m = D(
+    () => ({ v: new r.Vector3(), w: new r.Vector3(), ctrl: new r.Vector3(), h: new r.Vector3(), c: new r.Color(), cm: new r.Matrix4(), sm: new r.Matrix4(), off: new r.Vector3(), one: new r.Vector3(1, 1, 1) }),
+    []
+  ), w = (y) => {
+    let v = f.get(y);
+    return v === void 0 && f.set(y, v = Ke(t, y)), s.cellOf[v] ?? 0;
+  }, n = (y, v) => xe(y, v).applyMatrix4(o[Math.floor(y / Et)].m);
+  return ht(({ clock: y }, v) => {
+    var H;
+    const x = performance.now(), B = pt(), A = Math.min(0.05, v), S = nt ? 0 : y.elapsedTime, { occ: z, base: C, dep: F, white: E, depC: T } = s, { v: V, w: G, ctrl: W, h: Y, c: $, cm: mt, sm: Mt, off: gt, one: Ct } = m;
+    F.fill(0), E.fill(0);
+    for (const g of o)
+      g.act = 0, g.read = 0, g.want.setRGB(0, 0, 0);
+    for (const g of L.flares) {
+      const M = w(g.node), P = (x - g.start) / 1e3, K = L.instances.get(g.instance), O = K ? It[K.type] : X, j = g.op === "write", U = P < 0.25 ? P / 0.25 : Math.exp(-(P - 0.25) * 1.1);
+      U > F[M] && (F[M] = U, T[M].copy(j ? N : O), E[M] = j ? 1 : 0);
+      const J = o[Math.floor(M / Et)];
+      U > J.act && (J.act = U, J.want.copy(j ? N : O)), !j && P < 2.2 && (J.read = Math.max(J.read, P < 0.2 ? P / 0.2 : rt((2.2 - P) / 0.8)));
+    }
+    for (let g = 0; g < zt; g++) {
+      const M = o[g];
+      M.slide += (M.read - M.slide) * Math.min(1, A * (M.read > M.slide ? 7 : 2.5)), bo(g, M.pos, M.q), gt.set(0, 0.06, mo).applyQuaternion(M.q).multiplyScalar(zo(M.slide)), M.pos.add(gt), M.m.compose(M.pos, M.q, Ct);
+      const P = d.current[g];
+      P && (P.position.copy(M.pos), P.quaternion.copy(M.q)), M.tint.lerp(M.act > 0.02 ? M.want : X, Math.min(1, A * 6));
+      const K = nt ? 1 : 0.9 + 0.1 * Math.sin(S * 0.7 + g * 1.3), O = M.act;
+      M.edge.color.copy(X).lerp(M.tint, O).multiplyScalar((0.2 + 0.06 * g / zt) * K + O * 0.75 + M.slide * 0.2), M.grid.color.copy(X).lerp(M.tint, O).multiplyScalar(0.06 + O * 0.18), M.fill.color.copy($.set("#4fd1c5")).lerp(M.tint, O * 0.8).multiplyScalar(0.03 + O * 0.06 + M.slide * 0.03);
+    }
+    l.begin();
+    for (const g of u) {
+      let M = !1;
+      for (const P of L.flares) P.id === g && (M = !0);
+      M || u.delete(g);
+    }
+    for (const g of L.flares) {
+      const M = w(g.node), P = (x - g.start) / 1e3, K = L.instances.get(g.instance), O = K ? It[K.type] : X, j = g.op === "write";
+      n(M, V), qe(V, G), j && !u.has(g.id) && P > 0.55 && (u.add(g.id), re(G, 12, 0.45, 0.1, N, 1, 2.2, B), Z().emit(G.x, G.y, G.z, 1.2, N, 0.9, 0.5, B, 2));
+      const U = St(g.instance);
+      if (U && P < 1.9) {
+        qt(U, G, 0.1, W);
+        const J = Math.min(1, P / 0.2) * Math.pow(1 - P / 1.9, 1.5), dt = j ? Math.min(1, P * 1.6) : 1 - Math.min(1, P * 1.6);
+        $.copy(j ? N : O).lerp(N, 0.2), l.add(U, W, G, $, (j ? 0.32 : 0.24) * J, 0.03, 0.99, 0, 0, dt, 1.5 * J), dt > 0.02 && dt < 0.98 && (Ut(U, W, G, dt, Y), Z().emit(Y.x, Y.y, Y.z, 0.45, $, 1.3 * J, 0.12, B, 1));
+      }
+    }
+    l.end();
+    const yt = a.instanceColor;
+    for (let g = 0; g < at; g++) {
+      const M = F[g], P = z[g] > 0, K = nt ? 1 : 0.85 + 0.15 * Math.sin(S * 0.8 + g * 1.7), O = P || M > 0.01 ? 0.36 + 0.12 * Math.min(1, z[g] / 3) + 0.4 * M : 1e-4;
+      xe(g, V), Mt.makeScale(O * de, 1, O * pe).setPosition(V), mt.multiplyMatrices(o[Math.floor(g / Et)].m, Mt), a.setMatrixAt(g, mt), $.copy(C[g]).multiplyScalar(P ? (0.3 + 0.15 * Math.min(1, z[g] / 3)) * K : 0), M > 0.01 && ($.r += T[g].r * M * 1.5 + M * 0.25 * (1 + E[g]), $.g += T[g].g * M * 1.5 + M * 0.25 * (1 + E[g]), $.b += T[g].b * M * 1.5 + M * 0.25 * (1 + E[g])), yt.setXYZ(g, $.r, $.g, $.b);
+    }
+    a.instanceMatrix.needsUpdate = !0, yt.needsUpdate = !0;
+    let Q = 0;
+    for (let g = L.flares.length - 1; g >= 0 && Q < Nt; g--) {
+      const M = L.flares[g];
+      if (x - M.start > 2200) break;
+      if (M.area) continue;
+      let P = !1;
+      n(w(M.node), V);
+      for (let j = 0; j < Q; j++) {
+        const U = p.current[j];
+        (h.current[j] === M.node || U && Math.abs(U.position.y - V.y) < 0.55 && Math.abs(U.position.x - V.x) < 3.2) && (P = !0);
+      }
+      if (P) continue;
+      const K = i.current[Q], O = p.current[Q];
+      K && O && (O.position.copy(V), h.current[Q] !== M.node && (K.setText(`${M.op === "write" ? "wrote" : "read"} · ${M.node}`), K.setColor(M.op === "write" ? "#ffffff" : "#8fe9f5")), K.setOpacity(rt(1.4 - (x - M.start) / 1600))), h.current[Q] = M.node, Q++;
+    }
+    for (let g = Q; g < Nt; g++)
+      (H = i.current[g]) == null || H.setOpacity(0), h.current[g] = "";
+  }), /* @__PURE__ */ lt(Kt, { children: [
+    o.map((y, v) => /* @__PURE__ */ lt("group", { ref: (x) => void (d.current[v] = x), children: [
+      /* @__PURE__ */ b("mesh", { geometry: Ve, material: y.fill }),
+      /* @__PURE__ */ b("lineSegments", { geometry: yo, material: y.edge }),
+      /* @__PURE__ */ b("lineSegments", { geometry: wo, material: y.grid })
+    ] }, v)),
+    /* @__PURE__ */ b("primitive", { object: a }),
+    /* @__PURE__ */ b(We, { children: /* @__PURE__ */ b("primitive", { object: l.obj }) }),
+    Array.from({ length: Nt }, (y, v) => /* @__PURE__ */ b("group", { ref: (x) => void (p.current[v] = x), children: /* @__PURE__ */ b(Bt, { ref: (x) => void (i.current[v] = x), text: "", offset: [0, 0.45], size: 0.24, opacity: 0, fadeMs: 250, pxRange: [8, 12] }) }, v)),
+    /* @__PURE__ */ b(So, {})
+  ] });
+}
+const zo = (t) => 1 - Math.pow(1 - rt(t), 2);
+function So() {
+  const t = _e(), e = t.graphLabel === "knowledge graph" ? "FalkorDB" : t.graphLabel;
+  return /* @__PURE__ */ b(
+    Bt,
+    {
+      declutter: "resource",
+      position: [0, De + 0.75, 0],
+      text: `${e} · event archive`,
+      color: "#5eead4",
+      letterSpacing: 0.04,
+      size: 0.28,
+      opacity: 0.85,
+      pxRange: [8, 12]
+    }
+  );
+}
+const Co = (
+  /* glsl */
+  "varying vec2 vW; void main(){ vW = position.xy; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }"
+), Ao = (
+  /* glsl */
+  `
+uniform float uTime; varying vec2 vW;
+float h(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+float n(vec2 p){ vec2 i = floor(p); vec2 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); }
+void main(){
+  float r = length(vW * vec2(0.85, 1.0));
+  // back-lit chamber: a soft cool glow in the middle, deep blue-black at the edges
+  vec3 col = mix(vec3(0.010, 0.030, 0.036), vec3(0.003, 0.007, 0.012), smoothstep(4.0, 46.0, r));
+  // emulsion: very low-frequency blotches
+  float b = n(vW * 0.07) * 0.6 + n(vW * 0.19 + 3.0) * 0.4;
+  col *= 0.8 + 0.45 * b;
+  // film grain (screen space, animated)
+  float g = h(gl_FragCoord.xy + fract(uTime * 7.31) * 113.0) - 0.5;
+  col += vec3(0.006, 0.011, 0.013) * g * 2.0;
+  gl_FragColor = vec4(col, 1.0);
+}`
+), Po = (
+  /* glsl */
+  `
+varying vec3 vN; varying vec3 vV; varying float vZ;
+void main(){
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  vN = normalize(normalMatrix * normal); vV = normalize(-mv.xyz); vZ = position.y;
+  gl_Position = projectionMatrix * mv;
+}`
+), _o = (
+  /* glsl */
+  `
+uniform vec3 uC; varying vec3 vN; varying vec3 vV; varying float vZ;
+void main(){
+  float f = 1.0 - abs(dot(normalize(vN), normalize(vV)));
+  float k = pow(f, 4.0) * 0.8 + 0.012;
+  // faint streaks along the axis (the steel staves' reflections in the glass)
+  k *= 0.85 + 0.15 * smoothstep(0.6, 1.0, abs(vZ));
+  gl_FragColor = vec4(uC * k, 1.0);
+}`
+), Ft = Math.PI * 2;
+function Ro() {
+  const t = (u, i, p, h = 128) => {
+    for (let m = 0; m < h; m++) {
+      const w = m / h * Ft, n = (m + 1) / h * Ft;
+      u.push(Math.cos(w) * i, Math.sin(w) * i, p, Math.cos(n) * i, Math.sin(n) * i, p);
+    }
+  }, e = [];
+  for (const u of [-1, 1])
+    t(e, 1, u), t(e, 1.045, u), t(e, 1.045, u * 0.97);
+  const s = [], o = 24;
+  for (let u = 0; u < o; u++) {
+    const i = u / o * Ft, p = Math.cos(i) * 1.045, h = Math.sin(i) * 1.045;
+    for (let m = 0; m < 40; m++) {
+      if (m % 2) continue;
+      const w = -1 + m / 40 * 2, n = -1 + (m + 1) / 40 * 2;
+      s.push(p, h, w, p, h, n);
+    }
+  }
+  for (const u of [-0.34, 0.34]) t(s, 1.045, u, 96);
+  const d = [];
+  for (const u of [-0.72, 0.72]) for (let i = 0; i < 4; i++) t(d, 1.1 + i % 2 * 0.025, u + (i - 1.5) * 0.035, 128);
+  const c = [];
+  let a = 9001;
+  const l = () => (a = a * 16807 % 2147483647) / 2147483647;
+  for (let u = 0; u < 14; u++) {
+    const i = -0.85 + l() * 1.7, p = -0.92 + l() * 1.84, h = (6 + l() * 14) * (l() < 0.5 ? 1 : -1), m = 0.012;
+    for (let w = -1.1; w < 1.1; w += m) {
+      if (l() < 0.42) continue;
+      const n = w + m * 0.45, y = i + w * w / (2 * h), v = i + n * n / (2 * h);
+      w * w + y * y > 0.97 || n * n + v * v > 0.97 || c.push(w, y, p, n, v, p);
+    }
+  }
+  const f = (u) => new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(u, 3));
+  return { steel: f(e), staves: f(s), coils: f(d), beams: f(c) };
+}
+function Io(t, e) {
+  const s = [];
+  for (let c = -Math.floor(t / 3) * 3; c <= t; c += 3)
+    for (let a = -Math.floor(e / 3) * 3; a <= e; a += 3)
+      if (!((c / t) ** 2 + (a / e) ** 2 > 0.86))
+        for (const l of [-1, 1]) s.push(c - 0.26, a, l, c + 0.26, a, l, c, a - 0.26, l, c, a + 0.26, l);
+  return new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(s, 3));
+}
+const Bo = (() => {
+  const t = [];
+  for (let e = 0; e < 24; e++) e % 2 === 0 && t.push(0, 0, -1 + e / 24 * 2, 0, 0, -1 + (e + 1) / 24 * 2);
+  return t.push(0, 0, 1, 0.09, 0, 0.84, 0, 0, 1, -0.09, 0, 0.84, 0, 0, 1, 0, 0.09, 0.84, 0, 0, 1, 0, -0.09, 0.84), new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(t, 3));
+})();
+function To() {
+  const t = D(Ro, []), e = D(
+    () => ({
+      back: new r.ShaderMaterial({ uniforms: { uTime: { value: 0 } }, vertexShader: Co, fragmentShader: Ao, depthWrite: !1 }),
+      steel: ot(new r.Color("#9fd8e0").multiplyScalar(0.15)),
+      staves: ot(new r.Color("#7cc6d0").multiplyScalar(0.07)),
+      coils: ot(new r.Color("#d79a52").multiplyScalar(0.12)),
+      beams: ot(new r.Color("#8fdcea").multiplyScalar(0.07)),
+      fid: ot(new r.Color("#4fd1c5").multiplyScalar(0.22)),
+      arrow: ot(new r.Color("#d79a52").multiplyScalar(0.45)),
+      glass: new r.ShaderMaterial({
+        uniforms: { uC: { value: new r.Color("#6fd3e0").multiplyScalar(0.075) } },
+        vertexShader: Po,
+        fragmentShader: _o,
+        transparent: !0,
+        depthWrite: !1,
+        blending: r.AdditiveBlending,
+        side: r.DoubleSide
+      })
+    }),
+    []
+  ), s = D(() => new r.CylinderGeometry(1.045, 1.045, 2, 96, 1, !0).rotateX(Math.PI / 2), []), o = I(null), d = I(null), c = I("");
+  ce(() => () => {
+    var m;
+    return (m = o.current) == null ? void 0 : m.dispose();
+  }, []);
+  const a = I(0), l = I(null), f = I(null), u = I(null), i = I(null), p = I(null), h = I(!1);
+  return ht(({ clock: m, camera: w }, n) => {
+    var V, G, W, Y;
+    e.back.uniforms.uTime.value = nt ? 0 : m.elapsedTime, l.current && (w.getWorldDirection(Ce), l.current.position.copy(Ce).multiplyScalar(14), l.current.quaternion.copy(w.quaternion));
+    const y = st.core, v = y.hw + 0.9, x = y.hh + 0.9, B = r.MathUtils.clamp(0.72 * Math.min(v, x), 5, 13), A = h.current ? Math.min(1, n * 2.5) : 1;
+    h.current = !0, R.rx += (v - R.rx) * A, R.ry += (x - R.ry) * A, R.hz += (B - R.hz) * A, (V = f.current) == null || V.scale.set(R.rx, R.ry, R.hz), (G = u.current) == null || G.scale.set(1, 1, R.hz);
+    const S = `${Math.round(R.rx * 2)}:${Math.round(R.ry * 2)}`;
+    S !== c.current && d.current && (c.current = S, (W = o.current) == null || W.dispose(), o.current = Io(R.rx, R.ry), d.current.geometry = o.current), i.current && (i.current.position.set(0, R.ry * 1.13 + 0.25, 0), i.current.scale.set(1, 1, R.hz * 0.55)), (Y = p.current) == null || Y.position.set(0, R.ry * 1.13 + 0.62, R.hz * 0.55);
+    const z = pt();
+    if (nt || z < a.current) return;
+    a.current = z + 1.4 + Math.random() * 2.2;
+    const C = Math.random() * Ft, F = Math.sqrt(Math.random()) * 0.85;
+    Se.set(Math.cos(C) * F * R.rx, Math.sin(C) * F * R.ry, (Math.random() - 0.5) * 1.7 * R.hz);
+    const E = Math.random() < 0.3, T = Math.random() < 0.5 ? 1 : -1;
+    Re(Se, Math.random() * Ft, E ? 0.9 + Math.random() * 0.8 : 0.3 + Math.random() * 0.4, E ? 2.4 : 1.6, E ? 70 : 30, 0.075, X, 0.3, 6, z, T, T * (E ? 1.4 : 0.6));
+  }), /* @__PURE__ */ lt(Kt, { children: [
+    /* @__PURE__ */ b("mesh", { ref: l, material: e.back, position: [0, 0, -14], renderOrder: -10, frustumCulled: !1, children: /* @__PURE__ */ b("planeGeometry", { args: [700, 500] }) }),
+    /* @__PURE__ */ lt("group", { ref: f, children: [
+      /* @__PURE__ */ b("mesh", { geometry: s, material: e.glass, renderOrder: -5, frustumCulled: !1 }),
+      /* @__PURE__ */ b("lineSegments", { geometry: t.steel, material: e.steel, frustumCulled: !1 }),
+      /* @__PURE__ */ b("lineSegments", { geometry: t.staves, material: e.staves, frustumCulled: !1 }),
+      /* @__PURE__ */ b("lineSegments", { geometry: t.coils, material: e.coils, frustumCulled: !1 }),
+      /* @__PURE__ */ b("lineSegments", { geometry: t.beams, material: e.beams, frustumCulled: !1 })
+    ] }),
+    /* @__PURE__ */ b("group", { ref: u, children: /* @__PURE__ */ b("lineSegments", { ref: d, material: e.fid, frustumCulled: !1 }) }),
+    /* @__PURE__ */ b("group", { ref: i, children: /* @__PURE__ */ b("lineSegments", { geometry: Bo, material: e.arrow, frustumCulled: !1 }) }),
+    /* @__PURE__ */ b("group", { ref: p, children: /* @__PURE__ */ b(Bt, { text: "B field", color: "#e0a868", size: 0.26, plate: "none", opacity: 0.75, pxRange: [9, 12] }) })
+  ] });
+}
+const Se = new r.Vector3(), Ce = new r.Vector3();
+function Do() {
+  const { size: t, gl: e, camera: s } = Fe(), o = D(() => Z(), []);
+  return ht(() => {
+    o.flush(), o.mat.uniforms.uTime.value = pt(), o.setScale(t.height, e.getPixelRatio(), s.fov);
+  }, -1), /* @__PURE__ */ b("primitive", { object: o.obj });
+}
+const Zt = 0.34, tt = 2.1, ae = 12;
+(() => {
+  const t = [], e = (s, o, d, c) => t.push(s, o, 0, d, c, 0);
+  for (const s of [-0.28, 0.28]) {
+    const o = s - Zt / 2, d = s + Zt / 2;
+    e(o, -tt / 2, d, -tt / 2), e(d, -tt / 2, d, tt / 2), e(d, tt / 2, o, tt / 2), e(o, tt / 2, o, -tt / 2);
+    for (let c = 1; c < ae; c++) {
+      const a = -tt / 2 + c / ae * tt;
+      e(o, a, d, a);
+    }
+  }
+  return new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(t, 3));
+})();
+new r.PlaneGeometry(Zt, tt);
+new r.PlaneGeometry(Zt * 0.92, tt / ae * 0.8);
+(() => {
+  const t = [];
+  for (let e = 0; e < 6; e++) {
+    const s = e / 6 * Math.PI * 2 + Math.PI / 6, o = (e + 1) / 6 * Math.PI * 2 + Math.PI / 6;
+    t.push(Math.cos(s), Math.sin(s), 0, Math.cos(o), Math.sin(o), 0), t.push(Math.cos(s) * 0.62, Math.sin(s) * 0.62, 0, Math.cos(o) * 0.62, Math.sin(o) * 0.62, 0);
+  }
+  return new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(t, 3));
+})();
+new r.CircleGeometry(1, 6, Math.PI / 6);
+const Vo = 48, Vt = new r.Vector3(), Gt = new r.Vector3(), wt = new r.Color();
+function Go() {
+  const t = D(() => new Yt(Vo, 36), []), e = D(() => /* @__PURE__ */ new Map(), []);
+  return ht(({ clock: s }) => {
+    const o = performance.now(), d = pt(), c = nt ? 0 : s.elapsedTime;
+    t.begin();
+    for (const a of L.mcpPending.values()) {
+      const l = St(a.instance), f = ve(a.server), u = L.mcpServers.get(a.server);
+      if (!l || !f || !u) continue;
+      qt(l, f, 0.12, Vt);
+      const i = Ue(a, o);
+      wt.set(u.color).lerp(Xt, rt(i / 1.2)), i > 1.2 && wt.lerp(_t, rt((i - 1.2) / 1));
+      const p = l.distanceTo(f), h = 0.04 + 0.92 * jt(i / 0.45);
+      t.add(l, Vt, f, wt, (0.3 + Math.min(0.3, i * 0.12)) * jt(i / 0.3), 0.04, h, Math.max(4, Math.round(p / 0.5)), c * 1.4, i < 0.45 ? h : -1, 1);
+    }
+    for (const a of e.keys()) {
+      let l = !1;
+      for (const f of L.mcpCalls) f.id === a && (l = !0);
+      l || e.delete(a);
+    }
+    for (const a of L.mcpCalls) {
+      if (a.phase !== "result") continue;
+      const l = rt((o - a.start) / a.dur);
+      if (l >= 1) continue;
+      const f = St(a.instance), u = ve(a.server), i = L.mcpServers.get(a.server);
+      if (!f || !u || !i) continue;
+      let p = e.get(a.id);
+      p || e.set(a.id, p = new fe()), qt(f, u, 0.12, Vt);
+      const h = ne(l);
+      Ut(f, Vt, u, 1 - h, Gt), wt.set(i.color).lerp(N, 0.45);
+      const m = 1 - Math.max(0, (h - 0.85) / 0.15);
+      t.add(f, Vt, u, wt, 0.1 * m, 0.04, 0.96, 0, 0, 1 - h, 1.3 * m), p.step(Gt, 0.065, 0.08, wt, 0.95 * m, 2.6, d, 6), Z().emit(Gt.x, Gt.y, Gt.z, 0.5, wt, 1.3 * m, 0.12, d, 1);
+    }
+    t.end();
+  }), /* @__PURE__ */ b("primitive", { object: t.obj });
+}
+const ko = (() => {
+  const t = [];
+  for (let e = 0; e < 4; e++) {
+    const s = Math.PI / 4 + e * Math.PI / 2;
+    t.push(Math.cos(s) * 0.22, Math.sin(s) * 0.22, 0, Math.cos(s) * 0.55, Math.sin(s) * 0.55, 0);
+  }
+  return new r.BufferGeometry().setAttribute("position", new r.Float32BufferAttribute(t, 3));
+})(), Lo = new r.Vector3(1, 0.07, 0).normalize(), ee = new r.Vector3(), Oo = new r.Vector3();
+function Eo(t, e, s, o) {
+  const d = Z(), c = pt();
+  d.emit(t.x, t.y, t.z, 1.6 * o, N, 1.4, 0.6, c, 1), d.emit(t.x, t.y, t.z, 3.2 * o, s, 1, 0.9, c, 2);
+  const a = 5 + Math.floor(et(e, 41) * 3);
+  for (let l = 0; l < a; l++) {
+    const f = l / a * Math.PI * 2 + et(e, 50 + l) * 0.9, u = (1.2 + et(e, 60 + l) * 4) * o, i = (1.1 + et(e, 70 + l) * 1.8) * o, p = et(e, 80 + l) < 0.5 ? 1 : -1, h = (et(e, 90 + l) - 0.5) * 1.6, m = Math.max(6, Math.round(i / (0.075 * o))), w = t.x + Math.cos(f + p * Math.PI * 0.5) * u, n = t.y + Math.sin(f + p * Math.PI * 0.5) * u, y = f - p * Math.PI * 0.5;
+    for (let v = 1; v <= m; v++) {
+      const x = v / m * i, B = y + p * x / u;
+      d.emit(w + Math.cos(B) * u, n + Math.sin(B) * u, t.z + x * h, 0.085 * o * (0.7 + Math.random() * 0.6), s, 0.85, 5, c + x / (7 * o), 0);
+    }
+  }
+}
+function Fo({ run: t }) {
+  const e = D(() => new r.Color(t.color).lerp(X, 0.35), [t.color]), s = D(() => se("#000"), []), o = D(() => ot("#000"), []), d = I(null), c = D(() => new Yt(1, 64), []), a = I(null), l = I(null), f = D(() => ({ p: new r.Vector3(), fired: !1, init: !1, dep: { z: 0, tz: 0 } }), []);
+  return ce(() => (xt.set(t.id, f.p), $t.set(t.id, f.dep), () => {
+    xt.get(t.id) === f.p && xt.delete(t.id), $t.get(t.id) === f.dep && $t.delete(t.id);
+  }), [t.id, f]), ht(({ clock: u, camera: i }, p) => {
+    var G;
+    const h = performance.now(), m = t.run ?? L.runs.get(t.id);
+    let w = 0, n = 0, y = 1e9;
+    for (const W of st.agents.values())
+      W.run !== t || W.inst.parent || (w += W.eu, n++, W.ev < y && (y = W.ev));
+    const v = n ? w / n : t.cu, x = (n ? y : t.cv - t.hv) - 1.55 * Rt.spread;
+    Ne(t, v, x, f.p), f.dep.tz = ho(t.index, t.count), f.dep.z = f.init ? f.dep.z + (f.dep.tz - f.dep.z) * Math.min(1, Math.min(0.05, p) * 1.2) : f.dep.tz, f.p.z = f.dep.z, f.init = !0;
+    const B = m ? (h - m.startedAt) / 1e3 : 99;
+    f.fired || (f.fired = !0, B < 1.2 && Eo(f.p, t.id, e, Math.max(0.6, Rt.scale)));
+    const A = jt(B / 0.8), S = m ? m.status !== "started" : !1, z = m != null && m.endedAt ? rt(1 - (h - m.endedAt - (Xe - 2500)) / 2500) : 1, C = nt || S ? 1 : 0.85 + 0.15 * Math.sin(u.elapsedTime * 2.2 + t.index);
+    a.current && (a.current.position.copy(f.p), a.current.scale.setScalar((0.9 + (S ? 0 : 0.25)) * Math.max(0.7, Rt.scale))), d.current && (d.current.position.copy(f.p), d.current.quaternion.copy(i.quaternion), d.current.scale.setScalar(Math.max(0.7, Rt.scale))), o.color.copy(e).lerp(N, 0.3).multiplyScalar((S ? 0.3 : 0.75) * A * z), s.color.copy(e).lerp(N, 0.4).multiplyScalar((S ? 0.35 : 0.8) * C * A * z), c.begin();
+    const F = 7 + st.core.hw * 0.6;
+    ee.copy(f.p).addScaledVector(Lo, -F);
+    const E = Oo.copy(ee).add(f.p).multiplyScalar(0.5);
+    c.add(ee, E, f.p, e, 0.16 * A * z * (S ? 0.6 : 1), 0, 0.985 * A, Math.round(F / 0.16), 0, 1, 0.35 * z), c.end();
+    const T = Math.abs(t.side.y) * t.hu + Math.abs(t.axis.y) * t.hv, V = Math.max(t.origin.y + T, f.p.y + 0.4);
+    (G = l.current) == null || G.position.set(t.origin.x, V + 0.75, f.p.z);
+  }), /* @__PURE__ */ lt(Kt, { children: [
+    /* @__PURE__ */ b("primitive", { object: c.obj }),
+    /* @__PURE__ */ b("sprite", { ref: a, material: s }),
+    /* @__PURE__ */ b("lineSegments", { ref: d, geometry: ko, material: o }),
+    /* @__PURE__ */ b("group", { ref: l, children: t.run && /* @__PURE__ */ b(jo, { run: t.run }) })
+  ] });
+}
+function jo({ run: t }) {
+  _e();
+  const e = t.status !== "started";
+  return /* @__PURE__ */ b(
+    Bt,
+    {
+      text: t.topic,
+      secondary: $e(t, { base: "#8fb3bd", current: "#fde68a", done: "#cfe9ee" }, ["running…", "run complete"]),
+      color: t.color,
+      textColor: "#e3fbff",
+      plate: "none",
+      anchorY: "bottom",
+      uppercase: !0,
+      letterSpacing: 0.12,
+      size: 0.34,
+      maxWidth: 11,
+      opacity: e ? 0.5 : 0.92,
+      fadeMs: 600,
+      pxRange: [10, 14],
+      glow: 1.1
+    }
+  );
+}
+const oe = 4;
+function qo() {
+  const t = I(/* @__PURE__ */ new Set()), e = I([]), s = I([]), o = I([]), d = I([]);
+  return ht(() => {
+    const c = performance.now();
+    for (const a of L.runs.values()) {
+      if (!a.final || t.current.has(a.id)) continue;
+      t.current.add(a.id);
+      const l = st.runs.get(a.id);
+      if (!l) continue;
+      let f;
+      for (const z of L.instances.values()) z.run === a.id && !z.parent && (f = St(z.id) ?? f);
+      const u = (f ?? xt.get(a.id) ?? l.origin).clone(), i = Math.abs(u.x) > 0.5 ? u.x < 0 ? -1 : 1 : et(a.id, 23) < 0.5 ? 1 : -1, p = Math.atan2(-0.35 - et(a.id, 22) * 0.4, i), h = 40 * (et(a.id, 24) < 0.5 ? 1 : -1), m = (et(a.id, 25) - 0.5) * 0.35, w = st.core.r + 9, n = new r.Color(a.color).lerp(N, 0.6), y = Z(), v = pt(), x = u.x + Math.cos(p + Math.PI * 0.5) * h, B = u.y + Math.sin(p + Math.PI * 0.5) * h, A = p - Math.PI * 0.5, S = Math.round(w / 0.085);
+      for (let z = 1; z <= S; z++) {
+        const C = z / S * w, F = A + C / h, E = x + Math.cos(F) * h, T = B + Math.sin(F) * h, V = v + C / 11, G = u.z + C * m;
+        y.emit(E, T, G, 0.09 * (0.75 + Math.random() * 0.5), n, 0.7, 5.5, V, 0), z % 3 === 0 && y.emit(E, T, G, 0.6, N, 0.9, 0.16, V, 1);
+      }
+      y.emit(u.x, u.y, u.z, 1.6, N, 1.3, 0.6, v, 1), e.current.push({ run: a.id, at: c, from: u, text: a.final }), e.current.length > oe && e.current.shift();
+    }
+    if (t.current.size > 200)
+      for (const a of t.current) L.runs.has(a) || t.current.delete(a);
+    for (let a = 0; a < oe; a++) {
+      const l = e.current[a], f = s.current[a], u = o.current[a];
+      if (!f || !u) continue;
+      const i = l ? (c - l.at) / 1e3 : 99;
+      if (!l || i > 5.5) {
+        f.setOpacity(0);
+        continue;
+      }
+      u.position.set(l.from.x, l.from.y - 2.2, l.from.z), d.current[a] !== l.run + l.at && (d.current[a] = l.run + l.at, f.setText(`final answer - ${l.text.length > 64 ? l.text.slice(0, 62) + "…" : l.text}`)), f.setOpacity(rt(i / 0.3) * rt((5.5 - i) / 1.2));
+    }
+  }), /* @__PURE__ */ b(Kt, { children: Array.from({ length: oe }, (c, a) => /* @__PURE__ */ b("group", { ref: (l) => void (o.current[a] = l), children: /* @__PURE__ */ b(Bt, { ref: (l) => void (s.current[a] = l), text: "", color: "#cff8ff", size: 0.26, maxWidth: 11, opacity: 0, pxRange: [8, 12], renderOrder: 24 }) }, a)) });
+}
+const kt = Math.PI * 2, ie = 0.85, Ae = 6.5, Wo = new r.MeshBasicMaterial({ colorWrite: !1, depthWrite: !1, transparent: !0, opacity: 0 }), it = new r.Vector3(), bt = new r.Vector3(), Lt = new r.Vector3();
+function Ko({ agent: t, selected: e, onSelect: s }) {
+  const o = t.inst, d = I(null), c = I(null), a = I(null), l = I(null), f = I(null), u = I(null), i = I(null), p = I(null), h = D(() => [...o.id].reduce((x, B) => (x * 31 + B.charCodeAt(0)) % 9973, 7) / 9973, [o.id]), m = oo[o.type], w = D(
+    () => ({
+      halo: se(m),
+      core: se("#fff"),
+      sel: ot("#e6fbff"),
+      wait: ot(Xt)
+    }),
+    [m]
+  ), n = D(
+    () => ({
+      // charge: which way the field curls this particle
+      q: h < 0.5 ? 1 : -1,
+      th: h * kt,
+      ph: h * 17,
+      rc: 0.3,
+      rg: 0.25,
+      w: kt * 0.6,
+      boost: 0,
+      red: 0,
+      waitK: 0,
+      selK: 0,
+      calls: o.llmCalls,
+      tools: o.toolCalls,
+      decAt: performance.now(),
+      first: !0,
+      fly: !1,
+      from: new r.Vector3(),
+      trail: new fe(),
+      col: new r.Color(),
+      stopped: !1,
+      hx: t.pos.x,
+      hy: t.pos.y,
+      move: 0,
+      // depth: mirror-bounce phase along the field and its amplitude (the home depth is <AgentDepth/>'s)
+      ps: h * 23,
+      lz: 0.6
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  ce(() => () => void Ht.delete(o.id), [o.id]), ht(({ camera: x }, B) => {
+    var ge, ye;
+    const A = performance.now(), S = pt(), z = Math.min(0.05, B), C = t.scale, F = nt ? 0.3 : 1, E = !o.exitAt, T = !E || o.doneAt > 0, V = !T && (o.status === "thinking" || o.status === "spawning");
+    let G = !1;
+    if (!T)
+      for (const _ of L.mcpPending.values()) _.instance === o.id && (G = !0);
+    const W = (A - o.bornAt) / 1e3;
+    if (n.first && (n.first = !1, W < ie * 0.8 && !t.fresh)) {
+      const _ = o.parent ? St(o.parent) : void 0, q = xt.get(o.run), At = _ ?? q;
+      if (At) {
+        n.fly = !0, n.from.copy(At), it.subVectors(n.from, t.pos);
+        const ct = 4.2 * Math.max(0.6, Rt.spread);
+        it.length() > ct && n.from.copy(t.pos).addScaledVector(it.normalize(), ct);
+        const Tt = Z(), Pt = n.from;
+        if (Tt.emit(Pt.x, Pt.y, Pt.z, 0.9 * C, X, 1.3, 0.45, S, 1), Tt.emit(Pt.x, Pt.y, Pt.z, 1.5 * C, It[o.type], 0.9, 0.6, S, 2), _ && o.parent) {
+          const we = st.agents.get(o.parent);
+          it.copy(t.pos).sub(n.from);
+          const Qt = it.length() || 1, Jt = we ? we.scale : C;
+          te(o.parent, -it.x / Qt * 0.32 * Jt, -it.y / Qt * 0.32 * Jt, -it.z / Qt * 0.32 * Jt, A);
+        }
+      }
+    }
+    const Y = n.th + n.q * Math.PI * 0.5;
+    if (o.llmCalls !== n.calls && (n.calls = o.llmCalls, !T)) {
+      const _ = Math.min(2.5, Math.max(0.6, o.pulse));
+      n.boost = Math.min(1.1, n.boost + 0.25 + _ * 0.22);
+      const q = t.live;
+      re(q, Math.round(6 + _ * 7), (0.14 + _ * 0.12) * C, 0.12 * C, X, 1, 2.8, S), Z().emit(q.x, q.y, q.z, (0.7 + _ * 0.45) * C, X, 0.9, 0.45, S, 1), nt || Re(q, Y + n.q * 0.9, (0.14 + _ * 0.07) * C, 1.7, 22, 0.07 * C, X, 0.85, 3.4, S, -n.q, -n.q * (0.25 + _ * 0.1) * C);
+    }
+    if (o.toolCalls !== n.tools && (n.tools = o.toolCalls, !T)) {
+      const _ = Math.random() < 0.5 ? 1 : -1;
+      te(o.id, Math.cos(Y + _ * 1.4) * 0.2 * C, Math.sin(Y + _ * 1.4) * 0.2 * C, _ * 0.16 * C, A);
+      const q = t.live;
+      Z().emit(q.x, q.y, q.z, 0.55 * C, N, 1.1, 0.3, S + 0.05, 1);
+    }
+    const $ = o.decisions;
+    for (let _ = 0; _ < $.length; _++) {
+      const q = $[_];
+      if (q.at <= n.decAt || q.at > A || (n.decAt = q.at, q.hidden || !He(q) || T)) continue;
+      const At = Math.random() < 0.5 ? 1 : -1;
+      te(o.id, Math.cos(Y + At * 1.9) * 0.42 * C, Math.sin(Y + At * 1.9) * 0.42 * C, -At * 0.36 * C, A), n.red = 1;
+      const ct = t.live, Tt = Z();
+      Tt.emit(ct.x, ct.y, ct.z, 1 * C, _t, 1.4, 0.55, S + 0.05, 1), Tt.emit(ct.x, ct.y, ct.z, 1.9 * C, _t, 1, 0.75, S + 0.05, 2), re(ct, 5, 0.18 * C, 0.11 * C, _t, 1, 2, S + 0.05);
+    }
+    n.boost *= Math.exp(-z / 2.4), n.red *= Math.exp(-z / 0.6);
+    let mt, Mt, gt, Ct, yt;
+    T ? (mt = 0, Mt = 0, gt = kt * 0.95, Ct = 0, yt = 0.5) : V && !G ? (mt = 0.34, Mt = 0.28, gt = kt * 0.6, Ct = 1.5, yt = 0.5) : (mt = 0.15, Mt = 0.06, gt = kt * 0.22, Ct = 0.32, yt = 0.2);
+    const Q = Math.min(1, z * (T ? 1.3 : 2.6));
+    n.rc += (mt + (T ? 0 : n.boost * 0.4) - n.rc) * Q, n.rg += (Mt - n.rg) * Q, n.w += (gt - n.w) * Math.min(1, z * 2), n.lz += (Ct + (T ? 0 : n.boost * 0.5) - n.lz) * Q, n.th += n.q * n.w * z * F, n.ph += n.q * 0.42 * z * F, n.ps += yt * z * F;
+    const H = t.live;
+    H.copy(t.pos);
+    const g = Math.max(C, 0.72);
+    H.x += (Math.cos(n.ph) * n.rg + Math.cos(n.th) * n.rc) * g, H.y += (Math.sin(n.ph) * n.rg * 0.7 + Math.sin(n.th) * n.rc) * g, H.z += Math.sin(n.ps) * n.lz * g;
+    const M = Ht.get(o.id);
+    if (M) {
+      const _ = uo(A - M.at);
+      H.x += M.x * _, H.y += M.y * _, H.z += M.z * _;
+    }
+    let P = !1;
+    if (n.fly) {
+      const _ = W / ie;
+      _ >= 1 ? n.fly = !1 : (P = !0, it.copy(H), qt(n.from, it, n.q * 0.24, bt), Ut(n.from, bt, it, jt(_ * 0.85 + 0.15 * _ * _), H));
+    }
+    const K = Math.hypot(t.pos.x - n.hx, t.pos.y - n.hy) / Math.max(1e-3, z) / Math.max(0.3, C);
+    n.hx = t.pos.x, n.hy = t.pos.y, n.move += (Math.min(1, Math.max(0, K - 0.4) * 0.5) - n.move) * Math.min(1, z * 8), n.waitK += ((G ? 1 : 0) - n.waitK) * Math.min(1, z * 4), n.col.copy(It[o.type]).lerp(Xt, n.waitK * 0.75).lerp(_t, n.red * 0.85), o.status === "failed" && n.col.lerp(_t, 0.5);
+    const O = n.rc + n.rg + (P ? 1 : 0);
+    if (!n.stopped) {
+      const _ = (P ? 1.5 : T ? 0.7 : V ? 1.55 : 0.95) * (P ? 1 : 1 - 0.85 * n.move);
+      n.trail.step(H, 0.065 * g, 0.13 * g, n.col, _, P ? Ae + 1 : Ae, S, 10), T && O < 0.015 && (n.stopped = !0);
+    }
+    !T && n.stopped && (n.stopped = !1, n.trail.reset());
+    const j = o.exitAt ? (A - o.exitAt) / 1e3 : -1, U = j >= 0 ? rt(j / 1.6) : 0, J = jt(W / 0.35), dt = Ze(o, A), me = ((T ? 0.45 : V ? 1 : 0.6) + dt * 0.25 + n.boost * 0.4 + (P ? 0.5 : 0)) * (1 - U);
+    if (d.current && (d.current.position.copy(H), d.current.scale.setScalar(Math.max(1e-4, C * J))), l.current && (l.current.scale.setScalar(0.5 + dt * 0.1 + n.boost * 0.12), w.core.color.copy(N).lerp(n.col, 0.2).multiplyScalar(Math.min(2, 1.5 * me))), a.current) {
+      const _ = Math.min(1, Math.sqrt(1.3 / Math.max(0.1, C)));
+      a.current.scale.setScalar(((V ? 2 : 1.5) + dt * 0.4 + n.boost * 0.6) * _), w.halo.color.copy(m).lerp(n.col, 0.4).multiplyScalar(0.62 * me);
+    }
+    c.current && (c.current.position.copy(t.pos), c.current.quaternion.copy(x.quaternion), c.current.scale.setScalar(Math.max(1e-4, g)));
+    const Me = 0.34 + 0.28 + 0.3;
+    n.selK += ((e ? 1 : 0) - n.selK) * 0.14, f.current && (f.current.visible = n.selK > 0.02, f.current.scale.setScalar(Me + 0.18 + (1 - n.selK) * 0.3), f.current.rotation.z = nt ? 0 : S * 0.15, w.sel.color.setScalar(0.85 * n.selK)), u.current && (u.current.visible = n.waitK > 0.02, u.current.scale.setScalar(0.5 + 0.03 * Math.sin(S * 3)), u.current.rotation.z = nt ? 0 : -S * 0.8, w.wait.color.copy(Xt).multiplyScalar(0.9 * n.waitK)), (ge = i.current) == null || ge.position.set(t.pos.x, t.pos.y - (Me + 0.12) * g - 0.3, t.pos.z), (ye = p.current) == null || ye.setOpacity(Ye(o.id) ? J * (E ? 0.95 : 0.6 * (1 - U)) : 0);
+  });
+  const y = (x) => {
+    x.stopPropagation(), s(o.id);
+  }, v = o.id.split(":")[2];
+  return /* @__PURE__ */ lt(Kt, { children: [
+    /* @__PURE__ */ lt("group", { ref: c, scale: 1e-4, children: [
+      /* @__PURE__ */ b("mesh", { geometry: ro, material: Wo, scale: 0.85, onClick: y, onPointerOver: () => document.body.style.cursor = "pointer", onPointerOut: () => document.body.style.cursor = "" }),
+      /* @__PURE__ */ b("lineSegments", { ref: f, geometry: be, material: w.sel, visible: !1 }),
+      /* @__PURE__ */ b("lineSegments", { ref: u, geometry: be, material: w.wait, visible: !1 })
+    ] }),
+    /* @__PURE__ */ lt("group", { ref: d, scale: 1e-4, children: [
+      /* @__PURE__ */ b("sprite", { ref: a, material: w.halo }),
+      /* @__PURE__ */ b("sprite", { ref: l, material: w.core })
+    ] }),
+    /* @__PURE__ */ b("group", { ref: i, children: /* @__PURE__ */ b(
+      Bt,
+      {
+        ref: p,
+        text: `${o.name}${v !== void 0 ? ` ${Number(v) + 1}` : ""}`,
+        live: o.job ? () => Qe(o) : null,
+        color: le[o.type],
+        size: o.subagent ? 0.22 : 0.28,
+        letterSpacing: 0.02,
+        opacity: 0,
+        fit: !0,
+        pxRange: o.subagent ? [8, 11.5] : [9, 13.5]
+      }
+    ) })
+  ] });
+}
+const Ot = /* @__PURE__ */ new Map();
+function Uo() {
+  return ht((t, e) => {
+    const s = Math.min(1, Math.min(0.05, e) * 1.6);
+    for (const o of st.agents.values()) {
+      const d = Ie(o), c = Ot.get(o.id), a = c === void 0 ? d : c + (d - c) * s;
+      Ot.set(o.id, a), o.pos.z = a, o.live.z = a;
+    }
+    if (Ot.size > st.agents.size + 64)
+      for (const o of Ot.keys()) st.agents.has(o) || Ot.delete(o);
+  }, -1), null;
+}
+const No = 160, Xo = 32;
+function $o() {
+  const t = D(() => new Yt(No + Xo, 24), []), e = D(() => /* @__PURE__ */ new Map(), []), s = D(() => ({ a: new r.Vector3(), b: new r.Vector3(), col: new r.Color() }), []);
+  return ht(({ clock: o }) => {
+    const d = performance.now(), c = pt(), a = nt ? 0 : o.elapsedTime;
+    t.begin();
+    const { a: l, b: f, col: u } = s;
+    for (const i of st.agents.values()) {
+      const p = i.inst, h = p.parent ? st.agents.get(p.parent) : void 0, m = h ? h.pos : p.parent ? void 0 : xt.get(p.run);
+      if (!m) continue;
+      const w = i.pos.distanceTo(m);
+      if (w < 0.5) continue;
+      const n = Math.min(0.4, ((h ? 0.85 * h.scale : 0.25) + 0.05) / w), y = Math.max(n + 0.05, 1 - (0.85 * i.scale + 0.05) / w), v = (d - p.bornAt) / 1e3, x = ne(v / ie), B = (h ? 0.3 : 0.2) * (1 - 0.65 * i.dim) * x;
+      u.copy(It[p.type]).lerp(X, 0.4), l.copy(m), f.copy(i.pos), bt.copy(l).add(f).multiplyScalar(0.5), t.add(l, bt, f, u, B, n, n + (y - n) * x, Math.max(3, Math.round(w / 0.42)), a * 0.35, -1, 0);
+    }
+    for (const i of e.keys()) {
+      let p = !1;
+      for (const h of L.comets) h.id === i && (p = !0);
+      p || e.delete(i);
+    }
+    for (const i of L.comets) {
+      const p = St(i.from), h = St(i.to);
+      if (!p || !h) continue;
+      const m = Je(i, d);
+      if (!to(i, d)) continue;
+      let w = e.get(i.id);
+      w || e.set(i.id, w = new fe()), qt(p, h, i.id % 2 ? 0.22 : -0.22, bt);
+      const n = ne(m);
+      Ut(p, bt, h, n, Lt);
+      const y = L.instances.get(i.from);
+      u.copy(y ? It[y.type] : X).lerp(N, 0.35);
+      const v = Math.min(1, m / 0.08) * Math.min(1, (1 - m) / 0.12);
+      t.add(p, bt, h, u, 0, 0, 1, 0, 0, n, 1.1 * v), w.step(Lt, 0.06, 0.07, u, 0.9 * v, 2.4, c, 6), Z().emit(Lt.x, Lt.y, Lt.z, 0.42, u, 1.2 * v, 0.12, c, 1);
+    }
+    t.end();
+  }), /* @__PURE__ */ b("primitive", { object: t.obj });
+}
+const Ho = { tint: "#7dd3fc", tintAmt: 0.3, gain: 0.6, halo: 0.4 }, Zo = {
+  minPolarAngle: Math.PI * 0.25,
+  maxPolarAngle: Math.PI * 0.75
+};
+function Yo(t) {
+  for (const e of xt.values()) t(e, 0.9);
+  for (const e of st.agents.values()) t(vt.set(e.target.x, e.target.y, Ie(e)), 1.1 * e.scale);
+  t(vt.set(R.rx, 0, 0), 0), t(vt.set(-R.rx, 0, 0), 0), t(vt.set(0, R.ry, 0), 0), t(vt.set(0, -R.ry, 0), 0), t(vt.set(0, 0, R.hz), 0), t(vt.set(0, 0, -R.hz), 0);
+}
+const vt = new r.Vector3();
+function sn() {
+  return /* @__PURE__ */ lt(
+    eo,
+    {
+      title: "bubble chamber · particle tracks",
+      subtitle: "Agents are charged particles on helices along the field (tight = thinking, slow orbit = waiting, spiral in = done) · a spawn is a decay into a V · LLM calls burst bubbles, tools kink the track, a deny flashes red · each run is an event at its vertex · ▭ MCP detector plates, ⬡ backend cells · graph = event archive (a read pulls its plate out)",
+      preset: "radial",
+      plane: "xy",
+      camera: { position: [0, 0, 34], fov: 46, far: 1200 },
+      controls: Zo,
+      bg: "#010406",
+      gl: { antialias: !0 },
+      fit: { nRef: 4, min: 0.62, max: 1.6, minRadius: 5.5 },
+      agentRadius: 1.1,
+      graph: { natural: Mo * 1.05, radius: 4.4 },
+      peripheryGap: 3.8,
+      extents: Yo,
+      Background: /* @__PURE__ */ b(To, {}),
+      Agent: Ko,
+      RunMarker: Fo,
+      mcpStyle: Ho,
+      GraphResource: xo,
+      cluster: { radius: 1.4, variant: "swarm", glowGain: 0.9 },
+      PostFX: /* @__PURE__ */ lt(Le, { multisampling: 0, children: [
+        /* @__PURE__ */ b(Oe, { mipmapBlur: !0, intensity: 0.9, luminanceThreshold: 0.2, luminanceSmoothing: 0.3, radius: 0.6 }),
+        /* @__PURE__ */ b(Ee, { eskil: !1, offset: 0.22, darkness: 0.85 })
+      ] }),
+      children: [
+        /* @__PURE__ */ b(Uo, {}),
+        /* @__PURE__ */ b($o, {}),
+        /* @__PURE__ */ b(Go, {}),
+        /* @__PURE__ */ b(qo, {}),
+        /* @__PURE__ */ b(Do, {})
+      ]
+    }
+  );
+}
+export {
+  sn as default
+};