feat(frontier): test-time-compute + SSM + Genie surfaces + tabs (organs on killinchu)

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

static/3d/holographic.html

@@ -74,6 +74,9 @@ const SURFACES = [
   { id: "worldmodel", title: "World Model", mod: "/static/3d/surfaces/worldmodel.js" },
   { id: "qec", title: "Topological QEC", mod: "/static/3d/surfaces/qec.js" },
   { id: "episodic", title: "Episodic Memory", mod: "/static/3d/surfaces/episodic.js" },
+  { id: "testtime", title: "Test-Time Compute", mod: "/static/3d/surfaces/testtime.js" },
+  { id: "ssm", title: "State-Space (Mamba-3)", mod: "/static/3d/surfaces/ssm.js" },
+  { id: "genie", title: "Genie World-Model", mod: "/static/3d/surfaces/genie.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/genie.js

@@ -0,0 +1,453 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/genie.js — GENERATIVE / INTERACTIVE LATENT-ACTION WORLD-MODEL organ for the
+// holographic frontier ring, inspired by (clean-room, not a reproduction of) Google
+// DeepMind's Genie / Genie 2 / Genie 3 generative interactive world models.
+//
+// DISTINCT FROM worldmodel.js: that surface renders a PREDICTOR's latent trajectory —
+// two static-ish paths (observed vs predicted) with a "surprise" gap between them. THIS
+// surface instead renders a GENERATED, EVOLVING NxN GRID-WORLD — a lattice of cells that
+// visibly changes shape/colour every time a new latent action code is applied, i.e. a
+// *playable* rollout being generated frame-by-frame, not a predicted path being scored.
+// There is no "observed vs predicted" comparison here at all — only forward generation.
+//
+// Renders the live /api/killinchu/v1/genie/rollout snapshot as an NxN plane of cubes
+// (the generated grid-world state) that steps forward through the rollout's
+// generated_states[] on a timer, each step driven by the next latent action_code in the
+// sequence. A HUD shows the action-code sequence + coherence score. Honesty label
+// "MODELED" is read VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors interpretability.js / worldmodel.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   grid_size, n_latent_actions, rollout_horizon   — rollout shape
+//   action_codes[]                                  — the latent-action-code sequence applied
+//   latent_action_codebook[]                        — clustered latent-action centroids (dx,dy,dstate)
+//   generated_states[]                              — per-step {mean, active_cells, delta_from_prev}
+//   coherence_score                                 — MODELED world-consistency analogue
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Genie (v1): Bruce, Segar, Mnih et al. (2024) arXiv:2402.15391
+//     https://arxiv.org/abs/2402.15391
+//   Genie 2 (Google DeepMind blog):
+//     https://deepmind.google/discover/blog/genie-2-a-large-scale-foundation-world-model/
+//   Genie 3 (Google DeepMind blog):
+//     https://deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/
+//
+// HONESTY LABELS: MODELED (a toy simulation of the Genie COMPUTATION SHAPE; no video
+//   tokenizer, no trained dynamics model, no learned latent-action model, no borrowed
+//   weights). Read verbatim from JSON; never upgraded here. SZL does not claim parity
+//   with any real Genie model.
+// COLOURS: lattice-blue 0x5b8dee (generated cell — low activation), violet-blue 0x8a6bff
+//   (generated cell — high activation / most-recently-changed flash — data-viz only),
+//   proof-teal 0x3af4c8 (coherence halo), greys for degraded/no-data. Purple BANNED.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+
+const ID    = "genie";
+const TITLE = "Genie · Generative Latent-Action World (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 genie organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/genie/rollout?seed=42&grid=8&horizon=16&n_latent_actions=6";
+
+// data-viz hues — purple BANNED
+const C_LO     = 0x5b8dee;  // lattice-blue (generated cell, low activation)
+const C_HI     = 0x8a6bff;  // violet-blue (generated cell, high activation / just-changed flash)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_ACCENT = 0x3af4c8;  // proof-teal accent (coherence halo)
+const C_GRID   = 0x1b3a44;  // floor / wire colour
+
+const MAX_GRID = 16;   // visual cap on grid_size (endpoint clamps grid<=64; we tile at most 16x16 cells for perf)
+const CELL     = 0.62; // world-unit spacing between generated cells
+const STEP_MS  = 650;  // ms between generated-rollout steps (one latent action applied per tick)
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _cells = [];       // Array<THREE.Mesh> — one per generated grid cell (row-major)
+let _halo = null;      // THREE.Mesh — coherence halo above the grid
+let _floor = null;
+
+// rollout playback state (steps through generated_states[] to visibly "play" the world)
+let _stepTimer = null;
+let _curStep = 0;
+
+// live state
+const S = {
+  label:        null,
+  gridSize:     null,
+  nActions:     null,
+  horizon:      null,
+  actionCodes:  null,   // Array<int>
+  codebook:     null,   // Array<{code,dx,dy,dstate}>
+  states:       null,   // Array<{step,action_code,mean,active_cells,delta_from_prev}>
+  coherence:    null,
+  state:        "init",
+};
+
+// deterministic per-cell base pattern so the grid has visible structure even before the
+// first generated step lands (re-derived client-side from grid_size only — cosmetic).
+function _basePattern(n, r, c) {
+  return 0.5 + 0.5 * Math.sin((r * 1.7 + c * 2.3));
+}
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(0, 9, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 0, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildHalo();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onRollout, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+function _buildHalo() {
+  const THREE = _THREE;
+  // Coherence halo — a torus above the grid whose fullness/brightness tracks
+  // coherence_score (higher = generated rollout stays more "on-manifold").
+  _halo = new THREE.Mesh(
+    new THREE.TorusGeometry(3.2, 0.035, 10, 64),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.35, transparent: true, opacity: 0.4 }),
+  );
+  _halo.position.set(0, 3.4, 0);
+  _halo.rotation.x = Math.PI / 2;
+  _group.add(_halo);
+}
+
+function _disposeGrid() {
+  _cells.forEach((m) => {
+    if (m.geometry && m.geometry.dispose) m.geometry.dispose();
+    if (m.material && m.material.dispose) m.material.dispose();
+    if (_group) _group.remove(m);
+  });
+  _cells = [];
+}
+
+// (re)build the NxN generated-grid-world lattice
+function _buildGrid(n) {
+  const THREE = _THREE;
+  _disposeGrid();
+  const dim = Math.min(n || 8, MAX_GRID);
+  const geo = new THREE.BoxGeometry(CELL * 0.86, 0.2, CELL * 0.86);
+  const offset = (dim - 1) / 2;
+  for (let r = 0; r < dim; r++) {
+    for (let c = 0; c < dim; c++) {
+      const v = _basePattern(dim, r, c);
+      const mat = new THREE.MeshStandardMaterial({
+        color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.12,
+        metalness: 0.2, roughness: 0.6,
+      });
+      const mesh = new THREE.Mesh(geo, mat);
+      mesh.position.set((c - offset) * CELL, 0, (r - offset) * CELL);
+      mesh.userData.baseHeight = 0.2;
+      mesh.userData.value = v;
+      _group.add(mesh);
+      _cells.push(mesh);
+    }
+  }
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onRollout(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label       = (j.label || "MODELED").toUpperCase();
+  S.gridSize    = typeof j.grid_size === "number" ? j.grid_size : null;
+  S.nActions    = typeof j.n_latent_actions === "number" ? j.n_latent_actions : null;
+  S.horizon     = typeof j.rollout_horizon === "number" ? j.rollout_horizon : null;
+  S.actionCodes = Array.isArray(j.action_codes) ? j.action_codes : null;
+  S.codebook    = Array.isArray(j.latent_action_codebook) ? j.latent_action_codebook : null;
+  S.states      = Array.isArray(j.generated_states) ? j.generated_states : null;
+  S.coherence   = typeof j.coherence_score === "number" ? j.coherence_score : null;
+
+  const dim = Math.min(S.gridSize || 8, MAX_GRID);
+  if (_cells.length !== dim * dim) _buildGrid(dim);
+
+  _curStep = 0;
+  _startPlayback();
+  _updateHalo();
+  _paintOverlay();
+}
+
+// =============================================================================
+// rollout playback — visibly EVOLVE the grid one generated step at a time,
+// driven by the corresponding latent action_code (this is what makes the organ
+// "generative/interactive" rather than a static readout)
+// =============================================================================
+function _startPlayback() {
+  if (_stepTimer) { clearInterval(_stepTimer); _stepTimer = null; }
+  if (!S.states || !S.states.length) return;
+  _applyStep(0);
+  _stepTimer = setInterval(() => {
+    _curStep = (_curStep + 1) % S.states.length;
+    _applyStep(_curStep);
+  }, STEP_MS);
+}
+
+function _applyStep(i) {
+  const live = S.state === "live";
+  const step = S.states && S.states[i];
+  const dim = Math.min(S.gridSize || 8, MAX_GRID);
+  if (!step || !_cells.length) return;
+
+  // Deterministically re-derive a per-cell activation for THIS step from the step's
+  // scalar summary (mean/delta) + each cell's base pattern + which latent action code
+  // is currently being applied — a light client-side visual analogue of the server's
+  // generated lattice (full per-cell state is not shipped over the wire to keep the
+  // payload small; the endpoint's generated_states[] gives the authoritative summary).
+  const code = step.action_code != null ? step.action_code : 0;
+  const codebookEntry = (S.codebook && S.codebook[code]) ? S.codebook[code] : { dx: 1, dy: 0, dstate: 0.5 };
+  const mean = typeof step.mean === "number" ? step.mean : 0.5;
+  const delta = typeof step.delta_from_prev === "number" ? step.delta_from_prev : 0;
+
+  _cells.forEach((mesh, idx) => {
+    const r = Math.floor(idx / dim), c = idx % dim;
+    const phase = (r * codebookEntry.dx + c * codebookEntry.dy) * 0.6 + i * 0.4;
+    const v = live ? Math.max(0, Math.min(1, mean + 0.35 * Math.sin(phase) * codebookEntry.dstate)) : mesh.userData.value;
+    mesh.userData.value = v;
+    const col = v > 0.62 ? C_HI : C_LO;
+    if (live) {
+      mesh.material.color.setHex(col);
+      mesh.material.emissive.setHex(col);
+      mesh.material.emissiveIntensity = 0.15 + 0.75 * v;
+      const h = 0.2 + v * 1.3;
+      mesh.scale.set(1, h / mesh.userData.baseHeight, 1);
+      mesh.position.y = (h - 0.2) / 2;
+    } else {
+      mesh.material.color.setHex(C_DIM);
+      mesh.material.emissive.setHex(C_DIM);
+      mesh.material.emissiveIntensity = 0.1;
+      mesh.scale.set(1, 1, 1);
+      mesh.position.y = 0;
+    }
+  });
+
+  _paintOverlay(delta);
+}
+
+// =============================================================================
+// halo updater — driven by coherence_score
+// =============================================================================
+function _updateHalo() {
+  const live = S.state === "live";
+  if (!_halo) return;
+  const coh = S.coherence != null ? S.coherence : 0.5;
+  const col = live ? C_ACCENT : C_DIM;
+  _halo.material.color.setHex(col);
+  _halo.material.emissive.setHex(col);
+  _halo.material.emissiveIntensity = live ? 0.2 + 0.6 * coh : 0.12;
+  _halo.material.opacity = live ? 0.5 : 0.2;
+  _halo.scale.setScalar(live ? (0.6 + coh) : 0.8);  // fuller halo = higher generated-world coherence
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00009) * 0.15;
+  if (_halo) _halo.rotation.z += 0.0035;
+}
+
+// =============================================================================
+// 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 small <b>latent-action codebook</b> is clustered from state deltas, then applied ' +
+    'step-by-step to <b>GENERATE</b> a brand-new grid-world \u2014 the grid you see evolving ' +
+    'below \u2014 rather than predicting a pre-recorded path. Honesty label <b>MODELED</b> ' +
+    '(a toy simulation of the Genie-style computation shape \u2014 no trained dynamics model, ' +
+    'no video tokenizer, no borrowed 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:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "genie";
+  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("gn-grid",   "grid_size \u00d7 n_latent_actions"));
+  grid.appendChild(kpiRow("gn-step",   "step (action code applied)"));
+  grid.appendChild(kpiRow("gn-seq",    "action-code sequence"));
+  grid.appendChild(kpiRow("gn-coh",    "coherence score \u2014 MODELED"));
+  grid.appendChild(kpiRow("gn-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 = "Bruce, Segar, Mnih et al. arXiv:2402.15391 (Genie) \u00b7 deepmind.google Genie 2 blog \u00b7 deepmind.google Genie 3 blog. MODELED \u00b7 not claimed-as \u00b7 not claimed at parity.";
+  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 = "gn-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 coh = S.coherence != null ? (S.coherence * 100).toFixed(1) + "%" : "loading\u2026";
+  const na  = S.nActions != null ? String(S.nActions) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Instead of just watching and predicting a pre-recorded clip, " +
+    "this organ <b>generates a brand-new interactive world</b> one step at a time \u2014 each " +
+    "step conditioned on one of <b>" + na + "</b> discrete \u201clatent actions\u201d, the same " +
+    "idea behind Google DeepMind's Genie models: learn a small action vocabulary with no " +
+    "labels, then let you \u2018play\u2019 the generated world through it. The grid evolves live " +
+    "as each action is applied, and it stays <b>" + coh + "</b> consistent with itself " +
+    "step-to-step. " +
+    "Plain: this is the shape of computation behind a playable AI-generated world \u2014 but " +
+    "this view is a <b>MODELED</b> toy simulation of the technique, not a readout from any " +
+    "trained Genie model or real video.";
+}
+
+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(latestDelta) {
+  const t = _tok(S.state);
+  _set("gn-grid",  t || ((S.gridSize != null && S.nActions != null) ? (S.gridSize + "\u00d7" + S.gridSize + "  \u00d7  " + S.nActions) : "\u2014"));
+  const stepInfo = (S.states && S.states[_curStep]) ? S.states[_curStep] : null;
+  _set("gn-step",  t || (stepInfo ? ("#" + stepInfo.step + "  code=" + stepInfo.action_code + "  \u0394=" + fx(stepInfo.delta_from_prev, 4)) : "\u2014"));
+  const seq = S.actionCodes ? S.actionCodes.slice(0, 12).join(",") + (S.actionCodes.length > 12 ? "\u2026" : "") : "\u2014";
+  _set("gn-seq",   t || seq);
+  _set("gn-coh",   t || fx(S.coherence, 4));
+  // honesty label verbatim — never upgraded
+  _set("gn-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 = [];
+  if (_stepTimer) { clearInterval(_stepTimer); _stepTimer = null; }
+  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;
+  _cells = []; _halo = null; _floor = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.gridSize = S.nActions = S.horizon = null;
+  S.actionCodes = S.codebook = S.states = S.coherence = null;
+  S.state = "init";
+  _curStep = 0;
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/ssm.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/ssm.js — STATE-SPACE-MODEL (Mamba-3 successor) sequence-mixing organ for the
+// holographic frontier ring.
+//
+// Renders a 3D ribbon/trajectory of a selective state-space scan's hidden state evolving
+// over sequence steps, driven by a live snapshot from /api/killinchu/v1/ssm/scan. Two
+// ribbons are drawn side by side: a REAL-valued state trajectory (decay-only diagonal SSM)
+// and a COMPLEX-valued state trajectory (rotation-capable, the Mamba-3 addition) — so the
+// state-tracking gap is directly visible as ribbon shape, not just a number. HUD shows
+// real vs complex task accuracy plus the O(L) vs O(L^2) compute gap (sub-quadratic win).
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is; it is never
+// upgraded.
+//
+// Surface export shape (mirrors interpretability.js / neuromorphic.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   task                      — 'copy' | 'parity' | 'induction'
+//   seq_len, state_dim        — scan dimensions
+//   real_state_accuracy       — accuracy of the REAL-valued selective-SSM state tracker
+//   complex_state_accuracy    — accuracy of the COMPLEX-valued state tracker (Mamba-3 add)
+//   compute_flops_quadratic   — MODELED Transformer O(L^2) self-attention FLOPs
+//   compute_flops_ssm         — MODELED SSM O(L) scan FLOPs
+//   throughput_ratio          — quadratic / ssm (the sub-quadratic win)
+//   sample.trajectory_real / trajectory_complex_magnitude — per-step hidden-state samples
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Mamba — Gu & Dao (2023) "Linear-Time Sequence Modeling with Selective State Spaces".
+//     arXiv:2312.00752. https://arxiv.org/abs/2312.00752
+//   Mamba-2 — Dao & Gu (2024) "Transformers are SSMs...Structured State Space Duality".
+//     arXiv:2405.21060. https://arxiv.org/abs/2405.21060
+//   state-spaces/mamba (official implementation, Apache-2.0):
+//     https://github.com/state-spaces/mamba
+//   Mamba-3 — Lahoti et al. (2026) "Mamba-3: Improved Sequence Modeling using State Space
+//     Principles". arXiv:2603.15569 (ICLR 2026). https://arxiv.org/abs/2603.15569
+//
+// HONESTY LABELS: MODELED (deterministic simulation of the RECURRENCE; no trained
+//   Mamba/Mamba-2/Mamba-3 checkpoint, no measured GPU benchmark). Read verbatim from
+//   JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (real-state ribbon), violet-blue 0x8a6bff (complex-state
+//   ribbon — data-viz only), proof-teal 0x3af4c8 (accent / plain-language). 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.
+
+const ID    = "ssm";
+const TITLE = "State-Space Model · Selective Scan (live, Mamba-3-style)";
+
+// 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 SSM organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/ssm/scan?seed=42&seq_len=32&state_dim=16&task=parity";
+
+// data-viz hues — purple BANNED
+const C_REAL    = 0x5b8dee;  // lattice-blue (real-valued state ribbon)
+const C_COMPLEX = 0x8a6bff;  // violet-blue (complex-valued state ribbon — data-viz only)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_ACCENT  = 0x3af4c8;  // proof-teal accent (compute-gap bar / plain-language)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+const MAX_STEPS = 64;   // ribbon vertex cap (matches endpoint seq_len ceiling in practice)
+const RIBBON_LEN_WORLD = 14;  // world-units the ribbon spans along its axis
+const RIBBON_SEP = 3.2;       // world-units separating the two ribbons (real vs complex)
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _realLine = null, _complexLine = null;     // THREE.Line ribbons (trajectory curves)
+let _realDots = null, _complexDots = null;     // THREE.Points per-step markers
+let _gapBar = null;                            // THREE.Mesh — O(L) vs O(L^2) compute-gap bar
+let _gapBarBg = null;
+
+// live state
+const S = {
+  label:    null,
+  task:     null,
+  seqLen:   null,
+  stateDim: null,
+  realAcc:  null,
+  complexAcc: null,
+  flopsQuad: null,
+  flopsSSM:  null,
+  throughputRatio: null,
+  trajReal: null,     // Array<Array<number>> per-step real-channel state vector
+  trajComplexMag: null, // Array<Array<number>> per-step complex-channel magnitude vector
+  state:    "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(0, 6, 19);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 1.2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildRibbons();
+  _buildGapBar();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onScan, { 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);
+}
+
+function _emptyRibbonPoints() {
+  const pts = [];
+  for (let i = 0; i < MAX_STEPS; i++) pts.push(new (_THREE.Vector3)(0, 0, 0));
+  return pts;
+}
+
+function _buildRibbons() {
+  const THREE = _THREE;
+
+  // REAL-state ribbon (lattice-blue), offset to one side
+  const realGeo = new THREE.BufferGeometry().setFromPoints(_emptyRibbonPoints());
+  _realLine = new THREE.Line(realGeo, new THREE.LineBasicMaterial({ color: C_REAL, transparent: true, opacity: 0.85, linewidth: 2 }));
+  _realLine.position.x = -RIBBON_SEP / 2;
+  _group.add(_realLine);
+
+  _realDots = new THREE.Points(realGeo, new THREE.PointsMaterial({ color: C_REAL, size: 0.12, transparent: true, opacity: 0.9 }));
+  _realDots.position.x = -RIBBON_SEP / 2;
+  _group.add(_realDots);
+
+  // COMPLEX-state ribbon (violet-blue), offset to the other side
+  const complexGeo = new THREE.BufferGeometry().setFromPoints(_emptyRibbonPoints());
+  _complexLine = new THREE.Line(complexGeo, new THREE.LineBasicMaterial({ color: C_COMPLEX, transparent: true, opacity: 0.85, linewidth: 2 }));
+  _complexLine.position.x = RIBBON_SEP / 2;
+  _group.add(_complexLine);
+
+  _complexDots = new THREE.Points(complexGeo, new THREE.PointsMaterial({ color: C_COMPLEX, size: 0.12, transparent: true, opacity: 0.9 }));
+  _complexDots.position.x = RIBBON_SEP / 2;
+  _group.add(_complexDots);
+}
+
+function _buildGapBar() {
+  const THREE = _THREE;
+  // background track (grey) + foreground bar (teal) visualizing O(L) vs O(L^2) compute gap.
+  _gapBarBg = new THREE.Mesh(
+    new THREE.BoxGeometry(8, 0.18, 0.18),
+    new THREE.MeshStandardMaterial({ color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.15, transparent: true, opacity: 0.35 }),
+  );
+  _gapBarBg.position.set(0, -0.6, 6);
+  _group.add(_gapBarBg);
+
+  _gapBar = new THREE.Mesh(
+    new THREE.BoxGeometry(0.4, 0.22, 0.22),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.4 }),
+  );
+  _gapBar.position.set(-3.8, -0.6, 6);
+  _group.add(_gapBar);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onScan(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label      = (j.label || "MODELED").toUpperCase();
+  S.task       = typeof j.task === "string" ? j.task : null;
+  S.seqLen     = typeof j.seq_len === "number" ? j.seq_len : null;
+  S.stateDim   = typeof j.state_dim === "number" ? j.state_dim : null;
+  S.realAcc    = typeof j.real_state_accuracy === "number" ? j.real_state_accuracy : null;
+  S.complexAcc = typeof j.complex_state_accuracy === "number" ? j.complex_state_accuracy : null;
+  S.flopsQuad  = typeof j.compute_flops_quadratic === "number" ? j.compute_flops_quadratic : null;
+  S.flopsSSM   = typeof j.compute_flops_ssm === "number" ? j.compute_flops_ssm : null;
+  S.throughputRatio = typeof j.throughput_ratio === "number" ? j.throughput_ratio : null;
+
+  const sample = j.sample || {};
+  S.trajReal       = Array.isArray(sample.trajectory_real) ? sample.trajectory_real : null;
+  S.trajComplexMag = Array.isArray(sample.trajectory_complex_magnitude) ? sample.trajectory_complex_magnitude : null;
+
+  _updateRibbons();
+  _updateGapBar();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives ribbon shape from the live trajectory
+// =============================================================================
+function _vecNorm(vec) {
+  // L2 norm of a per-step state vector (collapses state_dim channels to one scalar height)
+  let s = 0;
+  for (let i = 0; i < vec.length; i++) s += vec[i] * vec[i];
+  return Math.sqrt(s);
+}
+
+function _trajToPoints(traj) {
+  const THREE = _THREE;
+  const pts = [];
+  if (!traj || !traj.length) {
+    for (let i = 0; i < MAX_STEPS; i++) pts.push(new THREE.Vector3(0, 0, 0));
+    return pts;
+  }
+  const n = Math.min(traj.length, MAX_STEPS);
+  // normalize height by the max norm across the trajectory so ribbons are comparable
+  let maxNorm = 0.0001;
+  for (let i = 0; i < n; i++) maxNorm = Math.max(maxNorm, _vecNorm(traj[i]));
+  for (let i = 0; i < n; i++) {
+    const z = (i / Math.max(n - 1, 1)) * RIBBON_LEN_WORLD - RIBBON_LEN_WORLD / 2;
+    const h = (_vecNorm(traj[i]) / maxNorm) * 3.0;  // scaled hidden-state magnitude -> height
+    // slight lateral wobble from the first channel's raw value, for visual richness
+    const lateral = traj[i][0] !== undefined ? Math.max(-1, Math.min(1, traj[i][0])) * 0.5 : 0;
+    pts.push(new THREE.Vector3(lateral, h, z));
+  }
+  // pad remaining slots by repeating the last point (keeps buffer size constant)
+  const last = pts[pts.length - 1] || new THREE.Vector3(0, 0, 0);
+  while (pts.length < MAX_STEPS) pts.push(last.clone());
+  return pts;
+}
+
+function _updateRibbons() {
+  const live = S.state === "live";
+  const THREE = _THREE;
+
+  const realPts = live ? _trajToPoints(S.trajReal) : _emptyRibbonPoints();
+  const complexPts = live ? _trajToPoints(S.trajComplexMag) : _emptyRibbonPoints();
+
+  if (_realLine) {
+    _realLine.geometry.setFromPoints(realPts);
+    _realLine.geometry.computeBoundingSphere();
+    const col = live ? C_REAL : C_DIM;
+    _realLine.material.color.setHex(col);
+    _realLine.material.opacity = live ? 0.85 : 0.25;
+  }
+  if (_realDots) {
+    _realDots.geometry.setFromPoints(realPts);
+    const col = live ? C_REAL : C_DIM;
+    _realDots.material.color.setHex(col);
+    _realDots.material.opacity = live ? 0.9 : 0.2;
+  }
+  if (_complexLine) {
+    _complexLine.geometry.setFromPoints(complexPts);
+    _complexLine.geometry.computeBoundingSphere();
+    const col = live ? C_COMPLEX : C_DIM;
+    _complexLine.material.color.setHex(col);
+    _complexLine.material.opacity = live ? 0.85 : 0.25;
+  }
+  if (_complexDots) {
+    _complexDots.geometry.setFromPoints(complexPts);
+    const col = live ? C_COMPLEX : C_DIM;
+    _complexDots.material.color.setHex(col);
+    _complexDots.material.opacity = live ? 0.9 : 0.2;
+  }
+}
+
+function _updateGapBar() {
+  if (!_gapBar) return;
+  const live = S.state === "live";
+  // bar length encodes log10(throughput_ratio) clamped to a reasonable visual range
+  const ratio = (live && S.throughputRatio) ? S.throughputRatio : 1;
+  const logRatio = Math.max(0, Math.min(4, Math.log10(Math.max(ratio, 1))));  // 0..4 decades
+  const len = 0.4 + logRatio * 1.9;  // world units
+  _gapBar.scale.x = len / 0.4;
+  _gapBar.position.x = -3.8 + (len / 0.4) * 0.2;
+  const col = live ? C_ACCENT : C_DIM;
+  _gapBar.material.color.setHex(col);
+  _gapBar.material.emissive.setHex(col);
+  _gapBar.material.emissiveIntensity = live ? 0.4 : 0.15;
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00010) * 0.15;
+  if (_realLine) _realLine.rotation.y += 0.0015;
+  if (_complexLine) _complexLine.rotation.y += 0.0015;
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A <b>selective state-space scan</b> (h<sub>t</sub> = A(x<sub>t</sub>)\u00b7h<sub>t-1</sub> + B(x<sub>t</sub>)\u00b7x<sub>t</sub>) ' +
+    'runs over a synthetic sequence task. The <b style="color:#5b8dee">blue ribbon</b> is a ' +
+    '<b>real-valued</b> state (decay-only); the <b style="color:#8a6bff">violet ribbon</b> is a ' +
+    '<b>complex-valued</b> state (decay + rotation \u2014 the Mamba-3 addition). Honesty label ' +
+    '<b>MODELED</b> (a simulation of the recurrence \u2014 no trained checkpoint, no measured GPU ' +
+    'benchmark). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "ssm";
+  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("ssm-task",     "task"));
+  grid.appendChild(kpiRow("ssm-dims",     "seq_len \u00d7 state_dim"));
+  grid.appendChild(kpiRow("ssm-real",     "real-state accuracy"));
+  grid.appendChild(kpiRow("ssm-complex",  "complex-state accuracy (Mamba-3)"));
+  grid.appendChild(kpiRow("ssm-flopsq",   "compute FLOPs \u2014 O(L\u00b2) attention"));
+  grid.appendChild(kpiRow("ssm-flopss",   "compute FLOPs \u2014 O(L) SSM scan"));
+  grid.appendChild(kpiRow("ssm-ratio",    "throughput ratio (quad / ssm)"));
+  grid.appendChild(kpiRow("ssm-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 = "Gu & Dao arXiv:2312.00752 (Mamba) \u00b7 Dao & Gu arXiv:2405.21060 (Mamba-2) \u00b7 Lahoti et al. arXiv:2603.15569 (Mamba-3, complex-valued state tracking) \u00b7 github.com/state-spaces/mamba. 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 = "ssm-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 task = S.task || "loading\u2026";
+  const real = S.realAcc != null ? (S.realAcc * 100).toFixed(1) + "%" : "loading\u2026";
+  const cplx = S.complexAcc != null ? (S.complexAcc * 100).toFixed(1) + "%" : "loading\u2026";
+  const ratio = S.throughputRatio != null ? S.throughputRatio.toFixed(1) + "\u00d7" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Transformers compare every token to every other token, so their " +
+    "compute grows with the <i>square</i> of sequence length (O(L\u00b2)). A <b>state-space model</b> " +
+    "(the architecture family behind Mamba) instead keeps a running summary (\u201cstate\u201d) that updates " +
+    "once per token, so compute grows only <i>linearly</i> (O(L)) \u2014 our modeled FLOP counts show " +
+    "roughly a <b>" + ratio + "</b> compute advantage at this sequence length. But early state-space " +
+    "models had a weakness: a real-number-only state can only fade, not <i>flip</i>, so it fails at " +
+    "exact tasks like <b>" + task + "</b> (here: <b>" + real + "</b> accuracy). Mamba-3's key addition is " +
+    "letting the state be a <b>complex number</b> \u2014 it can rotate, which lets it flip sign exactly " +
+    "when needed, jumping accuracy to <b>" + cplx + "</b>. " +
+    "Plain: linear-cost sequence models are catching up to Transformers not just on speed, but on " +
+    "exact reasoning tasks. This view is a <b>MODELED</b> simulation of the mechanism, not a trained " +
+    "production model.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function fexp(v) { return typeof v === "number" ? v.toExponential(3) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("ssm-task",     t || (S.task || "\u2014"));
+  _set("ssm-dims",     t || ((S.seqLen != null && S.stateDim != null) ? `${S.seqLen} \u00d7 ${S.stateDim}` : "\u2014"));
+  _set("ssm-real",     t || (S.realAcc != null ? (S.realAcc * 100).toFixed(2) + "%" : "\u2014"));
+  _set("ssm-complex",  t || (S.complexAcc != null ? (S.complexAcc * 100).toFixed(2) + "%" : "\u2014"));
+  _set("ssm-flopsq",   t || fexp(S.flopsQuad));
+  _set("ssm-flopss",   t || fexp(S.flopsSSM));
+  _set("ssm-ratio",    t || (S.throughputRatio != null ? S.throughputRatio.toFixed(2) + "\u00d7" : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("ssm-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;
+  _realLine = _complexLine = _realDots = _complexDots = _gapBar = _gapBarBg = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.task = S.seqLen = S.stateDim = null;
+  S.realAcc = S.complexAcc = S.flopsQuad = S.flopsSSM = S.throughputRatio = null;
+  S.trajReal = S.trajComplexMag = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/testtime.js

@@ -0,0 +1,493 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/testtime.js — TEST-TIME-COMPUTE / REASONING-SCALING-LAWS organ for the
+// holographic frontier ring. The THIRD scaling axis (alongside pretrain scaling and
+// post-train scaling): how much extra INFERENCE-time compute buys how much accuracy.
+//
+// Renders two 3D growing curves driven by a live closed-form snapshot from
+// /api/killinchu/v1/testtime/scaling:
+//   1. pass@N (best-of-N / repeated-sampling coverage) — a curve that climbs across
+//      N = 1,2,4,...,256 parallel samples.
+//   2. sequential revision accuracy vs number of reasoning/revision steps — a curve
+//      with diminishing returns as k grows.
+// A HUD shows accuracy climbing as compute (N / steps) increases, plus the derived
+// scaling_exponent and effective_oom_multiplier. Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors neuromorphic.js / interpretability.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   base_accuracy, N_samples, pass_at_N, pass_at_N_curve[]
+//   sequential_steps, revised_accuracy, revised_accuracy_curve[]
+//   scaling_exponent, effective_oom_multiplier
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   DeepSeek-R1 (RL reasoning / long CoT): DeepSeek-AI et al. 2025, arXiv:2501.12948
+//     https://arxiv.org/abs/2501.12948
+//   Scaling LLM Test-Time Compute Optimally: Snell et al. 2024, arXiv:2408.03314
+//     https://arxiv.org/abs/2408.03314
+//   Large Language Monkeys (repeated sampling / pass@N): Brown et al. 2024, arXiv:2407.21787
+//     https://arxiv.org/abs/2407.21787
+//
+// HONESTY LABELS: MODELED (closed-form scaling-law simulation; no LLM calls, no live
+//   model eval). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (pass@N curve), violet-blue 0x8a6bff (revision curve),
+//   proof-teal 0x3af4c8 (HUD accent / rising-compute marker). 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    = "testtime";
+const TITLE = "Test-Time Compute · Reasoning-Scaling Laws (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 test-time-compute organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/testtime/scaling?seed=42&p=0.2&N=64&steps=8";
+
+// data-viz hues — purple BANNED
+const C_PASSN  = 0x5b8dee;  // lattice-blue (pass@N curve)
+const C_REVISE = 0x8a6bff;  // violet-blue (sequential revision curve — data-viz only)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_ACCENT = 0x3af4c8;  // proof-teal accent (HUD / rising-compute marker)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+// curve layout geometry
+const CURVE_LEN   = 10.0;   // world-units along X (compute axis, log-spaced)
+const CURVE_DEPTH = 3.0;    // world-units separating the two curve lanes (Z)
+const CURVE_HEIGHT= 5.0;    // world-units of max curve rise (Y, accuracy axis)
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _passLine = null;     // THREE.Line — pass@N growing curve
+let _passDots = [];       // Array<THREE.Mesh> — markers along pass@N curve
+let _revLine  = null;     // THREE.Line — sequential-revision growing curve
+let _revDots  = [];       // Array<THREE.Mesh> — markers along revision curve
+let _marker   = null;     // THREE.Mesh — HUD "current compute" marker (pulses)
+let _floor    = null;
+
+// live state
+const S = {
+  label:        null,
+  baseAcc:      null,   // base_accuracy
+  N:            null,   // N_samples
+  passAtN:      null,   // pass_at_N
+  passCurve:    null,   // pass_at_N_curve[]
+  steps:        null,   // sequential_steps
+  revAcc:       null,   // revised_accuracy
+  revCurve:     null,   // revised_accuracy_curve[]
+  scalingExp:   null,   // scaling_exponent
+  effOom:       null,   // effective_oom_multiplier
+  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(2, 8, 20);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(2, 2.5, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildCurves();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onScaling, { 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 curve line geometries with a fixed max point-count; we update
+// point positions in-place as live data arrives (no per-poll geometry churn).
+const _MAX_PTS = 16;
+
+function _buildCurves() {
+  const THREE = _THREE;
+
+  // pass@N curve lane (Z = 0)
+  {
+    const pts = new Array(_MAX_PTS).fill(0).map(() => new THREE.Vector3(0, 0, 0));
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_PASSN, transparent: true, opacity: 0.85, linewidth: 2 });
+    _passLine = new THREE.Line(geo, mat);
+    _group.add(_passLine);
+
+    const dotGeo = new THREE.SphereGeometry(0.09, 10, 8);
+    for (let i = 0; i < _MAX_PTS; i++) {
+      const m = new THREE.Mesh(dotGeo, new THREE.MeshStandardMaterial({ color: C_PASSN, emissive: C_PASSN, emissiveIntensity: 0.3 }));
+      m.visible = false;
+      _group.add(m);
+      _passDots.push(m);
+    }
+  }
+
+  // sequential-revision curve lane (Z = CURVE_DEPTH)
+  {
+    const pts = new Array(_MAX_PTS).fill(0).map(() => new THREE.Vector3(0, 0, CURVE_DEPTH));
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_REVISE, transparent: true, opacity: 0.85, linewidth: 2 });
+    _revLine = new THREE.Line(geo, mat);
+    _group.add(_revLine);
+
+    const dotGeo = new THREE.SphereGeometry(0.09, 10, 8);
+    for (let i = 0; i < _MAX_PTS; i++) {
+      const m = new THREE.Mesh(dotGeo, new THREE.MeshStandardMaterial({ color: C_REVISE, emissive: C_REVISE, emissiveIntensity: 0.3 }));
+      m.visible = false;
+      _group.add(m);
+      _revDots.push(m);
+    }
+  }
+
+  // baseline axes (compute axis + accuracy axis ticks), grey, data-viz only
+  const axisPts = [
+    new THREE.Vector3(0, 0, -0.6), new THREE.Vector3(0, CURVE_HEIGHT, -0.6),          // accuracy axis
+    new THREE.Vector3(0, 0, -0.6), new THREE.Vector3(CURVE_LEN, 0, -0.6),             // compute axis
+  ];
+  const axisGeo = new THREE.BufferGeometry().setFromPoints(axisPts);
+  const axisLine = new THREE.LineSegments(axisGeo, new THREE.LineBasicMaterial({ color: C_GRID, transparent: true, opacity: 0.4 }));
+  _group.add(axisLine);
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.22, 1),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, 0, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onScaling(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label      = (j.label || "MODELED").toUpperCase();
+  S.baseAcc    = typeof j.base_accuracy    === "number" ? j.base_accuracy    : null;
+  S.N          = typeof j.N_samples        === "number" ? j.N_samples        : null;
+  S.passAtN    = typeof j.pass_at_N        === "number" ? j.pass_at_N        : null;
+  S.passCurve  = Array.isArray(j.pass_at_N_curve) ? j.pass_at_N_curve : null;
+  S.steps      = typeof j.sequential_steps === "number" ? j.sequential_steps : null;
+  S.revAcc     = typeof j.revised_accuracy === "number" ? j.revised_accuracy : null;
+  S.revCurve   = Array.isArray(j.revised_accuracy_curve) ? j.revised_accuracy_curve : null;
+  S.scalingExp = typeof j.scaling_exponent === "number" ? j.scaling_exponent : null;
+  S.effOom     = typeof j.effective_oom_multiplier === "number" ? j.effective_oom_multiplier : null;
+
+  _updateCurves();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the two growing curves from live data
+// =============================================================================
+function _logX(n, nMax) {
+  // log-spaced compute axis: n=1 -> x=0, n=nMax -> x=CURVE_LEN
+  const lo = Math.log10(Math.max(1, 1));
+  const hi = Math.log10(Math.max(2, nMax));
+  const v  = Math.log10(Math.max(1, n));
+  return CURVE_LEN * (v - lo) / Math.max(1e-6, (hi - lo));
+}
+
+function _linX(k, kMax) {
+  return CURVE_LEN * (k / Math.max(1, kMax));
+}
+
+function _updateCurves() {
+  const THREE = _THREE;
+  const live = S.state === "live";
+
+  // --- pass@N curve ---
+  if (live && S.passCurve && S.passCurve.length) {
+    const nMax = S.passCurve.reduce((m, r) => Math.max(m, r.n), 1);
+    const pos = _passLine.geometry.attributes.position;
+    const n = Math.min(_MAX_PTS, S.passCurve.length);
+    for (let i = 0; i < _MAX_PTS; i++) {
+      if (i < n) {
+        const row = S.passCurve[i];
+        const x = _logX(row.n, nMax);
+        const y = row.pass_at_n * CURVE_HEIGHT;
+        pos.setXYZ(i, x, y, 0);
+        _passDots[i].position.set(x, y, 0);
+        _passDots[i].visible = true;
+      } else {
+        // repeat last point so the line doesn't dangle at origin
+        const row = S.passCurve[n - 1];
+        const x = _logX(row.n, nMax);
+        const y = row.pass_at_n * CURVE_HEIGHT;
+        pos.setXYZ(i, x, y, 0);
+        _passDots[i].visible = false;
+      }
+    }
+    pos.needsUpdate = true;
+    _passLine.geometry.computeBoundingSphere();
+    _passLine.material.color.setHex(C_PASSN);
+    _passLine.material.opacity = 0.85;
+  } else {
+    _passDots.forEach((d) => { d.visible = false; });
+    _passLine.material.color.setHex(C_DIM);
+    _passLine.material.opacity = 0.25;
+  }
+
+  // --- sequential-revision curve ---
+  if (live && S.revCurve && S.revCurve.length) {
+    const kMax = S.revCurve.reduce((m, r) => Math.max(m, r.k), 1);
+    const pos = _revLine.geometry.attributes.position;
+    const n = Math.min(_MAX_PTS, S.revCurve.length);
+    for (let i = 0; i < _MAX_PTS; i++) {
+      if (i < n) {
+        const row = S.revCurve[i];
+        const x = _linX(row.k, kMax);
+        const y = row.revised_accuracy * CURVE_HEIGHT;
+        pos.setXYZ(i, x, y, CURVE_DEPTH);
+        _revDots[i].position.set(x, y, CURVE_DEPTH);
+        _revDots[i].visible = true;
+      } else {
+        const row = S.revCurve[n - 1];
+        const x = _linX(row.k, kMax);
+        const y = row.revised_accuracy * CURVE_HEIGHT;
+        pos.setXYZ(i, x, y, CURVE_DEPTH);
+        _revDots[i].visible = false;
+      }
+    }
+    pos.needsUpdate = true;
+    _revLine.geometry.computeBoundingSphere();
+    _revLine.material.color.setHex(C_REVISE);
+    _revLine.material.opacity = 0.85;
+  } else {
+    _revDots.forEach((d) => { d.visible = false; });
+    _revLine.material.color.setHex(C_DIM);
+    _revLine.material.opacity = 0.25;
+  }
+
+  // --- HUD marker: sits at the current (N, pass@N) point, pulses proof-teal ---
+  if (_marker) {
+    if (live && S.passAtN != null && S.N != null && S.passCurve && S.passCurve.length) {
+      const nMax = S.passCurve.reduce((m, r) => Math.max(m, r.n), 1);
+      const x = _logX(S.N, nMax);
+      const y = S.passAtN * CURVE_HEIGHT;
+      _marker.position.set(x, y, 0);
+      _marker.material.color.setHex(C_ACCENT);
+      _marker.material.emissive.setHex(C_ACCENT);
+      _marker.material.opacity = 0.85;
+    } else {
+      _marker.material.color.setHex(C_DIM);
+      _marker.material.emissive.setHex(C_DIM);
+      _marker.material.opacity = 0.3;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00010) * 0.15;
+  if (_marker) {
+    _marker.rotation.y += 0.02;
+    _marker.rotation.x += 0.01;
+    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 =
+    'The <b>third scaling axis</b> (alongside pretrain and post-train): spend more ' +
+    '<b>inference-time compute</b> \u2014 parallel repeated sampling (<b>pass@N</b>) or ' +
+    'sequential reasoning steps \u2014 and trade it for accuracy. Honesty label ' +
+    '<b>MODELED</b> (closed-form scaling law; no LLM calls, no live model eval). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "test-time-compute";
+  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("tt-base",  "base accuracy p"));
+  grid.appendChild(kpiRow("tt-n",     "N samples (parallel compute)"));
+  grid.appendChild(kpiRow("tt-passn", "pass@N \u2014 MODELED"));
+  grid.appendChild(kpiRow("tt-steps", "sequential steps k"));
+  grid.appendChild(kpiRow("tt-rev",   "revised accuracy \u2014 MODELED"));
+  grid.appendChild(kpiRow("tt-exp",   "scaling exponent"));
+  grid.appendChild(kpiRow("tt-oom",   "effective compute (orders of magnitude)"));
+  grid.appendChild(kpiRow("tt-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-R1, DeepSeek-AI et al. arXiv:2501.12948 \u00b7 Snell et al. arXiv:2408.03314 (optimal test-time compute) \u00b7 Brown et al. arXiv:2407.21787 (Large Language Monkeys / pass@N). 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 = "tt-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 n    = S.N != null ? String(S.N) : "loading\u2026";
+  const pAtN = S.passAtN != null ? (S.passAtN * 100).toFixed(2) + "%" : "loading\u2026";
+  const steps= S.steps != null ? String(S.steps) : "loading\u2026";
+  const rAcc = S.revAcc != null ? (S.revAcc * 100).toFixed(2) + "%" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Instead of training a bigger model, you can spend more " +
+    "compute <i>at answer time</i>. Drawing <b>" + n + " independent samples</b> and " +
+    "keeping the best one (\u201cbest-of-N\u201d) pushes the chance of getting a correct " +
+    "answer to <b>" + pAtN + "</b>. Letting the model take <b>" + steps + " sequential " +
+    "reasoning/revision steps</b> instead pushes accuracy to <b>" + rAcc + "</b>, but with " +
+    "<i>diminishing returns</i> \u2014 each extra step helps less than the last. " +
+    "Plain: this is the third lever for making AI smarter \u2014 next to \u201ctrain a bigger " +
+    "model\u201d and \u201cfine-tune it more\u201d, you can also just let it \u201cthink longer\u201d " +
+    "at inference time. This view is a <b>MODELED</b> closed-form scaling law, not a live " +
+    "model evaluation.";
+}
+
+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("tt-base",  t || pct(S.baseAcc, 2));
+  _set("tt-n",     t || (S.N != null ? String(S.N) : "\u2014"));
+  _set("tt-passn", t || pct(S.passAtN, 4));
+  _set("tt-steps", t || (S.steps != null ? String(S.steps) : "\u2014"));
+  _set("tt-rev",   t || pct(S.revAcc, 4));
+  _set("tt-exp",   t || fx(S.scalingExp, 6));
+  _set("tt-oom",   t || fx(S.effOom, 3));
+  // honesty label verbatim — never upgraded
+  _set("tt-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;
+  _passLine = null; _passDots = []; _revLine = null; _revDots = []; _marker = null; _floor = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.baseAcc = S.N = S.passAtN = S.passCurve = null;
+  S.steps = S.revAcc = S.revCurve = S.scalingExp = S.effOom = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

szl3d_holographic.py

@@ -37,6 +37,9 @@ SURFACES: List[Dict[str, str]] = [
     {"id": "worldmodel", "title": "World Model", "owner": "Dev0"},
     {"id": "qec", "title": "Topological QEC", "owner": "Dev0"},
     {"id": "episodic", "title": "Episodic Memory", "owner": "Dev0"},
+    {"id": "testtime", "title": "Test-Time Compute", "owner": "Dev0"},
+    {"id": "ssm", "title": "State-Space (Mamba-3)", "owner": "Dev0"},
+    {"id": "genie", "title": "Genie World-Model", "owner": "Dev0"},
     {"id": "energy", "title": "Energy", "owner": "Dev1"},
     {"id": "fabric", "title": "Compute Fabric", "owner": "Dev2"},
     {"id": "pnt", "title": "PNT", "owner": "Dev3"},