aztrx-cli 0.1.0

package/dist/core/studio.js

@@ -0,0 +1,219 @@
+import * as fs from "fs";
+import * as http from "http";
+import * as path from "path";
+import pc from "picocolors";
+import { BASE_CSS, SEVERITY_COLOR, seismograph } from "./ui.js";
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function send(res, status, contentType, body) {
+    res.writeHead(status, { "Content-Type": contentType });
+    res.end(body);
+}
+function sendFile(res, filePath, contentType) {
+    try {
+        const body = fs.readFileSync(filePath, "utf-8");
+        send(res, 200, contentType, body);
+    }
+    catch {
+        send(res, 404, "text/plain; charset=utf-8", "not found");
+    }
+}
+/**
+ * SSE tail of the run log. Replays the current log from byte 0 (so a studio
+ * opened after a run still shows its history), then pushes new lines as they
+ * land, every 500ms.
+ */
+function sseHandler(req, res, eventsFile) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+    });
+    res.write(`data: ${JSON.stringify({ type: "hello" })}\n\n`);
+    let offset = 0;
+    let closed = false;
+    const tick = () => {
+        if (closed)
+            return;
+        let text = "";
+        try {
+            text = fs.readFileSync(eventsFile, "utf-8");
+        }
+        catch {
+            text = "";
+        }
+        if (text.length > offset) {
+            const chunk = text.slice(offset);
+            offset = text.length;
+            for (const line of chunk.split("\n")) {
+                if (line.trim())
+                    res.write(`data: ${line}\n\n`);
+            }
+        }
+    };
+    const timer = setInterval(tick, 500);
+    tick();
+    req.on("close", () => {
+        closed = true;
+        clearInterval(timer);
+    });
+}
+function dashboardScript() {
+    return `const list = document.getElementById("list");
+const target = document.getElementById("target");
+const foot = document.getElementById("foot");
+const spikes = document.getElementById("spikes");
+const counts = { crash: 0, error: 0, warning: 0 };
+const sevColor = ${JSON.stringify(SEVERITY_COLOR)};
+const byFingerprint = new Map();
+const pendingRepro = new Map();
+let first = true;
+
+function setCount(k, v) {
+  counts[k] = v;
+  const b = document.getElementById("c-" + k);
+  if (b) b.textContent = String(v);
+}
+
+function addSpike() {
+  if (!spikes) return;
+  const n = spikes.children.length + 1;
+  const x = 80 + (((n - 1) % 8) + 0.5) / 8 * 640;
+  const p = document.createElementNS("http://www.w3.org/2000/svg", "path");
+  p.setAttribute("d", "M " + x.toFixed(1) + " 32 L " + x.toFixed(1) + " 12");
+  p.setAttribute("stroke", "#ff5a5f");
+  p.setAttribute("stroke-width", "2");
+  p.setAttribute("stroke-linecap", "round");
+  p.setAttribute("fill", "none");
+  p.setAttribute("style", "filter:drop-shadow(0 0 4px #ff5a5f)");
+  spikes.appendChild(p);
+}
+
+function applyRepro(fp, r) {
+  const card = byFingerprint.get(fp);
+  if (!card) { pendingRepro.set(fp, r); return; }
+  let el = card.querySelector(".repro");
+  if (!el) {
+    el = document.createElement("div");
+    card.appendChild(el);
+  }
+  el.className = "repro " + r.verdict;
+  el.textContent = r.verdict + " · " + r.reproductions + "/" + r.runs + " runs · spec " + r.specPath;
+}
+
+function addFinding(f) {
+  if (counts[f.severity] !== undefined) setCount(f.severity, counts[f.severity] + 1);
+  if (f.severity === "crash") addSpike();
+
+  const card = document.createElement("article");
+  card.className = "finding";
+  card.style.setProperty("--sev", sevColor[f.severity] || "#4cc2ff");
+
+  const header = document.createElement("header");
+  const chip = document.createElement("span");
+  chip.className = "sev";
+  chip.textContent = f.severity;
+  const h2 = document.createElement("h2");
+  h2.textContent = f.rawMessage.split("\\n")[0];
+  header.appendChild(chip);
+  header.appendChild(h2);
+  card.appendChild(header);
+
+  if (f.mappedLocation) {
+    const loc = document.createElement("div");
+    loc.className = "loc";
+    loc.textContent = f.mappedLocation.filePath + ":" + f.mappedLocation.line + ":" + f.mappedLocation.column;
+    card.appendChild(loc);
+  }
+
+  byFingerprint.set(f.fingerprint, card);
+  if (pendingRepro.has(f.fingerprint)) {
+    applyRepro(f.fingerprint, pendingRepro.get(f.fingerprint));
+    pendingRepro.delete(f.fingerprint);
+  }
+
+  if (first) { list.innerHTML = ""; first = false; }
+  list.insertBefore(card, list.firstChild);
+}
+
+const es = new EventSource("/events");
+es.onmessage = (e) => {
+  const evt = JSON.parse(e.data);
+  if (evt.type === "run_start") {
+    target.textContent = evt.url;
+    list.innerHTML = "";
+    foot.textContent = "";
+    byFingerprint.clear();
+    pendingRepro.clear();
+    first = true;
+    setCount("crash", 0); setCount("error", 0); setCount("warning", 0);
+    while (spikes && spikes.firstChild) spikes.removeChild(spikes.firstChild);
+  } else if (evt.type === "finding") {
+    addFinding(evt.finding);
+  } else if (evt.type === "repro") {
+    applyRepro(evt.fingerprint, evt);
+  } else if (evt.type === "run_end") {
+    const c = evt.counts || {};
+    foot.textContent = "run complete — " + (c.crash || 0) + " crash · " + (c.error || 0) + " error · " + (c.warning || 0) + " warning";
+  }
+};`;
+}
+function dashboardHtml() {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Aztrx Studio</title>
+<style>${BASE_CSS}</style>
+</head>
+<body>
+<main>
+  <div class="hero">
+    ${seismograph(0)}
+    <div class="brand-row">
+      <h1><span class="brand">aztrx</span> <span class="brand-sub">studio</span></h1>
+    </div>
+    <div class="target" id="target">waiting for a run…</div>
+    <div class="live"><span class="live-dot"></span> streaming .aztrx/events.jsonl</div>
+  </div>
+  <div class="bar">
+    <span class="count">crash <b class="crash" id="c-crash">0</b></span>
+    <span class="count">error <b class="error" id="c-error">0</b></span>
+    <span class="count">warning <b class="warning" id="c-warning">0</b></span>
+  </div>
+  <div id="list"><p class="empty">Run <code>aztrx &lt;url&gt; --repo .</code> to stream findings here live.</p></div>
+  <p class="foot" id="foot"></p>
+  <p class="foot">Full report: <a href="/report">.aztrx/report.html</a></p>
+</main>
+<script>${dashboardScript()}</script>
+</body>
+</html>`;
+}
+export function startStudio(opts) {
+    const repoRoot = path.resolve(opts.repoRoot);
+    const port = opts.port ?? 7331;
+    const aztrxDir = path.join(repoRoot, ".aztrx");
+    const eventsFile = path.join(aztrxDir, "events.jsonl");
+    const server = http.createServer((req, res) => {
+        const url = (req.url ?? "/").split("?")[0];
+        if (url === "/events")
+            return sseHandler(req, res, eventsFile);
+        if (url === "/" || url === "/index.html")
+            return send(res, 200, "text/html; charset=utf-8", dashboardHtml());
+        if (url === "/report" || url === "/report.html")
+            return sendFile(res, path.join(aztrxDir, "report.html"), "text/html; charset=utf-8");
+        if (url.startsWith("/repro/"))
+            return sendFile(res, path.join(aztrxDir, "repro", path.basename(url)), "text/plain; charset=utf-8");
+        return send(res, 404, "text/plain; charset=utf-8", "not found");
+    });
+    server.listen(port, () => {
+        console.log(pc.cyan("\n⚡ Aztrx Studio"));
+        console.log(pc.dim(`   → http://localhost:${port}`));
+        console.log(pc.dim(`   watching ${path.relative(process.cwd(), eventsFile)}`));
+        console.log(pc.dim("   Ctrl+C to stop\n"));
+    });
+    return server;
+}

