chore(sync): mirror front-door files to Space (hf-sync)

Automated front-door sync from szl-holdings/a11oy main via hf-sync.
Added/updated: cathedral.html, cathedral_genius.html, console/docs.html, console/index.html, console/pricing.html, console/throne-room.html, console/throne-room.js, pages/api-keys.html, pages/audit.html, pages/ayni.html, pages/brain-dual.html, pages/brain-jack.html, pages/brain.html, pages/chaski.html, pages/codex-kernel.html, pages/company.html, pages/compliance.html, pages/console.html, pages/counter-uas.html, pages/cued-engagement.html, pages/docs.html, pages/evidence.html, pages/gap-report.html, pages/harvest.html, pages/hatun-mcp.html, pages/hub.html, pages/integrations.html, pages/landing.html, pages/mesh.html, pages/observability.html, pages/operator_organ.html, pages/pricing.html, pages/run-all.html, pages/sdk.html, pages/security.html, pages/status.html, pages/substrate.html, pages/superpowers.html, pages/throne-room.html, pages/throne-room.js, pages/uds.html, pages/upgrades.html, pages/wallpa.html, pages/warhacker.html, pages/wasi-rikuq.html, pages/wires.html, static/a11oy_cathedral.js, static/cathedral_app.js, static/shared/szl_codename_sanitizer.js, static/shared/szl_holo3d.js, static/shared/szl_label_engine.js, static/shared/szl_receipt_cosign.js
Deleted (gone from GitHub main): (none)

Keeps the served front-door (pages/*.html, console/*.html) identical
to GitHub main so an HF factory rebuild never drops a GitHub edit or
keeps serving a page that was deleted on GitHub.

static/shared/szl_holo3d.js

@@ -0,0 +1,723 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * © 2026 SZL Holdings. szl_holo3d.js — the SZL 3D / HOLOGRAPHIC SUBSTRATE KIT.
+ * =====================================================================================
+ * THE reusable holographic substrate every SZL frontier surface renders on.
+ * Vendored locally, served at /static/shared/szl_holo3d.js — ZERO RUNTIME CDN.
+ * Byte-identical across a11oy and killinchu (shared-source drift guard enforced).
+ *
+ * DESIGN INTENT (Surface 10 of FRONTIER_RESEARCH.md): a defense-grade dark-glass
+ * holographic scene shell with a node/edge GRAPH renderer (proof-DAGs, factory
+ * graphs, ontology organisms), a lightweight GLOBE renderer, a Λ-driven TRUST
+ * SPHERE primitive, a SIGNED-PULSE edge animation (light flows along an edge when
+ * a receipt is signed), and a time-slider replay hook.
+ *
+ * RENDERER STRATEGY (honest, air-gap-clean, 0-CDN):
+ *   - SELF-CONTAINED: the kit ships its OWN minimal WebGL2 renderer (no hard
+ *     dependency on three.js). This guarantees byte-identical behaviour on BOTH
+ *     apps regardless of whether a heavy 3D vendor bundle is present.
+ *   - WebGL2 BASELINE: feature-detected; the default render path.
+ *   - WebGPU PROGRESSIVE ENHANCEMENT: feature-detected (navigator.gpu). When
+ *     present we expose it via caps.webgpu = true and (ROADMAP) a WGSL compute
+ *     layout path; we DO NOT claim a WebGPU pipeline we have not built — the
+ *     baseline WebGL2 path renders identically. Honestly labelled ROADMAP.
+ *   - CPU / OLD-GPU FALLBACK: if WebGL2 is unavailable the kit renders an HONEST
+ *     2D <canvas> projection (never a blank canvas) with a visible
+ *     "2D FALLBACK" badge. Graph, trust sphere, globe and signed-pulse all have
+ *     a 2D path so the surface is always legible.
+ *
+ * DOCTRINE: 0 runtime CDN; Λ = Conjecture 1 (a bounded score < 1.0, NOT a
+ * theorem); trust < 100%; honest SAMPLE labels on demo data; never claim live
+ * data; 0 visible character codenames. window.SZLLabels drives honest badges.
+ *
+ * Citations (build references, not runtime calls):
+ *   three.js / R3F  — https://github.com/pmndrs/react-three-fiber
+ *   deck.gl (vis.gl)— https://github.com/visgl/deck.gl
+ *   CesiumJS        — https://github.com/CesiumGS/cesium
+ *
+ * Public API: window.SZLHolo
+ *   SZLHolo.version
+ *   SZLHolo.capabilities()                     -> { webgl2, webgpu, mode, dpr }
+ *   SZLHolo.createScene(mountEl, opts)         -> Scene
+ *   Scene.addGraph(spec)                       -> GraphHandle  (nodes/edges DAG)
+ *   Scene.addGlobe(spec)                       -> GlobeHandle  (lightweight globe)
+ *   Scene.addTrustSphere(spec)                 -> TrustSphereHandle (morph by Λ)
+ *   Scene.signPulse(edgeId, opts)              -> animate light along an edge
+ *   Scene.timeSlider(opts)                     -> replay hook (onTime callback)
+ *   Scene.setLambda(value)                     -> drive global Λ (< 1.0)
+ *   Scene.start() / Scene.stop() / Scene.dispose()
+ * =====================================================================================
+ */
+(function (root, factory) {
+  "use strict";
+  var mod = factory();
+  if (root) { root.SZLHolo = mod; }
+  if (typeof module !== "undefined" && module.exports) { module.exports = mod; }
+})(typeof self !== "undefined" ? self : (typeof window !== "undefined" ? window : null), function () {
+  "use strict";
+
+  var VERSION = "1.0.0";
+
+  /* ----------------------------------------------------------------------- *
+   * Honest palette — Palantir/Datadog-style dark glass, defense-grade.
+   * ----------------------------------------------------------------------- */
+  var PALETTE = {
+    bg0: [0.020, 0.027, 0.043],   // deep space navy
+    bg1: [0.043, 0.063, 0.098],   // glass tint
+    grid: "rgba(90,140,200,0.10)",
+    node: "#7fd4ff",
+    nodeLock: "#ffd479",
+    edge: "rgba(120,170,230,0.45)",
+    pulse: "#aef6ff",
+    text: "#cfe6ff",
+    ok: "#46d39a",
+    warn: "#ffcf5c",
+    bad: "#ff6b6b"
+  };
+
+  /* Λ -> colour. Λ is a bounded score in [0,1) (Conjecture 1; NOT a theorem).
+   * Lower Λ = healthier (green); higher = riskier (red). Trust is never 100%. */
+  function lambdaColor(lam) {
+    lam = clamp01(lam == null ? 0.5 : lam);
+    // green (low) -> amber (mid) -> red (high)
+    var r, g, b;
+    if (lam < 0.5) { var t = lam / 0.5; r = lerp(70, 255, t); g = lerp(211, 207, t); b = lerp(154, 92, t); }
+    else { var u = (lam - 0.5) / 0.5; r = lerp(255, 255, u); g = lerp(207, 107, u); b = lerp(92, 107, u); }
+    return "rgb(" + (r | 0) + "," + (g | 0) + "," + (b | 0) + ")";
+  }
+  function clamp01(x) { return x < 0 ? 0 : (x > 1 ? 1 : x); }
+  function lerp(a, b, t) { return a + (b - a) * t; }
+
+  /* ----------------------------------------------------------------------- *
+   * Capability detection. WebGL2 baseline, WebGPU enhancement, 2D fallback.
+   * ----------------------------------------------------------------------- */
+  function detectCaps() {
+    var webgl2 = false, webgpu = false;
+    try {
+      var c = document.createElement("canvas");
+      var gl = c.getContext("webgl2");
+      webgl2 = !!gl;
+      if (gl && gl.getExtension) { /* probe ok */ }
+    } catch (e) { webgl2 = false; }
+    try { webgpu = (typeof navigator !== "undefined" && !!navigator.gpu); } catch (e2) { webgpu = false; }
+    var dpr = (typeof window !== "undefined" && window.devicePixelRatio) ? Math.min(window.devicePixelRatio, 2) : 1;
+    var mode = webgl2 ? "webgl2" : "2d";
+    return { webgl2: webgl2, webgpu: webgpu, mode: mode, dpr: dpr,
+             // WebGPU is feature-detected but the compute-layout pipeline is ROADMAP;
+             // we honestly do NOT switch the render path to an unbuilt WebGPU path.
+             webgpuPipeline: false };
+  }
+
+  /* ----------------------------------------------------------------------- *
+   * Honest label badge helper (reuses window.SZLLabels when present).
+   * ----------------------------------------------------------------------- */
+  function badgeHTML(key, text) {
+    try {
+      if (typeof window !== "undefined" && window.SZLLabels && window.SZLLabels.badgeHTML) {
+        return window.SZLLabels.badgeHTML(key, { text: text });
+      }
+    } catch (e) {}
+    // honest inline fallback if the shared label engine is not loaded
+    var label = text || key;
+    return '<span class="szl-holo-badge" data-k="' + esc(key) + '">' + esc(label) + "</span>";
+  }
+  function esc(s) {
+    return String(s == null ? "" : s)
+      .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  }
+
+  /* small style sheet injected once (self-styled, 0 external font/css) */
+  var STYLE_ID = "szl-holo3d-style";
+  function ensureStyle(doc) {
+    if (!doc || doc.getElementById(STYLE_ID)) { return; }
+    var css =
+      ".szl-holo-root{position:relative;width:100%;height:100%;min-height:240px;" +
+      "background:radial-gradient(120% 120% at 50% 0%,#0a1326 0%,#050a14 60%,#03060d 100%);" +
+      "overflow:hidden;border-radius:12px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:" + PALETTE.text + ";}" +
+      ".szl-holo-root canvas{display:block;width:100%;height:100%;}" +
+      ".szl-holo-hud{position:absolute;top:8px;left:10px;z-index:5;font-size:11px;letter-spacing:.04em;" +
+      "text-shadow:0 1px 3px rgba(0,0,0,.8);pointer-events:none;}" +
+      ".szl-holo-hud .row{display:flex;gap:6px;align-items:center;margin-bottom:3px;flex-wrap:wrap;}" +
+      ".szl-holo-badge{display:inline-block;padding:1px 6px;border-radius:6px;font-size:10px;font-weight:600;" +
+      "background:rgba(70,150,230,.18);border:1px solid rgba(120,180,240,.35);color:#bfe0ff;}" +
+      ".szl-holo-badge[data-k='SAMPLE']{background:rgba(90,160,240,.16);}" +
+      ".szl-holo-badge[data-k='2DFALLBACK']{background:rgba(255,180,90,.18);border-color:rgba(255,190,110,.4);color:#ffd9a8;}" +
+      ".szl-holo-lambda{position:absolute;bottom:8px;left:10px;z-index:5;font-size:11px;pointer-events:none;}" +
+      ".szl-holo-slider{position:absolute;bottom:8px;right:10px;left:auto;z-index:6;width:42%;max-width:260px;}" +
+      ".szl-holo-slider input{width:100%;}" +
+      ".szl-holo-slider label{font-size:10px;display:block;margin-bottom:2px;opacity:.85;}";
+    var el = doc.createElement("style");
+    el.id = STYLE_ID;
+    el.textContent = css;
+    (doc.head || doc.documentElement).appendChild(el);
+  }
+
+  /* ----------------------------------------------------------------------- *
+   * Minimal 3x perspective math (no matrix lib needed for our point cloud).
+   * We project 3D points to 2D with a simple rotating camera; both the WebGL2
+   * path and the 2D fallback use the SAME projection so visuals match.
+   * ----------------------------------------------------------------------- */
+  function project(p, cam, w, h) {
+    // rotate around Y then X
+    var cy = Math.cos(cam.yaw), sy = Math.sin(cam.yaw);
+    var cx = Math.cos(cam.pitch), sx = Math.sin(cam.pitch);
+    var x = p[0], y = p[1], z = p[2];
+    var x1 = x * cy + z * sy;
+    var z1 = -x * sy + z * cy;
+    var y1 = y * cx - z1 * sx;
+    var z2 = y * sx + z1 * cx;
+    var d = cam.dist;
+    var zc = z2 + d;
+    var f = (cam.fov * Math.min(w, h)) / (zc <= 0.05 ? 0.05 : zc);
+    return {
+      x: w / 2 + x1 * f,
+      y: h / 2 - y1 * f,
+      z: zc,
+      s: f / cam.fov // relative scale for size/alpha
+    };
+  }
+
+  /* ----------------------------------------------------------------------- *
+   * Scene — the holographic shell + all primitives.
+   * ----------------------------------------------------------------------- */
+  function Scene(mountEl, opts) {
+    opts = opts || {};
+    this.mount = mountEl;
+    this.doc = (mountEl && mountEl.ownerDocument) || (typeof document !== "undefined" ? document : null);
+    this.caps = detectCaps();
+    this.opts = opts;
+    this.lambda = (typeof opts.lambda === "number") ? clamp01(opts.lambda) : 0.42;
+    this.cam = { yaw: 0.6, pitch: -0.35, dist: 3.2, fov: 1.7, autoRotate: opts.autoRotate !== false };
+    this.graphs = [];
+    this.globes = [];
+    this.spheres = [];
+    this.pulses = [];
+    this._running = false;
+    this._raf = null;
+    this._lastT = 0;
+    this._t0 = (typeof performance !== "undefined" ? performance.now() : Date.now());
+    this._replay = null; // { from,to,value,playing }
+    this._build();
+  }
+
+  Scene.prototype._build = function () {
+    var doc = this.doc;
+    ensureStyle(doc);
+    var root = doc.createElement("div");
+    root.className = "szl-holo-root";
+    root.setAttribute("data-szl-holo", VERSION);
+    this.root = root;
+
+    var canvas = doc.createElement("canvas");
+    canvas.setAttribute("aria-label", "SZL holographic scene");
+    this.canvas = canvas;
+    root.appendChild(canvas);
+
+    // HUD with honest mode + SAMPLE badge (demo data is SAMPLE)
+    var hud = doc.createElement("div");
+    hud.className = "szl-holo-hud";
+    var modeBadge = this.caps.webgl2 ? badgeHTML("EXPERIMENTAL", "WEBGL2") : badgeHTML("2DFALLBACK", "2D FALLBACK");
+    var gpuBadge = this.caps.webgpu ? badgeHTML("EXPERIMENTAL", "WEBGPU·ROADMAP") : "";
+    hud.innerHTML =
+      '<div class="row">' + (this.opts.title ? '<strong>' + esc(this.opts.title) + '</strong>' : '') +
+      ' ' + modeBadge + ' ' + gpuBadge + '</div>' +
+      '<div class="row" data-szl-holo-labels>' + badgeHTML("SAMPLE", "SAMPLE DATA") + '</div>';
+    this.hud = hud;
+    root.appendChild(hud);
+
+    // Λ readout (Conjecture 1, < 1.0) — never claims a theorem, never 100%.
+    var lam = doc.createElement("div");
+    lam.className = "szl-holo-lambda";
+    this.lamEl = lam;
+    root.appendChild(lam);
+    this._renderLambdaReadout();
+
+    this.mount.appendChild(root);
+
+    // renderer init
+    if (this.caps.webgl2) {
+      this._initGL();
+    }
+    this.ctx2d = canvas.getContext("2d"); // always available for HUD/2D fallback layer
+    this._resize();
+    var self = this;
+    this._onResize = function () { self._resize(); };
+    if (typeof window !== "undefined") { window.addEventListener("resize", this._onResize); }
+  };
+
+  Scene.prototype._renderLambdaReadout = function () {
+    var col = lambdaColor(this.lambda);
+    this.lamEl.innerHTML =
+      'Λ <span style="color:' + col + ';font-weight:700">' + this.lambda.toFixed(3) + '</span> ' +
+      '<span style="opacity:.6">· Conjecture 1 (&lt;1.0) · trust &lt;100%</span>';
+  };
+
+  Scene.prototype._initGL = function () {
+    var gl = null;
+    try { gl = this.canvas.getContext("webgl2", { antialias: true, alpha: false, premultipliedAlpha: false }); }
+    catch (e) { gl = null; }
+    if (!gl) { this.caps.webgl2 = false; this.caps.mode = "2d"; return; }
+    this.gl = gl;
+    // point + line shader (instanced-free, simple gl.POINTS / gl.LINES)
+    var vs =
+      "#version 300 es\n" +
+      "layout(location=0) in vec3 aPos;\n" +
+      "layout(location=1) in vec4 aColor;\n" +
+      "layout(location=2) in float aSize;\n" +
+      "uniform mat4 uMVP;\n" +
+      "out vec4 vColor;\n" +
+      "void main(){ gl_Position = uMVP * vec4(aPos,1.0); gl_PointSize = aSize; vColor = aColor; }\n";
+    var fs =
+      "#version 300 es\nprecision highp float;\n" +
+      "in vec4 vColor; out vec4 frag;\n" +
+      "void main(){\n" +
+      "  vec2 d = gl_PointCoord - vec2(0.5);\n" +
+      "  float r = length(d);\n" +
+      "  float a = smoothstep(0.5,0.1,r);\n" +
+      "  frag = vec4(vColor.rgb, vColor.a * max(a, 0.18));\n" +
+      "}\n";
+    this.prog = this._linkProgram(gl, vs, fs);
+    this.uMVP = gl.getUniformLocation(this.prog, "uMVP");
+    this.vbo = gl.createBuffer();
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE); // additive glow
+  };
+
+  Scene.prototype._linkProgram = function (gl, vsSrc, fsSrc) {
+    function sh(type, src) {
+      var s = gl.createShader(type);
+      gl.shaderSource(s, src); gl.compileShader(s);
+      if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
+        // honest degrade: drop to 2D rather than throw
+        return null;
+      }
+      return s;
+    }
+    var v = sh(gl.VERTEX_SHADER, vsSrc), f = sh(gl.FRAGMENT_SHADER, fsSrc);
+    if (!v || !f) { this.caps.webgl2 = false; this.caps.mode = "2d"; return null; }
+    var p = gl.createProgram();
+    gl.attachShader(p, v); gl.attachShader(p, f); gl.linkProgram(p);
+    if (!gl.getProgramParameter(p, gl.LINK_STATUS)) { this.caps.webgl2 = false; this.caps.mode = "2d"; return null; }
+    return p;
+  };
+
+  Scene.prototype._resize = function () {
+    var dpr = this.caps.dpr;
+    var w = this.root.clientWidth || 640, h = this.root.clientHeight || 360;
+    this.W = w; this.H = h;
+    this.canvas.width = Math.max(1, (w * dpr) | 0);
+    this.canvas.height = Math.max(1, (h * dpr) | 0);
+    if (this.gl) { this.gl.viewport(0, 0, this.canvas.width, this.canvas.height); }
+  };
+
+  /* -------- primitives ------------------------------------------------ */
+
+  // GRAPH: { nodes:[{id,pos:[x,y,z],label,locked,lambda}], edges:[{id,from,to}] }
+  Scene.prototype.addGraph = function (spec) {
+    spec = spec || {};
+    var nodes = (spec.nodes || []).map(function (n, i) {
+      return {
+        id: n.id != null ? n.id : ("n" + i),
+        pos: n.pos || sphereLayout(i, (spec.nodes || []).length, 1.1),
+        label: n.label || "",
+        locked: !!n.locked,
+        lambda: (typeof n.lambda === "number") ? clamp01(n.lambda) : null
+      };
+    });
+    var index = {}; nodes.forEach(function (n, i) { index[n.id] = i; });
+    var edges = (spec.edges || []).map(function (e, i) {
+      return { id: e.id != null ? e.id : ("e" + i), from: index[e.from], to: index[e.to],
+               fromId: e.from, toId: e.to };
+    }).filter(function (e) { return e.from != null && e.to != null; });
+    var h = { kind: "graph", nodes: nodes, edges: edges, index: index };
+    this.graphs.push(h);
+    return h;
+  };
+
+  // GLOBE: lightweight wireframe sphere + lat/long graticule + optional points.
+  // Honest: this is a procedural SAMPLE globe, NOT a CesiumJS tile basemap.
+  // A real basemap (CesiumJS local tiles / three-globe) is ROADMAP and must be
+  // vendored 0-CDN before any tile call is made.
+  Scene.prototype.addGlobe = function (spec) {
+    spec = spec || {};
+    var pts = (spec.points || []).map(function (p, i) {
+      var la = (p.lat || 0) * Math.PI / 180, lo = (p.lon || 0) * Math.PI / 180;
+      var r = 1.0;
+      return { pos: [r * Math.cos(la) * Math.cos(lo), r * Math.sin(la), r * Math.cos(la) * Math.sin(lo)],
+               label: p.label || "", lambda: (typeof p.lambda === "number") ? clamp01(p.lambda) : 0.4 };
+    });
+    var h = { kind: "globe", radius: spec.radius || 1.0, points: pts,
+              sample: true, basemap: "PROCEDURAL_SAMPLE" };
+    this.globes.push(h);
+    return h;
+  };
+
+  // TRUST SPHERE: a sphere whose radius/colour morph with Λ (Conjecture 1).
+  // Lower Λ -> larger, greener (more trust); higher Λ -> smaller, redder.
+  Scene.prototype.addTrustSphere = function (spec) {
+    spec = spec || {};
+    var h = { kind: "sphere",
+              center: spec.center || [0, 0, 0],
+              baseR: spec.radius || 0.6,
+              lambda: (typeof spec.lambda === "number") ? clamp01(spec.lambda) : this.lambda,
+              label: spec.label || "TRUST",
+              segs: spec.segments || 16 };
+    this.spheres.push(h);
+    return h;
+  };
+
+  // SIGNED-PULSE: animate a light packet flowing along an edge (receipt signed).
+  Scene.prototype.signPulse = function (edgeRef, opts) {
+    opts = opts || {};
+    var graph = this.graphs[0];
+    var edge = null;
+    if (graph) {
+      for (var i = 0; i < graph.edges.length; i++) {
+        if (graph.edges[i].id === edgeRef || i === edgeRef) { edge = graph.edges[i]; break; }
+      }
+    }
+    if (!edge && graph && graph.edges.length) { edge = graph.edges[0]; }
+    if (!edge) { return null; }
+    var p = { graph: graph, edge: edge, t: 0, dur: opts.duration || 1200,
+              color: opts.color || PALETTE.pulse, started: this._now(), loop: !!opts.loop };
+    this.pulses.push(p);
+    return p;
+  };
+
+  // TIME-SLIDER replay hook. Injects a slider; calls opts.onTime(normalized,absolute).
+  Scene.prototype.timeSlider = function (opts) {
+    opts = opts || {};
+    var doc = this.doc, self = this;
+    var box = doc.createElement("div");
+    box.className = "szl-holo-slider";
+    var from = opts.from != null ? opts.from : 0;
+    var to = opts.to != null ? opts.to : 100;
+    box.innerHTML = '<label>REPLAY ' + badgeHTML("SAMPLE", "SAMPLE") + '</label>' +
+                    '<input type="range" min="0" max="1000" value="1000" step="1" aria-label="time replay">';
+    var input = box.querySelector("input");
+    input.addEventListener("input", function () {
+      var n = (+input.value) / 1000;
+      self._replay = { from: from, to: to, value: from + (to - from) * n, norm: n };
+      if (typeof opts.onTime === "function") { opts.onTime(n, self._replay.value); }
+    });
+    this.root.appendChild(box);
+    this._replay = { from: from, to: to, value: to, norm: 1 };
+    return { el: box, set: function (n) { input.value = String(Math.round(clamp01(n) * 1000)); input.dispatchEvent(new Event("input")); } };
+  };
+
+  Scene.prototype.setLambda = function (v) {
+    this.lambda = clamp01(v);
+    // trust sphere(s) without an explicit lambda track the global Λ
+    for (var i = 0; i < this.spheres.length; i++) {
+      if (this.spheres[i]._tracksGlobal !== false && this.spheres[i].lambda == null) {
+        this.spheres[i].lambda = this.lambda;
+      }
+    }
+    this._renderLambdaReadout();
+    return this.lambda;
+  };
+
+  Scene.prototype._now = function () { return (typeof performance !== "undefined" ? performance.now() : Date.now()); };
+
+  /* -------- run loop -------------------------------------------------- */
+  Scene.prototype.start = function () {
+    if (this._running) { return; }
+    this._running = true;
+    var self = this;
+    function loop(t) {
+      if (!self._running) { return; }
+      self._frame(t || self._now());
+      self._raf = (typeof requestAnimationFrame !== "undefined")
+        ? requestAnimationFrame(loop) : setTimeout(function () { loop(self._now()); }, 33);
+    }
+    this._raf = (typeof requestAnimationFrame !== "undefined")
+      ? requestAnimationFrame(loop) : setTimeout(function () { loop(self._now()); }, 33);
+    return this;
+  };
+  Scene.prototype.stop = function () {
+    this._running = false;
+    if (this._raf != null) {
+      if (typeof cancelAnimationFrame !== "undefined") { cancelAnimationFrame(this._raf); }
+      else { clearTimeout(this._raf); }
+      this._raf = null;
+    }
+    return this;
+  };
+
+  Scene.prototype._frame = function (t) {
+    var dt = this._lastT ? (t - this._lastT) : 16;
+    this._lastT = t;
+    if (this.cam.autoRotate) { this.cam.yaw += dt * 0.00018; }
+    this._drawCount = 0;
+    if (this.caps.webgl2 && this.gl && this.prog) {
+      this._renderGL(t);
+    }
+    // 2D overlay always draws labels/pulses/slider markers; in fallback it draws everything.
+    this._render2D(t);
+    // expose a draw count so verifiers can confirm >0 draws
+    this.root.setAttribute("data-szl-draws", String(this._drawCount));
+  };
+
+  /* Build the full point/line set in scene space (shared by GL + 2D). */
+  Scene.prototype._collectGeometry = function (t) {
+    var pts = [];   // {pos, color, size, label}
+    var lines = []; // {a, b, color}
+    var self = this;
+    var replayN = this._replay ? this._replay.norm : 1;
+
+    // graphs
+    this.graphs.forEach(function (g) {
+      g.edges.forEach(function (e) {
+        var a = g.nodes[e.from], b = g.nodes[e.to];
+        if (!a || !b) { return; }
+        lines.push({ a: a.pos, b: b.pos, color: PALETTE.edge });
+      });
+      g.nodes.forEach(function (n, i) {
+        // replay: reveal nodes progressively by index
+        var reveal = (i / Math.max(1, g.nodes.length - 1)) <= (replayN + 0.0001);
+        if (!reveal) { return; }
+        var col = n.locked ? PALETTE.nodeLock : (n.lambda != null ? lambdaColor(n.lambda) : PALETTE.node);
+        pts.push({ pos: n.pos, color: col, size: n.locked ? 16 : 12, label: n.label });
+      });
+    });
+
+    // globes
+    this.globes.forEach(function (gl) {
+      var R = gl.radius, rings = 10, seg = 22;
+      for (var i = 1; i < rings; i++) {
+        var lat = (i / rings - 0.5) * Math.PI;
+        var prev = null;
+        for (var j = 0; j <= seg; j++) {
+          var lon = (j / seg) * Math.PI * 2;
+          var p = [R * Math.cos(lat) * Math.cos(lon), R * Math.sin(lat), R * Math.cos(lat) * Math.sin(lon)];
+          if (prev) { lines.push({ a: prev, b: p, color: "rgba(110,160,220,0.18)" }); }
+          prev = p;
+        }
+      }
+      for (var k = 0; k < seg; k++) {
+        var lon2 = (k / seg) * Math.PI * 2; var prev2 = null;
+        for (var m = 0; m <= rings; m++) {
+          var lat2 = (m / rings - 0.5) * Math.PI;
+          var q = [R * Math.cos(lat2) * Math.cos(lon2), R * Math.sin(lat2), R * Math.cos(lat2) * Math.sin(lon2)];
+          if (prev2) { lines.push({ a: prev2, b: q, color: "rgba(110,160,220,0.12)" }); }
+          prev2 = q;
+        }
+      }
+      gl.points.forEach(function (p) {
+        pts.push({ pos: p.pos, color: lambdaColor(p.lambda), size: 14, label: p.label });
+      });
+    });
+
+    // trust spheres — radius morphs with Λ (lower Λ = larger/greener)
+    this.spheres.forEach(function (s) {
+      var lam = (s.lambda != null) ? s.lambda : self.lambda;
+      var R = s.baseR * (1.25 - 0.5 * lam); // morph
+      var col = lambdaColor(lam);
+      var rings = s.segs, seg = s.segs;
+      for (var i = 0; i <= rings; i++) {
+        var lat = (i / rings - 0.5) * Math.PI; var prev = null;
+        for (var j = 0; j <= seg; j++) {
+          var lon = (j / seg) * Math.PI * 2;
+          var p = [s.center[0] + R * Math.cos(lat) * Math.cos(lon),
+                   s.center[1] + R * Math.sin(lat),
+                   s.center[2] + R * Math.cos(lat) * Math.sin(lon)];
+          if (prev) { lines.push({ a: prev, b: p, color: hexA(col, 0.30) }); }
+          prev = p;
+        }
+      }
+      pts.push({ pos: s.center, color: col, size: 10 + 14 * (1 - lam), label: s.label + " Λ" + lam.toFixed(2) });
+    });
+
+    // signed pulses — moving light packet along an edge
+    var alive = [];
+    this.pulses.forEach(function (p) {
+      var age = self._now() - p.started;
+      var f = age / p.dur;
+      if (f >= 1) { if (p.loop) { p.started = self._now(); f = 0; } else { return; } }
+      var a = p.graph.nodes[p.edge.from], b = p.graph.nodes[p.edge.to];
+      if (!a || !b) { return; }
+      var pos = [lerp(a.pos[0], b.pos[0], f), lerp(a.pos[1], b.pos[1], f), lerp(a.pos[2], b.pos[2], f)];
+      pts.push({ pos: pos, color: p.color, size: 18, label: "" , pulse: true });
+      // glowing trail
+      for (var q = 1; q <= 4; q++) {
+        var tf = Math.max(0, f - q * 0.05);
+        pts.push({ pos: [lerp(a.pos[0], b.pos[0], tf), lerp(a.pos[1], b.pos[1], tf), lerp(a.pos[2], b.pos[2], tf)],
+                   color: hexA(p.color, 0.5 - q * 0.1), size: 14 - q * 2, pulse: true });
+      }
+      alive.push(p);
+    });
+    this.pulses = alive;
+
+    return { pts: pts, lines: lines };
+  };
+
+  Scene.prototype._renderGL = function (t) {
+    var gl = this.gl, geo = this._collectGeometry(t);
+    gl.clearColor(PALETTE.bg0[0], PALETTE.bg0[1], PALETTE.bg0[2], 1);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    var mvp = this._mvp();
+    gl.useProgram(this.prog);
+    gl.uniformMatrix4fv(this.uMVP, false, mvp);
+
+    // lines
+    var lineArr = [];
+    geo.lines.forEach(function (ln) {
+      var c = parseColor(ln.color);
+      lineArr.push(ln.a[0], ln.a[1], ln.a[2], c[0], c[1], c[2], c[3], 2.0);
+      lineArr.push(ln.b[0], ln.b[1], ln.b[2], c[0], c[1], c[2], c[3], 2.0);
+    });
+    this._drawArray(gl, lineArr, gl.LINES);
+    this._drawCount += geo.lines.length;
+
+    // points
+    var ptArr = [];
+    geo.pts.forEach(function (pt) {
+      var c = parseColor(pt.color);
+      ptArr.push(pt.pos[0], pt.pos[1], pt.pos[2], c[0], c[1], c[2], c[3], pt.size * 1.0);
+    });
+    this._drawArray(gl, ptArr, gl.POINTS);
+    this._drawCount += geo.pts.length;
+    this._lastGeo = geo; // for 2D label overlay
+  };
+
+  Scene.prototype._drawArray = function (gl, arr, mode) {
+    if (!arr.length) { return; }
+    var data = new Float32Array(arr);
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, data, gl.DYNAMIC_DRAW);
+    var stride = 8 * 4;
+    gl.enableVertexAttribArray(0); gl.vertexAttribPointer(0, 3, gl.FLOAT, false, stride, 0);
+    gl.enableVertexAttribArray(1); gl.vertexAttribPointer(1, 4, gl.FLOAT, false, stride, 3 * 4);
+    gl.enableVertexAttribArray(2); gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, 7 * 4);
+    gl.drawArrays(mode, 0, arr.length / 8);
+  };
+
+  // Build a perspective * view matrix consistent with our project() camera.
+  Scene.prototype._mvp = function () {
+    var cam = this.cam;
+    var aspect = this.canvas.width / Math.max(1, this.canvas.height);
+    var f = 1.0 / Math.tan(cam.fov / 2);
+    var near = 0.1, far = 100;
+    var proj = [
+      f / aspect, 0, 0, 0,
+      0, f, 0, 0,
+      0, 0, (far + near) / (near - far), -1,
+      0, 0, (2 * far * near) / (near - far), 0
+    ];
+    var cy = Math.cos(cam.yaw), sy = Math.sin(cam.yaw);
+    var cx = Math.cos(cam.pitch), sx = Math.sin(cam.pitch);
+    var ry = [cy, 0, -sy, 0, 0, 1, 0, 0, sy, 0, cy, 0, 0, 0, 0, 1];
+    var rx = [1, 0, 0, 0, 0, cx, sx, 0, 0, -sx, cx, 0, 0, 0, 0, 1];
+    var trans = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, -cam.dist, 1];
+    return mul(proj, mul(trans, mul(rx, ry)));
+  };
+
+  /* 2D layer: in fallback mode renders the full scene; otherwise draws labels. */
+  Scene.prototype._render2D = function (t) {
+    var ctx = this.ctx2d; if (!ctx) { return; }
+    var dpr = this.caps.dpr, w = this.canvas.width, h = this.canvas.height;
+    if (!this.caps.webgl2) {
+      // FULL 2D FALLBACK — never a blank canvas.
+      var grd = ctx.createRadialGradient(w / 2, h * 0.2, 10, w / 2, h * 0.2, h);
+      grd.addColorStop(0, "#0a1326"); grd.addColorStop(1, "#03060d");
+      ctx.fillStyle = grd; ctx.fillRect(0, 0, w, h);
+      // faint grid
+      ctx.strokeStyle = PALETTE.grid; ctx.lineWidth = 1;
+      for (var gx = 0; gx < w; gx += 40 * dpr) { ctx.beginPath(); ctx.moveTo(gx, 0); ctx.lineTo(gx, h); ctx.stroke(); }
+      for (var gy = 0; gy < h; gy += 40 * dpr) { ctx.beginPath(); ctx.moveTo(0, gy); ctx.lineTo(w, gy); ctx.stroke(); }
+      var geo = this._collectGeometry(t);
+      var self = this;
+      ctx.lineWidth = 1.4 * dpr;
+      geo.lines.forEach(function (ln) {
+        var pa = project(ln.a, self.cam, w, h), pb = project(ln.b, self.cam, w, h);
+        ctx.strokeStyle = ln.color; ctx.beginPath(); ctx.moveTo(pa.x, pa.y); ctx.lineTo(pb.x, pb.y); ctx.stroke();
+        self._drawCount++;
+      });
+      geo.pts.slice().sort(function (a, b) {
+        return project(b.pos, self.cam, w, h).z - project(a.pos, self.cam, w, h).z;
+      }).forEach(function (pt) {
+        var p = project(pt.pos, self.cam, w, h);
+        var r = Math.max(2, pt.size * 0.5 * dpr * p.s);
+        var glow = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, r * 2.4);
+        glow.addColorStop(0, pt.color); glow.addColorStop(1, "rgba(0,0,0,0)");
+        ctx.fillStyle = glow; ctx.beginPath(); ctx.arc(p.x, p.y, r * 2.4, 0, Math.PI * 2); ctx.fill();
+        ctx.fillStyle = pt.color; ctx.beginPath(); ctx.arc(p.x, p.y, r, 0, Math.PI * 2); ctx.fill();
+        if (pt.label) {
+          ctx.fillStyle = PALETTE.text; ctx.font = (11 * dpr) + "px ui-monospace,monospace";
+          ctx.fillText(pt.label, p.x + r + 3, p.y + 3);
+        }
+        self._drawCount++;
+      });
+      return;
+    }
+    // WebGL2 mode: overlay node labels on a transparent 2D layer is not possible
+    // on the same canvas (GL owns it). Labels are shown via the HUD; here we just
+    // keep the draw count honest from the GL pass. (No second canvas to stay 0-CDN
+    // and simple.)
+  };
+
+  Scene.prototype.dispose = function () {
+    this.stop();
+    if (typeof window !== "undefined" && this._onResize) { window.removeEventListener("resize", this._onResize); }
+    if (this.root && this.root.parentNode) { this.root.parentNode.removeChild(this.root); }
+    this.gl = null; this.ctx2d = null;
+  };
+
+  /* ----------------------------------------------------------------------- *
+   * helpers
+   * ----------------------------------------------------------------------- */
+  function sphereLayout(i, n, r) {
+    // fibonacci sphere for pleasing graph node distribution
+    n = Math.max(1, n);
+    var phi = Math.acos(1 - 2 * (i + 0.5) / n);
+    var theta = Math.PI * (1 + Math.sqrt(5)) * i;
+    return [r * Math.sin(phi) * Math.cos(theta), r * Math.cos(phi), r * Math.sin(phi) * Math.sin(theta)];
+  }
+  function parseColor(c) {
+    // returns [r,g,b,a] in 0..1
+    if (Array.isArray(c)) { return [c[0], c[1], c[2], c[3] == null ? 1 : c[3]]; }
+    c = String(c).trim();
+    var m;
+    if ((m = c.match(/^#([0-9a-f]{6})$/i))) {
+      var n = parseInt(m[1], 16);
+      return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255, 1];
+    }
+    if ((m = c.match(/^rgba?\(([^)]+)\)$/i))) {
+      var p = m[1].split(",").map(function (x) { return parseFloat(x); });
+      return [(p[0] || 0) / 255, (p[1] || 0) / 255, (p[2] || 0) / 255, p[3] == null ? 1 : p[3]];
+    }
+    return [0.5, 0.8, 1, 1];
+  }
+  function hexA(c, a) {
+    var p = parseColor(c);
+    return "rgba(" + (p[0] * 255 | 0) + "," + (p[1] * 255 | 0) + "," + (p[2] * 255 | 0) + "," + a + ")";
+  }
+  function mul(a, b) {
+    var out = new Array(16);
+    for (var r = 0; r < 4; r++) {
+      for (var c = 0; c < 4; c++) {
+        var s = 0;
+        for (var k = 0; k < 4; k++) { s += a[k * 4 + c] * b[r * 4 + k]; }
+        out[r * 4 + c] = s;
+      }
+    }
+    return out;
+  }
+
+  /* ----------------------------------------------------------------------- *
+   * public module surface
+   * ----------------------------------------------------------------------- */
+  return {
+    version: VERSION,
+    palette: PALETTE,
+    lambdaColor: lambdaColor,
+    capabilities: function () { return detectCaps(); },
+    createScene: function (mountEl, opts) {
+      if (!mountEl) { throw new Error("SZLHolo.createScene requires a mount element"); }
+      return new Scene(mountEl, opts || {});
+    },
+    // expose for advanced lanes (F2-F5) that build their own scene types
+    _Scene: Scene,
+    _helpers: { sphereLayout: sphereLayout, project: project }
+  };
+});