feat(frontier): moe+formalmath+ccattest+ringattn surfaces+tabs (organs on killinchu)

Surfaces 22-25. Poll killinchu cross-origin. MODELED. Nothing in locked-8; Lambda stays Conjecture 1.

static/3d/holographic.html

@@ -80,6 +80,10 @@ const SURFACES = [
   { id: "specdecode", title: "Speculative Decoding", mod: "/static/3d/surfaces/specdecode.js" },
   { id: "flowmatch", title: "Flow Matching", mod: "/static/3d/surfaces/flowmatch.js" },
   { id: "dllm", title: "Diffusion LLM", mod: "/static/3d/surfaces/dllm.js" },
+  { id: "moe", title: "MoE Router", mod: "/static/3d/surfaces/moe.js" },
+  { id: "formalmath", title: "Formal-Math Retrieval", mod: "/static/3d/surfaces/formalmath.js" },
+  { id: "ccattest", title: "Confidential-Compute Attest", mod: "/static/3d/surfaces/ccattest.js" },
+  { id: "ringattn", title: "Ring Attention", mod: "/static/3d/surfaces/ringattn.js" },
   { id: "energy",      title: "Energy",      mod: "/static/3d/surfaces/energy.js" },
   { id: "fabric",      title: "Fabric",      mod: "/static/3d/surfaces/fabric.js" },
   { id: "pnt",         title: "PNT",         mod: "/static/3d/surfaces/pnt.js" },

static/3d/surfaces/ccattest.js

@@ -0,0 +1,422 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/ccattest.js — CONFIDENTIAL-COMPUTE ATTESTATION CHAIN (TEE / NVIDIA H100 CC)
+// organ for the holographic frontier ring. DISTINCT from the L6 chain-of-title receipt
+// organ (governance/provenance/sovereign-compute doctrine) — this is a hardware-
+// attestation hash-chain simulation, not a build/agent-action provenance receipt.
+//
+// Renders a vertical lattice-blue tower of stacked hash-blocks driven by a live
+// deterministic snapshot from /api/killinchu/v1/cc-attest/verify:
+//   device_identity (sha384) -> measurement_chain[] (bootloader -> firmware -> driver ->
+//   microcode -> gpu-vbios) -> final_digest -> golden_match (bool).
+// Each block in the tower is one measurement-log stage; blocks whose chained digest
+// matches the fixed golden reference glow proof-teal, non-matching/pending blocks are
+// grey. A HUD shows golden_match + a truncated final_digest. Honesty label "MODELED" is
+// read VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors testtime.js / neuromorphic.js / interpretability.js):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   label, seed, stages, device_identity, measurement_chain[{stage,digest}],
+//   final_digest, golden_match, honest_note
+//
+// CONCEPT CITED (clean-room; NOT claimed as SZL's own; NO real GPU/TEE/network used):
+//   NVIDIA, "Confidential Computing on H100 GPUs for Secure and Trustworthy AI" (2023):
+//   https://developer.nvidia.com/blog/confidential-computing-on-h100-gpus-for-secure-and-trustworthy-ai/
+//
+// HONESTY LABEL: MODELED (deterministic sha256/sha384 hash-chain simulation of the TEE +
+//   H100 CC attestation concept; NOT a real TDX/SEV-SNP/NRAS verifier; NEVER-CLAIMED-AS
+//   actual hardware attestation). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (pending/tower body), proof-teal 0x3af4c8 (golden-match
+//   glow ring), violet-blue 0x8a6bff (device-identity marker, data-viz only), greys for
+//   pending/unverified/degraded. Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100% — the
+// attestation is MODELED, not real trust.
+
+const ID    = "ccattest";
+const TITLE = "Confidential-Compute Attestation Chain · TEE / H100 CC (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/cc-attest/verify?seed=42&stages=5";
+
+// data-viz hues — purple BANNED
+const C_BLOCK   = 0x5b8dee;  // lattice-blue (tower block body)
+const C_IDENT   = 0x8a6bff;  // violet-blue (device-identity marker — data-viz only)
+const C_DIM     = 0x42505d;  // grey (pending / unverified / no-live-data)
+const C_ACCENT  = 0x3af4c8;  // proof-teal (golden-match glow ring / HUD accent)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// tower layout geometry
+const BLOCK_H     = 1.1;    // world-units, height of one hash-block
+const BLOCK_W     = 2.2;    // world-units, block footprint (X/Z)
+const BLOCK_GAP   = 0.22;   // world-units, gap between stacked blocks
+const MAX_BLOCKS  = 5;      // bootloader..gpu-vbios
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _blocks   = [];   // Array<{ mesh: THREE.Mesh, ring: THREE.Mesh }> — stacked hash-blocks
+let _identMarker = null;  // THREE.Mesh — device-identity marker (base of tower)
+let _floor    = null;
+
+// live state
+const S = {
+  label:      null,
+  seed:       null,
+  stagesReq:  null,
+  deviceId:   null,   // device_identity hex
+  chain:      null,   // measurement_chain[]
+  finalDigest:null,
+  goldenMatch:null,   // bool
+  honestNote: null,
+  state:      "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(3, 7, 14);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 3, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildIdentMarker();
+  _buildTower();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onAttest, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(30, 30, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+function _buildIdentMarker() {
+  const THREE = _THREE;
+  _identMarker = new THREE.Mesh(
+    new THREE.OctahedronGeometry(0.4, 0),
+    new THREE.MeshStandardMaterial({ color: C_IDENT, emissive: C_IDENT, emissiveIntensity: 0.35, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _identMarker.position.set(0, 0.35, 0);
+  _group.add(_identMarker);
+}
+
+// Pre-allocate MAX_BLOCKS stacked hash-block meshes + glow rings; visibility and
+// colour are updated in-place as live data arrives (no per-poll geometry churn).
+function _buildTower() {
+  const THREE = _THREE;
+  const boxGeo = new THREE.BoxGeometry(BLOCK_W, BLOCK_H, BLOCK_W);
+  const ringGeo = new THREE.TorusGeometry(BLOCK_W * 0.62, 0.05, 8, 24);
+
+  for (let i = 0; i < MAX_BLOCKS; i++) {
+    const y = 0.9 + i * (BLOCK_H + BLOCK_GAP);
+
+    const mat = new THREE.MeshStandardMaterial({
+      color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.15,
+      transparent: true, opacity: 0.5, wireframe: false,
+    });
+    const mesh = new THREE.Mesh(boxGeo, mat);
+    mesh.position.set(0, y, 0);
+    mesh.visible = false;
+    _group.add(mesh);
+
+    const ringMat = new THREE.MeshBasicMaterial({ color: C_ACCENT, transparent: true, opacity: 0.0 });
+    const ring = new THREE.Mesh(ringGeo, ringMat);
+    ring.position.set(0, y, 0);
+    ring.rotation.x = Math.PI / 2;
+    ring.visible = false;
+    _group.add(ring);
+
+    _blocks.push({ mesh, ring, y });
+  }
+
+  // vertical spine (edge lines) connecting block centers, grey, data-viz only
+  const spinePts = [];
+  for (let i = 0; i < MAX_BLOCKS; i++) spinePts.push(new THREE.Vector3(0, _blocks[i].y, 0));
+  const spineGeo = new THREE.BufferGeometry().setFromPoints(spinePts);
+  const spine = new THREE.Line(spineGeo, new THREE.LineBasicMaterial({ color: C_GRID, transparent: true, opacity: 0.5 }));
+  _group.add(spine);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onAttest(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label       = (j.label || "MODELED").toUpperCase();
+  S.seed        = typeof j.seed === "number" ? j.seed : null;
+  S.stagesReq   = typeof j.stages === "number" ? j.stages : null;
+  S.deviceId    = typeof j.device_identity === "string" ? j.device_identity : null;
+  S.chain       = Array.isArray(j.measurement_chain) ? j.measurement_chain : null;
+  S.finalDigest = typeof j.final_digest === "string" ? j.final_digest : null;
+  S.goldenMatch = typeof j.golden_match === "boolean" ? j.golden_match : null;
+  S.honestNote  = typeof j.honest_note === "string" ? j.honest_note : null;
+
+  _updateTower();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the stacked hash-block tower from live data
+// =============================================================================
+function _updateTower() {
+  const live = S.state === "live";
+
+  if (live && S.chain && S.chain.length) {
+    const n = Math.min(MAX_BLOCKS, S.chain.length);
+    for (let i = 0; i < MAX_BLOCKS; i++) {
+      const b = _blocks[i];
+      if (i < n) {
+        b.mesh.visible = true;
+        // Golden-match applies to the CHAIN AS A WHOLE (final_digest comparison);
+        // if golden_match is true, light every realized block proof-teal to show
+        // the whole verified chain; otherwise blocks stay lattice-blue (present,
+        // computed) but the top block + ring signal the mismatch in grey/teal below.
+        const isFinal = i === n - 1;
+        const verified = S.goldenMatch === true;
+        b.mesh.material.color.setHex(verified ? C_ACCENT : C_BLOCK);
+        b.mesh.material.emissive.setHex(verified ? C_ACCENT : C_BLOCK);
+        b.mesh.material.emissiveIntensity = verified ? 0.55 : 0.25;
+        b.mesh.material.opacity = 0.88;
+
+        b.ring.visible = isFinal;
+        if (isFinal) {
+          b.ring.material.color.setHex(verified ? C_ACCENT : C_DIM);
+          b.ring.material.opacity = verified ? 0.9 : 0.35;
+        }
+      } else {
+        b.mesh.visible = false;
+        b.ring.visible = false;
+      }
+    }
+  } else {
+    _blocks.forEach((b) => {
+      b.mesh.visible = false;
+      b.ring.visible = false;
+    });
+  }
+
+  if (_identMarker) {
+    if (live && S.deviceId) {
+      _identMarker.material.color.setHex(C_IDENT);
+      _identMarker.material.emissive.setHex(C_IDENT);
+      _identMarker.material.opacity = 0.85;
+    } else {
+      _identMarker.material.color.setHex(C_DIM);
+      _identMarker.material.emissive.setHex(C_DIM);
+      _identMarker.material.opacity = 0.3;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00009) * 0.12;
+  if (_identMarker) {
+    _identMarker.rotation.y += 0.015;
+    _identMarker.rotation.x += 0.008;
+  }
+  // pulse the top (final-digest) glow ring, if visible and golden_match
+  for (const b of _blocks) {
+    if (b.ring.visible && S.goldenMatch === true) {
+      const pulse = 1.0 + 0.12 * Math.sin(t * 0.0035);
+      b.ring.scale.setScalar(pulse);
+    }
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A deterministic <b>sha256/sha384 hash-chain</b> stand-in for a TEE + ' +
+    '<b>NVIDIA H100 Confidential Computing</b>-style measured-boot attestation: ' +
+    'device identity \\u2192 ordered stage digests \\u2192 final digest checked ' +
+    'against a fixed golden reference. Honesty label <b>MODELED</b> \\u2014 NOT a real ' +
+    'TDX/SEV-SNP/NRAS verifier, no real key material, no live GPU, no network. 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "cc-attest";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:62%;overflow-wrap:anywhere";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("cc-seed",   "seed"));
+  grid.appendChild(kpiRow("cc-stages", "stages (measurement log depth)"));
+  grid.appendChild(kpiRow("cc-ident",  "device identity (sha384, truncated)"));
+  grid.appendChild(kpiRow("cc-final",  "final digest (truncated)"));
+  grid.appendChild(kpiRow("cc-golden", "golden_match \\u2014 MODELED"));
+  grid.appendChild(kpiRow("cc-label",  "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "NVIDIA, \"Confidential Computing on H100 GPUs for Secure and Trustworthy AI\" (2023), developer.nvidia.com/blog/confidential-computing-on-h100-gpus-for-secure-and-trustworthy-ai. MODELED \\u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "cc-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const match = S.goldenMatch === true ? "MATCHES" : (S.goldenMatch === false ? "does NOT match" : "loading\u2026");
+  pd.innerHTML =
+    "<b>What this means:</b> Real NVIDIA H100 Confidential-Computing hardware boots " +
+    "through a measured sequence \\u2014 bootloader, firmware, driver, microcode, GPU " +
+    "VBIOS \\u2014 and produces a signed attestation report a relying party checks " +
+    "against NVIDIA's remote attestation service before trusting the GPU with secrets. " +
+    "This view is a <b>toy stand-in</b>: it hashes together a synthetic device ID and a " +
+    "chain of stage names with plain SHA-256/SHA-384, then compares the result to a " +
+    "single fixed \\u201cgolden\\u201d value. Right now the computed chain <b>" + match +
+    "</b> that golden value. There is <b>no real GPU, no real key, and no network call</b> " +
+    "involved \\u2014 it exists to show how attestation-chain verification WORKS, not to " +
+    "perform one. Plain: this is a labeled toy model of a real security concept, not a " +
+    "working hardware verifier.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function _trunc(s, n) { return typeof s === "string" ? (s.length > n ? s.slice(0, n) + "\u2026" : s) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("cc-seed",   t || (S.seed != null ? String(S.seed) : "\u2014"));
+  _set("cc-stages", t || (S.stagesReq != null ? String(S.stagesReq) : "\u2014"));
+  _set("cc-ident",  t || _trunc(S.deviceId, 20));
+  _set("cc-final",  t || _trunc(S.finalDigest, 20));
+  _set("cc-golden", t || (S.goldenMatch === true ? "MATCH" : (S.goldenMatch === false ? "MISMATCH" : "\u2014")));
+  // honesty label verbatim — never upgraded
+  _set("cc-label",  t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _blocks = []; _identMarker = null; _floor = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.seed = S.stagesReq = S.deviceId = S.chain = null;
+  S.finalDigest = S.goldenMatch = S.honestNote = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/formalmath.js

@@ -0,0 +1,491 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/formalmath.js — FORMAL-MATH RETRIEVAL-AUGMENTED TACTIC SELECTION organ
+// for the holographic frontier ring (LeanDojo/ReProver-style premise retrieval +
+// best-first proof search). Renders the synthetic tactic tree explored by the live
+// snapshot from /api/killinchu/v1/formalmath/retrieve as a branching lattice-blue
+// wireframe: nodes sized/colored proof-teal by retrieval similarity (the branch's
+// premise_bias score), grey dashed edges mark unexplored/pruned branches beyond the
+// live search_trace. A HUD shows the top retrieved premise + the tree depth reached.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is; it is
+// never upgraded.
+//
+// Surface export shape (mirrors testtime.js / specdecode.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   goal, corpus_size, k, top_k_premises[], similarity_scores{},
+//   simulated_proof_tree_depth, nodes_expanded, search_trace[]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   LeanDojo (premise-annotated Lean data/benchmark toolkit):
+//     Yang et al. 2023, NeurIPS (Datasets and Benchmarks Track)
+//     https://github.com/lean-dojo/LeanDojo
+//   ReProver (Retrieval-Augmented Prover; ByT5 premise retriever + tactic generator):
+//     lean-dojo/ReProver
+//     https://github.com/lean-dojo/ReProver
+//   DeepSeek-Prover-V2 (subgoal decomposition + recursive proof search for Lean 4):
+//     DeepSeek-AI et al. 2025, arXiv:2504.21801
+//     https://arxiv.org/abs/2504.21801
+//
+// HONESTY LABELS: MODELED (deterministic bag-of-tokens cosine retrieval + best-first
+//   search simulation; NOT connected to Lean 4 or Mathlib; NEVER-CLAIMED-AS
+//   DeepSeek-Prover or ReProver output). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (tactic-tree wireframe / explored edges), proof-teal
+//   0x3af4c8 (nodes sized/colored by retrieval similarity / HUD accent), greys
+//   (unexplored/pruned branches, degraded state). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "formalmath";
+const TITLE = "Formal-Math Retrieval-Augmented Tactic Selection (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the formal-math organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/formalmath/retrieve?seed=42&goal=theorem%20add_comm_example%20(a%20b%20%3A%20Nat)%20%3A%20a%20%2B%20b%20%3D%20b%20%2B%20a&corpus_size=24&k=5";
+
+// data-viz hues — purple BANNED
+const C_TREE    = 0x5b8dee;  // lattice-blue (tactic-tree wireframe / explored edges)
+const C_NODE    = 0x3af4c8;  // proof-teal (nodes, sized/colored by retrieval similarity)
+const C_UNEXPL  = 0x5a6570;  // grey (unexplored / pruned branch, dashed)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// tactic-tree layout geometry
+const DEPTH_LEN   = 2.4;   // world-units between depth levels along X
+const LANE_GAP    = 1.1;   // world-units between sibling nodes (Y)
+const MAX_DEPTH   = 6;     // matches server _MAX_DEPTH
+const MAX_TRACE   = 64;    // matches server search_trace cap
+const BRANCH      = 3;     // matches server _BRANCH_FACTOR (layout hint only)
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _floor        = null;
+let _spine        = null;                 // THREE.Line — root->depth axis
+let _nodeMesh     = [];                   // Array<THREE.Mesh> — one per trace slot
+let _edgeLines    = [];                   // Array<THREE.Line> — explored edges (lattice-blue)
+let _unexplLines  = [];                   // Array<THREE.Line> — grey dashed unexplored-branch stubs
+let _marker       = null;                 // THREE.Mesh — HUD "top premise" pulsing marker
+
+// live state
+const S = {
+  label:        null,
+  goal:         null,   // goal
+  corpusSize:   null,   // corpus_size
+  k:            null,   // k
+  topPremises:  null,   // top_k_premises[]
+  simScores:    null,   // similarity_scores{}
+  treeDepth:    null,   // simulated_proof_tree_depth
+  nodesExpand:  null,   // nodes_expanded
+  trace:        null,   // search_trace[]
+  state:        "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(5, 8, 20);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(6, 2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildLattice();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onFormalmath, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Pre-allocate a fixed pool of node meshes + edge/unexplored-branch lines sized to
+// MAX_TRACE; we toggle visibility/position/color in-place as live data arrives
+// (no per-poll geometry churn).
+function _buildLattice() {
+  const THREE = _THREE;
+
+  // root->depth spine (visual reading guide only)
+  {
+    const pts = [new THREE.Vector3(0, 0, 0), new THREE.Vector3(DEPTH_LEN * MAX_DEPTH, 0, 0)];
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_TREE, transparent: true, opacity: 0.35 });
+    _spine = new THREE.Line(geo, mat);
+    _group.add(_spine);
+  }
+
+  const nodeGeo = new THREE.IcosahedronGeometry(0.16, 0);
+  for (let i = 0; i < MAX_TRACE; i++) {
+    const mesh = new THREE.Mesh(
+      nodeGeo,
+      new THREE.MeshStandardMaterial({ color: C_NODE, emissive: C_NODE, emissiveIntensity: 0.35, wireframe: true, transparent: true, opacity: 0.0 }),
+    );
+    mesh.visible = false;
+    _group.add(mesh);
+    _nodeMesh.push(mesh);
+
+    // explored-edge line (parent -> this node), lattice-blue wireframe-style
+    const edgeGeo = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(0, 0, 0), new THREE.Vector3(0, 0, 0)]);
+    const edgeMat = new THREE.LineBasicMaterial({ color: C_TREE, transparent: true, opacity: 0.0 });
+    const edge = new THREE.Line(edgeGeo, edgeMat);
+    edge.visible = false;
+    _group.add(edge);
+    _edgeLines.push(edge);
+
+    // unexplored/pruned-branch stub: short grey dashed line hinting at a
+    // branch beyond what the bounded search_trace sample shows
+    const unGeo = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(0, 0, 0), new THREE.Vector3(0, 0, 0)]);
+    const unMat = new THREE.LineDashedMaterial({ color: C_UNEXPL, transparent: true, opacity: 0.0, dashSize: 0.12, gapSize: 0.09 });
+    const un = new THREE.Line(unGeo, unMat);
+    un.computeLineDistances();
+    un.visible = false;
+    _group.add(un);
+    _unexplLines.push(un);
+  }
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.OctahedronGeometry(0.24, 0),
+    new THREE.MeshStandardMaterial({ color: C_NODE, emissive: C_NODE, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, 1.4, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onFormalmath(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label       = (j.label || "MODELED").toUpperCase();
+  S.goal        = typeof j.goal === "string" ? j.goal : null;
+  S.corpusSize  = typeof j.corpus_size === "number" ? j.corpus_size : null;
+  S.k           = typeof j.k === "number" ? j.k : null;
+  S.topPremises = Array.isArray(j.top_k_premises) ? j.top_k_premises : null;
+  S.simScores   = (j.similarity_scores && typeof j.similarity_scores === "object") ? j.similarity_scores : null;
+  S.treeDepth   = typeof j.simulated_proof_tree_depth === "number" ? j.simulated_proof_tree_depth : null;
+  S.nodesExpand = typeof j.nodes_expanded === "number" ? j.nodes_expanded : null;
+  S.trace       = Array.isArray(j.search_trace) ? j.search_trace : null;
+
+  _updateLattice();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the branching lattice from live search_trace[]
+// =============================================================================
+// Layout: each trace entry gets a lane index within its depth level (stable
+// hash of node_id keeps lanes reproducible across polls), positioned at
+// x = depth * DEPTH_LEN, y = (lane - laneCount/2) * LANE_GAP.
+function _laneFor(nodeId, depth, seenAtDepth) {
+  const n = seenAtDepth.get(depth) || 0;
+  seenAtDepth.set(depth, n + 1);
+  return n;
+}
+
+function _updateLattice() {
+  const THREE = _THREE;
+  const live = S.state === "live";
+  const trace = live && S.trace && S.trace.length ? S.trace.slice(0, MAX_TRACE) : [];
+
+  // find max similarity among top_k_premises for node-size/color normalization
+  let maxSim = 0.0;
+  if (live && S.topPremises && S.topPremises.length) {
+    maxSim = S.topPremises.reduce((m, p) => Math.max(m, p.similarity || 0), 0);
+  }
+  const simByName = {};
+  if (live && S.topPremises) S.topPremises.forEach((p) => { simByName[p.name] = p.similarity; });
+
+  const seenAtDepth = new Map();
+  const posByNodeId = new Map();
+
+  for (let i = 0; i < MAX_TRACE; i++) {
+    const mesh = _nodeMesh[i];
+    const edge = _edgeLines[i];
+    const un   = _unexplLines[i];
+
+    if (i >= trace.length || !live) {
+      mesh.visible = false;
+      edge.visible = false;
+      un.visible = false;
+      continue;
+    }
+
+    const row = trace[i];
+    const depth = Math.min(MAX_DEPTH, row.depth || 0);
+    const lane = _laneFor(row.node_id, depth, seenAtDepth);
+    const laneCountEstimate = Math.max(1, Math.pow(BRANCH, depth));
+    const x = depth * DEPTH_LEN;
+    const y = (lane - laneCountEstimate / 2) * LANE_GAP * (1 / Math.max(1, Math.log2(laneCountEstimate + 1)));
+    posByNodeId.set(row.node_id, { x, y, depth });
+
+    // node size/color driven by this branch's premise_bias similarity
+    const biasSim = row.premise_bias != null ? (simByName[row.premise_bias] || 0) : 0;
+    const norm = maxSim > 0 ? Math.min(1, biasSim / maxSim) : 0;
+    const scale = 0.7 + 1.6 * norm; // proof-teal nodes grow with retrieval similarity
+
+    mesh.position.set(x, y, 0);
+    mesh.scale.setScalar(scale);
+    mesh.visible = true;
+    mesh.material.opacity = 0.55 + 0.4 * norm;
+    mesh.material.color.setHex(C_NODE);
+    mesh.material.emissive.setHex(C_NODE);
+    mesh.material.emissiveIntensity = 0.25 + 0.4 * norm;
+
+    // explored edge: from root (depth 0 anchor) or a coarse parent-depth
+    // anchor back to this node (bounded trace has no explicit parent id, so
+    // we draw a lattice-blue edge from the previous depth-level's centroid X
+    // for a clean branching-lattice read, per the wireframe brief).
+    const parentX = Math.max(0, x - DEPTH_LEN);
+    edge.geometry.setFromPoints([new THREE.Vector3(parentX, 0, 0), new THREE.Vector3(x, y, 0)]);
+    edge.geometry.attributes.position.needsUpdate = true;
+    edge.material.color.setHex(C_TREE);
+    edge.material.opacity = 0.5;
+    edge.visible = true;
+
+    // unexplored-branch stub: a short grey dashed line fanning out beyond this
+    // node, hinting at sibling branches beyond the bounded trace sample
+    const stubX = x + DEPTH_LEN * 0.55;
+    const stubY = y + LANE_GAP * 0.4;
+    un.geometry.setFromPoints([new THREE.Vector3(x, y, 0), new THREE.Vector3(stubX, stubY, 0)]);
+    un.geometry.attributes.position.needsUpdate = true;
+    un.computeLineDistances();
+    un.material.color.setHex(C_UNEXPL);
+    un.material.opacity = depth < MAX_DEPTH ? 0.35 : 0.0;
+    un.visible = depth < MAX_DEPTH;
+  }
+
+  _spine.material.color.setHex(live ? C_TREE : C_DIM);
+  _spine.material.opacity = live ? 0.35 : 0.12;
+
+  // HUD marker: sits above the deepest/most-similar node, pulses proof-teal
+  if (_marker) {
+    if (live && trace.length) {
+      const best = trace.reduce((a, b) => ((b.priority || 0) > (a.priority || 0) ? b : a), trace[0]);
+      const pos = posByNodeId.get(best.node_id) || { x: 0, y: 1.4 };
+      _marker.position.set(pos.x, (pos.y || 0) + 0.8, 0);
+      _marker.material.color.setHex(C_NODE);
+      _marker.material.emissive.setHex(C_NODE);
+      _marker.material.opacity = 0.85;
+    } else {
+      _marker.material.color.setHex(C_DIM);
+      _marker.material.emissive.setHex(C_DIM);
+      _marker.material.opacity = 0.3;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.10;
+  if (_marker) {
+    _marker.rotation.y += 0.022;
+    _marker.rotation.x += 0.011;
+    const pulse = 1.0 + 0.15 * Math.sin(t * 0.004);
+    _marker.scale.setScalar(pulse);
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'Retrieves the most relevant <b>premises</b> for a goal by <b>cosine similarity</b> over ' +
+    'hand-rolled bag-of-tokens vectors (no embeddings), then runs a deterministic ' +
+    '<b>best-first search</b> over a synthetic tactic tree, biased by the retrieved premises ' +
+    '\u2014 the LeanDojo/ReProver premise-selection concept. Honesty label <b>MODELED</b> ' +
+    '(NOT connected to Lean 4 or Mathlib). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#3af4c8;box-shadow:0 0 7px #3af4c8";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#3af4c8;letter-spacing:.3px";
+  nm.textContent = "formal-math retrieval + tactic search";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("fm-goal",    "goal"));
+  grid.appendChild(kpiRow("fm-corpus",  "corpus_size"));
+  grid.appendChild(kpiRow("fm-k",       "k (top-k retrieved)"));
+  grid.appendChild(kpiRow("fm-top",     "top premise \u2014 MODELED"));
+  grid.appendChild(kpiRow("fm-sim",     "top similarity"));
+  grid.appendChild(kpiRow("fm-depth",   "proof-tree depth"));
+  grid.appendChild(kpiRow("fm-nodes",   "nodes expanded"));
+  grid.appendChild(kpiRow("fm-label",   "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "LeanDojo github.com/lean-dojo/LeanDojo \u00b7 ReProver github.com/lean-dojo/ReProver \u00b7 DeepSeek-Prover-V2 arXiv:2504.21801. MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "fm-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const top    = (S.topPremises && S.topPremises[0]) ? S.topPremises[0].name : "loading\u2026";
+  const simPct = (S.topPremises && S.topPremises[0]) ? (S.topPremises[0].similarity * 100).toFixed(1) + "%" : "loading\u2026";
+  const depth  = S.treeDepth != null ? String(S.treeDepth) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Proving a math theorem in a system like Lean often needs the " +
+    "<i>right supporting fact</i> (a \u201cpremise\u201d) from a huge library. Instead of " +
+    "searching blindly, this organ scores every candidate premise by how many words it shares " +
+    "with the goal (<b>" + top + "</b> scored highest here, at <b>" + simPct + "</b> similarity), " +
+    "then explores a tree of possible next proof steps, trying the most promising branches " +
+    "first \u2014 reaching a simulated depth of <b>" + depth + "</b> steps. Plain: find the most " +
+    "relevant facts first, then search smart instead of exhaustively. This is a <b>MODELED</b> " +
+    "toy simulation of the LeanDojo/ReProver idea \u2014 it is not connected to real Lean 4 or " +
+    "Mathlib, and is not DeepSeek-Prover or ReProver output.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function pct(v, d) { return typeof v === "number" ? (v * 100).toFixed(d) + "%" : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  const top = S.topPremises && S.topPremises[0] ? S.topPremises[0] : null;
+  _set("fm-goal",   t || (S.goal ? (S.goal.length > 34 ? S.goal.slice(0, 34) + "\u2026" : S.goal) : "\u2014"));
+  _set("fm-corpus", t || (S.corpusSize != null ? String(S.corpusSize) : "\u2014"));
+  _set("fm-k",      t || (S.k != null ? String(S.k) : "\u2014"));
+  _set("fm-top",    t || (top ? top.name : "\u2014"));
+  _set("fm-sim",    t || (top ? pct(top.similarity, 2) : "\u2014"));
+  _set("fm-depth",  t || (S.treeDepth != null ? String(S.treeDepth) : "\u2014"));
+  _set("fm-nodes",  t || (S.nodesExpand != null ? String(S.nodesExpand) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("fm-label",  t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _floor = null; _spine = null; _nodeMesh = []; _edgeLines = []; _unexplLines = []; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.goal = S.corpusSize = S.k = S.topPremises = S.simScores = null;
+  S.treeDepth = S.nodesExpand = S.trace = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/moe.js

@@ -0,0 +1,438 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/moe.js — MoE SPARSE-UPCYCLING ROUTER SIMULATOR organ for the holographic
+// frontier ring.
+//
+// Renders a 3D expert-load HEAT-SURFACE driven by a live snapshot from
+// /api/killinchu/v1/moe/route:
+//   X axis = expert index (0..experts-1)
+//   Y axis = cumulative load (bar height) for that expert, up to a "routing round"
+//   Z axis = routing round (the routing_table sample is bucketed into rounds so the
+//            surface shows load ACCUMULATING over rounds, not just a final snapshot)
+// Under-loaded experts (below the mean) render as lattice-blue peaks; balanced /
+// at-or-above-mean experts render as proof-teal peaks — so the load_balance_cv HUD
+// number has a directly visible shape (a flat teal skyline = balanced; spiky blue/teal
+// contrast = imbalanced / "hot expert" routing). Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors ssm.js / testtime.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   tokens, experts, topk
+//   routing_table (sample) — bucketed into rounds to build the heat-surface
+//   expert_load_counts[]   — final per-expert load counts
+//   load_balance_cv        — coefficient of variation of expert_load_counts
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Sparse Upcycling — Komatsuzaki et al. (2023) "Sparse Upcycling: Training
+//     Mixture-of-Experts from Dense Checkpoints". arXiv:2212.05055.
+//     https://arxiv.org/abs/2212.05055
+//   DeepSeekMoE — Dai et al. (2024) "DeepSeekMoE: Towards Ultimate Expert
+//     Specialization in Mixture-of-Experts Language Models". arXiv:2401.06066.
+//     https://arxiv.org/abs/2401.06066
+//   Expert Upcycling (amazon-science, code):
+//     https://github.com/amazon-science/expert-upcycling
+//
+// HONESTY LABELS: MODELED (deterministic top-K softmax router simulation illustrating
+//   sparse-upcycling load balance; NOT a trained MoE; NEVER-CLAIMED-AS DeepSeekMoE/
+//   Gemma-MoE/any production router). Read verbatim from JSON; never upgraded here.
+// COLOURS: grey base grid, lattice-blue 0x5b8dee (under-loaded peaks), proof-teal
+//   0x3af4c8 (balanced/at-or-above-mean peaks). Violet-blue 0x8a6bff reserved for HUD
+//   accent only. Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "moe";
+const TITLE = "MoE Sparse-Upcycling Router Simulator (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the MoE-router organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/moe/route?seed=42&tokens=64&experts=8&topk=2";
+
+// data-viz hues — purple BANNED
+const C_UNDER   = 0x5b8dee;  // lattice-blue (under-loaded expert peaks)
+const C_BALANCE = 0x3af4c8;  // proof-teal (balanced / at-or-above-mean expert peaks)
+const C_ACCENT  = 0x8a6bff;  // violet-blue (HUD accent only — not used as a bar colour)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+const N_ROUNDS_MAX = 8;      // number of "routing rounds" the sample is bucketed into
+const CELL_X = 1.1;          // world-units per expert column
+const CELL_Z = 1.3;          // world-units per routing round row
+const MAX_BAR_H = 5.0;       // world-units of max bar height (cumulative load axis)
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _floor = null;
+let _bars = [];          // Array<THREE.Mesh> — heat-surface bars, index = round*experts + expertIdx
+let _barGeo = null;      // shared unit-box geometry (scaled per-bar)
+let _labelGroup = null;  // small per-expert axis tick markers
+
+// live state
+const S = {
+  label:      null,
+  tokens:     null,
+  experts:    null,
+  topk:       null,
+  routingTable: null,     // Array<{token, chosen_experts, weights}>
+  loadCounts: null,       // Array<number> — final per-expert load counts
+  loadCV:     null,       // load_balance_cv
+  state:      "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(4, 9, 20);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(3, 1.5, 2); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildHeatSurface();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onRoute, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Pre-allocate a fixed max grid of bar meshes (N_ROUNDS_MAX x MAX experts we ever
+// expect, generously capped); we scale/recolor/position in-place as live data
+// arrives (no per-poll geometry churn beyond count changes on shape change).
+const _MAX_EXPERTS_GRID = 32;
+
+function _buildHeatSurface() {
+  const THREE = _THREE;
+  _barGeo = new THREE.BoxGeometry(0.8, 1, 0.8); // unit height; scaled per-bar in Y
+  _bars = [];
+  for (let r = 0; r < N_ROUNDS_MAX; r++) {
+    for (let e = 0; e < _MAX_EXPERTS_GRID; e++) {
+      const mat = new THREE.MeshStandardMaterial({
+        color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.25, transparent: true, opacity: 0.85,
+      });
+      const m = new THREE.Mesh(_barGeo, mat);
+      m.visible = false;
+      m.position.set(e * CELL_X, 0, r * CELL_Z);
+      _group.add(m);
+      _bars.push(m);
+    }
+  }
+
+  // baseline axes (expert axis + round axis), grey, data-viz only
+  const axisPts = [
+    new THREE.Vector3(-0.6, 0, -0.6), new THREE.Vector3(-0.6, 0, N_ROUNDS_MAX * CELL_Z),   // round axis
+    new THREE.Vector3(-0.6, 0, -0.6), new THREE.Vector3(_MAX_EXPERTS_GRID * CELL_X, 0, -0.6), // expert axis
+  ];
+  const axisGeo = new THREE.BufferGeometry().setFromPoints(axisPts);
+  const axisLine = new THREE.LineSegments(axisGeo, new THREE.LineBasicMaterial({ color: C_GRID, transparent: true, opacity: 0.4 }));
+  _group.add(axisLine);
+}
+
+function _bar(round, expertIdx) {
+  const idx = round * _MAX_EXPERTS_GRID + expertIdx;
+  return (idx >= 0 && idx < _bars.length) ? _bars[idx] : null;
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onRoute(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label       = (j.label || "MODELED").toUpperCase();
+  S.tokens      = typeof j.tokens === "number" ? j.tokens : null;
+  S.experts     = typeof j.experts === "number" ? j.experts : null;
+  S.topk        = typeof j.topk === "number" ? j.topk : null;
+  S.routingTable = Array.isArray(j.routing_table) ? j.routing_table : null;
+  S.loadCounts  = Array.isArray(j.expert_load_counts) ? j.expert_load_counts : null;
+  S.loadCV      = typeof j.load_balance_cv === "number" ? j.load_balance_cv : null;
+
+  _updateHeatSurface();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — buckets the routing_table sample into rounds, accumulates
+// per-expert load across rounds, and renders each (round, expert) cell as a bar
+// whose height = cumulative load-so-far for that expert.
+// =============================================================================
+function _bucketIntoRounds(routingTable, nExperts) {
+  // split the sampled routing_table (already token-ordered) into up to
+  // N_ROUNDS_MAX contiguous chunks ("rounds"); accumulate per-expert counts
+  // round-over-round so height = CUMULATIVE load (Z axis = round).
+  const n = routingTable.length;
+  const nRounds = Math.max(1, Math.min(N_ROUNDS_MAX, n));
+  const chunkSize = Math.max(1, Math.ceil(n / nRounds));
+
+  const cumulative = new Array(nExperts).fill(0);
+  const rounds = []; // Array<Array<number>> — cumulative load per expert, per round
+
+  for (let r = 0; r < nRounds; r++) {
+    const start = r * chunkSize;
+    const end = Math.min(n, start + chunkSize);
+    for (let i = start; i < end; i++) {
+      const row = routingTable[i];
+      const chosen = Array.isArray(row.chosen_experts) ? row.chosen_experts : [];
+      for (const e of chosen) {
+        if (e >= 0 && e < nExperts) cumulative[e] += 1;
+      }
+    }
+    rounds.push(cumulative.slice());
+  }
+  return rounds;
+}
+
+function _updateHeatSurface() {
+  const live = S.state === "live";
+
+  // hide everything first; re-show only the cells this snapshot uses
+  for (const b of _bars) b.visible = false;
+
+  if (!live || !S.routingTable || !S.loadCounts || !S.experts) {
+    return;
+  }
+
+  const nExperts = Math.min(S.experts, _MAX_EXPERTS_GRID);
+  const rounds = _bucketIntoRounds(S.routingTable, nExperts);
+  const nRounds = rounds.length;
+
+  // mean of the FINAL expert_load_counts (from the full endpoint result, not just
+  // the sample) — used as the balanced/under-loaded colour threshold.
+  const finalCounts = S.loadCounts.slice(0, nExperts);
+  const mean = finalCounts.reduce((a, c) => a + c, 0) / Math.max(1, finalCounts.length);
+  const maxCum = Math.max(1, ...rounds.map((row) => Math.max(1, ...row)));
+
+  for (let r = 0; r < nRounds; r++) {
+    const row = rounds[r];
+    for (let e = 0; e < nExperts; e++) {
+      const m = _bar(r, e);
+      if (!m) continue;
+      const cum = row[e] || 0;
+      const h = Math.max(0.05, (cum / maxCum) * MAX_BAR_H);
+      m.scale.y = h;
+      m.position.set(e * CELL_X, h / 2, r * CELL_Z);
+      // colour: under the FINAL mean -> lattice-blue (under-loaded); at/above -> proof-teal (balanced)
+      const col = (finalCounts[e] >= mean) ? C_BALANCE : C_UNDER;
+      m.material.color.setHex(col);
+      m.material.emissive.setHex(col);
+      m.material.emissiveIntensity = 0.35;
+      m.material.opacity = 0.88;
+      m.visible = true;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.12;
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A <b>top-K softmax router</b> dispatches each synthetic token to its highest-weight ' +
+    'experts. The heat-surface shows <b>cumulative expert load</b> building up across ' +
+    'routing rounds (X = expert, Z = round, Y = cumulative load). <b style="color:#5b8dee">Blue</b> ' +
+    'peaks are <b>under-loaded</b> experts (below mean); <b style="color:#3af4c8">teal</b> peaks are ' +
+    '<b>balanced/at-or-above-mean</b>. Honesty label <b>MODELED</b> (deterministic router ' +
+    'simulation — no trained MoE, never claimed as DeepSeekMoE/Gemma-MoE/any production ' +
+    'router). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "moe-router";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("moe-tokens",  "tokens routed"));
+  grid.appendChild(kpiRow("moe-experts", "experts N"));
+  grid.appendChild(kpiRow("moe-topk",    "top-K per token"));
+  grid.appendChild(kpiRow("moe-cv",      "load_balance_cv"));
+  grid.appendChild(kpiRow("moe-minmax",  "min / max expert load"));
+  grid.appendChild(kpiRow("moe-label",   "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Komatsuzaki et al. arXiv:2212.05055 (Sparse Upcycling) \u00b7 Dai et al. arXiv:2401.06066 (DeepSeekMoE) \u00b7 github.com/amazon-science/expert-upcycling (Expert Upcycling). MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "moe-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const tokens = S.tokens != null ? String(S.tokens) : "loading\u2026";
+  const experts = S.experts != null ? String(S.experts) : "loading\u2026";
+  const topk = S.topk != null ? String(S.topk) : "loading\u2026";
+  const cv = S.loadCV != null ? S.loadCV.toFixed(3) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> A Mixture-of-Experts (MoE) layer has many small \u2018expert\u2019 " +
+    "sub-networks, but only sends each token to a handful of them (here: top-<b>" + topk +
+    "</b> out of <b>" + experts + "</b> experts) \u2014 this is what makes MoE models cheap to " +
+    "run despite having huge total parameter counts. \u2018<b>Sparse upcycling</b>\u2019 is a real " +
+    "training trick where you take an already-trained dense model and convert it into an " +
+    "MoE by copying its layers into multiple experts and adding a fresh <b>router</b> " +
+    "that learns to pick which expert handles which token. The hard part is <b>load " +
+    "balance</b>: if the router always picks the same few experts, those experts get " +
+    "overtrained and the rest are wasted. Here we routed <b>" + tokens + "</b> synthetic " +
+    "tokens and measured <b>load_balance_cv = " + cv + "</b> (0 = perfectly even, higher " +
+    "= some experts are getting hammered while others sit idle). " +
+    "Plain: this is a toy, fully-deterministic stand-in for the router-fairness problem " +
+    "real MoE systems have to solve \u2014 it is a <b>MODELED</b> simulation, not a trained " +
+    "MoE and not a benchmark of any named production model.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("moe-tokens",  t || (S.tokens != null ? String(S.tokens) : "\u2014"));
+  _set("moe-experts", t || (S.experts != null ? String(S.experts) : "\u2014"));
+  _set("moe-topk",    t || (S.topk != null ? String(S.topk) : "\u2014"));
+  _set("moe-cv",      t || fx(S.loadCV, 4));
+  if (!t && Array.isArray(S.loadCounts) && S.loadCounts.length) {
+    _set("moe-minmax", `${Math.min(...S.loadCounts)} / ${Math.max(...S.loadCounts)}`);
+  } else {
+    _set("moe-minmax", t || "\u2014");
+  }
+  // honesty label verbatim — never upgraded
+  _set("moe-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  if (_barGeo && _barGeo.dispose) { try { _barGeo.dispose(); } catch (_) {} }
+  _group = _overlay = null;
+  _bars = []; _barGeo = null; _floor = null; _labelGroup = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.tokens = S.experts = S.topk = null;
+  S.routingTable = S.loadCounts = S.loadCV = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/ringattn.js

@@ -0,0 +1,456 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/ringattn.js — RING-ATTENTION LONG-CONTEXT BLOCKWISE SIMULATOR organ for
+// the holographic frontier ring. Renders a 3D RING of `devices` device nodes with
+// KV blocks rotating around it (num_rotation_steps == devices); a running online-
+// softmax accumulator glows proof-teal as each KV block is absorbed. A HUD shows
+// per_device_memory_ratio, exact_match, and max_context_supported from a live
+// snapshot at /api/killinchu/v1/ringattn/simulate. Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors specdecode.js / testtime.js / interpretability.js
+// exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   seq_len, devices, block_size, num_rotation_steps, per_device_memory_ratio,
+//   exact_match, max_context_supported, rotation_trace[]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Ring Attention with Blockwise Transformers for Near-Infinite Context:
+//     Liu, Zaharia & Abbeel 2023, arXiv:2310.01889
+//     https://arxiv.org/abs/2310.01889
+//   Blockwise Parallel Transformer (the online-softmax blockwise trick):
+//     Liu & Abbeel 2023, arXiv:2305.19370
+//     https://arxiv.org/abs/2305.19370
+//   Reference implementation: haoliuhl/ringattention
+//     https://github.com/haoliuhl/ringattention
+//
+// HONESTY LABELS: MODELED (deterministic blockwise online-softmax simulation of
+//   ring-attention's exact-attention accumulation; NOT a trained model or real
+//   multi-device kernel; NEVER-CLAIMED-AS a production ring-attention
+//   implementation). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (device nodes / ring), violet-blue 0x8a6bff
+//   (rotating KV blocks), proof-teal 0x3af4c8 (online-softmax accumulator glow /
+//   HUD accent), greys (degraded / rejected state). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "ringattn";
+const TITLE = "Ring Attention · Long-Context Blockwise Simulator (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the ring-attention organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/ringattn/simulate?seed=42&seq_len=4096&devices=8";
+
+// data-viz hues — purple BANNED
+const C_DEVICE  = 0x5b8dee;  // lattice-blue (device nodes / ring spine)
+const C_KVBLOCK = 0x8a6bff;  // violet-blue (rotating KV block — data-viz only)
+const C_ACCUM   = 0x3af4c8;  // proof-teal (online-softmax accumulator glow / HUD accent)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// ring layout geometry
+const RING_RADIUS  = 6.0;   // world-units, radius of the device ring
+const NODE_SIZE    = 0.34;  // device node sphere radius
+const MAX_DEVICES  = 32;    // pre-allocated device-node cap (perf)
+const KV_ORBIT_R   = RING_RADIUS + 1.1; // KV block travels slightly outside the ring
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _floor       = null;
+let _ringLine    = null;             // THREE.LineLoop — the ring spine
+let _deviceMesh  = [];               // Array<THREE.Mesh> — device nodes around the ring
+let _kvBlock     = null;             // THREE.Mesh — the rotating KV block marker
+let _accumulator = null;             // THREE.Mesh — running online-softmax accumulator (glows)
+let _accumPulsePhase = 0;
+
+// live state
+const S = {
+  label:        null,
+  seqLen:       null,   // seq_len
+  devices:      null,   // devices
+  blockSize:    null,   // block_size
+  rotSteps:     null,   // num_rotation_steps
+  memRatio:     null,   // per_device_memory_ratio
+  exactMatch:   null,   // exact_match (bool)
+  maxContext:   null,   // max_context_supported
+  trace:        null,   // rotation_trace[]
+  state:        "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(0, 9, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 1, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildRing();
+  _buildKvBlock();
+  _buildAccumulator();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onRingAttn, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+function _ringPos(i, n, radius, y) {
+  const a = (i / Math.max(1, n)) * Math.PI * 2;
+  return [Math.cos(a) * radius, y, Math.sin(a) * radius];
+}
+
+// Pre-allocate a fixed ring of device-node meshes (MAX_DEVICES); toggle
+// visibility / color in-place as live data arrives (no per-poll geometry churn).
+function _buildRing() {
+  const THREE = _THREE;
+
+  // ring spine (visual guide at y=0)
+  {
+    const pts = [];
+    const SEG = 96;
+    for (let i = 0; i <= SEG; i++) {
+      const a = (i / SEG) * Math.PI * 2;
+      pts.push(new THREE.Vector3(Math.cos(a) * RING_RADIUS, 0, Math.sin(a) * RING_RADIUS));
+    }
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_DEVICE, transparent: true, opacity: 0.35 });
+    _ringLine = new THREE.Line(geo, mat);
+    _group.add(_ringLine);
+  }
+
+  const nodeGeo = new THREE.IcosahedronGeometry(NODE_SIZE, 0);
+  for (let i = 0; i < MAX_DEVICES; i++) {
+    const mesh = new THREE.Mesh(
+      nodeGeo,
+      new THREE.MeshStandardMaterial({ color: C_DEVICE, emissive: C_DEVICE, emissiveIntensity: 0.35, transparent: true, opacity: 0.0 }),
+    );
+    mesh.visible = false;
+    _group.add(mesh);
+    _deviceMesh.push(mesh);
+  }
+}
+
+function _buildKvBlock() {
+  const THREE = _THREE;
+  _kvBlock = new THREE.Mesh(
+    new THREE.BoxGeometry(0.5, 0.5, 0.5),
+    new THREE.MeshStandardMaterial({ color: C_KVBLOCK, emissive: C_KVBLOCK, emissiveIntensity: 0.45, transparent: true, opacity: 0.9 }),
+  );
+  _kvBlock.position.set(KV_ORBIT_R, 0.6, 0);
+  _kvBlock.visible = false;
+  _group.add(_kvBlock);
+}
+
+function _buildAccumulator() {
+  const THREE = _THREE;
+  // The running online-softmax accumulator sits at the ring's center and
+  // glows proof-teal as blocks are absorbed (running_sum growth cue).
+  _accumulator = new THREE.Mesh(
+    new THREE.SphereGeometry(0.55, 20, 16),
+    new THREE.MeshStandardMaterial({
+      color: C_ACCUM, emissive: C_ACCUM, emissiveIntensity: 0.4,
+      wireframe: true, transparent: true, opacity: 0.75,
+    }),
+  );
+  _accumulator.position.set(0, 1.4, 0);
+  _group.add(_accumulator);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onRingAttn(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label      = (j.label || "MODELED").toUpperCase();
+  S.seqLen     = typeof j.seq_len                   === "number" ? j.seq_len                   : null;
+  S.devices    = typeof j.devices                   === "number" ? j.devices                   : null;
+  S.blockSize  = typeof j.block_size                === "number" ? j.block_size                : null;
+  S.rotSteps   = typeof j.num_rotation_steps        === "number" ? j.num_rotation_steps         : null;
+  S.memRatio   = typeof j.per_device_memory_ratio   === "number" ? j.per_device_memory_ratio    : null;
+  S.exactMatch = typeof j.exact_match               === "boolean" ? j.exact_match               : null;
+  S.maxContext = typeof j.max_context_supported     === "number" ? j.max_context_supported      : null;
+  S.trace      = Array.isArray(j.rotation_trace) ? j.rotation_trace : null;
+
+  _updateRing();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the ring + rotating KV block + accumulator
+// =============================================================================
+function _updateRing() {
+  const live = S.state === "live";
+  const n = live && S.devices ? Math.min(S.devices, MAX_DEVICES) : 0;
+
+  for (let i = 0; i < MAX_DEVICES; i++) {
+    const mesh = _deviceMesh[i];
+    if (i >= n) { mesh.visible = false; continue; }
+    mesh.visible = true;
+    const [x, y, z] = _ringPos(i, n, RING_RADIUS, 0.6);
+    mesh.position.set(x, y, z);
+    const color = live ? C_DEVICE : C_DIM;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.opacity = live ? 0.9 : 0.25;
+    mesh.material.emissiveIntensity = live ? 0.35 : 0.08;
+  }
+
+  _ringLine.material.color.setHex(live ? C_DEVICE : C_DIM);
+  _ringLine.material.opacity = live ? 0.35 : 0.12;
+
+  if (_kvBlock) {
+    _kvBlock.visible = live && n > 0;
+    _kvBlock.material.color.setHex(live ? C_KVBLOCK : C_DIM);
+    _kvBlock.material.emissive.setHex(live ? C_KVBLOCK : C_DIM);
+  }
+
+  if (_accumulator) {
+    if (live && S.exactMatch != null) {
+      const color = S.exactMatch ? C_ACCUM : C_DIM; // exact -> teal; mismatch (never expected) -> grey, never red/purple
+      _accumulator.material.color.setHex(color);
+      _accumulator.material.emissive.setHex(color);
+      _accumulator.material.opacity = 0.8;
+    } else {
+      _accumulator.material.color.setHex(C_DIM);
+      _accumulator.material.emissive.setHex(C_DIM);
+      _accumulator.material.opacity = 0.25;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation — KV block rotates around the ring; accumulator pulses
+// as each rotation step is "absorbed" (proof-teal glow intensifies)
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.10;
+
+  const live = S.state === "live";
+  const n = live && S.devices ? Math.min(S.devices, MAX_DEVICES) : 0;
+
+  if (_kvBlock && n > 0) {
+    // one full rotation every ~ (devices * 900ms), i.e. slower with more devices
+    // (visually implies num_rotation_steps == devices).
+    const periodMs = Math.max(2000, n * 900);
+    const phase = (t % periodMs) / periodMs; // 0..1
+    const a = phase * Math.PI * 2;
+    _kvBlock.position.set(Math.cos(a) * KV_ORBIT_R, 0.6 + 0.15 * Math.sin(t * 0.006), Math.sin(a) * KV_ORBIT_R);
+    _kvBlock.rotation.x += 0.03;
+    _kvBlock.rotation.y += 0.02;
+
+    // pulse the accumulator once per rotation step as a block is "absorbed"
+    const stepPhase = (phase * n) % 1.0;
+    _accumPulsePhase = stepPhase;
+  }
+
+  if (_accumulator) {
+    _accumulator.rotation.y += 0.015;
+    const basePulse = 1.0 + 0.12 * Math.sin(t * 0.004);
+    const stepGlow = live ? 1.0 + 0.25 * Math.exp(-6.0 * _accumPulsePhase) : 1.0;
+    _accumulator.scale.setScalar(basePulse * stepGlow);
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'Q/K/V are sharded across a logical <b>ring of devices</b>; KV blocks rotate around the ' +
+    'ring in <b>num_rotation_steps = devices</b> steps while a running <b>online-softmax</b> ' +
+    'accumulator (max/sum) absorbs each block. Result is provably <b>identical</b> to full ' +
+    'attention (<b>exact_match</b>) at <b>1/devices</b> memory per device. Honesty label ' +
+    '<b>MODELED</b> (deterministic blockwise simulation; NOT a real multi-device kernel). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#3af4c8;box-shadow:0 0 7px #3af4c8";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#3af4c8;letter-spacing:.3px";
+  nm.textContent = "ring attention";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("ra-seqlen",  "seq_len (context tokens)"));
+  grid.appendChild(kpiRow("ra-devices", "devices (ring size)"));
+  grid.appendChild(kpiRow("ra-block",   "block_size"));
+  grid.appendChild(kpiRow("ra-steps",   "num_rotation_steps"));
+  grid.appendChild(kpiRow("ra-memratio","per_device_memory_ratio \u2014 MODELED"));
+  grid.appendChild(kpiRow("ra-exact",   "exact_match (blockwise == full)"));
+  grid.appendChild(kpiRow("ra-maxctx",  "max_context_supported"));
+  grid.appendChild(kpiRow("ra-label",   "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Liu, Zaharia & Abbeel arXiv:2310.01889 (Ring Attention) \u00b7 Liu & Abbeel arXiv:2305.19370 (Blockwise Parallel Transformer) \u00b7 github.com/haoliuhl/ringattention. MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "ra-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const seqLen = S.seqLen  != null ? S.seqLen.toLocaleString() : "loading\u2026";
+  const dev    = S.devices != null ? String(S.devices) : "loading\u2026";
+  const ratio  = S.memRatio!= null ? "1/" + Math.round(1 / S.memRatio) : "loading\u2026";
+  const exact  = S.exactMatch === true ? "exactly the same" : S.exactMatch === false ? "different (unexpected)" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Long documents mean huge Q/K/V matrices that don't fit on one " +
+    "chip. Ring Attention splits the sequence (<b>" + seqLen + " tokens</b>) across a ring of " +
+    "<b>" + dev + " devices</b>: each device keeps only its own slice and passes its key/value " +
+    "block to the next device in the ring, one step at a time. A running \u201conline-softmax\u201d " +
+    "tally (a running maximum and running sum) is updated after each block arrives, so the " +
+    "final answer comes out <b>" + exact + "</b> as if one giant device had computed the whole " +
+    "thing at once \u2014 while each device only ever needs <b>" + ratio + "</b> of the memory a " +
+    "single device would need for the full sequence. Plain: same exact answer, spread across " +
+    "many machines, using far less memory each. This view is a <b>MODELED</b> deterministic " +
+    "simulation of that accumulation math, not a real multi-GPU run.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("ra-seqlen",   t || (S.seqLen  != null ? S.seqLen.toLocaleString() : "\u2014"));
+  _set("ra-devices",  t || (S.devices != null ? String(S.devices) : "\u2014"));
+  _set("ra-block",    t || (S.blockSize != null ? String(S.blockSize) : "\u2014"));
+  _set("ra-steps",    t || (S.rotSteps  != null ? String(S.rotSteps) : "\u2014"));
+  _set("ra-memratio", t || (S.memRatio  != null ? ("1/" + Math.round(1 / S.memRatio) + " (" + fx(S.memRatio, 4) + ")") : "\u2014"));
+  _set("ra-exact",    t || (S.exactMatch === true ? "TRUE (exact)" : S.exactMatch === false ? "FALSE" : "\u2014"));
+  _set("ra-maxctx",   t || (S.maxContext != null ? S.maxContext.toLocaleString() + " tokens" : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("ra-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _floor = null; _ringLine = null; _deviceMesh = []; _kvBlock = null; _accumulator = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false; _accumPulsePhase = 0;
+  _stage = _THREE = _ctx = null;
+  S.label = S.seqLen = S.devices = S.blockSize = S.rotSteps = null;
+  S.memRatio = S.exactMatch = S.maxContext = S.trace = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

szl3d_holographic.py

@@ -43,6 +43,10 @@ SURFACES: List[Dict[str, str]] = [
     {"id": "specdecode", "title": "Speculative Decoding", "owner": "Dev0"},
     {"id": "flowmatch", "title": "Flow Matching", "owner": "Dev0"},
     {"id": "dllm", "title": "Diffusion LLM", "owner": "Dev0"},
+    {"id": "moe", "title": "MoE Router", "owner": "Dev0"},
+    {"id": "formalmath", "title": "Formal-Math Retrieval", "owner": "Dev0"},
+    {"id": "ccattest", "title": "Confidential-Compute Attest", "owner": "Dev0"},
+    {"id": "ringattn", "title": "Ring Attention", "owner": "Dev0"},
     {"id": "energy", "title": "Energy", "owner": "Dev1"},
     {"id": "fabric", "title": "Compute Fabric", "owner": "Dev2"},
     {"id": "pnt", "title": "PNT", "owner": "Dev3"},