deploy(hf): sync szl-holdings/a11oy@main derived COPY set

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy main.
Files: 848 Pruned: 0
Derived from Dockerfile COPY sources (NO hand-maintained allowlist).

Signed-off-by: SZL Holdings <noreply@szlholdings.ai>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

static/3d/holographic.html

@@ -84,6 +84,10 @@ const SURFACES = [
   { 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: "grpo", title: "GRPO Reward Dynamics", mod: "/static/3d/surfaces/grpo.js" },
+  { id: "kvcache", title: "KV-Cache H2O", mod: "/static/3d/surfaces/kvcache.js" },
+  { id: "mla", title: "Latent Attention (MLA)", mod: "/static/3d/surfaces/mla.js" },
+  { id: "blt", title: "Byte-Latent Patching", mod: "/static/3d/surfaces/blt.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/blt.js

@@ -0,0 +1,472 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/blt.js — BYTE LATENT TRANSFORMER ENTROPY-PATCHING organ for the
+// holographic frontier ring (Meta FAIR tokenizer-free dynamic byte-patching
+// idea). Renders the input byte stream as a 3D ribbon: entropy height per
+// byte (lattice-blue), patch boundaries drawn as proof-teal cut-planes where
+// entropy spikes, and low-entropy runs grouped visually into big grey/dim
+// patches. A HUD shows num_patches + compute_savings_ratio. 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 exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   text_len, threshold, num_patches, avg_patch_len, patch_boundaries[],
+//   entropy_series[], compute_savings_ratio
+//
+// LEADER ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Byte Latent Transformer (entropy-patching idea rendered here):
+//     Pagnoni, Pasunuru, Rodriguez et al. 2024, Meta FAIR
+//     arXiv:2412.09871 — https://arxiv.org/abs/2412.09871
+//   Reference implementation (reference only):
+//     github.com/facebookresearch/blt
+//     https://github.com/facebookresearch/blt
+//
+// HONESTY LABELS: MODELED (deterministic order-2 Markov byte-entropy
+//   patching simulation of the BLT dynamic-patching idea; NOT the trained
+//   BLT entropy model; NEVER-CLAIMED-AS Meta FAIR BLT). Read verbatim from
+//   JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (byte ribbon / entropy height), proof-teal
+//   0x3af4c8 (patch-boundary cut-planes / HUD accent), greys (low-entropy
+//   grouped runs / 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    = "blt";
+const TITLE = "Byte Latent Transformer · Entropy-Patching (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 BLT organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/blt/entropy-patch?seed=42&threshold=2.5";
+
+// data-viz hues — purple BANNED
+const C_RIBBON  = 0x5b8dee;  // lattice-blue (byte ribbon / entropy height)
+const C_CUT     = 0x3af4c8;  // proof-teal (patch-boundary cut-plane / HUD accent)
+const C_PATCH   = 0x5a6570;  // grey (low-entropy grouped-patch fill)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// ribbon layout geometry
+const SEG_LEN     = 0.16;  // world-units per byte along X (ribbon axis)
+const MAX_SEGS    = 512;   // cap on rendered byte segments (perf; matches endpoint sample cap)
+const HEIGHT_SCALE = 0.55; // world-units per bit of entropy (Y)
+const MAX_CUTS    = 96;    // cap on rendered patch-boundary cut-planes (perf)
+
+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 — ribbon baseline axis
+let _ribbon     = null;               // THREE.Line — entropy-height ribbon polyline
+let _segMesh    = [];                 // Array<THREE.Mesh> — per-sample entropy pillars
+let _cutPlanes  = [];                 // Array<THREE.Mesh> — patch-boundary cut-planes
+let _marker     = null;               // THREE.Mesh — HUD "compute savings" pulsing marker
+
+// live state
+const S = {
+  label:        null,
+  textLen:      null,   // text_len
+  threshold:    null,   // threshold
+  numPatches:   null,   // num_patches
+  avgPatchLen:  null,   // avg_patch_len
+  boundaries:   null,   // patch_boundaries[]
+  entropySeries: null,  // entropy_series[] -> [byte_idx, bits]
+  savingsRatio: null,   // compute_savings_ratio
+  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, 6, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(6, 1, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildRibbon();
+  _buildCutPlanes();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onBlt, { 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 set of ribbon-segment pillars (entropy height per
+// sampled byte) + a baseline spine. We toggle visibility/height/color
+// in-place as live data arrives (no per-poll geometry churn).
+function _buildRibbon() {
+  const THREE = _THREE;
+
+  // baseline spine: a straight line along X marking the byte-stream axis
+  {
+    const pts = [new THREE.Vector3(0, 0, 0), new THREE.Vector3(SEG_LEN * (MAX_SEGS - 1) + 1, 0, 0)];
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_RIBBON, transparent: true, opacity: 0.35 });
+    _spine = new THREE.Line(geo, mat);
+    _group.add(_spine);
+  }
+
+  // entropy-height ribbon: a polyline whose Y tracks entropy bits per byte
+  {
+    const pts = [];
+    for (let i = 0; i < MAX_SEGS; i++) pts.push(new THREE.Vector3(i * SEG_LEN, 0, 0));
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_RIBBON, transparent: true, opacity: 0.0 });
+    _ribbon = new THREE.Line(geo, mat);
+    _group.add(_ribbon);
+  }
+
+  const segGeo = new THREE.BoxGeometry(SEG_LEN * 0.8, 1, 0.22);
+  for (let i = 0; i < MAX_SEGS; i++) {
+    const mesh = new THREE.Mesh(
+      segGeo,
+      new THREE.MeshStandardMaterial({ color: C_RIBBON, emissive: C_RIBBON, emissiveIntensity: 0.22, transparent: true, opacity: 0.0 }),
+    );
+    mesh.position.set(i * SEG_LEN, 0, 0);
+    mesh.scale.y = 0.0001;
+    mesh.visible = false;
+    _group.add(mesh);
+    _segMesh.push(mesh);
+  }
+}
+
+// Pre-allocate cut-plane meshes marking patch boundaries (proof-teal, thin
+// vertical panels perpendicular to the ribbon axis).
+function _buildCutPlanes() {
+  const THREE = _THREE;
+  const planeGeo = new THREE.PlaneGeometry(0.03, 2.2);
+  for (let i = 0; i < MAX_CUTS; i++) {
+    const mesh = new THREE.Mesh(
+      planeGeo,
+      new THREE.MeshBasicMaterial({ color: C_CUT, transparent: true, opacity: 0.0, side: THREE.DoubleSide }),
+    );
+    mesh.position.set(0, 1.1, 0);
+    mesh.visible = false;
+    _group.add(mesh);
+    _cutPlanes.push(mesh);
+  }
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.26, 1),
+    new THREE.MeshStandardMaterial({ color: C_CUT, emissive: C_CUT, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, -0.7, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onBlt(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label         = (j.label || "MODELED").toUpperCase();
+  S.textLen       = typeof j.text_len              === "number" ? j.text_len              : null;
+  S.threshold     = typeof j.threshold             === "number" ? j.threshold             : null;
+  S.numPatches    = typeof j.num_patches           === "number" ? j.num_patches           : null;
+  S.avgPatchLen   = typeof j.avg_patch_len         === "number" ? j.avg_patch_len         : null;
+  S.boundaries    = Array.isArray(j.patch_boundaries) ? j.patch_boundaries : null;
+  S.entropySeries = Array.isArray(j.entropy_series)   ? j.entropy_series   : null;
+  S.savingsRatio  = typeof j.compute_savings_ratio === "number" ? j.compute_savings_ratio : null;
+
+  _updateRibbon();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the ribbon + cut-planes from live data
+// =============================================================================
+function _updateRibbon() {
+  const live = S.state === "live";
+  const series = live && S.entropySeries && S.entropySeries.length ? S.entropySeries.slice(0, MAX_SEGS) : [];
+  const boundarySet = new Set(live && S.boundaries ? S.boundaries : []);
+
+  // ribbon polyline points
+  const positions = _ribbon.geometry.attributes.position;
+  let maxH = 0;
+  for (let i = 0; i < series.length; i++) maxH = Math.max(maxH, series[i][1] || 0);
+  maxH = Math.max(maxH, 0.001);
+
+  for (let i = 0; i < MAX_SEGS; i++) {
+    const mesh = _segMesh[i];
+    if (!live || i >= series.length) {
+      mesh.visible = false;
+      positions.setXYZ(i, i * SEG_LEN, 0, 0);
+      continue;
+    }
+    const [byteIdx, hBits] = series[i];
+    const h = Math.max(0.02, (hBits / maxH) * 2.4 * HEIGHT_SCALE);
+    const isBoundary = boundarySet.has(byteIdx);
+
+    mesh.visible = true;
+    mesh.scale.y = Math.max(h, 0.02);
+    mesh.position.set(i * SEG_LEN, h / 2, 0);
+
+    // low-entropy runs (below threshold) render dim grey "grouped patch";
+    // high-entropy spikes (>= threshold, i.e. a cut point) render lattice-blue.
+    const spiky = S.threshold != null ? hBits > S.threshold : hBits > 2.5;
+    const color = spiky ? C_RIBBON : C_PATCH;
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = spiky ? 0.4 : 0.12;
+    mesh.material.opacity = spiky ? 0.95 : 0.55;
+
+    positions.setXYZ(i, i * SEG_LEN, h, 0);
+  }
+  positions.needsUpdate = true;
+  _ribbon.material.opacity = live ? 0.5 : 0.0;
+  _ribbon.material.color.setHex(live ? C_RIBBON : C_DIM);
+
+  // patch-boundary cut-planes: place at each boundary's ribbon-space x
+  const boundaries = live && S.boundaries ? S.boundaries.slice(0, MAX_CUTS) : [];
+  // map boundary byte-index -> nearest sample index x-position (approx via
+  // proportion of text_len, since entropy_series may be a downsample)
+  const textLen = S.textLen || 1;
+  for (let i = 0; i < MAX_CUTS; i++) {
+    const plane = _cutPlanes[i];
+    if (!live || i >= boundaries.length) {
+      plane.visible = false;
+      continue;
+    }
+    const byteIdx = boundaries[i];
+    const frac = Math.min(1, byteIdx / textLen);
+    const x = frac * SEG_LEN * (MAX_SEGS - 1);
+    plane.visible = true;
+    plane.position.set(x, 1.1, 0);
+    plane.material.opacity = 0.55;
+    plane.material.color.setHex(C_CUT);
+  }
+
+  _spine.material.color.setHex(live ? C_RIBBON : C_DIM);
+  _spine.material.opacity = live ? 0.35 : 0.15;
+
+  if (_marker) {
+    if (live && S.savingsRatio != null) {
+      _marker.material.color.setHex(C_CUT);
+      _marker.material.emissive.setHex(C_CUT);
+      _marker.material.opacity = 0.85;
+      // marker rides along X proportional to compute_savings_ratio (visual "compute win" cue)
+      const x = Math.min(SEG_LEN * (MAX_SEGS - 1), Math.log2(1 + (S.savingsRatio || 1)) * 2.2);
+      _marker.position.set(x, -0.7, 0);
+    } 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.024;
+    _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 =
+    'Instead of fixed-vocabulary tokens, bytes are grouped into <b>variable-length patches</b> ' +
+    'cut wherever the next-byte entropy <b>spikes</b> (high surprise). Predictable spans (grey, ' +
+    'low entropy) collapse into one big patch; unpredictable spans (lattice-blue, high entropy) ' +
+    'fragment into many small patches at proof-teal cut-planes. ' +
+    'Honesty label <b>MODELED</b> (deterministic order-2 Markov byte-entropy simulation of the BLT ' +
+    'entropy-patching idea; NOT the trained BLT entropy model). 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 = "byte latent transformer · entropy-patching";
+  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("blt-textlen",  "text_len (bytes)"));
+  grid.appendChild(kpiRow("blt-threshold","threshold (bits)"));
+  grid.appendChild(kpiRow("blt-numpatch", "num_patches"));
+  grid.appendChild(kpiRow("blt-avglen",   "avg_patch_len"));
+  grid.appendChild(kpiRow("blt-savings",  "compute_savings_ratio \u2014 MODELED"));
+  grid.appendChild(kpiRow("blt-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 = "Pagnoni et al. (Meta FAIR) arXiv:2412.09871 (Byte Latent Transformer) \u00b7 github.com/facebookresearch/blt (reference). 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 = "blt-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 patches = S.numPatches  != null ? String(S.numPatches) : "loading\u2026";
+  const bytes   = S.textLen     != null ? String(S.textLen)    : "loading\u2026";
+  const ratio   = S.savingsRatio != null ? S.savingsRatio.toFixed(2) + "\u00d7" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Normal language models chop text into a fixed dictionary of " +
+    "\u201ctokens\u201d before reading it. This organ instead reads raw <b>bytes</b> and asks, at every " +
+    "position, \u201chow surprising is the next byte, given what came right before it?\u201d When that " +
+    "surprise (entropy) spikes, it starts a new <b>patch</b>; when the text is predictable, it keeps " +
+    "stretching the same patch. Here, <b>" + bytes + " bytes</b> collapsed into just <b>" + patches +
+    " patches</b> \u2014 a <b>" + ratio + " compute-savings ratio</b>, because predictable stretches " +
+    "(like repeated letters) get bundled into one cheap patch instead of being processed byte-by-byte. " +
+    "This is the core idea behind Meta FAIR's Byte Latent Transformer (BLT): spend compute where the " +
+    "data is hard, save it where the data is easy. This view is a <b>MODELED</b> stand-in entropy " +
+    "signal built from the text itself, not a run of the real trained BLT 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("blt-textlen",   t || (S.textLen    != null ? String(S.textLen) : "\u2014"));
+  _set("blt-threshold", t || fx(S.threshold, 2));
+  _set("blt-numpatch",  t || (S.numPatches != null ? String(S.numPatches) : "\u2014"));
+  _set("blt-avglen",    t || fx(S.avgPatchLen, 3));
+  _set("blt-savings",   t || (S.savingsRatio != null ? S.savingsRatio.toFixed(3) + "\u00d7" : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("blt-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; _ribbon = null; _segMesh = []; _cutPlanes = []; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.textLen = S.threshold = S.numPatches = null;
+  S.avgPatchLen = S.boundaries = S.entropySeries = S.savingsRatio = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/grpo.js

@@ -0,0 +1,508 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/grpo.js — GRPO REWARD DYNAMICS organ for the holographic frontier
+// ring (Group Relative Policy Optimization, critic-free RL post-training).
+// Renders each training step's sampled reward GROUP as points scattering
+// around a group-mean plane; each point's height above/below the plane is
+// its group-normalized advantage (proof-teal above the mean, grey below),
+// a KL-tether line ties the group to a reference-policy anchor, and a HUD
+// tracks mean_reward + kl_divergence + final_policy_score climbing over the
+// run, from the live snapshot at /api/killinchu/v1/grpo/reward-dynamics.
+// 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 exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   group_size, steps, kl_beta, clip_eps, mean_reward, mean_advantage,
+//   kl_divergence, clip_fraction, final_policy_score, reward_trajectory[],
+//   kl_trajectory[], policy_score_trajectory[], advantage_trajectory[],
+//   clip_fraction_trajectory[]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   GRPO (group-relative advantage + PPO-clip + KL-penalty arithmetic
+//   simulated here):
+//     Shao et al. 2024, "DeepSeekMath", arXiv:2402.03300
+//     https://arxiv.org/abs/2402.03300
+//   DeepSeek-R1 (large-scale RL post-training using GRPO — reference only):
+//     DeepSeek-AI 2025, arXiv:2501.12948
+//     https://arxiv.org/abs/2501.12948
+//
+// HONESTY LABELS: MODELED (deterministic simulation of GRPO group-advantage +
+//   PPO-clip + KL arithmetic; NOT a trained policy; NEVER-CLAIMED-AS
+//   DeepSeek-R1/DeepSeekMath training). Read verbatim from JSON; never
+//   upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (group-mean plane / spine), proof-teal
+//   0x3af4c8 (above-mean / positive-advantage samples, HUD accent), greys
+//   (below-mean / 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    = "grpo";
+const TITLE = "GRPO Reward Dynamics · Group-Relative Advantage (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 GRPO organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/grpo/reward-dynamics?seed=42&group_size=8&steps=200&kl_beta=0.04";
+
+// data-viz hues — purple BANNED
+const C_PLANE   = 0x5b8dee;  // lattice-blue (group-mean plane / spine)
+const C_ABOVE   = 0x3af4c8;  // proof-teal (above-mean / positive-advantage sample, HUD accent)
+const C_BELOW   = 0x5a6570;  // grey (below-mean / negative-advantage sample)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+const C_KL      = 0x8a6bff;  // NOTE: reserved slot unused — see doctrine note below
+
+// Doctrine v11 colour scope: purple (any hue) is BANNED — the KL-tether line
+// below intentionally uses lattice-blue (dimmed), never the 0x8a6bff constant
+// above. The constant is retained ONLY as a documented "never use" marker so
+// future edits do not accidentally reach for a purple hue for the tether.
+const C_TETHER  = 0x5b8dee;  // KL-tether line — lattice-blue, dimmed via opacity
+
+// group/step scatter layout geometry
+const STEP_LEN    = 1.9;   // world-units between steps along X (training-step axis)
+const GROUP_SPAN  = 3.2;   // world-units spread of a group across Z (per-sample jitter)
+const MAX_STEPS   = 14;    // number of recent steps rendered along the axis
+const MAX_SAMPLES = 16;    // cap on group_size rendered per step (perf)
+const ADV_SCALE   = 1.6;   // world-units of height per unit of |advantage|
+
+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 _plane      = null;               // THREE.Mesh — translucent group-mean plane
+let _spine      = null;               // THREE.Line — training-step axis
+let _sampleMesh = [];                 // Array<Array<THREE.Mesh>> — [step][sampleIdx]
+let _tethers    = [];                 // Array<THREE.Line> — KL-tether per step
+let _marker     = null;               // THREE.Mesh — HUD "policy_score" pulsing marker
+
+// live state
+const S = {
+  label:        null,
+  groupSize:    null,   // group_size
+  steps:        null,   // steps
+  klBeta:       null,   // kl_beta
+  clipEps:      null,   // clip_eps
+  meanReward:   null,   // mean_reward
+  meanAdv:      null,   // mean_advantage
+  klDiv:        null,   // kl_divergence
+  clipFrac:     null,   // clip_fraction
+  policyScore:  null,   // final_policy_score
+  rewardTraj:   null,   // reward_trajectory[]
+  klTraj:       null,   // kl_trajectory[]
+  scoreTraj:    null,   // policy_score_trajectory[]
+  advTraj:      null,   // advantage_trajectory[]
+  clipTraj:     null,   // clip_fraction_trajectory[]
+  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, 7, 17);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(6, 1, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildPlaneAndSpine();
+  _buildScatterGrid();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onGrpo, { 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;
+}
+
+// Group-mean plane: a thin, translucent strip along the training-step axis at
+// y=0 representing "the group mean" for each step — advantage is literally
+// the height of each sample above/below this plane.
+function _buildPlaneAndSpine() {
+  const THREE = _THREE;
+
+  const planeGeo = new THREE.PlaneGeometry(STEP_LEN * (MAX_STEPS - 1) + 1.4, GROUP_SPAN + 0.6);
+  const planeMat = new THREE.MeshBasicMaterial({
+    color: C_PLANE, transparent: true, opacity: 0.08, side: THREE.DoubleSide,
+  });
+  _plane = new THREE.Mesh(planeGeo, planeMat);
+  _plane.rotation.x = -Math.PI / 2;
+  _plane.position.set((STEP_LEN * (MAX_STEPS - 1)) / 2, 0, 0);
+  _group.add(_plane);
+
+  const pts = [new THREE.Vector3(0, 0, 0), new THREE.Vector3(STEP_LEN * (MAX_STEPS - 1) + 1, 0, 0)];
+  const geo = new THREE.BufferGeometry().setFromPoints(pts);
+  const mat = new THREE.LineBasicMaterial({ color: C_PLANE, transparent: true, opacity: 0.5 });
+  _spine = new THREE.Line(geo, mat);
+  _group.add(_spine);
+}
+
+// Pre-allocate a fixed grid of sample meshes: MAX_STEPS steps x MAX_SAMPLES
+// samples per step, plus one KL-tether line per step. We toggle
+// visibility/color/position in-place as live data arrives (no per-poll
+// geometry churn).
+function _buildScatterGrid() {
+  const THREE = _THREE;
+
+  const sampleGeo = new THREE.SphereGeometry(0.16, 12, 10);
+  for (let s = 0; s < MAX_STEPS; s++) {
+    const stepSamples = [];
+    const x = s * STEP_LEN;
+    for (let t = 0; t < MAX_SAMPLES; t++) {
+      // deterministic-looking jitter across Z for visual spread (purely
+      // layout, not data — actual height/color comes from live advantage)
+      const z = (((t * 2654435761) % 1000) / 1000 - 0.5) * GROUP_SPAN;
+      const mesh = new THREE.Mesh(
+        sampleGeo,
+        new THREE.MeshStandardMaterial({ color: C_ABOVE, emissive: C_ABOVE, emissiveIntensity: 0.25, transparent: true, opacity: 0.0 }),
+      );
+      mesh.position.set(x, 0, z);
+      mesh.visible = false;
+      _group.add(mesh);
+      stepSamples.push(mesh);
+    }
+    _sampleMesh.push(stepSamples);
+
+    // KL-tether: vertical line from the plane up to a small anchor point,
+    // whose height encodes that step's KL-divergence-vs-reference estimate.
+    const tetherGeo = new THREE.BufferGeometry().setFromPoints([
+      new THREE.Vector3(x, 0, GROUP_SPAN / 2 + 0.4), new THREE.Vector3(x, 0.01, GROUP_SPAN / 2 + 0.4),
+    ]);
+    const tetherMat = new THREE.LineBasicMaterial({ color: C_TETHER, transparent: true, opacity: 0.55 });
+    const tether = new THREE.Line(tetherGeo, tetherMat);
+    tether.visible = false;
+    _group.add(tether);
+    _tethers.push(tether);
+  }
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.26, 1),
+    new THREE.MeshStandardMaterial({ color: C_ABOVE, emissive: C_ABOVE, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, -0.6, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onGrpo(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label       = (j.label || "MODELED").toUpperCase();
+  S.groupSize   = typeof j.group_size          === "number" ? j.group_size          : null;
+  S.steps       = typeof j.steps               === "number" ? j.steps               : null;
+  S.klBeta      = typeof j.kl_beta             === "number" ? j.kl_beta             : null;
+  S.clipEps     = typeof j.clip_eps            === "number" ? j.clip_eps            : null;
+  S.meanReward  = typeof j.mean_reward         === "number" ? j.mean_reward         : null;
+  S.meanAdv     = typeof j.mean_advantage      === "number" ? j.mean_advantage      : null;
+  S.klDiv       = typeof j.kl_divergence       === "number" ? j.kl_divergence       : null;
+  S.clipFrac    = typeof j.clip_fraction       === "number" ? j.clip_fraction       : null;
+  S.policyScore = typeof j.final_policy_score  === "number" ? j.final_policy_score  : null;
+  S.rewardTraj  = Array.isArray(j.reward_trajectory)       ? j.reward_trajectory       : null;
+  S.klTraj      = Array.isArray(j.kl_trajectory)           ? j.kl_trajectory           : null;
+  S.scoreTraj   = Array.isArray(j.policy_score_trajectory) ? j.policy_score_trajectory : null;
+  S.advTraj     = Array.isArray(j.advantage_trajectory)    ? j.advantage_trajectory    : null;
+  S.clipTraj    = Array.isArray(j.clip_fraction_trajectory)? j.clip_fraction_trajectory: null;
+
+  _updateScatter();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the group scatter / KL-tethers from live data
+// =============================================================================
+function _updateScatter() {
+  const live = S.state === "live";
+  const groupSize = live && S.groupSize ? Math.min(S.groupSize, MAX_SAMPLES) : 0;
+
+  // Use the tail of each trajectory (most recent MAX_STEPS points) so the
+  // pipeline always shows the latest training window.
+  const rewardTail = live && S.rewardTraj && S.rewardTraj.length ? S.rewardTraj.slice(-MAX_STEPS) : [];
+  const advTail     = live && S.advTraj    && S.advTraj.length    ? S.advTraj.slice(-MAX_STEPS)    : [];
+  const klTail      = live && S.klTraj     && S.klTraj.length     ? S.klTraj.slice(-MAX_STEPS)     : [];
+  const nSteps = rewardTail.length;
+
+  for (let s = 0; s < MAX_STEPS; s++) {
+    const showStep = live && s < nSteps && groupSize > 0;
+    const meanAdvAtStep = showStep ? advTail[s] : 0;
+    const klAtStep = showStep ? klTail[s] : 0;
+
+    _tethers[s].visible = showStep;
+    if (showStep) {
+      const tetherHeight = Math.min(2.4, 0.3 + klAtStep * 6.0);
+      const pos = _tethers[s].geometry.attributes.position;
+      pos.setXYZ(1, s * STEP_LEN, tetherHeight, GROUP_SPAN / 2 + 0.4);
+      pos.needsUpdate = true;
+      _tethers[s].material.color.setHex(C_TETHER);
+      _tethers[s].material.opacity = 0.55;
+    }
+
+    for (let t = 0; t < MAX_SAMPLES; t++) {
+      const mesh = _sampleMesh[s][t];
+      if (!showStep || t >= groupSize) {
+        mesh.visible = false;
+        continue;
+      }
+      mesh.visible = true;
+      // per-sample advantage sign alternates deterministically around the
+      // step's mean |advantage| so the cloud visibly straddles the plane —
+      // exact per-sample values are not re-transmitted by the endpoint
+      // (only the step aggregate is), so this renders the aggregate
+      // magnitude as a symmetric scatter, which is an honest visual proxy.
+      const sign = (t % 2 === 0) ? 1 : -1;
+      const jitter = 0.65 + 0.35 * (((t * 2246822519) % 1000) / 1000);
+      const height = sign * meanAdvAtStep * ADV_SCALE * jitter;
+      mesh.position.y = height;
+
+      const above = height >= 0;
+      const color = above ? C_ABOVE : C_BELOW;
+      mesh.material.color.setHex(color);
+      mesh.material.emissive.setHex(color);
+      mesh.material.emissiveIntensity = above ? 0.5 : 0.15;
+      mesh.material.opacity = above ? 0.92 : 0.45;
+    }
+  }
+
+  // plane + spine + marker degrade to grey when not live
+  _plane.material.color.setHex(live ? C_PLANE : C_DIM);
+  _plane.material.opacity = live ? 0.08 : 0.03;
+  _spine.material.color.setHex(live ? C_PLANE : C_DIM);
+  _spine.material.opacity = live ? 0.5 : 0.15;
+
+  if (_marker) {
+    if (live && S.policyScore != null) {
+      _marker.material.color.setHex(C_ABOVE);
+      _marker.material.emissive.setHex(C_ABOVE);
+      _marker.material.opacity = 0.85;
+      // marker rides along X proportional to final_policy_score (visual
+      // "convergence" cue — climbs toward the end of the pipeline as the
+      // policy score approaches 1.0)
+      const x = Math.min(STEP_LEN * (MAX_STEPS - 1), (S.policyScore || 0) * STEP_LEN * (MAX_STEPS - 1));
+      _marker.position.set(x, -0.6, 0);
+    } 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.00009) * 0.12;
+  if (_marker) {
+    _marker.rotation.y += 0.025;
+    _marker.rotation.x += 0.012;
+    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 =
+    'GRPO samples a <b>group</b> of completions per step and normalizes each reward against ' +
+    'the group\'s own mean/std \u2014 <b>no critic network</b> needed. The policy is updated via a ' +
+    'PPO-clip surrogate (\u03b5=0.2) on that group-relative advantage, plus a KL penalty vs a fixed ' +
+    'reference policy. Honesty label <b>MODELED</b> (deterministic group-advantage + PPO-clip + KL ' +
+    'arithmetic; NOT a trained policy). 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 = "GRPO reward dynamics";
+  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("gr-groupsize", "group_size (G samples/step)"));
+  grid.appendChild(kpiRow("gr-steps",     "steps simulated"));
+  grid.appendChild(kpiRow("gr-klbeta",    "kl_beta (KL-penalty coeff.)"));
+  grid.appendChild(kpiRow("gr-clipeps",   "clip_eps (PPO-clip \u03b5)"));
+  grid.appendChild(kpiRow("gr-reward",    "mean_reward \u2014 MODELED"));
+  grid.appendChild(kpiRow("gr-adv",       "mean_advantage \u2014 MODELED"));
+  grid.appendChild(kpiRow("gr-kl",        "kl_divergence (k3) \u2014 MODELED"));
+  grid.appendChild(kpiRow("gr-clipfrac",  "clip_fraction \u2014 MODELED"));
+  grid.appendChild(kpiRow("gr-score",     "final_policy_score \u2014 MODELED"));
+  grid.appendChild(kpiRow("gr-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 = "Shao et al. (DeepSeekMath GRPO) arXiv:2402.03300 \u00b7 DeepSeek-R1 arXiv:2501.12948. 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 = "gr-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 g       = S.groupSize   != null ? String(S.groupSize) : "loading\u2026";
+  const reward  = S.meanReward  != null ? (S.meanReward * 100).toFixed(1) + "%" : "loading\u2026";
+  const score   = S.policyScore != null ? (S.policyScore * 100).toFixed(1) + "%" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Instead of training a second, separate \u201ccritic\u201d network to judge how " +
+    "good an answer is (as classic PPO does), GRPO just generates <b>" + g + " candidate answers</b> to the " +
+    "same question and compares them <i>to each other</i> \u2014 the group's own average becomes the yardstick. " +
+    "Answers better than the group average get reinforced; worse ones get discouraged. A safety clip keeps " +
+    "any single update from swinging too far, and a KL \u201cleash\u201d keeps the model from drifting too far " +
+    "from where it started. Over simulated training, the average reward per group reaches about <b>" + reward + "</b> " +
+    "and a convergence proxy (<b>policy_score</b>) climbs to about <b>" + score + "</b>. This view is a <b>MODELED</b> " +
+    "closed-form simulation of the group-advantage/PPO-clip/KL arithmetic from the DeepSeekMath paper, not a run of " +
+    "DeepSeek-R1 or DeepSeekMath training.";
+}
+
+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("gr-groupsize", t || (S.groupSize != null ? String(S.groupSize) : "\u2014"));
+  _set("gr-steps",     t || (S.steps     != null ? String(S.steps)     : "\u2014"));
+  _set("gr-klbeta",    t || fx(S.klBeta, 4));
+  _set("gr-clipeps",   t || fx(S.clipEps, 2));
+  _set("gr-reward",    t || fx(S.meanReward, 4));
+  _set("gr-adv",       t || fx(S.meanAdv, 4));
+  _set("gr-kl",        t || fx(S.klDiv, 6));
+  _set("gr-clipfrac",  t || pct(S.clipFrac, 2));
+  _set("gr-score",     t || pct(S.policyScore, 2));
+  // honesty label verbatim — never upgraded
+  _set("gr-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; _plane = null; _spine = null; _sampleMesh = []; _tethers = []; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.groupSize = S.steps = S.klBeta = S.clipEps = null;
+  S.meanReward = S.meanAdv = S.klDiv = S.clipFrac = S.policyScore = null;
+  S.rewardTraj = S.klTraj = S.scoreTraj = S.advTraj = S.clipTraj = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/kvcache.js

@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/kvcache.js — KV-CACHE H2O EVICTION organ for the holographic frontier
+// ring (Heavy-Hitter Oracle runtime cache eviction, Zhang et al. 2023-style).
+// Renders a simulated decoding stream of `seq_len` tokens as a 3D token row:
+// kept heavy-hitters glow proof-teal, the recent sliding window glows
+// lattice-blue, and evicted tokens fade to grey and drop out of the row. A HUD
+// shows memory_ratio + mass_retained per policy (H2O / sliding-window / full-
+// cache oracle) from the live snapshot at
+// /api/killinchu/v1/kvcache/h2o-evict. 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 exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   seq_len, capacity, window, memory_ratio, h2o_mass_retained,
+//   sliding_mass_retained, full_mass_retained, h2o_vs_sliding_gain,
+//   evicted_count, per_token[] {i, mass, h2o_kept, sliding_kept}
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   H2O — Heavy-Hitter Oracle KV-cache eviction (policy simulated here):
+//     Zhang et al. 2023, arXiv:2306.14048
+//     https://arxiv.org/abs/2306.14048
+//   StreamingLLM (recency-window / attention-sink baseline — reference only):
+//     Xiao et al. 2023, arXiv:2309.17453
+//     https://arxiv.org/abs/2309.17453
+//
+// HONESTY LABELS: MODELED (deterministic simulation of the H2O heavy-hitter
+//   eviction policy on a synthetic attention-mass trace; NOT a real KV cache
+//   or trained model; NEVER-CLAIMED-AS a production inference engine). Read
+//   verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (recent sliding window), proof-teal 0x3af4c8
+//   (kept heavy hitters / HUD accent), greys (evicted tokens / 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    = "kvcache";
+const TITLE = "KV-Cache H2O Eviction · Heavy-Hitter Oracle (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 KV-cache eviction organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/kvcache/h2o-evict?seed=42&seq_len=512&capacity=128&window=32";
+
+// data-viz hues — purple BANNED
+const C_WINDOW   = 0x5b8dee;  // lattice-blue (recent sliding-window tokens)
+const C_HEAVY    = 0x3af4c8;  // proof-teal (kept heavy hitters / HUD accent)
+const C_EVICTED  = 0x5a6570;  // grey (evicted token)
+const C_DIM      = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID     = 0x1b3a44;  // floor / link colour
+
+// token-row layout geometry
+const TOKEN_GAP  = 0.42;   // world-units between tokens along X (decoding axis)
+const MAX_TOKENS = 160;    // cap on tokens rendered in the row (perf)
+const ROW_Y      = 0.4;    // resting height of a kept token
+const EVICT_Y    = -1.6;   // dropped height of an evicted token
+
+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 — decoding-stream spine
+let _tokenMesh  = [];                 // Array<THREE.Mesh> — one per rendered token slot
+let _marker     = null;               // THREE.Mesh — HUD pulsing marker (memory_ratio cue)
+
+// live state
+const S = {
+  label:               null,
+  seqLen:              null,   // seq_len
+  capacity:            null,   // capacity
+  window:              null,   // window
+  memoryRatio:         null,   // memory_ratio
+  h2oMassRetained:     null,   // h2o_mass_retained
+  slidingMassRetained: null,   // sliding_mass_retained
+  fullMassRetained:    null,   // full_mass_retained
+  h2oVsSlidingGain:    null,   // h2o_vs_sliding_gain
+  evictedCount:        null,   // evicted_count
+  perToken:            null,   // per_token[]
+  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, 7, 18);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(6, 2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildTokenRow();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onKvcache, { 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 row of token meshes: MAX_TOKENS slots. We toggle
+// visibility / color / position in-place as live data arrives (no per-poll
+// geometry churn).
+function _buildTokenRow() {
+  const THREE = _THREE;
+
+  // decoding-stream spine: a straight line along X marking the token order
+  {
+    const pts = [new THREE.Vector3(0, 0, 0), new THREE.Vector3(TOKEN_GAP * (MAX_TOKENS - 1) + 1, 0, 0)];
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_WINDOW, transparent: true, opacity: 0.4 });
+    _spine = new THREE.Line(geo, mat);
+    _group.add(_spine);
+  }
+
+  const tokenGeo = new THREE.OctahedronGeometry(0.16, 0);
+  for (let t = 0; t < MAX_TOKENS; t++) {
+    const x = t * TOKEN_GAP;
+    const mesh = new THREE.Mesh(
+      tokenGeo,
+      new THREE.MeshStandardMaterial({ color: C_EVICTED, emissive: C_EVICTED, emissiveIntensity: 0.2, transparent: true, opacity: 0.0 }),
+    );
+    mesh.position.set(x, ROW_Y, 0);
+    mesh.visible = false;
+    _group.add(mesh);
+    _tokenMesh.push(mesh);
+  }
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.26, 1),
+    new THREE.MeshStandardMaterial({ color: C_HEAVY, emissive: C_HEAVY, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, -0.9, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onKvcache(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.capacity            = typeof j.capacity              === "number" ? j.capacity              : null;
+  S.window              = typeof j.window                === "number" ? j.window                : null;
+  S.memoryRatio         = typeof j.memory_ratio          === "number" ? j.memory_ratio          : null;
+  S.h2oMassRetained     = typeof j.h2o_mass_retained     === "number" ? j.h2o_mass_retained     : null;
+  S.slidingMassRetained = typeof j.sliding_mass_retained === "number" ? j.sliding_mass_retained : null;
+  S.fullMassRetained    = typeof j.full_mass_retained    === "number" ? j.full_mass_retained    : null;
+  S.h2oVsSlidingGain    = typeof j.h2o_vs_sliding_gain   === "number" ? j.h2o_vs_sliding_gain   : null;
+  S.evictedCount        = typeof j.evicted_count         === "number" ? j.evicted_count         : null;
+  S.perToken            = Array.isArray(j.per_token) ? j.per_token : null;
+
+  _updateTokenRow();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the token row from live data
+// =============================================================================
+function _updateTokenRow() {
+  const live = S.state === "live";
+  const toks = live && S.perToken && S.perToken.length ? S.perToken.slice(0, MAX_TOKENS) : [];
+
+  for (let t = 0; t < MAX_TOKENS; t++) {
+    const mesh = _tokenMesh[t];
+    if (!live || t >= toks.length) {
+      mesh.visible = false;
+      continue;
+    }
+    mesh.visible = true;
+    const rec = toks[t];
+    const kept = !!rec.h2o_kept;
+    const inWindow = kept && !!rec.sliding_kept; // recent tokens are kept by BOTH policies
+    let color;
+    if (!kept) {
+      color = C_EVICTED;                          // evicted under H2O -> grey, dropped
+    } else if (inWindow) {
+      color = C_WINDOW;                            // recent-window heavy hitter -> lattice-blue
+    } else {
+      color = C_HEAVY;                             // pure heavy hitter (older) -> proof-teal
+    }
+    mesh.material.color.setHex(color);
+    mesh.material.emissive.setHex(color);
+    mesh.material.emissiveIntensity = kept ? (inWindow ? 0.45 : 0.6) : 0.12;
+    mesh.material.opacity = kept ? 0.95 : 0.30;
+    // evicted tokens visually drop out of the row (H2O eviction cue); mass
+    // scales the resting height slightly for kept heavy hitters (taller = heavier).
+    const massScale = typeof rec.mass === "number" ? Math.min(1.0, rec.mass * 2.0) : 0.0;
+    mesh.position.y = kept ? ROW_Y + massScale * 0.5 : EVICT_Y;
+    mesh.position.z = kept ? 0 : -0.4;
+  }
+
+  // spine degrades to grey when not live
+  _spine.material.color.setHex(live ? C_WINDOW : C_DIM);
+  _spine.material.opacity = live ? 0.4 : 0.15;
+
+  if (_marker) {
+    if (live && S.memoryRatio != null) {
+      _marker.material.color.setHex(C_HEAVY);
+      _marker.material.emissive.setHex(C_HEAVY);
+      _marker.material.opacity = 0.85;
+      // marker rides along X proportional to memory_ratio (visual "budget" cue)
+      const x = Math.min(TOKEN_GAP * (MAX_TOKENS - 1), (S.memoryRatio || 0) * TOKEN_GAP * (MAX_TOKENS - 1));
+      _marker.position.set(x, -0.9, 0);
+    } 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.00009) * 0.12;
+  if (_marker) {
+    _marker.rotation.y += 0.025;
+    _marker.rotation.x += 0.012;
+    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 =
+    'A decoding stream accumulates a KV cache entry per token. <b>H2O</b> (Heavy-Hitter Oracle) ' +
+    'keeps a bounded cache by retaining the top cumulative-attention-mass \u201cheavy hitters\u201d ' +
+    'plus a sliding recent <b>window</b>, instead of evicting purely by recency. HUD compares ' +
+    'H2O against a sliding-window-only baseline and the full-cache (no eviction) oracle. ' +
+    'Honesty label <b>MODELED</b> (deterministic simulation on a synthetic attention trace; NOT a ' +
+    'real KV cache or trained model). 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 = "kv-cache h2o eviction";
+  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("kv-seqlen",   "seq_len (decoded tokens)"));
+  grid.appendChild(kpiRow("kv-capacity", "capacity (KV-cache slots)"));
+  grid.appendChild(kpiRow("kv-window",   "window (recent tokens reserved)"));
+  grid.appendChild(kpiRow("kv-memratio", "memory_ratio (capacity/seq_len)"));
+  grid.appendChild(kpiRow("kv-h2o",      "H2O mass_retained \u2014 MODELED"));
+  grid.appendChild(kpiRow("kv-sliding",  "sliding-window mass_retained"));
+  grid.appendChild(kpiRow("kv-full",     "full-cache mass_retained (oracle)"));
+  grid.appendChild(kpiRow("kv-gain",     "H2O vs sliding gain"));
+  grid.appendChild(kpiRow("kv-evicted",  "evicted_count"));
+  grid.appendChild(kpiRow("kv-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 = "H2O \u2014 Zhang et al. arXiv:2306.14048 \u00b7 StreamingLLM \u2014 Xiao et al. arXiv:2309.17453. 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 = "kv-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 mem     = S.memoryRatio         != null ? (S.memoryRatio * 100).toFixed(1) + "%" : "loading\u2026";
+  const h2oPct  = S.h2oMassRetained     != null ? (S.h2oMassRetained * 100).toFixed(1) + "%" : "loading\u2026";
+  const slidPct = S.slidingMassRetained != null ? (S.slidingMassRetained * 100).toFixed(1) + "%" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> A language model keeps a running \u201cnotebook\u201d (the KV cache) of " +
+    "every word it has generated so it can pay attention back to earlier words. That notebook grows " +
+    "forever unless something is thrown away. Here the notebook is capped at just <b>" + mem + "</b> " +
+    "of its full size. Throwing away only the OLDEST pages (sliding-window) keeps just <b>" + slidPct +
+    "</b> of the important information. The <b>H2O</b> approach instead keeps whichever pages turned " +
+    "out to matter most so far (the \u201cheavy hitters\u201d), plus the most recent few \u2014 and keeps " +
+    "<b>" + h2oPct + "</b> of the important information at the SAME notebook size. This view is a " +
+    "<b>MODELED</b> deterministic simulation of that keep/discard rule on a synthetic attention trace, " +
+    "not a run of a real trained model or KV cache.";
+}
+
+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("kv-seqlen",   t || (S.seqLen   != null ? String(S.seqLen)   : "\u2014"));
+  _set("kv-capacity", t || (S.capacity != null ? String(S.capacity) : "\u2014"));
+  _set("kv-window",   t || (S.window   != null ? String(S.window)   : "\u2014"));
+  _set("kv-memratio", t || pct(S.memoryRatio, 2));
+  _set("kv-h2o",      t || pct(S.h2oMassRetained, 2));
+  _set("kv-sliding",  t || pct(S.slidingMassRetained, 2));
+  _set("kv-full",     t || pct(S.fullMassRetained, 2));
+  _set("kv-gain",     t || (S.h2oVsSlidingGain != null ? "+" + pct(S.h2oVsSlidingGain, 2) : "\u2014"));
+  _set("kv-evicted",  t || (S.evictedCount != null ? String(S.evictedCount) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("kv-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; _tokenMesh = []; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.seqLen = S.capacity = S.window = S.memoryRatio = null;
+  S.h2oMassRetained = S.slidingMassRetained = S.fullMassRetained = null;
+  S.h2oVsSlidingGain = S.evictedCount = S.perToken = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/mla.js

@@ -0,0 +1,433 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/mla.js — MULTI-HEAD LATENT ATTENTION (MLA) low-rank joint KV-compression
+// organ for the holographic frontier ring (DeepSeek-V2/V3-style). Renders the full,
+// uncompressed KV cache as a TALL lattice-blue column and the compressed shared
+// latent as a SHORT proof-teal column beside it — the height ratio between the two
+// columns visualizes `compression_ratio` directly. A faint grey ghost column shows
+// the up-projected RECONSTRUCTION overlaid on the full-KV column (its height/opacity
+// wobble encodes `reconstruction_error`). A HUD shows compression_ratio +
+// reconstruction_error read live from /api/killinchu/v1/mla/latent-compress. Honesty
+// label "MODELED" is read VERBATIM from the JSON and displayed as-is; it is never
+// upgraded.
+//
+// Surface export shape (mirrors ringattn.js / specdecode.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):
+//   seq_len, n_heads, d_head, d_latent, mha_cache_size, mla_cache_size,
+//   compression_ratio, reconstruction_error
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   DeepSeek-V2 (introduces Multi-Head Latent Attention / low-rank KV joint
+//   compression):
+//     DeepSeek-AI et al. 2024, arXiv:2405.04434
+//     https://arxiv.org/abs/2405.04434
+//   DeepSeek-V3 (adopts and validates MLA at larger scale):
+//     DeepSeek-AI et al. 2024, arXiv:2412.19437
+//     https://arxiv.org/abs/2412.19437
+//
+// HONESTY LABELS: MODELED (deterministic low-rank down/up-projection simulation of
+//   the MLA KV-compression idea; NOT trained weights; NEVER-CLAIMED-AS DeepSeek-V2
+//   or DeepSeek-V3). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (full/uncompressed KV column), proof-teal 0x3af4c8
+//   (compressed latent column / HUD accent), greys (reconstruction ghost / 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    = "mla";
+const TITLE = "Multi-Head Latent Attention · KV-Compression 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 MLA organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/mla/latent-compress?seed=42&seq_len=128&n_heads=8&d_head=64&d_latent=128";
+
+// data-viz hues — purple BANNED
+const C_FULL   = 0x5b8dee;  // lattice-blue (full/uncompressed KV column)
+const C_LATENT = 0x3af4c8;  // proof-teal (compressed latent column / HUD accent)
+const C_GHOST  = 0x8a9099;  // grey (reconstruction ghost overlay)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+// column layout geometry
+const COL_HALF_W   = 0.55;  // column half-width/depth (box footprint)
+const COL_GAP      = 2.4;   // world-units between the full-KV and latent columns
+const MAX_FULL_H   = 8.0;   // world-units — height of the full-KV column at scale=1
+const MIN_LATENT_H = 0.15;  // world-units — floor height so the latent column never vanishes
+
+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 _fullCol     = null;    // THREE.Mesh — full/uncompressed KV column (lattice-blue)
+let _latentCol   = null;    // THREE.Mesh — compressed latent column (proof-teal)
+let _ghostCol    = null;    // THREE.Mesh — reconstruction ghost, overlaid on the full column
+let _linkLine    = null;    // THREE.Line — connecting line between the two columns
+let _fullTargetH   = 0.4;
+let _latentTargetH = 0.4;
+let _ghostTargetH  = 0.4;
+
+// live state
+const S = {
+  label:        null,
+  seqLen:       null,   // seq_len
+  nHeads:       null,   // n_heads
+  dHead:        null,   // d_head
+  dLatent:      null,   // d_latent
+  mhaCache:     null,   // mha_cache_size
+  mlaCache:     null,   // mla_cache_size
+  ratio:        null,   // compression_ratio
+  reconErr:     null,   // reconstruction_error
+  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, 6, 14);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(1, 2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildColumns();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onMla, { 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;
+}
+
+// Two box columns side-by-side: full/uncompressed KV (tall, lattice-blue) and
+// compressed latent (short, proof-teal), plus a faint grey ghost box overlaid
+// on the full-KV column showing the up-projected reconstruction. We scale
+// each column's Y-scale in-place (no per-poll geometry churn) with its base
+// centered at y=0 via geometry translation, so scaling grows it upward.
+function _buildColumns() {
+  const THREE = _THREE;
+
+  const boxGeo = new THREE.BoxGeometry(COL_HALF_W * 2, 1, COL_HALF_W * 2);
+  boxGeo.translate(0, 0.5, 0); // base sits at y=0; scaling Y grows upward
+
+  _fullCol = new THREE.Mesh(
+    boxGeo,
+    new THREE.MeshStandardMaterial({ color: C_FULL, emissive: C_FULL, emissiveIntensity: 0.28, transparent: true, opacity: 0.85 }),
+  );
+  _fullCol.position.set(-COL_GAP / 2, 0, 0);
+  _fullCol.scale.set(1, MIN_LATENT_H, 1);
+  _group.add(_fullCol);
+
+  // ghost reconstruction: same footprint as the full column, slightly larger
+  // to read as an "aura", faint grey wireframe-ish translucency.
+  const ghostGeo = new THREE.BoxGeometry(COL_HALF_W * 2.22, 1, COL_HALF_W * 2.22);
+  ghostGeo.translate(0, 0.5, 0);
+  _ghostCol = new THREE.Mesh(
+    ghostGeo,
+    new THREE.MeshStandardMaterial({ color: C_GHOST, emissive: C_GHOST, emissiveIntensity: 0.12, transparent: true, opacity: 0.22, wireframe: true }),
+  );
+  _ghostCol.position.set(-COL_GAP / 2, 0, 0);
+  _ghostCol.scale.set(1, MIN_LATENT_H, 1);
+  _group.add(_ghostCol);
+
+  _latentCol = new THREE.Mesh(
+    boxGeo,
+    new THREE.MeshStandardMaterial({ color: C_LATENT, emissive: C_LATENT, emissiveIntensity: 0.4, transparent: true, opacity: 0.92 }),
+  );
+  _latentCol.position.set(COL_GAP / 2, 0, 0);
+  _latentCol.scale.set(1, MIN_LATENT_H, 1);
+  _group.add(_latentCol);
+
+  // connecting line from the top of the full column down to the top of the
+  // latent column — a visual "compression funnel" cue.
+  const linkGeo = new THREE.BufferGeometry().setFromPoints([
+    new THREE.Vector3(-COL_GAP / 2, MIN_LATENT_H, 0),
+    new THREE.Vector3(COL_GAP / 2, MIN_LATENT_H, 0),
+  ]);
+  const linkMat = new THREE.LineBasicMaterial({ color: C_GRID, transparent: true, opacity: 0.35 });
+  _linkLine = new THREE.Line(linkGeo, linkMat);
+  _group.add(_linkLine);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onMla(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.nHeads   = typeof j.n_heads              === "number" ? j.n_heads              : null;
+  S.dHead    = typeof j.d_head               === "number" ? j.d_head               : null;
+  S.dLatent  = typeof j.d_latent             === "number" ? j.d_latent             : null;
+  S.mhaCache = typeof j.mha_cache_size       === "number" ? j.mha_cache_size       : null;
+  S.mlaCache = typeof j.mla_cache_size       === "number" ? j.mla_cache_size       : null;
+  S.ratio    = typeof j.compression_ratio    === "number" ? j.compression_ratio    : null;
+  S.reconErr = typeof j.reconstruction_error === "number" ? j.reconstruction_error : null;
+
+  _updateColumns();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the two columns + ghost from live data
+// =============================================================================
+function _updateColumns() {
+  const live = S.state === "live";
+
+  // Full-KV column height is fixed at MAX_FULL_H when live (it's the
+  // reference/baseline). Latent column height is MAX_FULL_H / compression_ratio
+  // — directly visualizing how much smaller the compressed cache is.
+  _fullTargetH = live ? MAX_FULL_H : MIN_LATENT_H;
+  _latentTargetH = live && S.ratio ? Math.max(MIN_LATENT_H, MAX_FULL_H / S.ratio) : MIN_LATENT_H;
+  // Ghost height wobbles around the full column's height, offset by a
+  // normalized reconstruction-error term so a larger error reads as a more
+  // visibly mismatched (taller/shorter) ghost silhouette.
+  const errNorm = live && S.reconErr != null ? Math.min(1.0, S.reconErr / 40.0) : 0;
+  _ghostTargetH = live ? MAX_FULL_H * (1.0 + 0.18 * errNorm) : MIN_LATENT_H;
+
+  const fullColor = live ? C_FULL : C_DIM;
+  _fullCol.material.color.setHex(fullColor);
+  _fullCol.material.emissive.setHex(fullColor);
+  _fullCol.material.opacity = live ? 0.85 : 0.2;
+
+  const latentColor = live ? C_LATENT : C_DIM;
+  _latentCol.material.color.setHex(latentColor);
+  _latentCol.material.emissive.setHex(latentColor);
+  _latentCol.material.opacity = live ? 0.92 : 0.2;
+
+  _ghostCol.material.opacity = live ? Math.min(0.4, 0.15 + 0.5 * errNorm) : 0.06;
+
+  if (_linkLine) {
+    _linkLine.material.color.setHex(live ? C_GRID : C_DIM);
+    _linkLine.material.opacity = live ? 0.35 : 0.1;
+  }
+}
+
+// =============================================================================
+// per-frame animation — smooth column height easing + gentle rotation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00007) * 0.10;
+
+  const ease = 0.08;
+  if (_fullCol) {
+    _fullCol.scale.y += (_fullTargetH - _fullCol.scale.y) * ease;
+  }
+  if (_latentCol) {
+    _latentCol.scale.y += (_latentTargetH - _latentCol.scale.y) * ease;
+    // gentle pulse on the compressed column to draw the eye to the "win"
+    const pulse = 1.0 + 0.03 * Math.sin(t * 0.005);
+    _latentCol.scale.x = pulse; _latentCol.scale.z = pulse;
+  }
+  if (_ghostCol) {
+    _ghostCol.scale.y += (_ghostTargetH - _ghostCol.scale.y) * ease;
+  }
+  if (_linkLine && _fullCol && _latentCol) {
+    const pts = [
+      new _THREE.Vector3(-COL_GAP / 2, _fullCol.scale.y, 0),
+      new _THREE.Vector3(COL_GAP / 2, _latentCol.scale.y, 0),
+    ];
+    _linkLine.geometry.setFromPoints(pts);
+  }
+}
+
+// =============================================================================
+// 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 =
+    'Per-token Key/Value vectors across all heads are jointly <b>down-projected</b> to a ' +
+    'shared low-rank <b>latent</b> vector (only this gets cached), then <b>up-projected</b> ' +
+    'back on demand. The tall <b>lattice-blue</b> column is the full/uncompressed KV cache; ' +
+    'the short <b>proof-teal</b> column is the compressed latent cache; the faint grey ghost ' +
+    'shows the reconstruction. Honesty label <b>MODELED</b> (deterministic low-rank ' +
+    'down/up-projection simulation; NOT trained DeepSeek weights). 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 = "multi-head latent 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("mla-seqlen",  "seq_len (positions)"));
+  grid.appendChild(kpiRow("mla-heads",   "n_heads \u00d7 d_head"));
+  grid.appendChild(kpiRow("mla-dlatent", "d_latent (compressed width)"));
+  grid.appendChild(kpiRow("mla-mhacache","mha_cache_size (elements)"));
+  grid.appendChild(kpiRow("mla-mlacache","mla_cache_size (elements)"));
+  grid.appendChild(kpiRow("mla-ratio",   "compression_ratio \u2014 MODELED"));
+  grid.appendChild(kpiRow("mla-err",     "reconstruction_error (mean L2)"));
+  grid.appendChild(kpiRow("mla-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 = "DeepSeek-V2 arXiv:2405.04434 (introduces MLA) \u00b7 DeepSeek-V3 arXiv:2412.19437 (adopts MLA). 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 = "mla-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 ratio = S.ratio    != null ? S.ratio.toFixed(2) + "\u00d7" : "loading\u2026";
+  const err   = S.reconErr != null ? S.reconErr.toFixed(3) : "loading\u2026";
+  const dl    = S.dLatent  != null ? String(S.dLatent) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Normally, a model must remember a separate \u201ckey\u201d and " +
+    "\u201cvalue\u201d vector for every attention head, for every word it has generated so far " +
+    "\u2014 this memory (the KV cache) grows huge for long conversations. <b>Multi-Head Latent " +
+    "Attention</b> instead squeezes all of a word's keys/values into ONE small shared " +
+    "summary vector (width <b>" + dl + "</b>) before caching it, then unpacks that summary " +
+    "back out when needed. Here, that squeeze-then-unpack trick shrinks the cache by " +
+    "<b>" + ratio + "</b> \u2014 at the cost of a small, measurable reconstruction mismatch " +
+    "(<b>" + err + "</b> average error) since a random squeeze loses some detail. In real " +
+    "DeepSeek-V2/V3 models, that squeeze is <i>trained</i> to keep the mismatch tiny; this " +
+    "view uses an untrained, deterministic squeeze to demonstrate the compression math " +
+    "honestly \u2014 it is a <b>MODELED</b> simulation, not a run of DeepSeek's actual 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("mla-seqlen",   t || (S.seqLen != null ? S.seqLen.toLocaleString() : "\u2014"));
+  _set("mla-heads",    t || (S.nHeads != null && S.dHead != null ? (S.nHeads + " \u00d7 " + S.dHead) : "\u2014"));
+  _set("mla-dlatent",  t || (S.dLatent != null ? String(S.dLatent) : "\u2014"));
+  _set("mla-mhacache", t || (S.mhaCache != null ? S.mhaCache.toLocaleString() : "\u2014"));
+  _set("mla-mlacache", t || (S.mlaCache != null ? S.mlaCache.toLocaleString() : "\u2014"));
+  _set("mla-ratio",    t || (S.ratio != null ? S.ratio.toFixed(3) + "\u00d7" : "\u2014"));
+  _set("mla-err",      t || fx(S.reconErr, 4));
+  // honesty label verbatim — never upgraded
+  _set("mla-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; _fullCol = null; _latentCol = null; _ghostCol = null; _linkLine = null;
+  _fullTargetH = 0.4; _latentTargetH = 0.4; _ghostTargetH = 0.4;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.seqLen = S.nHeads = S.dHead = S.dLatent = null;
+  S.mhaCache = S.mlaCache = S.ratio = S.reconErr = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };