ptywright 0.1.0 → 0.2.0

package/dist/runner-zApMYWZx.mjs

@@ -0,0 +1,3257 @@
+import { a as applyTextMaskRules, c as encodeSgrMouse, d as isDefaultStyle, f as styleKey, i as fnv1a32, l as extractStyle, n as TraceRecorder, o as snapshotGrid, p as encodeKey, r as sleep, s as snapshotLines, t as TerminalSession, u as findMeaningfulEndCol } from "./terminal_session-DopC7Xg6.mjs";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { spawn } from "bun-pty";
+import { Terminal } from "@xterm/headless";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/pty/bun_pty_adapter.ts
+function toForkOptions(options) {
+	return {
+		name: options.name,
+		cols: options.cols,
+		rows: options.rows,
+		cwd: options.cwd,
+		env: options.env
+	};
+}
+function toPtyProcess(pty) {
+	return {
+		pid: pty.pid,
+		cols: pty.cols,
+		rows: pty.rows,
+		write: (data) => pty.write(data),
+		resize: (cols, rows) => pty.resize(cols, rows),
+		kill: (signal) => pty.kill(signal),
+		onData: (listener) => pty.onData(listener),
+		onExit: (listener) => pty.onExit(listener)
+	};
+}
+var BunPtyAdapter = class {
+	spawn(command, args, options) {
+		return toPtyProcess(spawn(command, args, toForkOptions(options)));
+	}
+};
+//#endregion
+//#region src/pty/bun_terminal_adapter.ts
+function createDisposable(set, listener) {
+	return { dispose: () => {
+		set.delete(listener);
+	} };
+}
+var BunTerminalAdapter = class {
+	spawn(command, args, options) {
+		if (process.platform === "win32") throw new Error("Bun.Terminal PTY is only available on POSIX systems (Linux/macOS)");
+		let cols = options.cols;
+		let rows = options.rows;
+		const decoder = new TextDecoder();
+		const dataListeners = /* @__PURE__ */ new Set();
+		const exitListeners = /* @__PURE__ */ new Set();
+		const pendingData = [];
+		let pendingExit = null;
+		const dispatchData = (chunk) => {
+			if (!chunk) return;
+			if (dataListeners.size === 0) {
+				pendingData.push(chunk);
+				if (pendingData.length > 2e3) pendingData.splice(0, pendingData.length - 2e3);
+				return;
+			}
+			for (const listener of dataListeners) listener(chunk);
+		};
+		const flushPendingDataTo = (listener) => {
+			if (pendingData.length === 0) return;
+			for (const chunk of pendingData) listener(chunk);
+		};
+		const dispatchExit = (event) => {
+			pendingExit = event;
+			for (const listener of exitListeners) listener(event);
+		};
+		const flushExitTo = (listener) => {
+			if (!pendingExit) return;
+			listener(pendingExit);
+		};
+		const terminalOptions = {
+			cols,
+			rows,
+			name: options.name,
+			data: (_term, data) => {
+				dispatchData(decoder.decode(data, { stream: true }));
+			},
+			exit: () => {
+				dispatchData(decoder.decode());
+			}
+		};
+		let terminal;
+		let killed = false;
+		const proc = Bun.spawn([command, ...args], {
+			cwd: options.cwd,
+			env: options.env,
+			terminal: terminalOptions,
+			onExit(subprocess, exitCode, _signalCode) {
+				dispatchData(decoder.decode());
+				const signal = subprocess.signalCode ?? void 0;
+				dispatchExit({
+					exitCode: exitCode ?? (killed ? -1 : 0),
+					signal
+				});
+			}
+		});
+		terminal = proc.terminal;
+		if (!terminal) throw new Error("expected Bun.spawn(..., { terminal }) to attach a PTY terminal");
+		terminal.setRawMode(true);
+		return {
+			pid: proc.pid,
+			get cols() {
+				return cols;
+			},
+			get rows() {
+				return rows;
+			},
+			write: (data) => {
+				terminal?.write(data);
+			},
+			resize: (nextCols, nextRows) => {
+				cols = nextCols;
+				rows = nextRows;
+				terminal?.resize(nextCols, nextRows);
+			},
+			kill: (signal) => {
+				killed = true;
+				if (signal) proc.kill(signal);
+				else proc.kill();
+				terminal?.close();
+			},
+			onData: (listener) => {
+				dataListeners.add(listener);
+				flushPendingDataTo(listener);
+				if (dataListeners.size === 1) queueMicrotask(() => {
+					pendingData.length = 0;
+				});
+				return createDisposable(dataListeners, listener);
+			},
+			onExit: (listener) => {
+				exitListeners.add(listener);
+				flushExitTo(listener);
+				return createDisposable(exitListeners, listener);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/pty/default_adapter.ts
+function resolvePtyBackend(value) {
+	const backend = (value ?? process.env.TUI_TEST_PTY_BACKEND ?? "auto").toLowerCase();
+	if (backend === "auto" || backend === "bun-terminal" || backend === "bun-pty") return backend;
+	throw new Error(`unknown PTY backend: ${value ?? ""}`);
+}
+function createDefaultPtyAdapter(value) {
+	const backend = resolvePtyBackend(value);
+	if (backend === "bun-pty") return new BunPtyAdapter();
+	if (backend === "bun-terminal") return new BunTerminalAdapter();
+	return process.platform === "win32" ? new BunPtyAdapter() : new BunTerminalAdapter();
+}
+//#endregion
+//#region src/session/session_manager.ts
+var SessionManager = class {
+	ptyAdapter;
+	snapshotRingSize;
+	sessions = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.ptyAdapter = options?.ptyAdapter ?? createDefaultPtyAdapter();
+		this.snapshotRingSize = options?.snapshotRingSize ?? 50;
+	}
+	listSessionIds() {
+		return [...this.sessions.keys()];
+	}
+	listSessions() {
+		return [...this.sessions.values()];
+	}
+	getSession(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	launchSession(args) {
+		const sessionId = crypto.randomUUID();
+		const cols = clampInt$2(args.cols ?? 80, 1, 500);
+		const rows = clampInt$2(args.rows ?? 24, 1, 300);
+		const cwd = args.cwd ?? process.cwd();
+		const term = args.env?.TERM ?? args.name ?? "xterm-256color";
+		const env = mergeEnv({
+			TERM: term,
+			COLORTERM: "truecolor"
+		}, args.env);
+		const pty = this.ptyAdapter.spawn(args.command, args.args ?? [], {
+			cols,
+			rows,
+			cwd,
+			name: term,
+			env
+		});
+		const traceEnv = pickTraceEnv(env);
+		const traceCommand = [args.command, ...args.args ?? []].join(" ").trim();
+		const session = new TerminalSession({
+			id: sessionId,
+			pty,
+			cols,
+			rows,
+			snapshotRingSize: this.snapshotRingSize,
+			trace: {
+				command: traceCommand,
+				args: args.args ?? [],
+				cwd,
+				env: traceEnv
+			}
+		});
+		this.sessions.set(sessionId, session);
+		return session;
+	}
+	closeSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return false;
+		session.close();
+		this.sessions.delete(sessionId);
+		return true;
+	}
+	closeAll() {
+		for (const [id, session] of this.sessions) {
+			session.close();
+			this.sessions.delete(id);
+		}
+	}
+};
+function clampInt$2(value, min, max) {
+	if (!Number.isFinite(value)) return min;
+	const int = Math.trunc(value);
+	if (int < min) return min;
+	if (int > max) return max;
+	return int;
+}
+function mergeEnv(base, override) {
+	const env = {};
+	for (const [k, v] of Object.entries(process.env)) if (typeof v === "string") env[k] = v;
+	for (const [k, v] of Object.entries(base)) env[k] = v;
+	if (override) for (const [k, v] of Object.entries(override)) env[k] = v;
+	return env;
+}
+function pickTraceEnv(env) {
+	const picked = {};
+	for (const key of [
+		"TERM",
+		"COLORTERM",
+		"LANG",
+		"LC_ALL"
+	]) {
+		const value = env[key];
+		if (value) picked[key] = value;
+	}
+	return picked;
+}
+//#endregion
+//#region src/terminal/view.ts
+function formatSnapshotView(options) {
+	const lineNumbers = options.lineNumbers ?? true;
+	const cursorViewportRow = options.meta.baseY + options.meta.cursorY - options.meta.viewportY;
+	const cursorViewportCol = options.meta.cursorX;
+	const header = [
+		`session=${options.sessionId}`,
+		`scope=${options.scope}`,
+		`size=${options.meta.cols}x${options.meta.rows}`,
+		`buffer=${options.meta.bufferType}`,
+		`cursor=${cursorViewportCol + 1},${cursorViewportRow + 1}`,
+		`hash=${options.hash}`
+	].join(" ");
+	const digits = Math.max(2, String(options.lines.length).length);
+	const out = [header];
+	for (let i = 0; i < options.lines.length; i += 1) {
+		const n = i + 1;
+		const prefix = lineNumbers ? `${String(n).padStart(digits, "0")}│ ` : "";
+		out.push(`${prefix}${options.lines[i] ?? ""}`);
+	}
+	return out.join("\n");
+}
+//#endregion
+//#region src/trace/asciinema_player_assets.ts
+function ensureAsciinemaPlayerAssets(reportPath) {
+	const dir = dirname(reportPath);
+	const cssPath = join(dir, "asciinema-player.css");
+	const jsPath = join(dir, "asciinema-player.min.js");
+	const cssExists = existsSync(cssPath);
+	const jsExists = existsSync(jsPath);
+	if (cssExists && jsExists) return {
+		ok: true,
+		copied: false,
+		cssPath,
+		jsPath
+	};
+	try {
+		mkdirSync(dir, { recursive: true });
+		const require = createRequire(import.meta.url);
+		const resolvedCss = require.resolve("asciinema-player/dist/bundle/asciinema-player.css");
+		const resolvedJs = require.resolve("asciinema-player/dist/bundle/asciinema-player.min.js");
+		if (!cssExists) copyFileSync(resolvedCss, cssPath);
+		if (!jsExists) copyFileSync(resolvedJs, jsPath);
+		return {
+			ok: true,
+			copied: true,
+			cssPath,
+			jsPath
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			copied: false,
+			cssPath,
+			jsPath,
+			error: error.message
+		};
+	}
+}
+//#endregion
+//#region src/trace/report.ts
+async function generateTraceReportHtml(cast, options) {
+	const parsed = parseAsciicast(cast);
+	const termInfo = getTermInfo(parsed.header);
+	const terminal = new Terminal({
+		cols: termInfo.cols,
+		rows: termInfo.rows,
+		allowProposedApi: true,
+		scrollback: 2e3,
+		convertEol: true
+	});
+	const scope = options?.scope ?? "visible";
+	const maxFrames = options?.maxFrames ?? 200;
+	const scriptName = options?.scriptName?.trim() ? options.scriptName.trim() : "";
+	const result = options?.result;
+	const artifacts = options?.artifacts;
+	const steps = options?.steps;
+	let writeChain = Promise.resolve();
+	const frames = [];
+	let previousRowSignatures = null;
+	const capture = (args) => {
+		if (frames.length >= maxFrames) return;
+		let viewHtml;
+		let changedCount;
+		if (args.overrideViewText) {
+			const parsedView = parseSnapshotViewText(args.overrideViewText.text);
+			const headerLine = parsedView.headerLine ?? (args.overrideViewText.hash?.trim() ? `hash=${args.overrideViewText.hash.trim()}` : "snapshot");
+			const rowSignatures = parsedView.rows.map((r) => r.text);
+			const changedLines = diffLineIndices(previousRowSignatures ?? [], rowSignatures);
+			previousRowSignatures = rowSignatures;
+			changedCount = changedLines.size;
+			viewHtml = renderSnapshotViewTextHtml({
+				headerLine,
+				rows: parsedView.rows,
+				changedLines
+			});
+		} else {
+			let lines;
+			let hash;
+			let changedLines = /* @__PURE__ */ new Set();
+			if (scope === "visible") {
+				const grid = snapshotGrid(terminal, {
+					trimRight: true,
+					includeStyles: true
+				});
+				lines = grid.lines;
+				hash = fnv1a32(JSON.stringify(grid));
+				const rowSignatures = lines.map((line, idx) => {
+					const runs = grid.styleRuns?.[idx] ?? [];
+					if (line === "" && runs.length === 0) return "";
+					return `${line}\n${JSON.stringify(runs)}`;
+				});
+				changedLines = diffLineIndices(previousRowSignatures ?? [], rowSignatures);
+				previousRowSignatures = rowSignatures;
+			} else {
+				lines = snapshotLines(terminal, {
+					scope,
+					trimRight: true
+				});
+				hash = fnv1a32(lines.join("\n"));
+			}
+			changedCount = changedLines.size;
+			viewHtml = renderSnapshotViewHtml({
+				terminal,
+				sessionId: "replay",
+				scope,
+				hash,
+				lines,
+				meta: getMeta(terminal),
+				lineNumbers: true,
+				changedLines,
+				trimRight: true
+			});
+		}
+		const previousFrame = frames.at(-1);
+		frames.push({
+			id: `frame-${frames.length + 1}`,
+			atSeconds: args.atSeconds,
+			kind: args.kind,
+			label: args.label,
+			markLabel: args.markLabel,
+			viewHtml,
+			changedCount,
+			stepInfo: args.stepInfo,
+			previousViewHtml: previousFrame?.viewHtml
+		});
+	};
+	if (steps && steps.length > 0) for (let i = 0; i < steps.length; i += 1) {
+		const stepRec = steps[i];
+		if (!stepRec) continue;
+		const stepLabel = formatStepLabel$1(stepRec.step);
+		const viewText = stepRec.after?.text ?? "";
+		const displayIndex = (typeof stepRec.index === "number" ? stepRec.index : i) + 1;
+		const stepType = stepRec.step.type;
+		const kind = stepType === "mark" ? "mark" : stepType === "resize" ? "resize" : "step";
+		const markLabel = kind === "mark" && typeof stepRec.step.label === "string" ? String(stepRec.step.label) : void 0;
+		const stepParams = {};
+		for (const [key, value] of Object.entries(stepRec.step)) if (key !== "type") stepParams[key] = value;
+		capture({
+			atSeconds: displayIndex,
+			kind,
+			label: stepLabel,
+			markLabel,
+			stepInfo: {
+				index: displayIndex,
+				type: stepType,
+				ok: stepRec.ok,
+				error: stepRec.error,
+				params: Object.keys(stepParams).length > 0 ? stepParams : void 0,
+				durationMs: typeof stepRec.durationMs === "number" ? stepRec.durationMs : void 0
+			},
+			overrideViewText: {
+				text: viewText,
+				hash: stepRec.after?.hash
+			}
+		});
+		if (frames.length >= maxFrames) break;
+	}
+	else {
+		for (const event of parsed.events) {
+			const [time, type, data] = event;
+			if (type === "o") writeChain = writeChain.then(() => writeTerminal(terminal, data));
+			else if (type === "r") writeChain.then(() => {
+				const resized = parseResize(data);
+				if (resized) terminal.resize(resized.cols, resized.rows);
+				capture({
+					atSeconds: time,
+					kind: "resize",
+					label: `resize ${data}`
+				});
+			});
+			else if (type === "m") writeChain.then(() => {
+				const markLabel = (data ?? "").trim();
+				capture({
+					atSeconds: time,
+					kind: "mark",
+					label: markLabel ? `mark ${markLabel}` : "mark",
+					markLabel
+				});
+			});
+		}
+		await writeChain;
+		capture({
+			atSeconds: parsed.events.at(-1)?.[0] ?? 0,
+			kind: "final",
+			label: "final"
+		});
+	}
+	terminal.dispose();
+	return renderHtml({
+		cast,
+		header: parsed.header,
+		term: termInfo,
+		scope,
+		scriptName,
+		result,
+		artifacts,
+		frames,
+		eventCount: parsed.events.length
+	});
+}
+function formatStepLabel$1(step) {
+	const showText = envTruthy$1(process.env.PTYWRIGHT_REPORT_SHOW_STEP_TEXT);
+	if (step.type === "custom" && typeof step.name === "string") return `custom(${step.name})`;
+	if (step.type === "sendText") {
+		const enter = typeof step.enter === "boolean" ? step.enter : void 0;
+		const enterSuffix = enter !== void 0 ? `enter=${enter}` : "";
+		const description = typeof step.description === "string" ? step.description : "";
+		const text = typeof step.text === "string" ? step.text : description;
+		if (!text) return enterSuffix ? `sendText (${enterSuffix})` : "sendText";
+		if (!showText) return `sendText <redacted> (len=${text.length}${enterSuffix ? `, ${enterSuffix}` : ""})`;
+		return `sendText "${truncateInline$1(text)}"${enterSuffix ? ` (${enterSuffix})` : ""}`;
+	}
+	if (step.type === "waitForText") {
+		const text = typeof step.text === "string" ? step.text : void 0;
+		const regex = typeof step.regex === "string" ? step.regex : void 0;
+		const description = typeof step.description === "string" ? step.description : void 0;
+		if (!showText) {
+			if (text) return "waitForText (text)";
+			if (regex) return "waitForText (regex)";
+			return "waitForText";
+		}
+		if (text) return `waitFor "${truncateInline$1(text)}"`;
+		if (regex) return `waitFor /${truncateInline$1(regex)}/`;
+		if (description) return `waitForText "${truncateInline$1(description)}"`;
+		return "waitForText";
+	}
+	if (step.type === "assert") {
+		const text = typeof step.text === "string" ? step.text : void 0;
+		const regex = typeof step.regex === "string" ? step.regex : void 0;
+		const description = typeof step.description === "string" ? step.description : void 0;
+		if (!showText) {
+			if (text) return "assert (text)";
+			if (regex) return "assert (regex)";
+			return "assert";
+		}
+		if (text) return `assert "${truncateInline$1(text)}"`;
+		if (regex) return `assert /${truncateInline$1(regex)}/`;
+		if (description) return `assert "${truncateInline$1(description)}"`;
+		return "assert";
+	}
+	if (step.type === "pressKey" && typeof step.key === "string") return `pressKey ${step.key}`;
+	if (step.type === "mark") {
+		const label = typeof step.label === "string" ? step.label.trim() : "";
+		return label ? `mark ${label}` : "mark";
+	}
+	if (step.type === "resize") {
+		const cols = typeof step.cols === "number" ? step.cols : void 0;
+		const rows = typeof step.rows === "number" ? step.rows : void 0;
+		if (cols !== void 0 && rows !== void 0) return `resize ${cols}x${rows}`;
+		return "resize";
+	}
+	return step.type;
+}
+function truncateInline$1(text, maxChars = 60) {
+	const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\\n");
+	if (normalized.length <= maxChars) return normalized;
+	return `${normalized.slice(0, maxChars)}…(+${normalized.length - maxChars})`;
+}
+function envTruthy$1(value) {
+	if (!value?.trim()) return false;
+	const normalized = value.trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function stripAnsi(str) {
+	return str.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function parseSnapshotViewText(viewText) {
+	const lines = stripAnsi(viewText).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+	const first = lines[0] ?? "";
+	const hasHeader = /\bsession=/.test(first) && /\bhash=/.test(first);
+	return {
+		headerLine: hasHeader ? first : null,
+		rows: (hasHeader ? lines.slice(1) : lines).map((line) => {
+			const match = line.match(/^(\d+│\s)(.*)$/);
+			if (!match) return { text: line };
+			return {
+				prefix: match[1],
+				text: match[2] ?? ""
+			};
+		})
+	};
+}
+function renderSnapshotViewTextHtml(options) {
+	const digits = Math.max(2, String(options.rows.length).length);
+	const out = [`<span class="headerblock">${escapeHtml(options.headerLine)}</span>`];
+	for (let i = 0; i < options.rows.length; i += 1) {
+		const row = options.rows[i];
+		const prefixHtml = `<span class="ln">${escapeHtml(row?.prefix ?? `${String(i + 1).padStart(digits, "0")}│ `)}</span>`;
+		const rowClass = options.changedLines.has(i) ? "row changed" : "row";
+		out.push(`<span class="${rowClass}">${prefixHtml}${escapeHtml(row?.text ?? "")}</span>`);
+	}
+	return out.join("");
+}
+async function writeTerminal(terminal, data) {
+	await new Promise((resolve) => {
+		terminal.write(data, resolve);
+	});
+}
+function renderHtml(input) {
+	const title = input.scriptName || coerceDisplayString(input.header.title) || "ptywright trace report";
+	const command = coerceDisplayString(input.header.command);
+	const timestamp = input.header.timestamp;
+	const headerJson = JSON.stringify(input.header, null, 2);
+	const durationSeconds = input.frames.at(-1)?.atSeconds ?? 0;
+	const markFrames = input.frames.filter((f) => f.kind === "mark");
+	const resultLabel = input.result?.ok === true ? "PASS" : input.result?.ok === false ? "FAIL" : "UNKNOWN";
+	const resultClass = input.result?.ok === true ? "pass" : input.result?.ok === false ? "fail" : "unknown";
+	const artifactsRows = [];
+	if (input.artifacts?.castHref?.trim()) artifactsRows.push({
+		label: "cast",
+		href: input.artifacts.castHref.trim()
+	});
+	if (input.artifacts?.failureErrorHref?.trim()) artifactsRows.push({
+		label: "failure.error.txt",
+		href: input.artifacts.failureErrorHref.trim()
+	});
+	if (input.artifacts?.failureStepHref?.trim()) artifactsRows.push({
+		label: "failure.step.json",
+		href: input.artifacts.failureStepHref.trim()
+	});
+	if (input.artifacts?.failureLastTextHref?.trim()) artifactsRows.push({
+		label: "failure.last.txt",
+		href: input.artifacts.failureLastTextHref.trim()
+	});
+	if (input.artifacts?.failureLastViewHref?.trim()) artifactsRows.push({
+		label: "failure.last.view.txt",
+		href: input.artifacts.failureLastViewHref.trim()
+	});
+	const artifactsHtml = artifactsRows.length === 0 ? `<p class="muted">No artifacts linked.</p>` : `<ul class="artifacts">
+${artifactsRows.map((a) => `<li><a href="${escapeHtml(a.href)}">${escapeHtml(a.label)}</a><span class="muted"> (${escapeHtml(a.href)})</span></li>`).join("\n")}
+</ul>`;
+	const castPlayerHtml = `
+        <p class="muted">Render the full recording using <span class="mono">asciinema-player</span>.</p>
+        <div class="cast-controls">
+          <button id="castToggleSize" class="badge chip" type="button">expand</button>
+          <span id="castPlayerStatus" class="muted mono"></span>
+        </div>
+        <div id="castPlayer" class="cast-player"></div>
+        <script id="castData" type="application/json">${jsonForHtml(input.cast)}<\/script>
+        <script>
+          (function () {
+            const statusEl = document.getElementById("castPlayerStatus");
+            const container = document.getElementById("castPlayer");
+            const castEl = document.getElementById("castData");
+            const toggleBtn = document.getElementById("castToggleSize");
+            if (!container || !castEl) return;
+
+            // Load external assets automatically (no extra click).
+            const VERSION = "3.9.0";
+            const LOCAL_CSS = "./asciinema-player.css";
+            const LOCAL_JS = "./asciinema-player.min.js";
+            // Use multiple CDNs to avoid regional blocks (e.g. jsdelivr).
+            const CDN_BASES = [
+              "https://cdn.jsdelivr.net/npm/asciinema-player@" + VERSION + "/dist/bundle/",
+              "https://unpkg.com/asciinema-player@" + VERSION + "/dist/bundle/",
+            ];
+            const CSS_URLS = [LOCAL_CSS, ...CDN_BASES.map((b) => b + "asciinema-player.css")];
+            const JS_URLS = [LOCAL_JS, ...CDN_BASES.map((b) => b + "asciinema-player.min.js")];
+
+            function setStatus(text) {
+              if (statusEl) statusEl.textContent = text ? " " + text : "";
+            }
+
+            async function loadCssOnce() {
+              if (document.getElementById("asciinemaPlayerCss")) return;
+
+              for (const href of CSS_URLS) {
+                try {
+                  await new Promise((resolve, reject) => {
+                    const link = document.createElement("link");
+                    link.id = "asciinemaPlayerCss";
+                    link.rel = "stylesheet";
+                    link.href = href;
+                    link.onload = resolve;
+                    link.onerror = reject;
+                    document.head.appendChild(link);
+                  });
+                  return;
+                } catch {
+                  const el = document.getElementById("asciinemaPlayerCss");
+                  if (el) el.remove();
+                }
+              }
+            }
+
+            function loadScriptOnce() {
+              return new Promise((resolve, reject) => {
+                if (window.AsciinemaPlayer) return resolve(window.AsciinemaPlayer);
+                const existing = document.getElementById("asciinemaPlayerJs");
+                if (existing) {
+                  // If another instance is loading, poll until available.
+                  const startedAt = Date.now();
+                  const poll = setInterval(() => {
+                    if (window.AsciinemaPlayer) {
+                      clearInterval(poll);
+                      resolve(window.AsciinemaPlayer);
+                    } else if (Date.now() - startedAt > 15000) {
+                      clearInterval(poll);
+                      reject(new Error("timeout loading asciinema-player"));
+                    }
+                  }, 100);
+                  return;
+                }
+
+                let idx = 0;
+                const tryNext = () => {
+                  const src = JS_URLS[idx++];
+                  if (!src) {
+                    reject(new Error("failed to load asciinema-player"));
+                    return;
+                  }
+
+                  const script = document.createElement("script");
+                  script.id = "asciinemaPlayerJs";
+                  script.src = src;
+                  script.async = true;
+                  script.onload = () => resolve(window.AsciinemaPlayer);
+                  script.onerror = () => {
+                    script.remove();
+                    if (window.AsciinemaPlayer) {
+                      resolve(window.AsciinemaPlayer);
+                      return;
+                    }
+                    tryNext();
+                  };
+                  document.head.appendChild(script);
+                };
+                tryNext();
+              });
+            }
+
+            function computeMarkers(castText) {
+              try {
+                const lines = String(castText || "").trimEnd().split("\\n");
+                const out = [];
+                for (let i = 1; i < lines.length; i++) {
+                  const line = (lines[i] || "").trim();
+                  if (!line) continue;
+                  const value = JSON.parse(line);
+                  if (!Array.isArray(value) || value.length < 3) continue;
+                  const t = Number(value[0]);
+                  const type = String(value[1]);
+                  const data = String(value[2]);
+                  if (!Number.isFinite(t)) continue;
+
+                  // Prefer explicit marks when present.
+                  if (type === "m") out.push(t);
+
+                  // Also mark "Enter" submissions (helps jump between commands).
+                  if (type === "i" && data.indexOf("\\r") >= 0) out.push(t);
+                }
+
+                out.sort((a, b) => a - b);
+                // Deduplicate with a tiny epsilon to keep the marker list sane.
+                const uniq = [];
+                let last = -1e9;
+                for (const t of out) {
+                  if (t - last > 0.001) {
+                    uniq.push(t);
+                    last = t;
+                  }
+                }
+                // Cap to avoid pathological UIs (e.g. every keypress).
+                return uniq.slice(0, 200);
+              } catch {
+                return [];
+              }
+            }
+
+            function toggleSize(player) {
+              container.classList.toggle("expanded");
+              if (toggleBtn) {
+                toggleBtn.textContent = container.classList.contains("expanded")
+                  ? "collapse"
+                  : "expand";
+              }
+              // Nudge the player to re-render after resize.
+              try {
+                if (player && typeof player.getCurrentTime === "function" && typeof player.seek === "function") {
+                  const t = player.getCurrentTime();
+                  player.seek(t);
+                }
+              } catch {
+                // ignore
+              }
+            }
+
+            async function mountPlayer() {
+              setStatus("loading…");
+              await loadCssOnce();
+              const AsciinemaPlayer = await loadScriptOnce();
+              if (!AsciinemaPlayer || !AsciinemaPlayer.create) {
+                throw new Error("AsciinemaPlayer API missing");
+              }
+
+              const castText = JSON.parse(castEl.textContent || '""');
+              const markers = computeMarkers(castText);
+
+              const player = AsciinemaPlayer.create({ data: () => castText }, container, {
+                // Keep it compact inside the report; user can expand if needed.
+                fit: "both",
+                controls: true,
+                preload: true,
+                autoPlay: false,
+                markers: markers.length ? markers : undefined,
+              });
+
+              if (toggleBtn) toggleBtn.addEventListener("click", () => toggleSize(player));
+
+              setStatus("ready");
+            }
+
+            mountPlayer().catch((err) => {
+              setStatus("failed: " + (err && err.message ? err.message : String(err)));
+            });
+          })();
+        <\/script>
+  `;
+	const markListHtml = markFrames.length === 0 ? `<p class="muted">No marks recorded.</p>` : `<ol class="marks">
+${markFrames.map((f) => {
+		const label = f.markLabel?.trim() || "(unnamed)";
+		return `<li><a href="#${escapeHtml(f.id)}">t=${f.atSeconds.toFixed(3)}s — ${escapeHtml(label)}</a></li>`;
+	}).join("\n")}
+</ol>`;
+	const traceData = {
+		version: 2,
+		durationSeconds,
+		frames: input.frames.map((f, idx) => ({
+			index: idx + 1,
+			id: f.id,
+			atSeconds: f.atSeconds,
+			kind: f.kind,
+			label: f.label,
+			markLabel: f.markLabel ?? null,
+			changedCount: f.changedCount,
+			stepInfo: f.stepInfo ?? null
+		}))
+	};
+	const frameListHtml = input.frames.map((frame, idx) => {
+		const statusBadge = frame.stepInfo && frame.stepInfo.ok ? `<span class="badge pass">PASS</span>` : frame.stepInfo && !frame.stepInfo.ok ? `<span class="badge fail">FAIL</span>` : `<span class="badge">INFO</span>`;
+		const changedBadge = frame.changedCount > 0 ? `<span class="badge">changed=${frame.changedCount}</span>` : "";
+		return `<li>
+  <button
+    type="button"
+    class="frame-btn"
+    data-idx="${idx}"
+    data-id="${escapeHtml(frame.id)}"
+    data-kind="${escapeHtml(frame.kind)}"
+    data-ok="${frame.stepInfo ? String(frame.stepInfo.ok) : ""}"
+    data-changed="${String(frame.changedCount)}"
+  >
+    <div class="frame-btn-top">
+      ${statusBadge}
+      ${changedBadge}
+      <span class="mono frame-btn-time">t=${frame.atSeconds.toFixed(3)}s</span>
+    </div>
+    <div class="frame-btn-label mono">${escapeHtml(frame.label)}</div>
+  </button>
+</li>`;
+	}).join("\n");
+	const templatesHtml = input.frames.map((frame) => {
+		const prevTpl = frame.previousViewHtml ? `<template id="prev-${escapeHtml(frame.id)}">${frame.previousViewHtml}</template>` : "";
+		return `<template id="tpl-${escapeHtml(frame.id)}">${frame.viewHtml}</template>${prevTpl}`;
+	}).join("\n");
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+        <style>
+      :root {
+        /* Base Colors - Slate/Zinc inspired */
+        --bg-body: #f8fafc;
+        --bg-card: #ffffff;
+        --bg-subtle: #f1f5f9;
+        --bg-hover: #e2e8f0;
+        --bg-active: #cbd5e1;
+        
+        --border-subtle: #e2e8f0;
+        --border-default: #cbd5e1;
+        --border-active: #94a3b8;
+
+        --text-main: #0f172a;
+        --text-muted: #64748b;
+        --text-faint: #94a3b8;
+
+        /* Accents */
+        --accent-primary: #0f172a; /* Slate 900 */
+        --accent-primary-fg: #f8fafc;
+        --accent-brand: #3b82f6; /* Blue 500 */
+        
+        /* Status Colors */
+        --status-pass-bg: #dcfce7;
+        --status-pass-text: #166534;
+        --status-pass-border: #86efac;
+        
+        --status-fail-bg: #fee2e2;
+        --status-fail-text: #991b1b;
+        --status-fail-border: #fca5a5;
+        
+        --status-info-bg: #e0f2fe;
+        --status-info-text: #075985;
+        --status-info-border: #7dd3fc;
+        
+        --status-changed-bg: #fef3c7;
+        --status-changed-text: #92400e;
+
+        /* Fonts */
+        --font-sans: "Inter", ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+        --font-mono: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+
+        /* Shadows */
+        --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+        --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+      }
+
+      @media (prefers-color-scheme: dark) {
+        :root {
+          /* Dark Mode Base */
+          --bg-body: #0f172a;
+          --bg-card: #1e293b;
+          --bg-subtle: #334155;
+          --bg-hover: #475569;
+          --bg-active: #64748b;
+
+          --border-subtle: #334155;
+          --border-default: #475569;
+          --border-active: #64748b;
+
+          --text-main: #f8fafc;
+          --text-muted: #94a3b8;
+          --text-faint: #64748b;
+
+          --accent-primary: #f8fafc;
+          --accent-primary-fg: #0f172a;
+          --accent-brand: #60a5fa; /* Blue 400 */
+
+          /* Dark Mode Status */
+          --status-pass-bg: #052e16;
+          --status-pass-text: #4ade80;
+          --status-pass-border: #166534;
+
+          --status-fail-bg: #450a0a;
+          --status-fail-text: #f87171;
+          --status-fail-border: #991b1b;
+
+          --status-info-bg: #082f49;
+          --status-info-text: #38bdf8;
+          --status-info-border: #075985;
+          
+          --status-changed-bg: #451a03;
+          --status-changed-text: #fbbf24;
+        }
+      }
+
+      body {
+        margin: 0;
+        background-color: var(--bg-body);
+        color: var(--text-main);
+        font-family: var(--font-sans);
+        line-height: 1.5;
+        font-size: 14px;
+        -webkit-font-smoothing: antialiased;
+      }
+      
+      * {
+        box-sizing: border-box;
+      }
+
+      /* Layout & Containers */
+      header {
+        background-color: var(--bg-card);
+        padding: 16px 24px;
+        border-bottom: 1px solid var(--border-subtle);
+        box-shadow: var(--shadow-sm);
+        position: sticky;
+        top: 0;
+        z-index: 50;
+      }
+
+      main {
+        max-width: 1600px;
+        margin: 0 auto;
+        padding: 24px;
+      }
+
+      .section {
+        margin-bottom: 24px;
+        background-color: var(--bg-card);
+        border: 1px solid var(--border-subtle);
+        border-radius: 12px;
+        padding: 20px;
+        box-shadow: var(--shadow-sm);
+      }
+      
+      h1, h2, h3 {
+        margin: 0;
+        font-weight: 600;
+        letter-spacing: -0.025em;
+      }
+      
+      header h1 {
+        font-size: 20px;
+        margin-bottom: 8px;
+        color: var(--text-main);
+      }
+      
+      h2 {
+        font-size: 16px;
+        margin-bottom: 16px;
+        padding-bottom: 8px;
+        border-bottom: 1px solid var(--border-subtle);
+        color: var(--text-main);
+      }
+
+      /* Typography & Utility */
+      .mono { font-family: var(--font-mono); }
+      .muted { color: var(--text-muted); }
+      
+      a {
+        color: var(--accent-brand);
+        text-decoration: none;
+      }
+      a:hover { text-decoration: underline; }
+
+      pre {
+        margin: 0;
+        font-family: var(--font-mono);
+        font-size: 13px;
+        line-height: normal;
+        white-space: pre;
+        overflow: auto;
+      }
+
+      /* Badges */
+      .badges {
+        display: flex;
+        gap: 8px;
+        flex-wrap: wrap;
+        margin-top: 8px;
+      }
+      
+      .badge {
+        display: inline-flex;
+        align-items: center;
+        padding: 2px 10px;
+        border-radius: 9999px;
+        font-size: 12px;
+        font-weight: 500;
+        border: 1px solid var(--border-default);
+        background-color: var(--bg-subtle);
+        color: var(--text-muted);
+      }
+      
+      .badge.pass {
+        background-color: var(--status-pass-bg);
+        color: var(--status-pass-text);
+        border-color: var(--status-pass-border);
+      }
+      
+      .badge.fail {
+        background-color: var(--status-fail-bg);
+        color: var(--status-fail-text);
+        border-color: var(--status-fail-border);
+      }
+      
+      .badge.chip {
+        cursor: pointer;
+        transition: all 0.2s;
+      }
+      .badge.chip:hover {
+        background-color: var(--bg-hover);
+      }
+      .badge.chip[aria-pressed="true"] {
+        background-color: var(--accent-primary);
+        color: var(--accent-primary-fg);
+        border-color: var(--accent-primary);
+      }
+      /* Special case: toggle badge in header */
+      .badge.toggle { cursor: pointer; user-select: none; }
+      #debugToggle:checked ~ header .badge.toggle {
+        background-color: var(--accent-brand);
+        color: white;
+        border-color: var(--accent-brand);
+      }
+
+      /* Trace Layout */
+      .trace {
+        display: grid;
+        grid-template-columns: 320px 1fr;
+        gap: 24px;
+        height: 70vh;
+        min-height: 500px;
+      }
+      
+      .trace aside {
+        display: flex;
+        flex-direction: column;
+        height: 100%;
+        overflow: hidden;
+      }
+
+      /* Frame List in Sidebar */
+      .controls {
+        display: flex;
+        gap: 8px;
+        flex-wrap: wrap;
+        margin-bottom: 12px;
+        padding-bottom: 12px;
+        border-bottom: 1px solid var(--border-subtle);
+      }
+      
+      .input {
+        width: 100%;
+        font-family: var(--font-mono);
+        font-size: 13px;
+        padding: 8px 12px;
+        border-radius: 6px;
+        border: 1px solid var(--border-default);
+        background-color: var(--bg-body);
+        color: var(--text-main);
+        transition: border-color 0.2s;
+      }
+      .input:focus {
+        outline: none;
+        border-color: var(--accent-brand);
+        box-shadow: 0 0 0 2px var(--bg-body), 0 0 0 4px var(--accent-brand);
+      }
+      
+      .frame-list {
+        list-style: none;
+        padding: 0;
+        margin: 0;
+        overflow-y: auto;
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        gap: 4px;
+      }
+      
+      .frame-btn {
+        width: 100%;
+        text-align: left;
+        padding: 10px 12px;
+        border-radius: 8px;
+        border: 1px solid transparent;
+        background: transparent;
+        color: var(--text-main);
+        cursor: pointer;
+        transition: all 0.1s;
+      }
+      
+      .frame-btn:hover {
+        background-color: var(--bg-hover);
+      }
+      
+      .frame-btn[aria-selected="true"] {
+        background-color: var(--bg-active);
+        border-color: var(--border-active);
+        font-weight: 500;
+      }
+      
+      .frame-btn-top {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin-bottom: 4px;
+        font-size: 11px;
+      }
+      
+      .frame-btn-label {
+        font-family: var(--font-mono);
+        font-size: 12px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      /* Main Viewer */
+      .viewer {
+        display: flex;
+        flex-direction: column;
+        height: 100%;
+        border: 1px solid var(--border-default);
+        border-radius: 8px;
+        overflow: hidden;
+        background-color: var(--bg-body);
+      }
+      
+      .viewer-tabs {
+        display: flex;
+        background-color: var(--bg-subtle);
+        border-bottom: 1px solid var(--border-default);
+      }
+      
+      .viewer-tab {
+        padding: 10px 16px;
+        font-size: 13px;
+        font-weight: 500;
+        color: var(--text-muted);
+        background: transparent;
+        border: none;
+        border-right: 1px solid var(--border-subtle);
+        cursor: pointer;
+        transition: background 0.2s;
+      }
+      
+      .viewer-tab:hover {
+        background-color: var(--bg-hover);
+        color: var(--text-main);
+      }
+      
+      .viewer-tab[aria-selected="true"] {
+        background-color: var(--bg-body);
+        color: var(--accent-brand);
+        box-shadow: inset 0 -2px 0 0 var(--accent-brand);
+      }
+      
+      .viewer-tab.has-error {
+        color: var(--status-fail-text);
+      }
+
+      .viewer-header {
+        padding: 12px 16px;
+        border-bottom: 1px solid var(--border-subtle);
+        background-color: var(--bg-card);
+        font-size: 13px;
+        display: flex;
+        gap: 12px;
+        align-items: baseline;
+      }
+      .viewer-title { font-weight: 600; color: var(--text-main); }
+      .viewer-sub { color: var(--text-faint); font-size: 12px; }
+
+      .viewer-content {
+        flex: 1;
+        overflow: auto;
+        position: relative;
+        display: none;
+      }
+      .viewer-content.active { display: block; }
+
+      /* Terminal Render */
+      .terminal {
+        background-color: #0d1117; /* GitHub Dark dim */
+        color: #c9d1d9;
+        font-family: var(--font-mono);
+        font-size: 13px;
+        line-height: normal;
+        padding: 16px;
+        min-height: 100%;
+      }
+      .terminal .headerblock {
+        color: #8b949e;
+        margin-bottom: 8px;
+        display: block;
+        font-size: 11px;
+      }
+      .terminal .row {
+        display: block;
+      }
+      .terminal .ln {
+        display: inline-block;
+        width: 3ch;
+        margin-right: 1ch;
+        color: #484f58;
+        user-select: none;
+        text-align: right;
+        vertical-align: top;
+      }
+      .terminal .row.changed {
+        background: rgba(187, 128, 9, 0.15); /* Yellow marking */
+      }
+      .terminal .seg { display: inline; }
+
+      /* Hide debug lines if toggle off */
+      #debugToggle:not(:checked) ~ main .terminal .headerblock,
+      #debugToggle:not(:checked) ~ main .terminal .ln {
+        display: none;
+      }
+      #debugToggle:not(:checked) ~ main .terminal .row.changed {
+        background: transparent;
+      }
+      .debug-toggle {
+        position: absolute;
+        width: 0; height: 0; opacity: 0;
+      }
+
+      /* Timeline */
+      .timeline {
+        padding: 6px 0;
+        margin-bottom: 16px;
+      }
+      .timeline-header {
+        display: flex;
+        justify-content: space-between;
+        margin-bottom: 8px;
+        font-size: 12px;
+        color: var(--text-muted);
+        font-family: var(--font-mono);
+      }
+      .timeline-track {
+        height: 32px;
+        background-color: var(--bg-subtle);
+        border: 1px solid var(--border-default);
+        border-radius: 4px;
+        position: relative;
+        cursor: pointer;
+        overflow: hidden;
+      }
+      .timeline-bar {
+        position: absolute;
+        top: 4px; bottom: 4px;
+        background-color: var(--border-active);
+        border-radius: 1px;
+        min-width: 2px;
+      }
+      .timeline-bar.pass { background-color: var(--status-pass-border); }
+      .timeline-bar.fail { background-color: var(--status-fail-text); }
+      .timeline-bar.info { background-color: var(--status-info-border); }
+      .timeline-bar.selected {
+        background-color: var(--accent-brand);
+        z-index: 10;
+        top: 0; bottom: 0;
+        box-shadow: 0 0 0 1px white;
+      }
+      
+      /* Other Components */
+      .call-row {
+        display: grid;
+        grid-template-columns: 100px 1fr;
+        gap: 16px;
+        padding: 8px 16px;
+        border-bottom: 1px solid var(--border-subtle);
+        font-size: 13px;
+      }
+      .call-key { color: var(--text-muted); font-weight: 500; text-align: right; }
+      .call-value { color: var(--text-main); font-family: var(--font-mono); }
+      
+      .error-box {
+        margin: 16px;
+        padding: 16px;
+        background-color: var(--status-fail-bg);
+        border: 1px solid var(--status-fail-border);
+        border-radius: 6px;
+        color: var(--status-fail-text);
+      }
+      .error-title { font-weight: 700; margin-bottom: 8px; }
+
+      .diff-view {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        height: 100%;
+      }
+      .diff-pane {
+        overflow: auto;
+        border-right: 1px solid #30363d;
+        background-color: #0d1117;
+      }
+      .diff-pane-header {
+        background: #161b22;
+        color: #8b949e;
+        padding: 8px 16px;
+        font-size: 11px;
+        font-weight: 600;
+        border-bottom: 1px solid #30363d;
+        position: sticky;
+        top: 0;
+      }
+      /* Built-in player */
+      .builtin-player {
+        background: #0b0f14;
+        border-radius: 10px;
+        overflow: hidden;
+        border: 1px solid color-mix(in oklab, currentColor 14%, transparent);
+      }
+      /* Cast player styles */
+      .cast-player {
+        height: 450px;
+        min-height: 200px;
+        max-height: 450px;
+        overflow: hidden;
+        background: transparent;
+        margin-top: 16px;
+        margin-bottom: 20px;
+        border-bottom: 1px solid var(--border-subtle);
+      }
+      
+      /* Force left alignment of the player */
+      .cast-player .ap-wrapper {
+        display: flex;
+        justify-content: flex-start !important;
+        text-align: left;
+      }
+      
+      /* Style the inner player terminal box */
+      .cast-player .ap-player {
+        border-radius: 8px;
+        box-shadow: var(--shadow-md);
+        border: 1px solid var(--border-subtle);
+      }
+
+      .cast-player.expanded {
+        height: 80vh;
+      }
+      
+      .cast-controls {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        margin: 12px 0;
+        padding-bottom: 12px;
+        border-bottom: 1px solid var(--border-subtle);
+      }
+      
+      @media (max-width: 1024px) {
+        .trace { grid-template-columns: 1fr; height: auto; }
+        .viewer { height: 500px; }
+        .frame-list { max-height: 300px; }
+      }
+    </style>
+  </head>
+  <body>
+    <input id="debugToggle" class="debug-toggle" type="checkbox" checked />
+    <header>
+      <h1>${escapeHtml(title)}</h1>
+      <div class="badges">
+        <span class="badge ${resultClass}">result=${escapeHtml(resultLabel)}</span>
+        <span class="badge">marks=${markFrames.length}</span>
+        <span class="badge">duration=${durationSeconds.toFixed(3)}s</span>
+        <label class="badge toggle" for="debugToggle">debug</label>
+      </div>
+      <div class="meta">term=${escapeHtml(input.term.type)} ${input.term.cols}x${input.term.rows} scope=${escapeHtml(input.scope)} events=${input.eventCount}
+command=${escapeHtml(command)}
+timestamp=${escapeHtml(coerceDisplayString(timestamp))}</div>
+      <details>
+        <summary>Raw header JSON</summary>
+        <pre>${escapeHtml(headerJson)}</pre>
+      </details>
+    </header>
+    <main>
+      <section class="section">
+        <h2>Task</h2>
+        <pre>${escapeHtml([
+		input.scriptName ? `script=${input.scriptName}` : null,
+		command ? `command=${command}` : null,
+		`term=${input.term.type} ${input.term.cols}x${input.term.rows}`,
+		`scope=${input.scope}`
+	].filter(Boolean).join("\n"))}</pre>
+      </section>
+      <section class="section">
+        <h2>Artifacts</h2>
+        ${artifactsHtml}
+      </section>
+      <section class="section" id="cast-playback">
+        <h2>Cast Playback</h2>
+        ${castPlayerHtml}
+      </section>
+      <section class="section">
+        <h2>Marks</h2>
+        ${markListHtml}
+      </section>
+      <section class="section">
+        <h2>Trace</h2>
+        <!-- Timeline -->
+        <div class="timeline" id="timeline">
+          <div class="timeline-header">
+            <span class="mono">Timeline</span>
+            <span class="mono muted" id="timelineInfo">0 steps · 0.000s</span>
+          </div>
+          <div class="timeline-track" id="timelineTrack"></div>
+        </div>
+        <div class="trace">
+          <aside>
+            <div class="controls">
+              <input id="frameSearch" class="input mono" placeholder="Search frames…" autocomplete="off" />
+              <button id="modeAll" class="badge chip" type="button" aria-pressed="true">all</button>
+              <button id="modeChanged" class="badge chip" type="button" aria-pressed="false">changed</button>
+              <button id="modeMarks" class="badge chip" type="button" aria-pressed="false">marks</button>
+              <button id="modeFailed" class="badge chip fail" type="button" aria-pressed="false">failed</button>
+              <span id="visibleFrames" class="badge">visible=0</span>
+            </div>
+            <ol id="frameList" class="frame-list">
+              ${frameListHtml}
+            </ol>
+          </aside>
+          <div class="viewer">
+            <div class="viewer-tabs" id="viewerTabs">
+              <button class="viewer-tab" data-tab="snapshot" aria-selected="true">Snapshot</button>
+              <button class="viewer-tab" data-tab="call">Call</button>
+              <button class="viewer-tab" data-tab="errors" id="errorsTab">Errors</button>
+              <button class="viewer-tab" data-tab="diff">Diff</button>
+            </div>
+            <div class="viewer-header">
+              <span id="viewerTitle" class="viewer-title mono"></span>
+              <span id="viewerSub" class="viewer-sub mono muted"></span>
+            </div>
+            <div id="viewerSnapshot" class="viewer-content active">
+              <pre id="viewer" class="terminal"></pre>
+            </div>
+            <div id="viewerCall" class="viewer-content">
+              <div class="call-details" id="callDetails"></div>
+            </div>
+            <div id="viewerErrors" class="viewer-content">
+              <div id="errorContent"></div>
+            </div>
+            <div id="viewerDiff" class="viewer-content">
+              <div class="diff-view" id="diffView">
+                <div class="diff-pane">
+                  <div class="diff-pane-header">Previous</div>
+                  <pre id="diffPrev" class="terminal"></pre>
+                </div>
+                <div class="diff-pane">
+                  <div class="diff-pane-header">Current</div>
+                  <pre id="diffCurr" class="terminal"></pre>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div class="muted mono" style="margin-top: 10px;">Tips: click a frame or timeline bar, use ↑/↓ (j/k) to navigate, 1-4 to switch tabs.</div>
+        <script id="traceData" type="application/json">${jsonForHtml(traceData)}<\/script>
+        ${templatesHtml}
+        <script>
+          (function () {
+            const dataEl = document.getElementById("traceData");
+            const listEl = document.getElementById("frameList");
+            const viewerEl = document.getElementById("viewer");
+            const titleEl = document.getElementById("viewerTitle");
+            const subEl = document.getElementById("viewerSub");
+            const searchEl = document.getElementById("frameSearch");
+            const visibleEl = document.getElementById("visibleFrames");
+            const modeAll = document.getElementById("modeAll");
+            const modeChanged = document.getElementById("modeChanged");
+            const modeMarks = document.getElementById("modeMarks");
+            const modeFailed = document.getElementById("modeFailed");
+            const timelineTrack = document.getElementById("timelineTrack");
+            const timelineInfo = document.getElementById("timelineInfo");
+            const viewerTabs = document.getElementById("viewerTabs");
+            const callDetails = document.getElementById("callDetails");
+            const errorContent = document.getElementById("errorContent");
+            const diffPrev = document.getElementById("diffPrev");
+            const diffCurr = document.getElementById("diffCurr");
+            const errorsTab = document.getElementById("errorsTab");
+            if (!dataEl || !listEl || !viewerEl || !titleEl || !subEl || !searchEl) return;
+
+            const raw = JSON.parse(dataEl.textContent || "{}");
+            const frames = Array.isArray(raw.frames) ? raw.frames : [];
+            const durationSeconds = raw.durationSeconds || 0;
+            const buttons = Array.from(listEl.querySelectorAll("button.frame-btn"));
+            const idToIndex = new Map();
+            for (const f of frames) idToIndex.set(f.id, f.index - 1);
+
+            let mode = "all";
+            let current = 0;
+            let activeTab = "snapshot";
+
+            // Timeline setup
+            if (timelineTrack && frames.length > 0) {
+              const maxTime = Math.max(durationSeconds, frames[frames.length - 1]?.atSeconds || 1);
+              timelineInfo.textContent = frames.length + " steps · " + maxTime.toFixed(3) + "s";
+
+              frames.forEach((f, idx) => {
+                const bar = document.createElement("div");
+                bar.className = "timeline-bar";
+                const left = (f.atSeconds / maxTime) * 100;
+                const width = Math.max(2, (1 / frames.length) * 100);
+                bar.style.left = left + "%";
+                bar.style.width = width + "%";
+
+                if (f.stepInfo) {
+                  bar.classList.add(f.stepInfo.ok ? "pass" : "fail");
+                } else {
+                  bar.classList.add("info");
+                }
+
+                bar.dataset.idx = idx;
+                bar.title = f.label;
+                bar.addEventListener("click", () => select(idx, true));
+                timelineTrack.appendChild(bar);
+
+                // Add error markers
+                if (f.stepInfo && !f.stepInfo.ok) {
+                  const marker = document.createElement("div");
+                  marker.className = "timeline-marker error";
+                  marker.style.left = left + "%";
+                  timelineTrack.appendChild(marker);
+                }
+
+                // Add mark markers
+                if (f.kind === "mark") {
+                  const marker = document.createElement("div");
+                  marker.className = "timeline-marker";
+                  marker.style.left = left + "%";
+                  timelineTrack.appendChild(marker);
+                }
+              });
+            }
+
+            // Tab switching
+            const tabs = viewerTabs ? Array.from(viewerTabs.querySelectorAll(".viewer-tab")) : [];
+            const contents = {
+              snapshot: document.getElementById("viewerSnapshot"),
+              call: document.getElementById("viewerCall"),
+              errors: document.getElementById("viewerErrors"),
+              diff: document.getElementById("viewerDiff"),
+            };
+
+            function switchTab(tabName) {
+              activeTab = tabName;
+              tabs.forEach(t => t.setAttribute("aria-selected", t.dataset.tab === tabName ? "true" : "false"));
+              Object.entries(contents).forEach(([name, el]) => {
+                if (el) el.classList.toggle("active", name === tabName);
+              });
+            }
+
+            tabs.forEach(tab => {
+              tab.addEventListener("click", () => switchTab(tab.dataset.tab));
+            });
+
+            function setPressed(el, on) {
+              el.setAttribute("aria-pressed", on ? "true" : "false");
+            }
+
+            function setMode(next) {
+              mode = next;
+              setPressed(modeAll, mode === "all");
+              setPressed(modeChanged, mode === "changed");
+              setPressed(modeMarks, mode === "marks");
+              setPressed(modeFailed, mode === "failed");
+              applyFilter();
+            }
+
+            function applyFilter() {
+              const q = (searchEl.value || "").trim().toLowerCase();
+              let visible = 0;
+              for (const btn of buttons) {
+                const idx = Number(btn.dataset.idx || "0");
+                let show = true;
+                if (mode === "changed") show = Number(btn.dataset.changed || "0") > 0;
+                else if (mode === "marks") show = btn.dataset.kind === "mark";
+                else if (mode === "failed") show = btn.dataset.ok === "false";
+                if (show && q) {
+                  const label = (btn.querySelector(".frame-btn-label")?.textContent || "").toLowerCase();
+                  if (!label.includes(q)) show = false;
+                }
+                btn.parentElement.style.display = show ? "" : "none";
+                if (show) visible += 1;
+              }
+              if (visibleEl) visibleEl.textContent = "visible=" + visible;
+
+              if (buttons[current] && buttons[current].parentElement.style.display === "none") {
+                const firstVisible = buttons.findIndex((b) => b.parentElement.style.display !== "none");
+                if (firstVisible >= 0) select(firstVisible, false);
+              } else {
+                updateSelected();
+              }
+            }
+
+            function updateSelected() {
+              for (const btn of buttons) {
+                const idx = Number(btn.dataset.idx || "0");
+                btn.setAttribute("aria-selected", idx === current ? "true" : "false");
+              }
+              // Update timeline selection
+              if (timelineTrack) {
+                const bars = timelineTrack.querySelectorAll(".timeline-bar");
+                bars.forEach((bar, idx) => bar.classList.toggle("selected", idx === current));
+              }
+            }
+
+            function escapeHtml(s) {
+              return (s || "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+            }
+
+            function renderFrame(idx) {
+              const f = frames[idx];
+              if (!f) return;
+
+              // Render snapshot tab
+              const tpl = document.getElementById("tpl-" + f.id);
+              if (tpl && tpl.content) {
+                viewerEl.innerHTML = "";
+                viewerEl.appendChild(tpl.content.cloneNode(true));
+              } else if (tpl) {
+                viewerEl.innerHTML = tpl.innerHTML || "";
+              } else {
+                viewerEl.textContent = "(missing template)";
+              }
+
+              // Render call tab
+              if (callDetails) {
+                let html = '<div class="call-row"><span class="call-key">type</span><span class="call-value mono">' + escapeHtml(f.stepInfo?.type || f.kind) + '</span></div>';
+                html += '<div class="call-row"><span class="call-key">index</span><span class="call-value mono">' + (idx + 1) + '</span></div>';
+                html += '<div class="call-row"><span class="call-key">time</span><span class="call-value mono">' + f.atSeconds.toFixed(3) + 's</span></div>';
+                if (f.stepInfo?.durationMs !== undefined) {
+                  html += '<div class="call-row"><span class="call-key">duration</span><span class="call-value mono">' + f.stepInfo.durationMs + 'ms</span></div>';
+                }
+                if (f.stepInfo?.params) {
+                  Object.entries(f.stepInfo.params).forEach(([key, value]) => {
+                    const val = typeof value === "string" ? value : JSON.stringify(value);
+                    html += '<div class="call-row"><span class="call-key">' + escapeHtml(key) + '</span><span class="call-value mono">' + escapeHtml(val) + '</span></div>';
+                  });
+                }
+                callDetails.innerHTML = html;
+              }
+
+              // Render errors tab
+              if (errorContent) {
+                if (f.stepInfo && !f.stepInfo.ok && f.stepInfo.error) {
+                  errorContent.innerHTML = '<div class="error-box"><div class="error-title">Step ' + (idx + 1) + ' Failed</div><div class="error-message">' + escapeHtml(f.stepInfo.error) + '</div></div>';
+                  if (errorsTab) errorsTab.classList.add("has-error");
+                } else {
+                  errorContent.innerHTML = '<div class="muted" style="padding: 12px;">No errors for this step.</div>';
+                  if (errorsTab) errorsTab.classList.remove("has-error");
+                }
+              }
+
+              // Render diff tab
+              if (diffPrev && diffCurr) {
+                const prevTpl = document.getElementById("prev-" + f.id);
+                if (prevTpl && prevTpl.content) {
+                  diffPrev.innerHTML = "";
+                  diffPrev.appendChild(prevTpl.content.cloneNode(true));
+                } else if (prevTpl) {
+                  diffPrev.innerHTML = prevTpl.innerHTML || "";
+                } else {
+                  diffPrev.textContent = "(first frame - no previous)";
+                }
+                if (tpl && tpl.content) {
+                  diffCurr.innerHTML = "";
+                  diffCurr.appendChild(tpl.content.cloneNode(true));
+                } else if (tpl) {
+                  diffCurr.innerHTML = tpl.innerHTML || "";
+                }
+              }
+
+              titleEl.textContent = (idx + 1) + ". t=" + f.atSeconds.toFixed(3) + "s — " + f.label;
+              const bits = [];
+              if (f.kind) bits.push("kind=" + f.kind);
+              if (typeof f.changedCount === "number") bits.push("changed=" + f.changedCount);
+              if (f.stepInfo && typeof f.stepInfo.ok === "boolean") bits.push("ok=" + String(f.stepInfo.ok));
+              subEl.textContent = bits.join(" ");
+
+              // Auto-switch to errors tab if step failed
+              if (f.stepInfo && !f.stepInfo.ok && activeTab === "snapshot") {
+                switchTab("errors");
+              }
+            }
+
+            function select(idx, updateHash) {
+              current = Math.max(0, Math.min(buttons.length - 1, idx));
+              updateSelected();
+              renderFrame(current);
+              if (updateHash) location.hash = frames[current]?.id ? "#" + frames[current].id : "";
+              // Scroll button into view
+              if (buttons[current]) buttons[current].scrollIntoView({ block: "nearest" });
+            }
+
+            function selectById(id) {
+              const idx = idToIndex.get(id);
+              if (typeof idx === "number") select(idx, false);
+            }
+
+            for (const btn of buttons) {
+              btn.addEventListener("click", function () {
+                select(Number(btn.dataset.idx || "0"), true);
+              });
+            }
+
+            modeAll.addEventListener("click", () => setMode("all"));
+            modeChanged.addEventListener("click", () => setMode("changed"));
+            modeMarks.addEventListener("click", () => setMode("marks"));
+            modeFailed.addEventListener("click", () => setMode("failed"));
+            searchEl.addEventListener("input", applyFilter);
+
+            window.addEventListener("hashchange", function () {
+              const id = (location.hash || "").replace(/^#/, "");
+              if (id) selectById(id);
+            });
+
+            document.addEventListener("keydown", function (e) {
+              const tag = (document.activeElement && document.activeElement.tagName) || "";
+              if (tag === "INPUT" || tag === "TEXTAREA") return;
+
+              // Navigation
+              if (e.key === "ArrowDown" || e.key === "j") {
+                e.preventDefault();
+                let next = current + 1;
+                while (next < buttons.length && buttons[next].parentElement.style.display === "none") next += 1;
+                if (next < buttons.length) select(next, true);
+              } else if (e.key === "ArrowUp" || e.key === "k") {
+                e.preventDefault();
+                let next = current - 1;
+                while (next >= 0 && buttons[next].parentElement.style.display === "none") next -= 1;
+                if (next >= 0) select(next, true);
+              }
+
+              // Tab switching with number keys
+              if (e.key === "1") switchTab("snapshot");
+              if (e.key === "2") switchTab("call");
+              if (e.key === "3") switchTab("errors");
+              if (e.key === "4") switchTab("diff");
+            });
+
+            // Initial frame: prefer hash, otherwise first failing, otherwise final.
+            const hashId = (location.hash || "").replace(/^#/, "");
+            if (hashId) {
+              selectById(hashId);
+            } else {
+              const firstFail = buttons.findIndex((b) => b.dataset.ok === "false");
+              if (firstFail >= 0) select(firstFail, false);
+              else select(buttons.length - 1, false);
+            }
+
+            applyFilter();
+          })();
+        <\/script>
+      </section>
+      <section class="summary">
+        <h2>Summary</h2>
+        <pre>${escapeHtml([
+		`result=${resultLabel}`,
+		`marks=${markFrames.length}`,
+		`frames=${input.frames.length}`,
+		`duration=${durationSeconds.toFixed(3)}s`,
+		input.result?.ok === false && input.result.error ? `error=${input.result.error}` : null,
+		input.result?.ok === false && input.result.failureStep ? `failedStep=${input.result.failureStep.index} ${input.result.failureStep.type}` : null
+	].filter(Boolean).join("\n"))}</pre>
+      </section>
+    </main>
+	  </body>
+	</html>`;
+}
+function jsonForHtml(data) {
+	return JSON.stringify(data).replaceAll("<", "\\u003c");
+}
+function renderSnapshotViewHtml(options) {
+	const headerLine = formatHeaderLine({
+		sessionId: options.sessionId,
+		scope: options.scope,
+		hash: options.hash,
+		meta: options.meta,
+		changedCount: options.changedLines.size
+	});
+	const digits = Math.max(2, String(options.lines.length).length);
+	const out = [`<span class="headerblock">${escapeHtml(headerLine)}</span>`];
+	if (options.scope === "visible") {
+		for (let i = 0; i < options.lines.length; i += 1) {
+			const n = i + 1;
+			const prefix = options.lineNumbers ? `${String(n).padStart(digits, "0")}│ ` : "";
+			const prefixHtml = options.lineNumbers ? `<span class="ln">${escapeHtml(prefix)}</span>` : "";
+			const contentHtml = renderVisibleRowHtml(options.terminal, i, options.trimRight);
+			const rowClass = options.changedLines.has(i) ? "row changed" : "row";
+			out.push(`<span class="${rowClass}">${prefixHtml}${contentHtml}</span>`);
+		}
+		return out.join("");
+	}
+	for (let i = 0; i < options.lines.length; i += 1) {
+		const n = i + 1;
+		const prefix = options.lineNumbers ? `${String(n).padStart(digits, "0")}│ ` : "";
+		const prefixHtml = options.lineNumbers ? `<span class="ln">${escapeHtml(prefix)}</span>` : "";
+		out.push(`<span class="row">${prefixHtml}${escapeHtml(options.lines[i] ?? "")}</span>`);
+	}
+	return out.join("");
+}
+function renderVisibleRowHtml(terminal, rowIndex, trimRight) {
+	const buffer = terminal.buffer.active;
+	const nullCell = buffer.getNullCell();
+	const startY = buffer.viewportY;
+	const line = buffer.getLine(startY + rowIndex);
+	const endCol = trimRight ? findMeaningfulEndCol(line, terminal.cols, nullCell) : terminal.cols;
+	const segments = [];
+	let currentKey = null;
+	let currentStyle = null;
+	let currentText = "";
+	const flush = () => {
+		if (!currentStyle) return;
+		if (currentText.length === 0) return;
+		segments.push({
+			key: currentKey ?? styleKey(currentStyle),
+			style: currentStyle,
+			text: currentText
+		});
+		currentText = "";
+	};
+	for (let x = 0; x < endCol; x += 1) {
+		const cell = line?.getCell(x, nullCell);
+		if (!cell) {
+			if (currentStyle) {
+				flush();
+				currentStyle = null;
+				currentKey = null;
+			}
+			continue;
+		}
+		if (cell.getWidth() === 0) continue;
+		const chars = cell.getChars() || " ";
+		const style = extractStyle(cell);
+		const key = styleKey(style);
+		if (!currentStyle) {
+			currentStyle = style;
+			currentKey = key;
+			currentText = chars;
+			continue;
+		}
+		if (key === currentKey) {
+			currentText += chars;
+			continue;
+		}
+		flush();
+		currentStyle = style;
+		currentKey = key;
+		currentText = chars;
+	}
+	if (currentStyle) flush();
+	return segments.map((segment) => renderSegmentHtml(segment.text, segment.style)).join("");
+}
+function renderSegmentHtml(text, style) {
+	const safeText = escapeHtml(text);
+	if (isDefaultStyle(style)) return safeText;
+	const css = styleToCss(style);
+	if (!css) return `<span class="seg">${safeText}</span>`;
+	return `<span class="seg" style="${css}">${safeText}</span>`;
+}
+function styleToCss(style) {
+	let fg = colorToCss(style.fg);
+	let bg = colorToCss(style.bg);
+	if (style.inverse) {
+		const tmp = fg;
+		fg = bg;
+		bg = tmp;
+	}
+	const decls = [];
+	if (fg) decls.push(`color: ${fg}`);
+	if (bg) decls.push(`background-color: ${bg}`);
+	if (style.bold) decls.push("font-weight: 600");
+	if (style.italic) decls.push("font-style: italic");
+	if (style.dim) decls.push("opacity: 0.75");
+	const decorations = [];
+	if (style.underline) decorations.push("underline");
+	if (style.strikethrough) decorations.push("line-through");
+	if (decorations.length > 0) decls.push(`text-decoration: ${decorations.join(" ")}`);
+	return decls.join("; ");
+}
+function colorToCss(color) {
+	if (color.mode === "default") return null;
+	if (color.mode === "rgb") return `#${(color.value & 16777215).toString(16).padStart(6, "0")}`;
+	return xterm256Color(clampInt$1(color.value, 0, 255));
+}
+function xterm256Color(idx) {
+	const table16 = [
+		"#000000",
+		"#800000",
+		"#008000",
+		"#808000",
+		"#000080",
+		"#800080",
+		"#008080",
+		"#c0c0c0",
+		"#808080",
+		"#ff0000",
+		"#00ff00",
+		"#ffff00",
+		"#0000ff",
+		"#ff00ff",
+		"#00ffff",
+		"#ffffff"
+	];
+	if (idx < 16) return table16[idx] ?? "#000000";
+	if (idx >= 16 && idx <= 231) {
+		const c = [
+			0,
+			95,
+			135,
+			175,
+			215,
+			255
+		];
+		const n = idx - 16;
+		return `rgb(${c[Math.trunc(n / 36) % 6] ?? 0} ${c[Math.trunc(n / 6) % 6] ?? 0} ${c[n % 6] ?? 0})`;
+	}
+	const v = clampInt$1(8 + (idx - 232) * 10, 0, 255);
+	return `rgb(${v} ${v} ${v})`;
+}
+function diffLineIndices(previous, next) {
+	const out = /* @__PURE__ */ new Set();
+	const max = Math.max(previous.length, next.length);
+	for (let i = 0; i < max; i += 1) if ((previous[i] ?? "") !== (next[i] ?? "")) out.add(i);
+	return out;
+}
+function formatHeaderLine(input) {
+	const cursorViewportRow = input.meta.baseY + input.meta.cursorY - input.meta.viewportY;
+	const cursorViewportCol = input.meta.cursorX;
+	return [
+		`session=${input.sessionId}`,
+		`scope=${input.scope}`,
+		`size=${input.meta.cols}x${input.meta.rows}`,
+		`buffer=${input.meta.bufferType}`,
+		`cursor=${cursorViewportCol + 1},${cursorViewportRow + 1}`,
+		`hash=${input.hash}`,
+		`changed=${input.changedCount}`
+	].join(" ");
+}
+function coerceDisplayString(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		return JSON.stringify(value) ?? "";
+	} catch {
+		return "";
+	}
+}
+function escapeHtml(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function getMeta(terminal) {
+	const buffer = terminal.buffer.active;
+	return {
+		cols: terminal.cols,
+		rows: terminal.rows,
+		bufferType: buffer.type,
+		viewportY: buffer.viewportY,
+		baseY: buffer.baseY,
+		length: buffer.length,
+		cursorX: buffer.cursorX,
+		cursorY: buffer.cursorY
+	};
+}
+function parseAsciicast(cast) {
+	const lines = cast.trimEnd().split("\n");
+	const header = safeJsonObject(lines[0]);
+	const events = [];
+	for (const line of lines.slice(1)) {
+		if (!line.trim()) continue;
+		const value = JSON.parse(line);
+		if (!Array.isArray(value) || value.length < 3) continue;
+		const time = Number(value[0]);
+		const type = String(value[1]);
+		const data = String(value[2]);
+		if (!Number.isFinite(time)) continue;
+		if (type === "o" || type === "i" || type === "r" || type === "m") events.push([
+			time,
+			type,
+			data
+		]);
+	}
+	return {
+		header,
+		events
+	};
+}
+function safeJsonObject(line) {
+	if (!line) return {};
+	try {
+		const value = JSON.parse(line);
+		return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+	} catch {
+		return {};
+	}
+}
+function getTermInfo(header) {
+	if (Number(header.version ?? 2) === 3) {
+		const term = header.term;
+		return {
+			cols: clampInt$1(Number(term?.cols ?? 80), 1, 500),
+			rows: clampInt$1(Number(term?.rows ?? 24), 1, 300),
+			type: typeof term?.type === "string" ? term.type : "xterm-256color"
+		};
+	}
+	return {
+		cols: clampInt$1(Number(header.width ?? 80), 1, 500),
+		rows: clampInt$1(Number(header.height ?? 24), 1, 300),
+		type: typeof header.term === "string" ? header.term : "xterm-256color"
+	};
+}
+function parseResize(value) {
+	const match = /^\s*(\d+)x(\d+)\s*$/.exec(value);
+	if (!match) return null;
+	return {
+		cols: clampInt$1(Number(match[1] ?? 0), 1, 500),
+		rows: clampInt$1(Number(match[2] ?? 0), 1, 300)
+	};
+}
+function clampInt$1(value, min, max) {
+	if (!Number.isFinite(value)) return min;
+	const int = Math.trunc(value);
+	if (int < min) return min;
+	if (int > max) return max;
+	return int;
+}
+if (import.meta.main) {
+	const inputPath = process.argv[2];
+	if (!inputPath) {
+		console.error("Usage: bun run src/trace/report.ts <path/to/cast>");
+		process.exit(2);
+	}
+	const html = await generateTraceReportHtml(await Bun.file(inputPath).text());
+	const outPath = join(dirname(inputPath), `${basename(inputPath, extname(inputPath))}.report.html`);
+	writeFileSync(outPath, html);
+	ensureAsciinemaPlayerAssets(outPath);
+	console.log(outPath);
+}
+//#endregion
+//#region src/script/frame_session.ts
+var FrameSession = class {
+	id;
+	backend;
+	frames;
+	advanceOnInput;
+	trace;
+	snapshotRing = [];
+	rawOutputRing = [];
+	colsValue;
+	rowsValue;
+	activeFrame = 0;
+	closed = {
+		type: "process_exit",
+		exitCode: 0
+	};
+	constructor(options) {
+		if (options.frames.length === 0) throw new Error("frame backend requires at least one frame");
+		this.id = options.id ?? crypto.randomUUID();
+		this.backend = options.backend;
+		this.frames = [...options.frames];
+		this.advanceOnInput = options.advanceOnInput ?? true;
+		this.colsValue = options.cols ?? inferCols(this.frames);
+		this.rowsValue = options.rows ?? inferRows(this.frames);
+		this.trace = new TraceRecorder({
+			version: 2,
+			width: this.colsValue,
+			height: this.rowsValue,
+			timestamp: Math.floor(Date.now() / 1e3),
+			title: options.title ?? `${options.backend} frame backend`,
+			command: `${options.backend}:frame`,
+			term: `${options.backend}-test-backend`
+		});
+		this.recordCurrentFrameOutput();
+	}
+	get cols() {
+		return this.colsValue;
+	}
+	get rows() {
+		return this.rowsValue;
+	}
+	resize(cols, rows) {
+		this.colsValue = clampInt(cols, 1, 500);
+		this.rowsValue = clampInt(rows, 1, 300);
+		this.trace.recordResize(this.colsValue, this.rowsValue);
+	}
+	sendText(text, options) {
+		const payload = options?.enter ? `${text}\r` : text;
+		this.trace.recordInput(payload);
+		this.advanceFrame();
+	}
+	pressKey(key) {
+		this.trace.recordInput(encodeKey(key));
+		this.advanceFrame();
+	}
+	sendMouse(event) {
+		this.trace.recordInput(encodeSgrMouse(event));
+		this.advanceFrame();
+	}
+	mark(label) {
+		this.trace.mark(label);
+	}
+	async flush() {
+		await Promise.resolve();
+	}
+	getMeta() {
+		return {
+			cols: this.colsValue,
+			rows: this.rowsValue,
+			bufferType: "normal",
+			viewportY: 0,
+			baseY: 0,
+			length: this.visibleLines({ trimRight: true }).length,
+			cursorX: 0,
+			cursorY: Math.max(0, Math.min(this.rowsValue - 1, this.currentLines().length - 1))
+		};
+	}
+	async snapshotText(options) {
+		if (options?.maxLines !== void 0 && options.tailLines !== void 0) throw new Error("snapshotText: maxLines and tailLines are mutually exclusive");
+		let lines = options?.scope === "buffer" ? this.currentLines({ trimRight: options?.trimRight }) : this.visibleLines({ trimRight: options?.trimRight });
+		if (options?.trimBottom ?? true) lines = trimBottomEmptyLines(lines);
+		lines = sliceLines(lines, options);
+		lines = applyTextMaskRules(lines, options?.mask);
+		const text = lines.join("\n");
+		const hash = fnv1a32(text);
+		if (options?.captureFrame ?? true) this.captureFrame(text, hash);
+		return {
+			text,
+			hash
+		};
+	}
+	async snapshotAnsi(options) {
+		const { text, hash } = await this.snapshotText(options);
+		return {
+			ansi: text,
+			plain: text,
+			hash,
+			lines: text.split("\n").map((line) => ({
+				ansi: line,
+				plain: line
+			}))
+		};
+	}
+	async snapshotGrid(options) {
+		const lines = this.visibleLines({ trimRight: options?.trimRight });
+		const grid = {
+			cols: this.colsValue,
+			rows: this.rowsValue,
+			bufferType: "normal",
+			cursorX: 0,
+			cursorY: Math.max(0, Math.min(this.rowsValue - 1, this.currentLines().length - 1)),
+			viewportY: 0,
+			lines,
+			styleRuns: options?.includeStyles ? lines.map(() => []) : void 0
+		};
+		const hash = fnv1a32(JSON.stringify(grid));
+		if (options?.captureFrame ?? true) this.captureFrame(lines.join("\n"), hash);
+		return {
+			grid,
+			hash
+		};
+	}
+	async snapshotCast(options) {
+		await this.flush();
+		return this.trace.snapshot({ tailEvents: options?.tailEvents });
+	}
+	async waitForText(args) {
+		const startedAt = Date.now();
+		while (true) {
+			const snapshot = await this.snapshotText({
+				scope: args.scope,
+				captureFrame: true
+			});
+			if (args.text && snapshot.text.includes(args.text)) return {
+				found: true,
+				...snapshot
+			};
+			if (args.regex && args.regex.test(snapshot.text)) return {
+				found: true,
+				...snapshot
+			};
+			if (Date.now() - startedAt >= args.timeoutMs) return {
+				found: false,
+				...snapshot
+			};
+			await sleep(Math.max(1, args.intervalMs));
+		}
+	}
+	async waitForStableScreen() {
+		return {
+			stable: true,
+			...await this.snapshotText({ captureFrame: true })
+		};
+	}
+	isClosed() {
+		return this.closed !== null;
+	}
+	getCloseReason() {
+		return this.closed;
+	}
+	close() {
+		if (!this.closed) this.closed = { type: "closed_by_user" };
+	}
+	getSnapshotFrames() {
+		return [...this.snapshotRing];
+	}
+	getRawOutputChunks() {
+		return [...this.rawOutputRing];
+	}
+	advanceFrame() {
+		if (!this.advanceOnInput) return;
+		if (this.activeFrame >= this.frames.length - 1) return;
+		this.activeFrame += 1;
+		this.recordCurrentFrameOutput();
+	}
+	currentText() {
+		return this.frames[this.activeFrame] ?? "";
+	}
+	currentLines(options) {
+		const trimRight = options?.trimRight ?? true;
+		return normalizeNewlines(this.currentText()).split("\n").map((line) => normalizeLineWidth(line, this.colsValue, trimRight));
+	}
+	visibleLines(options) {
+		const lines = this.currentLines(options).slice(0, this.rowsValue);
+		while (lines.length < this.rowsValue) lines.push("");
+		return lines;
+	}
+	captureFrame(text, hash) {
+		this.snapshotRing.push({
+			atMs: Date.now(),
+			hash,
+			text
+		});
+		while (this.snapshotRing.length > 50) this.snapshotRing.shift();
+	}
+	recordCurrentFrameOutput() {
+		const text = this.currentText();
+		const output = `\x1b[2J\x1b[H${text}`;
+		this.rawOutputRing.push(text);
+		while (this.rawOutputRing.length > 50) this.rawOutputRing.shift();
+		this.trace.recordOutput(output);
+	}
+};
+async function createFrameSessionFromLaunch(args) {
+	const backend = args.launch.backend;
+	if (backend === void 0 || backend === "pty") throw new Error("createFrameSessionFromLaunch requires a non-pty backend");
+	return new FrameSession({
+		backend,
+		frames: await resolveLaunchFrames(args.launch, args.cwd, backend),
+		cols: args.launch.cols,
+		rows: args.launch.rows,
+		title: args.title,
+		advanceOnInput: args.launch.advanceOnInput
+	});
+}
+async function resolveLaunchFrames(launch, cwd, backend) {
+	const frames = [];
+	if (launch.frames?.length) frames.push(...normalizeFrames(launch.frames));
+	if (launch.frame !== void 0) frames.push(launch.frame);
+	if (launch.framePath) {
+		const path = resolveLaunchPath(cwd, launch.framePath);
+		frames.push(readFileSync(path, "utf8").replace(/\n$/, ""));
+	}
+	if (launch.frameModule) frames.push(...await loadFrameModule(resolveLaunchPath(cwd, launch.frameModule), backend));
+	if (frames.length === 0) throw new Error(`launch.backend=${backend} requires frame, frames, framePath, or frameModule`);
+	return frames;
+}
+async function loadFrameModule(modulePath, backend) {
+	return normalizeFrames(await materializeFrameSource(selectModuleFrameSource(await import(pathToFileURL(modulePath).href), backend)));
+}
+function selectModuleFrameSource(mod, backend) {
+	if (mod.frames !== void 0) return mod.frames;
+	if (mod.default !== void 0) return mod.default;
+	if (backend === "ink" && mod.lastFrame !== void 0) return mod.lastFrame;
+	if (backend === "ink" && mod.frame !== void 0) return mod.frame;
+	if (backend === "ratatui" && mod.snapshot !== void 0) return mod.snapshot;
+	if (mod.frame !== void 0) return mod.frame;
+	if (mod.snapshot !== void 0) return mod.snapshot;
+	throw new Error(`frame module did not export frames/default/frame/snapshot/lastFrame`);
+}
+async function materializeFrameSource(source) {
+	if (typeof source === "function") return await source();
+	return source;
+}
+function normalizeFrames(source) {
+	if (Array.isArray(source)) return source.map((frame) => normalizeFrame(frame));
+	return [normalizeFrame(source)];
+}
+function normalizeFrame(frame) {
+	if (typeof frame === "string") return normalizeNewlines(frame).replace(/\n$/, "");
+	if (typeof frame === "object" && frame !== null) {
+		const value = frame;
+		const text = typeof value.text === "string" ? value.text : typeof value.frame === "string" ? value.frame : typeof value.snapshot === "string" ? value.snapshot : typeof value.lastFrame === "string" ? value.lastFrame : void 0;
+		if (text !== void 0) return normalizeNewlines(text).replace(/\n$/, "");
+	}
+	throw new Error("frame entries must be strings or objects with text/frame/snapshot/lastFrame");
+}
+function resolveLaunchPath(cwd, path) {
+	return isAbsolute(path) ? path : resolve(cwd, path);
+}
+function normalizeNewlines(text) {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function normalizeLineWidth(line, cols, trimRight) {
+	const clipped = line.length > cols ? line.slice(0, cols) : line;
+	return trimRight ? clipped.trimEnd() : clipped.padEnd(cols, " ");
+}
+function trimBottomEmptyLines(lines) {
+	let end = lines.length;
+	while (end > 0 && (lines[end - 1] ?? "").trim() === "") end -= 1;
+	return lines.slice(0, end);
+}
+function sliceLines(lines, options) {
+	if (options?.maxLines !== void 0) return lines.slice(0, Math.max(0, Math.trunc(options.maxLines)));
+	if (options?.tailLines !== void 0) {
+		const tail = Math.max(0, Math.trunc(options.tailLines));
+		return lines.slice(Math.max(0, lines.length - tail));
+	}
+	return lines;
+}
+function inferCols(frames) {
+	return clampInt(frames.reduce((acc, frame) => {
+		const lines = normalizeNewlines(frame).split("\n");
+		return Math.max(acc, ...lines.map((line) => line.length));
+	}, 0) || 80, 1, 500);
+}
+function inferRows(frames) {
+	return clampInt(frames.reduce((acc, frame) => {
+		return Math.max(acc, normalizeNewlines(frame).split("\n").length);
+	}, 0) || 24, 1, 300);
+}
+function clampInt(value, min, max) {
+	if (!Number.isFinite(value)) return min;
+	const int = Math.trunc(value);
+	if (int < min) return min;
+	if (int > max) return max;
+	return int;
+}
+//#endregion
+//#region src/script/schema.ts
+const textMaskRuleSchema = z.object({
+	regex: z.string().min(1),
+	flags: z.string().optional(),
+	replacement: z.string().optional(),
+	preserveLength: z.boolean().optional()
+});
+const launchConfigSchema = z.object({
+	backend: z.enum([
+		"pty",
+		"frames",
+		"ink",
+		"ratatui"
+	]).optional(),
+	command: z.string().min(1).optional(),
+	args: z.array(z.string()).optional(),
+	cwd: z.string().optional(),
+	env: z.record(z.string()).optional(),
+	cols: z.number().int().positive().optional(),
+	rows: z.number().int().positive().optional(),
+	name: z.string().optional(),
+	frame: z.string().optional(),
+	frames: z.array(z.union([z.string(), z.object({
+		name: z.string().optional(),
+		text: z.string().optional(),
+		frame: z.string().optional(),
+		snapshot: z.string().optional(),
+		lastFrame: z.string().optional()
+	})])).optional(),
+	framePath: z.string().optional(),
+	frameModule: z.string().optional(),
+	advanceOnInput: z.boolean().optional()
+}).superRefine((value, ctx) => {
+	if ((value.backend ?? "pty") === "pty") {
+		if (!value.command) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["command"],
+			message: "launch.command is required when backend=pty"
+		});
+		return;
+	}
+	if (!value.frame && !value.frames?.length && !value.framePath && !value.frameModule) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "framework launch requires one of frame, frames, framePath, or frameModule when backend is not pty"
+	});
+});
+const scriptTraceSchema = z.object({
+	saveCast: z.boolean().optional(),
+	saveReport: z.boolean().optional(),
+	castPath: z.string().optional(),
+	reportPath: z.string().optional(),
+	reportScope: z.enum(["visible", "buffer"]).optional(),
+	reportMaxFrames: z.number().int().positive().optional()
+});
+const sendTextStepSchema = z.object({
+	type: z.literal("sendText"),
+	text: z.string(),
+	enter: z.boolean().optional()
+});
+const pressKeyStepSchema = z.object({
+	type: z.literal("pressKey"),
+	key: z.string().min(1)
+});
+const sendMouseStepSchema = z.object({
+	type: z.literal("sendMouse"),
+	action: z.enum([
+		"down",
+		"up",
+		"move",
+		"click",
+		"scroll_up",
+		"scroll_down"
+	]),
+	x: z.number().int(),
+	y: z.number().int(),
+	button: z.enum([
+		"left",
+		"middle",
+		"right"
+	]).optional(),
+	shift: z.boolean().optional(),
+	alt: z.boolean().optional(),
+	ctrl: z.boolean().optional()
+});
+const resizeStepSchema = z.object({
+	type: z.literal("resize"),
+	cols: z.number().int().positive(),
+	rows: z.number().int().positive()
+});
+const markStepSchema = z.object({
+	type: z.literal("mark"),
+	label: z.string().optional()
+});
+const sleepStepSchema = z.object({
+	type: z.literal("sleep"),
+	ms: z.number().int().nonnegative()
+});
+const waitForTextStepSchema = z.object({
+	type: z.literal("waitForText"),
+	scope: z.enum(["visible", "buffer"]).optional(),
+	text: z.string().optional(),
+	regex: z.string().optional(),
+	timeoutMs: z.number().int().positive().optional(),
+	intervalMs: z.number().int().positive().optional()
+}).superRefine((value, ctx) => {
+	if (!value.text && !value.regex) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "waitForText requires text or regex"
+	});
+});
+const waitForStableScreenStepSchema = z.object({
+	type: z.literal("waitForStableScreen"),
+	timeoutMs: z.number().int().positive().optional(),
+	quietMs: z.number().int().positive().optional(),
+	intervalMs: z.number().int().positive().optional()
+});
+const waitForExitStepSchema = z.object({
+	type: z.literal("waitForExit"),
+	timeoutMs: z.number().int().positive().optional(),
+	intervalMs: z.number().int().positive().optional(),
+	exitCode: z.number().int().optional(),
+	signal: z.union([z.number().int(), z.string()]).optional()
+});
+const expectMetaStepSchema = z.object({
+	type: z.literal("expectMeta"),
+	bufferType: z.enum(["normal", "alternate"]).optional(),
+	cols: z.number().int().positive().optional(),
+	rows: z.number().int().positive().optional(),
+	cursor: z.object({
+		x: z.number().int().positive(),
+		y: z.number().int().positive()
+	}).optional()
+}).superRefine((value, ctx) => {
+	if (value.bufferType === void 0 && value.cols === void 0 && value.rows === void 0 && value.cursor === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "expectMeta requires at least one assertion (bufferType/cols/rows/cursor)"
+	});
+});
+const snapshotStepSchema = z.object({
+	type: z.literal("snapshot"),
+	kind: z.enum([
+		"text",
+		"view",
+		"ansi",
+		"view_ansi",
+		"grid"
+	]),
+	scope: z.enum(["visible", "buffer"]).optional(),
+	trimRight: z.boolean().optional(),
+	trimBottom: z.boolean().optional(),
+	maxLines: z.number().int().positive().optional(),
+	tailLines: z.number().int().positive().optional(),
+	lineNumbers: z.boolean().optional(),
+	includeStyles: z.boolean().optional(),
+	mask: z.array(textMaskRuleSchema).optional(),
+	saveAs: z.string().optional(),
+	saveTo: z.string().optional()
+}).superRefine((value, ctx) => {
+	if (value.maxLines !== void 0 && value.tailLines !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "snapshot: maxLines and tailLines are mutually exclusive"
+	});
+});
+const expectStepSchema = z.object({
+	type: z.literal("expect"),
+	from: z.string().optional(),
+	equals: z.string().optional(),
+	contains: z.array(z.string()).optional(),
+	notContains: z.array(z.string()).optional(),
+	regex: z.string().optional()
+}).superRefine((value, ctx) => {
+	if (value.equals === void 0 && !value.contains?.length && !value.notContains?.length && !value.regex) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "expect requires at least one matcher (equals/contains/notContains/regex)"
+	});
+});
+const expectGoldenStepSchema = z.object({
+	type: z.literal("expectGolden"),
+	from: z.string().optional(),
+	path: z.string().min(1)
+});
+const customStepSchema = z.object({
+	type: z.literal("custom"),
+	name: z.string().min(1),
+	payload: z.unknown().optional()
+});
+const assertStepSchema = z.object({
+	type: z.literal("assert"),
+	scope: z.enum(["visible", "buffer"]).optional(),
+	text: z.string().optional(),
+	regex: z.string().optional(),
+	description: z.string().optional()
+}).superRefine((value, ctx) => {
+	if (!value.text && !value.regex) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "assert requires text or regex"
+	});
+});
+const assertSemanticStepSchema = z.object({
+	type: z.literal("assertSemantic"),
+	prompt: z.string().min(1),
+	description: z.string().optional()
+});
+const scriptStepSchema = z.union([
+	sendTextStepSchema,
+	pressKeyStepSchema,
+	sendMouseStepSchema,
+	resizeStepSchema,
+	markStepSchema,
+	sleepStepSchema,
+	waitForTextStepSchema,
+	waitForStableScreenStepSchema,
+	waitForExitStepSchema,
+	expectMetaStepSchema,
+	snapshotStepSchema,
+	expectStepSchema,
+	expectGoldenStepSchema,
+	customStepSchema,
+	assertStepSchema,
+	assertSemanticStepSchema
+]);
+const scriptSchema = z.object({
+	name: z.string().optional(),
+	artifactsDir: z.string().optional(),
+	launch: launchConfigSchema,
+	trace: scriptTraceSchema.optional(),
+	steps: z.array(scriptStepSchema).min(1)
+});
+//#endregion
+//#region src/script/runner.ts
+async function runScriptFile(scriptPath, options) {
+	const raw = await Bun.file(scriptPath).text();
+	const parsedJson = JSON.parse(raw);
+	const baseName = basename(scriptPath, extname(scriptPath));
+	return runScript(parsedJson && typeof parsedJson === "object" && !Array.isArray(parsedJson) && !("name" in parsedJson) ? {
+		...parsedJson,
+		name: baseName
+	} : parsedJson, options);
+}
+async function runScript(script, options) {
+	const parsed = scriptSchema.parse(script);
+	const scriptName = parsed.name ?? "script";
+	const artifactsDir = resolveArtifactsDir(parsed, scriptName, options?.artifactsDir);
+	mkdirSync(artifactsDir, { recursive: true });
+	const launch = parsed.launch;
+	const cwd = launch.cwd ? resolve(process.cwd(), launch.cwd) : process.cwd();
+	const backend = launch.backend ?? "pty";
+	let sessions = null;
+	let session;
+	if (backend === "pty") {
+		sessions = new SessionManager({ snapshotRingSize: 50 });
+		if (!launch.command) throw new Error("launch.command is required when backend=pty");
+		session = sessions.launchSession({
+			command: launch.command,
+			args: launch.args ?? [],
+			cwd,
+			env: launch.env,
+			cols: launch.cols,
+			rows: launch.rows,
+			name: launch.name
+		});
+	} else session = await createFrameSessionFromLaunch({
+		launch,
+		cwd,
+		title: scriptName
+	});
+	const closeSession = () => {
+		if (sessions) {
+			sessions.closeAll();
+			return;
+		}
+		session.close();
+	};
+	const snapshots = /* @__PURE__ */ new Map();
+	let last = null;
+	let currentStepIndex = -1;
+	let currentStep = null;
+	const resolveGoldenPath = (path) => isAbsolute(path) ? path : resolve(process.cwd(), path);
+	const resolveArtifactPath = (path) => isAbsolute(path) ? path : resolve(artifactsDir, path);
+	const trace = parsed.trace ?? {};
+	const saveCast = trace.saveCast ?? true;
+	const saveReport = trace.saveReport ?? true;
+	const castPath = resolveArtifactPath(trace.castPath ?? `${scriptName}.cast`);
+	const reportPath = resolveArtifactPath(trace.reportPath ?? `${scriptName}.report.html`);
+	const stepHandlers = options?.steps;
+	const executionSteps = [];
+	try {
+		for (let stepIndex = 0; stepIndex < parsed.steps.length; stepIndex += 1) {
+			const step = parsed.steps[stepIndex];
+			currentStepIndex = stepIndex;
+			currentStep = step;
+			const stepStartedAt = Date.now();
+			const before = last;
+			try {
+				last = await runStep({
+					step,
+					stepIndex,
+					session,
+					snapshots,
+					last,
+					resolveGoldenPath,
+					resolveArtifactPath,
+					updateGoldens: options?.updateGoldens ?? envTruthy(process.env.UPDATE_GOLDENS),
+					stepHandlers,
+					artifactsDir
+				});
+				let after = last;
+				if (!(last !== before)) try {
+					const captured = await session.snapshotText({
+						scope: "visible",
+						trimRight: true,
+						trimBottom: true,
+						captureFrame: true
+					});
+					const lines = captured.text.split("\n");
+					const view = formatSnapshotView({
+						sessionId: session.id,
+						scope: "visible",
+						hash: captured.hash,
+						lines,
+						meta: session.getMeta(),
+						lineNumbers: true
+					});
+					after = {
+						kind: "view",
+						hash: captured.hash,
+						text: view
+					};
+					last = after;
+				} catch {}
+				executionSteps.push({
+					index: stepIndex,
+					step,
+					before,
+					after,
+					durationMs: Date.now() - stepStartedAt,
+					ok: true
+				});
+			} catch (err) {
+				executionSteps.push({
+					index: stepIndex,
+					step,
+					before,
+					after: null,
+					durationMs: Date.now() - stepStartedAt,
+					ok: false,
+					error: err.message
+				});
+				throw err;
+			}
+		}
+		await writeTraceArtifacts({
+			session,
+			artifactsDir,
+			saveCast,
+			castPath,
+			saveReport,
+			reportPath,
+			reportScope: trace.reportScope,
+			reportMaxFrames: trace.reportMaxFrames,
+			scriptName,
+			result: { ok: true },
+			executionSteps
+		});
+		writeTestDataArtifact({
+			artifactsDir,
+			scriptName,
+			ok: true,
+			executionSteps,
+			resolveArtifactPath
+		});
+		closeSession();
+		return {
+			ok: true,
+			artifactsDir
+		};
+	} catch (error) {
+		try {
+			writeTestDataArtifact({
+				artifactsDir,
+				scriptName,
+				ok: false,
+				error: error.message,
+				executionSteps,
+				resolveArtifactPath
+			});
+			await writeFailureArtifacts({
+				session,
+				artifactsDir,
+				scriptName,
+				stepIndex: currentStepIndex,
+				step: currentStep,
+				last,
+				error
+			});
+			await writeTraceArtifacts({
+				session,
+				artifactsDir,
+				saveCast,
+				castPath,
+				saveReport,
+				reportPath,
+				reportScope: trace.reportScope,
+				reportMaxFrames: trace.reportMaxFrames,
+				scriptName,
+				result: {
+					ok: false,
+					error: error.message,
+					failureStep: currentStep ? {
+						index: currentStepIndex + 1,
+						type: formatStepLabel(currentStep)
+					} : void 0
+				},
+				executionSteps
+			});
+		} catch {} finally {
+			closeSession();
+		}
+		throw error;
+	}
+}
+function resolveArtifactsDir(script, scriptName, override) {
+	if (override?.trim()) return resolve(override.trim());
+	if (script.artifactsDir?.trim()) return resolve(script.artifactsDir.trim());
+	return resolve(".tmp", "runs", scriptName);
+}
+async function runStep(args) {
+	const { step } = args;
+	try {
+		if (step.type === "sendText") {
+			args.session.sendText(step.text, { enter: step.enter });
+			return args.last;
+		}
+		if (step.type === "pressKey") {
+			args.session.pressKey(step.key);
+			return args.last;
+		}
+		if (step.type === "sendMouse") {
+			const modifiers = step.shift || step.alt || step.ctrl ? {
+				shift: step.shift,
+				alt: step.alt,
+				ctrl: step.ctrl
+			} : void 0;
+			args.session.sendMouse({
+				action: step.action,
+				x: step.x,
+				y: step.y,
+				button: step.button,
+				modifiers
+			});
+			return args.last;
+		}
+		if (step.type === "resize") {
+			args.session.resize(step.cols, step.rows);
+			return args.last;
+		}
+		if (step.type === "mark") {
+			args.session.mark(step.label);
+			return args.last;
+		}
+		if (step.type === "sleep") {
+			await sleep(step.ms);
+			return args.last;
+		}
+		if (step.type === "waitForText") {
+			const regex = step.regex ? new RegExp(step.regex) : void 0;
+			if (!(await args.session.waitForText({
+				scope: step.scope,
+				text: step.text,
+				regex,
+				timeoutMs: step.timeoutMs ?? 1e4,
+				intervalMs: step.intervalMs ?? 100
+			})).found) throw new Error(`step ${args.stepIndex + 1} waitForText not found: ${step.text ?? step.regex ?? ""}`);
+			return args.last;
+		}
+		if (step.type === "waitForStableScreen") {
+			if (!(await args.session.waitForStableScreen({
+				timeoutMs: step.timeoutMs ?? 1e4,
+				quietMs: step.quietMs ?? 400,
+				intervalMs: step.intervalMs ?? 80
+			})).stable) throw new Error(`step ${args.stepIndex + 1} waitForStableScreen timed out`);
+			return args.last;
+		}
+		if (step.type === "waitForExit") {
+			const startedAt = Date.now();
+			const timeoutMs = step.timeoutMs ?? 1e4;
+			const intervalMs = step.intervalMs ?? 50;
+			while (Date.now() - startedAt <= timeoutMs) {
+				if (args.session.isClosed()) break;
+				await sleep(intervalMs);
+			}
+			const reason = args.session.getCloseReason();
+			if (!reason) throw new Error("waitForExit timed out");
+			if (reason.type !== "process_exit") throw new Error("waitForExit: session was closed by user");
+			if (step.exitCode !== void 0 && reason.exitCode !== step.exitCode) throw new Error(`waitForExit: exitCode mismatch (got ${reason.exitCode})`);
+			if (step.signal !== void 0 && reason.signal !== step.signal) throw new Error(`waitForExit: signal mismatch (got ${String(reason.signal ?? "")})`);
+			return args.last;
+		}
+		if (step.type === "expectMeta") {
+			await args.session.flush();
+			const meta = args.session.getMeta();
+			if (step.bufferType !== void 0 && meta.bufferType !== step.bufferType) throw new Error(`expectMeta.bufferType mismatch (got ${meta.bufferType})`);
+			if (step.cols !== void 0 && meta.cols !== step.cols) throw new Error(`expectMeta.cols mismatch (got ${meta.cols})`);
+			if (step.rows !== void 0 && meta.rows !== step.rows) throw new Error(`expectMeta.rows mismatch (got ${meta.rows})`);
+			if (step.cursor) {
+				const cursorViewportRow = meta.baseY + meta.cursorY - meta.viewportY;
+				const actual = {
+					x: meta.cursorX + 1,
+					y: cursorViewportRow + 1
+				};
+				if (actual.x !== step.cursor.x || actual.y !== step.cursor.y) throw new Error(`expectMeta.cursor mismatch (got ${actual.x},${actual.y})`);
+			}
+			return args.last;
+		}
+		if (step.type === "snapshot") {
+			const record = await snapshotStep(args.session, step);
+			persistSnapshotRecord({
+				record,
+				saveAs: step.saveAs,
+				saveTo: step.saveTo,
+				snapshots: args.snapshots,
+				resolveArtifactPath: args.resolveArtifactPath
+			});
+			return record;
+		}
+		if (step.type === "expect") {
+			assertRecordMatches(selectSnapshot(args.last, args.snapshots, step.from), step, args.stepIndex);
+			return args.last;
+		}
+		if (step.type === "assert") {
+			const regex = step.regex ? new RegExp(step.regex) : void 0;
+			if (!(await args.session.waitForText({
+				scope: step.scope,
+				text: step.text,
+				regex,
+				timeoutMs: 0,
+				intervalMs: 0
+			})).found) throw new Error(`step ${args.stepIndex + 1} assert failed: ${step.description || step.text || step.regex || "pattern mismatch"}`);
+			return args.last;
+		}
+		if (step.type === "assertSemantic") return args.last;
+		if (step.type === "expectGolden") {
+			const record = selectSnapshot(args.last, args.snapshots, step.from);
+			assertGoldenText(args.resolveGoldenPath(step.path), `${record.text}\n`, args.updateGoldens);
+			return args.last;
+		}
+		if (step.type === "custom") {
+			const handler = args.stepHandlers?.[step.name];
+			if (!handler) throw new Error(`custom handler not found: ${step.name}`);
+			const result = await handler({
+				session: args.session,
+				stepIndex: args.stepIndex,
+				last: args.last,
+				snapshots: args.snapshots,
+				artifactsDir: args.artifactsDir,
+				resolveArtifactPath: args.resolveArtifactPath,
+				resolveGoldenPath: args.resolveGoldenPath,
+				updateGoldens: args.updateGoldens,
+				captureSnapshot: async (snapshotConfig) => {
+					const record = await snapshotStep(args.session, {
+						type: "snapshot",
+						...snapshotConfig
+					});
+					persistSnapshotRecord({
+						record,
+						saveAs: snapshotConfig.saveAs,
+						saveTo: snapshotConfig.saveTo,
+						snapshots: args.snapshots,
+						resolveArtifactPath: args.resolveArtifactPath
+					});
+					return record;
+				},
+				getSnapshot: (from) => selectSnapshot(args.last, args.snapshots, from),
+				writeArtifactText: (path, text) => {
+					const resolved = args.resolveArtifactPath(path);
+					mkdirSync(dirname(resolved), { recursive: true });
+					writeFileSync(resolved, text, "utf8");
+				},
+				assertGoldenText: (path, text) => {
+					assertGoldenText(args.resolveGoldenPath(path), text, args.updateGoldens);
+				}
+			}, step);
+			if (!result) return args.last;
+			return result;
+		}
+		throw new Error(`unknown type: ${step.type}`);
+	} catch (error) {
+		throw annotateStepError(error, args.stepIndex, step);
+	}
+}
+function persistSnapshotRecord(args) {
+	const saveAs = args.saveAs?.trim();
+	if (saveAs) args.snapshots.set(saveAs, args.record);
+	const saveTo = args.saveTo?.trim();
+	if (!saveTo) return;
+	const path = args.resolveArtifactPath(saveTo);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${args.record.text}\n`, "utf8");
+}
+function annotateStepError(error, stepIndex, step) {
+	const label = step.type === "custom" ? `custom(${step.name})` : step.type;
+	const prefix = `step ${stepIndex + 1} ${label}`;
+	if (error instanceof Error) {
+		if (!error.message.startsWith("step ")) error.message = `${prefix}: ${error.message}`;
+		return error;
+	}
+	return /* @__PURE__ */ new Error(`${prefix}: ${String(error)}`);
+}
+function selectSnapshot(last, snapshots, from) {
+	const key = from?.trim() ? from.trim() : "last";
+	if (key === "last") {
+		if (!last) throw new Error("expect: no previous snapshot (from=last)");
+		return last;
+	}
+	const found = snapshots.get(key);
+	if (!found) throw new Error(`expect: unknown snapshot reference: ${key}`);
+	return found;
+}
+function assertRecordMatches(record, step, stepIndex) {
+	if (step.equals !== void 0 && record.text !== step.equals) throw new Error(`step ${stepIndex + 1} expect.equals failed`);
+	if (step.contains && step.contains.length > 0) {
+		for (const item of step.contains) if (!record.text.includes(item)) throw new Error(`step ${stepIndex + 1} expect.contains failed: ${JSON.stringify(item)}`);
+	}
+	if (step.notContains && step.notContains.length > 0) {
+		for (const item of step.notContains) if (record.text.includes(item)) throw new Error(`step ${stepIndex + 1} expect.notContains failed: ${JSON.stringify(item)}`);
+	}
+	if (step.regex) {
+		if (!new RegExp(step.regex).test(record.text)) throw new Error(`step ${stepIndex + 1} expect.regex failed: ${JSON.stringify(step.regex)}`);
+	}
+}
+function assertGoldenText(path, text, update) {
+	if (update) {
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, text, "utf8");
+		return;
+	}
+	if (text !== readFileSync(path, "utf8")) throw new Error(`golden mismatch: ${path}`);
+}
+async function writeFailureArtifacts(args) {
+	const { session, artifactsDir, scriptName, stepIndex, step, last, error } = args;
+	const err = error instanceof Error ? error : new Error(String(error));
+	const errorText = err.stack ?? err.message;
+	writeFileSync(join(artifactsDir, "failure.error.txt"), `${errorText}\n`, "utf8");
+	const stepPayload = {
+		script: scriptName,
+		stepIndex: stepIndex >= 0 ? stepIndex + 1 : null,
+		step: step ?? null,
+		last: last ? {
+			kind: last.kind,
+			hash: last.hash
+		} : null
+	};
+	writeFileSync(join(artifactsDir, "failure.step.json"), `${JSON.stringify(stepPayload, null, 2)}\n`, "utf8");
+	let capturedText = void 0;
+	let capturedHash = void 0;
+	try {
+		const captured = await session.snapshotText({
+			scope: "visible",
+			trimRight: true,
+			trimBottom: true,
+			captureFrame: true
+		});
+		capturedText = captured.text;
+		capturedHash = captured.hash;
+	} catch {}
+	const text = capturedText ?? last?.text;
+	const hash = capturedHash ?? last?.hash ?? "unknown";
+	if (text !== void 0) {
+		writeFileSync(join(artifactsDir, "failure.last.txt"), `${text}\n`, "utf8");
+		const view = formatSnapshotView({
+			sessionId: session.id,
+			scope: "visible",
+			hash,
+			lines: text.split("\n"),
+			meta: session.getMeta(),
+			lineNumbers: true
+		});
+		writeFileSync(join(artifactsDir, "failure.last.view.txt"), `${view}\n`, "utf8");
+	}
+}
+async function snapshotStep(session, step) {
+	if (step.kind === "grid") {
+		if (step.mask && step.mask.length > 0) throw new Error("snapshot.kind=grid does not support mask (use text/view instead)");
+		const { grid, hash } = await session.snapshotGrid({
+			trimRight: step.trimRight,
+			includeStyles: step.includeStyles,
+			captureFrame: true
+		});
+		return {
+			kind: step.kind,
+			hash,
+			text: JSON.stringify(grid, null, 2)
+		};
+	}
+	if (step.kind === "ansi" || step.kind === "view_ansi") {
+		const { ansi, hash } = await session.snapshotAnsi({
+			scope: step.scope,
+			trimRight: step.trimRight,
+			trimBottom: step.trimBottom ?? true,
+			maxLines: step.maxLines,
+			tailLines: step.tailLines,
+			mask: step.mask
+		});
+		if (step.kind === "ansi") return {
+			kind: step.kind,
+			hash,
+			text: ansi
+		};
+		const lines = ansi.split("\n");
+		const view = formatSnapshotView({
+			sessionId: session.id,
+			scope: step.scope ?? "visible",
+			hash,
+			lines,
+			meta: session.getMeta(),
+			lineNumbers: step.lineNumbers
+		});
+		return {
+			kind: step.kind,
+			hash,
+			text: view
+		};
+	}
+	const { text, hash } = await session.snapshotText({
+		scope: step.scope,
+		trimRight: step.trimRight,
+		trimBottom: step.trimBottom ?? true,
+		maxLines: step.maxLines,
+		tailLines: step.tailLines,
+		captureFrame: true,
+		mask: step.mask
+	});
+	if (step.kind === "text") return {
+		kind: step.kind,
+		hash,
+		text
+	};
+	const lines = text.split("\n");
+	const view = formatSnapshotView({
+		sessionId: session.id,
+		scope: step.scope ?? "visible",
+		hash,
+		lines,
+		meta: session.getMeta(),
+		lineNumbers: step.lineNumbers
+	});
+	return {
+		kind: step.kind,
+		hash,
+		text: view
+	};
+}
+async function writeTraceArtifacts(args) {
+	if (!args.saveCast && !args.saveReport) return;
+	const snapshot = await args.session.snapshotCast();
+	if (args.saveCast) {
+		mkdirSync(dirname(args.castPath), { recursive: true });
+		writeFileSync(args.castPath, snapshot.cast, "utf8");
+	}
+	if (args.saveReport) {
+		const artifactHrefs = buildReportArtifactHrefs({
+			reportPath: args.reportPath,
+			castPath: args.saveCast ? args.castPath : null,
+			artifactsDir: args.artifactsDir,
+			includeFailures: args.result?.ok === false
+		});
+		const html = await generateTraceReportHtml(snapshot.cast, {
+			scope: args.reportScope,
+			maxFrames: args.reportMaxFrames,
+			scriptName: args.scriptName,
+			result: args.result,
+			artifacts: artifactHrefs,
+			steps: args.executionSteps
+		});
+		mkdirSync(dirname(args.reportPath), { recursive: true });
+		writeFileSync(args.reportPath, html, "utf8");
+		ensureAsciinemaPlayerAssets(args.reportPath);
+	}
+}
+function buildReportArtifactHrefs(args) {
+	const items = {};
+	if (args.castPath) items.castHref = relativeHref(args.reportPath, args.castPath);
+	if (args.includeFailures) {
+		items.failureErrorHref = relativeHref(args.reportPath, join(args.artifactsDir, "failure.error.txt"));
+		items.failureStepHref = relativeHref(args.reportPath, join(args.artifactsDir, "failure.step.json"));
+		items.failureLastTextHref = relativeHref(args.reportPath, join(args.artifactsDir, "failure.last.txt"));
+		items.failureLastViewHref = relativeHref(args.reportPath, join(args.artifactsDir, "failure.last.view.txt"));
+	}
+	return Object.keys(items).length ? items : void 0;
+}
+function relativeHref(fromFile, toFile) {
+	const normalized = relative(dirname(fromFile), toFile).replace(/\\/g, "/");
+	return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+function formatStepLabel(step) {
+	return step.type === "custom" ? `custom(${step.name})` : step.type;
+}
+function formatPublicStepLabel(step) {
+	const showText = envTruthy(process.env.PTYWRIGHT_REPORT_SHOW_STEP_TEXT);
+	if (step.type === "custom") return `custom(${step.name})`;
+	if (step.type === "sendText") {
+		const enter = step.enter !== void 0 ? ` enter=${String(step.enter)}` : "";
+		if (!showText) return `sendText <redacted> (len=${step.text.length}${enter})`;
+		return `sendText "${truncateInline(step.text)}"${enter ? ` (${enter.trim()})` : ""}`;
+	}
+	if (step.type === "pressKey") return `pressKey ${step.key}`;
+	if (step.type === "sendMouse") return `sendMouse ${step.action} (${step.x},${step.y})`;
+	if (step.type === "resize") return `resize ${step.cols}x${step.rows}`;
+	if (step.type === "mark") return step.label ? `mark ${step.label}` : "mark";
+	if (step.type === "sleep") return `sleep ${step.ms}ms`;
+	if (step.type === "waitForText") {
+		if (!showText) return step.text ? "waitForText (text)" : step.regex ? "waitForText (regex)" : "waitForText";
+		if (step.text) return `waitFor "${truncateInline(step.text)}"`;
+		if (step.regex) return `waitFor /${truncateInline(step.regex)}/`;
+		return "waitForText";
+	}
+	if (step.type === "waitForStableScreen") return "waitForStableScreen";
+	if (step.type === "waitForExit") return "waitForExit";
+	if (step.type === "expectMeta") return "expectMeta";
+	if (step.type === "snapshot") return `snapshot ${step.kind}${step.saveAs ? ` as ${step.saveAs}` : ""}`;
+	if (step.type === "expect") {
+		const parts = [];
+		if (step.equals !== void 0) parts.push("equals");
+		if (step.contains?.length) parts.push(`contains(${step.contains.length})`);
+		if (step.notContains?.length) parts.push(`notContains(${step.notContains.length})`);
+		if (step.regex) parts.push("regex");
+		return parts.length ? `expect ${parts.join(",")}` : "expect";
+	}
+	if (step.type === "expectGolden") return `expectGolden ${step.path}`;
+	if (step.type === "assert") {
+		if (!showText) return step.text ? "assert (text)" : step.regex ? "assert (regex)" : "assert";
+		if (step.text) return `assert "${truncateInline(step.text)}"`;
+		if (step.regex) return `assert /${truncateInline(step.regex)}/`;
+		if (step.description) return `assert "${truncateInline(step.description)}"`;
+		return "assert";
+	}
+	if (step.type === "assertSemantic") return "assertSemantic";
+	return assertUnreachableStep(step);
+}
+function truncateInline(text, maxChars = 60) {
+	const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\\n");
+	if (normalized.length <= maxChars) return normalized;
+	return `${normalized.slice(0, maxChars)}…(+${normalized.length - maxChars})`;
+}
+function assertUnreachableStep(_step) {
+	return "unknown";
+}
+function writeTestDataArtifact(args) {
+	try {
+		const testId = basename(args.artifactsDir);
+		const outPath = args.resolveArtifactPath("test.data.js");
+		mkdirSync(dirname(outPath), { recursive: true });
+		const steps = args.executionSteps.map((s) => ({
+			index: s.index + 1,
+			type: s.step.type,
+			label: formatPublicStepLabel(s.step),
+			ok: s.ok,
+			durationMs: s.durationMs,
+			error: s.ok ? null : s.error ?? null
+		}));
+		const data = {
+			version: 1,
+			testId,
+			scriptName: args.scriptName,
+			ok: args.ok,
+			error: args.ok ? null : args.error ?? null,
+			stepCount: steps.length,
+			steps,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const json = JSON.stringify(data).replaceAll("<", "\\u003c");
+		writeFileSync(outPath, `globalThis.__ptywright = globalThis.__ptywright || {};
+globalThis.__ptywright.tests = globalThis.__ptywright.tests || {};
+globalThis.__ptywright.tests[${JSON.stringify(testId)}] = ${json};\n`, "utf8");
+	} catch {}
+}
+function envTruthy(value) {
+	const v = value?.trim().toLowerCase();
+	return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+//#endregion
+export { ensureAsciinemaPlayerAssets as a, createDefaultPtyAdapter as c, generateTraceReportHtml as i, resolvePtyBackend as l, runScriptFile as n, formatSnapshotView as o, scriptSchema as r, SessionManager as s, runScript as t };