feat(wave13): add 3 frontier surfaces — muon, specexec, nvfp4 (52→55 surfaces); wire holographic.html + szl3d_holographic.py

static/3d/holographic.html

@@ -120,6 +120,9 @@ const SURFACES = [
   { id: "router",      title: "Router",      mod: "/static/3d/surfaces/router.js" },
   { id: "anatomy",     title: "Anatomy",     mod: "/static/3d/surfaces/anatomy.js" },
   { id: "estate",      title: "Estate",      mod: "/static/3d/surfaces/estate.js" },
+  { id: "muon",        title: "Muon Orthogonalized-Momentum Optimizer", mod: "/static/3d/surfaces/muon.js" },
+  { id: "specexec",    title: "Tree Speculative Execution",             mod: "/static/3d/surfaces/specexec.js" },
+  { id: "nvfp4",       title: "NVFP4 4-bit Training Format",            mod: "/static/3d/surfaces/nvfp4.js" },
 ];
 
 const stageEl = document.getElementById("stage");

static/3d/surfaces/muon.js

@@ -0,0 +1,568 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/muon.js — MUON ORTHOGONALIZED-MOMENTUM OPTIMIZER organ for the
+// holographic frontier ring (Muon = "MomentUm Orthogonalized by Newton–Schulz";
+// Keller Jordan et al. / Moonshot AI). Renders the quintic Newton–Schulz
+// orthogonalization of a synthetic momentum matrix as three live panels:
+//   (1) SINGULAR-VALUE TRAJECTORY — one 3D line per singular value across the
+//       Newton–Schulz iterations (x = iteration 0..ns, y = σ value), with the
+//       Muon [0.68, 1.13] oscillation band drawn as two reference planes;
+//   (2) BEFORE / AFTER HEATMAP — the raw normalized matrix G/||G||_F vs. the
+//       orthogonalized output UVᵀ ≈ X_ns, as two grids of coloured cells;
+//   (3) CONDITION-NUMBER BARS — κ = σ_max/σ_min raw vs. orthogonalized, honestly
+//       showing spectral flattening.
+// A HUD reports the MEASURED metrics from the live snapshot at
+// /api/killinchu/v1/muon/orthogonalize. Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors ternary.js / kvcache.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   m, n, ns_steps, coeffs{a,b,c}, frob_norm_raw, aspect_scale, rank,
+//   sv_spectrum[[...]], cond_raw, cond_ortho, cond_improvement,
+//   band_lo, band_hi, frac_in_band, sv_min_final, sv_max_final,
+//   matrix_raw[[...]], matrix_ortho[[...]]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   Muon: An optimizer for hidden layers in neural networks — Keller Jordan et al.
+//     https://kellerjordan.github.io/posts/muon/
+//   Muon is Scalable for LLM Training (Moonlight) — Moonshot AI arXiv:2502.16982
+//     https://arxiv.org/abs/2502.16982
+//   KellerJordan/Muon reference implementation: https://github.com/KellerJordan/Muon
+//
+// HONESTY LABELS: MODELED (deterministic reproduction of the Muon Newton–Schulz
+//   ORTHOGONALIZATION mechanism on a toy synthetic momentum matrix; NOT a
+//   trained model; trains nothing; the spectral flattening is MEASURED and
+//   displayed; NEVER-CLAIMED-AS a production optimizer). Read verbatim from JSON.
+// COLOURS: lattice-blue 0x5b8dee, violet-blue 0x8a6bff, proof-teal 0x3af4c8,
+//   greys (0x5a6570 / 0x42505d). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js via ctx.THREE (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    = "muon";
+const TITLE = "Muon Orthogonalized-Momentum Optimizer";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute),
+// reached cross-origin (killinchu returns access-control-allow-origin).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/muon/orthogonalize?seed=42&m=32&n=32&ns_steps=5";
+
+// data-viz hues — purple BANNED
+const C_SV       = 0x3af4c8;  // proof-teal  (singular-value trajectory lines)
+const C_BAND     = 0x8a6bff;  // violet-blue ([0.68,1.13] band reference planes)
+const C_RAW      = 0x5b8dee;  // lattice-blue (raw matrix heatmap / raw cond bar)
+const C_ORTHO    = 0x3af4c8;  // proof-teal  (orthogonalized heatmap / ortho bar)
+const C_DIM      = 0x42505d;  // grey (degraded / no-live-data)
+const C_ZERO     = 0x5a6570;  // grey (near-zero heatmap cell)
+const C_GRID     = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const TRAJ_X0    = 0.0;    // trajectory panel origin x
+const TRAJ_DX    = 1.5;    // world-units per Newton–Schulz iteration
+const TRAJ_YSC   = 3.0;    // world-units per unit singular value
+const HEAT_CELL  = 0.16;   // heatmap cell size
+const HEAT_GAP   = 0.17;   // heatmap cell pitch
+const HEAT_MAX   = 24;     // cap cells per axis rendered (perf)
+const BAR_W      = 0.9;    // condition-number bar width
+
+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 _trajGroup  = null;   // THREE.Group — SV trajectory lines + band planes
+let _heatRaw    = [];     // Array<THREE.Mesh> — before heatmap cells
+let _heatOrtho  = [];     // Array<THREE.Mesh> — after heatmap cells
+let _heatGroup  = null;
+let _barRaw     = null;   // THREE.Mesh — raw condition-number bar
+let _barOrtho   = null;   // THREE.Mesh — orthogonalized condition-number bar
+let _barGroup   = null;
+
+// live state
+const S = {
+  label:      null,
+  m:          null,
+  n:          null,
+  nsSteps:    null,   // ns_steps
+  coA:        null, coB: null, coC: null,   // coeffs
+  frobRaw:    null,   // frob_norm_raw
+  aspect:     null,   // aspect_scale
+  rank:       null,
+  svSpectrum: null,   // Array<Array<number>>
+  condRaw:    null,   // cond_raw
+  condOrtho:  null,   // cond_ortho
+  condImp:    null,   // cond_improvement
+  bandLo:     null,   // band_lo
+  bandHi:     null,   // band_hi
+  fracInBand: null,   // frac_in_band
+  svMinFinal: null,   // sv_min_final
+  svMaxFinal: null,   // sv_max_final
+  matrixRaw:  null,   // Array<Array<number>>
+  matrixOrtho:null,   // Array<Array<number>>
+  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(6, 7, 18);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(4, 1.5, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildTrajectory();
+  _buildHeatmaps();
+  _buildBars();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onMuon, { badge: _badge, onState: (msg) => { S.state = msg.state; _updateAll(); _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(44, 44, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// SV trajectory panel: the band reference planes are pre-built here; the
+// per-singular-value lines are rebuilt in-place whenever fresh data arrives
+// (line count depends on live rank). Two translucent planes mark [0.68,1.13].
+function _buildTrajectory() {
+  const THREE = _THREE;
+  _trajGroup = new THREE.Group();
+  _trajGroup.position.set(TRAJ_X0, 0, -3.0);
+  _group.add(_trajGroup);
+  // band planes are added by _updateTrajectory once band bounds are known
+}
+
+// two grids of coloured cells (raw | orthogonalized). Pre-allocate a fixed
+// HEAT_MAX x HEAT_MAX per side; toggle visibility/color in place (no churn).
+function _buildHeatmaps() {
+  const THREE = _THREE;
+  _heatGroup = new THREE.Group();
+  _heatGroup.position.set(0.0, 0.05, 3.2);
+  _group.add(_heatGroup);
+  const cellGeo = new THREE.PlaneGeometry(HEAT_CELL, HEAT_CELL);
+
+  function makeGrid(offsetX, arr) {
+    for (let r = 0; r < HEAT_MAX; r++) {
+      for (let c = 0; c < HEAT_MAX; c++) {
+        const mesh = new THREE.Mesh(
+          cellGeo,
+          new THREE.MeshBasicMaterial({ color: C_ZERO, transparent: true, opacity: 0.0, side: THREE.DoubleSide }),
+        );
+        mesh.rotation.x = -Math.PI / 2;
+        mesh.position.set(offsetX + c * HEAT_GAP, 0.02, r * HEAT_GAP);
+        mesh.visible = false;
+        _heatGroup.add(mesh);
+        arr.push(mesh);
+      }
+    }
+  }
+  makeGrid(0.0, _heatRaw);
+  makeGrid(HEAT_MAX * HEAT_GAP + 0.8, _heatOrtho);
+}
+
+function _buildBars() {
+  const THREE = _THREE;
+  _barGroup = new THREE.Group();
+  _barGroup.position.set(-3.4, 0, 0.0);
+  _group.add(_barGroup);
+  const geo = new THREE.BoxGeometry(BAR_W, 1.0, BAR_W);
+
+  _barRaw = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_RAW, emissive: C_RAW, emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+  );
+  _barRaw.position.set(0, 0.5, 0);
+  _barGroup.add(_barRaw);
+
+  _barOrtho = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_ORTHO, emissive: C_ORTHO, emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+  );
+  _barOrtho.position.set(1.3, 0.5, 0);
+  _barGroup.add(_barOrtho);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onMuon(j) {
+  // read honesty label VERBATIM — never upgrade. handle top-level 'label' OR
+  // nested 'payload.label' to match our own module's shape.
+  const lbl = (j && j.label != null) ? j.label
+            : (j && j.payload && j.payload.label != null) ? j.payload.label
+            : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : j;
+  S.label = String(lbl).toUpperCase();
+
+  S.m          = typeof src.m                === "number" ? src.m                : null;
+  S.n          = typeof src.n                === "number" ? src.n                : null;
+  S.nsSteps    = typeof src.ns_steps         === "number" ? src.ns_steps         : null;
+  S.frobRaw    = typeof src.frob_norm_raw    === "number" ? src.frob_norm_raw    : null;
+  S.aspect     = typeof src.aspect_scale     === "number" ? src.aspect_scale     : null;
+  S.rank       = typeof src.rank             === "number" ? src.rank             : null;
+  S.condRaw    = typeof src.cond_raw         === "number" ? src.cond_raw         : null;
+  S.condOrtho  = typeof src.cond_ortho       === "number" ? src.cond_ortho       : null;
+  S.condImp    = typeof src.cond_improvement === "number" ? src.cond_improvement : null;
+  S.bandLo     = typeof src.band_lo          === "number" ? src.band_lo          : null;
+  S.bandHi     = typeof src.band_hi          === "number" ? src.band_hi          : null;
+  S.fracInBand = typeof src.frac_in_band     === "number" ? src.frac_in_band     : null;
+  S.svMinFinal = typeof src.sv_min_final     === "number" ? src.sv_min_final     : null;
+  S.svMaxFinal = typeof src.sv_max_final     === "number" ? src.sv_max_final     : null;
+
+  if (src.coeffs && typeof src.coeffs === "object") {
+    S.coA = typeof src.coeffs.a === "number" ? src.coeffs.a : null;
+    S.coB = typeof src.coeffs.b === "number" ? src.coeffs.b : null;
+    S.coC = typeof src.coeffs.c === "number" ? src.coeffs.c : null;
+  }
+  S.svSpectrum  = Array.isArray(src.sv_spectrum)  ? src.sv_spectrum  : null;
+  S.matrixRaw   = Array.isArray(src.matrix_raw)   ? src.matrix_raw   : null;
+  S.matrixOrtho = Array.isArray(src.matrix_ortho) ? src.matrix_ortho : null;
+
+  _updateAll();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updaters
+// =============================================================================
+function _updateAll() {
+  _updateTrajectory();
+  _updateHeatmaps();
+  _updateBars();
+}
+
+// Rebuild the SV trajectory lines + band planes from the live spectrum.
+function _updateTrajectory() {
+  const THREE = _THREE;
+  if (!_trajGroup) return;
+  const live = S.state === "live";
+
+  // dispose previous trajectory children (lines + planes)
+  for (let i = _trajGroup.children.length - 1; i >= 0; i--) {
+    const o = _trajGroup.children[i];
+    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(); });
+    }
+    _trajGroup.remove(o);
+  }
+
+  if (!live || !S.svSpectrum || !S.svSpectrum.length) return;
+
+  const lo = (S.bandLo != null) ? S.bandLo : 0.68;
+  const hi = (S.bandHi != null) ? S.bandHi : 1.13;
+  const iters = S.svSpectrum.length;               // ns_steps + 1
+  const width = (iters - 1) * TRAJ_DX;
+
+  // two band reference planes at y = lo and y = hi (violet-blue, translucent)
+  const planeGeo = new THREE.PlaneGeometry(width || TRAJ_DX, 5.0);
+  [lo, hi].forEach((yv) => {
+    const pm = new THREE.Mesh(
+      planeGeo,
+      new THREE.MeshBasicMaterial({ color: C_BAND, transparent: true, opacity: 0.10, side: THREE.DoubleSide }),
+    );
+    pm.rotation.x = -Math.PI / 2;
+    pm.position.set(width / 2, yv * TRAJ_YSC, 2.5);
+    _trajGroup.add(pm);
+  });
+
+  // one line per singular value: point (iter, σ_at_iter). Only draw a subset of
+  // ranks if very large, to keep the panel legible & cheap.
+  const rank = S.svSpectrum[0].length;
+  const stride = rank > 32 ? Math.ceil(rank / 32) : 1;
+  for (let s = 0; s < rank; s += stride) {
+    const pts = [];
+    for (let k = 0; k < iters; k++) {
+      const sv = (S.svSpectrum[k] && typeof S.svSpectrum[k][s] === "number") ? S.svSpectrum[k][s] : 0.0;
+      pts.push(new THREE.Vector3(k * TRAJ_DX, sv * TRAJ_YSC, 0));
+    }
+    const lg = new THREE.BufferGeometry().setFromPoints(pts);
+    const lm = new THREE.LineBasicMaterial({ color: C_SV, transparent: true, opacity: 0.7 });
+    _trajGroup.add(new THREE.Line(lg, lm));
+  }
+}
+
+// colour a heatmap grid from a matrix: sign -> hue (raw=lattice-blue tint,
+// ortho=proof-teal tint), |value| -> opacity. Near-zero -> grey.
+function _paintHeat(arr, mat, baseColor) {
+  const live = S.state === "live";
+  const rows = (live && mat && mat.length) ? Math.min(mat.length, HEAT_MAX) : 0;
+  const cols = (live && mat && mat[0]) ? Math.min(mat[0].length, HEAT_MAX) : 0;
+
+  // find max-abs for normalization
+  let amax = 0.0;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const v = Math.abs(mat[r][c]);
+      if (v > amax) amax = v;
+    }
+  }
+  if (amax <= 0.0) amax = 1.0;
+
+  for (let r = 0; r < HEAT_MAX; r++) {
+    for (let c = 0; c < HEAT_MAX; c++) {
+      const mesh = arr[r * HEAT_MAX + c];
+      if (!live || r >= rows || c >= cols) { mesh.visible = false; continue; }
+      mesh.visible = true;
+      const v = mat[r][c];
+      const mag = Math.min(1.0, Math.abs(v) / amax);
+      const color = mag < 0.04 ? C_ZERO : baseColor;
+      mesh.material.color.setHex(color);
+      mesh.material.opacity = 0.18 + 0.75 * mag;
+    }
+  }
+}
+
+function _updateHeatmaps() {
+  _paintHeat(_heatRaw,   S.matrixRaw,   C_RAW);
+  _paintHeat(_heatOrtho, S.matrixOrtho, C_ORTHO);
+}
+
+// condition-number bars: height ∝ log10(κ) so the raw (large κ) and
+// orthogonalized (κ≈1) bars are both legible.
+function _updateBars() {
+  const live = S.state === "live";
+  function setBar(mesh, kappa, color) {
+    if (!mesh) return;
+    if (!live || kappa == null) {
+      mesh.material.color.setHex(C_DIM);
+      mesh.material.emissive.setHex(C_DIM);
+      mesh.material.opacity = 0.3;
+      mesh.scale.y = 0.05;
+      mesh.position.y = 0.025;
+      return;
+    }
+    const h = Math.max(0.08, Math.log10(Math.max(1.0, kappa)) + 0.15) * 2.2;
+    mesh.scale.y = h;
+    mesh.position.y = h * 0.5;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = 0.4;
+    mesh.material.opacity = 0.92;
+  }
+  setBar(_barRaw,   S.condRaw,   C_RAW);
+  setBar(_barOrtho, S.condOrtho, C_ORTHO);
+}
+
+// =============================================================================
+// 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%,470px)",
+    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 =
+    'Muon (\u201cMomentUm Orthogonalized by Newton\u2013Schulz\u201d) replaces a momentum update matrix ' +
+    'with the nearest <b>semi-orthogonal</b> matrix (UV\u1d40 from its SVD) via a hand-tuned <b>quintic ' +
+    'Newton\u2013Schulz</b> recurrence X<sub>k+1</sub> = a\u00b7X + b\u00b7(XX\u1d40)X + c\u00b7(XX\u1d40)\u00b2X ' +
+    '(a=3.4445, b=\u22124.7750, c=2.0315). This <b>flattens the singular-value spectrum</b> toward the ' +
+    'non-convergent <b>[0.68, 1.13]</b> band so no direction dominates the step. Panels: singular-value ' +
+    'trajectory, before/after matrix heatmap, condition-number bars (raw vs orthogonalized). Honesty label ' +
+    '<b>MODELED</b> (deterministic mechanism reproduction on a toy matrix; trains nothing). 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 = "muon orthogonalized-momentum optimizer";
+  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:56%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("mu-dims",   "momentum matrix (m \u00d7 n)"));
+  grid.appendChild(kpiRow("mu-ns",     "Newton\u2013Schulz iterations"));
+  grid.appendChild(kpiRow("mu-coeffs", "quintic coefficients (a / b / c)"));
+  grid.appendChild(kpiRow("mu-rank",   "singular values tracked (rank)"));
+  grid.appendChild(kpiRow("mu-condr",  "condition \u03ba \u2014 RAW"));
+  grid.appendChild(kpiRow("mu-condo",  "condition \u03ba \u2014 ORTHOGONALIZED"));
+  grid.appendChild(kpiRow("mu-condi",  "spectral-flattening factor"));
+  grid.appendChild(kpiRow("mu-band",   "convergence band"));
+  grid.appendChild(kpiRow("mu-frac",   "final \u03c3 inside band (MEASURED)"));
+  grid.appendChild(kpiRow("mu-svrange","final \u03c3 range (min \u2192 max)"));
+  grid.appendChild(kpiRow("mu-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 = "Muon \u2014 Keller Jordan et al. (kellerjordan.github.io/posts/muon) \u00b7 Moonshot AI \u201cMuon is Scalable for LLM Training\u201d arXiv:2502.16982 \u00b7 github.com/KellerJordan/Muon. MODELED \u00b7 Newton\u2013Schulz demo, not a trained model.";
+  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 = "mu-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 cr   = S.condRaw    != null ? S.condRaw.toFixed(1)    : "loading\u2026";
+  const co   = S.condOrtho  != null ? S.condOrtho.toFixed(2)  : "loading\u2026";
+  const imp  = S.condImp    != null ? S.condImp.toFixed(1) + "\u00d7" : "loading\u2026";
+  const frac = S.fracInBand != null ? (S.fracInBand * 100).toFixed(0) + "%" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> When a model learns, each update is a grid of numbers (a \u201cmatrix\u201d). Some " +
+    "directions in that grid can be far bigger than others, so the step lurches. Muon first <b>rebalances</b> " +
+    "the update so every direction has roughly equal weight \u2014 like normalizing the volume across a mixing " +
+    "board before pressing play. It does this not with an expensive exact calculation but with a fast, " +
+    "GPU-friendly repeated formula (Newton\u2013Schulz) run about five times. Here the imbalance measure " +
+    "(\u201ccondition number\u201d) drops from about <b>" + cr + "</b> to about <b>" + co + "</b> \u2014 a " +
+    "<b>" + imp + "</b> flattening \u2014 and <b>" + frac + "</b> of the rebalanced values land in the target " +
+    "<b>0.68\u20131.13</b> range the method aims for. This view is a <b>MODELED</b> deterministic reproduction " +
+    "of that rebalancing MECHANISM on a small synthetic matrix \u2014 it <b>trains no model</b> and runs no GPU " +
+    "kernel. The \u201c\u2248 2\u00d7 faster training vs. AdamW\u201d headline is a <b>claim about real training " +
+    "runs</b> (Keller Jordan / Moonshot AI) that the estate does not independently verify.";
+}
+
+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);
+  _set("mu-dims",    t || ((S.m != null && S.n != null) ? (S.m + " \u00d7 " + S.n) : "\u2014"));
+  _set("mu-ns",      t || (S.nsSteps != null ? String(S.nsSteps) : "\u2014"));
+  _set("mu-coeffs",  t || ((S.coA != null) ? (fx(S.coA, 4) + " / " + fx(S.coB, 4) + " / " + fx(S.coC, 4)) : "\u2014"));
+  _set("mu-rank",    t || (S.rank != null ? String(S.rank) : "\u2014"));
+  _set("mu-condr",   t || fx(S.condRaw, 2));
+  _set("mu-condo",   t || fx(S.condOrtho, 3));
+  _set("mu-condi",   t || (S.condImp != null ? S.condImp.toFixed(1) + "\u00d7" : "\u2014"));
+  _set("mu-band",    t || ((S.bandLo != null && S.bandHi != null) ? ("[" + S.bandLo + ", " + S.bandHi + "]") : "\u2014"));
+  _set("mu-frac",    t || pct(S.fracInBand, 1));
+  _set("mu-svrange", t || ((S.svMinFinal != null && S.svMaxFinal != null) ? (fx(S.svMinFinal, 3) + " \u2192 " + fx(S.svMaxFinal, 3)) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("mu-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;
+  _trajGroup = null;
+  _heatRaw = []; _heatOrtho = []; _heatGroup = null;
+  _barRaw = null; _barOrtho = null; _barGroup = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.m = S.n = S.nsSteps = null;
+  S.coA = S.coB = S.coC = null;
+  S.frobRaw = S.aspect = S.rank = null;
+  S.svSpectrum = null;
+  S.condRaw = S.condOrtho = S.condImp = null;
+  S.bandLo = S.bandHi = S.fracInBand = S.svMinFinal = S.svMaxFinal = null;
+  S.matrixRaw = S.matrixOrtho = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/nvfp4.js

@@ -0,0 +1,549 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/nvfp4.js — NVFP4 4-BIT TRAINING-FORMAT organ for the holographic
+// frontier ring. Visualizes a deterministic toy arithmetic demonstration of
+// block-scaled 4-bit floating-point (FP4 E2M1) quantization, from the live
+// snapshot at /api/killinchu/v1/nvfp4/quantize. Three things are rendered:
+//   (1) reconstruction-error MSE bars per scheme — naive-FP4 (single global
+//       scale) vs MXFP4 (32-elem blocks, power-of-two scale) vs NVFP4 (16-elem
+//       blocks, E4M3 FP8 scale + FP32 global; two-level). Errors are MEASURED
+//       and shown, never hidden.
+//   (2) a cumulative rounding-bias line — deterministic round-to-nearest
+//       (DRIFTS) vs stochastic rounding (stays near zero) over N roundings of a
+//       fixed delta.
+//   (3) a two-level NVFP4 scaling-pipeline diagram: tensor -> FP32 global scale
+//       -> E4M3 block scale -> FP4 value.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is;
+// never upgraded.
+//
+// Surface export shape (mirrors ternary.js / kvcache.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   size, outliers, tensor_amax, best_scheme, fp4_levels[],
+//   schemes[]{name, block_size, scale_format, two_level, mse, max_abs_err},
+//   rounding{n, delta, det_final_bias, stoch_final_bias,
+//            det_bias_series[], stoch_bias_series[]}
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   NVFP4 pretraining — Agrusa, Rouhani, Micikevicius, Patwary, Shoeybi et al.
+//     (NVIDIA) arXiv:2509.25149  https://arxiv.org/abs/2509.25149
+//   MXFP4 / OCP Microscaling — Rouhani et al. arXiv:2310.10537
+//     https://arxiv.org/pdf/2310.10537
+//   Introducing NVFP4 (NVIDIA blog):
+//     https://developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference/
+//   Oscillation-Reduced MXFP4 Training (TetraJet) arXiv:2502.20853
+//     https://arxiv.org/abs/2502.20853
+//
+// HONESTY LABELS: MODELED (deterministic ARITHMETIC DEMONSTRATION of the FP4
+//   block-scaling + two-level-scaling + stochastic-rounding MECHANISMS on a toy
+//   synthetic tensor; NO GPU kernel executed, NOT the trained model; error is
+//   MEASURED and displayed). Read verbatim from JSON; never upgraded here.
+// COLOURS: proof-teal 0x3af4c8 (NVFP4 / best), lattice-blue 0x5b8dee (MXFP4 /
+//   deterministic line), violet-blue 0x8a6bff (naive / accent), greys
+//   (0x5a6570 / 0x42505d, degraded / stochastic line). Purple BANNED.
+// 0 RUNTIME CDN. Vendored three.js via ctx.THREE (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    = "nvfp4";
+const TITLE = "NVFP4 4-bit Training Format";
+
+// Endpoint hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/nvfp4/quantize?seed=42&size=32&outliers=3";
+
+// data-viz hues — purple BANNED
+const C_NV      = 0x3af4c8;  // proof-teal   (NVFP4 / best scheme)
+const C_MX      = 0x5b8dee;  // lattice-blue (MXFP4 / deterministic rounding line)
+const C_NAIVE   = 0x8a6bff;  // violet-blue  (naive-FP4 / accent)
+const C_STOCH   = 0x3af4c8;  // proof-teal   (stochastic rounding line)
+const C_ZERO    = 0x5a6570;  // grey (zero baseline / neutral)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+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> — one MSE bar per scheme
+let _detLine  = null; // THREE.Line — deterministic cumulative bias
+let _stochLine= null; // THREE.Line — stochastic cumulative bias
+let _biasZero = null; // THREE.Line — zero baseline for the bias plot
+let _pipe     = [];   // Array<THREE.Mesh> — two-level pipeline diagram stages
+
+// bar layout
+const BAR_X0   = 0.0;
+const BAR_GAP  = 1.5;
+const BAR_W    = 0.7;
+const BAR_MAXH = 3.2;
+
+// bias-plot layout
+const PLOT_X0  = 6.2;
+const PLOT_W   = 4.2;
+const PLOT_Y   = 1.6;
+const PLOT_H   = 2.0;
+
+// pipeline layout
+const PIPE_X0  = 0.0;
+const PIPE_Z   = 4.4;
+const PIPE_GAP = 1.7;
+
+// live state
+const S = {
+  label:       null,
+  size:        null,
+  outliers:    null,
+  tensorAmax:  null,
+  bestScheme:  null,
+  fp4Levels:   null,   // array
+  schemes:     null,   // array of {name, mse, max_abs_err, block_size, scale_format, two_level}
+  rDelta:      null,
+  rN:          null,
+  detFinal:    null,
+  stochFinal:  null,
+  detSeries:   null,   // array
+  stochSeries: null,   // array
+  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, 7, 15);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(4, 1, 2); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildBars();
+  _buildBiasPlot();
+  _buildPipeline();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onNvfp4, { badge: _badge, onState: (m) => { S.state = m.state; _updateScene(); _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;
+}
+
+// three MSE bars: naive-FP4 (violet-blue), MXFP4 (lattice-blue), NVFP4 (proof-teal)
+function _buildBars() {
+  const THREE = _THREE;
+  const cols = [C_NAIVE, C_MX, C_NV];
+  const geo = new THREE.BoxGeometry(BAR_W, 1, BAR_W);
+  for (let i = 0; i < 3; i++) {
+    const mesh = new THREE.Mesh(
+      geo,
+      new THREE.MeshStandardMaterial({ color: cols[i], emissive: cols[i], emissiveIntensity: 0.35, transparent: true, opacity: 0.9 }),
+    );
+    mesh.position.set(BAR_X0 + i * BAR_GAP, 0.5, 0);
+    mesh.scale.y = 0.02;
+    _group.add(mesh);
+    _bars.push(mesh);
+  }
+}
+
+// two poly-lines for cumulative rounding bias + a zero baseline
+function _buildBiasPlot() {
+  const THREE = _THREE;
+  // zero baseline
+  const zg = new THREE.BufferGeometry();
+  zg.setAttribute("position", new THREE.Float32BufferAttribute([PLOT_X0, PLOT_Y, 0, PLOT_X0 + PLOT_W, PLOT_Y, 0], 3));
+  _biasZero = new THREE.Line(zg, new THREE.LineBasicMaterial({ color: C_ZERO, transparent: true, opacity: 0.5 }));
+  _group.add(_biasZero);
+
+  const dg = new THREE.BufferGeometry();
+  dg.setAttribute("position", new THREE.Float32BufferAttribute([PLOT_X0, PLOT_Y, 0, PLOT_X0, PLOT_Y, 0], 3));
+  _detLine = new THREE.Line(dg, new THREE.LineBasicMaterial({ color: C_MX }));
+  _group.add(_detLine);
+
+  const sg = new THREE.BufferGeometry();
+  sg.setAttribute("position", new THREE.Float32BufferAttribute([PLOT_X0, PLOT_Y, 0, PLOT_X0, PLOT_Y, 0], 3));
+  _stochLine = new THREE.Line(sg, new THREE.LineBasicMaterial({ color: C_STOCH }));
+  _group.add(_stochLine);
+}
+
+// two-level scaling pipeline: tensor -> FP32 global -> E4M3 block -> FP4 value
+function _buildPipeline() {
+  const THREE = _THREE;
+  const stageCols = [C_NAIVE, C_NAIVE, C_MX, C_NV];  // tensor, global, block, fp4
+  const shapes = [
+    new THREE.BoxGeometry(0.6, 0.6, 0.6),
+    new THREE.OctahedronGeometry(0.42, 0),
+    new THREE.OctahedronGeometry(0.42, 0),
+    new THREE.IcosahedronGeometry(0.42, 0),
+  ];
+  for (let i = 0; i < 4; i++) {
+    const c = stageCols[i];
+    const mesh = new THREE.Mesh(
+      shapes[i],
+      new THREE.MeshStandardMaterial({ color: c, emissive: c, emissiveIntensity: 0.3, transparent: true, opacity: 0.85, wireframe: i > 0 }),
+    );
+    mesh.position.set(PIPE_X0 + i * PIPE_GAP, 0.55, PIPE_Z);
+    _group.add(mesh);
+    _pipe.push(mesh);
+    // connecting link to previous stage
+    if (i > 0) {
+      const lg = new THREE.BufferGeometry();
+      lg.setAttribute("position", new THREE.Float32BufferAttribute([
+        PIPE_X0 + (i - 1) * PIPE_GAP, 0.55, PIPE_Z,
+        PIPE_X0 + i * PIPE_GAP,       0.55, PIPE_Z,
+      ], 3));
+      const link = new THREE.Line(lg, new THREE.LineBasicMaterial({ color: C_GRID, transparent: true, opacity: 0.6 }));
+      _group.add(link);
+      _pipe.push(link);
+    }
+  }
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onNvfp4(j) {
+  // read honesty label VERBATIM — never upgrade. handle top-level or nested.
+  const lbl = (j && j.label != null) ? j.label
+            : (j && j.payload && j.payload.label != null) ? j.payload.label
+            : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : j;
+  S.label      = String(lbl).toUpperCase();
+
+  S.size       = typeof src.size        === "number" ? src.size        : null;
+  S.outliers   = typeof src.outliers    === "number" ? src.outliers    : null;
+  S.tensorAmax = typeof src.tensor_amax === "number" ? src.tensor_amax : null;
+  S.bestScheme = typeof src.best_scheme === "string" ? src.best_scheme : null;
+  S.fp4Levels  = Array.isArray(src.fp4_levels) ? src.fp4_levels : null;
+  S.schemes    = Array.isArray(src.schemes)    ? src.schemes    : null;
+
+  if (src.rounding && typeof src.rounding === "object") {
+    const r = src.rounding;
+    S.rDelta      = typeof r.delta            === "number" ? r.delta            : null;
+    S.rN          = typeof r.n                === "number" ? r.n                : null;
+    S.detFinal    = typeof r.det_final_bias   === "number" ? r.det_final_bias   : null;
+    S.stochFinal  = typeof r.stoch_final_bias === "number" ? r.stoch_final_bias : null;
+    S.detSeries   = Array.isArray(r.det_bias_series)   ? r.det_bias_series   : null;
+    S.stochSeries = Array.isArray(r.stoch_bias_series) ? r.stoch_bias_series : null;
+  }
+
+  _updateScene();
+  _paintOverlay();
+}
+
+// =============================================================================
+// scene updater
+// =============================================================================
+function _schemeByName(nm) {
+  if (!S.schemes) return null;
+  for (const s of S.schemes) if (s && s.name === nm) return s;
+  return null;
+}
+
+function _updateScene() {
+  const live = S.state === "live" && S.schemes;
+
+  // ---- MSE bars ----
+  const order = ["naive-FP4", "MXFP4", "NVFP4"];
+  const cols  = [C_NAIVE, C_MX, C_NV];
+  let maxMse = 0;
+  if (live) {
+    for (const nm of order) {
+      const s = _schemeByName(nm);
+      if (s && typeof s.mse === "number" && s.mse > maxMse) maxMse = s.mse;
+    }
+  }
+  for (let i = 0; i < _bars.length; i++) {
+    const bar = _bars[i];
+    if (!live || maxMse <= 0) {
+      bar.material.color.setHex(C_DIM);
+      bar.material.emissive.setHex(C_DIM);
+      bar.material.opacity = 0.35;
+      bar.scale.y = 0.02;
+      bar.position.y = 0.01;
+      continue;
+    }
+    const s = _schemeByName(order[i]);
+    const mse = (s && typeof s.mse === "number") ? s.mse : 0;
+    const h = Math.max(0.02, (mse / maxMse) * BAR_MAXH);
+    bar.scale.y = h;
+    bar.position.y = h / 2;
+    const isBest = S.bestScheme && order[i] === S.bestScheme;
+    bar.material.color.setHex(cols[i]);
+    bar.material.emissive.setHex(cols[i]);
+    bar.material.emissiveIntensity = isBest ? 0.65 : 0.3;
+    bar.material.opacity = 0.92;
+  }
+
+  // ---- rounding-bias lines ----
+  _updateBiasLine(_detLine, live ? S.detSeries : null);
+  _updateBiasLine(_stochLine, live ? S.stochSeries : null);
+
+  // ---- pipeline highlight ----
+  for (const m of _pipe) {
+    if (m.material && m.material.emissive) {
+      m.material.emissiveIntensity = live ? 0.4 : 0.12;
+      m.material.opacity = live ? 0.85 : 0.3;
+    }
+  }
+}
+
+function _updateBiasLine(line, series) {
+  if (!line) return;
+  const THREE = _THREE;
+  if (!series || series.length < 2) {
+    // collapse to a flat segment on the baseline
+    line.geometry.setAttribute("position", new THREE.Float32BufferAttribute([PLOT_X0, PLOT_Y, 0, PLOT_X0 + PLOT_W, PLOT_Y, 0], 3));
+    line.geometry.attributes.position.needsUpdate = true;
+    line.visible = S.state === "live";
+    return;
+  }
+  // symmetric vertical scale from the max abs across BOTH series so the drift
+  // vs near-zero contrast is faithful (never invented — from live data only).
+  let amax = 1e-6;
+  const scan = (arr) => { if (Array.isArray(arr)) for (const v of arr) { const a = Math.abs(v); if (a > amax) amax = a; } };
+  scan(S.detSeries); scan(S.stochSeries);
+  const n = series.length;
+  const pos = new Float32Array(n * 3);
+  for (let i = 0; i < n; i++) {
+    const x = PLOT_X0 + (i / (n - 1)) * PLOT_W;
+    const y = PLOT_Y + (series[i] / amax) * (PLOT_H / 2);
+    pos[i * 3 + 0] = x;
+    pos[i * 3 + 1] = y;
+    pos[i * 3 + 2] = 0;
+  }
+  line.geometry.setAttribute("position", new THREE.Float32BufferAttribute(pos, 3));
+  line.geometry.attributes.position.needsUpdate = true;
+  line.geometry.computeBoundingSphere();
+  line.visible = true;
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00009) * 0.12;
+  for (let i = 0; i < _pipe.length; i++) {
+    const m = _pipe[i];
+    if (m && m.rotation && m.geometry && m.geometry.type !== "BufferGeometry") {
+      m.rotation.y += 0.012;
+    }
+  }
+}
+
+// =============================================================================
+// 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%,470px)",
+    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 + " (live)";
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A synthetic tensor with a few injected <b>outliers</b> is quantized to 4-bit float (<b>FP4 E2M1</b>) three ways, ' +
+    'then dequantized: <b>naive</b> (one global scale) vs <b>MXFP4</b> (32-elem blocks, power-of-two scale) vs ' +
+    '<b>NVFP4</b> (16-elem blocks, <b>E4M3</b> FP8 block scale + <b>FP32</b> global \u2014 <b>two-level</b>). Bars show ' +
+    'the MEASURED reconstruction <b>MSE</b> per scheme (shown, NOT hidden). The line plot contrasts <b>deterministic</b> ' +
+    'round-to-nearest (drifts) vs <b>stochastic</b> rounding (near zero) over repeated roundings. Honesty label ' +
+    '<b>MODELED</b> \u2014 arithmetic demonstration only, no GPU kernel executed. 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 = "nvfp4 4-bit training format";
+  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:56%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("nv-size",    "tensor (size \u00d7 size)"));
+  grid.appendChild(kpiRow("nv-outl",    "injected outliers"));
+  grid.appendChild(kpiRow("nv-amax",    "tensor max |value|"));
+  grid.appendChild(kpiRow("nv-naive",   "MSE \u2014 naive-FP4 (global scale)"));
+  grid.appendChild(kpiRow("nv-mx",      "MSE \u2014 MXFP4 (32-blk pow2)"));
+  grid.appendChild(kpiRow("nv-nv",      "MSE \u2014 NVFP4 (16-blk E4M3+FP32)"));
+  grid.appendChild(kpiRow("nv-best",    "best scheme (lowest MSE)"));
+  grid.appendChild(kpiRow("nv-rn",      "rounding demo \u2014 N roundings"));
+  grid.appendChild(kpiRow("nv-det",     "cumulative bias \u2014 deterministic"));
+  grid.appendChild(kpiRow("nv-stoch",   "cumulative bias \u2014 stochastic"));
+  grid.appendChild(kpiRow("nv-label",   "honesty label"));
+  card.appendChild(grid);
+
+  // scaling-pipeline legend (two-level)
+  const pipe = document.createElement("div");
+  pipe.style.cssText = "font-size:10px;color:#9fb1bf;line-height:1.5;border-top:1px solid #1d2a36;padding-top:6px";
+  pipe.innerHTML =
+    "<b style='color:#c9d6df'>two-level scaling pipeline:</b><br>" +
+    "tensor <span style='color:#8a6bff'>\u25a0</span> \u2192 FP32 global scale <span style='color:#8a6bff'>\u25c8</span> " +
+    "\u2192 E4M3 block scale <span style='color:#5b8dee'>\u25c8</span> \u2192 FP4 value <span style='color:#3af4c8'>\u2b21</span>";
+  card.appendChild(pipe);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "NVFP4 \u2014 Agrusa, Rouhani, Micikevicius, Patwary, Shoeybi et al. (NVIDIA) arXiv:2509.25149 \u00b7 MXFP4/OCP arXiv:2310.10537 \u00b7 TetraJet arXiv:2502.20853. MODELED \u00b7 arithmetic-only \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 = "nv-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 nvMse    = _schemeByName("NVFP4");
+  const naiveMse = _schemeByName("naive-FP4");
+  const nvTxt    = (nvMse && typeof nvMse.mse === "number")       ? nvMse.mse.toExponential(2)    : "loading\u2026";
+  const naiveTxt = (naiveMse && typeof naiveMse.mse === "number") ? naiveMse.mse.toExponential(2) : "loading\u2026";
+  const detTxt   = S.detFinal   != null ? S.detFinal.toFixed(2)   : "loading\u2026";
+  const stochTxt = S.stochFinal != null ? S.stochFinal.toFixed(2) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Training big models in only 4 bits per number saves memory and speeds up the math, " +
+    "but 4 bits is very coarse \u2014 so how you pick the <i>scale</i> matters enormously. The <b>naive</b> approach uses " +
+    "one scale for the whole tensor; a single large \u201coutlier\u201d value then crushes precision for everything else " +
+    "(error here \u2248 <b>" + naiveTxt + "</b>). <b>MXFP4</b> scales each 32-number block, and <b>NVFP4</b> scales each " +
+    "smaller 16-number block with a more precise scale plus a second whole-tensor scale (\u201ctwo-level\u201d) \u2014 giving the " +
+    "lowest error here (\u2248 <b>" + nvTxt + "</b>). The line plot shows a second idea: always rounding the same way " +
+    "(<b>deterministic</b>) lets tiny errors pile up in one direction (bias drifts to \u2248 <b>" + detTxt + "</b>), while " +
+    "<b>stochastic</b> rounding \u2014 flipping a weighted coin each time \u2014 cancels out (stays near <b>" + stochTxt + "</b>). " +
+    "This view is <b>MODELED</b>: a deterministic arithmetic demonstration on a tiny synthetic tensor, with the error " +
+    "MEASURED and shown. <b>No GPU kernel runs here</b>, and it does not reproduce NVIDIA's 12-billion-parameter, " +
+    "10-trillion-token training run or its speed claims \u2014 those are NVIDIA's, not independently verified.";
+}
+
+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 _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+function _mseTxt(nm) {
+  const s = _schemeByName(nm);
+  return (s && typeof s.mse === "number") ? s.mse.toExponential(3) : "\u2014";
+}
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("nv-size",  t || (S.size != null ? (S.size + " \u00d7 " + S.size) : "\u2014"));
+  _set("nv-outl",  t || (S.outliers != null ? String(S.outliers) : "\u2014"));
+  _set("nv-amax",  t || (typeof S.tensorAmax === "number" ? S.tensorAmax.toFixed(3) : "\u2014"));
+  _set("nv-naive", t || _mseTxt("naive-FP4"));
+  _set("nv-mx",    t || _mseTxt("MXFP4"));
+  _set("nv-nv",    t || _mseTxt("NVFP4"));
+  _set("nv-best",  t || (S.bestScheme || "\u2014"));
+  _set("nv-rn",    t || ((S.rN != null && S.rDelta != null) ? (S.rN + " \u00d7 \u03b4=" + S.rDelta) : "\u2014"));
+  _set("nv-det",   t || (typeof S.detFinal === "number" ? S.detFinal.toFixed(3) : "\u2014"));
+  _set("nv-stoch", t || (typeof S.stochFinal === "number" ? S.stochFinal.toFixed(3) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("nv-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; _bars = []; _detLine = null; _stochLine = null; _biasZero = null; _pipe = [];
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.size = S.outliers = S.tensorAmax = S.bestScheme = null;
+  S.fp4Levels = S.schemes = null;
+  S.rDelta = S.rN = S.detFinal = S.stochFinal = S.detSeries = S.stochSeries = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/specexec.js

@@ -0,0 +1,560 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/specexec.js — TREE SPECULATIVE EXECUTION organ for the holographic
+// frontier ring (token-tree speculative decoding: a static fixed-shape tree vs.
+// an EAGLE-2-style dynamic Expansion/Rerank tree, verified against a scripted
+// min(1,p/q) acceptance oracle). Renders three views from the live snapshot at
+// /api/killinchu/v1/specexec/tree:
+//   (1) a 3D TREE DIAGRAM — nodes laid out by depth (y-axis), colored by depth,
+//       edges (root→child) widened by the child's synthetic confidence/value V_i;
+//   (2) a TREE CAUSAL-ATTENTION MASK heatmap — the binary ancestor mask (each
+//       node attends only to its ancestors) that lets the whole tree be verified
+//       in ONE forward pass (SpecInfer);
+//   (3) a BAR CHART of expected accepted-path length: static tree vs. dynamic
+//       (Expansion/Rerank) tree under the same synthetic confidences.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is;
+// it is never upgraded.
+//
+// Surface export shape (mirrors ternary.js / kvcache.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   depth, branch, budget, static_nodes, dynamic_nodes,
+//   static_expected_accepted_path_length, dynamic_expected_accepted_path_length,
+//   improvement_ratio, nodes[]{id,parent,depth,confidence,value,accepted},
+//   attention_mask[][]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   Sequoia (DP-optimal token trees): arXiv:2402.12374
+//     https://arxiv.org/abs/2402.12374
+//   EAGLE-2 (context-aware dynamic draft tree; Expansion/Rerank): arXiv:2406.16858
+//     https://arxiv.org/abs/2406.16858
+//   Medusa (multi-head, tree attention, typical acceptance): arXiv:2401.10774
+//     https://arxiv.org/abs/2401.10774
+//   SpecInfer (token-tree verification; tree-structured causal mask), CMU PDF:
+//     https://www.cs.cmu.edu/~zhihaoj2/papers/specinfer.pdf
+//
+// HONESTY LABELS: MODELED (deterministic toy tree-walk demonstrating the tree
+//   topology + Expansion/Rerank value-propagation + min(1,p/q) acceptance
+//   MECHANISM on a synthetic token-tree; NOT a live LLM; no real draft/target
+//   model, no real tokens, no forward pass; expected-path-length values are
+//   computed exactly and DISPLAYED). Read verbatim from JSON; never upgraded.
+// COLOURS (allowed hues only; purple BANNED): lattice-blue 0x5b8dee,
+//   violet-blue 0x8a6bff, proof-teal 0x3af4c8, greys 0x5a6570 / 0x42505d.
+// 0 RUNTIME CDN. Vendored three.js via ctx.THREE (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    = "specexec";
+const TITLE = "Tree Speculative Execution";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/specexec/tree?seed=42&depth=4&branch=3&budget=24";
+
+// data-viz hues — purple BANNED
+const C_D0   = 0x3af4c8;  // proof-teal   (depth 0 / root)
+const C_D1   = 0x5b8dee;  // lattice-blue (depth 1)
+const C_D2   = 0x8a6bff;  // violet-blue  (depth 2)
+const C_D3   = 0x3af4c8;  // proof-teal   (depth 3 — cycles back)
+const C_DEEP = 0x5b8dee;  // lattice-blue (depth ≥ 4)
+const C_EDGE = 0x3af4c8;  // proof-teal   (tree edges)
+const C_DYN  = 0x3af4c8;  // proof-teal   (dynamic bar)
+const C_STAT = 0x5b8dee;  // lattice-blue (static bar)
+const C_MASK = 0x8a6bff;  // violet-blue  (attention-mask "attends" cell)
+const C_DIM  = 0x42505d;  // grey (degraded / no-live-data)
+const C_ZERO = 0x5a6570;  // grey (mask "no-attend" / empty)
+const C_GRID = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const DEPTH_GAP = 1.6;    // world-units per depth level (y)
+const SPREAD    = 6.0;    // horizontal spread of the tree (x)
+const MASK_ORIGIN = { x: 9.0, y: 0.2, z: 0.0 };
+const MASK_CELL   = 0.34;
+const MASK_MAX    = 32;   // cap cells per axis (matches organ node cap)
+const BAR_ORIGIN  = { x: -3.0, y: 0.0, z: 8.0 };
+
+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 _treeGroup = null;               // THREE.Group — nodes + edges
+let _maskMesh  = [];                 // Array<THREE.Mesh> — mask cells (MASK_MAX^2)
+let _barStatic = null;               // THREE.Mesh — static bar
+let _barDyn    = null;               // THREE.Mesh — dynamic bar
+
+// live state
+const S = {
+  label:      null,
+  depth:      null,
+  branch:     null,
+  budget:     null,
+  staticNodes: null,
+  dynamicNodes: null,
+  staticEpl:  null,   // static_expected_accepted_path_length
+  dynamicEpl: null,   // dynamic_expected_accepted_path_length
+  improvement: null,  // improvement_ratio
+  nodes:      null,   // array
+  mask:       null,   // 2D array
+  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, 18);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(3, 2, 3); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildTreeGroup();
+  _buildMaskGrid();
+  _buildBars();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onSnap, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); _repaintScene(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(48, 48, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.16; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+function _buildTreeGroup() {
+  const THREE = _THREE;
+  _treeGroup = new THREE.Group();
+  _group.add(_treeGroup);
+}
+
+// Pre-allocate a fixed MASK_MAX x MASK_MAX grid of mask cells; toggle
+// visibility / color in-place as live data arrives (no per-poll geometry churn).
+function _buildMaskGrid() {
+  const THREE = _THREE;
+  const cellGeo = new THREE.PlaneGeometry(MASK_CELL * 0.9, MASK_CELL * 0.9);
+  for (let r = 0; r < MASK_MAX; r++) {
+    for (let c = 0; c < MASK_MAX; c++) {
+      const mesh = new THREE.Mesh(
+        cellGeo,
+        new THREE.MeshBasicMaterial({ color: C_ZERO, transparent: true, opacity: 0.0, side: THREE.DoubleSide }),
+      );
+      mesh.position.set(MASK_ORIGIN.x + c * MASK_CELL, MASK_ORIGIN.y + (MASK_MAX - r) * MASK_CELL, MASK_ORIGIN.z);
+      mesh.visible = false;
+      _group.add(mesh);
+      _maskMesh.push(mesh);
+    }
+  }
+}
+
+function _buildBars() {
+  const THREE = _THREE;
+  const geo = new THREE.BoxGeometry(0.9, 1.0, 0.9);
+  _barStatic = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_STAT, emissive: C_STAT, emissiveIntensity: 0.4, transparent: true, opacity: 0.9 }),
+  );
+  _barStatic.position.set(BAR_ORIGIN.x, 0.5, BAR_ORIGIN.z);
+  _barStatic.scale.y = 0.01;
+  _group.add(_barStatic);
+
+  _barDyn = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_DYN, emissive: C_DYN, emissiveIntensity: 0.5, transparent: true, opacity: 0.9 }),
+  );
+  _barDyn.position.set(BAR_ORIGIN.x + 1.4, 0.5, BAR_ORIGIN.z);
+  _barDyn.scale.y = 0.01;
+  _group.add(_barDyn);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onSnap(j) {
+  // read honesty label VERBATIM — never upgrade. handle top-level 'label' OR
+  // nested 'payload.label' to match our own module's shape.
+  const lbl = (j && j.label != null) ? j.label
+            : (j && j.payload && j.payload.label != null) ? j.payload.label
+            : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : j;
+  S.label = String(lbl).toUpperCase();
+
+  S.depth        = typeof src.depth  === "number" ? src.depth  : null;
+  S.branch       = typeof src.branch === "number" ? src.branch : null;
+  S.budget       = typeof src.budget === "number" ? src.budget : null;
+  S.staticNodes  = typeof src.static_nodes  === "number" ? src.static_nodes  : null;
+  S.dynamicNodes = typeof src.dynamic_nodes === "number" ? src.dynamic_nodes : null;
+  S.staticEpl    = typeof src.static_expected_accepted_path_length  === "number" ? src.static_expected_accepted_path_length  : null;
+  S.dynamicEpl   = typeof src.dynamic_expected_accepted_path_length === "number" ? src.dynamic_expected_accepted_path_length : null;
+  S.improvement  = typeof src.improvement_ratio === "number" ? src.improvement_ratio : null;
+  S.nodes        = Array.isArray(src.nodes) ? src.nodes : null;
+  S.mask         = Array.isArray(src.attention_mask) ? src.attention_mask : null;
+
+  _repaintScene();
+  _paintOverlay();
+}
+
+// =============================================================================
+// scene painters
+// =============================================================================
+function _depthColor(d) {
+  switch (d) {
+    case 0: return C_D0;
+    case 1: return C_D1;
+    case 2: return C_D2;
+    case 3: return C_D3;
+    default: return C_DEEP;
+  }
+}
+
+function _disposeTree() {
+  if (!_treeGroup) return;
+  const kids = _treeGroup.children.slice();
+  kids.forEach((o) => {
+    _treeGroup.remove(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(); });
+    }
+  });
+}
+
+function _repaintScene() {
+  _repaintTree();
+  _repaintMask();
+  _repaintBars();
+}
+
+// 3D tree: place nodes by depth (y), spread siblings across x within each depth
+// band; color by depth; edge tube radius scaled by child confidence/value.
+function _repaintTree() {
+  const THREE = _THREE;
+  _disposeTree();
+  const live = S.state === "live";
+  const nodes = (live && S.nodes) ? S.nodes : null;
+  if (!nodes || !nodes.length) {
+    // degraded placeholder: a single dim node so the scene is never empty
+    const geo = new THREE.SphereGeometry(0.22, 12, 12);
+    const m = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.2, transparent: true, opacity: 0.35 }));
+    m.position.set(0, DEPTH_GAP, 0);
+    _treeGroup.add(m);
+    return;
+  }
+
+  // group node indices by depth for horizontal layout
+  const byDepth = {};
+  let maxDepth = 0;
+  nodes.forEach((n) => {
+    const d = n.depth || 0;
+    if (!byDepth[d]) byDepth[d] = [];
+    byDepth[d].push(n);
+    if (d > maxDepth) maxDepth = d;
+  });
+
+  // assign world positions
+  const pos = {};  // id -> {x,y,z}
+  Object.keys(byDepth).forEach((dk) => {
+    const d = Number(dk);
+    const arr = byDepth[d];
+    const count = arr.length;
+    arr.forEach((n, i) => {
+      const frac = count > 1 ? (i / (count - 1)) : 0.5;
+      const x = (frac - 0.5) * SPREAD;
+      const y = DEPTH_GAP * (maxDepth - d) + 0.6;  // root highest
+      const z = 0;
+      pos[n.id] = { x, y, z };
+    });
+  });
+
+  // nodes as spheres (radius scaled a touch by value)
+  nodes.forEach((n) => {
+    const p = pos[n.id];
+    if (!p) return;
+    const v = typeof n.value === "number" ? n.value : 0.5;
+    const rad = 0.14 + 0.16 * Math.max(0, Math.min(1, v));
+    const geo = new THREE.SphereGeometry(rad, 14, 14);
+    const col = _depthColor(n.depth || 0);
+    const m = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: col, emissive: col, emissiveIntensity: 0.55, transparent: true, opacity: 0.95 }));
+    m.position.set(p.x, p.y, p.z);
+    _treeGroup.add(m);
+  });
+
+  // edges as thin cylinders; radius scaled by child confidence
+  nodes.forEach((n) => {
+    if (n.parent == null || n.parent < 0) return;
+    const a = pos[n.id];
+    const b = pos[n.parent];
+    if (!a || !b) return;
+    const conf = typeof n.confidence === "number" ? n.confidence : 0.5;
+    const rad = 0.015 + 0.075 * Math.max(0, Math.min(1, conf));
+    const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 0.001;
+    const geo = new THREE.CylinderGeometry(rad, rad, len, 8);
+    const m = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: C_EDGE, emissive: C_EDGE, emissiveIntensity: 0.35, transparent: true, opacity: 0.6 }));
+    // midpoint
+    m.position.set((a.x + b.x) / 2, (a.y + b.y) / 2, (a.z + b.z) / 2);
+    // orient cylinder (default +y) to point from b->a
+    const up = new THREE.Vector3(0, 1, 0);
+    const dir = new THREE.Vector3(dx, dy, dz).normalize();
+    const quat = new THREE.Quaternion().setFromUnitVectors(up, dir);
+    m.quaternion.copy(quat);
+    _treeGroup.add(m);
+  });
+}
+
+function _repaintMask() {
+  const live = S.state === "live";
+  const mask = (live && S.mask) ? S.mask : null;
+  const n = mask ? Math.min(mask.length, MASK_MAX) : 0;
+  for (let r = 0; r < MASK_MAX; r++) {
+    for (let c = 0; c < MASK_MAX; c++) {
+      const mesh = _maskMesh[r * MASK_MAX + c];
+      if (!mask || r >= n || c >= n) {
+        mesh.visible = false;
+        continue;
+      }
+      mesh.visible = true;
+      const on = mask[r] && mask[r][c] === 1;
+      const col = on ? C_MASK : C_ZERO;
+      mesh.material.color.setHex(col);
+      mesh.material.opacity = on ? 0.9 : 0.14;
+    }
+  }
+}
+
+function _repaintBars() {
+  const live = S.state === "live";
+  const s = (live && typeof S.staticEpl === "number") ? S.staticEpl : 0;
+  const d = (live && typeof S.dynamicEpl === "number") ? S.dynamicEpl : 0;
+  const maxv = Math.max(s, d, 1);
+  const scale = 5.0 / maxv;   // tallest bar ≈ 5 world units
+  if (_barStatic) {
+    const h = Math.max(0.01, s * scale);
+    _barStatic.scale.y = h;
+    _barStatic.position.y = h / 2;
+    _barStatic.material.color.setHex(live ? C_STAT : C_DIM);
+    _barStatic.material.emissive.setHex(live ? C_STAT : C_DIM);
+    _barStatic.material.opacity = live ? 0.9 : 0.35;
+  }
+  if (_barDyn) {
+    const h = Math.max(0.01, d * scale);
+    _barDyn.scale.y = h;
+    _barDyn.position.y = h / 2;
+    _barDyn.material.color.setHex(live ? C_DYN : C_DIM);
+    _barDyn.material.emissive.setHex(live ? C_DYN : C_DIM);
+    _barDyn.material.opacity = live ? 0.9 : 0.35;
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_treeGroup) _treeGroup.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%,470px)",
+    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 =
+    'Instead of drafting one linear chain, tree speculative decoding drafts a <b>tree</b> of candidate ' +
+    'tokens \u2014 each root\u2192node path is a candidate sequence, siblings are alternatives at the same ' +
+    'position. A <b>tree causal-attention mask</b> (each token attends only to its ancestors) lets the ' +
+    'whole tree be verified in one pass. This view builds the tree two ways \u2014 a <b>static</b> fixed ' +
+    'shape vs. an EAGLE-2-style <b>dynamic</b> Expansion/Rerank on synthetic confidences (value ' +
+    'V<sub>i</sub> = product of confidences root\u2192i) \u2014 then walks both against a scripted ' +
+    '<b>min(1, p/q)</b> acceptance oracle to count the expected accepted-path length. Honesty label ' +
+    '<b>MODELED</b> (deterministic toy tree-walk, NOT a live LLM). 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 = "tree speculative execution";
+  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:56%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("sx-tree",     "tree (depth / branch / budget)"));
+  grid.appendChild(kpiRow("sx-nodes",    "nodes (static / dynamic)"));
+  grid.appendChild(kpiRow("sx-static",   "E[accepted path] \u2014 static (MEASURED)"));
+  grid.appendChild(kpiRow("sx-dynamic",  "E[accepted path] \u2014 dynamic (MEASURED)"));
+  grid.appendChild(kpiRow("sx-improve",  "improvement (dynamic / static)"));
+  grid.appendChild(kpiRow("sx-mask",     "tree causal-attention mask"));
+  grid.appendChild(kpiRow("sx-label",    "honesty label"));
+  card.appendChild(grid);
+
+  const legend = document.createElement("div");
+  legend.style.cssText = "font-size:10px;color:#9fb1bf;line-height:1.5;display:flex;gap:10px;flex-wrap:wrap";
+  legend.innerHTML =
+    '<span style="color:#3af4c8">\u25cf dynamic / root</span>' +
+    '<span style="color:#5b8dee">\u25cf static / depth</span>' +
+    '<span style="color:#8a6bff">\u25cf mask attends</span>' +
+    '<span style="color:#5a6570">\u25cf no-attend</span>';
+  card.appendChild(legend);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Tree speculative decoding \u2014 Sequoia arXiv:2402.12374 \u00b7 EAGLE-2 arXiv:2406.16858 \u00b7 Medusa arXiv:2401.10774 \u00b7 SpecInfer (CMU). 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 = "sx-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 sEpl = S.staticEpl   != null ? S.staticEpl.toFixed(2)   : "loading\u2026";
+  const dEpl = S.dynamicEpl  != null ? S.dynamicEpl.toFixed(2)  : "loading\u2026";
+  const imp  = S.improvement != null ? S.improvement.toFixed(2) + "\u00d7" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> To speed up a language model, a small \u201cdraft\u201d step guesses several of the " +
+    "next words at once so the big model can check them in a single batch. Guessing a <b>tree</b> of possible " +
+    "words (with branches for alternatives) beats guessing a single straight line, because more good guesses " +
+    "survive the check. This view builds the guess-tree two ways: a fixed shape (<b>static</b>) and a smarter " +
+    "shape that spends its limited budget on the most promising branches (<b>dynamic</b>, the EAGLE-2 idea). " +
+    "Under the same scripted accept/reject rule, the static tree commits about <b>" + sEpl + "</b> words on " +
+    "average and the dynamic tree about <b>" + dEpl + "</b> \u2014 roughly <b>" + imp + "</b> as many. The grid on " +
+    "the right is the <b>attention mask</b>: it shows each guessed word only looking back at its own ancestors, " +
+    "which is what lets the whole tree be checked in one pass. This is a <b>MODELED</b> deterministic toy " +
+    "tree-walk on made-up confidence numbers \u2014 <b>not a live LLM</b>, no real model is queried, and no " +
+    "wall-clock speedup is claimed. The numbers shown are computed exactly and displayed, not hidden.";
+}
+
+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("sx-tree",    t || ((S.depth != null && S.branch != null && S.budget != null) ? (S.depth + " / " + S.branch + " / " + S.budget) : "\u2014"));
+  _set("sx-nodes",   t || ((S.staticNodes != null && S.dynamicNodes != null) ? (S.staticNodes + " / " + S.dynamicNodes) : "\u2014"));
+  _set("sx-static",  t || fx(S.staticEpl, 3));
+  _set("sx-dynamic", t || fx(S.dynamicEpl, 3));
+  _set("sx-improve", t || (S.improvement != null ? S.improvement.toFixed(3) + "\u00d7" : "\u2014"));
+  _set("sx-mask",    t || ((S.mask && S.mask.length) ? (S.mask.length + " \u00d7 " + S.mask.length) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("sx-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; _treeGroup = null; _maskMesh = []; _barStatic = null; _barDyn = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.depth = S.branch = S.budget = null;
+  S.staticNodes = S.dynamicNodes = null;
+  S.staticEpl = S.dynamicEpl = S.improvement = null;
+  S.nodes = S.mask = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

szl3d_holographic.py

@@ -83,6 +83,9 @@ SURFACES: List[Dict[str, str]] = [
     {"id": "router", "title": "Router", "owner": "Dev7"},
     {"id": "anatomy", "title": "Anatomy", "owner": "Dev8"},
     {"id": "estate", "title": "Estate", "owner": "Dev9"},
+    {"id": "muon", "title": "Muon Orthogonalized-Momentum Optimizer", "owner": "Wave13"},
+    {"id": "specexec", "title": "Tree Speculative Execution", "owner": "Wave13"},
+    {"id": "nvfp4", "title": "NVFP4 4-bit Training Format", "owner": "Wave13"},
 ]
 
 # Content-type by extension (the only extensions we serve from the 3d tree).