agentglow 0.4.1 → 0.4.2

package/dist/chunks/index-BGWvBQoI.js

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