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

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

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

static/3d/holographic.html

@@ -165,6 +165,7 @@ const SURFACES = [
   { id: "flower", title: "Flower Brain", mod: "/static/3d/surfaces/flower.js" },
   { id: "agentmem",    title: "AgentMem · Λ-Governed Agent Memory (synthesis)",   mod: "/static/3d/surfaces/agentmem.js" },
   { id: "loopforge", title: "Loop Forge", mod: "/static/3d/surfaces/loopforge.js" },
+  { id: "edgefusion",  title: "EdgeFusion · Λ-Gated Energy-Proportional Sensor Fusion (synthesis)", mod: "/static/3d/surfaces/edgefusion.js" },
 ];
 
 const stageEl = document.getElementById("stage");

static/3d/surfaces/edgefusion.js

@@ -0,0 +1,450 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/edgefusion.js — EDGEFUSION: energy-proportional, Λ-gated multi-sensor
+// edge fusion (SZL synthesis) for the holographic frontier ring. Heterogeneous
+// sensors sit on an outer arc; each modeled track flows inward, is FUSED by
+// inverse-variance weighting, and passes a central Λ-GATE (Λ = Conjecture 1 —
+// gray, NEVER green). Admitted tracks glow proof-teal, Λ-gated / inconsistent
+// tracks stay grey. The gate core scales with the CAPPED trust (≤0.97). A compact
+// HUD shows the fusion / energy / gate stats and the signed-fusion-receipt-per-
+// write DESIGN (nothing minted on a read). Live snapshot:
+//   /api/a11oy/v1/frontier/edgefusion
+//
+// This is an SZL CROSS-AXIS SYNTHESIS no published system ships together:
+//   multi-sensor fusion (BEVFusion / TransFuser / VINS-Fusion) + energy-
+//   proportional / carbon-aware inference (MLPerf Power / CarbonCall) + a
+//   neuromorphic (SNN / Loihi) efficiency factor + the Λ trust gate + a signed
+//   fusion-receipt-per-write chain.
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   BEVFusion — Liu et al. 2022, arXiv:2205.13542
+//   TransFuser — Chitta et al. 2022, arXiv:2205.15997
+//   VINS-Fusion — HKUST-Aerial-Robotics
+//   MLPerf Power — Tschand et al. 2024, arXiv:2410.12032
+//   CarbonCall — 2025, arXiv:2504.20348
+//   snnTorch — Eshraghian et al. 2021, arXiv:2109.12894
+//   Loihi — Davies et al. 2018, IEEE Micro
+//
+// HONESTY LABELS: MODELED (deterministic multi-sensor scene + inverse-variance
+//   fusion + parametric joules model; read VERBATIM from JSON, never upgraded).
+//   The SZL SYNTHESIS is CONJECTURE: Λ as a per-track trust gate is Λ = Conjecture
+//   1 (gray, never green), and the signed-fusion-receipt-per-write chain is design-
+//   only (RECEIPT-ON-WRITE — nothing minted or signed on this GET). Energy is
+//   MODELED, NOT MEASURED (no NVML/RAPL/Loihi meter wired). Trust capped at 0.97.
+// COLOURS: lattice-blue 0x5b8dee (sensors / track links), violet-blue 0x8a6bff
+//   (Λ-gate ring), proof-teal 0x3af4c8 (admitted track / accent), greys (gated-out
+//   / inconsistent / degraded). Purple BANNED.
+// 0 RUNTIME CDN. three.js via ctx.THREE (vendored by the page importmap).
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8 (adds 0). Λ stays Conjecture 1. Trust never 100%.
+
+import { createShowcase } from "./_showcase.js";
+
+const ID    = "edgefusion";
+const TITLE = "EdgeFusion · Λ-Gated Energy-Proportional Sensor Fusion (live)";
+
+// Served SAME-ORIGIN by szl_edgefusion.py — a deterministic governed-fusion model.
+const EP = "/api/a11oy/v1/frontier/edgefusion?seed=42&n_tracks=48&n_sensors=4&horizon=64";
+
+// data-viz hues — purple BANNED
+const C_SENSOR = 0x5b8dee;  // lattice-blue (sensor emitter / track link)
+const C_GATE   = 0x8a6bff;  // violet-blue (Λ-gate ring)
+const C_ADMIT  = 0x3af4c8;  // proof-teal (admitted track / accent)
+const C_GATED  = 0x5a6570;  // grey (Λ-gated-out / inconsistent)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const SENSOR_R  = 7.0;   // radius of the outer sensor arc
+const MAX_TRACK = 96;    // cap on track meshes rendered (matches backend _TRACK_CAP)
+const MAX_SENS  = 6;     // cap on sensor emitters (matches backend _SENSOR_BANK)
+const GATE_Y    = 0.7;   // height of the central Λ-gate core
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _show = null;
+let _frameReg = false, _polls = [], _badge = null, _f = {};
+
+// geometry handles
+let _floor    = null;
+let _sensMesh = [];   // Array<THREE.Mesh> — sensor emitters on the outer arc
+let _gateRing = null; // THREE.LineLoop — Λ-gate ring
+let _core     = null; // THREE.Mesh — central gate core (scales with trust)
+let _trkMesh  = [];   // Array<THREE.Mesh> — fused-track particles
+let _trkLine  = [];   // Array<THREE.Line> — track -> gate links
+
+// live state
+const S = {
+  label: null,
+  nTracks: null, nSensors: null, horizon: null,
+  sensors: null,           // sensors[] {name, sigma, joules}
+  tracks: null,            // tracks[] (per-track)
+  admits: null, gatedOut: null,
+  meanConf: null, meanAgree: null, consistencyRate: null,
+  meanLambda: null, lambdaMax: null, admitThresh: null,
+  trust: null, trustCap: null,
+  joules: null, joulesIdle: null, neuro: null, neuroFactor: null,
+  receiptSigned: null, receiptDigest: null,
+  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, 10, 22);
+  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();
+  _buildSensors();
+  _buildGate();
+  _buildTracks();
+
+  if (!_frameReg && _stage.onFrame) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _buildShowcase(ctx);
+
+  // top-N sensor labels (billboarded) + hover tooltip via the shared helper.
+  _show.attachSceneLabels({
+    objects: () => _sensMesh.filter((m) => m.visible),
+    text: (o) => (o && o.userData && o.userData.label) || "",
+    weight: (o) => (o && o.userData ? o.userData.weight : 0),
+    topN: MAX_SENS,
+    hover: true,
+  });
+
+  _polls.push(ctx.live.poll(EP, 5000, _onData, {
+    badge: _badge, onState: (m) => { S.state = m.state; _paint(); },
+  }));
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(48, 48, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Sensor emitters: up to MAX_SENS nodes on the outer arc (front hemisphere), each
+// a lattice-blue node; a lower-sigma (better) sensor is drawn larger + weighted
+// higher for the top-N label ranking.
+function _buildSensors() {
+  const THREE = _THREE;
+  const geo = new THREE.OctahedronGeometry(0.34, 0);
+  for (let i = 0; i < MAX_SENS; i++) {
+    const a = Math.PI * (0.15 + 0.7 * (i / Math.max(1, MAX_SENS - 1))); // front arc
+    const mesh = new THREE.Mesh(
+      geo,
+      new THREE.MeshStandardMaterial({ color: C_SENSOR, emissive: C_SENSOR, emissiveIntensity: 0.25, transparent: true, opacity: 0.0 }),
+    );
+    mesh.position.set(Math.cos(a) * SENSOR_R, 1.1, Math.sin(a) * SENSOR_R);
+    mesh.visible = false;
+    mesh.userData = { label: "", weight: 0 };
+    _group.add(mesh);
+    _sensMesh.push(mesh);
+  }
+}
+
+// Central Λ-gate: an advisory ring + a core that scales with the CAPPED trust.
+function _buildGate() {
+  const THREE = _THREE;
+  {
+    const pts = [];
+    for (let i = 0; i <= 64; i++) {
+      const a = (i / 64) * Math.PI * 2;
+      pts.push(new THREE.Vector3(Math.cos(a) * 1.9, GATE_Y, Math.sin(a) * 1.9));
+    }
+    const g = new THREE.BufferGeometry().setFromPoints(pts);
+    const m = new THREE.LineBasicMaterial({ color: C_GATE, transparent: true, opacity: 0.45 });
+    _gateRing = new THREE.LineLoop(g, m);
+    _group.add(_gateRing);
+  }
+  _core = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.75, 1),
+    new THREE.MeshStandardMaterial({ color: C_GATE, emissive: C_GATE, emissiveIntensity: 0.4, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _core.position.set(0, GATE_Y, 0);
+  _group.add(_core);
+}
+
+// Fused-track particles: pre-allocated spheres arranged on a deterministic spiral
+// between the sensor arc and the gate, each with a link line toward the gate core.
+function _buildTracks() {
+  const THREE = _THREE;
+  const geo = new THREE.SphereGeometry(0.13, 8, 8);
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  for (let i = 0; i < MAX_TRACK; i++) {
+    const t = (i + 1) / MAX_TRACK;
+    const r = 2.6 + (SENSOR_R - 3.4) * Math.sqrt(t);
+    const a = i * golden;
+    const mesh = new THREE.Mesh(
+      geo,
+      new THREE.MeshStandardMaterial({ color: C_SENSOR, emissive: C_SENSOR, emissiveIntensity: 0.15, transparent: true, opacity: 0.0 }),
+    );
+    mesh.position.set(Math.cos(a) * r, 0.5 + 0.6 * Math.sin(t * 6.283), Math.sin(a) * r);
+    mesh.visible = false;
+    _group.add(mesh);
+    _trkMesh.push(mesh);
+
+    const lg = new THREE.BufferGeometry().setFromPoints([mesh.position.clone(), new THREE.Vector3(0, GATE_Y, 0)]);
+    const lm = new THREE.LineBasicMaterial({ color: C_SENSOR, transparent: true, opacity: 0.0 });
+    const line = new THREE.Line(lg, lm);
+    line.visible = false;
+    _group.add(line);
+    _trkLine.push(line);
+  }
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onData(j) {
+  const p = (j && typeof j.payload === "object" && j.payload) ? j.payload : j;
+  const rawLabel = (j && j.label) || (p && p.label) || "MODELED";
+  S.label = String(rawLabel).toUpperCase();
+
+  S.nTracks  = typeof p.n_tracks  === "number" ? p.n_tracks  : null;
+  S.nSensors = typeof p.n_sensors === "number" ? p.n_sensors : null;
+  S.horizon  = typeof p.horizon   === "number" ? p.horizon   : null;
+  S.sensors  = Array.isArray(p.sensors) ? p.sensors : null;
+  S.tracks   = Array.isArray(p.tracks)  ? p.tracks  : null;
+
+  const fus = (p && typeof p.fusion === "object") ? p.fusion : {};
+  S.admits          = typeof fus.admitted === "number" ? fus.admitted : null;
+  S.gatedOut        = typeof fus.gated_out === "number" ? fus.gated_out : null;
+  S.meanConf        = typeof fus.mean_fused_confidence === "number" ? fus.mean_fused_confidence : null;
+  S.meanAgree       = typeof fus.mean_sensor_agreement === "number" ? fus.mean_sensor_agreement : null;
+  S.consistencyRate = typeof fus.consistency_rate === "number" ? fus.consistency_rate : null;
+
+  const g = (p && typeof p.lambda_gate === "object") ? p.lambda_gate : {};
+  S.meanLambda  = typeof g.mean_lambda_advisory === "number" ? g.mean_lambda_advisory : null;
+  S.admitThresh = typeof g.admit_threshold === "number" ? g.admit_threshold : null;
+  S.lambdaMax   = (g.bounds && typeof g.bounds.max === "number") ? g.bounds.max : null;
+  S.trust       = typeof g.trust === "number" ? g.trust : null;
+  S.trustCap    = typeof g.trust_cap === "number" ? g.trust_cap : null;
+
+  const e = (p && typeof p.energy === "object") ? p.energy : {};
+  S.joules      = typeof e.joules_per_inference === "number" ? e.joules_per_inference : null;
+  S.joulesIdle  = typeof e.joules_idle_floor === "number" ? e.joules_idle_floor : null;
+  S.neuro       = typeof e.neuromorphic === "boolean" ? e.neuromorphic : null;
+  S.neuroFactor = typeof e.neuromorphic_factor === "number" ? e.neuromorphic_factor : null;
+
+  const rd = (p && typeof p.receipt_design === "object") ? p.receipt_design : {};
+  S.receiptSigned = typeof rd.signed === "boolean" ? rd.signed : null;
+  S.receiptDigest = typeof rd.receipt_preview_digest === "string" ? rd.receipt_preview_digest : null;
+
+  _updateScene();
+  _paint();
+}
+
+// =============================================================================
+// geometry updater
+// =============================================================================
+function _updateScene() {
+  const live = S.state === "live";
+
+  // gate ring degrades to grey when not live
+  if (_gateRing) {
+    _gateRing.material.color.setHex(live ? C_GATE : C_DIM);
+    _gateRing.material.opacity = live ? 0.45 : 0.12;
+  }
+
+  // sensor emitters: light up the active sensor set; size ~ inverse sigma (better
+  // sensor = larger), label = name + sigma, weight for the top-N ranking.
+  const sens = live && S.sensors ? S.sensors : [];
+  for (let i = 0; i < MAX_SENS; i++) {
+    const mesh = _sensMesh[i];
+    const s = i < sens.length ? sens[i] : null;
+    if (!s) { mesh.visible = false; mesh.userData.label = ""; mesh.userData.weight = 0; continue; }
+    mesh.visible = true;
+    const sigma = typeof s.sigma === "number" ? s.sigma : 0.5;
+    const w = 1 / Math.max(0.05, sigma);
+    mesh.userData.label = (s.name || ("s" + i)) + " σ" + sigma.toFixed(2);
+    mesh.userData.weight = w;
+    mesh.material.color.setHex(live ? C_SENSOR : C_DIM);
+    mesh.material.emissive.setHex(live ? C_SENSOR : C_DIM);
+    mesh.material.emissiveIntensity = live ? 0.3 : 0.1;
+    mesh.material.opacity = live ? 0.9 : 0.3;
+    mesh.scale.setScalar(0.7 + Math.min(1.4, w * 0.28));
+  }
+
+  // fused tracks: colour by verdict — admitted proof-teal, Λ-gated/inconsistent
+  // grey (the advisory verdict is always shown, never hidden). Size ~ fused conf.
+  const trk = live && S.tracks ? S.tracks.slice(0, MAX_TRACK) : [];
+  for (let i = 0; i < MAX_TRACK; i++) {
+    const mesh = _trkMesh[i];
+    const line = _trkLine[i];
+    const t = i < trk.length ? trk[i] : null;
+    if (!t) { mesh.visible = false; line.visible = false; continue; }
+    mesh.visible = true; line.visible = true;
+    const admitted = !!t.admitted;
+    const conf = typeof t.fused_confidence === "number" ? t.fused_confidence : 0.5;
+    const col = admitted ? C_ADMIT : C_GATED;
+    mesh.material.color.setHex(col);
+    mesh.material.emissive.setHex(col);
+    mesh.material.emissiveIntensity = admitted ? 0.6 : 0.12;
+    mesh.material.opacity = admitted ? 0.95 : 0.4;
+    mesh.scale.setScalar(0.7 + conf * 1.0);
+    line.material.color.setHex(col);
+    line.material.opacity = admitted ? 0.5 : 0.15;
+  }
+
+  // gate core: colour + size reflect the CAPPED trust (never green / never 1.0).
+  if (_core) {
+    if (live && S.trust != null) {
+      _core.material.color.setHex(C_ADMIT);
+      _core.material.emissive.setHex(C_ADMIT);
+      _core.material.opacity = 0.85;
+      _core.scale.setScalar(0.6 + S.trust * 1.0);
+    } else {
+      _core.material.color.setHex(C_DIM);
+      _core.material.emissive.setHex(C_DIM);
+      _core.material.opacity = 0.3;
+      _core.scale.setScalar(0.6);
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = (typeof performance !== "undefined" ? performance.now() : Date.now());
+  if (_group) _group.rotation.y = Math.sin(t * 0.00007) * 0.12;
+  if (_gateRing) _gateRing.rotation.y += 0.0015;
+  if (_core) {
+    _core.rotation.y += 0.02;
+    _core.rotation.x += 0.008;
+    const pulse = 1.0 + 0.1 * Math.sin(t * 0.0035);
+    const base = (S.state === "live" && S.trust != null) ? (0.6 + S.trust * 1.0) : 0.6;
+    _core.scale.setScalar(base * pulse);
+  }
+}
+
+// =============================================================================
+// showcase overlay (shared helper) — compact chrome + collapsible KPIs
+// =============================================================================
+function _buildShowcase(ctx) {
+  _show = createShowcase(ctx, {
+    id: ID,
+    title: TITLE,
+    accent: "#5b8dee",
+    badge: _badge,
+    chips: [
+      { label: "MODELED", text: "fusion + energy", name: "ef" },
+      { label: "STRUCTURAL-ONLY", text: "Λ=Conjecture 1 · receipt design", name: "syn" },
+    ],
+    legend: ["MODELED", "STRUCTURAL-ONLY"],
+    description:
+      "<b>EdgeFusion.</b> Heterogeneous sensors (outer arc) feed MODELED tracks that are " +
+      "fused by <b>inverse-variance weighting</b>, then pass a central <b>Λ-gate</b> " +
+      "(Λ = Conjecture 1 — gray, NEVER green). Admitted tracks glow proof-teal, Λ-gated / " +
+      "inconsistent tracks stay grey; the core scales with the capped trust (≤0.97). A " +
+      "MODELED joules-per-inference readout scales with the active sensor+track workload " +
+      "(energy-proportional; optional neuromorphic factor). Energy is <b>MODELED, not " +
+      "MEASURED</b> — no NVML/RAPL/Loihi meter is wired.",
+    citations:
+      "BEVFusion arXiv:2205.13542 · TransFuser 2205.15997 · VINS-Fusion (HKUST) · " +
+      "MLPerf Power 2410.12032 · CarbonCall 2504.20348 · snnTorch 2109.12894 · Loihi (IEEE Micro 2018). " +
+      "MODELED/CONJECTURE · not claimed-as. Nothing here is in the locked-8.",
+    plain: {
+      html: () =>
+        "Many different sensors (camera, lidar, radar, …) each see the world imperfectly. " +
+        "EdgeFusion combines them so the good sensors count more — that's the inward flow to " +
+        "the middle. A <b>trust gate</b> in the centre decides which combined tracks are " +
+        "reliable enough to act on: teal = admitted, grey = held back. It also estimates the " +
+        "<b>energy per decision</b> so an edge device can stay power-frugal. The gate is a " +
+        "restraint idea we call Λ — an honest <b>conjecture</b>, so it's drawn grey and its " +
+        "trust never hits 100%. Nothing is signed or saved just by looking at this page.",
+    },
+  });
+
+  _f.workload = _show.addField("sensors / tracks", "workload");
+  _f.conf     = _show.addField("mean fused confidence", "conf");
+  _f.agree    = _show.addField("mean sensor agreement", "agree");
+  _f.cons     = _show.addField("consistency rate", "cons");
+  _f.lambda   = _show.addField("mean Λ advisory (gray)", "lambda");
+  _f.gate     = _show.addField("Λ-gate admits / gated-out", "gate");
+  _f.trust    = _show.addField("trust (capped ≤0.97)", "trust");
+  _f.energy   = _show.addField("energy / inference (MODELED)", "energy");
+  _f.receipt  = _show.addField("fusion receipt", "receipt");
+  _f.label    = _show.addField("honesty label", "label");
+  _paint();
+}
+
+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 "…";
+}
+
+function pct(v, d) { return typeof v === "number" ? (v * 100).toFixed(d) + "%" : "—"; }
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "—"; }
+function _set(k, v) { if (_f[k]) _f[k].textContent = v; }
+
+function _paint() {
+  if (!_show) return;
+  const t = _tok(S.state);
+  if (_show.setChip) _show.setChip("ef", S.label || "MODELED", { text: "fusion + energy" });
+
+  _set("workload", t || (S.nSensors != null || S.nTracks != null
+        ? (S.nSensors != null ? S.nSensors : "—") + " / " + (S.nTracks != null ? S.nTracks : "—") : "—"));
+  _set("conf",  t || pct(S.meanConf, 1));
+  _set("agree", t || pct(S.meanAgree, 1));
+  _set("cons",  t || pct(S.consistencyRate, 1));
+  _set("lambda", t || (S.meanLambda != null
+        ? fx(S.meanLambda, 3) + (S.lambdaMax != null ? " (max " + S.lambdaMax + ")" : "") : "—"));
+  _set("gate",  t || (S.admits != null || S.gatedOut != null
+        ? (S.admits != null ? S.admits : "—") + " / " + (S.gatedOut != null ? S.gatedOut : "—") : "—"));
+  _set("trust", t || (S.trust != null ? fx(S.trust, 3) + (S.trustCap != null ? " (≤" + S.trustCap + ")" : "") : "—"));
+  _set("energy", t || (S.joules != null
+        ? S.joules.toFixed(4) + " J" + (S.neuro ? " · neuro ×" + (S.neuroFactor != null ? S.neuroFactor : "?") : "")
+        : "—"));
+  _set("receipt", t || (S.receiptSigned === false
+        ? "unsigned preview" + (S.receiptDigest ? " " + S.receiptDigest.slice(0, 10) + "…" : "")
+        : (S.receiptDigest ? S.receiptDigest.slice(0, 10) + "…" : "—")));
+  _set("label", t || (S.label || "MODELED"));
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_show) _show.destroy(); } 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 = _show = null;
+  _floor = null; _sensMesh = []; _gateRing = null; _core = null; _trkMesh = []; _trkLine = [];
+  _f = {}; _badge = null; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.nTracks = S.nSensors = S.horizon = S.sensors = S.tracks = null;
+  S.admits = S.gatedOut = S.meanConf = S.meanAgree = S.consistencyRate = null;
+  S.meanLambda = S.lambdaMax = S.admitThresh = S.trust = S.trustCap = null;
+  S.joules = S.joulesIdle = S.neuro = S.neuroFactor = null;
+  S.receiptSigned = S.receiptDigest = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };