import { useState, useEffect, useCallback, useRef } from “react”; import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, ScatterChart, Scatter, Cell, ReferenceLine } from “recharts”; // ── TOYRIF ENGINE (JS port of the Python baseline) ────────────────────────── function seededRng(seed) { let s = seed >>> 0; return () => { s ^= s << 13; s ^= s >> 17; s ^= s << 5; const u = (s >>> 0) / 4294967296; // Box-Muller return null; // placeholder — use lcg below }; } class RNG { constructor(seed = 42) { this.seed = (seed ^ 0x5a4d) >>> 0; } next() { this.seed = (Math.imul(1664525, this.seed) + 1013904223) >>> 0; return this.seed / 4294967296; } normal(mean = 0, std = 1) { const u1 = Math.max(this.next(), 1e-10); const u2 = this.next(); return mean + std * Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2); } int(max) { return Math.floor(this.next() * max); } } function movingAverage(arr, k = 5) { if (arr.length < k) return arr.length ? [arr.reduce((a, b) => a + b, 0) / arr.length] : []; const out = []; for (let i = k - 1; i < arr.length; i++) { let s = 0; for (let j = 0; j < k; j++) s += arr[i - j]; out.push(s / k); } return out; } function nanMean(arr) { const v = arr.filter(x => isFinite(x)); return v.length ? v.reduce((a, b) => a + b, 0) / v.length : NaN; } function classify(W, R, C, decoherence) { if (W.length < 4) return “insufficient_data”; const tail = n => arr => arr.slice(-Math.min(n, arr.length)); const diff = arr => arr.slice(1).map((v, i) => v - arr[i]); const wobble_slope = nanMean(diff(tail(10)(W))); const coherence_slope = nanMean(diff(tail(10)(C))); const recovery_recent = nanMean(tail(10)(R).filter(isFinite)); const peak_c_idx = C.indexOf(Math.max(…C)); const peaked_then_lost = ( peak_c_idx > 2 && peak_c_idx < C.length - 2 && C[peak_c_idx] - C[0] > 0.05 && C[C.length - 1] < C[peak_c_idx] - 0.04 ); if (!decoherence) { if (wobble_slope < 0 && recovery_recent > 0 && coherence_slope > 0) return “stable”; return “near_stable”; } if (peaked_then_lost && recovery_recent > -0.01) return “prophetic_failure”; return “failure”; } function runOnce({ T = 120, alpha = 0.18, noise_std = 0.06, tau = 20, phi = 0.67, sigma = 0.08, rng }) { let x = rng.normal(0, 0.8); let x_prev = x; const X = [x], W = [], R = [], C = []; let decoherence = false, decoherence_reason = null, decoherence_t = null; for (let t = 1; t <= T; t++) { const noise = rng.normal(0, noise_std); x = x + alpha * (-x) + noise; const w = Math.abs(x - x_prev); const c = 1.0 / (1.0 + Math.abs(x)); const r = W.length === 0 ? NaN : -(w - W[W.length - 1]); X.push(x); W.push(w); C.push(c); R.push(r); x_prev = x; ``` if (Math.abs(x) > phi) { decoherence = true; decoherence_reason = "corridor"; decoherence_t = t; break; } if (W.length >= tau) { const slice = W.slice(-tau); if (slice.reduce((a, b) => a + b, 0) / tau >= sigma) { decoherence = true; decoherence_reason = "wobble_window"; decoherence_t = t; break; } } ``` } const H = movingAverage(W, 5); const cls = classify(W, R, C, decoherence); return { X, W, R, C, H, decoherence, decoherence_reason, decoherence_t, classification: cls }; } function runSweep({ n_runs = 200, T = 120, alpha = 0.18, noise_std = 0.06, tau = 20, phi_values = [0.35, 0.50, 0.67, 0.85, 1.10], sigma_values = [0.04, 0.06, 0.08, 0.10, 0.14], seed = 42, onProgress }) { const masterRng = new RNG(seed); const results = []; const total_cells = phi_values.length * sigma_values.length; let done = 0; for (const phi of phi_values) { for (const sigma of sigma_values) { const counts = { stable: 0, near_stable: 0, prophetic_failure: 0, failure: 0, insufficient_data: 0 }; const hums = [], c_slopes = []; ``` for (let i = 0; i < n_runs; i++) { const rng = new RNG(masterRng.int(1_000_000_000)); const out = runOnce({ T, alpha, noise_std, tau, phi, sigma, rng }); counts[out.classification]++; if (out.H.length) hums.push(out.H.reduce((a, b) => a + b, 0) / out.H.length); if (out.C.length > 1) { const slopes = out.C.slice(1).map((v, i) => v - out.C[i]); c_slopes.push(slopes.reduce((a, b) => a + b, 0) / slopes.length); } } const total = Object.values(counts).reduce((a, b) => a + b, 0); results.push({ phi, sigma, stable_pct: counts.stable / total, near_stable_pct: counts.near_stable / total, prophetic_failure_pct: counts.prophetic_failure / total, failure_pct: counts.failure / total, avg_hum: hums.length ? hums.reduce((a, b) => a + b, 0) / hums.length : NaN, avg_c_slope: c_slopes.length ? c_slopes.reduce((a, b) => a + b, 0) / c_slopes.length : NaN, }); done++; if (onProgress) onProgress(done / total_cells); } ``` } return results; } // ── SINGLE RUN for trajectory view ────────────────────────────────────────── function runSingle(phi, sigma, seed) { const rng = new RNG(seed); return runOnce({ T: 120, alpha: 0.18, noise_std: 0.06, tau: 20, phi, sigma, rng }); } // ── COLOR HELPERS ───────────────────────────────────────────────────────────── const CLS_COLOR = { stable: “#00e5a0”, near_stable: “#ffe066”, prophetic_failure: “#ff8c42”, failure: “#ff3d6e”, insufficient_data: “#555”, }; function lerp(a, b, t) { return a + (b - a) * t; } function pctColor(v) { // 0 = #1a1a2e, 1 = #00e5a0 const r = Math.round(lerp(0x1a, 0x00, v)); const g = Math.round(lerp(0x1a, 0xe5, v)); const b2 = Math.round(lerp(0x2e, 0xa0, v)); return `rgb(${r},${g},${b2})`; } function humColor(v, min, max) { const t = max === min ? 0.5 : 1 - (v - min) / (max - min); // lower hum = better return `hsl(${Math.round(lerp(0, 150, t))},80%,45%)`; } // ── COMPONENTS ──────────────────────────────────────────────────────────────── const PHI_VALUES = [0.35, 0.50, 0.67, 0.85, 1.10]; const SIGMA_VALUES = [0.04, 0.06, 0.08, 0.10, 0.14]; function HeatGrid({ data, metric, label, colorFn, fmt = v => (v * 100).toFixed(1) + “%” }) { if (!data.length) return null; const vals = data.map(d => d[metric]).filter(isFinite); const min = Math.min(…vals), max = Math.max(…vals); return (

