aztrx-cli 0.1.0

package/dist/core/pr.js

@@ -0,0 +1,141 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * F-report — the PR bot's markdown comment. Same findings as the HTML report,
+ * reshaped for a GitHub PR: a status badge, one `<details>` per finding, the
+ * minimized reproduction steps, the compiled Playwright spec inlined, and the
+ * gated patch as a `diff` view. Self-contained — no external data beyond the
+ * shields.io badges, which GitHub renders natively.
+ */
+const SEV_ORDER = ["crash", "error", "warning", "noise"];
+const SEV_BADGE = {
+    crash: "ff5a5f",
+    error: "ff5a5f",
+    warning: "f5a623",
+    noise: "5b6573",
+};
+const SEV_ICON = {
+    crash: "💥",
+    error: "🚨",
+    warning: "⚠️",
+    noise: "·",
+};
+/** Shields.io badge-path escaping: literal `-` → `--`, `/` → `%2F`, space → `_`. */
+function shield(s) {
+    return s.replace(/-/g, "--").replace(/\//g, "%2F").replace(/ /g, "_");
+}
+function badge(label, value, color) {
+    return `![${label}: ${value}](https://img.shields.io/badge/${shield(label)}-${shield(value)}-${shield(color)})`;
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function readIfExists(p) {
+    try {
+        return fs.readFileSync(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function describeAction(a) {
+    const sel = a.selectors[0] ? ` \`${a.selectors[0]}\`` : "";
+    const val = a.value ? ` \`${a.value}\`` : "";
+    return `**${a.type}**${val}${sel}`;
+}
+function healBlock(f) {
+    const h = f.heal;
+    if (!h)
+        return "";
+    const labels = {
+        healed: { text: "healed", color: "43e58a" },
+        unfixed: { text: "unfixed", color: "f5a623" },
+        rejected: { text: "rejected", color: "ff5a5f" },
+        "compile-failed": { text: "compile-failed", color: "ff5a5f" },
+        "apply-failed": { text: "apply-failed", color: "ff5a5f" },
+        skipped: { text: "skipped", color: "5b6573" },
+        "no-llm": { text: "no-llm", color: "5b6573" },
+    };
+    const meta = labels[h.status] ?? { text: h.status, color: "5b6573" };
+    const via = h.model ? ` · \`${h.model}\`` : "";
+    const tiers = h.tiers && h.tiers.length > 1 ? ` · router: ${h.tiers.join(" → ")}` : "";
+    const body = [];
+    // The saved unified diff is only produced for a patch that reached verify.
+    const diff = h.patchPath ? readIfExists(path.resolve(h.patchPath)) : null;
+    if (diff) {
+        body.push("```diff");
+        body.push(diff.trimEnd());
+        body.push("```");
+    }
+    else if (h.explanation) {
+        body.push(`> ${h.explanation}`);
+    }
+    if (h.error)
+        body.push(`\n_${escapeHtml(h.error)}_`);
+    return `\n<details>\n<summary>${badge("heal", meta.text, meta.color)} proposed patch${via}${tiers}</summary>\n\n${body.join("\n")}\n</details>`;
+}
+function reproBlock(f) {
+    const r = f.repro;
+    if (!r || !r.specPath)
+        return "";
+    const verdict = badge("repro", `${r.verdict} ${r.reproductions}/${r.runs}`, r.verdict === "deterministic" ? "43e58a" : "f5a623");
+    const steps = r.actions.length
+        ? `\n${r.actions.map((a, i) => `${i + 1}. ${describeAction(a)}`).join("\n")}`
+        : "";
+    const spec = readIfExists(path.resolve(r.specPath));
+    const specBlock = spec ? `\n\`\`\`ts\n${spec.trimEnd()}\n\`\`\`` : "";
+    return `\n<details>\n<summary>▶ ${verdict} · ${r.actions.length} step(s)</summary>\n\n**Reproduce**${steps}${specBlock}\n</details>`;
+}
+function findingBlock(f) {
+    const sev = f.severity;
+    const icon = SEV_ICON[sev] ?? "·";
+    const first = f.rawMessage.split("\n")[0];
+    const loc = f.mappedLocation
+        ? `\n**Location** \`${f.mappedLocation.filePath}:${f.mappedLocation.line}:${f.mappedLocation.column}\``
+        : "";
+    const snippet = f.mappedLocation?.codeContext
+        ? `\n\n\`\`\`${path.extname(f.mappedLocation.filePath).replace(".", "") || "ts"}\n${f.mappedLocation.codeContext.trimEnd()}\n\`\`\``
+        : "";
+    return `<details open>\n<summary>${icon} <code>${escapeHtml(sev)}</code> — ${escapeHtml(first)}</summary>\n${loc}${snippet}${reproBlock(f)}${healBlock(f)}\n</details>`;
+}
+export function renderPrComment(targetUrl, findings, opts = {}) {
+    void opts;
+    const sorted = [...findings].sort((a, b) => SEV_ORDER.indexOf(a.severity) - SEV_ORDER.indexOf(b.severity));
+    const counts = { crash: 0, error: 0, warning: 0, noise: 0 };
+    for (const f of sorted)
+        counts[f.severity] = (counts[f.severity] ?? 0) + 1;
+    const critical = (counts.crash ?? 0) + (counts.error ?? 0);
+    const healed = sorted.filter((f) => f.heal?.status === "healed").length;
+    const repros = sorted.filter((f) => f.repro?.specPath).length;
+    const deterministic = sorted.filter((f) => f.repro?.verdict === "deterministic").length;
+    const statusBadge = critical
+        ? badge("aztrx", `${critical} critical`, "ff5a5f")
+        : badge("aztrx", "clean", "43e58a");
+    const summaryBadges = [
+        statusBadge,
+        repros ? badge("repro", `${deterministic}/${repros} deterministic`, deterministic === repros ? "43e58a" : "f5a623") : "",
+        healed ? badge("heal", `${healed} patched`, "43e58a") : "",
+    ]
+        .filter(Boolean)
+        .join("  ");
+    const body = sorted.length
+        ? sorted.map(findingBlock).join("\n\n")
+        : "> ✅ No crash, error, or warning surfaced — the app survived this pass.";
+    return `<!-- aztrx -->
+## ⚡ Aztrx — runtime stress-test
+
+${summaryBadges}
+
+**Target** \`${targetUrl}\` · **${counts.crash ?? 0} crash** · **${counts.error ?? 0} error** · **${counts.warning ?? 0} warning**
+
+---
+
+${body}
+`;
+}
+export function writePrComment(repoRoot, targetUrl, findings, filePath) {
+    const file = filePath ?? path.join(repoRoot, ".aztrx", "pr-comment.md");
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, renderPrComment(targetUrl, findings, { repoRoot }), "utf-8");
+    return file;
+}

package/dist/core/recorder.js

@@ -0,0 +1,93 @@
+/**
+ * F2 — ring buffer of the last 25 actions. The Repro Minimizer (F7) later
+ * shrinks this history; for now it's the action context attached to findings.
+ */
+export class ActionRecorder {
+    buffer = [];
+    capacity = 25;
+    record(action) {
+        this.buffer.push(action);
+        if (this.buffer.length > this.capacity)
+            this.buffer.shift();
+    }
+    snapshot() {
+        return [...this.buffer];
+    }
+}
+/**
+ * Selector cascade, most-reliable first: data-testid → text → css path.
+ *
+ * Each `evaluate` is wrapped defensively: selector resolution is best-effort
+ * and must never take down a whole run if the page tears the node down
+ * mid-query or the browser rejects a serialized function. A failed probe just
+ * degrades to the next (weaker) selector in the cascade.
+ */
+export async function selectorCascade(page, handle) {
+    const out = [];
+    try {
+        const testId = await handle.evaluate((el) => {
+            const t = el.getAttribute("data-testid");
+            return t ? `[data-testid="${t}"]` : null;
+        });
+        if (testId)
+            out.push(testId);
+    }
+    catch {
+        // degraded — no data-testid selector
+    }
+    try {
+        const text = await handle.evaluate((el) => {
+            const t = el.innerText?.trim().replace(/\s+/g, " ").slice(0, 60);
+            return t ?? "";
+        });
+        if (text)
+            out.push(`text=${JSON.stringify(text)}`);
+    }
+    catch {
+        // degraded — no text selector
+    }
+    const css = await cssPathOf(handle);
+    if (css)
+        out.push(css);
+    return out;
+}
+/**
+ * Build a CSS path to `handle`, preferring an `#id`. The logic is inlined in
+ * the `evaluate` callback (no nested named function) because V8/Playwright's
+ * `Function.prototype.toString()` serialization of a *named* inner function
+ * emits a `__name` helper reference that is undefined in the page context —
+ * which silently collapses the whole cascade to `[]`.
+ */
+async function cssPathOf(handle) {
+    try {
+        return await handle.evaluate((el) => {
+            if (el.id)
+                return `#${CSS.escape(el.id)}`;
+            const parts = [];
+            let current = el;
+            while (current !== null && current !== document.body) {
+                const tag = current.tagName.toLowerCase();
+                if (current.id) {
+                    parts.unshift(`#${CSS.escape(current.id)}`);
+                    break;
+                }
+                const parentElement = current.parentElement;
+                if (parentElement !== null) {
+                    const siblings = Array.from(parentElement.children).filter((child) => child.tagName === tag);
+                    if (siblings.length > 1) {
+                        parts.unshift(`${tag}:nth-of-type(${siblings.indexOf(current) + 1})`);
+                        current = parentElement;
+                        continue;
+                    }
+                }
+                parts.unshift(tag);
+                current = parentElement;
+            }
+            return parts.join(" > ");
+        });
+    }
+    catch {
+        // degraded — no css-path selector
+        return null;
+    }
+}

package/dist/core/replay.js

@@ -0,0 +1,112 @@
+import { chromium } from "playwright";
+import { EventBus } from "./eventBus.js";
+import { attachInterceptor } from "./interceptor.js";
+import { fingerprintOf } from "./classifier.js";
+/** Replays a recorded action sequence against a page. Best-effort: a selector
+ * that no longer resolves is skipped, not fatal. */
+export async function replayActions(page, actions) {
+    for (const a of actions) {
+        if (a.type === "navigate") {
+            if (a.value) {
+                await page.goto(a.value, { waitUntil: "domcontentloaded", timeout: 10000 }).catch(() => { });
+            }
+            continue;
+        }
+        if (a.type === "scroll") {
+            await page.mouse.wheel(0, a.value === "up" ? -600 : 600).catch(() => { });
+            await page.waitForTimeout(30);
+            continue;
+        }
+        if (a.type === "keypress") {
+            const key = a.value ?? "Enter";
+            if (a.selectors[0]) {
+                await page.locator(a.selectors[0]).first().focus().catch(() => { });
+            }
+            await page.keyboard.press(key).catch(() => { });
+            await page.waitForTimeout(30);
+            continue;
+        }
+        for (const sel of a.selectors) {
+            const loc = page.locator(sel).first();
+            const n = await loc.count().catch(() => 0);
+            if (n === 0)
+                continue;
+            switch (a.type) {
+                case "input":
+                    await loc.fill(a.value ?? "").catch(() => { });
+                    break;
+                case "hover":
+                    await loc.hover().catch(() => { });
+                    break;
+                case "select":
+                    await loc.selectOption(a.value ?? "").catch(() => { });
+                    break;
+                default:
+                    await loc.click({ timeout: 1000 }).catch(() => { });
+                    break;
+            }
+            break;
+        }
+        await page.waitForTimeout(50);
+    }
+}
+/**
+ * Reuses one browser across replays (ddmin + validator each run many). Each
+ * `run` gets a fresh page; the interceptor collects telemetry fingerprints and
+ * reports whether `targetFingerprint` was seen.
+ */
+export class ReplayEngine {
+    opts;
+    browser = null;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async getBrowser() {
+        if (!this.browser)
+            this.browser = await chromium.launch({ headless: true });
+        return this.browser;
+    }
+    async run(url, actions, targetFingerprint) {
+        // The browser is reused across replays for speed, but after enough page
+        // loads a renderer can crash. Relaunch once and retry so a single crash
+        // doesn't take down the whole repro pipeline.
+        let lastError = null;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            let context = null;
+            let page = null;
+            try {
+                const browser = await this.getBrowser();
+                context = await browser.newContext(this.opts.storageState ? { storageState: this.opts.storageState } : {});
+                page = await context.newPage();
+                const bus = new EventBus();
+                const fingerprints = new Set();
+                bus.on("telemetry", (p) => fingerprints.add(fingerprintOf(p)));
+                attachInterceptor(page, bus);
+                if (this.opts.attachGuard)
+                    await this.opts.attachGuard(page);
+                await page.goto(url, { waitUntil: "load", timeout: 30000 }).catch(() => { });
+                // Settle for hydration before replaying — the detection pass waits on the
+                // `load` event plus a settle window, and a replay that clicks before React
+                // attaches its handlers won't reproduce the crash (false "unreliable").
+                await page.waitForTimeout(2000);
+                await replayActions(page, actions);
+                await page.waitForTimeout(300);
+                return { reproduced: fingerprints.has(targetFingerprint) };
+            }
+            catch (e) {
+                lastError = e;
+                await this.close(); // drop the (possibly crashed) browser and retry fresh
+            }
+            finally {
+                await page?.close().catch(() => { });
+                await context?.close().catch(() => { });
+            }
+        }
+        throw lastError;
+    }
+    async close() {
+        if (this.browser)
+            await this.browser.close().catch(() => { });
+        this.browser = null;
+    }
+}

package/dist/core/report.js

@@ -0,0 +1,84 @@
+import * as fs from "fs";
+import * as path from "path";
+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;");
+}
+const SEV_ORDER = ["crash", "error", "warning", "noise"];
+/**
+ * F-report — standalone offline HTML report. Self-contained (inline CSS, no
+ * CDN), rendered in the shared "crash seismograph" identity: one red spike per
+ * crash, severity chips, and colored repro verdicts.
+ */
+export function renderReport(targetUrl, findings) {
+    const sorted = [...findings].sort((a, b) => SEV_ORDER.indexOf(a.severity) - SEV_ORDER.indexOf(b.severity));
+    const counts = { crash: 0, error: 0, warning: 0 };
+    for (const f of sorted)
+        if (counts[f.severity] !== undefined)
+            counts[f.severity]++;
+    const cards = sorted
+        .map((f) => {
+        const loc = f.mappedLocation
+            ? `${escapeHtml(f.mappedLocation.filePath)}:${f.mappedLocation.line}:${f.mappedLocation.column}`
+            : "";
+        const snippet = f.mappedLocation ? escapeHtml(f.mappedLocation.codeContext) : "";
+        const repro = f.repro
+            ? `<div class="repro ${f.repro.verdict}">${f.repro.verdict} · ${f.repro.reproductions}/${f.repro.runs} runs · ${f.repro.actions.length} step(s) · <code>${escapeHtml(path.basename(f.repro.specPath))}</code></div>`
+            : "";
+        const steps = f.actionHistory.length
+            ? `<details><summary>action history (${f.actionHistory.length})</summary><ol>${f.actionHistory
+                .map((a) => {
+                const detail = a.value ? ` <span>${escapeHtml(a.value)}</span>` : "";
+                const sel = a.selectors[0] ? ` ${escapeHtml(a.selectors[0])}` : "";
+                return `<li><code>${escapeHtml(a.type)}${detail}</code>${sel}</li>`;
+            })
+                .join("")}</ol></details>`
+            : "";
+        return `
+    <article class="finding">
+      <header>
+        <span class="sev" style="--sev:${SEVERITY_COLOR[f.severity]}">${escapeHtml(f.severity)}</span>
+        <h2>${escapeHtml(f.rawMessage.split("\n")[0])}</h2>
+      </header>
+      ${loc ? `<div class="loc">${loc}</div>` : ""}
+      ${snippet ? `<pre class="snippet">${snippet}</pre>` : ""}
+      ${f.occurrences > 1 ? `<div class="occ">seen ×${f.occurrences}</div>` : ""}
+      ${repro}
+      ${steps}
+    </article>`;
+    })
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>aztrx report</title>
+<style>${BASE_CSS}</style>
+</head>
+<body>
+<main>
+  <div class="hero">
+    ${seismograph(counts.crash ?? 0)}
+    <div class="brand-row">
+      <h1><span class="brand">aztrx</span> <span class="brand-sub">report</span></h1>
+    </div>
+    <div class="target">${escapeHtml(targetUrl)}</div>
+  </div>
+  <div class="bar">
+    <span class="count">crash <b class="crash">${counts.crash ?? 0}</b></span>
+    <span class="count">error <b class="error">${counts.error ?? 0}</b></span>
+    <span class="count">warning <b class="warning">${counts.warning ?? 0}</b></span>
+  </div>
+  ${sorted.length ? cards : `<p class="empty">No findings — the app survived this pass.</p>`}
+</main>
+</body>
+</html>`;
+}
+export function writeReport(repoRoot, targetUrl, findings) {
+    const dir = path.join(repoRoot, ".aztrx");
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, "report.html");
+    fs.writeFileSync(file, renderReport(targetUrl, findings), "utf-8");
+    return file;
+}

package/dist/core/resolver.js

@@ -0,0 +1,124 @@
+import * as fs from "fs";
+import * as path from "path";
+import { TraceMap, originalPositionFor, } from "@jridgewell/trace-mapping";
+/**
+ * Pulls the first `url:line:col` frame out of a stack string. Handles React
+ * Error Boundary console text, which embeds the original stack in its body.
+ */
+export function extractFrame(text) {
+    const match = text.match(/(https?:\/\/[^\s)"']+?):(\d+):(\d+)/);
+    if (!match)
+        return null;
+    return {
+        url: match[1],
+        line: parseInt(match[2], 10),
+        column: parseInt(match[3], 10),
+        message: text.split("\n")[0].trim().slice(0, 200),
+    };
+}
+function stripQuery(url) {
+    return url.split("?")[0];
+}
+/** True only for a real, readable regular file — directories and unreadable
+ * paths return false so readers never hit `EISDIR` / permission errors. */
+function isFile(p) {
+    try {
+        return fs.existsSync(p) && fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Turns a sourcemap `source` value into candidate absolute paths to probe. */
+function sourceCandidates(source, repoRoot) {
+    const cleaned = source
+        .replace(/^webpack:\/\/[^/]+\//, "") // webpack://namespace/src/...
+        .replace(/^webpack:\/\//, "")
+        .replace(/^\/@fs\//, "")
+        .replace(/^\//, "")
+        .split("?")[0];
+    const prefixes = ["", "apps/web/", "src/", "app/"];
+    return prefixes.map((p) => path.resolve(repoRoot, p, cleaned));
+}
+function locateFile(candidates) {
+    for (const c of candidates) {
+        if (isFile(c))
+            return c;
+    }
+    return null;
+}
+export async function resolveFrame(frame, repoRoot) {
+    const viaMap = await trySourceMap(frame, repoRoot);
+    if (viaMap)
+        return viaMap;
+    // Fallback: Vite dev serves real source files at their URL path, so the
+    // bundle URL is already the source path — no sourcemap needed.
+    const relative = stripQuery(frame.url)
+        .replace(/^https?:\/\/[^/]+\//, "")
+        .replace(/^\//, "");
+    const directPath = path.resolve(repoRoot, relative);
+    return {
+        message: frame.message,
+        sourceFile: path.relative(repoRoot, directPath),
+        line: frame.line,
+        column: frame.column,
+        codeSnippet: extractSnippet(directPath, frame.line),
+        resolvedFrom: isFile(directPath) ? "direct" : "unresolved",
+    };
+}
+async function trySourceMap(frame, repoRoot) {
+    const mapUrl = stripQuery(frame.url) + ".map";
+    let rawMap;
+    try {
+        const res = await fetch(mapUrl);
+        if (!res.ok)
+            return null;
+        rawMap = (await res.json());
+    }
+    catch {
+        return null;
+    }
+    try {
+        const map = new TraceMap(rawMap);
+        const pos = originalPositionFor(map, { line: frame.line, column: frame.column });
+        if (!pos.source || pos.line == null)
+            return null;
+        const absolute = locateFile(sourceCandidates(pos.source, repoRoot));
+        if (!absolute) {
+            return {
+                message: frame.message,
+                sourceFile: pos.source,
+                line: pos.line,
+                column: pos.column ?? 0,
+                codeSnippet: `<file not accessible locally: ${pos.source}>`,
+                resolvedFrom: "unresolved",
+            };
+        }
+        return {
+            message: frame.message,
+            sourceFile: path.relative(repoRoot, absolute),
+            line: pos.line,
+            column: pos.column ?? 0,
+            codeSnippet: extractSnippet(absolute, pos.line),
+            resolvedFrom: "sourcemap",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function extractSnippet(filePath, targetLine, window = 4) {
+    if (!isFile(filePath))
+        return `<file not accessible locally: ${filePath}>`;
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    const start = Math.max(0, targetLine - window - 1);
+    const end = Math.min(lines.length, targetLine + window);
+    return lines
+        .slice(start, end)
+        .map((line, idx) => {
+        const n = start + idx + 1;
+        const marker = n === targetLine ? "> " : "  ";
+        return `${marker}${String(n).padStart(4, " ")} │ ${line}`;
+    })
+        .join("\n");
+}

package/dist/core/rng.js

@@ -0,0 +1,11 @@
+/** Deterministic seeded PRNG (mulberry32) so fuzz runs are reproducible. */
+export function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}

package/dist/core/specCompiler.js

@@ -0,0 +1,69 @@
+import * as fs from "fs";
+import * as path from "path";
+const js = (s) => JSON.stringify(s);
+/**
+ * F8 — spec compiler. Turns a minimal action sequence into an executable
+ * Playwright test that asserts the failure actually happens, so a human can
+ * run `npx playwright test` and see the bug with their own eyes — proof, not
+ * a log line.
+ */
+export function compileSpec(finding, actions, url) {
+    const title = finding.rawMessage.split("\n")[0].slice(0, 80) || "unknown error";
+    const needle = finding.rawMessage.split("\n")[0].slice(0, 120);
+    const out = [];
+    out.push(`import { test, expect } from "@playwright/test";`);
+    out.push(``);
+    out.push(`// Aztrx repro — ${finding.id}`);
+    out.push(`// severity: ${finding.severity}   type: ${finding.type}`);
+    if (finding.mappedLocation) {
+        out.push(`// source: ${finding.mappedLocation.filePath}:${finding.mappedLocation.line}:${finding.mappedLocation.column}`);
+    }
+    out.push(`test(${js(`repro: ${title}`)}, async ({ page }) => {`);
+    out.push(`  const errors: string[] = [];`);
+    out.push(`  page.on("pageerror", (e) => errors.push(e.message));`);
+    out.push(`  page.on("console", (m) => { if (m.type() === "error") errors.push(m.text()); });`);
+    out.push(`  await page.goto(${js(url)});`);
+    for (const a of actions) {
+        if (a.type === "navigate") {
+            out.push(`  await page.goto(${js(a.value ?? url)});`);
+            continue;
+        }
+        if (a.type === "scroll") {
+            out.push(`  await page.mouse.wheel(0, ${a.value === "up" ? -600 : 600});`);
+            continue;
+        }
+        const sel = a.selectors[0];
+        if (!sel) {
+            out.push(`  // (skipped — no reliable selector for this step)`);
+            continue;
+        }
+        switch (a.type) {
+            case "input":
+                out.push(`  await page.locator(${js(sel)}).first().fill(${js(a.value ?? "")});`);
+                break;
+            case "hover":
+                out.push(`  await page.locator(${js(sel)}).first().hover();`);
+                break;
+            case "select":
+                out.push(`  await page.locator(${js(sel)}).first().selectOption(${js(a.value ?? "")});`);
+                break;
+            case "keypress":
+                out.push(`  await page.locator(${js(sel)}).first().focus();`);
+                out.push(`  await page.keyboard.press(${js(a.value ?? "Enter")});`);
+                break;
+            default:
+                out.push(`  await page.locator(${js(sel)}).first().click();`);
+                break;
+        }
+    }
+    out.push(`  await expect.poll(() => errors.join("\\n"), { timeout: 5000 }).toContain(${js(needle)});`);
+    out.push(`});`);
+    return out.join("\n") + "\n";
+}
+export function writeSpec(repoRoot, finding, actions, url) {
+    const dir = path.join(repoRoot, ".aztrx", "repro");
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${finding.id}.spec.ts`);
+    fs.writeFileSync(file, compileSpec(finding, actions, url), "utf-8");
+    return file;
+}