# Stabilizing Beyond 105 Qubits Instrument v0.2 — Implementation Architecture

**Three-Run Stabilization Architecture: Public Backtrace, HIR/OAM Settlement, and Diamond-Gate Hexshell Stabilization**

Created and Developed by Collin D. Weber · Creator and Developer of Primordial Calculus / HIR-OAM · Systems Architect / Systems Integrity Steward

> Public-review structural instrument only. Not quantum hardware control. Not direct qubit measurement. Not QEC replacement. Not a Google / Willow product claim. Public constraints only. Run C is a theoretical HIR architecture model, not a hardware validation.

---

## 0. Reading guide

This document is the build contract. It is deterministic and self-contained: given the same control inputs, the same numbers come out, every time, with no randomness. The instrument is a **structural pressure model**. It does not measure physical qubits. It scores how three different *stabilization grammars* respond to the same modeled pressure field. Output is always labeled **"theoretical qubit-equivalent stabilization ceiling"** / **"model-internal stabilization ceiling."**

The eleven sections below map 1:1 to the requested deliverables.

---

## 1. Naming and version structure

| Field | Value |
|---|---|
| `artifact_name` | `Stabilizing Beyond 105 Qubits Instrument` |
| `version` | `0.2.0` |
| `codename` | `Three-Run Stabilization Architecture` |
| `subtitle` | `Public Backtrace, HIR/OAM Settlement, and Diamond-Gate Hexshell Stabilization` |
| `schema_version` | `hir-oam-review-packet/2` |
| `run_ids` | `A` = Public Constraint Backtrace · `B` = HIR/OAM Encapsulated Settlement · `C` = Full HIR Architecture / Diamond-Gate Hexshell |

Versioning rule: `MAJOR.MINOR.PATCH`. MINOR increments when a run's state machine or scoring band changes; PATCH for copy/UI; MAJOR for a change to the core `S_field` / `S_full` formulas or packet schema. The `schema_version` is independent of artifact version so downstream readers can validate packets across artifact revisions.

---

## 2. Full data model

All control values are normalized **0.0–1.0** unless noted. "Good" sliders raise stability; "pressure" sliders raise system pressure. Internal scores are kept as floats in `[-1, 1]` or `[0, 1]` and mapped to a `0–100` display band only at render time.

```
ModelState
├── meta
│   ├── artifact_name, version, schema_version
│   ├── boundary_statement
│   └── timestamp (ISO 8601, generated at packet export)
│
├── controls.shared              // applies to A, B, C
│   ├── localTraceStability      [0..1]  good → T
│   ├── latticePressure          [0..1]  → Q (inverse), P_lattice
│   ├── correlationLevel         [0..1]  → P_correlation, independence (inverse)
│   ├── decoderStrain            [0..1]  → R (inverse), P_decoder
│   ├── controlDrift             [0..1]  → P_control, temporal validity (inverse)
│   ├── runtimePressure          [0..1]  → P_runtime
│   ├── resourcePressure         [0..1]  → P_resource
│   ├── provenanceContinuity     [0..1]  good → G, P_provenance (inverse)
│   ├── securityRisk             [0..1]  → P_security
│   ├── publicClaimPressure      [0..1]  → P_public
│   ├── pUnknown                 [0..1]  → P_unknown (residual uncertainty)
│   ├── evidenceQuality          [0..1]  good → ECS
│   └── operationType            enum    // severity multiplier
│
├── controls.runC               // additional, Run C only
│   ├── shellCount               int 2..7
│   ├── gateDensity              [0..1]
│   ├── gateHandoffEfficiency    [0..1]  → DG
│   ├── alignmentStrength        [0..1]  instantaneous alignment under pressure
│   ├── routingEfficiency        [0..1]  omnidirectional relief
│   ├── ramLearningRate          [0..1]  → RAM
│   ├── immuneRetention          [0..1]
│   ├── redTeamSensitivity       [0..1]
│   ├── redTeamFalsePositive     [0..1]  pressure
│   ├── redTeamFalseNegative     [0..1]  pressure
│   ├── encapsulationThreshold   [0..1]  cryptobiotic trigger point
│   ├── malformedPressure        [0..1]
│   ├── counterfeitResonance     [0..1]
│   ├── myceliumPropagation      [0..1]  → DM
│   ├── hirInternalization       [0..1]
│   ├── gritDensity              [0..1]
│   ├── uwcThermalBurden         [0..1]  cost (inverse to UWC)
│   └── resourceTruthVisibility  [0..1]  good (raises UWC)
│
└── derived (recomputed every tick — never stored as source of truth)
    ├── factors: T, Q, R, G, DG, RAM, IM, DM, UWC
    ├── pressures: P_lattice … P_unknown, P_malformed, P_constraint, P_system, P_total
    ├── runA, runB, runC readout objects
    ├── ecs, hardInvariantFlags[]
    └── qCeiling, qCeilingFull
```