{label}

φ \ σ

{SIGMA_VALUES.map(s => (

{s}

))} {PHI_VALUES.map(phi => ( <>

{phi}

{SIGMA_VALUES.map(sigma => { const row = data.find(d => d.phi === phi && d.sigma === sigma); const v = row ? row[metric] : NaN; const bg = isFinite(v) ? colorFn(v, min, max) : “#111”; return (

{isFinite(v) ? fmt(v) : “—”}

); })} ))}

); } function TrajectoryPanel({ phi, sigma }) { const [seed, setSeed] = useState(42); const result = runSingle(phi, sigma, seed); const { X, W, R, C, H, classification, decoherence, decoherence_reason, decoherence_t } = result; const tLen = X.length; const xData = X.map((v, i) => ({ t: i, x: +v.toFixed(4) })); const wData = W.map((v, i) => ({ t: i + 1, w: +v.toFixed(4) })); const cData = C.map((v, i) => ({ t: i + 1, c: +v.toFixed(4) })); const hData = H.map((v, i) => ({ t: i + 4, h: +v.toFixed(4) })); const rData = R.filter(isFinite).map((v, i) => ({ t: i + 2, r: +v.toFixed(4) })); const cls = classification; const clsColor = CLS_COLOR[cls] || “#aaa”; return (

TRAJECTORY φ={phi} σ={sigma}

{cls.toUpperCase().replace(”_”, “ “)} {decoherence && ( ✗ {decoherence_reason} @ t={decoherence_t} )}

```

{/* X(t) */}

X(t) — STATE

{/* C(t) */}

C(t) — COHERENCE PROXY

{/* W(t) + H(t) */}

W(t) — WOBBLE / H(t) — HUM

{/* R(t) */}

R(t) — LOCAL RECOVERY

``` ); } function PhiSlicePlot({ data, sigma }) { const filtered = PHI_VALUES.map(phi => { const row = data.find(d => d.phi === phi && d.sigma === sigma); return row ? { phi, …row } : null; }).filter(Boolean); return (

Phi Slice (σ={sigma}) — Wall signal search

); } // ── MAIN APP ────────────────────────────────────────────────────────────────── export default function App() { const [sweepData, setSweepData] = useState([]); const [running, setRunning] = useState(false); const [progress, setProgress] = useState(0); const [nRuns, setNRuns] = useState(200); const [selectedPhi, setSelectedPhi] = useState(0.67); const [selectedSigma, setSelectedSigma] = useState(0.08); const [sliceSigma, setSliceSigma] = useState(0.08); const workerRef = useRef(null); const runSweepAsync = useCallback(() => { setRunning(true); setProgress(0); // Run in chunks via setTimeout to keep UI responsive setTimeout(() => { const results = runSweep({ n_runs: nRuns, phi_values: PHI_VALUES, sigma_values: SIGMA_VALUES, seed: 42, onProgress: p => setProgress(p), }); setSweepData(results); setRunning(false); }, 50); }, [nRuns]); useEffect(() => { runSweepAsync(); }, []); const humVals = sweepData.map(d => d.avg_hum).filter(isFinite); const humMin = Math.min(…humVals), humMax = Math.max(…humVals); return (

