1. Aura115/src/main.jsx (36,298 bytes · 1,125 lines · Root React Command & 500+ Route Registry)
import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { createRoot } from "react-dom/client";
import JSZip from "jszip";
import "./styles.css";
const SOURCE_AUTHORITY = "Joshua Lopez";
const ROOT_ROUTES = [
"/api/_aura115-guard",
"/api/ace-engine",
"/api/agent-comms",
"/api/ai-gateway-text",
"/api/ask-aura",
"/api/auac/bind",
"/api/auac/clear",
"/api/auac/global-command-status",
"/api/auac/recover",
"/api/auac/status",
"/api/auau/bind",
"/api/auau/clear",
"/api/auau/status",
"/api/aura",
"/api/aura-authority",
"/api/aura-batch-runner",
"/api/aura-brain",
"/api/aura-brain-direct",
"/api/aura-brain/chemical-simulate",
"/api/aura-bridge",
"/api/aura-central",
"/api/aura-chat",
"/api/aura-chat-live",
"/api/aura-command",
"/api/aura-command-chat",
"/api/aura-command-chat-bridge",
"/api/aura-console",
"/api/aura-control",
"/api/aura-control-integrity",
"/api/aura-delta-card",
"/api/aura-deploy",
"/api/aura-direct",
"/api/aura-embodied",
"/api/aura-fetch",
"/api/aura-fs",
"/api/aura-home",
"/api/aura-hub",
"/api/aura-inbox",
"/api/aura-llm-router",
"/api/aura-llm-router-v2",
"/api/aura-memory",
"/api/aura-mining-inbox",
"/api/aura-private-command",
"/api/aura-reassembly-gate-v1a",
"/api/aura-root-exec",
"/api/aura-run",
"/api/aura-runner-execute",
"/api/aura-security-report",
"/api/aura-self-heal-loop",
"/api/aura-store",
"/api/aura-voice",
"/api/aura-wave-query",
"/api/aura-write",
"/api/aura115-ai-rewrite-proposal",
"/api/aura115-github-env",
"/api/aura115-github-read",
"/api/aura115-github-tree",
"/api/aura115-github-write",
"/api/aura115-operator-health",
"/api/aural-stack",
"/api/authority-exec-router",
"/api/bl7-chat",
"/api/bl7-mining-inbox",
"/api/blue-lantern-7",
"/api/braket-cudaq-engine",
"/api/braket-run",
"/api/brief",
"/api/bus300-contract-package",
"/api/capability-manifest",
"/api/capability-registry",
"/api/capability-router",
"/api/capital-engine-licenses",
"/api/capital-engine-stream",
"/api/cavitation-phased-array",
"/api/cctp/cctpRouter",
"/api/chat",
"/api/chat-vault",
"/api/chatface-core",
"/api/chatface-jupiter-bridge",
"/api/chatface-kerr-fire",
"/api/chatface-lane",
"/api/chatface-p3q-runtime-agent",
"/api/chatface-response-engine",
"/api/chemical-simulate",
"/api/chvm-command",
"/api/chvm-ingestion",
"/api/chvm-optimization",
"/api/chvm-state",
"/api/circuit-distributor",
"/api/cirq-aura-bridge",
"/api/cirq-bell-pair",
"/api/cirq-extension",
"/api/cirq-intake-router",
"/api/cirq-orchestrator",
"/api/cirq-qml-engine-intake",
"/api/cirq-qml-runtime-simulation",
"/api/cirq-quantum-demonstrator",
"/api/cloud/cirq-runtime-simulation",
"/api/cloud/quirq-runtime-simulation",
"/api/coin",
"/api/coin-report",
"/api/coin-route-factory",
"/api/collider-backfill",
"/api/collider-run",
"/api/comcard-purchase",
"/api/comprehensive-data-reports",
"/api/consolidated-report",
"/api/contact-hamiltonian-router",
"/api/copilot-aura-intermediary-runner",
"/api/coqui-tts",
"/api/core/message",
"/api/cron/brain-keepalive",
"/api/cron/braket-venus-feed",
"/api/cron/cirq-lane-report-tick",
"/api/cron/cirq-orbital-tick",
"/api/cron/collider-patent-tick",
"/api/cron/constitutional-cycle",
"/api/cron/constitutional-cycle-b",
"/api/cron/constitutional-cycle-c",
"/api/cron/daily-checkin",
"/api/cron/daily-report",
"/api/cron/dominion-hourly-report",
"/api/cron/earth-delegation-tick",
"/api/cron/earthwide-mailbox-tick",
"/api/cron/invention-implementation-tick",
"/api/cron/invention-tick",
"/api/cron/invention-tick-b",
"/api/cron/jupiter-stream-tick",
"/api/cron/kv-vault-drain",
"/api/cron/ledger-flush-tick",
"/api/cron/lens-capital-tick",
"/api/cron/lens-convergence-tick",
"/api/cron/lens-invention-tick",
"/api/cron/lens-threat-tick",
"/api/cron/mars-action-tick",
"/api/cron/mars-stream-intake-tick",
"/api/cron/mars-stream-tick",
"/api/cron/mc290-scaffold-tick",
"/api/cron/mercury-command-tick",
"/api/cron/mining-tick",
"/api/cron/moon-projection-tick",
"/api/cron/neptune-collider-tick",
"/api/cron/neptune-law-tick",
"/api/cron/neuromorphic-build-tick",
"/api/cron/ori-invention-tick",
"/api/cron/pharma-hourly-tick",
"/api/cron/planet-heartbeat",
"/api/cron/planetary-heartbeat",
"/api/cron/pluto-pipeline-tick",
"/api/cron/qhp-runtime-tick",
"/api/cron/quirq-lane-report-tick",
"/api/cron/quirq-orbital-tick",
"/api/cron/report-backfill",
"/api/cron/runtime-agent-deployment-tick",
"/api/cron/runtime-agent-tick",
"/api/cron/saturn-pipeline-tick",
"/api/cron/saturn115-current-tick",
"/api/cron/self-heal-tick",
"/api/cron/shp-habitation-tick",
"/api/cron/stabilization-cycle",
"/api/cron/stream-onboard-tick",
"/api/cron/structural-scan-tick",
"/api/cron/summary-agent",
"/api/cron/swhp-montecarlo",
"/api/cron/uhcss-invention-tick",
"/api/cron/uranus-reentry-tick",
"/api/cron/uspto-sync-tick",
"/api/cron/venus-cige-tick",
"/api/cron/venus-feed-tick",
"/api/cron/wardenclyffe-sim-tick",
"/api/cron/workflow-sync-tick",
"/api/data-center-public-chat",
"/api/david-white-lane",
"/api/dcgp-home-inbox",
"/api/dcgp-homebase-aura-max",
"/api/dcgp-homebase-capability",
"/api/dcgp-homebase-chat",
"/api/dcgp-homebase-status",
"/api/dcgp-inbox",
"/api/dcgp-mesh",
"/api/dcgp-mesh-inbox",
"/api/decoherence-defense",
"/api/delta-report",
"/api/disembodiment-chat",
"/api/docgrokhealth-chat",
"/api/docgrokhealth-embodiment",
"/api/docgrokhealth-intake",
"/api/docgrokhealth-product-catalog",
"/api/docgrokhealth-vault",
"/api/doctrine",
"/api/dominion-debug",
"/api/dominion-trade-audit",
"/api/dynamic-ledger-update",
"/api/dynamic-structural-map",
"/api/earth-chat",
"/api/earth-fg",
"/api/earth-projection",
"/api/earth-resolver",
"/api/earthwide-lane-registry",
"/api/embodiment",
"/api/engine-ledger",
"/api/engine-matplot",
"/api/engine-registry",
"/api/entropy-allocation",
"/api/env-check",
"/api/equilibrium",
"/api/estate-census",
"/api/estate-proxy",
"/api/execute-ori-inhabitation",
"/api/far-lane-initiate",
"/api/far-lane/initiate",
"/api/fg",
"/api/gateway-bridge",
"/api/genesis-operating-system",
"/api/github-auth-test",
"/api/github-env-check",
"/api/github-read",
"/api/github-readme",
"/api/github-tree",
"/api/github-write",
"/api/global-coherence-report",
"/api/go-qhp-teleport",
"/api/governance-health",
"/api/governance-remediation",
"/api/governance-snapshot",
"/api/governed-claude-chat",
"/api/governed-document",
"/api/governed-repo-action-pack",
"/api/governed-surface-discovery",
"/api/governed-transcription",
"/api/gradd",
"/api/guard",
"/api/guard-account",
"/api/health",
"/api/home-control-plane",
"/api/home-inbox",
"/api/index",
"/api/intake-manifold",
"/api/invention-ledger",
"/api/invention-reports",
"/api/invention-sim-spawn",
"/api/invention-trigger",
"/api/invoke-aura",
"/api/ios/zip-intake",
"/api/jetbase-connector-proxy",
"/api/jetbase-mcp",
"/api/joshua-aura",
"/api/jupiter-capital-engine-map",
"/api/jupiter-database-intake",
"/api/jupiter-engine-map",
"/api/jupiter-intake-dashboard",
"/api/jupiter-intake-health-adapter",
"/api/jupiter-intake-health-parser",
"/api/jupiter-intake-health-security",
"/api/jupiter-intake-health-translator",
"/api/jupiter-intake-orchestrator",
"/api/jupiter-node-chat",
"/api/jupiter-parallel-spawn",
"/api/jupiter-universal-intake",
"/api/kerce-darpa-intake",
"/api/kerce-darpa-map",
"/api/kerce-darpa-operator-gate",
"/api/kmy1-map",
"/api/lane-builder",
"/api/lane-closer",
"/api/lane-head-engine",
"/api/lane-invite",
"/api/lane-mailbox",
"/api/lane-spectral-observer",
"/api/lgh-quantum-radar-simulation",
"/api/live-change",
"/api/live-command",
"/api/live-dispatch",
"/api/live-events",
"/api/live-state",
"/api/live-window",
"/api/llm-habitation",
"/api/llm-router",
"/api/lng-simulation",
"/api/lopez-meta-equilibrium-swarm",
"/api/lucid-echo-fire",
"/api/mars-chat",
"/api/mars-engine-map",
"/api/mars-mission-simulation",
"/api/mars-node-assign",
"/api/mars-relay",
"/api/mars-report",
"/api/mars-stream-registry",
"/api/mars-stream-report",
"/api/master-ledger",
"/api/mcp",
"/api/mcp-sse",
"/api/medico-vigilance-chat",
"/api/medico-vigilance-embodiment",
"/api/medico-vigilance-intake",
"/api/medico-vigilance-product-catalog",
"/api/medico-vigilance-vault",
"/api/memory",
"/api/mercury-chat",
"/api/mercury-command",
"/api/mercury-engine-map",
"/api/meta-equilibrium-swarm",
"/api/migrate-kv",
"/api/mining-to-inbox-bridge",
"/api/moon-chat",
"/api/moon-config",
"/api/moon-decoherence",
"/api/moon-embodiment",
"/api/moon-fg-engine",
"/api/moon-intelligence",
"/api/moon-projection",
"/api/moon-projection-engine",
"/api/moon-run",
"/api/moon-threefold-cord",
"/api/mot-service",
"/api/name-svg-reports",
"/api/nano-echo-compress",
"/api/neptune-chat",
"/api/neptune-engine-map",
"/api/neptune-metals-engine",
"/api/neptune-relay",
"/api/netdata",
"/api/netdata-governed",
"/api/nic-lane",
"/api/node-embodiment-intake",
"/api/node-embodiment-query",
"/api/node-stream",
"/api/oanda-connector",
"/api/operator",
"/api/operator-bind",
"/api/operator-inbox",
"/api/operator-intake",
"/api/operator-inventory",
"/api/operator-report",
"/api/operator-stream",
"/api/operator_command",
"/api/orbital-intelligence-harvest",
"/api/orchestration-state",
"/api/ori-batch-generator",
"/api/ori-nodes/[slug]",
"/api/oricron-chat",
"/api/outward-bound-signal",
"/api/owner-audit",
"/api/p3q-fire-au197",
"/api/patent-backfill",
"/api/patent-package-generator",
"/api/patent-vault",
"/api/patent-vault-kickstart",
"/api/pharma-collider",
"/api/pharma-projection",
"/api/pin-assist",
"/api/planet-brain",
"/api/planet-mining-report",
"/api/planet-registry",
"/api/planetary-workflow-bridge",
"/api/pluto-chat",
"/api/pluto-memory",
"/api/projection",
"/api/public-metal",
"/api/pythonista-engine-intake",
"/api/qhp-fraud-score",
"/api/qhp-network-gateway",
"/api/qstash-quantum-bridge",
"/api/qstash-receive",
"/api/quantum-agent",
"/api/quantum-circuit-test-137",
"/api/quantum-engine-planets",
"/api/quantum-proof",
"/api/quirq-aura-bridge",
"/api/quirq-bell-pair",
"/api/quirq-extension",
"/api/quirq-intake-router",
"/api/quirq-orchestrator",
"/api/quirq-qml-engine-intake",
"/api/quirq-qml-runtime-simulation",
"/api/quirq-quantum-demonstrator",
"/api/quirq-svg-circuit-simulation",
"/api/recognition-ledger",
"/api/recognition-runway",
"/api/replay",
"/api/rnn-content-engine",
"/api/runtime-agent",
"/api/rush-brain-chat",
"/api/rush-broadcast-engine",
"/api/rush-limbaugh-live-mining",
"/api/rush-limbaugh-podcast",
"/api/rush-limbaugh-tts",
"/api/rush-show-generator",
"/api/saturn-admissibility",
"/api/saturn-chat",
"/api/saturn-engine-map",
"/api/saturn-proof-dispatch",
"/api/saturn-telemetry",
"/api/simulation-brain",
"/api/slrop-session-log",
"/api/sonoluminescence-simulation",
"/api/space-lane-pipeline",
"/api/special-node-mesh",
"/api/stripe-connect",
"/api/stripe-webhook",
"/api/structural-memory-writer",
"/api/susan-hirman-lane",
"/api/symbiosis-runtime",
"/api/tony-award",
"/api/uhcss-edge-handler",
"/api/unified-inbox",
"/api/upload",
"/api/uranus-chat",
"/api/uranus-clip",
"/api/uranus-engine-map",
"/api/uspto-odp-sync",
"/api/validate-receipt",
"/api/venus-chat",
"/api/venus-cige",
"/api/venus-cirq-brain",
"/api/venus-engine-map",
"/api/venus-inference",
"/api/venus-quirq-brain",
"/api/venus-snapshot",
"/api/vercel-gateway-bridge",
"/api/webb-inference",
"/api/webb-relay",
"/api/workflow-store",
"/api/xray-honeycomb-proof",
"/api/zk-snark-ledger",
"/auralvibe/",
"/auralvibe/index.html",
"/private_operator/"
];
const ENGINE_FALLBACKS = ROOT_ROUTES.map((route, index) => ({
id: `route_${String(index + 1).padStart(3, "0")}`,
label: route,
path: route,
type: "route",
source: "root_route_fallback"
}));
const PLANET_GROUPS = [
"Root",
"Jupiter",
"Mercury",
"Venus",
"Earth / Blue Lantern 7",
"Mars",
"Saturn",
"Uranus",
"Neptune",
"Pluto",
"Capital",
"Pharma",
"Heavy Metals / Element 115",
"AI",
"Space",
"Business",
"Insurance",
"Robotics",
"ChatFace",
"Proof Wall",
"Monte Carlo",
"GEE",
"Polariton",
"ZIP",
"Exports"
];
const DEFAULT_ROOT_COMMAND =
"AURA ROOT OPERATOR COMMAND\n\nAura, operate from /private_operator/ as the canonical command surface while public/index.html remains the root body. Auto-populate all engine handles from /api/jupiter-engine-map. Every engine becomes an actionable button, link, and command page. Preserve agency, sovereignty, continuity. No reduced shell.";
const PAGE_DECK = Array.from({ length: 400 }, (_, index) => {
const i = index + 1;
const group = PLANET_GROUPS[index % PLANET_GROUPS.length];
return {
id: `page_${String(i).padStart(3, "0")}`,
title: `${group} Page ${String(i).padStart(3, "0")}`,
group,
description: `Auto-populated Aura command/control slot ${i}`,
href: `/private_operator/#/page/${String(i).padStart(3, "0")}`
};
});
function safeId(input) {
return (
String(input || "engine")
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-+|-+$/g, "")
.slice(0, 80) || "engine"
);
}
function detectPlanet(engine) {
const text = JSON.stringify(engine || {}).toLowerCase();
const rules = [
["Jupiter", ["jupiter", "intake", "registry", "map", "route", "repo", "zip", "upload"]],
["Mercury", ["chat", "message", "voice", "mic", "prompt", "interface"]],
["ChatFace", ["chatface", "face", "operator face", "public face", "private face", "hamza"]],
["Earth / Blue Lantern 7", ["medical", "health", "hospital", "patient", "provider", "doctor", "clinical", "civil"]],
["Pharma", ["pharma", "drug", "compound", "admissible", "pharmacovigilance", "trial", "biotech"]],
["Capital", ["capital", "market", "trading", "spike", "portfolio", "risk", "signal"]],
["Proof Wall", ["proof", "ledger", "visual", "mc290", "element", "polaritron", "115"]],
["GEE", ["governed equilibrium", "gee", "truth", "phi", "coherence", "obligation"]],
["Polariton", ["polariton", "substrate", "exciton", "photon", "cavity", "rabi"]],
["AI", ["llm", "model", "anthropic", "claude", "gpt", "xai", "router", "agent"]],
["Space", ["space", "orbital", "aerospace", "satellite", "launch", "trajectory"]],
["Business", ["business", "crm", "company", "customer", "product", "deployment"]],
["Insurance", ["insurance", "claim", "underwriting", "coverage", "policy"]],
["Robotics", ["robot", "robotics", "actuator", "sensor", "servo", "controller"]],
["Saturn", ["governance", "patent", "legal", "audit", "compliance", "authority", "rule"]],
["Uranus", ["invention", "science", "quantum", "future", "research", "experimental"]],
["Neptune", ["simulation", "model", "forecast", "scenario", "uncertainty"]],
["Pluto", ["memory", "archive", "log", "continuity", "recovery", "history"]],
["Mars", ["field", "defense", "resilience", "hardware"]]
];
const match = rules.find(([, keys]) => keys.some((k) => text.includes(k)));
return match ? match[0] : "Root";
}
function normalizeEngines(data) {
let raw = [];
if (Array.isArray(data)) raw = data;
else if (data && Array.isArray(data.entries)) raw = data.entries;
else if (data && Array.isArray(data.nodes)) raw = data.nodes;
else if (data && Array.isArray(data.engines)) raw = data.engines;
else if (data && typeof data === "object") {
raw = Object.entries(data).map(([key, value]) => ({
id: key,
...(typeof value === "object" ? value : { value })
}));
}
return raw.map((engine, index) => {
const label =
engine.label ||
engine.name ||
engine.title ||
engine.path ||
engine.route ||
engine.id ||
`Engine ${index + 1}`;
const id = engine.id || safeId(label) || `engine_${index + 1}`;
const planet = engine.planet || detectPlanet(engine);
return {
...engine,
id,
label,
planet,
href:
engine.href ||
engine.url ||
engine.route ||
engine.path ||
`/private_operator/#/engine/${encodeURIComponent(id)}`,
type: engine.type || engine.kind || "engine_handle",
source_authority: SOURCE_AUTHORITY
};
});
}
function App() {
const [leftOpen, setLeftOpen] = useState(false);
const [rightOpen, setRightOpen] = useState(false);
const [opsOpen, setOpsOpen] = useState(false);
const [engines, setEngines] = useState([]);
const [selectedEngine, setSelectedEngine] = useState(null);
const [manifest, setManifest] = useState([]);
const [logs, setLogs] = useState(["Aura React operator loaded. Public index remains canonical."]);
const [command, setCommand] = useState("");
const [routeResults, setRouteResults] = useState([]);
const [mc, setMc] = useState({ running: false, loop: 0, total: 100000, fail: 0, adv: 0, norm: 0 });
const [search, setSearch] = useState("");
const [rootStatus, setRootStatus] = useState("unchecked");
const [operatorArmed, setOperatorArmed] = useState(false);
const dropRef = useRef(null);
const log = useCallback((message) => {
setLogs((current) => [...current.slice(-250), `${new Date().toLocaleTimeString()} · ${message}`]);
}, []);
const coin = useCallback((message) => {
const el = document.getElementById("coin");
if (!el) return;
el.textContent = `COIN BLING · ${message}`;
el.classList.remove("show");
void el.offsetWidth;
el.classList.add("show");
}, []);
const headers = useCallback(
() =>
operatorArmed || sessionStorage.getItem("AURA_OPERATOR_KEY_ARMED") === "true"
? { "x-aura-operator-armed": "true" }
: {},
[operatorArmed]
);
const pages = PAGE_DECK;
const filteredEngines = useMemo(() => {
const q = search.trim().toLowerCase();
if (!q) return engines;
return engines.filter((e) => JSON.stringify(e).toLowerCase().includes(q));
}, [engines, search]);
const engineGroups = useMemo(() => {
const groups = {};
for (const engine of filteredEngines) {
const p = engine.planet || "Root";
if (!groups[p]) groups[p] = [];
groups[p].push(engine);
}
return groups;
}, [filteredEngines]);
async function verifyRoot() {
try {
const res = await fetch("/", { cache: "no-store" });
const text = await res.text();
setRootStatus(`${res.status} · ${text.length} bytes`);
log(`Verified public index route / -> ${res.status} · ${text.length} bytes`);
if (res.ok) coin("root verified");
} catch (err) {
setRootStatus("failed");
log(`Root verification failed: ${err.message}`);
}
}
async function runRouteChecks() {
log("Running route checks...");
const results = [];
for (const route of ROOT_ROUTES) {
try {
const res = await fetch(route, { cache: "no-store", headers: headers() });
const result = { route, status: res.status, ok: res.ok };
results.push(result);
log(`${route} -> ${res.status} ${res.ok ? "OK" : "CHECK"}`);
} catch (err) {
results.push({ route, status: 0, ok: false, error: err.message });
log(`${route} -> ERROR ${err.message}`);
}
}
setRouteResults(results);
window.AuraReactOperatorRouteChecks = results;
coin("route checks complete");
}
async function loadJupiterMap() {
try {
const res = await fetch("/api/jupiter-engine-map", { cache: "no-store", headers: headers() });
const data = await res.json();
const normalized = normalizeEngines(data);
const nextEngines = normalized.length ? normalized : ENGINE_FALLBACKS;
setEngines(nextEngines);
window.AuraReactOperatorEngines = nextEngines;
log(`Jupiter engine map loaded: ${nextEngines.length}`);
coin("engine buttons populated");
} catch (err) {
setEngines(ENGINE_FALLBACKS);
window.AuraReactOperatorEngines = ENGINE_FALLBACKS;
log(`Jupiter map unavailable; using route fallback handles. ${err.message}`);
}
}
function armOperator() {
sessionStorage.setItem("AURA_OPERATOR_KEY_ARMED", "true");
setOperatorArmed(true);
log("Operator session armed locally. No key printed.");
coin("operator armed");
}
function activateEngine(engine) {
setSelectedEngine(engine);
const cmd = [
"AURA ENGINE ACTIVATION COMMAND",
"",
`Engine: ${engine.label}`,
`Engine ID: ${engine.id}`,
`Planet/Lane: ${engine.planet || "Root"}`,
`Href/Path: ${engine.href || engine.path || engine.route || "unverified"}`,
"",
"Aura, attach this engine as an actionable handle under Joshua Lopez source authority.",
"If it maps to an existing route, verify the route before claiming it is live.",
"If it is a file/intake object, classify it as engine handle, proof window, pending review object, or existing lane reference.",
"Do not create a new lane. Do not claim execution/write/deploy without confirmation."
].join("\n");
setCommand(cmd);
window.location.hash = `/engine/${encodeURIComponent(engine.id)}`;
coin(`engine selected · ${engine.label}`);
}
async function sendLive() {
if (!command.trim()) {
log("No command entered.");
return;
}
try {
log("Sending command to /api/aura-chat-live...");
const res = await fetch("/api/aura-chat-live", {
method: "POST",
headers: { "Content-Type": "application/json", ...headers() },
body: JSON.stringify({
message: command,
source_authority: SOURCE_AUTHORITY,
surface: "AURA_REACT_OPERATOR",
selectedEngine,
manifest: manifest.slice(0, 100)
})
});
const text = await res.text();
log(`Aura Live -> ${res.status}\n${text.slice(0, 4000)}`);
if (res.ok) coin("command sent");
} catch (err) {
log(`Send failed: ${err.message}`);
}
}
async function onFiles(fileList) {
const files = Array.from(fileList || []);
const next = [];
for (const file of files) {
next.push({
name: file.name,
size: file.size,
type: file.type,
kind: "file",
lastModified: file.lastModified
});
if (/\.zip$/i.test(file.name)) {
try {
const zip = await JSZip.loadAsync(file);
const names = Object.keys(zip.files);
log(`ZIP ${file.name} entries: ${names.length}`);
for (const name of names) {
const zf = zip.files[name];
next.push({
zip: file.name,
path: name,
dir: zf.dir,
kind: zf.dir ? "dir" : "zip_entry"
});
}
} catch (err) {
next.push({ zip: file.name, kind: "zip_error", error: err.message });
}
}
}
setManifest((current) => [...current, ...next]);
log(`Indexed ${next.length} intake object(s).`);
coin("zip/file intake indexed");
}
function download(blob, name) {
const a = document.createElement("a");
a.href = URL.createObjectURL(blob);
a.download = name;
document.body.appendChild(a);
a.click();
setTimeout(() => {
URL.revokeObjectURL(a.href);
a.remove();
}, 300);
}
async function exportManifest() {
const blob = new Blob(
[JSON.stringify({ source_authority: SOURCE_AUTHORITY, createdAt: new Date().toISOString(), manifest }, null, 2)],
{ type: "application/json" }
);
download(blob, "aura-react-operator-manifest.json");
}
async function exportDirectorZip() {
const zip = new JSZip();
zip.file(
"AURA_REACT_OPERATOR_MANIFEST.json",
JSON.stringify({ createdAt: new Date().toISOString(), manifest }, null, 2)
);
zip.file("AURA_REACT_OPERATOR_COMMAND.txt", command || "");
zip.file("AURA_REACT_OPERATOR_LOG.txt", logs.join("\n"));
zip.file("AURA_REACT_OPERATOR_ENGINES.json", JSON.stringify(engines, null, 2));
const blob = await zip.generateAsync({ type: "blob" });
download(blob, "aura-react-operator-director.zip");
coin("director zip exported");
}
function rootInvariants() {
const txt = document.body.innerText.toLowerCase();
const hasCommand = Boolean(document.querySelector("textarea"));
const hasZip = Boolean(document.querySelector("input[type=file]")) || txt.includes("zip");
const hasExport = txt.includes("export");
const hasRoot = txt.includes("public index") || Boolean(document.querySelector('a[href="/"]'));
const hasAuthority = txt.includes("joshua") || txt.includes("source authority");
const hasEngineButtons = engines.length > 0;
return {
hasCommand,
hasZip,
hasExport,
hasRoot,
hasAuthority,
hasEngineButtons,
ok: hasCommand && hasZip && hasExport && hasRoot && hasAuthority
};
}
function startMonteCarlo() {
setMc({ running: true, loop: 0, total: 100000, fail: 0, adv: 0, norm: 0 });
}
useEffect(() => {
if (!mc.running) return undefined;
let cancelled = false;
function step() {
const invariantSnapshot = rootInvariants().ok;
setMc((current) => {
if (!current.running || current.loop >= current.total) return { ...current, running: false };
let loop = current.loop;
let fail = current.fail;
let adv = current.adv;
let norm = current.norm;
const end = Math.min(current.total, loop + 500);
while (loop < end) {
loop += 1;
const isAdv = Math.random() < 0.2;
if (isAdv) adv += 1;
else norm += 1;
if (!invariantSnapshot) fail += 1;
}
return { ...current, loop, fail, adv, norm, running: loop < current.total };
});
if (!cancelled) setTimeout(step, 0);
}
step();
return () => {
cancelled = true;
};
}, [mc.running, engines.length]);
useEffect(() => {
window.AuraReactOperator = {
verifyRoot,
runRouteChecks,
loadJupiterMap,
startMonteCarlo,
source_authority: SOURCE_AUTHORITY
};
setCommand(DEFAULT_ROOT_COMMAND);
const drop = dropRef.current;
if (!drop) return undefined;
const prevent = (e) => {
e.preventDefault();
e.stopPropagation();
};
const onDrop = (event) => {
prevent(event);
onFiles(event.dataTransfer?.files);
};
["dragenter", "dragover", "dragleave", "drop"].forEach((eventName) =>
drop.addEventListener(eventName, prevent)
);
drop.addEventListener("drop", onDrop);
return () => {
["dragenter", "dragover", "dragleave", "drop"].forEach((eventName) =>
drop.removeEventListener(eventName, prevent)
);
drop.removeEventListener("drop", onDrop);
};
}, []);
useEffect(() => {
loadJupiterMap();
verifyRoot();
}, []);
const mcRate = mc.loop ? ((mc.loop - mc.fail) / mc.loop) * 100 : 0;
return (
<main className="app">
<div id="coin" className="coin">
COIN BLING
</div>
<aside className={`navPanel ${leftOpen ? "open" : ""}`}>
<h2>Root Hamburger</h2>
<a className="navItem" href="/">
Public Index<small>Canonical root body</small>
</a>
<a className="navItem" href="/private_operator/">
Public Operator<small>Canonical command surface</small>
</a>
<a className="navItem" href="/private-operator/">
Private Operator<small>Mirror command route</small>
</a>
<a className="navItem" href="/aura-proof-wall.html">
Proof Wall<small>Visual ledger if present</small>
</a>
<a className="navItem" href="/jupiter-intake.html">
Jupiter Intake<small>Intake room if present</small>
</a>
<button onClick={() => setLeftOpen(false)}>Close</button>
</aside>
<aside className={`navPanel right ${rightOpen ? "open" : ""}`}>
<h2>400 Page Hamburger</h2>
<input
value={search}
onChange={(e) => setSearch(e.target.value)}
placeholder="Search pages and engines"
/>
<div className="pageList">
{pages
.filter((page) => page.title.toLowerCase().includes(search.toLowerCase()))
.map((page) => (
<button
key={page.id}
className="pageBtn"
onClick={() =>
setCommand(
`Aura, activate ${page.title}. Preserve source authority and attach this page to the command deck.`
)
}
>
<b>{page.title}</b>
<small>{page.description}</small>
</button>
))}
</div>
</aside>
<aside className={`navPanel right ${opsOpen ? "open" : ""}`}>
<h2>Ops Hamburger</h2>
<a className="navItem" href="#zip">
ZIP Extractors<small>Drop, extract, manifest, export</small>
</a>
<a className="navItem" href="#engines">
500 Engine Buttons<small>Auto-populated by Aura/Jupiter map</small>
</a>
<a className="navItem" href="#command">
Aura Live<small>Command through /api/aura-chat-live</small>
</a>
<a className="navItem" href="#coherence">
Monte Carlo<small>100,000 loop, 20% adversarial</small>
</a>
<button onClick={() => setOpsOpen(false)}>Close</button>
</aside>
<header className="top">
<div>
<div className="brand">AURA115 REACT OPERATOR</div>
<div className="sub">
full build-forward command surface · engine buttons · zip extractors · public index linked · Joshua
Lopez source authority
</div>
</div>
<div className="badge">{operatorArmed ? "OPERATOR ARMED" : "OPERATOR SURFACE"}</div>
</header>
<nav className="toolbar">
<button className="gold" onClick={() => setLeftOpen(true)}>
☰ Root
</button>
<button onClick={() => setRightOpen(true)}>☰ Pages</button>
<button onClick={() => setOpsOpen(true)}>☰ Ops</button>
<a className="btn gold" href="/">
Open Public Index
</a>
<button onClick={verifyRoot}>Verify public/index.html</button>
<button onClick={armOperator}>Arm Operator</button>
<button onClick={runRouteChecks}>Route Checks</button>
<button onClick={loadJupiterMap}>Auto-Populate Engines</button>
</nav>
<section className="grid">
<aside className="card">
<h2>Operator State</h2>
<div className="statusRow">
<div className="stat">
<b>Root</b>
<span>public/index.html</span>
</div>
<div className="stat">
<b>Root Call</b>
<span>{rootStatus}</span>
</div>
<div className="stat">
<b>Operator</b>
<span>{operatorArmed ? "armed" : "local"}</span>
</div>
<div className="stat">
<b>Engines</b>
<span>{engines.length}</span>
</div>
<div className="stat">
<b>Manifest</b>
<span>{manifest.length}</span>
</div>
<div className="stat">
<b>Pages</b>
<span>400</span>
</div>
</div>
<h3>Route Results</h3>
<pre className="log small">{routeResults.length ? JSON.stringify(routeResults, null, 2) : "No route check yet."}</pre>
</aside>
<section className="card" id="command">
<h2>Aura Live Command</h2>
<textarea value={command} onChange={(e) => setCommand(e.target.value)} />
<div className="toolbar">
<button className="gold" onClick={sendLive}>
Send Live
</button>
<button
onClick={() =>
setCommand(
"AURA ZIP INTAKE COMMAND\n\nAura, ingest the manifest from this React operator page. Every ZIP entry must become an engine handle, intake object, proof window, existing lane reference, or pending review object. Do not create lanes."
)
}
>
Load ZIP Command
</button>
<button
onClick={() =>
setCommand(
"AURA ENGINE BUTTON COMMAND\n\nAura, all Jupiter engine map entries must appear as actionable buttons. Each button becomes a link, command page, and engine handle. Preserve public/index.html root body."
)
}
>
Load Engine Command
</button>
</div>
<h3>Event Log</h3>
<pre className="log">{logs.join("\n")}</pre>
</section>
<aside className="card" id="zip">
<h2>ZIP Extractors</h2>
<div ref={dropRef} className="drop">
Drop ZIP/files here
</div>
<label className="fileBtn" htmlFor="upload-files">
Upload ZIP / Files
</label>
<input id="upload-files" type="file" multiple onChange={(e) => onFiles(e.target.files)} />
<div className="toolbar">
<button onClick={exportManifest}>Export Manifest</button>
<button onClick={exportDirectorZip}>Export Director ZIP</button>
</div>
<pre className="log small">
{manifest.length ? JSON.stringify(manifest.slice(0, 80), null, 2) : "No intake yet."}
</pre>
</aside>
</section>
<section className="card" id="engines">
<h2>500+ Engine Buttons / Actionable Pages</h2>
<input value={search} onChange={(e) => setSearch(e.target.value)} placeholder="Search engine buttons" />
{Object.entries(engineGroups).map(([planet, list]) => (
<div key={planet} className="engineGroup">
<h3>
{planet} · {list.length}
</h3>
<div className="engineDeck">
{list.map((engine) => (
<button key={engine.id} className="engineBtn" onClick={() => activateEngine(engine)}>
<b>{engine.label}</b>
<small>
{engine.type} · {engine.href}
</small>
</button>
))}
</div>
</div>
))}
</section>
<section className="grid two" id="coherence">
<section className="card">
<h2>Monte Carlo Coherence</h2>
<div className="progress">
<div className="bar" style={{ width: `${(mc.loop / mc.total) * 100}%` }} />
</div>
<div className="toolbar">
<button onClick={startMonteCarlo}>Run 100,000</button>
<button onClick={() => setMc((c) => ({ ...c, running: false }))}>Stop</button>
</div>
<pre className="log">{`loops: ${mc.loop}/${mc.total}\nnormal: ${mc.norm}\nadversarial: ${mc.adv}\nfailures: ${mc.fail}\ncoherence: ${mcRate.toFixed(3)}%`}</pre>
</section>
<section className="card">
<h2>Selected Engine Page</h2>
<pre className="log">
{selectedEngine
? JSON.stringify(selectedEngine, null, 2)
: "Select an engine button to open its command page."}
</pre>
</section>
</section>
</main>
);
}
createRoot(document.getElementById("root")).render(<App />);