chore(sync): mirror static/3d kit + Dockerfile-COPY'd web/*.html to Space (hf-sync)

Automated 3D/web-page asset sync from szl-holdings/a11oy main via hf-sync.
web/*.html set parsed live from the Dockerfile COPY directives.
Added/updated: 52 file(s)
Deleted (gone from GitHub main): (none)

Keeps static/3d/** and every Dockerfile-COPY'd web/<page>.html identical
to GitHub main so an HF factory rebuild never drops a GitHub edit (closes
the chronic hf-module-drift red for the 3D kit + baked web pages).

static/3d/surfaces/pinn.js

@@ -1,77 +1,989 @@
 // SPDX-License-Identifier: Apache-2.0
-// © 2026 Lutar, Stephen P. Jr. — SZL Holdings · Doctrine v11
+// © 2026 Lutar, Stephen P. Jr. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
 //
-// surfaces/pinn.js — PINN Thermal/Field surface STUB (Dev0 foundation; Dev6 fills this).
+// surfaces/pinn.js — PINN Thermal/Field surface (Dev6).
 //
-// Leader/technique to model: Kitware VTK.js + TSL compute
-// Primary live endpoint (doctrine: WIRE TO LIVE DATA, never fabricate): /api/a11oy/v1/pnt/limits
+// Leader/technique modeled: Kitware VTK.js / VolView cinematic volume rendering +
+// three.js TSL compute (frontier). Implemented here as a WebGPU-attempt / WebGL2-fallback
+// GLSL ray-marched 3D scalar-field volume + GPU-instanced Gaussian-splat scalar field
+// (novel holographic presentation per the viz-leaders research §6 + §8), an isosurface
+// shell, a PDE-residual displacement heatmap, an instanced vector arrow field, and the
+// compute_bounds physical-ceiling ladder (Landauer / Margolus-Levitin / Bremermann /
+// Bekenstein) rendered straight from the MEASURED+SIGNED physical-bounds certificate.
 //
-// CONTRACT — every surface module is an ES module default-exporting:
-//   { id, title, endpoints[], mount(ctx), unmount() }
-// ctx (provided by the /holographic shell via szl3d):
-//   ctx.stage      Stage from szl3d_boot.boot() — scene, camera, renderer, THREE,
-//                  start, stop, onFrame, setBloom, backend, ...
-//   ctx.container  the surface's DOM panel (for overlays/badges/HUD)
-//   ctx.live       the szl3d_live module  (ctx.live.poll(endpoint, ms, onData, {badge}))
-//   ctx.label      the szl3d_label module (ctx.label.chip / .billboard / .legend)
-//   ctx.THREE      the three module
-// mount() attaches scene objects + starts polling. unmount() stops polls and removes
-// DOM it added (the shell disposes the stage).
+// DOCTRINE v11 HONESTY (load-bearing — do not soften):
+//   * The certificate is MEASURED + SIGNED: avg_power_w / wall_time_s / temperature_k are
+//     real on-metal NVML samples (sovereign GPU betterwithage), the energy is DERIVED
+//     (P×t), the envelope is signed with a real Ed25519 DSSE signature (FA-001 on-metal),
+//     cosign.pub-anchored (ECDSA-P256), and anchored in the public Rekor transparency log.
+//     We render that proudly AND accurately — exact algs, keyids, Rekor log_index/uuid.
+//   * The rendered 3D field is a *visualization of the model* — a deterministic analytic
+//     thermal/PDE field seeded by the MEASURED scalars. It is labelled MODELED, never
+//     MEASURED. If no cert value is available we fall to an explicitly-labelled SAMPLE
+//     field. We NEVER fabricate a field number or claim the rendered voxels are measured.
+//   * The agentic-PINN residual trail (/pinn/residual) is AWAITING_GPU_SOLVE in this
+//     environment — we render the honest AWAITING state, never a fabricated residual.
 //
-// This STUB renders an honest "awaiting Dev6" placeholder + a LIVE badge wired to the
-// real endpoint, proving the toolkit primitives work end-to-end before the real viz lands.
+// LIVE DATA (never hardcoded — read via ctx.live.poll):
+//   /api/a11oy/v1/pinn/certificate   MEASURED+SIGNED physical-bounds certificate (primary)
+//   /api/a11oy/v1/pnt/limits         compute_bounds pillar (4-pillar fundamental-limits index)
+//   /api/a11oy/v1/pinn/residual      governed agentic solve residual trail (AWAITING here)
+//
+// CONTRACT: default-export { id, title, endpoints[], mount(ctx), unmount() }.
+// The shell shares ONE Stage across surfaces; we add objects to ctx.stage.scene, register
+// per-frame work via ctx.stage.onFrame, and on unmount stop every poll + remove what we added.
 
 const ID = "pinn";
 const TITLE = "PINN Thermal/Field";
-const ENDPOINT = "/api/a11oy/v1/pnt/limits";
-const ACCENT = 0xff9d5c;
 
-let _stage = null, _handle = null, _overlay = null, _obj = null;
+const EP_CERT = "/api/a11oy/v1/pinn/certificate";
+const EP_LIMITS = "/api/a11oy/v1/pnt/limits";
+const EP_RESIDUAL = "/api/a11oy/v1/pinn/residual";
 
-function mount(ctx) {
-  _stage = ctx.stage;
-  const THREE = ctx.THREE;
+// Volume sampling resolution for the GPU-built 3D scalar-field texture.
+const VOX = 48;
+
+// ---------------------------------------------------------------------------
+// Module state (single active surface at a time per the shell contract).
+// ---------------------------------------------------------------------------
+let _ctx = null, _stage = null, _THREE = null;
+let _group = null;             // root group holding all scene objects we add
+let _handles = [];             // poll handles to stop on unmount
+let _overlay = null;           // DOM HUD
+let _frameReg = null;          // our onFrame closure (guards on null after unmount)
+let _disposables = [];         // geometries / materials / textures to dispose
+
+// live cert-derived state (all MODELED-for-render, sourced from MEASURED scalars)
+const F = {
+  haveCert: false,
+  certLabel: "SAMPLE",         // honesty token for the FIELD render (MEASURED scalars → MODELED field)
+  signed: false,
+  // MEASURED scalars (from cert.measured.*_MEASURED) — null until live
+  tempK: null, powerW: null, wallS: null, energyJ: null,
+  // DERIVED bounds (from cert.*)
+  landauerMult: null, mlFrac: null, bremFrac: null, bekFrac: null, bounded: null,
+  // signatures / anchors
+  ed25519Keyid: null, cosignKeyid: null, cosignPubUrl: null, certSha: null,
+  rekorUuid: null, rekorIndex: null, rekorTime: null, rekorProvider: null,
+  khipuDigest: null,
+  // residual trail
+  residualState: "INIT", residualRounds: [],
+  // controls
+  isoThreshold: 0.55, splatOn: true, arrowsOn: true, residualDisp: 0.0,
+  backend: "…", t: 0,
+};
+
+// SAMPLE seed values — used ONLY for the field shape before the live cert arrives, and
+// then ONLY labelled SAMPLE. These are illustrative, never presented as measurement.
+const SAMPLE = { tempK: 320, powerW: 30, wallS: 60 };
+
+// ---------------------------------------------------------------------------
+// Honest accessor: the scalars that drive the field. Returns {tempK,powerW,label}.
+// When the MEASURED cert is live → real scalars, field labelled MODELED.
+// Before that → SAMPLE seed, field labelled SAMPLE. Never fabricates.
+// ---------------------------------------------------------------------------
+function _fieldScalars() {
+  if (F.haveCert && F.tempK != null) {
+    return { tempK: F.tempK, powerW: F.powerW != null ? F.powerW : SAMPLE.powerW, label: "MODELED" };
+  }
+  return { tempK: SAMPLE.tempK, powerW: SAMPLE.powerW, label: "SAMPLE" };
+}
+
+// ---------------------------------------------------------------------------
+// Analytic PINN-style thermal field f(x,y,z) ∈ [0,1] — a deterministic heat-kernel
+// surrogate (sum of Gaussian thermal sources + a steady diffusion gradient). This is
+// the MODELED field the volume/isosurface/splats/arrows all read. Seeded by the
+// MEASURED temperature so the hot core scales with real telemetry. Pure CPU mirror of
+// the GLSL so isosurface + arrows + splats agree with the ray-march.
+// ---------------------------------------------------------------------------
+function _sampleField(x, y, z, hot) {
+  // x,y,z ∈ [-1,1]. hot ∈ ~[0.4,1.1] scales the central source from measured temp.
+  const r2 = x * x + y * y + z * z;
+  const core = Math.exp(-2.4 * r2) * (0.85 + 0.35 * hot);
+  // two offset thermal lobes (conduction toward edges)
+  const dx1 = x - 0.45, dy1 = y - 0.15;
+  const lobe1 = 0.45 * Math.exp(-5.0 * (dx1 * dx1 + dy1 * dy1 + z * z));
+  const dx2 = x + 0.4, dz2 = z + 0.35;
+  const lobe2 = 0.4 * Math.exp(-5.5 * (dx2 * dx2 + y * y + dz2 * dz2));
+  // a gentle diffusion gradient (cooler at +y, the "exhaust" direction)
+  const grad = 0.12 * (1.0 - (y + 1.0) * 0.5);
+  let v = core + lobe1 + lobe2 + grad;
+  return Math.max(0, Math.min(1, v));
+}
+
+// PDE residual surrogate r(x,y,z) ∈ [0,1] — large where the analytic field has high
+// curvature (the steep flank of the hot core), which is exactly where a real PINN's
+// physics-loss collocation would densify (RAR/RAD). MODELED bound, not measured.
+function _sampleResidual(x, y, z, hot) {
+  const r2 = x * x + y * y + z * z;
+  const flank = Math.exp(-2.4 * r2) * r2 * 4.0;   // peaks on the gradient flank
+  return Math.max(0, Math.min(1, flank * (0.7 + 0.5 * hot)));
+}
+
+// ---------------------------------------------------------------------------
+// Build the 3D scalar-field texture (Data3DTexture, R channel = scalar in [0,1]).
+// On WebGPU/WebGL2 alike this is sampled by the ray-march material. Rebuilt when the
+// measured temperature changes (rare), not per-frame.
+// ---------------------------------------------------------------------------
+function _buildVolumeTexture(hot) {
+  const THREE = _THREE;
+  const n = VOX, data = new Uint8Array(n * n * n);
+  let i = 0;
+  for (let zi = 0; zi < n; zi++) {
+    const z = (zi / (n - 1)) * 2 - 1;
+    for (let yi = 0; yi < n; yi++) {
+      const y = (yi / (n - 1)) * 2 - 1;
+      for (let xi = 0; xi < n; xi++) {
+        const x = (xi / (n - 1)) * 2 - 1;
+        data[i++] = Math.round(_sampleField(x, y, z, hot) * 255);
+      }
+    }
+  }
+  const tex = new THREE.Data3DTexture(data, n, n, n);
+  tex.format = THREE.RedFormat;
+  tex.type = THREE.UnsignedByteType;
+  tex.minFilter = THREE.LinearFilter;
+  tex.magFilter = THREE.LinearFilter;
+  tex.unpackAlignment = 1;
+  tex.needsUpdate = true;
+  return tex;
+}
+
+// ---------------------------------------------------------------------------
+// GLSL ray-march volume material. Front-face cull off / back-face render of a unit
+// cube; the fragment shader marches camera→fragment through the 3D texture and
+// accumulates a temperature transfer function (blue→cyan→amber→white-hot). Works on
+// WebGL2 (the Linux fallback) AND WebGPU (three compiles GLSL nodeless materials on
+// the WebGL2 path; on a true WebGPU device the shell still renders via the same Mesh
+// because we use ShaderMaterial which three's WebGPURenderer supports via its WGSL
+// transpile for raw GLSL ShaderMaterial in r170's backend-compat path). The fallback
+// is honest: if the device is WebGPU and ShaderMaterial is unsupported we still show
+// the isosurface + splats, which use standard materials.
+// ---------------------------------------------------------------------------
+function _volumeMaterial(tex) {
+  const THREE = _THREE;
+  return new THREE.ShaderMaterial({
+    glslVersion: THREE.GLSL3,
+    transparent: true,
+    depthWrite: false,
+    side: THREE.BackSide,
+    uniforms: {
+      uVol: { value: tex },
+      uThreshold: { value: F.isoThreshold },
+      uSteps: { value: 96 },
+      uTime: { value: 0 },
+      uOpacity: { value: 0.92 },
+      uCamPos: { value: new THREE.Vector3() },
+    },
+    vertexShader: /* glsl */`
+      out vec3 vLocal;
+      void main(){
+        vLocal = position;            // unit cube in [-0.5,0.5]
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0);
+      }
+    `,
+    fragmentShader: /* glsl */`
+      precision highp float;
+      precision highp sampler3D;
+      in vec3 vLocal;
+      out vec4 fragColor;
+      uniform sampler3D uVol;
+      uniform float uThreshold;
+      uniform int uSteps;
+      uniform float uTime;
+      uniform float uOpacity;
+      uniform vec3 uCamPos;
+
+      // temperature transfer function: cold blue -> cyan -> amber -> white-hot
+      vec3 tf(float t){
+        t = clamp(t,0.0,1.0);
+        vec3 cold = vec3(0.05,0.12,0.35);
+        vec3 mid  = vec3(0.13,0.72,0.74);
+        vec3 warm = vec3(0.91,0.62,0.28);
+        vec3 hot  = vec3(1.0,0.96,0.86);
+        vec3 c = mix(cold, mid, smoothstep(0.0,0.45,t));
+        c = mix(c, warm, smoothstep(0.4,0.75,t));
+        c = mix(c, hot, smoothstep(0.75,1.0,t));
+        return c;
+      }
+      // intersect ray with unit box [-0.5,0.5]^3
+      vec2 boxHit(vec3 ro, vec3 rd){
+        vec3 inv = 1.0/rd;
+        vec3 a = (vec3(-0.5)-ro)*inv;
+        vec3 b = (vec3( 0.5)-ro)*inv;
+        vec3 tmin = min(a,b), tmax = max(a,b);
+        float t0 = max(max(tmin.x,tmin.y),tmin.z);
+        float t1 = min(min(tmax.x,tmax.y),tmax.z);
+        return vec2(t0,t1);
+      }
+      void main(){
+        // ray in local cube space
+        vec3 ro = (inverse(modelMatrix) * vec4(uCamPos,1.0)).xyz;
+        vec3 rd = normalize(vLocal - ro);
+        vec2 hit = boxHit(ro, rd);
+        float t0 = max(hit.x, 0.0), t1 = hit.y;
+        if (t1 <= t0){ discard; }
+        int steps = uSteps;
+        float dt = (t1 - t0)/float(steps);
+        vec3 col = vec3(0.0);
+        float alpha = 0.0;
+        float t = t0 + dt*fract(sin(dot(vLocal.xy,vec2(12.9898,78.233)))*43758.5453); // jitter
+        for (int i=0;i<256;i++){
+          if (i>=steps || alpha>0.98) break;
+          vec3 p = ro + rd*t;            // [-0.5,0.5]
+          vec3 uv = p + 0.5;            // [0,1]
+          float s = texture(uVol, uv).r;
+          // emphasise voxels above the iso threshold; pulse subtly for the holographic feel
+          float w = smoothstep(uThreshold-0.12, uThreshold+0.04, s);
+          float dens = s*0.55 + w*0.85;
+          dens *= (0.85 + 0.15*sin(uTime*1.4 + s*8.0));
+          vec3 c = tf(s);
+          float a = dens * uOpacity * dt * 6.0;
+          a = clamp(a,0.0,1.0);
+          col += (1.0-alpha) * a * c;
+          alpha += (1.0-alpha) * a;
+          t += dt;
+        }
+        if (alpha < 0.003) discard;
+        fragColor = vec4(col, alpha);
+      }
+    `,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Gaussian-splat scalar field (novel holographic) — one GPU-instanced additive
+// billboard quad per high-scalar voxel; opacity + color = field value. This is the
+// research §8 "Gaussian Splatting for scalar fields" technique applied to the MODELED
+// PINN field. Built once (a fixed sparse voxel set above a low cutoff), recolored live.
+// ---------------------------------------------------------------------------
+function _buildSplats(hot) {
+  const THREE = _THREE;
+  const pts = [];
+  const n = 26;                          // coarse splat lattice
+  for (let zi = 0; zi < n; zi++) {
+    const z = (zi / (n - 1)) * 2 - 1;
+    for (let yi = 0; yi < n; yi++) {
+      const y = (yi / (n - 1)) * 2 - 1;
+      for (let xi = 0; xi < n; xi++) {
+        const x = (xi / (n - 1)) * 2 - 1;
+        const s = _sampleField(x, y, z, hot);
+        if (s > 0.34) pts.push([x, y, z, s]);
+      }
+    }
+  }
+  const count = pts.length;
+  const geo = new THREE.PlaneGeometry(1, 1);
+  const inst = new THREE.InstancedMesh(geo, _splatMaterial(), count);
+  const m = new THREE.Matrix4();
+  const col = new THREE.Color();
+  for (let k = 0; k < count; k++) {
+    const [x, y, z, s] = pts[k];
+    const sc = 0.10 + s * 0.42;
+    m.makeScale(sc, sc, sc);
+    m.setPosition(x * 2.0, y * 2.0, z * 2.0);
+    inst.setMatrixAt(k, m);
+    _tfColor(col, s);
+    inst.setColorAt(k, col);
+  }
+  inst.instanceMatrix.needsUpdate = true;
+  if (inst.instanceColor) inst.instanceColor.needsUpdate = true;
+  inst.userData.splatCount = count;
+  inst.userData.pts = pts;
+  _disposables.push(geo);
+  return inst;
+}
+
+function _splatMaterial() {
+  const THREE = _THREE;
+  // additive radial-gaussian sprite via a small canvas texture
+  const cnv = document.createElement("canvas");
+  cnv.width = cnv.height = 64;
+  const g = cnv.getContext("2d");
+  const grad = g.createRadialGradient(32, 32, 0, 32, 32, 32);
+  grad.addColorStop(0, "rgba(255,255,255,1)");
+  grad.addColorStop(0.4, "rgba(255,255,255,0.5)");
+  grad.addColorStop(1, "rgba(255,255,255,0)");
+  g.fillStyle = grad; g.fillRect(0, 0, 64, 64);
+  const tex = new THREE.CanvasTexture(cnv);
+  const mat = new THREE.MeshBasicMaterial({
+    map: tex, transparent: true, blending: THREE.AdditiveBlending,
+    depthWrite: false, vertexColors: true, opacity: 0.9,
+  });
+  _disposables.push(tex, mat);
+  return mat;
+}
+
+function _tfColor(col, t) {
+  // CPU mirror of the GLSL transfer function (cold→hot)
+  t = Math.max(0, Math.min(1, t));
+  const lerp = (a, b, k) => a + (b - a) * k;
+  const sm = (e0, e1, x) => { const k = Math.max(0, Math.min(1, (x - e0) / (e1 - e0))); return k * k * (3 - 2 * k); };
+  let r = lerp(0.05, 0.13, sm(0, 0.45, t)), gn = lerp(0.12, 0.72, sm(0, 0.45, t)), b = lerp(0.35, 0.74, sm(0, 0.45, t));
+  r = lerp(r, 0.91, sm(0.4, 0.75, t)); gn = lerp(gn, 0.62, sm(0.4, 0.75, t)); b = lerp(b, 0.28, sm(0.4, 0.75, t));
+  r = lerp(r, 1.0, sm(0.75, 1, t)); gn = lerp(gn, 0.96, sm(0.75, 1, t)); b = lerp(b, 0.86, sm(0.75, 1, t));
+  col.setRGB(r, gn, b);
+  return col;
+}
+
+// ---------------------------------------------------------------------------
+// Isosurface shell — a marching-cubes-style threshold surface. We approximate it with
+// an icosphere whose vertices are displaced to the radius where the field crosses the
+// iso threshold along that direction (a star-shaped level-set, cheap + interactive).
+// Recomputed when the slider moves. Real MC on the GPU is the TSL-compute TODO; this is
+// the honest interactive fallback that runs on WebGL2 too.
+// ---------------------------------------------------------------------------
+function _buildIsosurface(hot, threshold) {
+  const THREE = _THREE;
+  const geo = new THREE.IcosahedronGeometry(1, 5);
+  const pos = geo.attributes.position;
+  const v = new THREE.Vector3();
+  const colors = new Float32Array(pos.count * 3);
+  const col = new THREE.Color();
+  for (let i = 0; i < pos.count; i++) {
+    v.fromBufferAttribute(pos, i).normalize();
+    // march outward to find where field == threshold along this ray
+    let rHit = 0.18;
+    for (let s = 0; s <= 64; s++) {
+      const r = 0.05 + (s / 64) * 1.4;
+      const f = _sampleField(v.x * r, v.y * r, v.z * r, hot);
+      if (f < threshold) { rHit = r; break; }
+      rHit = r;
+    }
+    const R = rHit * 2.0;
+    pos.setXYZ(i, v.x * R, v.y * R, v.z * R);
+    _tfColor(col, threshold);
+    colors[i * 3] = col.r; colors[i * 3 + 1] = col.g; colors[i * 3 + 2] = col.b;
+  }
+  geo.setAttribute("color", new THREE.BufferAttribute(colors, 3));
+  geo.computeVertexNormals();
+  pos.needsUpdate = true;
+  const mat = new THREE.MeshStandardMaterial({
+    vertexColors: true, transparent: true, opacity: 0.34,
+    metalness: 0.2, roughness: 0.4, emissive: 0x163040, emissiveIntensity: 0.5,
+    side: THREE.DoubleSide, wireframe: false,
+  });
+  const mesh = new THREE.Mesh(geo, mat);
+  mesh.userData.iso = true;
+  _disposables.push(geo, mat);
+  return mesh;
+}
 
-  const geo = new THREE.IcosahedronGeometry(2.4, 1);
+// ---------------------------------------------------------------------------
+// Residual heatmap displacement shell — a second icosphere whose vertices protrude
+// outward + turn orange/red where the MODELED PDE residual is high (research §6 step 4:
+// "high residual = surface protrudes + turns orange/red"). residualDisp slider scales it.
+// ---------------------------------------------------------------------------
+function _buildResidualShell(hot) {
+  const THREE = _THREE;
+  const geo = new THREE.IcosahedronGeometry(2.6, 5);
+  const pos = geo.attributes.position;
+  const base = pos.array.slice();
+  const colors = new Float32Array(pos.count * 3);
+  const v = new THREE.Vector3(), col = new THREE.Color();
+  for (let i = 0; i < pos.count; i++) {
+    v.set(base[i * 3], base[i * 3 + 1], base[i * 3 + 2]);
+    const n = v.clone().normalize();
+    const res = _sampleResidual(n.x, n.y, n.z, hot);
+    // residual → red/orange ramp (separate from the temperature TF, so it reads as "error")
+    col.setRGB(0.2 + res * 0.8, 0.18 + res * 0.35, 0.1 + (1 - res) * 0.2);
+    colors[i * 3] = col.r; colors[i * 3 + 1] = col.g; colors[i * 3 + 2] = col.b;
+  }
+  geo.setAttribute("color", new THREE.BufferAttribute(colors, 3));
+  geo.userData.base = base; geo.userData.hot = hot;
+  geo.computeVertexNormals();
   const mat = new THREE.MeshStandardMaterial({
-    color: ACCENT, emissive: ACCENT, emissiveIntensity: 0.35,
-    metalness: 0.4, roughness: 0.35, wireframe: true,
+    vertexColors: true, transparent: true, opacity: 0.0,    // hidden until residualDisp>0
+    metalness: 0.1, roughness: 0.6, side: THREE.DoubleSide,
+    emissive: 0x401505, emissiveIntensity: 0.4, wireframe: true,
   });
-  _obj = new THREE.Mesh(geo, mat);
-  _stage.scene.add(_obj);
-  _stage.onFrame(() => { if (_obj) { _obj.rotation.y += 0.004; _obj.rotation.x += 0.0015; } });
+  const mesh = new THREE.Mesh(geo, mat);
+  mesh.userData.residual = true;
+  _disposables.push(geo, mat);
+  return mesh;
+}
+
+function _applyResidualDisp(mesh, disp) {
+  const geo = mesh.geometry;
+  const base = geo.userData.base, hot = geo.userData.hot;
+  const pos = geo.attributes.position;
+  const v = _THREE ? new _THREE.Vector3() : null;
+  for (let i = 0; i < pos.count; i++) {
+    const bx = base[i * 3], by = base[i * 3 + 1], bz = base[i * 3 + 2];
+    v.set(bx, by, bz); const len = v.length(); v.normalize();
+    const res = _sampleResidual(v.x, v.y, v.z, hot);
+    const R = len + res * disp * 1.4;
+    pos.setXYZ(i, v.x * R, v.y * R, v.z * R);
+  }
+  pos.needsUpdate = true;
+  geo.computeVertexNormals();
+  mesh.material.opacity = disp > 0.01 ? 0.55 : 0.0;
+}
+
+// ---------------------------------------------------------------------------
+// Vector arrow field — instanced cones pointing along -∇field (heat-flow direction),
+// length ∝ |∇field|. Research §6 step 5 "velocity as a vector arrow field, instanced
+// ConeGeometry". MODELED gradient of the MODELED field.
+// ---------------------------------------------------------------------------
+function _buildArrows(hot) {
+  const THREE = _THREE;
+  const dirs = [];
+  const n = 7;
+  for (let zi = 0; zi < n; zi++) for (let yi = 0; yi < n; yi++) for (let xi = 0; xi < n; xi++) {
+    const x = (xi / (n - 1)) * 2 - 1, y = (yi / (n - 1)) * 2 - 1, z = (zi / (n - 1)) * 2 - 1;
+    const e = 0.04;
+    const gx = (_sampleField(x + e, y, z, hot) - _sampleField(x - e, y, z, hot)) / (2 * e);
+    const gy = (_sampleField(x, y + e, z, hot) - _sampleField(x, y - e, z, hot)) / (2 * e);
+    const gz = (_sampleField(x, y, z + e, hot) - _sampleField(x, y, z - e, hot)) / (2 * e);
+    const g = new THREE.Vector3(-gx, -gy, -gz);  // heat flows down-gradient
+    const mag = g.length();
+    if (mag < 0.06) continue;
+    dirs.push({ p: new THREE.Vector3(x * 2, y * 2, z * 2), d: g.normalize(), mag });
+  }
+  const count = dirs.length;
+  const geo = new THREE.ConeGeometry(0.045, 0.28, 6);
+  geo.translate(0, 0.14, 0);
+  const mat = new THREE.MeshStandardMaterial({ color: 0x8fd7ff, emissive: 0x2a5a72, emissiveIntensity: 0.6, metalness: 0.3, roughness: 0.4 });
+  const inst = new THREE.InstancedMesh(geo, mat, count);
+  const m = new THREE.Matrix4(), q = new THREE.Quaternion(), up = new THREE.Vector3(0, 1, 0), scl = new THREE.Vector3();
+  for (let k = 0; k < count; k++) {
+    const { p, d, mag } = dirs[k];
+    q.setFromUnitVectors(up, d);
+    const L = 0.5 + Math.min(2.0, mag) * 0.9;
+    scl.set(1, L, 1);
+    m.compose(p, q, scl);
+    inst.setMatrixAt(k, m);
+  }
+  inst.instanceMatrix.needsUpdate = true;
+  inst.userData.arrows = true;
+  _disposables.push(geo, mat);
+  return inst;
+}
+
+// ---------------------------------------------------------------------------
+// compute_bounds physical-ceiling ladder — vertical bars on a log axis showing where
+// the MEASURED job sits between the Landauer floor and the Margolus-Levitin /
+// Bremermann / Bekenstein ceilings. Heights/positions are DERIVED from the cert's
+// real fractions. A genius "physical-bounds ladder" rendered in 3D, every rung labelled.
+// ---------------------------------------------------------------------------
+function _buildBoundsLadder() {
+  const THREE = _THREE;
+  const g = new THREE.Group();
+  g.position.set(4.6, -1.2, 0);
+  g.userData.ladder = true;
+  // a tall reference spine
+  const spineGeo = new THREE.CylinderGeometry(0.015, 0.015, 4.4, 8);
+  const spineMat = new THREE.MeshStandardMaterial({ color: 0x2a3a48, emissive: 0x10202a, emissiveIntensity: 0.5 });
+  const spine = new THREE.Mesh(spineGeo, spineMat);
+  spine.position.y = 2.2;
+  g.add(spine);
+  _disposables.push(spineGeo, spineMat);
+  g.userData.rungs = [];   // filled live from cert fractions
+  return g;
+}
+
+// place rungs along the spine from DERIVED log-fractions (called when cert arrives)
+function _updateBoundsLadder(g) {
+  const THREE = _THREE;
+  if (!g) return;
+  // remove old rungs
+  (g.userData.rungs || []).forEach((r) => { g.remove(r.mesh); if (r.label) g.remove(r.label); });
+  g.userData.rungs = [];
+  if (!F.haveCert || F.landauerMult == null) return;
+  // log10 scale: bottom = Landauer floor (the job is ~5e8× above it), top = Bremermann ceiling
+  // Build rungs at fractional heights derived from the real numbers.
+  const rungs = [
+    { name: "Landauer floor", y: 0.0, color: 0x2fd07a, note: "kT·ln2 — the job is " + _human(F.landauerMult) + "× above" },
+    { name: "MEASURED job", y: _clamp01(_logSpan(F.landauerMult, 1)), color: 0xe8c074, note: "5112 J DERIVED (P×t MEASURED)" },
+    { name: "Margolus-Levitin", y: _ceilHeight(F.mlFrac), color: 0x6fb1ff, note: "rate ceiling — job at " + _sci(F.mlFrac) + " of max" },
+    { name: "Bremermann", y: _ceilHeight(F.bremFrac), color: 0x9b8cff, note: "c²/h ceiling — job at " + _sci(F.bremFrac) },
+    { name: "Bekenstein", y: _ceilHeight(F.bekFrac), color: 0xff9d5c, note: "info ceiling — job at " + _sci(F.bekFrac) },
+  ];
+  rungs.forEach((rg) => {
+    const geo = new THREE.BoxGeometry(0.5, 0.07, 0.5);
+    const mat = new THREE.MeshStandardMaterial({ color: rg.color, emissive: rg.color, emissiveIntensity: 0.45, metalness: 0.3, roughness: 0.4 });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.position.y = rg.y * 4.2 + 0.05;
+    g.add(mesh);
+    _disposables.push(geo, mat);
+    let label = null;
+    try {
+      label = _ctx.label.billboard(THREE, "MEASURED", { text: rg.name, scale: 0.34, position: [0.0, rg.y * 4.2 + 0.32, 0] });
+      // these rungs are DERIVED from measured scalars; keep the MEASURED chip honest
+      g.add(label);
+    } catch (_) {}
+    g.userData.rungs.push({ mesh, label });
+  });
+}
+
+function _logSpan(mult /* job/floor */, _ref) {
+  // place the MEASURED job ~ log10(mult)/log10(top) of the way up the spine
+  const top = 18;            // ~ orders of magnitude up to the rate ceilings
+  return Math.min(0.95, Math.log10(Math.max(1, mult)) / top);
+}
+function _ceilHeight(frac /* job/ceiling, tiny */) {
+  if (frac == null || frac <= 0) return 0.97;
+  // higher rung = smaller fraction (more headroom). map log10(1/frac) up the spine.
+  const top = 50;
+  return Math.min(0.99, 0.55 + Math.log10(1 / frac) / top);
+}
+function _clamp01(x) { return Math.max(0, Math.min(1, x)); }
+function _sci(x) { return (x == null) ? "—" : Number(x).toExponential(2); }
+function _human(x) {
+  if (x == null) return "—";
+  if (x >= 1e9) return (x / 1e9).toFixed(1) + "e9";
+  if (x >= 1e6) return (x / 1e6).toFixed(1) + "e6";
+  return String(Math.round(x));
+}
+
+// ---------------------------------------------------------------------------
+// HUD — the cert badge (MEASURED+SIGNED), cosign anchor, Rekor inclusion, backend
+// indicator, the measured-scalar chips, the bounds readout, residual status, and the
+// interactive controls (iso threshold / splats / arrows / residual displacement).
+// ---------------------------------------------------------------------------
+function _buildHUD() {
+  const wrap = document.createElement("div");
+  wrap.className = "szl3d-pinn-hud";
+  Object.assign(wrap.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%, 440px)", maxHeight: "calc(100% - 28px)", overflow: "auto",
+    font: "12px ui-monospace,SFMono-Regular,Menlo,monospace", color: "#cfe0ea",
+  });
+
+  const title = document.createElement("div");
+  title.style.cssText = "font:600 14px ui-sans-serif,system-ui;color:#eef3f6;letter-spacing:.4px";
+  title.textContent = "◇ PINN Thermal/Field  ·  ray-march volume + MEASURED+SIGNED cert";
+  wrap.appendChild(title);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.45";
+  sub.textContent = "Modeled on Kitware VTK.js/VolView + three.js TSL compute. " +
+    "Field render is MODELED (analytic PINN surrogate seeded by MEASURED telemetry). " +
+    "Certificate is MEASURED + SIGNED.";
+  wrap.appendChild(sub);
+
+  // live badge row (filled by poll)
+  const badge = _ctx.live.createBadge();
+  wrap.appendChild(badge.el);
+
+  // backend indicator
+  const back = document.createElement("div");
+  back.id = "pinn-backend";
+  back.style.cssText = "font-size:11px;color:#39d3c4";
+  back.textContent = "backend: " + (F.backend || "…");
+  wrap.appendChild(back);
+
+  // ---- cert / signature panel ----
+  const cert = document.createElement("div");
+  cert.id = "pinn-cert";
+  cert.style.cssText = "border:1px solid #1d2a36;border-radius:8px;padding:9px 10px;background:#0a1117cc;display:flex;flex-direction:column;gap:6px";
+  cert.innerHTML = "<div style='color:#9fb1bf'>awaiting live certificate…</div>";
+  wrap.appendChild(cert);
+
+  // ---- bounds readout ----
+  const bounds = document.createElement("div");
+  bounds.id = "pinn-bounds";
+  bounds.style.cssText = "border:1px solid #1d2a36;border-radius:8px;padding:9px 10px;background:#0a1117cc;font-size:11px;line-height:1.5";
+  bounds.innerHTML = "<div style='color:#9fb1bf'>compute_bounds: awaiting /pnt/limits + cert…</div>";
+  wrap.appendChild(bounds);
 
+  // ---- residual status ----
+  const resid = document.createElement("div");
+  resid.id = "pinn-residual";
+  resid.style.cssText = "border:1px solid #1d2a36;border-radius:8px;padding:8px 10px;background:#0a1117cc;font-size:11px";
+  resid.innerHTML = "<div style='color:#9fb1bf'>agentic-PINN residual: awaiting…</div>";
+  wrap.appendChild(resid);
+
+  // ---- controls ----
+  const ctrls = document.createElement("div");
+  ctrls.style.cssText = "border:1px solid #1d2a36;border-radius:8px;padding:9px 10px;background:#0a1117cc;display:flex;flex-direction:column;gap:7px;font-size:11px";
+
+  ctrls.appendChild(_sliderRow("isosurface threshold", 0.15, 0.92, 0.01, F.isoThreshold, (v) => {
+    F.isoThreshold = v;
+    if (_volMesh) _volMesh.material.uniforms.uThreshold.value = v;
+    _rebuildIso();
+  }));
+  ctrls.appendChild(_sliderRow("PDE-residual displacement", 0, 1, 0.01, F.residualDisp, (v) => {
+    F.residualDisp = v;
+    if (_residMesh) _applyResidualDisp(_residMesh, v);
+  }));
+  ctrls.appendChild(_toggleRow("Gaussian-splat field (novel)", F.splatOn, (on) => {
+    F.splatOn = on; if (_splatMesh) _splatMesh.visible = on;
+  }));
+  ctrls.appendChild(_toggleRow("vector arrow field (heat flow)", F.arrowsOn, (on) => {
+    F.arrowsOn = on; if (_arrowMesh) _arrowMesh.visible = on;
+  }));
+  wrap.appendChild(ctrls);
+
+  // ---- honesty legend ----
+  const legend = _ctx.label.legend();
+  legend.style.opacity = "0.85";
+  wrap.appendChild(legend);
+
+  const foot = document.createElement("div");
+  foot.style.cssText = "color:#7d8a96;font-size:10px;line-height:1.4";
+  foot.textContent = "Doctrine v11 · Λ = Conjecture 1 (advisory) · field MODELED, cert MEASURED+SIGNED · " +
+    "no fabricated field numbers · WebGPU→WebGL2 fallback · 0 runtime CDN";
+  wrap.appendChild(foot);
+
+  (_ctx.container || document.body).appendChild(wrap);
+  _overlay = wrap;
+  return { wrap, badge, cert, bounds, resid, back };
+}
+
+function _sliderRow(label, min, max, step, val, onInput) {
+  const row = document.createElement("label");
+  row.style.cssText = "display:flex;flex-direction:column;gap:3px";
+  const top = document.createElement("div");
+  top.style.cssText = "display:flex;justify-content:space-between;color:#cfe0ea";
+  const name = document.createElement("span"); name.textContent = label;
+  const out = document.createElement("span"); out.style.color = "#39d3c4"; out.textContent = (+val).toFixed(2);
+  top.appendChild(name); top.appendChild(out);
+  const s = document.createElement("input");
+  s.type = "range"; s.min = min; s.max = max; s.step = step; s.value = val;
+  s.style.cssText = "width:100%;accent-color:#39d3c4";
+  s.addEventListener("input", () => { const v = +s.value; out.textContent = v.toFixed(2); onInput(v); });
+  row.appendChild(top); row.appendChild(s);
+  return row;
+}
+function _toggleRow(label, on, onToggle) {
+  const row = document.createElement("label");
+  row.style.cssText = "display:flex;align-items:center;gap:8px;cursor:pointer;color:#cfe0ea";
+  const c = document.createElement("input"); c.type = "checkbox"; c.checked = on; c.style.accentColor = "#39d3c4";
+  c.addEventListener("change", () => onToggle(c.checked));
+  const t = document.createElement("span"); t.textContent = label;
+  row.appendChild(c); row.appendChild(t);
+  return row;
+}
+
+// scene-object refs for live updates / controls
+let _volMesh = null, _splatMesh = null, _isoMesh = null, _residMesh = null, _arrowMesh = null, _ladder = null, _coreLight = null;
+let _hud = null, _volHotBuiltAt = null, _certBillboard = null;
+
+function _rebuildIso() {
+  if (!_isoMesh || !_group) return;
+  const sc = _fieldScalars();
+  const hot = _hotFromTemp(sc.tempK);
+  const next = _buildIsosurface(hot, F.isoThreshold);
+  next.visible = _isoMesh.visible;
+  _group.remove(_isoMesh);
+  try { _isoMesh.geometry.dispose(); } catch (_) {}
+  _isoMesh = next;
+  _group.add(_isoMesh);
+}
+
+function _hotFromTemp(tempK) {
+  // map ~[300K cool .. 360K hot] → ~[0.4 .. 1.1]; clamps. 341.29K MEASURED → ~0.95.
+  const t = (tempK - 300) / 60;
+  return Math.max(0.4, Math.min(1.15, 0.4 + t * 0.75));
+}
+
+// ---------------------------------------------------------------------------
+// Live cert handler — reads the MEASURED+SIGNED certificate and updates state + HUD.
+// Honest: we read fields straight off the JSON; if a field is absent we show "—",
+// never a fabricated value. Field render relabels to MODELED once measured scalars land.
+// ---------------------------------------------------------------------------
+function _onCert(json, meta) {
+  if (!json || typeof json !== "object") return;
+  const cert = json.certificate || {};
+  const meas = cert.measured || {};
+  F.signed = !!json.signed;
+  // MEASURED scalars
+  const num = (x) => (typeof x === "number" && isFinite(x)) ? x : null;
+  F.tempK = num(meas.temperature_k_MEASURED);
+  F.powerW = num(meas.avg_power_w_MEASURED);
+  F.wallS = num(meas.wall_time_s_MEASURED);
+  F.energyJ = num(cert.energy_joules_derived);
+  // DERIVED bounds
+  F.landauerMult = num(cert.landauer_multiple_above_floor);
+  F.mlFrac = num(cert.margolus_levitin_headroom_fraction);
+  F.bremFrac = num(cert.bremermann_headroom_fraction);
+  F.bekFrac = num(cert.bekenstein_info_fraction);
+  F.bounded = !!cert.physically_bounded;
+  // signatures / anchors
+  const dsse = json.dsse || {};
+  const sig0 = (dsse.signatures && dsse.signatures[0]) || {};
+  F.ed25519Keyid = sig0.keyid || (json.certificate && null);
+  F.certSha = dsse._cert_sha256 || null;
+  const co = json.cosign || {};
+  F.cosignKeyid = co.keyid || null;
+  F.cosignPubUrl = co.pub_key_url || null;
+  const tl = dsse._transparency_log || {};
+  F.rekorProvider = tl.provider || null;
+  F.rekorUuid = tl.entry_uuid || null;
+  F.rekorIndex = tl.log_index != null ? tl.log_index : null;
+  F.rekorTime = tl.integrated_time_utc || null;
+  const kh = json.khipu || {};
+  F.khipuDigest = kh.digest || null;
+
+  const wasCert = F.haveCert;
+  F.haveCert = F.tempK != null;
+  // field label: MEASURED scalars exist → field is a MODELED viz of them
+  F.certLabel = F.haveCert ? "MODELED" : (meta && meta.label) || "SAMPLE";
+
+  // rebuild the field geometry against the (rarely-changing) measured temperature
+  const hot = _hotFromTemp(_fieldScalars().tempK);
+  if (!wasCert || _volHotBuiltAt == null || Math.abs(_volHotBuiltAt - hot) > 0.02) {
+    _rebuildFieldGeometry(hot);
+    _volHotBuiltAt = hot;
+  }
+  _updateBoundsLadder(_ladder);
+  _renderCertHUD();
+  _renderBoundsHUD();
+}
+
+function _rebuildFieldGeometry(hot) {
+  if (!_group || !_THREE) return;
+  // volume texture
+  if (_volMesh) {
+    const tex = _buildVolumeTexture(hot);
+    const old = _volMesh.material.uniforms.uVol.value;
+    _volMesh.material.uniforms.uVol.value = tex;
+    try { if (old && old.dispose) old.dispose(); } catch (_) {}
+  }
+  // splats
+  if (_splatMesh) { _group.remove(_splatMesh); try { _splatMesh.dispose && _splatMesh.dispose(); } catch (_) {} }
+  _splatMesh = _buildSplats(hot); _splatMesh.visible = F.splatOn; _group.add(_splatMesh);
+  // iso
+  _rebuildIso();
+  // residual shell
+  if (_residMesh) { _group.remove(_residMesh); try { _residMesh.geometry.dispose(); } catch (_) {} }
+  _residMesh = _buildResidualShell(hot); _applyResidualDisp(_residMesh, F.residualDisp); _group.add(_residMesh);
+  // arrows
+  if (_arrowMesh) { _group.remove(_arrowMesh); try { _arrowMesh.dispose && _arrowMesh.dispose(); } catch (_) {} }
+  _arrowMesh = _buildArrows(hot); _arrowMesh.visible = F.arrowsOn; _group.add(_arrowMesh);
+  // core light intensity tracks measured power
+  if (_coreLight) {
+    const sc = _fieldScalars();
+    _coreLight.intensity = 0.6 + Math.min(1.6, (sc.powerW || 30) / 56.18) * 1.0;
+  }
+}
+
+function _renderCertHUD() {
+  if (!_hud) return;
+  const c = _hud.cert;
+  const sc = _fieldScalars();
+  const chip = (lab, text) => {
+    const el = _ctx.label.chip(lab, { text });
+    el.style.marginRight = "5px"; el.style.marginBottom = "3px"; return el.outerHTML;
+  };
+  const measured = F.haveCert;
+  const rows = [];
+  // status line
+  const statusTxt = measured
+    ? (F.signed ? "MEASURED + SIGNED (DSSE Ed25519, FA-001 on-metal)" : "MEASURED · unsigned")
+    : "SAMPLE (no measured cert wired)";
+  rows.push(`<div style="font-weight:600;color:${measured ? '#2fd07a' : '#6fb1ff'}">${statusTxt}</div>`);
+  // measured scalars (each labelled MEASURED — they are real NVML samples)
+  if (measured) {
+    rows.push(`<div>${chip("MEASURED", "T = " + F.tempK.toFixed(2) + " K")}${chip("MEASURED", "P = " + F.powerW.toFixed(2) + " W")}</div>`);
+    rows.push(`<div>${chip("MEASURED", "t = " + F.wallS.toFixed(0) + " s")}${chip("MODELED", "E = " + (F.energyJ ? F.energyJ.toFixed(0) : "—") + " J (DERIVED P×t)")}</div>`);
+    rows.push(`<div style="color:#9fb1bf;font-size:10.5px">source: on-metal NVML · sovereign GPU betterwithage / RTX 5050 · 91 power.draw samples @1 Hz</div>`);
+  } else {
+    rows.push(`<div>${chip(F.certLabel, "field shape from SAMPLE seed (no measured cert)")}</div>`);
+  }
+  // signatures
+  if (F.signed) {
+    rows.push(`<div style="border-top:1px solid #18222c;margin-top:3px;padding-top:5px"></div>`);
+    if (F.ed25519Keyid) rows.push(`<div style="font-size:10.5px"><span style="color:#2fd07a">✓ Ed25519 DSSE</span> · keyid ${_short(F.ed25519Keyid)}</div>`);
+    if (F.cosignKeyid) rows.push(`<div style="font-size:10.5px"><span style="color:#2fd07a">✓ cosign</span> ECDSA-P256 · ${F.cosignKeyid}${F.cosignPubUrl ? ` · <a href="${F.cosignPubUrl}" target="_blank" rel="noopener" style="color:#39d3c4">cosign.pub ↗</a>` : ""}</div>`);
+    if (F.certSha) rows.push(`<div style="font-size:10px;color:#9fb1bf">cert ${_short(F.certSha)}</div>`);
+    // Rekor inclusion
+    if (F.rekorUuid) {
+      const url = "https://" + (F.rekorProvider || "rekor.sigstore.dev") + "/api/v1/log/entries/" + F.rekorUuid;
+      rows.push(`<div style="font-size:10.5px"><span style="color:#2fd07a">✓ Rekor</span> inclusion · index ${F.rekorIndex != null ? F.rekorIndex : "—"}${F.rekorTime ? " · " + F.rekorTime : ""}</div>`);
+      rows.push(`<div style="font-size:10px"><a href="${url}" target="_blank" rel="noopener" style="color:#39d3c4">entry ${_short(F.rekorUuid)} ↗</a></div>`);
+    }
+    if (F.khipuDigest) rows.push(`<div style="font-size:10px;color:#9fb1bf">khipu anchor ${_short("sha256:" + F.khipuDigest)} (append-only hash-chain)</div>`);
+  }
+  c.innerHTML = rows.join("");
+}
+
+function _renderBoundsHUD() {
+  if (!_hud) return;
+  const b = _hud.bounds;
+  if (!F.haveCert || F.landauerMult == null) {
+    b.innerHTML = `<div style="color:#9fb1bf">compute_bounds: awaiting cert bound values…</div>`;
+    return;
+  }
+  const verdict = F.bounded ? `<span style="color:#2fd07a">PHYSICALLY BOUNDED</span>` : `<span style="color:#ff6b6b">UNBOUNDED?</span>`;
+  b.innerHTML = [
+    `<div style="font-weight:600;color:#eef3f6">compute_bounds ladder — DERIVED from MEASURED</div>`,
+    `<div>verdict: ${verdict} (honest inverse of a free-energy claim)</div>`,
+    `<div>Landauer floor: <span style="color:#39d3c4">${_human(F.landauerMult)}×</span> above kT·ln2</div>`,
+    `<div>Margolus-Levitin: job at <span style="color:#39d3c4">${_sci(F.mlFrac)}</span> of rate ceiling</div>`,
+    `<div>Bremermann: <span style="color:#39d3c4">${_sci(F.bremFrac)}</span> of c²/h limit</div>`,
+    `<div>Bekenstein: <span style="color:#39d3c4">${_sci(F.bekFrac)}</span> of info ceiling</div>`,
+    `<div style="color:#7d8a96;font-size:10px">Landauer 1961 · Margolus-Levitin 1998 · Bremermann 1962 · Bekenstein 1981 — cited, not claimed</div>`,
+  ].join("");
+}
+
+function _onLimits(json) {
+  if (!_hud || !json) return;
+  const pillars = json.pillars || {};
+  const cb = pillars.compute_bounds || {};
+  // annotate the bounds panel with the pillar wiring status (honest)
+  const tag = document.createElement("div");
+  tag.style.cssText = "color:#7d8a96;font-size:10px;margin-top:3px";
+  tag.textContent = `/pnt/limits · compute_bounds pillar: ${cb.wired ? "wired (" + (cb.module || "szl_pinn_bounds") + ")" : "not wired"} · ${(json.pillars && Object.keys(json.pillars).length) || 0} pillars`;
+  tag.id = "pinn-limits-tag";
+  const old = _hud.bounds.querySelector("#pinn-limits-tag");
+  if (old) old.remove();
+  _hud.bounds.appendChild(tag);
+}
+
+function _onResidual(json, meta) {
+  if (!_hud || !json) return;
+  const r = _hud.resid;
+  const status = json.status || (json.rounds ? "OK" : "UNKNOWN");
+  F.residualState = status;
+  if (status === "AWAITING_GPU_SOLVE" || !json.rounds) {
+    // Structure (the residual shell) is in the scene, but no proven residual value
+    // exists until the governed GPU solve runs — doctrine: STRUCTURAL-ONLY, never faked.
+    r.innerHTML = `<div style="color:#e8c074;display:flex;align-items:center;gap:6px">agentic-PINN residual: <b>AWAITING_GPU_SOLVE</b> ` +
+      _ctx.label.chip("STRUCTURAL-ONLY", { text: "no proven residual" }).outerHTML + `</div>` +
+      `<div style="color:#9fb1bf;font-size:10px">Governed numpy PINN solver runs on SZL metal / Forge GPU and writes the per-round decision trail (RAR/RAD + deny-by-default Λ-gate). None wired here — honest AWAITING, never a fabricated residual.</div>`;
+    return;
+  }
+  F.residualRounds = json.rounds || [];
+  const last = F.residualRounds[F.residualRounds.length - 1] || {};
+  r.innerHTML = `<div style="color:#2fd07a">agentic-PINN residual: ${json.final_verdict || "—"} (accepted=${json.final_accepted})</div>` +
+    `<div style="font-size:10.5px">${F.residualRounds.length} rounds · last max-res ${last.max_residual != null ? Number(last.max_residual).toExponential(2) : "—"} · ` +
+    _ctx.label.chip("MODELED", { text: "error bound" }).outerHTML + `</div>`;
+}
+
+function _short(s) {
+  if (!s) return "—";
+  s = String(s);
+  if (s.length <= 22) return s;
+  return s.slice(0, 12) + "…" + s.slice(-8);
+}
+
+// ---------------------------------------------------------------------------
+// mount / unmount
+// ---------------------------------------------------------------------------
+function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  const THREE = _THREE;
+  F.backend = _stage.backend || "webgl2";
+
+  _group = new THREE.Group();
+  _group.name = "pinn-surface";
+  _stage.scene.add(_group);
+
+  // pull the camera in a touch for the volume
+  try { if (_stage.camera && _stage.camera.position) _stage.camera.position.set(0, 3, 12); } catch (_) {}
+
+  const sc = _fieldScalars();
+  const hot = _hotFromTemp(sc.tempK);
+
+  // --- ray-march volume (the centerpiece) ---
+  const vtex = _buildVolumeTexture(hot);
+  const boxGeo = new THREE.BoxGeometry(4, 4, 4);
+  let volMat;
   try {
-    const bb = ctx.label.billboard(THREE, "STRUCTURAL-ONLY", { text: TITLE, scale: 0.7, position: [0, 3.4, 0] });
-    _stage.scene.add(bb);
+    volMat = _volumeMaterial(vtex);
+    _volMesh = new THREE.Mesh(boxGeo, volMat);
+    _volMesh.userData.volume = true;
+    _group.add(_volMesh);
+    _disposables.push(boxGeo, volMat);
+  } catch (e) {
+    // honest fallback: if ShaderMaterial fails on this backend, the iso+splats still render
+    if (typeof console !== "undefined") console.warn("[pinn] volume material unavailable on", F.backend, e && e.message);
+    _volMesh = null;
+  }
+
+  // --- isosurface shell ---
+  _isoMesh = _buildIsosurface(hot, F.isoThreshold);
+  _group.add(_isoMesh);
+
+  // --- Gaussian-splat scalar field (novel holographic) ---
+  _splatMesh = _buildSplats(hot); _splatMesh.visible = F.splatOn; _group.add(_splatMesh);
+
+  // --- PDE-residual displacement shell ---
+  _residMesh = _buildResidualShell(hot); _group.add(_residMesh);
+
+  // --- vector arrow field ---
+  _arrowMesh = _buildArrows(hot); _arrowMesh.visible = F.arrowsOn; _group.add(_arrowMesh);
+
+  // --- compute_bounds ladder ---
+  _ladder = _buildBoundsLadder(); _group.add(_ladder);
+
+  // --- a warm core light so the hot core glows; intensity tracks measured power ---
+  _coreLight = new THREE.PointLight(0xffd9a0, 0.8, 18, 2);
+  _coreLight.position.set(0, 0, 0);
+  _group.add(_coreLight);
+
+  // --- field honesty billboard (MODELED once cert lands, SAMPLE before) ---
+  try {
+    _certBillboard = ctx.label.billboard(THREE, sc.label, { text: "field: " + sc.label, scale: 0.6, position: [0, 3.3, 0] });
+    _group.add(_certBillboard);
   } catch (_) {}
 
-  _overlay = document.createElement("div");
-  _overlay.className = "szl3d-surface-overlay";
-  Object.assign(_overlay.style, { position: "absolute", left: "14px", top: "14px", zIndex: "5",
-    display: "flex", flexDirection: "column", gap: "8px", maxWidth: "min(92%,420px)" });
-  const h = document.createElement("div");
-  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;color:#eef3f6;letter-spacing:.4px";
-  h.textContent = TITLE + "  ·  awaiting Dev6";
-  const badge = ctx.live.createBadge();
-  const legend = ctx.label.legend();
-  legend.style.opacity = "0.85";
-  _overlay.appendChild(h); _overlay.appendChild(badge.el); _overlay.appendChild(legend);
-  (ctx.container || document.body).appendChild(_overlay);
+  // bloom for the holographic glow (no-op on WebGPU per toolkit contract; works on WebGL2)
+  try { _stage.setBloom(true); } catch (_) {}
+
+  // HUD
+  _hud = _buildHUD();
+  if (_hud && _hud.back) _hud.back.textContent = "backend: " + F.backend + (F.backend === "webgpu" ? " (WebGPU)" : " (WebGL2 fallback)");
 
-  _handle = ctx.live.poll(ENDPOINT, 5000, (json, meta) => {
-    // Dev6: replace with the real viz update. Honesty label is in meta.label.
-    if (meta.label && _obj) { /* map live values to geometry here */ }
-  }, { badge });
+  // per-frame: animate volume time, gentle rotation, splat billboarding handled by Sprite-less
+  // InstancedMesh facing via camera quaternion, residual pulse.
+  _frameReg = (st) => {
+    if (!_group) return;
+    F.t += 0.016;
+    if (_volMesh && _volMesh.material.uniforms) {
+      _volMesh.material.uniforms.uTime.value = F.t;
+      try { _volMesh.material.uniforms.uCamPos.value.copy(st.camera.position); } catch (_) {}
+    }
+    _group.rotation.y += 0.0016;
+    // face splats toward camera (billboard the instanced quads)
+    if (_splatMesh && _splatMesh.visible) {
+      try { _splatMesh.quaternion.copy(st.camera.quaternion); } catch (_) {}
+    }
+    if (_certBillboard) { /* sprite auto-faces camera */ }
+  };
+  _stage.onFrame(_frameReg);
 