``` {/* Header */}

TOYRIF

RESONANCE INTEGRITY FIELD · DIAGNOSTIC SWEEP

n_runs

{/* Progress bar */} {running && (

)} {sweepData.length > 0 && ( <> {/* Legend */}

{Object.entries(CLS_COLOR).filter(([k]) => k !== "insufficient_data").map(([k, c]) => (

{k.toUpperCase().replace("_", " ")}

))}

{/* 4 heat grids */}

pctColor(v)} fmt={v => (v * 100).toFixed(0) + "%"} />

{ const t = max === min ? 0 : (v - min) / (max - min); return `hsl(${Math.round(30 - t * 30)},90%,${Math.round(20 + t * 35)}%)`; }} fmt={v => (v * 100).toFixed(0) + "%"} />

humColor(v, min, max)} fmt={v => v.toFixed(3)} />

{ const t = max === min ? 0.5 : (v - min) / (max - min); return `hsl(${Math.round(t * 150)},70%,35%)`; }} fmt={v => v.toFixed(4)} />

{/* Phi slice plot */}

σ slice: {SIGMA_VALUES.map(s => ( ))}

{[["#00e5a0", "stable"], ["#ff8c42", "prophetic_fail"], ["#ffe066", "near_stable"], ["#ff3d6e", "failure"]].map(([c, l]) => (

{l}

))}

{/* Trajectory inspector */}

TRAJECTORY INSPECTOR

φ: {PHI_VALUES.map(p => ( ))}

σ: {SIGMA_VALUES.map(s => ( ))}

{/* Raw table */}

RAW SWEEP TABLE

{["φ", "σ", "stable%", "near_stable%", "proph_fail%", "fail%", "avg_hum", "avg_c_slope"].map(h => ( ))} {sweepData.map((row, i) => ( { setSelectedPhi(row.phi); setSelectedSigma(row.sigma); }}> ))}

{h}
{row.phi}	{row.sigma}	{(row.stable_pct * 100).toFixed(1)}%	{(row.near_stable_pct * 100).toFixed(1)}%	{(row.prophetic_failure_pct * 100).toFixed(1)}%	{(row.failure_pct * 100).toFixed(1)}%	{isFinite(row.avg_hum) ? row.avg_hum.toFixed(4) : "—"}	0 ? "#00e5a0" : "#ff3d6e" }}>{isFinite(row.avg_c_slope) ? row.avg_c_slope.toFixed(5) : "—"}

)} {/* Footer */}

TOYRIF v1.0 · W=wobble R=recovery H=hum C=coherence · CLICK TABLE ROW → INSPECT TRAJECTORY

``` ); }