package/dist/core/telemetry/index.js

@@ -0,0 +1,103 @@
+/**
+ * F11 — opt-in telemetry / data flywheel. Collects the anonymized
+ * `[crash_fingerprint, min_repro_spec, verified_patch, framework_metadata,
+ * model_tier_used]` tuple for each crash/error finding, appends it to a local
+ * JSONL dataset, and — only under `--share-data` — dispatches an envelope to the
+ * telemetry endpoint.
+ *
+ * Privacy: everything is opt-in. `--telemetry` collects and persists locally
+ * only; `--share-data` additionally uploads. The dispatch is fire-and-forget,
+ * bounded by a 2s abort, and can never change the CLI exit code.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { detectFrameworkMeta } from "../init.js";
+import { createSanitizer } from "./sanitize.js";
+const DEFAULT_ENDPOINT = process.env.AZTRX_TELEMETRY_URL || "https://api.aztrx.app/api/telemetry";
+const UPLOAD_TIMEOUT_MS = 2000;
+/** In-flight uploads, drained by `flushTelemetry()` before the CLI exits. */
+const pendingUploads = [];
+function readFileIfExists(p) {
+    try {
+        return fs.readFileSync(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function buildTuples(findings, repoRoot) {
+    const sanitize = createSanitizer(repoRoot);
+    const framework_metadata = detectFrameworkMeta(repoRoot);
+    const tuples = [];
+    for (const f of findings) {
+        if (f.severity !== "crash" && f.severity !== "error")
+            continue;
+        const specRaw = f.repro?.specPath ? readFileIfExists(f.repro.specPath) : null;
+        const patchRaw = f.heal?.status === "healed" && f.heal.patchPath
+            ? readFileIfExists(f.heal.patchPath)
+            : null;
+        tuples.push({
+            crash_fingerprint: f.fingerprint,
+            min_repro_spec: specRaw ? sanitize.text(specRaw) : null,
+            verified_patch: patchRaw ? sanitize.text(patchRaw) : null,
+            framework_metadata,
+            model_tier_used: f.heal?.model ?? null,
+        });
+    }
+    return tuples;
+}
+function persistDataset(repoRoot, tuples) {
+    if (tuples.length === 0)
+        return null;
+    const dir = path.join(repoRoot, ".aztrx", "telemetry");
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, "dataset.jsonl");
+    const lines = tuples.map((t) => JSON.stringify(t)).join("\n") + "\n";
+    fs.appendFileSync(file, lines, "utf-8");
+    return file;
+}
+/** Fire-and-forget upload. Never rejects; bounded by a short abort. */
+export function dispatchTelemetry(envelope, endpoint, apiKey) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), UPLOAD_TIMEOUT_MS);
+    const headers = { "content-type": "application/json" };
+    if (apiKey)
+        headers["x-api-key"] = apiKey;
+    return fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(envelope),
+        signal: ctrl.signal,
+    })
+        .then(() => { })
+        .catch(() => { })
+        .finally(() => clearTimeout(timer));
+}
+/** Collect + sanitize + persist, and (under `--share-data`) dispatch. Sync on
+ * the local path; the upload is detached so the run never waits on the network. */
+export function submitTelemetry(findings, opts) {
+    const share = Boolean(opts.shareData);
+    if (!opts.telemetry && !share)
+        return;
+    const tuples = buildTuples(findings, opts.repoRoot);
+    if (tuples.length === 0)
+        return;
+    persistDataset(opts.repoRoot, tuples);
+    if (share) {
+        const envelope = {
+            schema: "aztrx.telemetry/1",
+            sentAt: new Date().toISOString(),
+            tuples,
+        };
+        const apiKey = opts.apiKey ?? process.env.AZTRX_API_KEY;
+        pendingUploads.push(dispatchTelemetry(envelope, opts.endpoint ?? DEFAULT_ENDPOINT, apiKey));
+    }
+}
+/** Await all in-flight uploads (each already bounded). Called right before the
+ * CLI exits so a pending upload isn't killed mid-flight; never affects exit code. */
+export async function flushTelemetry() {
+    while (pendingUploads.length) {
+        const batch = pendingUploads.splice(0);
+        await Promise.allSettled(batch);
+    }
+}

