agentglow 0.1.0 → 0.2.1

package/dist/chunks/index-Bqv_wy49.js

@@ -0,0 +1,889 @@
+var re = Object.defineProperty;
+var ae = (u, e, a) => e in u ? re(u, e, { enumerable: !0, configurable: !0, writable: !0, value: a }) : u[e] = a;
+var h = (u, e, a) => ae(u, typeof e != "symbol" ? e + "" : e, a);
+import { jsxs as gt, jsx as P, Fragment as ce } from "react/jsx-runtime";
+import { useFrame as ft, useThree as le } from "@react-three/fiber";
+import { EffectComposer as he, Bloom as fe, Vignette as ue, Noise as de } from "@react-three/postprocessing";
+import { useMemo as pe, useRef as $, useEffect as At } from "react";
+import * as x from "three";
+import { K as ge, v as me, f as nt, k as Z, w as q, q as ee, x as se, R as Me, d as $t, p as ye, e as be, S as st, c as Tt, T as ne, i as Ae, j as xe, G as we, L as xt, u as Re, t as Ge } from "./KitScene-C3SZiKL5.js";
+var te;
+const mt = typeof window < "u" && !!((te = window.matchMedia) != null && te.call(window, "(prefers-reduced-motion: reduce)").matches), it = mt ? 0.3 : 1, W = mt ? 9e3 : 24e3, ot = mt ? 3500 : 8e3, B = 12, J = mt ? 450 : 1100, kt = 9e3, Y = 64, Et = 31, Se = 4.6, rt = 28, _t = 64, St = 18, Lt = 16, ut = 8, X = Math.PI * 2, et = 200, Dt = 5.4, vt = 3.2, ze = ["planner", "researcher", "writer"], bt = Object.fromEntries(Object.entries(ne).map(([u, e]) => [u, new x.Color(e)])), ve = Ae, Ie = () => ({ used: !1, id: "", inst: null, seen: 0, x: 0, y: 0, z: 0, r: 1, g: 1, b: 1, omega: 0, bright: 0, swirl: 0, rscale: 1, tiltA: 0, tiltB: 0, count: 0, want: 0, rank: 0, ka: null, released: !1, p: 0, e: 0, waitMcp: 0 }), zt = et * 3, Ce = (u) => {
+  let e = 7;
+  for (let a = 0; a < u.length; a++) e = e * 31 + u.charCodeAt(a) >>> 0;
+  return e % 100003;
+}, K = (u) => {
+  const e = Math.sin(u * 127.1 + 311.7) * 43758.5453;
+  return e - Math.floor(e);
+};
+function dt(u) {
+  const e = new x.BufferGeometry();
+  return e.setAttribute("position", new x.BufferAttribute(new Float32Array(u * 3), 3).setUsage(x.DynamicDrawUsage)), e.setAttribute("acol", new x.BufferAttribute(new Float32Array(u * 3), 3).setUsage(x.DynamicDrawUsage)), e.setAttribute("size", new x.BufferAttribute(new Float32Array(u), 1).setUsage(x.DynamicDrawUsage)), e;
+}
+const j = (u, e) => u.getAttribute(e).array, pt = (u) => {
+  u.getAttribute("position").needsUpdate = !0, u.getAttribute("acol").needsUpdate = !0, u.getAttribute("size").needsUpdate = !0;
+};
+function Jt() {
+  return new x.ShaderMaterial({
+    uniforms: { uScale: { value: 300 }, uPR: { value: 1 } },
+    vertexShader: (
+      /* glsl */
+      `
+      attribute vec3 acol;
+      attribute float size;
+      uniform float uScale;
+      uniform float uPR;
+      varying vec3 vC;
+      void main() {
+        vec4 mv = modelViewMatrix * vec4(position, 1.0);
+        gl_Position = projectionMatrix * mv;
+        gl_PointSize = min(96.0, size * uPR * uScale / max(0.5, -mv.z));
+        vC = acol;
+        if (size <= 0.0) gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+      }`
+    ),
+    fragmentShader: (
+      /* glsl */
+      `
+      varying vec3 vC;
+      void main() {
+        vec2 c = gl_PointCoord - 0.5;
+        float d = dot(c, c) * 4.0;
+        if (d > 1.0) discard;
+        float a = exp(-d * 3.2) - 0.04;
+        gl_FragColor = vec4(vC * max(a, 0.0), 1.0);
+      }`
+    ),
+    transparent: !0,
+    depthWrite: !1,
+    blending: x.AdditiveBlending
+  });
+}
+const R = new x.Vector3(), N = new x.Vector3(), T = new x.Vector3(), G = new x.Color(), Q = new x.Color(), tt = new x.Object3D(), V = new x.Color(1, 1, 1), Qt = new x.Color("#fbbf24"), Fe = new x.Color("#ef4444"), Pe = new x.Color("#ef4444");
+class Be {
+  constructor() {
+    h(this, "material", Jt());
+    /** nebula points live in the (scaled) side graph group: their sprite size follows kit.graph.scale */
+    h(this, "nebMaterial", Jt());
+    h(this, "frame", 0);
+    h(this, "selectedId", null);
+    /** field radius (grows with the kit core so the murmuration always surrounds the agents + periphery) */
+    h(this, "fieldR", Et);
+    // ---- field
+    h(this, "fieldGeo", dt(W));
+    h(this, "fP", j(this.fieldGeo, "position"));
+    h(this, "fC", j(this.fieldGeo, "acol"));
+    h(this, "fS", j(this.fieldGeo, "size"));
+    h(this, "fYb", new Float32Array(W));
+    h(this, "fIvx", new Float32Array(W));
+    h(this, "fIvz", new Float32Array(W));
+    h(this, "fHeat", new Float32Array(W));
+    h(this, "fT", new Float32Array(W * 3));
+    h(this, "fOwner", new Int16Array(W).fill(-1));
+    h(this, "fAng", new Float32Array(W));
+    h(this, "fOrb", new Float32Array(W));
+    h(this, "fRnd", new Float32Array(W));
+    // ---- slots (agent eddies, one per drawn kit agent)
+    h(this, "slots", Array.from({ length: Y }, Ie));
+    h(this, "idToSlot", /* @__PURE__ */ new Map());
+    h(this, "pendingByInst", /* @__PURE__ */ new Map());
+    // ---- runs (pooled vortices, one per drawn kit run; a vortex fades out after its run leaves the kit)
+    h(this, "runRef", new Array(B).fill(null));
+    h(this, "runKit", new Array(B).fill(null));
+    h(this, "runId", new Array(B).fill(""));
+    h(this, "runPool", /* @__PURE__ */ new Map());
+    h(this, "rPresent", new Uint8Array(B));
+    h(this, "rSteps", new Uint8Array(B));
+    h(this, "rX", new Float32Array(B));
+    h(this, "rZ", new Float32Array(B));
+    /** vortex loop radius per run (around its agents) */
+    h(this, "rR", new Float32Array(B).fill(Se));
+    /** step attractors (x, z) per run: at the kit's role slots (plan | research | write) */
+    h(this, "rAt", new Float32Array(B * 6));
+    h(this, "rAlpha", new Float32Array(B));
+    h(this, "rCol", Array.from({ length: B }, () => new x.Color()));
+    h(this, "rColStr", new Array(B).fill(""));
+    h(this, "runGeo", dt(B * J));
+    h(this, "rTh", new Float32Array(B * J));
+    h(this, "rSp", new Float32Array(B * J));
+    h(this, "rRr", new Float32Array(B * J));
+    h(this, "rY", new Float32Array(B * J));
+    // ---- nebula (FalkorDB side current; local frame of the kit side graph)
+    h(this, "nebGeo", dt(ot));
+    h(this, "anchorGeo", dt(et));
+    h(this, "nA", new Uint16Array(ot));
+    h(this, "nO", new Float32Array(ot * 3));
+    h(this, "nSpin", new Float32Array(ot));
+    h(this, "nB", new Float32Array(ot));
+    h(this, "aLocal", new Float32Array(et * 3));
+    h(this, "aCol", new Float32Array(et * 3));
+    h(this, "aNamed", new Uint8Array(et));
+    h(this, "burst", new Float32Array(et));
+    h(this, "burstW", new Float32Array(et));
+    h(this, "flareCol", new Float32Array(et * 3));
+    h(this, "nameIdx", /* @__PURE__ */ new Map());
+    h(this, "nebAngle", 0.4);
+    h(this, "nAnchors", 0);
+    h(this, "edgeGeo", new x.BufferGeometry());
+    h(this, "edgeA", new Uint16Array(zt * 2));
+    h(this, "nEdge", 0);
+    h(this, "lastFlareId", 0);
+    h(this, "lastFlare", null);
+    // ---- streams + lines
+    h(this, "streamGeo", dt(kt));
+    h(this, "beamGeo");
+    h(this, "glowGeo", dt(Y + B * 3 + ut));
+    // ---- meshes
+    h(this, "cores");
+    h(this, "attractors");
+    h(this, "stepRings");
+    h(this, "rings");
+    h(this, "pulsars");
+    h(this, "pulsarBeams");
+    h(this, "selRing");
+    h(this, "ringStart", new Float32Array(rt).fill(-1e9));
+    h(this, "ringDur", new Float32Array(rt).fill(1));
+    h(this, "ringMax", new Float32Array(rt));
+    h(this, "ringPos", new Float32Array(rt * 3));
+    h(this, "ringCol", new Float32Array(rt * 3));
+    h(this, "ringNext", 0);
+    h(this, "mcpSpin", new Float32Array(ut));
+    // ------------------------------------------------------------------ frame
+    /** kit fit size multiplier for eddies, sampled once per frame */
+    h(this, "lodK", 1);
+    // active runs / swirls packed for the hot loop
+    h(this, "aX", new Float32Array(B));
+    h(this, "aZ", new Float32Array(B));
+    h(this, "aA", new Float32Array(B));
+    h(this, "aRR", new Float32Array(B));
+    h(this, "aR", new Float32Array(B * 3));
+    h(this, "sX", new Float32Array(Y));
+    h(this, "sZ", new Float32Array(Y));
+    h(this, "sS", new Float32Array(Y));
+    h(this, "stTh", new Float32Array(3));
+    h(this, "stB", new Float32Array(3));
+    for (let t = 0; t < W; t++) {
+      const s = Math.sqrt(Math.random()) * Et, m = Math.random() * X;
+      this.fP[t * 3] = Math.cos(m) * s, this.fP[t * 3 + 2] = Math.sin(m) * s, this.fYb[t] = (Math.random() - 0.5) * (0.6 + s * 0.05), this.fP[t * 3 + 1] = this.fYb[t], this.fRnd[t] = Math.random(), this.fOrb[t] = 0.16 + 1.35 * Math.pow(Math.random(), 1.5), this.fAng[t] = Math.random() * X;
+    }
+    for (let t = 0; t < B * J; t++) {
+      this.rTh[t] = Math.random() * X, this.rSp[t] = 0.2 + Math.random() * 0.14;
+      const s = (Math.random() + Math.random() + Math.random() - 1.5) * 0.55;
+      this.rRr[t] = s, this.rY[t] = (Math.random() - 0.5) * 0.35;
+    }
+    for (let t = 0; t < ot; t++) {
+      const s = 0.18 + 0.55 * Math.pow(Math.random(), 3), m = Math.random() * X, w = s * Math.sqrt(-2 * Math.log(1 - Math.random() * 0.98));
+      this.nO[t * 3] = Math.cos(m) * w, this.nO[t * 3 + 1] = (Math.random() - 0.5) * s * 0.8, this.nO[t * 3 + 2] = Math.sin(m) * w, this.nSpin[t] = (0.15 + Math.random() * 0.5) * (Math.random() < 0.5 ? 1 : 0.6), this.nB[t] = 0.5 + Math.random() * 0.7;
+    }
+    this.anchorGeo.setDrawRange(0, 0), this.edgeGeo.setAttribute("position", new x.BufferAttribute(new Float32Array(zt * 2 * 3), 3)), this.edgeGeo.setAttribute("color", new x.BufferAttribute(new Float32Array(zt * 2 * 3), 3).setUsage(x.DynamicDrawUsage)), this.edgeGeo.setDrawRange(0, 0), this.edgeGeo.boundingSphere = new x.Sphere(new x.Vector3(), 50);
+    const e = _t + Lt * St;
+    this.beamGeo = new x.BufferGeometry(), this.beamGeo.setAttribute("position", new x.BufferAttribute(new Float32Array(e * 6), 3).setUsage(x.DynamicDrawUsage)), this.beamGeo.setAttribute("color", new x.BufferAttribute(new Float32Array(e * 6), 3).setUsage(x.DynamicDrawUsage));
+    const a = new x.Sphere(new x.Vector3(), 400), o = new x.MeshBasicMaterial({ toneMapped: !1 });
+    this.cores = new x.InstancedMesh(new x.IcosahedronGeometry(0.26, 3), o, Y), this.attractors = new x.InstancedMesh(new x.IcosahedronGeometry(0.3, 3), new x.MeshBasicMaterial({ toneMapped: !1 }), B * 3);
+    const n = new x.RingGeometry(0.9, 1, 96);
+    n.rotateX(-Math.PI / 2);
+    const i = () => new x.MeshBasicMaterial({ toneMapped: !1, transparent: !0, blending: x.AdditiveBlending, depthWrite: !1, side: x.DoubleSide });
+    this.stepRings = new x.InstancedMesh(new x.RingGeometry(0.93, 1, 6, 1).rotateX(-Math.PI / 2), i(), B * 3), this.rings = new x.InstancedMesh(n, i(), rt), this.pulsars = new x.InstancedMesh(new x.OctahedronGeometry(0.42, 0), new x.MeshBasicMaterial({ toneMapped: !1 }), ut);
+    const l = new x.ConeGeometry(0.12, 3.2, 8, 1, !0);
+    l.translate(0, 1.6, 0);
+    const d = l.clone().rotateX(Math.PI), r = new x.BufferGeometry();
+    {
+      const t = l.getAttribute("position").array, s = d.getAttribute("position").array, m = l.getIndex().array, w = d.getIndex().array, S = new Float32Array(t.length + s.length);
+      S.set(t), S.set(s, t.length);
+      const z = [...m, ...Array.from(w, (v) => v + t.length / 3)];
+      r.setAttribute("position", new x.BufferAttribute(S, 3)), r.setIndex(z);
+    }
+    this.pulsarBeams = new x.InstancedMesh(r, i(), ut);
+    for (const t of [this.cores, this.attractors, this.stepRings, this.rings, this.pulsars, this.pulsarBeams]) {
+      t.boundingSphere = a, t.frustumCulled = !1, t.instanceMatrix.setUsage(x.DynamicDrawUsage), t.setColorAt(0, G.setRGB(0, 0, 0));
+      for (let s = 0; s < t.count; s++)
+        tt.position.set(0, -999, 0), tt.scale.setScalar(1e-4), tt.updateMatrix(), t.setMatrixAt(s, tt.matrix), t.setColorAt(s, G.setRGB(0, 0, 0));
+    }
+    this.selRing = new x.Mesh(new x.RingGeometry(1.25, 1.33, 64).rotateX(-Math.PI / 2), i()), this.selRing.visible = !1;
+  }
+  /**
+   * Swap in a new graph sample (the session's graph grows while it runs). Anchors are laid out per node id (stable:
+   * a node never moves when others arrive), new anchors take over a share of the nebula particles. No reset.
+   */
+  setGalaxy(e) {
+    const a = Math.min(et, e.nodes.length), o = this.nAnchors;
+    this.nAnchors = a, this.nameIdx.clear();
+    const n = /* @__PURE__ */ new Map();
+    for (let s = 0; s < a; s++) {
+      const m = e.nodes[s];
+      this.nameIdx.set(m.name.toLowerCase(), s), n.set(m.id, s);
+      const w = Ce(m.id), S = K(w), z = 0.5 + (Dt - 0.9) * Math.sqrt(S) + (K(w + 1) - 0.5) * 0.45, v = w % 3 / 3 * X + z * 1.15 + (K(w + 2) - 0.5) * 0.5;
+      this.aLocal[s * 3] = Math.cos(v) * z, this.aLocal[s * 3 + 1] = (K(w + 3) - 0.5) * 0.7 * (1.3 - S) + 0.4, this.aLocal[s * 3 + 2] = Math.sin(v) * z, G.set(ge[m.kind] ?? "#94a3b8"), this.aCol[s * 3] = G.r, this.aCol[s * 3 + 1] = G.g, this.aCol[s * 3 + 2] = G.b, this.aNamed[s] = s < 22 ? 1 : 0;
+    }
+    if (a > 0) {
+      const s = o > 0 && a > o ? (a - o) / a : o > 0 ? 0 : 1;
+      for (let m = 0; m < ot; m++)
+        this.nA[m] >= a ? this.nA[m] = Math.floor(Math.random() * a) : s > 0 && Math.random() < s && (this.nA[m] = o > 0 ? o + Math.floor(Math.random() * (a - o)) : Math.random() < 0.2 ? Math.floor(Math.random() * Math.min(22, a)) : Math.floor(Math.random() * a));
+    }
+    this.anchorGeo.setDrawRange(0, a);
+    const i = this.edgeA;
+    let l = 0;
+    const d = /* @__PURE__ */ new Set(), r = (s, m) => {
+      if (s === m || l >= zt) return;
+      const w = s < m ? s * 4096 + m : m * 4096 + s;
+      d.has(w) || (d.add(w), i[l * 2] = s, i[l * 2 + 1] = m, l++);
+    }, t = this.aLocal;
+    for (const s of e.links) {
+      const m = n.get(s.source), w = n.get(s.target);
+      if (m !== void 0 && w !== void 0) {
+        const S = t[m * 3] - t[w * 3], z = t[m * 3 + 2] - t[w * 3 + 2];
+        S * S + z * z < 9 && r(m, w);
+      }
+    }
+    for (let s = 0; s < a; s++) {
+      let m = -1, w = 1e9, S = -1, z = 1e9;
+      for (let v = 0; v < a; v++) {
+        if (v === s) continue;
+        const p = t[s * 3] - t[v * 3], y = t[s * 3 + 1] - t[v * 3 + 1], I = t[s * 3 + 2] - t[v * 3 + 2], c = p * p + y * y + I * I;
+        c < w ? (S = m, z = w, m = v, w = c) : c < z && (S = v, z = c);
+      }
+      m >= 0 && r(s, m), S >= 0 && s % 2 === 0 && r(s, S);
+    }
+    this.nEdge = l, this.edgeGeo.setDrawRange(0, l * 2);
+  }
+  dispose() {
+    for (const e of [this.edgeGeo, this.fieldGeo, this.runGeo, this.nebGeo, this.anchorGeo, this.streamGeo, this.beamGeo, this.glowGeo]) e.dispose();
+    for (const e of [this.cores, this.attractors, this.stepRings, this.rings, this.pulsars, this.pulsarBeams])
+      e.geometry.dispose(), e.material.dispose(), e.dispose();
+    this.material.dispose(), this.nebMaterial.dispose();
+  }
+  // ------------------------------------------------------------------ helpers
+  anchorIdx(e) {
+    const a = e.toLowerCase();
+    let o = this.nameIdx.get(a);
+    if (o === void 0) {
+      let n = 7;
+      for (let i = 0; i < a.length; i++) n = n * 31 + a.charCodeAt(i) >>> 0;
+      o = n % Math.max(1, this.nAnchors), this.nameIdx.set(a, o);
+    }
+    return o;
+  }
+  /** anchor in the nebula's local frame (rotated by the slow spin) */
+  anchorLocal(e, a) {
+    const o = Math.cos(this.nebAngle), n = Math.sin(this.nebAngle), i = this.aLocal[e * 3], l = this.aLocal[e * 3 + 2];
+    return a.set(i * o - l * n, this.aLocal[e * 3 + 1], i * n + l * o);
+  }
+  /** anchor on stage (the kit places + scales the side graph) */
+  anchorWorld(e, a) {
+    return me(this.anchorLocal(e, a), a);
+  }
+  slotOf(e) {
+    const a = this.idToSlot.get(e);
+    return a === void 0 ? null : this.slots[a];
+  }
+  /** stage position of a run's step attractor k (pool slot s) */
+  attractor(e, a, o) {
+    return o.set(this.rAt[e * 6 + a * 2], 0.35, this.rAt[e * 6 + a * 2 + 1]);
+  }
+  emitRing(e, a, o, n, i, l, d, r = 1) {
+    const t = this.ringNext++ % rt;
+    this.ringStart[t] = d, this.ringDur[t] = l, this.ringMax[t] = i, this.ringPos[t * 3] = e, this.ringPos[t * 3 + 1] = a, this.ringPos[t * 3 + 2] = o, this.ringCol[t * 3] = n.r * r, this.ringCol[t * 3 + 1] = n.g * r, this.ringCol[t * 3 + 2] = n.b * r;
+  }
+  alloc(e, a) {
+    const o = e.inst, n = this.slots.findIndex((r) => !r.used);
+    if (n < 0) return -1;
+    const i = this.slots[n], l = bt[o.type];
+    Object.assign(i, { used: !0, id: o.id, inst: o, ka: e, count: 0, released: !1, r: l.r, g: l.g, b: l.b, omega: 2, bright: 0.6, swirl: 0, p: 0, e: 0 }), i.tiltA = (K(n + a) - 0.5) * 0.7, i.tiltB = (K(n * 3.1 + a) - 0.5) * 0.7, i.rscale = ve(o.type) || e.depth > 0 ? 0.72 : 1, i.want = Math.round((i.rscale < 1 ? 380 : 620) * (mt ? 0.5 : 1));
+    const d = o.parent ? this.slotOf(o.parent) : null;
+    if (d ? (i.x = d.x, i.y = d.y, i.z = d.z) : (i.x = e.pos.x, i.y = 0.9, i.z = e.pos.z), this.idToSlot.set(o.id, n), this.emitRing(i.x, i.y, i.z, l, 2.4 * nt.scale, 0.9, a, 2.2), d) {
+      const r = this.idToSlot.get(o.parent);
+      let t = Math.floor(d.count * 0.28);
+      for (let s = 0; s < W && t > 0; s++)
+        this.fOwner[s] === r && s & 1 && (this.fOwner[s] = n, d.count--, i.count++, t--);
+    }
+    return n;
+  }
+  release(e, a) {
+    const o = this.slots[e], n = this.fP;
+    for (let i = 0; i < W; i++) {
+      if (this.fOwner[i] !== e) continue;
+      this.fOwner[i] = -1;
+      const l = n[i * 3] - o.x, d = n[i * 3 + 2] - o.z, r = Math.sqrt(l * l + d * d) + 1e-3, t = (2.4 + this.fRnd[i] * 3.6) * (mt ? 0.5 : 1);
+      this.fIvx[i] = l / r * t - d / r * o.omega * 0.5, this.fIvz[i] = d / r * t + l / r * o.omega * 0.5, this.fHeat[i] = 1, this.fT[i * 3] = o.r, this.fT[i * 3 + 1] = o.g, this.fT[i * 3 + 2] = o.b;
+    }
+    o.count = 0, G.setRGB(o.r, o.g, o.b).lerp(V, 0.5), this.emitRing(o.x, o.y, o.z, G, 3.2 * nt.scale, 1.1, a, 2.6);
+  }
+  /** Once per frame, after the kit's ticker (world tick -> lodTick -> kitTick). */
+  update(e, a, o) {
+    const n = Math.min(0.05, e);
+    this.lodK = nt.scale, this.frame++;
+    const i = Math.max(Et, Z.core.r + 20);
+    this.fieldR += (i - this.fieldR) * Math.min(1, n * 0.8), this.nebAngle += n * 0.04 * it, this.syncRuns(a, n), this.syncSlots(a, n, o), this.recruit(a), this.updateField(n, o), this.updateFlares(a), this.updateNebula(o), this.updateRunCurrents(a, o), this.updateStreams(a, o), this.updateMeshes(a, o, n);
+  }
+  syncRuns(e, a) {
+    var o;
+    this.rPresent.fill(0);
+    for (const n of Z.runs.values()) {
+      let i = this.runPool.get(n.id);
+      if (i === void 0) {
+        i = -1;
+        for (let l = 0; l < B; l++)
+          if (!this.runId[l] || this.rAlpha[l] < 0.01 && !this.runPool.has(this.runId[l])) {
+            i = l;
+            break;
+          }
+        if (i < 0)
+          for (let l = 0; l < B; l++) this.rAlpha[l] < 0.01 && !Z.runs.has(this.runId[l]) && (i = l, this.runPool.delete(this.runId[l]));
+        if (i < 0) continue;
+        this.runId[i] = n.id, this.runPool.set(n.id, i), this.rAlpha[i] = 0;
+      }
+      this.rPresent[i] = 1, this.runKit[i] = n, this.runRef[i] = n.run ?? q.runs.get(n.id) ?? null, this.rX[i] = n.origin.x, this.rZ[i] = n.origin.z, this.rR[i] = Math.max(2.6, Math.min(11, Math.hypot(n.hu, n.hv) * 0.92 + 0.6));
+      for (let l = 0; l < 3; l++)
+        ee(n, se(ze[l]), 0, R), this.rAt[i * 6 + l * 2] = R.x, this.rAt[i * 6 + l * 2 + 1] = R.z;
+      this.rSteps[i] = (o = this.runRef[i]) != null && o.hasSteps ? 1 : 0;
+    }
+    for (let n = 0; n < B; n++) {
+      this.rPresent[n] || this.runId[n] && this.rAlpha[n] < 0.01 && (this.runPool.get(this.runId[n]) === n && this.runPool.delete(this.runId[n]), this.runId[n] = "", this.runRef[n] = null, this.runKit[n] = null);
+      const i = this.runRef[n];
+      let l = 0;
+      i && this.rPresent[n] && (l = Math.min(1, (e - i.startedAt) / 1800), i.endedAt && (l *= Math.max(0, 1 - (e - i.endedAt - (Me - 3e3)) / 3e3))), i && i.color !== this.rColStr[n] && (this.rColStr[n] = i.color, this.rCol[n].set(i.color)), this.rAlpha[n] += (l - this.rAlpha[n]) * Math.min(1, a * 3);
+    }
+  }
+  syncSlots(e, a, o) {
+    const n = this.frame;
+    for (const d of Z.agents.values()) {
+      let r = this.idToSlot.get(d.id);
+      r !== void 0 && this.slots[r].ka !== d && (this.slots[r].ka = d), r === void 0 && (r = this.alloc(d, e)), !(r < 0) && (this.slots[r].seen = n, this.slots[r].inst = d.inst);
+    }
+    this.pendingByInst.clear();
+    for (const d of q.mcpPending.values()) this.pendingByInst.set(d.instance, Math.max(this.pendingByInst.get(d.instance) ?? 0, $t(d, e)));
+    const i = 1 - Math.exp(-a * 2.2), l = 1 - Math.exp(-a * 4);
+    for (let d = 0; d < Y; d++) {
+      const r = this.slots[d];
+      if (!r.used) continue;
+      const t = r.inst;
+      if (r.seen !== n) {
+        r.count > 0 && this.release(d, e), r.used = !1, r.inst = null, r.ka = null, this.idToSlot.delete(r.id);
+        continue;
+      }
+      const s = r.ka, m = s.pos.x, w = s.pos.z, S = 0.9 + Math.sin(o * 0.9 + d) * 0.18;
+      t.exitAt || (r.x += (m - r.x) * i, r.y += (S - r.y) * i, r.z += (w - r.z) * i), s.live.set(r.x, r.y, r.z), r.p = ye(t, e), r.e = be(t, e), r.waitMcp = this.pendingByInst.get(t.id) ?? -1;
+      const z = t.status === "thinking", v = t.status === "waiting";
+      let p = z ? 3.6 : v ? 0.7 : 2.2, y = z ? 1 : v ? 0.3 : 0.7;
+      r.waitMcp >= 0 && (p = 1, y = 0.45 + 0.3 * (0.5 + 0.5 * Math.sin(o * 3.2))), t.exitAt && (p = 0, y = 0), r.omega += (p * (1 + r.e * 0.7) * it - r.omega) * l, r.bright += (y + r.e * 1.2 - r.bright) * l, r.swirl = t.exitAt ? 0 : (z ? 1.6 : 0.6) * r.p * it, t.exitAt && !r.released && (r.released = !0, this.release(d, e));
+    }
+  }
+  recruit(e) {
+    const a = this.fP;
+    for (let o = 0; o < Y; o++) {
+      const n = this.slots[o];
+      if (!n.used || !n.inst || n.inst.exitAt) continue;
+      const i = (e - n.inst.bornAt) / 1e3, l = n.want * Math.min(1, i / 1.6);
+      for (let d = 0; d < 140 && n.count < l; d++) {
+        const r = Math.random() * W | 0;
+        if (this.fOwner[r] !== -1) continue;
+        const t = a[r * 3] - n.x, s = a[r * 3 + 2] - n.z;
+        t * t + s * s > 120 || (this.fOwner[r] = o, this.fAng[r] = Math.atan2(s, t), n.count++);
+      }
+    }
+  }
+  updateField(e, a) {
+    const o = this.fP, n = this.fC, i = this.fS, l = this.fOwner, d = this.slots, r = this.fRnd, t = e * it, s = a * it, m = 1 - Math.exp(-e * 2.8), w = Math.exp(-e * 0.5), S = Math.exp(-e * 1.3), z = 0.23 * s, v = 0.17 * s, p = 0.11 * s;
+    let y = 0;
+    for (let f = 0; f < B; f++)
+      this.rAlpha[f] < 0.01 || (this.aX[y] = this.rX[f], this.aZ[y] = this.rZ[f], this.aRR[y] = this.rR[f], this.aA[y] = this.rAlpha[f], this.aR[y * 3] = this.rCol[f].r, this.aR[y * 3 + 1] = this.rCol[f].g, this.aR[y * 3 + 2] = this.rCol[f].b, y++);
+    let I = 0;
+    for (const f of d)
+      !f.used || f.swirl <= 0.01 || (this.sX[I] = f.x, this.sZ[I] = f.z, this.sS[I] = f.swirl, I++);
+    const c = this.fieldR, b = c * c;
+    for (let f = 0; f < W; f++) {
+      const A = f * 3;
+      let M = o[A], g = o[A + 1], F = o[A + 2];
+      const _ = l[f];
+      if (_ >= 0) {
+        const O = d[_], k = this.fOrb[f] * O.rscale * (0.35 + 0.65 * O.p) * this.lodK, E = this.fAng[f] += O.omega * e / (0.3 + k), D = Math.cos(E), C = Math.sin(E), L = O.x + D * k, wt = O.z + C * k, It = O.y + (C * O.tiltA + D * O.tiltB) * k + (r[f] - 0.5) * 0.14;
+        M += (L - M) * m, g += (It - g) * m, F += (wt - F) * m;
+        const Mt = O.bright * (1.5 - k * 0.55) * (0.6 + 0.4 * r[f]);
+        n[A] = O.r * Mt + 0.05, n[A + 1] = O.g * Mt + 0.05, n[A + 2] = O.b * Mt + 0.05, i[f] = 0.5 + 0.35 * r[f];
+      } else {
+        const O = M * M + F * F, k = Math.sqrt(O) + 1e-4, E = k / 11, D = 1.25 * E / (1 + E * E);
+        let C = -F / k * D, L = M / k * D;
+        const wt = Math.sin(0.27 * M + z), It = Math.cos(0.27 * M + z), Mt = Math.sin(0.31 * F - v), jt = Math.cos(0.31 * F - v), Nt = 0.41 * F + 0.33 * M + p, ie = Math.sin(Nt), Wt = Math.cos(Nt);
+        C += (wt * -0.31 * Mt + 0.7 * 0.41 * Wt) * 3, L -= (0.27 * It * jt + 0.7 * 0.33 * Wt) * 3;
+        const Xt = wt * jt + 0.7 * ie + k * 0.09, Ct = 0.5 + 0.5 * Math.sin(Xt * 5.5), qt = Ct * Ct * Ct;
+        let Yt = 0, Kt = 0, Zt = 0;
+        for (let U = 0; U < y; U++) {
+          const H = M - this.aX[U], ct = F - this.aZ[U], yt = H * H + ct * ct, lt = this.aRR[U];
+          if (yt > lt * lt * 6.6) continue;
+          const Gt = Math.sqrt(yt) + 1e-4, Bt = Gt / lt, Ht = 2.6 * this.aA[U] * Bt * Math.exp(-Bt * Bt * 0.6);
+          C -= ct / Gt * Ht, L += H / Gt * Ht;
+          const Vt = Gt - lt, Ot = Math.exp(-Vt * Vt * 0.55) * this.aA[U];
+          Yt += this.aR[U * 3] * Ot, Kt += this.aR[U * 3 + 1] * Ot, Zt += this.aR[U * 3 + 2] * Ot;
+        }
+        for (let U = 0; U < I; U++) {
+          const H = M - this.sX[U], ct = F - this.sZ[U], yt = H * H + ct * ct;
+          if (yt > 16) continue;
+          const lt = this.sS[U] / (1 + yt * 0.9);
+          C -= ct * lt, L += H * lt;
+        }
+        C += this.fIvx[f], L += this.fIvz[f], this.fIvx[f] *= S, this.fIvz[f] *= S, M += C * t, F += L * t, g += (this.fYb[f] - g) * e * 1.2;
+        const Rt = this.fHeat[f] *= w, oe = C * C + L * L, Ft = (0.14 + qt * 2.8) * (0.6 + Math.min(1.2, oe * 0.3)) * (0.45 + 0.75 * r[f]), Pt = 0.5 + 0.5 * Math.sin(Xt * 1.3 + 1);
+        if (n[A] = (0.05 + 0.05 * Pt) * Ft + Yt * 0.42 + this.fT[A] * Rt * 1.8, n[A + 1] = (0.08 + 0.03 * Pt) * Ft + Kt * 0.42 + this.fT[A + 1] * Rt * 1.8, n[A + 2] = (0.2 - 0.04 * Pt) * Ft + Zt * 0.42 + this.fT[A + 2] * Rt * 1.8, i[f] = 0.26 + 0.2 * r[f] + qt * 0.12 + Rt * 0.35, O > b) {
+          const U = Math.sqrt(Math.random()) * c * 0.97, H = Math.random() * X;
+          M = Math.cos(H) * U, F = Math.sin(H) * U, this.fHeat[f] = 0, this.fIvx[f] = this.fIvz[f] = 0;
+        }
+      }
+      o[A] = M, o[A + 1] = g, o[A + 2] = F;
+    }
+    pt(this.fieldGeo);
+  }
+  updateFlares(e) {
+    if (this.burst.fill(0), this.burstW.fill(0), !this.nAnchors || !Z.graphWanted) return;
+    const a = Z.graph.scale;
+    for (const o of q.flares) {
+      const n = this.anchorIdx(o.node), i = (e - o.start) / 1e3, l = (1 - Math.exp(-i * 9)) * Math.exp(-i * 1.3);
+      if (o.id > this.lastFlareId) {
+        if (this.lastFlareId = o.id, this.anchorWorld(n, R), o.op === "write")
+          this.emitRing(R.x, R.y, R.z, V, 4.2 * a, 1.7, e, 2.4), this.emitRing(R.x, R.y, R.z, V, 2.2 * a, 1, e, 1.6);
+        else {
+          const d = q.instances.get(o.instance);
+          this.emitRing(R.x, R.y, R.z, d ? bt[d.type] : V, 1.1 * a, 0.7, e, 1.6);
+        }
+        this.lastFlare = { name: o.node, op: o.op, at: e, idx: n };
+      }
+      if (l > this.burst[n]) {
+        this.burst[n] = l;
+        const d = q.instances.get(o.instance), r = o.op === "write" ? V : d ? bt[d.type] : V;
+        this.flareCol[n * 3] = r.r, this.flareCol[n * 3 + 1] = r.g, this.flareCol[n * 3 + 2] = r.b, o.op === "write" && (this.burstW[n] = 1);
+      }
+    }
+  }
+  updateNebula(e) {
+    if (!this.nAnchors || !Z.graphWanted) return;
+    const a = j(this.nebGeo, "position"), o = j(this.nebGeo, "acol"), n = j(this.nebGeo, "size"), i = Math.cos(this.nebAngle), l = Math.sin(this.nebAngle), d = e * it, r = this.aLocal, t = this.aCol, s = this.flareCol;
+    for (let c = 0; c < ot; c++) {
+      const b = this.nA[c], f = this.burst[b], A = d * this.nSpin[c], M = Math.cos(A), g = Math.sin(A), F = this.nO[c * 3], _ = this.nO[c * 3 + 2], O = 1 + f * (2.2 + this.burstW[b] * 4.5), k = r[b * 3] + (F * M - _ * g) * O, E = r[b * 3 + 2] + (F * g + _ * M) * O, D = r[b * 3 + 1] + this.nO[c * 3 + 1] * O;
+      a[c * 3] = k * i - E * l, a[c * 3 + 1] = D, a[c * 3 + 2] = k * l + E * i;
+      const C = this.nB[c] * 0.3;
+      o[c * 3] = t[b * 3] * C + 0.05 + s[b * 3] * f * 2.4, o[c * 3 + 1] = t[b * 3 + 1] * C + 0.06 + s[b * 3 + 1] * f * 2.4, o[c * 3 + 2] = t[b * 3 + 2] * C + 0.12 + s[b * 3 + 2] * f * 2.4, n[c] = 0.3 + this.nB[c] * 0.2 + f * 0.5;
+    }
+    pt(this.nebGeo);
+    const m = j(this.anchorGeo, "position"), w = j(this.anchorGeo, "acol"), S = j(this.anchorGeo, "size"), z = this.nAnchors;
+    for (let c = 0; c < z; c++) {
+      const b = r[c * 3], f = r[c * 3 + 2];
+      m[c * 3] = b * i - f * l, m[c * 3 + 1] = r[c * 3 + 1], m[c * 3 + 2] = b * l + f * i;
+      const A = this.burst[c], M = this.aNamed[c] ? 2.2 : 1.1;
+      w[c * 3] = t[c * 3] * M + s[c * 3] * A * 7, w[c * 3 + 1] = t[c * 3 + 1] * M + s[c * 3 + 1] * A * 7, w[c * 3 + 2] = t[c * 3 + 2] * M + s[c * 3 + 2] * A * 7, S[c] = (this.aNamed[c] ? 1.25 : 0.75) * (1 + A * 3.5);
+    }
+    pt(this.anchorGeo);
+    const v = this.edgeGeo.getAttribute("position").array, p = this.edgeGeo.getAttribute("color").array, y = this.edgeA, I = this.nEdge * 2;
+    for (let c = 0; c < I; c++) {
+      const b = y[c], f = y[c ^ 1], A = r[b * 3], M = r[b * 3 + 2];
+      v[c * 3] = A * i - M * l, v[c * 3 + 1] = r[b * 3 + 1], v[c * 3 + 2] = A * l + M * i;
+      const g = Math.max(this.burst[b], this.burst[f] * 0.6);
+      p[c * 3] = t[b * 3] * 0.32 + 0.05 + s[b * 3] * g * 3, p[c * 3 + 1] = t[b * 3 + 1] * 0.32 + 0.06 + s[b * 3 + 1] * g * 3, p[c * 3 + 2] = t[b * 3 + 2] * 0.32 + 0.1 + s[b * 3 + 2] * g * 3;
+    }
+    this.edgeGeo.getAttribute("color").needsUpdate = !0, this.edgeGeo.getAttribute("position").needsUpdate = !0;
+  }
+  updateRunCurrents(e, a) {
+    const o = j(this.runGeo, "position"), n = j(this.runGeo, "acol"), i = j(this.runGeo, "size"), l = a * it, d = this.stTh, r = this.stB;
+    for (let t = 0; t < B; t++) {
+      const s = this.runRef[t], m = this.rAlpha[t], w = t * J;
+      if (!s || m < 0.01) {
+        for (let M = 0; M < J; M++) i[w + M] = 0;
+        continue;
+      }
+      const S = this.rX[t], z = this.rZ[t], v = this.rR[t];
+      for (let M = 0; M < 3; M++) {
+        const g = this.rAt[t * 6 + M * 2] - S, F = this.rAt[t * 6 + M * 2 + 1] - z;
+        d[M] = g * g + F * F < 0.6 ? -Math.PI / 2 : Math.atan2(F, g);
+        const _ = s.steps[st[M]];
+        r[M] = this.rSteps[t] ? _ === "running" ? 2.2 : _ === "done" ? 0.5 : 0 : 0;
+      }
+      const p = (e - s.handoffAt) / 1e3, y = this.rSteps[t] === 1 && s.handoffAt > 0 && p < 2.4, I = d[st.indexOf(s.handoffFrom)];
+      let c = (d[st.indexOf(s.handoffTo)] - I) % X;
+      c < 0 && (c += X);
+      const b = c * Math.min(1, 1 - Math.pow(1 - Math.min(1, p / 1.4), 3)), f = y ? 3.2 * (1 - p / 2.4) : 0, A = this.rCol[t];
+      for (let M = 0; M < J; M++) {
+        const g = w + M, F = this.rTh[g] + l * this.rSp[g], _ = v + this.rRr[g] + 0.16 * Math.sin(3 * F + l * 0.6 + g);
+        o[g * 3] = S + Math.cos(F) * _, o[g * 3 + 1] = 0.25 + this.rY[g], o[g * 3 + 2] = z + Math.sin(F) * _;
+        let O = 0;
+        for (let C = 0; C < 3; C++) {
+          if (r[C] === 0) continue;
+          let L = (F - d[C]) % X;
+          L < -Math.PI ? L += X : L > Math.PI && (L -= X), L > Math.PI && (L -= X), O += r[C] * Math.exp(-L * L * 2.2);
+        }
+        let k = 0;
+        if (y) {
+          let C = (F - I) % X;
+          if (C < 0 && (C += X), C <= b && C <= c + 0.1) {
+            const L = Math.exp(-(b - C) * 2.2);
+            O += f * (0.4 + L), k = 0.6 * L;
+          }
+        }
+        const E = Math.exp(-this.rRr[g] * this.rRr[g] * 4), D = m * (0.32 + 0.5 * E + O);
+        n[g * 3] = (A.r + (1 - A.r) * k) * D, n[g * 3 + 1] = (A.g + (1 - A.g) * k) * D, n[g * 3 + 2] = (A.b + (1 - A.b) * k) * D, i[g] = 0.36 + 0.28 * E + O * 0.12;
+      }
+    }
+    pt(this.runGeo);
+  }
+  updateStreams(e, a) {
+    const o = j(this.streamGeo, "position"), n = j(this.streamGeo, "acol"), i = j(this.streamGeo, "size");
+    let l = 0;
+    const d = (p, y, I, c, b, f, A) => {
+      l >= kt || (o[l * 3] = p, o[l * 3 + 1] = y, o[l * 3 + 2] = I, n[l * 3] = c, n[l * 3 + 1] = b, n[l * 3 + 2] = f, i[l] = A, l++);
+    }, r = (p, y, I, c, b) => {
+      const f = (p.x + y.x) / 2, A = (p.y + y.y) / 2 + I, M = (p.z + y.z) / 2, g = 1 - c;
+      return b.set(g * g * p.x + 2 * g * c * f + c * c * y.x, g * g * p.y + 2 * g * c * A + c * c * y.y, g * g * p.z + 2 * g * c * M + c * c * y.z);
+    };
+    for (let p = 0; p < B; p++) {
+      const y = this.runRef[p];
+      if (!y || !y.handoffAt) continue;
+      const I = (e - y.handoffAt) / 1e3;
+      if (I > 2.4 || !this.rSteps[p] || this.rAlpha[p] < 0.01) continue;
+      this.attractor(p, st.indexOf(y.handoffFrom), R), this.attractor(p, st.indexOf(y.handoffTo), N);
+      const c = this.rCol[p], b = 220;
+      for (let f = 0; f < b; f++) {
+        const A = (I - f / b * 1.4) / 0.9;
+        if (A < 0 || A > 1) continue;
+        r(R, N, 2.2, A, T);
+        const M = Math.sin(A * Math.PI) * 0.35, g = (1 - A * 0.4) * 2.4;
+        d(T.x + (K(f) - 0.5) * M, T.y + (K(f + 7) - 0.5) * M, T.z + (K(f + 13) - 0.5) * M, (c.r * 0.6 + 0.4) * g, (c.g * 0.6 + 0.4) * g, (c.b * 0.6 + 0.4) * g, 0.7 + (f % 9 === 0 ? 0.8 : 0));
+      }
+    }
+    for (const p of q.comets) {
+      const y = this.slotOf(p.from), I = this.slotOf(p.to);
+      if (!y || !I) continue;
+      const c = Math.min(1, (e - p.start) / p.dur), b = c < 0.5 ? 2 * c * c : 1 - Math.pow(-2 * c + 2, 2) / 2;
+      R.set(y.x, y.y, y.z), N.set(I.x, I.y, I.z);
+      const f = R.distanceTo(N), A = y.inst ? bt[y.inst.type] : V, M = c >= 1 ? Math.max(0, 1 - (e - p.start - p.dur) / 250) : 1;
+      for (let g = 0; g < 90; g++) {
+        const F = b - g * 55e-4;
+        if (F < 0) break;
+        r(R, N, 1.2 + f * 0.16, F, T);
+        const _ = g * 6e-3, O = (g === 0 ? 7 : 3.2 * Math.pow(1 - g / 90, 1.6)) * M;
+        d(T.x + (K(p.id + g) - 0.5) * _, T.y + (K(p.id * 3 + g) - 0.5) * _, T.z + (K(p.id * 7 + g) - 0.5) * _, (A.r * 0.7 + 0.3) * O, (A.g * 0.7 + 0.3) * O, (A.b * 0.7 + 0.3) * O, g === 0 ? 2.6 : 0.85 - g * 6e-3);
+      }
+    }
+    const t = this.beamGeo.getAttribute("position").array, s = this.beamGeo.getAttribute("color").array;
+    let m = 0;
+    const w = (p, y, I, c, b, f, A, M, g, F, _, O) => {
+      t.set([p, y, I, c, b, f], m * 6), s.set([A, M, g, F, _, O], m * 6), m++;
+    }, S = this.nAnchors > 0 && Z.graphWanted && Z.graph.mix > 0.05;
+    for (const p of q.flares) {
+      if (!S || m >= _t) break;
+      const y = this.slotOf(p.instance);
+      if (!y) continue;
+      const I = (e - p.start) / 2600;
+      if (I >= 1) continue;
+      this.anchorWorld(this.anchorIdx(p.node), N), R.set(y.x, y.y, y.z);
+      const c = p.op === "write", b = c ? V : y.inst ? bt[y.inst.type] : V, f = (1 - I) * (c ? 1.6 : 1);
+      w(R.x, R.y, R.z, N.x, N.y, N.z, b.r * f * 0.6, b.g * f * 0.6, b.b * f * 0.6, b.r * f * 1.4, b.g * f * 1.4, b.b * f * 1.4);
+      for (let A = 0; A < 22; A++) {
+        let M = ((e - p.start) / 1e3 * 0.75 + A / 22) % 1;
+        c || (M = 1 - M), r(R, N, 1.2, M, T);
+        const g = 2.4 * f * Math.sin(M * Math.PI);
+        d(T.x, T.y, T.z, b.r * g, b.g * g, b.b * g, 0.55);
+      }
+    }
+    for (const p of q.mcpCalls) {
+      const y = this.slotOf(p.instance), I = q.mcpServers.get(p.server), c = Tt(p.server);
+      if (!y || !I || !c) continue;
+      const b = (e - p.start) / p.dur;
+      if (b > 1) continue;
+      R.set(y.x, y.y, y.z), N.copy(c).setY(vt);
+      const f = p.phase === "call" ? R : N, A = p.phase === "call" ? N : R;
+      G.set(I.color);
+      const M = 1 - Math.pow(1 - b, 2);
+      for (let g = 0; g < 60; g++) {
+        const F = M - g * 8e-3;
+        if (F < 0) break;
+        r(f, A, 3, F, T);
+        const _ = (g === 0 ? 6 : 2.6 * (1 - g / 60)) * (p.phase === "result" ? 1.2 : 1);
+        d(T.x, T.y, T.z, (G.r * 0.75 + 0.25) * _, (G.g * 0.75 + 0.25) * _, (G.b * 0.75 + 0.25) * _, g === 0 ? 2.2 : 0.7);
+      }
+    }
+    let z = 0;
+    const v = (p, y, I, c) => {
+      if (z >= Lt) return;
+      const b = this.slotOf(p), f = q.mcpServers.get(y), A = Tt(y);
+      if (!b || !f || !A) return;
+      z++, R.set(b.x, b.y, b.z), N.copy(A).setY(vt), G.set(f.color), I < 2 ? G.lerp(Qt, Math.min(1, I / 2)) : G.copy(Qt).lerp(Fe, Math.min(1, I - 2));
+      const M = c >= 0 ? (1 - c) * 1.2 : 0.5 + Math.min(1.8, I * 0.6), g = a * 2.2;
+      let F = R.x, _ = R.y, O = R.z;
+      for (let k = 1; k <= St; k++) {
+        const E = k / St;
+        r(R, N, 3, E, T);
+        const D = 0.5 + 0.5 * Math.sin((E * 9 - g) * X * 0.5), C = M * (0.25 + 0.75 * D * D);
+        m < _t + Lt * St && w(F, _, O, T.x, T.y, T.z, G.r * C, G.g * C, G.b * C, G.r * C, G.g * C, G.b * C), F = T.x, _ = T.y, O = T.z;
+      }
+      if (c < 0) {
+        const k = 5 + Math.min(8, Math.floor(I * 3));
+        for (let E = 0; E < k; E++) {
+          const D = (a * (0.45 + I * 0.15) + E / k) % 1;
+          r(R, N, 3, D, T);
+          const C = M * 0.9;
+          d(T.x, T.y, T.z, G.r * C, G.g * C, G.b * C, 0.8);
+        }
+      } else {
+        const k = 1 - Math.min(1, c * 1.6);
+        for (let E = 0; E < 26; E++) {
+          const D = k + E * 0.012;
+          if (D > 1) break;
+          r(R, N, 3, D, T);
+          const C = (E === 0 ? 9 : 4 * (1 - E / 26)) * (1 - c * 0.5);
+          d(T.x, T.y, T.z, 0.6 * C + G.r * C * 0.4, 0.6 * C + G.g * C * 0.4, 0.6 * C + G.b * C * 0.4, E === 0 ? 2.8 : 0.9);
+        }
+      }
+    };
+    for (const p of q.mcpPending.values()) v(p.instance, p.server, $t(p, e), -1);
+    for (const p of q.mcpResolved) v(p.instance, p.server, (p.resolvedAt - p.since) / 1e3, Math.min(1, (e - p.resolvedAt) / 700));
+    for (let p = l; p < kt && i[p] !== 0; p++)
+      i[p] = 0;
+    this.streamGeo.setDrawRange(0, Math.max(l, 1)), pt(this.streamGeo), this.beamGeo.setDrawRange(0, m * 2), this.beamGeo.getAttribute("position").needsUpdate = !0, this.beamGeo.getAttribute("color").needsUpdate = !0;
+  }
+  setInst(e, a, o, n, i, l, d, r = 0, t = 0, s = 0) {
+    tt.position.set(o, n, i), tt.rotation.set(r, t, s), tt.scale.setScalar(Math.max(1e-4, l)), tt.updateMatrix(), e.setMatrixAt(a, tt.matrix), e.setColorAt(a, d);
+  }
+  updateMeshes(e, a, o) {
+    const n = j(this.glowGeo, "position"), i = j(this.glowGeo, "acol"), l = j(this.glowGeo, "size"), d = (t, s, m, w, S, z, v) => {
+      n[t * 3] = s, n[t * 3 + 1] = m, n[t * 3 + 2] = w, i[t * 3] = S.r * z, i[t * 3 + 1] = S.g * z, i[t * 3 + 2] = S.b * z, l[t] = v;
+    };
+    let r = null;
+    for (let t = 0; t < Y; t++) {
+      const s = this.slots[t];
+      if (!s.used || !s.inst) {
+        this.setInst(this.cores, t, 0, -999, 0, 0, G.setRGB(0, 0, 0)), l[t] = 0;
+        continue;
+      }
+      s.id === this.selectedId && (r = s);
+      const m = s.inst, w = (e - m.bornAt) / 1e3, S = Math.exp(-w * 3.5), z = m.exitAt ? (e - m.exitAt) / 1e3 : -1, v = z >= 0 ? Math.exp(-z * 5) : 0, y = m.status === "thinking" && !m.exitAt ? 0.1 * Math.sin(a * 9 + t) : 0, I = z >= 0 ? Math.pow(s.p, 1.6) : s.p, c = nt.scale, b = (I * (1 + s.e * 0.45 + y) + v * 0.9 + S * 0.6) * c;
+      G.setRGB(s.r, s.g, s.b).multiplyScalar(1.3 + s.bright * 1.5 + s.e * 1.1), G.lerp(Q.setRGB(4, 4, 4), Math.min(1, S + v)), this.setInst(this.cores, t, s.x, s.y, s.z, b, G, a * s.omega * 0.3, a * s.omega, 0), G.setRGB(s.r, s.g, s.b), d(t, s.x, s.y, s.z, G, (0.3 + s.bright * 0.4 + s.e * 0.5 + S * 2 + v * 2.5) * s.p + v, (5 + s.e * 4 + S * 10 + v * 14) * Math.max(s.p, v) * c);
+    }
+    r ? (this.selRing.visible = !0, this.selRing.position.set(r.x, r.y, r.z), this.selRing.rotation.y = a * 1.5, this.selRing.scale.setScalar(1 + 0.08 * Math.sin(a * 4)), this.selRing.material.color.setRGB(r.r * 3, r.g * 3, r.b * 3)) : this.selRing.visible = !1;
+    for (let t = 0; t < B; t++) {
+      const s = this.runRef[t], m = this.rAlpha[t];
+      for (let w = 0; w < 3; w++) {
+        const S = t * 3 + w, z = Y + S;
+        if (!s || m < 0.01 || !this.rSteps[t]) {
+          this.setInst(this.attractors, S, 0, -999, 0, 0, G.setRGB(0, 0, 0)), this.setInst(this.stepRings, S, 0, -999, 0, 0, G), l[z] = 0;
+          continue;
+        }
+        this.attractor(t, w, R);
+        const v = s.steps[st[w]], p = this.rCol[t];
+        let y = 0.6, I = 0.5, c = 0.25, b = 0.9, f = 0.12, A = 4;
+        if (G.copy(p), v === "running") {
+          const M = 0.5 + 0.5 * Math.sin(a * 5);
+          y = 1.15 + M * 0.2, G.lerp(V, 0.45), I = 3 + M * 1.5, c = 1.4 + M, b = 1.15 + M * 0.25, f = 1.1 + M * 0.6, A = 12;
+        } else v === "done" ? (y = 0.85, I = 1.8, c = 0.7, b = 0.95, f = 0.4, A = 6) : v === "failed" && G.copy(Pe);
+        if (s.handoffAt && st[w] === s.handoffTo) {
+          const M = (e - s.handoffAt) / 1e3 - 1.2;
+          if (M > 0 && M < 1) {
+            const g = Math.exp(-M * 4);
+            y += g * 0.8, f += g * 2, A += g * 10;
+          }
+        }
+        Q.copy(G).multiplyScalar(I * m), this.setInst(this.attractors, S, R.x, R.y, R.z, y, Q, 0, a * 0.6, 0), Q.copy(G).multiplyScalar(c * m), this.setInst(this.stepRings, S, R.x, R.y, R.z, b, Q, 0, v === "running" ? a * 1.6 : 0.3, 0), d(z, R.x, R.y, R.z, G, f * m, A);
+      }
+    }
+    for (let t = 0; t < ut; t++) {
+      const s = Y + B * 3 + t;
+      this.setInst(this.pulsars, t, 0, -999, 0, 0, G.setRGB(0, 0, 0)), this.setInst(this.pulsarBeams, t, 0, -999, 0, 0, G), l[s] = 0;
+    }
+    for (const t of q.mcpServers.values()) {
+      const s = t.slot % ut, m = Y + B * 3 + s, w = Tt(t.name);
+      if (!w) continue;
+      R.copy(w).setY(vt);
+      const S = Math.exp(-((e - t.activeAt) / 1e3) * 2.5), z = t.inflight > 0 ? 1 : 0;
+      this.mcpSpin[s] += o * (0.4 + z * 3.5) * it;
+      const v = 0.5 + 0.5 * Math.sin(a * (z ? 9 : 2.2) + s);
+      G.set(t.color), Q.copy(G).multiplyScalar(1.6 + z * 1.6 + S * 3 + v * 0.6), this.setInst(this.pulsars, s, R.x, R.y, R.z, 1 + S * 0.6 + z * 0.2 * v, Q, 0, this.mcpSpin[s], 0), Q.copy(G).multiplyScalar(0.25 + z * 0.9 * v + S * 0.8), this.setInst(this.pulsarBeams, s, R.x, R.y, R.z, 1 + z * 0.3, Q, 0.5 * Math.sin(this.mcpSpin[s] * 0.5), this.mcpSpin[s], 0.35 + 0.3 * Math.cos(this.mcpSpin[s])), d(m, R.x, R.y, R.z, G, 0.6 + z * 0.8 * v + S * 1.6, 9 + S * 12 + z * 4);
+    }
+    for (let t = 0; t < rt; t++) {
+      const s = (e - this.ringStart[t]) / (this.ringDur[t] * 1e3);
+      if (s < 0 || s >= 1) {
+        this.setInst(this.rings, t, 0, -999, 0, 0, G.setRGB(0, 0, 0));
+        continue;
+      }
+      const m = 1 - Math.pow(1 - s, 3), w = (1 - s) * (1 - s);
+      G.setRGB(this.ringCol[t * 3] * w, this.ringCol[t * 3 + 1] * w, this.ringCol[t * 3 + 2] * w), this.setInst(this.rings, t, this.ringPos[t * 3], this.ringPos[t * 3 + 1], this.ringPos[t * 3 + 2], 0.15 + this.ringMax[t] * m, G);
+    }
+    for (const t of [this.cores, this.attractors, this.stepRings, this.rings, this.pulsars, this.pulsarBeams])
+      t.instanceMatrix.needsUpdate = !0, t.instanceColor && (t.instanceColor.needsUpdate = !0);
+    pt(this.glowGeo);
+  }
+}
+const ht = new x.Vector3(), Oe = ["planner", "researcher", "writer"], at = { engine: null }, Ut = () => at.engine ?? (at.engine = new Be());
+function Te() {
+  const u = Ut(), e = le((o) => o.gl), a = Ge();
+  return At(() => {
+    u.setGalaxy(a);
+  }, [u, a]), At(() => {
+    u.material.uniforms.uPR.value = e.getPixelRatio(), u.nebMaterial.uniforms.uPR.value = e.getPixelRatio();
+  }, [u, e]), At(
+    () => () => {
+      u.dispose(), at.engine === u && (at.engine = null);
+    },
+    [u]
+  ), ft((o, n) => {
+    u.update(n, performance.now(), o.clock.elapsedTime);
+  }), /* @__PURE__ */ gt("group", { children: [
+    /* @__PURE__ */ P("points", { geometry: u.fieldGeo, material: u.material, frustumCulled: !1 }),
+    /* @__PURE__ */ P("points", { geometry: u.runGeo, material: u.material, frustumCulled: !1 }),
+    /* @__PURE__ */ P("points", { geometry: u.streamGeo, material: u.material, frustumCulled: !1 }),
+    /* @__PURE__ */ P("points", { geometry: u.glowGeo, material: u.material, frustumCulled: !1 }),
+    /* @__PURE__ */ P("lineSegments", { geometry: u.beamGeo, frustumCulled: !1, children: /* @__PURE__ */ P("lineBasicMaterial", { vertexColors: !0, transparent: !0, blending: x.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) }),
+    /* @__PURE__ */ P("primitive", { object: u.cores }),
+    /* @__PURE__ */ P("primitive", { object: u.attractors }),
+    /* @__PURE__ */ P("primitive", { object: u.stepRings }),
+    /* @__PURE__ */ P("primitive", { object: u.rings }),
+    /* @__PURE__ */ P("primitive", { object: u.pulsars }),
+    /* @__PURE__ */ P("primitive", { object: u.pulsarBeams }),
+    /* @__PURE__ */ P("primitive", { object: u.selRing })
+  ] });
+}
+function ke({ agent: u, selected: e, onSelect: a }) {
+  const o = $(null);
+  return At(() => {
+    const n = Ut();
+    e ? n.selectedId = u.id : n.selectedId === u.id && (n.selectedId = null);
+  }, [e, u.id]), At(
+    () => () => {
+      const n = at.engine;
+      n && n.selectedId === u.id && (n.selectedId = null);
+    },
+    [u.id]
+  ), ft(() => {
+    const n = o.current;
+    n && (n.position.copy(u.live), n.scale.setScalar(Math.max(0.6, nt.scale) * (u.depth ? 0.8 : 1)), n.visible = !u.inst.exitAt);
+  }), /* @__PURE__ */ gt(
+    "mesh",
+    {
+      ref: o,
+      onClick: (n) => (n.stopPropagation(), a(u.id)),
+      onPointerOver: () => document.body.style.cursor = "pointer",
+      onPointerOut: () => document.body.style.cursor = "",
+      children: [
+        /* @__PURE__ */ P("sphereGeometry", { args: [0.95, 10, 8] }),
+        /* @__PURE__ */ P("meshBasicMaterial", { transparent: !0, opacity: 0, depthWrite: !1, colorWrite: !1 })
+      ]
+    }
+  );
+}
+function Ee({ run: u }) {
+  Re();
+  const e = u.run ?? q.runs.get(u.id), a = $(null), o = $([]);
+  if (ft(() => {
+    var l;
+    (l = a.current) == null || l.position.set(u.origin.x, 0.6, u.origin.z - Math.min(11, Math.hypot(u.hu, u.hv) * 0.92 + 0.6) - 1.3);
+    for (let d = 0; d < 3; d++) {
+      const r = o.current[d];
+      r && (ee(u, se(Oe[d]), 0, ht), r.position.set(ht.x, 1.45 * Math.max(0.85, nt.scale), ht.z + 0.9 * nt.spread));
+    }
+  }), !e) return null;
+  const n = nt.w < 900, i = (l) => l === "running" ? e.color : l === "done" ? "#cbd5e1" : l === "failed" ? "#fecaca" : "#64748b";
+  return /* @__PURE__ */ gt(ce, { children: [
+    /* @__PURE__ */ P("group", { ref: a, children: /* @__PURE__ */ P(
+      xt,
+      {
+        text: `${e.hasSteps ? "hatchet · " : ""}${e.topic}`,
+        secondary: n ? void 0 : e.hasSteps ? st.map((l, d) => ({ text: `${d ? "  " : ""}${l.toUpperCase()}`, color: i(e.steps[l]) })) : e.status === "started" ? "running…" : "run complete",
+        secondarySize: 0.24,
+        color: e.color,
+        size: 0.32,
+        maxWidth: n ? 5 : 7,
+        fadeMs: 300,
+        pxRange: [10, 14]
+      }
+    ) }),
+    e.hasSteps && !n && st.map((l, d) => /* @__PURE__ */ P("group", { ref: (r) => void (o.current[d] = r), children: /* @__PURE__ */ P(
+      xt,
+      {
+        text: l,
+        font: "mono",
+        plate: "none",
+        uppercase: !0,
+        letterSpacing: 0.08,
+        textColor: e.color,
+        size: 0.24,
+        opacity: e.steps[l] === "running" ? 1 : e.steps[l] === "done" ? 0.75 : 0.55,
+        fadeMs: 300,
+        pxRange: [7.5, 10.5]
+      }
+    ) }, l))
+  ] });
+}
+function _e({ mcp: u }) {
+  const e = $(null), a = u.target.x >= 0;
+  return ft(() => {
+    var o;
+    return (o = e.current) == null ? void 0 : o.position.set(u.pos.x + (a ? 0.9 : -0.9), vt, u.pos.z);
+  }), /* @__PURE__ */ P("group", { ref: e, children: /* @__PURE__ */ P(xt, { text: `mcp · ${u.name}`, anchorX: a ? "left" : "right", color: u.srv.color, size: 0.28, pxRange: [8.5, 12] }) });
+}
+function Le(u) {
+  const e = Ut();
+  return ft(() => {
+    e.nebMaterial.uniforms.uScale.value = e.material.uniforms.uScale.value * Z.graph.scale;
+  }), /* @__PURE__ */ gt("group", { children: [
+    /* @__PURE__ */ P("points", { geometry: e.nebGeo, material: e.nebMaterial, frustumCulled: !1 }),
+    /* @__PURE__ */ P("points", { geometry: e.anchorGeo, material: e.nebMaterial, frustumCulled: !1 }),
+    /* @__PURE__ */ P("lineSegments", { geometry: e.edgeGeo, frustumCulled: !1, children: /* @__PURE__ */ P("lineBasicMaterial", { vertexColors: !0, transparent: !0, blending: x.AdditiveBlending, depthWrite: !1, toneMapped: !1 }) }),
+    /* @__PURE__ */ P(we, { position: [0, -0.6, Dt + 0.9], color: "#a5b4fc", size: 0.34, pxRange: [9.5, 13] })
+  ] });
+}
+function De() {
+  const u = $(null), e = $(null), a = $("");
+  return ft(() => {
+    var r;
+    const o = at.engine;
+    if (!o) return;
+    const n = o.selectedId ?? q.focus, i = n ? o.slotOf(n) : null, l = !!i && !!i.inst && !i.inst.exitAt;
+    if ((r = e.current) == null || r.setOpacity(l ? 1 : 0), !i || !i.inst || !u.current || !e.current) return;
+    u.current.position.set(i.x, i.y + 1.25 * Math.max(0.85, nt.scale), i.z);
+    const d = i.inst.name + " · " + i.inst.status;
+    d !== a.current && (a.current = d, e.current.setText(d), e.current.setColor(ne[i.inst.type]));
+  }), /* @__PURE__ */ P("group", { ref: u, children: /* @__PURE__ */ P(xt, { ref: e, text: "", size: 0.3, opacity: 0, fadeMs: 300, pxRange: [9, 13], renderOrder: 24 }) });
+}
+function Ue() {
+  const u = $(null), e = $(null), a = $("");
+  return ft(() => {
+    const o = at.engine, n = o == null ? void 0 : o.lastFlare;
+    if (!o || !n || !u.current || !e.current) return;
+    const i = (performance.now() - n.at) / 1e3;
+    e.current.setOpacity(i < 2.2 && Z.graphWanted ? 1 : 0), o.anchorWorld(n.idx, ht), u.current.position.set(ht.x, ht.y + 0.9, ht.z), a.current !== n.name + n.op && (a.current = n.name + n.op, e.current.setText((n.op === "write" ? "wrote · " : "read · ") + n.name), e.current.setColor(n.op === "write" ? "#ffffff" : "#a5b4fc"));
+  }), /* @__PURE__ */ P("group", { ref: u, children: /* @__PURE__ */ P(xt, { ref: e, text: "", size: 0.28, opacity: 0, fadeMs: 400, pxRange: [8.5, 12], renderOrder: 24 }) });
+}
+function Ke() {
+  const u = pe(() => ({ nRef: 4, min: 0.62, max: 1.45, minRadius: 7 }), []);
+  return /* @__PURE__ */ gt(
+    xe,
+    {
+      title: "flow · murmuration",
+      subtitle: "agents are eddies condensing out of the current · hatchet runs are vortices · the knowledge graph is a nebula current on the side",
+      preset: "drift",
+      plane: "xz",
+      camera: { position: [0, 25, 28], fov: 50 },
+      controls: { maxPolarAngle: Math.PI * 0.47 },
+      bg: "#020309",
+      gl: { antialias: !1 },
+      fit: u,
+      agentRadius: 1.6,
+      graph: { natural: Dt, radius: 3.6 },
+      peripheryGap: 4.5,
+      Agent: ke,
+      RunMarker: Ee,
+      McpServer: _e,
+      GraphResource: Le,
+      cluster: { radius: 1.7, variant: "swarm", pointSize: 1.1 },
+      clusterOffset: [0, 1.8, 0],
+      PostFX: /* @__PURE__ */ gt(he, { multisampling: 0, children: [
+        /* @__PURE__ */ P(fe, { mipmapBlur: !0, intensity: 1.25, luminanceThreshold: 0.22, luminanceSmoothing: 0.25, radius: 0.78 }),
+        /* @__PURE__ */ P(ue, { eskil: !1, offset: 0.22, darkness: 0.85 }),
+        /* @__PURE__ */ P(de, { opacity: 0.03 })
+      ] }),
+      children: [
+        /* @__PURE__ */ P(Te, {}),
+        /* @__PURE__ */ P(De, {}),
+        /* @__PURE__ */ P(Ue, {})
+      ]
+    }
+  );
+}
+export {
+  Ke as default
+};