Operation-type enum and its severity multiplier `σ` (used to harden invariants for higher-stakes operations):

| `operationType` | σ |
|---|---|
| `diagnostic` (Diagnostic review) | 0.5 |
| `calibration` (Calibration review) | 0.7 |
| `current_branch` (Current branch operation) | 1.0 |
| `final_logical` (Final logical operation) | 1.3 |
| `public_claim` (Public claim / benchmark interpretation) | 1.6 |
| `safety_critical` (Safety-critical downstream use) | 2.0 |

---

## 3. Control list

**Shared (all runs):** local trace stability · lattice pressure · correlation level · decoder strain · control drift · runtime scheduler pressure · resource pressure · provenance continuity · security risk · public claim pressure · P_unknown / residual uncertainty · evidence quality · operation type.

**Run C additional:** shell count · diamond gate density · gate handoff efficiency · instantaneous alignment strength · omnidirectional routing efficiency · RAM learning rate · immune memory retention · authorized red-team capture sensitivity · red-team false-positive pressure · red-team false-negative pressure · cryptobiotic encapsulation threshold · malformed data pressure · counterfeit resonance pressure · Digital Mycelium repair propagation · HIR internalization · grit density · UWC thermal/resource burden · resource-truth visibility.

UI control types: all `[0..1]` fields are range sliders (step 0.01) with a live numeric badge; `shellCount` is a stepped slider (int); `operationType` is a `<select>`. Every slider has a one-line tooltip stating direction ("higher = more pressure" vs "higher = better").

---

## 4. Formula design

Helper: `clamp(x,a,b)`, `lerp`, `norm01(x)`, `pct(x) = round(clamp(x,0,1)*100)`. All weights below are fixed constants in the build.

**Composite factors (each clamped to [0,1]):**

```
T  = localTraceStability
Q  = clamp(1 - 0.65*latticePressure - 0.35*correlationLevel)
R  = clamp(1 - 0.6*decoderStrain - 0.4*runtimePressure)
G  = clamp(0.5*provenanceContinuity + 0.3*evidenceQuality + 0.2*(1-securityRisk))

// Run C stack factors
DG  = clamp(0.5*gateHandoffEfficiency + 0.3*alignmentStrength + 0.2*routingEfficiency)
RAM = clamp(0.6*ramLearningRate + 0.4*immuneRetention)
IM  = clamp(0.55*redTeamSensitivity + 0.25*immuneRetention
            - 0.4*redTeamFalseNegative - 0.2*redTeamFalsePositive + 0.4)   // floored
DM  = clamp(0.7*myceliumPropagation + 0.3*hirInternalization)
UWC = clamp(0.6*resourceTruthVisibility + 0.4*(1 - uwcThermalBurden))
```

**Pressure terms (each [0,1]):**

```
P_lattice     = latticePressure
P_correlation = correlationLevel
P_decoder     = decoderStrain
P_control     = controlDrift
P_runtime     = runtimePressure
P_resource    = resourcePressure
P_provenance  = 1 - provenanceContinuity
P_security    = securityRisk
P_public      = publicClaimPressure * (0.5 + 0.5*σ_norm)   // σ_norm = σ/2
P_unknown     = pUnknown
P_malformed   = clamp(0.6*malformedPressure + 0.4*counterfeitResonance)   // Run C
P_constraint  = clamp(0.5*(1-routingEfficiency) + 0.5*(1-gateDensity))    // Run C
```

**System / total pressure** (weighted means → keep in [0,1]):

```
P_system = Σ(w_i * P_i) over the 10 shared terms,  Σw_i = 1
   weights: lattice .14, correlation .12, decoder .14, control .08,
            runtime .08, resource .08, provenance .12, security .10,
            public .08, unknown .06

P_total  = 0.78 * P_system + 0.12 * P_malformed + 0.10 * P_constraint   // Run C
```

**Base field pressure (spec form):**

```
S_field = T * Q * R * G - P_system          // float in ~[-1, 1]
display_A = pct((S_field + 1) / 2)           // 0..100
```

**Evidence Conversion Score:**

```
Provenance         = provenanceContinuity
Independence       = 1 - correlationLevel
ScopeMatch         = clamp(1 - publicClaimPressure * σ_norm)
PressureMatch      = clamp(1 - |declaredScopePressure - P_system|)
                     // declaredScopePressure approximated from operationType band
TemporalValidity   = 1 - controlDrift
RepeatStability    = clamp(localTraceStability * (1 - decoderStrain))
CorrelationPenalty       = correlationLevel
SelfCertPenalty          = clamp((1-Independence) * (1-Provenance))
BoundaryViolationPenalty = clamp(publicClaimPressure * σ_norm)

ECS_raw = Provenance + Independence + ScopeMatch + PressureMatch
        + TemporalValidity + RepeatStability
        - CorrelationPenalty - SelfCertPenalty - BoundaryViolationPenalty   // [-3, 6]
ECS = pct((ECS_raw + 3) / 9)
```

**Run C full-stack form (spec form):**

```
coreC   = T*Q*R*G*DG*RAM*IM*DM*UWC          // product of 9 factors, small but monotonic
S_full  = coreC - P_total                    // literal spec value, stored raw in packet

// display normalization (documented, monotonic, never inflates the literal):
S_full_norm = clamp( pow(coreC, 0.25) - 0.35*P_total )   // [0,1] display proxy
display_C   = pct(S_full_norm)
```

**Theoretical stabilization ceiling:**

```
Q_base          = 105
ShellMultiplier = 1 + 0.12*(shellCount - 2)            // more shells → more headroom
GateDensityF    = 0.5 + 0.5*gateDensity
AlignmentFactor = 0.5 + 0.5*alignmentStrength
RecoveryFactor  = clamp(0.4*RAM + 0.3*DM + 0.3*IM + 0.3)

Q_ceiling_A = round( Q_base * (1 + max(0, S_field) ) )                       // backtrace ceiling
Q_ceiling_full = round( Q_base * (1 + S_full_norm * ShellMultiplier
                  * GateDensityF * AlignmentFactor * RecoveryFactor) )       // Run C ceiling
```

**Pressure failure condition (Run C):**

```
GateCapacity            = DG * GateDensityF * AlignmentFactor
RAMRecovery             = 0.5 * RAM
ImmuneCapture           = 0.5 * IM
RepairPropagation       = 0.5 * DM
ResourceTruthCorrection = 0.4 * UWC

defense = GateCapacity + RAMRecovery + ImmuneCapture
        + RepairPropagation + ResourceTruthCorrection

FAIL_CLOSED  ⇔  P_total > defense
saturationMargin = defense - P_total       // < 0 means saturated
```

All constants are fixed in source; nothing is sampled.

---

## 5. Deterministic scoring logic

Single pure function `compute(state) -> derived`. Pipeline, evaluated top to bottom on every control change:

1. Read controls → clamp all to declared ranges.
2. Resolve `σ` from `operationType`; `σ_norm = σ/2`.
3. Compute factors `T,Q,R,G` and (for C) `DG,RAM,IM,DM,UWC`.
4. Compute all `P_*`, then `P_system`, then `P_total`.
5. `S_field` → Run A score + Run A state.
6. ECS + hard invariant flags → Run B score + settlement authority + Run B state.
7. `coreC`, `S_full`, `S_full_norm` → Run C score; `defense` vs `P_total` → failure condition; cryptobiotic state; immune state; RAM state; UWC burden.
8. `Q_ceiling_A`, `Q_ceiling_full`.
9. Recommended actions per run from state + flags.
10. Assemble readout objects (no DOM writes inside `compute`; render is separate).

Purity guarantees: no `Date.now()` inside `compute` (timestamp is taken only at packet export), no `Math.random()`, no reads of prior derived state. This makes the artifact fully reviewable — a reviewer can recompute any field by hand.

---

## 6. Run A / B / C state machines

State is chosen by ordered guard clauses (first match wins), so output is unambiguous.

**Run A — Public Constraint Backtrace** (drivers: `S_field`, `decoderStrain`, `correlationLevel`, `publicClaimPressure`, `pUnknown`)

```
if S_field >= 0.55                                  → CORRECTED FOR LIMITED SCOPE
elif decoderStrain >= 0.6                           → DECODER STRAIN
elif correlationLevel >= 0.6                        → CORRELATED PRESSURE RISK
elif publicClaimPressure >= 0.6                     → BENCHMARK SCOPE ONLY
elif pUnknown >= 0.55                               → UNRESOLVED PRESSURE COMPRESSED
else                                                → RECHECK RECOMMENDED
```
Run A always attempts to keep output usable; it has no settlement authority and no scope-bound closure. Residual pressure not corrected is reported as a *warning*, and may be "compressed into confidence" (flagged, never hidden).

**Run B — HIR/OAM Encapsulated Settlement** (drivers: `ECS`, hard invariant flags, `P_unknown`, `publicClaimPressure`, `securityRisk`)

Hard invariant flags (each boolean, any TRUE caps settlement):
```
PROVENANCE_BROKEN     = provenanceContinuity < 0.4
SELF_CERTIFIED        = SelfCertPenalty > 0.4
PUBLIC_OVERREACH      = publicClaimPressure*σ_norm > 0.6
UNRESOLVED_PRESSURE   = pUnknown > 0.55
SECURITY_RISK         = securityRisk > 0.6
SCOPE_MISMATCH        = PressureMatch < 0.45
```
State:
```
if PUBLIC_OVERREACH                                 → PUBLIC CLAIM BOUNDARY REQUIRED
elif SECURITY_RISK or PROVENANCE_BROKEN             → FAIL CLOSED FOR AFFECTED PATH
elif ECS >= 72 and no flags                         → FIELD HELD FOR CURRENT SCOPE
elif ECS >= 55                                      → LOCAL STRAIN ONLY
elif UNRESOLVED_PRESSURE                            → MUST RECHECK FIELD
elif ECS >= 40                                      → PARTIAL SETTLEMENT ONLY
else                                                → ERROR ADDRESSED, NOT CLOSED
```
Settlement authority label: `SETTLED (scope-bound)` / `CONDITIONAL` / `WITHHELD`, derived from the state tier.

**Run C — Full HIR / Diamond-Gate Hexshell** (drivers: `defense` vs `P_total`, `P_malformed` vs `IM`, encapsulation, routing)

```
saturationMargin = defense - P_total
encapStrain = P_total - encapsulationThreshold

immuneTriggered = P_malformed > IM*0.8 OR counterfeitResonance > 0.55
encapTriggered  = encapStrain > 0  AND  IM < 0.7   // too strained to handle lawfully

primary state (first match):
if saturationMargin < 0                             → GATE NETWORK SATURATED
elif encapStrain > 0.15                             → FAIL CLOSED AT SHELL BOUNDARY
elif encapTriggered                                 → CRYPTOBIOTIC ENCAPSULATION ACTIVE
elif immuneTriggered                                → IMMUNE CAPTURE EVENT  (+ MALFORMED TRACE QUARANTINED)
elif routingEfficiency >= 0.6 and gateDensity>=0.5  → OMNIDIRECTIONAL RELIEF ACTIVE
elif ramLearningRate >= 0.5                         → PRESSURE LEARNED INTO RAM
elif saturationMargin >= 0.25                       → GATE-ALIGNED FIELD HELD
else                                                → SHELL RE-ROUTE SUCCESSFUL

side flags (can stack): MALFORMED TRACE QUARANTINED, RESOURCE BURDEN VISIBLE (uwcThermalBurden>0.5)
```

**Cryptobiotic encapsulation sub-state machine** (independent track, drives the encapsulation readout):
```
OPEN        : P_total <= encapsulationThreshold*0.6
HELD        : P_total <= encapsulationThreshold*0.85
STRAINED    : P_total <  encapsulationThreshold
ENCAPSULATED: P_total >= encapsulationThreshold and IM < 0.7
DORMANT     : ENCAPSULATED and myceliumPropagation < 0.3
REPAIRING   : ENCAPSULATED and myceliumPropagation >= 0.5
REOPENED    : was ENCAPSULATED and now P_total < encapsulationThreshold*0.8 (hysteresis)
MUST STOP   : saturationMargin < -0.2 (defense overwhelmed)
```
(REOPENED uses hysteresis on the previous tick; this is the one place a single prior boolean is retained, and it is explicitly part of the documented machine, not hidden state.)

---

## 7. UI layout

```
┌────────────────────────────────────────────────────────────────────┐
│ HEADER  title + subtitle                                             │
│ BOUNDARY BOX (always visible, high-contrast, top of fold)            │
├──────────────┬─────────────────────────────┬───────────────────────┤
│ LEFT         │ CENTER                       │ RIGHT                  │
│ Pressure     │ 105-qubit-scale pressure     │ Three run readouts     │
│ Field        │ field visual.                │ (A / B / C) stacked on │
│ Controls     │ Run toggle: A flat lattice / │ narrow screens, side-  │
│ (shared +    │ B trace-tagged + Evidence    │ by-side ≥ 1100px.      │
│  Run C group │ overlay / C concentric       │ Each: score dial +     │
│  collapsible)│ hexshells + diamond gates +  │ status chips + ceiling │
│              │ routing pathways.            │ + recommended action.  │
├──────────────┴─────────────────────────────┴───────────────────────┤
│ EXPORT BAR: [Copy JSON Review Packet] [Download JSON Review Packet]  │
├──────────────────────────────────────────────────────────────────────┤
│ SECTIONS 1–13 (long-form, below the dashboard)                        │
└──────────────────────────────────────────────────────────────────────┘
```

Responsive: CSS grid `grid-template-columns: 320px 1fr 420px` on wide; collapses to a single column stack `<900px`. Right-panel readouts use `display:flex; flex-wrap:wrap`. No external CSS/JS. Sliders update the model on `input`; render is throttled with `requestAnimationFrame`.

Readout field lists (exactly as specified):
- **Run A:** baseline stability score · correction status · decoder strain status · correlation risk · public claim boundary · residual pressure warning · model-internal ceiling.
- **Run B:** field stability score · P_system profile · P_unknown honesty reservoir · ECS · hard invariant flags · settlement authority · recommended action · model-internal ceiling.
- **Run C:** full-stack stabilization score · diamond gate capacity · shell handoff status · omnidirectional relief status · RAM learning state · immune capture state · cryptobiotic encapsulation state · resource-truth burden · theoretical qubit-equivalent stabilization ceiling · recommended action.

---

## 8. Visual model description

A single inline `<svg>` re-rendered per tick; the run toggle swaps which layer group is drawn.

- **Run A — flat lattice.** A square grid of qubit-equivalent nodes. Node color = local pressure heat (green→amber→red) computed from a smooth function of `P_system` plus a fixed deterministic spatial pattern (sine of node index, no randomness) so the field reads as "pressure spreading." No gates, no shells. High pressure → red bleed across the lattice; correction status overlaid as a banner.

- **Run B — trace-tagged lattice.** Same grid, but nodes carry small "trace capsule" tags; an **Evidence Gate** overlay (a vertical settlement bar) sits on the field. Nodes that violate an invariant get an outline ring; scope-bound region is drawn as a dashed boundary box labeled with the operation type. Color still encodes pressure but with settlement annotations.

- **Run C — concentric hexshells.** `shellCount` nested hexagons drawn from outer→inner. Between each adjacent shell, **diamond gates** (rotated squares) sit on the shell vertices; `gateDensity` controls how many vertices carry a gate. Active **routing pathways** are drawn as lines fanning omnidirectionally from saturated regions toward open gates (more lines when `routingEfficiency` is high). Gate fill encodes per-gate decision: pass (green), tag (cyan), quarantine (red), encapsulate (violet), fail-closed (grey). The innermost shell shows the protected trace field. A small RAM ring and an immune-capture marker animate (CSS only) when those states are active.

All geometry is computed deterministically from controls; the only motion is CSS pulse/opacity transitions, never data-affecting.

---

## 9. JSON packet schema

`schema_version: "hir-oam-review-packet/2"`. Exact top-level keys (as requested), filled from `derived`:

```jsonc
{
  "artifact_name": "Stabilizing Beyond 105 Qubits Instrument",
  "version": "0.2.0",
  "schema_version": "hir-oam-review-packet/2",
  "boundary_statement": "Public-review structural instrument only…",
  "timestamp": "2026-…Z",
  "input_controls": { "shared": {…}, "runC": {…}, "operationType": "…" },
  "shared_pressure_field": {
    "factors": { "T":…, "Q":…, "R":…, "G":… },
    "S_field": …, "display_A_score": …
  },
  "run_a_public_constraint_backtrace": {
    "stability_score": …, "correction_status": "…", "decoder_strain_status": "…",
    "correlation_risk": "…", "public_claim_boundary": "…",
    "residual_pressure_warning": "…", "model_internal_ceiling": …
  },
  "run_b_hir_oam_encapsulated": {
    "field_stability_score": …, "settlement_authority": "…",
    "recommended_action": "…", "state": "…", "model_internal_ceiling": …
  },
  "run_c_full_hir_architecture": {
    "full_stack_score": …, "S_full_raw": …, "S_full_norm": …,
    "shell_handoff_status": "…", "omnidirectional_relief_status": "…",
    "ram_learning_state": "…", "immune_capture_state": "…",
    "state": "…", "recommended_action": "…",
    "theoretical_qubit_equivalent_ceiling": …
  },
  "p_system_profile": { "P_lattice":…, …, "P_unknown":…, "P_system":…, "P_total":… },
  "p_unknown": …,
  "evidence_conversion_score": { "ECS": …, "components": {…} },
  "hard_invariant_flags": ["PUBLIC_OVERREACH", …],
  "diamond_gate_profile": { "DG":…, "GateCapacity":…, "gateDensity":…, "saturationMargin":… },
  "shell_profile": { "shellCount":…, "ShellMultiplier":…, "RecoveryFactor":… },
  "ram_learning_profile": { "RAM":…, "state":"…" },
  "immune_capture_profile": { "IM":…, "state":"…", "quarantined": true|false },
  "cryptobiotic_encapsulation_state": "OPEN|HELD|…|MUST STOP",
  "uwc_resource_truth_profile": { "UWC":…, "thermal_burden":…, "visibility":…, "penalty_applied": bool },
  "theoretical_qubit_equivalent_ceiling": …,
  "settlement_authority": "SETTLED (scope-bound)|CONDITIONAL|WITHHELD",
  "recommended_action": "…",          // overall, from highest-stakes run
  "public_claim_boundary": "…",
  "claims_not_made": [ "No physical qubits stabilized", "No QEC replacement", … ]
}
```

`timestamp` is the **only** non-deterministic field and is generated solely at export. Copy uses `navigator.clipboard.writeText`; Download builds a `Blob` and an object-URL anchor.

---

## 10. Boundary language

Verbatim strings baked into the build (header boundary box + Sections 1, 12, 13):

- Boundary box: *"Public-review structural instrument only. Not quantum hardware control. Not direct qubit measurement. Not QEC replacement. Not a Google / Willow product claim. Public constraints only. Run C is a theoretical HIR architecture model, not a hardware validation."*
- `claims_not_made` array: no physical qubits are stabilized; no quantum error correction is performed or replaced; no hardware is controlled or measured; no Google / Willow endorsement, access, or product relationship; "ceiling" values are **model-internal / theoretical qubit-equivalent** only; all results are bounded to the declared operation scope.

Output naming is fixed: the scaling result is always rendered as **"theoretical qubit-equivalent stabilization ceiling"** or **"model-internal stabilization ceiling,"** never "qubits stabilized."

---

## 11. Suggested next-step implementation plan (single-file static HTML)

1. **Skeleton** — one `index.html`; `<style>` with CSS variables for theme (dark instrument palette, per-run accent), `<body>` with header, boundary box, dashboard grid, export bar, sections, single `<script>`.
2. **State + controls** — declare `controls` object with defaults; generate sliders from a config array (label, key, min/max/step, direction tooltip) so adding a control is one line. Bind `input` listeners → mutate `controls` → schedule render.
3. **`compute(controls)`** — pure function implementing §4/§5/§6. Unit-checkable by hand. Returns `derived`.
4. **`render(derived)`** — write the three readout panels and the SVG. Keep DOM writes out of `compute`.
5. **SVG layers** — three draw functions (`drawLatticeA`, `drawLatticeB`, `drawHexshellC`) sharing a node-grid helper; run toggle picks one. All geometry deterministic.
6. **Export** — `buildPacket(controls, derived)` → JSON; wire Copy and Download buttons; stamp `timestamp` here only.
7. **Sections 1–13** — static long-form copy with the boundary language from §10.
8. **QA pass** — verify determinism (same inputs → identical packet sans timestamp), responsive collapse `<900px`, no external requests, no `Math.random` in `compute`, and that no string anywhere claims physical qubit stabilization.

No frameworks, no build step, no network calls — drops straight into a static Hugging Face Space.