package/dist/core/telemetry/sanitize.js

@@ -0,0 +1,57 @@
+/**
+ * Telemetry sanitizer — the privacy gate before any byte is packaged. A strict
+ * superset of the heal redaction layer, applied irreversibly: secrets first
+ * (the redaction map is discarded), then URLs, webpack namespaces, and
+ * repo-absolute paths. The output must be safe to leave the machine even if the
+ * user's app, routes, and file layout are proprietary.
+ */
+import { redact } from "../heal/redact.js";
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1"]);
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Anonymize a single URL: strip query/fragment/userinfo; keep only a localhost
+ * authority (already anonymous) or a literal `<host>` placeholder. The route
+ * path is kept — it's structural, not identifying.
+ */
+export function sanitizeUrl(raw) {
+    const noQuery = raw.split(/[?#]/)[0];
+    const m = noQuery.match(/^([a-z][a-z0-9+.-]*:\/\/)([^/]*)(\/.*)?$/i);
+    if (!m)
+        return noQuery;
+    const scheme = m[1];
+    const authority = m[2];
+    const pathPart = m[3] ?? "";
+    const hostPort = authority.includes("@")
+        ? authority.slice(authority.lastIndexOf("@") + 1)
+        : authority;
+    const host = hostPort.replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+    if (LOCAL_HOSTS.has(host))
+        return `${scheme}${hostPort}${pathPart}`;
+    return `${scheme}<host>${pathPart}`;
+}
+const URL_RE = /https?:\/\/[^\s"')\]]+/g;
+const WEBPACK_RE = /webpack:\/\/[^/\s]+/g;
+/** Bound to a repo root so repo-absolute paths and the repo name can be scrubbed. */
+export function createSanitizer(repoRoot) {
+    const rootFwd = repoRoot.replace(/\\/g, "/");
+    const rootBk = repoRoot.replace(/\//g, "\\");
+    const rootFwdRe = new RegExp(escapeRe(rootFwd), "g");
+    const rootBkRe = new RegExp(escapeRe(rootBk), "g");
+    return {
+        url: sanitizeUrl,
+        text(raw) {
+            // 1. Secrets — irreversibly (the placeholder→secret map is discarded).
+            let out = redact(raw).text;
+            // 2. URLs — anonymize the authority, drop query-string secrets.
+            out = out.replace(URL_RE, (u) => sanitizeUrl(u));
+            // 3. Webpack namespaces embed the repo name.
+            out = out.replace(WEBPACK_RE, "webpack://<repo>");
+            // 4. Repo-absolute paths (both separators) → `<repo>`.
+            out = out.replace(rootFwdRe, "<repo>");
+            out = out.replace(rootBkRe, "<repo>");
+            return out;
+        },
+    };
+}

package/dist/core/telemetry/types.js

@@ -0,0 +1,4 @@
+/** Telemetry payload schema — the data-flywheel columnar tuple. Flat on purpose
+ * so a record can be appended to a JSONL dataset as-is and loaded into any
+ * columnar store later. Everything in here has already passed the sanitizer. */
+export {};

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ui.js

@@ -0,0 +1,93 @@
+// The single "crash seismograph" identity — shared by the HTML report, Local
+// Studio, and (later) the cloud dashboard so they can't drift apart. Tokens
+// mirror web/app/globals.css.
+export const PALETTE = {
+    bg: "#07090d",
+    surface: "#0d1117",
+    surface2: "#12161e",
+    border: "#232a36",
+    fg: "#e9edf4",
+    muted: "#a6aebb",
+    dim: "#5b6573",
+    azure: "#4cc2ff",
+    azureBright: "#8ad9ff",
+    red: "#ff5a5f",
+    amber: "#f5a623",
+    green: "#43e58a",
+};
+export const SEVERITY_COLOR = {
+    crash: PALETTE.red,
+    error: PALETTE.red,
+    warning: PALETTE.amber,
+    noise: PALETTE.dim,
+};
+export const REPRO_COLOR = {
+    deterministic: PALETTE.green,
+    flaky: PALETTE.amber,
+    unreliable: PALETTE.red,
+};
+export const BASE_CSS = `
+:root{color-scheme:dark;--bg:#07090d;--surface:#0d1117;--surface-2:#12161e;--border:#232a36;--fg:#e9edf4;--muted:#a6aebb;--dim:#5b6573;--azure:#4cc2ff;--azure-bright:#8ad9ff;--red:#ff5a5f;--amber:#f5a623;--green:#43e58a}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--fg);font:14px/1.65 ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,"Liberation Mono",monospace;-webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility;background-image:linear-gradient(rgba(76,194,255,.035) 1px,transparent 1px),linear-gradient(90deg,rgba(76,194,255,.035) 1px,transparent 1px);background-size:44px 44px}
+main{max-width:920px;margin:0 auto;padding:40px 24px 80px}
+.hero{margin-bottom:26px}
+.hero svg{width:100%;height:64px;display:block}
+.brand-row{display:flex;align-items:baseline;gap:10px;flex-wrap:wrap;margin-top:16px}
+h1{margin:0;font-size:20px;font-weight:700;letter-spacing:.02em}
+h1 .brand{color:var(--azure)}
+h1 .brand-sub{color:var(--dim)}
+.target{color:var(--dim);font-size:13px;margin-top:4px;word-break:break-all}
+.live{display:inline-flex;align-items:center;gap:7px;font-size:12px;color:var(--muted);margin-top:6px}
+.live-dot{width:8px;height:8px;border-radius:50%;background:var(--green);box-shadow:0 0 8px var(--green);animation:pulse 1.8s ease-in-out infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:.25}}
+.bar{display:flex;gap:10px;margin:0 0 24px;flex-wrap:wrap}
+.count{font:600 13px/1 ui-monospace,monospace;border:1px solid var(--border);border-radius:8px;padding:7px 12px;color:var(--dim);background:var(--surface)}
+.count b{color:var(--fg);font-weight:600}
+.count b.crash{color:var(--red)}
+.count b.error{color:var(--red)}
+.count b.warning{color:var(--amber)}
+.finding{background:var(--surface);border:1px solid var(--border);border-left:3px solid var(--sev,var(--azure));border-radius:10px;padding:16px 18px;margin-bottom:14px;animation:line-in .35s ease both}
+.finding header{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
+.sev{font:600 11px/1 ui-monospace,monospace;text-transform:uppercase;letter-spacing:.08em;color:var(--sev);border:1px solid var(--sev);border-radius:999px;padding:3px 9px;flex:none}
+h2{font-size:15px;margin:0;font-weight:600;word-break:break-word}
+.loc{color:var(--dim);font-size:12.5px;margin-top:8px}
+.snippet{background:var(--surface-2);border:1px solid var(--border);border-radius:8px;padding:12px 14px;overflow-x:auto;font:12px/1.6 ui-monospace,monospace;color:var(--muted);margin:12px 0 0;white-space:pre}
+.occ{color:var(--dim);font-size:12px;margin-top:8px}
+.repro{display:inline-flex;align-items:center;gap:8px;font-size:12px;margin-top:12px;padding:4px 10px;border-radius:6px;border:1px solid}
+.repro.deterministic{color:var(--green);border-color:rgba(67,229,138,.35);background:rgba(67,229,138,.07)}
+.repro.flaky{color:var(--amber);border-color:rgba(245,166,35,.35);background:rgba(245,166,35,.07)}
+.repro.unreliable{color:var(--red);border-color:rgba(255,90,95,.35);background:rgba(255,90,95,.07)}
+details{margin-top:12px;color:var(--dim);font-size:12.5px;border-top:1px solid var(--border);padding-top:10px}
+summary{cursor:pointer;color:var(--muted)}
+details ol{margin:8px 0 0;padding-left:22px;display:flex;flex-direction:column;gap:4px}
+details code{color:var(--fg)}
+.empty{color:var(--dim);border:1px dashed var(--border);border-radius:10px;padding:24px;text-align:center}
+.foot{color:var(--dim);font-size:12.5px;margin-top:24px}
+a{color:var(--azure)}
+@keyframes line-in{from{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}
+`;
+/**
+ * The crash seismograph: an azure trace with one red spike per crash. The
+ * spikes live inside `<g id="spikes">` so the Studio can append them live as
+ * crashes stream in; the report pre-fills them.
+ */
+export function seismograph(crashes) {
+    const pts = [];
+    for (let i = 0; i <= 400; i++) {
+        const x = (i / 400) * 800;
+        const y = 32 + Math.sin(i * 0.12) * 4 + Math.sin(i * 0.045) * 3 + Math.sin(i * 0.27) * 1.2;
+        pts.push(`${x.toFixed(1)},${y.toFixed(1)}`);
+    }
+    const spikes = [];
+    const n = Math.max(0, Math.min(crashes, 8));
+    for (let k = 0; k < n; k++) {
+        const x = 80 + ((k + 0.5) / n) * 640;
+        spikes.push(`<path d="M ${x.toFixed(1)} 32 L ${x.toFixed(1)} 12" stroke="${PALETTE.red}" stroke-width="2" stroke-linecap="round" fill="none" style="filter:drop-shadow(0 0 4px ${PALETTE.red})"/>`);
+    }
+    return `<svg viewBox="0 0 800 64" preserveAspectRatio="none" role="img" aria-label="crash seismograph">
+    <line x1="0" y1="32" x2="800" y2="32" stroke="${PALETTE.azure}" stroke-opacity="0.14" stroke-width="1"/>
+    <polyline points="${pts.join(" ")}" fill="none" stroke="${PALETTE.azure}" stroke-opacity="0.5" stroke-width="1.5"/>
+    <g id="spikes">${spikes.join("")}</g>
+  </svg>`;
+}

package/dist/core/validator.js

@@ -0,0 +1,16 @@
+/**
+ * F9 — repro validator. Replays the minimized sequence `runs` times and gates
+ * on the flake rate: 100% → deterministic, ≥60% → flaky, else unreliable. This
+ * is the difference between "we saw an error" and "we proved the bug".
+ */
+export async function validate(engine, url, finding, actions, runs = 3) {
+    let reproductions = 0;
+    for (let i = 0; i < runs; i++) {
+        const res = await engine.run(url, actions, finding.fingerprint);
+        if (res.reproduced)
+            reproductions += 1;
+    }
+    const rate = runs === 0 ? 0 : reproductions / runs;
+    const verdict = rate === 1 ? "deterministic" : rate >= 0.6 ? "flaky" : "unreliable";
+    return { runs, reproductions, rate, verdict };
+}

package/dist/ui/app.js

@@ -0,0 +1,131 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useReducer, useRef, useState } from "react";
+import { render, Box, Text, useApp } from "ink";
+// Palette — mirrors web/app/globals.css "crash seismograph" tokens, mapped to
+// the nearest ANSI colors so the terminal panel reads as the same instrument.
+const C = {
+    azure: "cyan",
+    azureBright: "cyanBright",
+    red: "red",
+    green: "green",
+    amber: "yellow",
+    dim: "gray",
+    muted: "white",
+    fg: "white",
+};
+const PHASE_LABEL = {
+    launch: { text: "◉ launching browser…", color: C.azure },
+    walk: { text: "◉ walking the DOM…", color: C.azure },
+    fuzz: { text: "◉ fuzzing (chaos)…", color: C.azure },
+    repro: { text: "◉ minimize → compile → validate…", color: C.azure },
+    heal: { text: "◉ healing (redact → generate → gate → sandbox → verify)…", color: C.azure },
+    done: { text: "✓ done", color: C.green },
+};
+// Actions that mutate app state — the ones that "count" toward ops/sec.
+const EFFECTIVE = new Set(["click", "input", "select", "keypress"]);
+function reducer(state, msg) {
+    switch (msg.type) {
+        case "phase":
+            return { ...state, phase: msg.phase, done: msg.phase === "done" };
+        case "action":
+            return {
+                ...state,
+                actions: state.actions + 1,
+                clicks: state.clicks + (msg.action.type === "click" ? 1 : 0),
+            };
+        case "finding":
+            return { ...state, findings: [...state.findings, msg.finding] };
+        case "noise":
+            return { ...state, noise: state.noise + 1 };
+        case "route": {
+            const last = state.routes[state.routes.length - 1];
+            const next = last === msg.url ? state.routes : [...state.routes, msg.url];
+            return { ...state, routes: next.slice(-7), navigations: state.navigations + 1 };
+        }
+        case "repro":
+            return { ...state, repros: { ...state.repros, [msg.repro.finding.fingerprint]: msg.repro } };
+        default:
+            return state;
+    }
+}
+const initialState = {
+    phase: "launch",
+    actions: 0,
+    clicks: 0,
+    findings: [],
+    repros: {},
+    noise: 0,
+    routes: [],
+    navigations: 0,
+    done: false,
+};
+function useAztrx(bus) {
+    const [state, dispatch] = useReducer(reducer, initialState);
+    const effectiveTs = useRef([]);
+    const [now, setNow] = useState(0);
+    useEffect(() => {
+        const offs = [
+            bus.on("phase", (p) => dispatch({ type: "phase", phase: p.phase })),
+            bus.on("action", (a) => {
+                dispatch({ type: "action", action: a });
+                if (EFFECTIVE.has(a.type))
+                    effectiveTs.current.push(a.timestamp);
+            }),
+            bus.on("finding", (f) => dispatch({ type: "finding", finding: f })),
+            bus.on("noise", () => dispatch({ type: "noise" })),
+            bus.on("route", (r) => dispatch({ type: "route", url: r.url })),
+            bus.on("repro", (r) => dispatch({ type: "repro", repro: r })),
+        ];
+        return () => offs.forEach((off) => off());
+    }, [bus]);
+    useEffect(() => {
+        const id = setInterval(() => setNow(Date.now()), 250);
+        return () => clearInterval(id);
+    }, []);
+    const rate = useMemo(() => {
+        if (now === 0)
+            return 0;
+        const cutoff = now - 5000;
+        effectiveTs.current = effectiveTs.current.filter((t) => t >= cutoff);
+        return effectiveTs.current.length / 5;
+    }, [now]);
+    return { state, rate };
+}
+function firstLine(s) {
+    return s.split("\n")[0].slice(0, 68);
+}
+function SeverityMark({ severity }) {
+    const color = severity === "warning" ? C.amber : C.red;
+    const glyph = severity === "warning" ? "○" : "●";
+    return (_jsxs(Text, { color: color, children: [glyph, " ", severity] }));
+}
+function ReproBadge({ repro }) {
+    const color = repro.verdict === "deterministic" ? C.green : repro.verdict === "flaky" ? C.amber : C.red;
+    return (_jsxs(Text, { color: color, children: ["[", repro.verdict, " ", repro.reproductions, "/", repro.runs, "]"] }));
+}
+function FindingRow({ finding, repro }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(SeverityMark, { severity: finding.severity }), _jsx(Text, { color: C.dim, children: "  " }), _jsx(Text, { color: C.fg, children: firstLine(finding.rawMessage) })] }), finding.mappedLocation ? (_jsxs(Text, { color: C.dim, children: ["   ", finding.mappedLocation.filePath, ":", finding.mappedLocation.line, ":", finding.mappedLocation.column] })) : null, repro ? (_jsxs(Box, { children: [_jsx(Text, { color: C.dim, children: "   " }), _jsx(ReproBadge, { repro: repro }), _jsxs(Text, { color: C.dim, children: ["  ", "spec ", repro.specPath, " \u00B7 ", repro.steps, "/", repro.totalSteps, " steps"] })] })) : null] }));
+}
+function AztrxApp({ bus, done, targetUrl, repoRoot, mode }) {
+    const { exit } = useApp();
+    const { state, rate } = useAztrx(bus);
+    useEffect(() => {
+        let cancelled = false;
+        const finish = () => {
+            if (!cancelled)
+                setTimeout(() => exit(), 400);
+        };
+        done.then(finish, finish);
+        return () => {
+            cancelled = true;
+        };
+    }, [done, exit]);
+    const phase = PHASE_LABEL[state.phase];
+    const currentRoute = state.routes[state.routes.length - 1] ?? targetUrl;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: C.azure, bold: true, children: "\u26A1 Aztrx" }), _jsx(Text, { color: C.dim, children: " \u2014 Runtime Detector" }), _jsx(Text, { color: C.dim, children: "   v0.1.0" })] }), _jsxs(Text, { color: C.dim, children: ["  target  ", targetUrl, "     repo  ", repoRoot] }), _jsxs(Text, { color: C.dim, children: ["  mode    ", mode] }), _jsx(Text, { color: C.dim, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: phase.color, children: phase.text }), _jsx(Text, { color: C.dim, children: "  " }), _jsx(Text, { color: C.azureBright, bold: true, children: rate.toFixed(1) }), _jsx(Text, { color: C.dim, children: " ops/s \u00B7 " }), _jsx(Text, { color: C.fg, children: state.actions }), _jsx(Text, { color: C.dim, children: " actions \u00B7 " }), _jsx(Text, { color: C.fg, children: state.clicks }), _jsx(Text, { color: C.dim, children: " clicks" })] }), _jsxs(Box, { children: [_jsx(Text, { color: C.dim, children: "  route   " }), _jsx(Text, { color: C.muted, children: currentRoute }), _jsxs(Text, { color: C.dim, children: [" \u00B7 ", state.routes.length, " route(s)"] })] }), state.findings.length > 0 ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: C.muted, bold: true, children: ["findings (", state.findings.length, ")"] }), state.findings.map((f) => (_jsx(FindingRow, { finding: f, repro: state.repros[f.fingerprint] }, f.fingerprint)))] })) : null, state.noise > 0 ? (_jsxs(Text, { color: C.dim, children: ["  \u25B8 ", state.noise, " noise event(s) suppressed"] })) : null] }));
+}
+/** Mount the live terminal panel and resolve once the run (or a failure) ends. */
+export function renderTui(props) {
+    const { waitUntilExit } = render(_jsx(AztrxApp, { ...props }));
+    return waitUntilExit();
+}