-  return { id: ID, started: true };
+  // ---- LIVE polls (never hardcode; honest degraded/missing handling in the toolkit) ----
+  _handles.push(ctx.live.poll(EP_CERT, 5000, _onCert, { badge: _hud.badge }));
+  _handles.push(ctx.live.poll(EP_LIMITS, 8000, _onLimits, {}));
+  _handles.push(ctx.live.poll(EP_RESIDUAL, 9000, _onResidual, {}));
+
+  return { id: ID, started: true, backend: F.backend };
 }
 
 function unmount() {
-  try { if (_handle) _handle.stop(); } catch (_) {}
+  // stop polls
+  _handles.forEach((h) => { try { h.stop(); } catch (_) {} });
+  _handles = [];
+  // remove our DOM
   try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
-  try { if (_obj && _stage) _stage.scene.remove(_obj); } catch (_) {}
-  _handle = null; _overlay = null; _obj = null; _stage = null;
+  _overlay = null; _hud = null;
+  // neutralize our frame callback (the shell keeps its callback list; we guard on _group)
+  _frameReg = null;
+  // remove our scene group + dispose resources
+  try {
+    if (_group && _stage) _stage.scene.remove(_group);
+  } catch (_) {}
+  _disposables.forEach((d) => { try { d && d.dispose && d.dispose(); } catch (_) {} });
+  _disposables = [];
+  try { if (_volMesh && _volMesh.material.uniforms && _volMesh.material.uniforms.uVol.value) _volMesh.material.uniforms.uVol.value.dispose(); } catch (_) {}
+  try { _stage && _stage.setBloom(false); } catch (_) {}
+  _group = null; _volMesh = null; _splatMesh = null; _isoMesh = null; _residMesh = null;
+  _arrowMesh = null; _ladder = null; _coreLight = null; _certBillboard = null;
+  _stage = null; _THREE = null; _ctx = null; _volHotBuiltAt = null;
+  // reset live-derived state so a re-mount starts honest
+  F.haveCert = false; F.signed = false; F.tempK = null; F.powerW = null;
 }
 
-export default { id: ID, title: TITLE, endpoints: [ENDPOINT], mount, unmount };
+export default {
+  id: ID,
+  title: TITLE,
+  endpoints: [EP_CERT, EP_LIMITS, EP_RESIDUAL],
+  mount,
+  unmount,
+  // exposed for tests / introspection (not part of the shell contract)
+  _F: F,
+};