ccqa 1.57.2 → 1.57.3

package/dist/bin/ccqa.mjs

@@ -8154,19 +8154,19 @@ function aliasCandidates(specifier, tsconfig) {
 }
 /** A path → the file it names: itself, `<path><ext>`, or `<path>/index<ext>`. */
 async function resolveFile(pathAbs) {
-	if (await isFile(pathAbs)) return pathAbs;
+	if (await isFile$1(pathAbs)) return pathAbs;
 	const rewritten = pathAbs.replace(/\.(js|mjs|cjs)$/, "");
 	if (rewritten !== pathAbs) {
-		for (const ext of EXTENSIONS) if (await isFile(rewritten + ext)) return rewritten + ext;
+		for (const ext of EXTENSIONS) if (await isFile$1(rewritten + ext)) return rewritten + ext;
 	}
-	for (const ext of EXTENSIONS) if (await isFile(pathAbs + ext)) return pathAbs + ext;
+	for (const ext of EXTENSIONS) if (await isFile$1(pathAbs + ext)) return pathAbs + ext;
 	for (const ext of EXTENSIONS) {
 		const indexed = join(pathAbs, `index${ext}`);
-		if (await isFile(indexed)) return indexed;
+		if (await isFile$1(indexed)) return indexed;
 	}
 	return null;
 }
-function isFile(pathAbs) {
+function isFile$1(pathAbs) {
 	return stat(pathAbs).then((s) => s.isFile(), () => false);
 }
 /** `export const NAME` / `export function NAME` / `export class NAME`, and `export { A, B }`. */
@@ -9338,8 +9338,8 @@ function mergeFindings(undecided, fromModel) {
 *
 * Several producers write the `<id>.png` + `<id>.json` pairs —
 * `abStepEvidence()` / `captureFailureEvidence()` in `test-helpers.ts`
-* (agent-browser replays), `targets/playwright/trace-capture.ts` (frames read
-* out of a run's Playwright trace), and `ccqaStepBefore`/`ccqaStepAfter` in
+* (agent-browser replays), `targets/playwright/trace-capture.ts` (snapshots
+* rendered from a run's Playwright trace), and `ccqaStepBefore`/`ccqaStepAfter` in
 * `step-evidence.ts` for tests generated before the capture calls left the
 * committed file — and one consumer reads them back (`loadEvidenceForSpec` in
 * `report/evidence.ts`). They agree only on the contract here, so it is kept
@@ -13712,10 +13712,10 @@ function emptySpecRow(args) {
 *
 * Producer-agnostic on purpose. Very different writers fill these directories
 * — `abStepEvidence()` during an agent-browser replay, and, for a Playwright
-* target, frames read back out of the run's trace once the command has exited
+* target, snapshots rendered from the run's trace once the command has exited
 * — and they only have to agree on the file-pair convention documented here,
 * not on how or when the screenshot was taken. `pngFile` names the image
-* whatever its format: a trace's screencast frames are JPEG.
+* whatever its format: the ones rendered from a trace are JPEG.
 */
 /** `<reportDir>/evidence/<feature>/<spec>` — one directory per spec. */
 function specEvidenceDir(reportDir, feature, spec) {
@@ -13864,21 +13864,21 @@ function readLocalEntryData(buf, offset, method, compressedSize) {
 	return null;
 }
 /**
-* The screencast frames and the `test.step` calls one trace file holds.
+* The calls one trace holds, each runner-side call with the DOM at its two
+* boundaries: the before-snapshot of the first Playwright call inside it and the
+* after-snapshot of the last, whatever kind of call (action, wait, assertion).
+* Nothing the test did not itself wait for is shown — a step ending in a click
+* shows the DOM right after the click. Calls count at any depth, so a step
+* nested in another counts toward both.
 *
-* A trace is JSON Lines, one event object per line; a corrupt or truncated
-* line must not sink the whole read, so parsing is best-effort per line.
-* Step events come in two shapes across Playwright versions — a `before`/
-* `after` pair sharing a `callId`, or a single merged `action` event — and
-* both are folded into the same `TraceStep` shape here so callers never see
-* the version skew.
+* A trace is JSON Lines; a corrupt or truncated line must not sink the whole
+* read, so parsing is best-effort per line. A browser call points at the
+* runner call it ran in through `stepId`; the runner calls chain through
+* `parentId`.
 */
-function parseTraceEvents(jsonl) {
-	const frames = [];
-	const steps = [];
-	const pendingByCallId = /* @__PURE__ */ new Map();
-	const wallOffsets = /* @__PURE__ */ new Map();
-	let maxTimestamp = -Infinity;
+function parseTraceSteps(jsonl) {
+	const calls = /* @__PURE__ */ new Map();
+	const viewports = /* @__PURE__ */ new Map();
 	for (const line of jsonl.split("\n")) {
 		if (line.trim() === "") continue;
 		let parsed;
@@ -13889,69 +13889,72 @@ function parseTraceEvents(jsonl) {
 		}
 		if (typeof parsed !== "object" || parsed === null) continue;
 		const event = parsed;
-		for (const field of [
-			"timestamp",
-			"startTime",
-			"endTime"
-		]) {
-			const value = event[field];
-			if (typeof value === "number") maxTimestamp = Math.max(maxTimestamp, value);
-		}
-		const type = event.type;
-		if (type === "screencast-frame") {
-			if (typeof event.sha1 === "string" && typeof event.timestamp === "number") frames.push({
-				sha1: event.sha1,
-				timestamp: event.timestamp,
-				...typeof event.frameSwapWallTime === "number" ? { swapWallTime: event.frameSwapWallTime } : {}
+		const callId = event.callId;
+		if (event.type === "frame-snapshot") {
+			const snapshot = event.snapshot;
+			const viewport = snapshot?.viewport;
+			if (typeof snapshot?.snapshotName === "string" && snapshot.isMainFrame !== false && typeof viewport?.width === "number" && typeof viewport.height === "number" && !viewports.has(snapshot.snapshotName)) viewports.set(snapshot.snapshotName, {
+				width: viewport.width,
+				height: viewport.height
 			});
-		} else if (type === "context-options") {
-			if (typeof event.wallTime === "number" && typeof event.monotonicTime === "number") {
-				if (!wallOffsets.has(event.origin)) wallOffsets.set(event.origin, event.wallTime - event.monotonicTime);
-			}
-		} else if (type === "action") {
-			if (typeof event.callId === "string" && typeof event.startTime === "number" && typeof event.endTime === "number") steps.push({
+		} else if ((event.type === "before" || event.type === "action") && typeof callId === "string") {
+			if (typeof event.startTime !== "number") continue;
+			const parent = (typeof event.stepId === "string" && event.stepId !== callId ? event.stepId : void 0) ?? (typeof event.parentId === "string" ? event.parentId : void 0);
+			calls.set(callId, {
 				title: titleOf$1(event),
 				startTime: event.startTime,
-				endTime: event.endTime,
-				...errorOf(event)
-			});
-		} else if (type === "before") {
-			if (typeof event.callId === "string" && typeof event.startTime === "number") pendingByCallId.set(event.callId, {
-				title: titleOf$1(event),
-				startTime: event.startTime
+				...parent !== void 0 ? { parent } : {},
+				...typeof event.pageId === "string" ? { pageId: event.pageId } : {},
+				...typeof event.beforeSnapshot === "string" ? { beforeSnapshot: event.beforeSnapshot } : {}
 			});
-		} else if (type === "after") {
-			if (typeof event.callId === "string" && typeof event.endTime === "number") {
-				const pending = pendingByCallId.get(event.callId);
-				if (pending !== void 0) {
-					pendingByCallId.delete(event.callId);
-					steps.push({
-						...pending,
-						endTime: event.endTime,
-						...errorOf(event)
-					});
-				}
-			}
+		}
+		if ((event.type === "after" || event.type === "action") && typeof callId === "string") {
+			const call = calls.get(callId);
+			if (call === void 0) continue;
+			if (typeof event.endTime === "number") call.endTime = event.endTime;
+			if (typeof event.afterSnapshot === "string") call.afterSnapshot = event.afterSnapshot;
+			Object.assign(call, errorOf(event));
 		}
 	}
-	for (const pending of pendingByCallId.values()) steps.push({
-		...pending,
-		endTime: maxTimestamp
-	});
-	const offset = wallOffsets.get("testRunner") ?? wallOffsets.values().next().value;
-	const painted = offset !== void 0 && frames.every((f) => f.swapWallTime !== void 0);
-	const placed = frames.map(({ sha1, timestamp, swapWallTime }) => ({
-		sha1,
-		timestamp: painted ? swapWallTime - offset : timestamp
-	}));
-	placed.sort((a, b) => a.timestamp - b.timestamp);
-	steps.sort((a, b) => a.startTime - b.startTime);
-	return {
-		frames: placed,
-		steps
+	const steps = /* @__PURE__ */ new Map();
+	for (const call of calls.values()) {
+		if (call.pageId !== void 0) continue;
+		steps.set(call, {
+			title: call.title,
+			...call.error !== void 0 ? { error: call.error } : {}
+		});
+	}
+	for (const call of calls.values()) {
+		if (call.pageId === void 0) continue;
+		const seen = /* @__PURE__ */ new Set();
+		for (let id = call.parent; id !== void 0 && !seen.has(id); id = calls.get(id)?.parent) {
+			seen.add(id);
+			const step = steps.get(calls.get(id));
+			if (step === void 0) continue;
+			if (call.beforeSnapshot !== void 0 && (!step.first || call.startTime < step.first.startTime)) step.first = call;
+			if (call.afterSnapshot !== void 0 && call.endTime !== void 0 && (!step.last || call.endTime > step.last.endTime)) step.last = call;
+		}
+	}
+	const ref = (call, name) => {
+		const viewport = viewports.get(name);
+		return {
+			pageId: call.pageId,
+			name,
+			...viewport ? { viewport } : {}
+		};
 	};
+	return [...steps.entries()].sort(([a], [b]) => a.startTime - b.startTime).map(([, { first, last, ...step }]) => ({
+		...step,
+		...first ? { before: ref(first, first.beforeSnapshot) } : {},
+		...last ? { after: ref(last, last.afterSnapshot) } : {}
+	}));
+}
+/** The joined `.trace` members of an archive: the runner's steps and the browser's calls are separate files. */
+async function readTraceJsonl(archive) {
+	const entries = await readZip(archive);
+	return entries.names.filter((name) => name.endsWith(".trace")).map((name) => entries.read(name)?.toString("utf8") ?? "").join("\n");
 }
-/** The step's failure message, in whichever shape the trace recorded it. */
+/** The call's failure message, in whichever shape the trace recorded it. */
 function errorOf(event) {
 	const error = event.error;
 	if (typeof error === "string") return { error };
@@ -13966,23 +13969,131 @@ function titleOf$1(event) {
 	if (typeof event.title === "string") return event.title;
 	return "";
 }
+//#endregion
+//#region src/targets/playwright/resolve-playwright.ts
 /**
-* One paint interval at 60fps. An assertion passes on the DOM, so a step can
-* end before the frame showing that DOM is painted — at most one interval later.
-*/
-const ONE_FRAME_MS = 17;
-/**
-* The frame showing the page as it was at `time`: the last one painted within
-* a frame interval of it, or — when the step began before any frame was
-* captured — the first frame after. Null when the trace holds no frames at
-* all. `frames` comes from {@link parseTraceEvents}, sorted by paint time.
+* The consumer's Playwright, not a dependency of ccqa's: its browser and its
+* trace viewer have to match the version the tests run with.
 *
-* A step's start takes the same allowance as its end: it is the same boundary
-* as the previous step's end, and would otherwise show that step unfinished.
+* Under pnpm's isolation `playwright-core` may only be reachable through
+* `@playwright/test` → `playwright`, so each link is resolved from the one
+* before, skipping links a project does not have. `dirs` are tried in order —
+* nearest first, since in a monorepo only the e2e package may have Playwright.
 */
-function frameAt(frames, time) {
-	const painted = time + ONE_FRAME_MS;
-	return frames.findLast((f) => f.timestamp <= painted) ?? frames[0] ?? null;
+async function loadPlaywright(dirs) {
+	for (const dir of dirs) {
+		const coreDir = resolveCoreDir(dir);
+		if (coreDir === null) continue;
+		const mod = await import(pathToFileURL(createRequire(join(coreDir, "package.json")).resolve("playwright-core")).href);
+		const chromium = mod.chromium ?? mod.default?.chromium;
+		if (chromium !== void 0) return {
+			coreDir,
+			chromium
+		};
+	}
+	throw new Error(`Playwright is not installed in ${dirs.join(" or ")}`);
+}
+function resolveCoreDir(dir) {
+	let from = dir;
+	for (const name of [
+		"@playwright/test",
+		"playwright",
+		"playwright-core"
+	]) try {
+		from = dirname(createRequire(join(from, "package.json")).resolve(`${name}/package.json`));
+		if (name === "playwright-core") return from;
+	} catch {}
+	return null;
+}
+//#endregion
+//#region src/targets/playwright/trace-snapshot.ts
+/** A snapshot that never settles must not hold the run's report hostage. */
+const RENDER_TIMEOUT_MS = 15e3;
+const LAUNCH_TIMEOUT_MS = 3e4;
+const TRACE_PATH = "trace.zip";
+const CONTENT_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript",
+	".css": "text/css",
+	".svg": "image/svg+xml",
+	".ttf": "font/ttf",
+	".zip": "application/zip"
+};
+/**
+* A renderer over one trace archive, using the first Playwright `dirs`
+* resolves. Throws when that Playwright, its viewer, or its Chromium is missing.
+*/
+async function openSnapshotRenderer(dirs, archive) {
+	const { coreDir, chromium } = await loadPlaywright(dirs);
+	const viewerDir = join(coreDir, "lib", "vite", "traceViewer");
+	if (!isFile(join(viewerDir, "snapshot.html"))) throw new Error(`the installed Playwright has no trace viewer at ${viewerDir}`);
+	const server = await serve(viewerDir, archive);
+	const base = `http://127.0.0.1:${server.address().port}/`;
+	const browser = await chromium.launch({ timeout: LAUNCH_TIMEOUT_MS }).catch(async (err) => {
+		await closeServer(server);
+		throw err;
+	});
+	const close = async () => {
+		try {
+			await browser.close();
+		} finally {
+			await closeServer(server);
+		}
+	};
+	try {
+		const page = await browser.newPage();
+		page.setDefaultTimeout(RENDER_TIMEOUT_MS);
+		await page.goto(`${base}snapshot.html?trace=${TRACE_PATH}`);
+		await page.waitForFunction("!!navigator.serviceWorker.controller");
+		if (await page.evaluate(`fetch("contexts?trace=${TRACE_PATH}").then((r) => r.ok)`) !== true) throw new Error("the trace viewer could not load the trace");
+		return {
+			async render(snapshot) {
+				if (snapshot.viewport) await page.setViewportSize(snapshot.viewport);
+				const url = `${base}snapshot/${snapshot.pageId}?trace=${TRACE_PATH}&name=${encodeURIComponent(snapshot.name)}`;
+				await page.goto(`${base}snapshot.html?trace=${TRACE_PATH}&r=${encodeURIComponent(url)}`);
+				const frame = await (await page.waitForSelector("iframe")).contentFrame();
+				if (frame === null) throw new Error("the trace viewer showed no snapshot frame");
+				await frame.waitForURL(/\/snapshot\//, { waitUntil: "load" });
+				await frame.waitForFunction("document.fonts.status === 'loaded' && Array.from(document.images).every((i) => i.complete)");
+				return await frame.evaluate("!document.body || (document.body.childElementCount === 0 && document.body.textContent.trim() === '')") === false ? page.screenshot({ type: "jpeg" }) : null;
+			},
+			close
+		};
+	} catch (err) {
+		await close().catch(() => {});
+		throw err;
+	}
+}
+/** The viewer's files and the one archive, on loopback only. */
+async function serve(viewerDir, archive) {
+	const root = resolve(viewerDir);
+	const server = createServer((req, res) => {
+		const path = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+		const file = path === `/${TRACE_PATH}` ? archive : resolve(root, `.${path}`);
+		if (file !== archive && !file.startsWith(root + sep) || !isFile(file)) {
+			res.statusCode = 404;
+			res.end();
+			return;
+		}
+		res.setHeader("Content-Type", CONTENT_TYPES[extname(file)] ?? "application/octet-stream");
+		createReadStream(file).on("error", () => res.destroy()).pipe(res);
+	});
+	await new Promise((done, fail) => {
+		server.once("error", fail);
+		server.listen(0, "127.0.0.1", done);
+	});
+	return server;
+}
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function closeServer(server) {
+	server.closeAllConnections();
+	return new Promise((done) => server.close(() => done()));
 }
 //#endregion
 //#region src/targets/playwright/trace-capture.ts
@@ -13993,15 +14104,11 @@ function frameAt(frames, time) {
 * `test.step` blocks and there is no capture call to place a screenshot at
 * either boundary. So the screenshots are not taken during the run at all —
 * ccqa asks Playwright for a trace on the invocations it owns, and afterwards
-* reads the step boundaries and the screencast out of the archive. Nothing in
-* the consumer's repository changes, and nothing ccqa does here can turn a
-* passing test red: the whole path runs after the command has exited, and a
-* trace it cannot read costs the report its pictures and says so.
-*
-* The frames are the trace's own screencast, which Playwright records
-* downscaled — they are the filmstrip a reviewer already sees in the trace
-* viewer, not `page.screenshot()` output. That is the price of taking the
-* capture code out of the committed file.
+* renders the DOM snapshots the trace took around each step's browser calls.
+* Nothing in the consumer's repository changes, and nothing ccqa does here can
+* turn a passing test red: the whole path runs after the command has exited,
+* and a trace it cannot read or render costs the report its pictures and says
+* so.
 */
 /** Shell characters that would hand an appended flag to a different program. */
 const SHELL_OPERATORS = /[|;&<>`$]/;
@@ -14043,82 +14150,124 @@ function amendForTrace(command, outputDir) {
 	const flags = [/(^|\s)--trace[=\s]/.test(command) ? "" : "--trace=on", directsOutput ? "" : `--output=${quoteForShell(outputDir)}`].filter(Boolean);
 	return { command: flags.length > 0 ? `${command} ${flags.join(" ")}` : command };
 }
+/** Rendering one archive stops here, so a slow viewer cannot stall the report. */
+const ARCHIVE_BUDGET_MS = 6e4;
 /**
-* Make sure `evidenceDir` holds the spec's per-step screenshots, reading the
-* trace the run left in `artifactsDir` when nothing else wrote them. Returns
-* null when the directory has evidence in it, and otherwise the reason there
-* is nothing to show.
+* Make sure `evidenceDir` holds the spec's per-step screenshots, rendering them
+* from the trace the run left in `artifactsDir` when nothing else wrote them.
+* Returns null when the directory has evidence in it, and otherwise the reason
+* there is nothing to show. A step that gets no picture is reported through
+* `warn` and costs only its own row.
 *
 * A spec generated before the capture calls left the committed file writes its
-* own frames as it runs; those are the test's own and are left alone.
-*
-* Every step of every trace found is written, not just the first archive's: a
-* retried test leaves one archive per attempt, and the later one overwrites
-* the earlier, which is the attempt the row reports.
+* own screenshots as it runs; those are the test's own and are left alone.
 */
 async function captureStepEvidence(args) {
 	if ((await readdir(args.evidenceDir).catch(() => [])).length > 0) return null;
-	const archives = (await walkFiles$1(args.artifactsDir)).filter(isTraceArchive).sort().map((rel) => join(args.artifactsDir, ...rel.split("/")));
+	const archives = lastAttempts((await walkFiles$1(args.artifactsDir)).filter(isTraceArchive)).map((rel) => join(args.artifactsDir, ...rel.split("/")));
 	if (archives.length === 0) return "the run left no Playwright trace, so there are no per-step screenshots to read — the generated test's `test.step` blocks are what ccqa reads them from";
 	let written = 0;
-	let frames = 0;
-	const failures = [];
+	let named = 0;
+	let firstError;
 	for (const archive of archives) try {
-		const archived = await writeArchiveEvidence(archive, args.evidenceDir);
+		const archived = await writeArchiveEvidence(archive, args);
 		written += archived.written;
-		frames += archived.frames;
+		named += archived.named;
+		firstError ??= archived.firstError;
 	} catch (err) {
-		failures.push(`${archive}: ${err instanceof Error ? err.message : String(err)}`);
+		firstError ??= errMessage(err);
 	}
 	if (written > 0) return null;
-	if (failures.length > 0) return `ccqa could not read the run's Playwright trace (${failures[0]})`;
-	if (frames === 0) return "the run's Playwright trace holds no screenshots — the step frames come from its screencast, which Playwright records only while the trace's `screenshots` option is on (`--trace=on` asks for it; a `trace` option in the project's config can turn it off)";
-	return "the run's Playwright trace holds no step the case names — a rewrite pass may have reshaped the `test.step` titles the draft wrote; re-run `ccqa generate` for this spec";
+	if (firstError !== void 0) return `ccqa could not render the trace's snapshots: ${firstError}`;
+	if (named === 0) return "the run's Playwright trace holds no step the case names — a rewrite pass may have reshaped the `test.step` titles the draft wrote; re-run `ccqa generate` for this spec";
+	return "the run's Playwright trace holds no DOM snapshot for any step — Playwright records them only while the trace's `snapshots` option is on (`--trace=on` asks for it; a `trace` option in the project's config can turn it off)";
 }
-/** One archive's steps, written as evidence, and the frames it had to write them from. */
-async function writeArchiveEvidence(archive, evidenceDir) {
-	const entries = await readZip(archive);
-	const { frames, steps } = parseTraceEvents(entries.names.filter((name) => name.endsWith(".trace")).map((name) => entries.read(name)?.toString("utf8") ?? "").join("\n"));
-	if (frames.length === 0) return {
+/**
+* Each test's last attempt: a retry leaves `<dir>-retry<n>` beside the first
+* attempt's `<dir>`, and the attempt the row reports is the last one.
+*/
+function lastAttempts(archives) {
+	const last = /* @__PURE__ */ new Map();
+	for (const archive of archives) {
+		const match = /^(.*)-retry(\d+)$/.exec(dirname(archive));
+		const test = match ? match[1] : dirname(archive);
+		const attempt = match ? Number(match[2]) : 0;
+		if ((last.get(test)?.attempt ?? -1) < attempt) last.set(test, {
+			archive,
+			attempt
+		});
+	}
+	return [...last.values()].map((v) => v.archive).sort();
+}
+/** One archive's steps, written as evidence; how many steps the case named; the first render error. */
+async function writeArchiveEvidence(archive, args) {
+	const steps = parseTraceSteps(await readTraceJsonl(archive)).flatMap((step) => {
+		const label = parseStepLabel(step.title);
+		return label === null ? [] : [{
+			...step,
+			label
+		}];
+	});
+	if (!steps.some((step) => step.after !== void 0)) return {
 		written: 0,
-		frames: 0
+		named: steps.length
 	};
-	await mkdir(evidenceDir, { recursive: true });
+	const renderer = await (args.openRenderer ?? openSnapshotRenderer)(args.playwrightFrom, archive);
+	const deadline = Date.now() + ARCHIVE_BUDGET_MS;
 	let written = 0;
-	for (const step of steps) {
-		const label = parseStepLabel(step.title);
-		if (label === null) continue;
-		const stem = sanitizeStepId(label.stepId);
-		const after = await writeFrame(entries, frames, step.endTime, evidenceDir, stem);
-		if (after === null) continue;
-		const before = await writeFrame(entries, frames, step.startTime, evidenceDir, `${stem}.before`);
-		await writeFile(join(evidenceDir, `${stem}.json`), `${JSON.stringify({
-			stepId: label.stepId,
-			source: label.source,
-			pngFile: after,
-			...before !== null ? { beforePngFile: before } : {},
-			...step.error !== void 0 ? { failureSummary: step.error } : {},
-			url: null,
-			title: null,
-			capturedAt: (/* @__PURE__ */ new Date()).toISOString()
-		}, null, 2)}\n`, "utf8");
-		written += 1;
+	let firstError;
+	const render = async (snapshot, stepId, end) => {
+		let failure;
+		try {
+			const image = await renderer.render(snapshot);
+			if (image !== null || end === "before") return image;
+			failure = "snapshot rendered blank";
+		} catch (err) {
+			failure = errMessage(err);
+		}
+		firstError ??= failure;
+		args.warn(`${stepId}: no ${end} screenshot — rendering ${snapshot.name} failed (${failure})`);
+		return null;
+	};
+	try {
+		await mkdir(args.evidenceDir, { recursive: true });
+		for (const [index, step] of steps.entries()) {
+			if (Date.now() > deadline) {
+				args.warn(`stopped rendering after ${ARCHIVE_BUDGET_MS / 1e3}s — ${steps.length - index} step(s) left without screenshots`);
+				break;
+			}
+			const { stepId, source } = step.label;
+			if (step.after === void 0) {
+				args.warn(`${stepId}: no screenshot — the trace holds no DOM snapshot of a browser call in this step`);
+				continue;
+			}
+			const stem = sanitizeStepId(stepId);
+			const after = await render(step.after, stepId, "after");
+			if (after === null) continue;
+			await writeFile(join(args.evidenceDir, `${stem}.jpeg`), after);
+			const before = step.before ? await render(step.before, stepId, "before") : null;
+			if (before !== null) await writeFile(join(args.evidenceDir, `${stem}.before.jpeg`), before);
+			await writeFile(join(args.evidenceDir, `${stem}.json`), `${JSON.stringify({
+				stepId,
+				source,
+				pngFile: `${stem}.jpeg`,
+				...before !== null ? { beforePngFile: `${stem}.before.jpeg` } : {},
+				...step.error !== void 0 ? { failureSummary: step.error } : {},
+				url: null,
+				title: null,
+				capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}, null, 2)}\n`, "utf8");
+			written += 1;
+		}
+	} finally {
+		await renderer.close().catch((err) => args.warn(`could not close the trace viewer (${errMessage(err)})`));
 	}
 	return {
 		written,
-		frames: frames.length
+		named: steps.length,
+		...firstError !== void 0 ? { firstError } : {}
 	};
 }
-/** The frame on screen at `time`, written under `stem`. Null when there is none. */
-async function writeFrame(entries, frames, time, evidenceDir, stem) {
-	const frame = frameAt(frames, time);
-	if (frame === null) return null;
-	const data = entries.read(`resources/${frame.sha1}`) ?? entries.read(`resources/${frame.sha1}.jpeg`);
-	if (data === void 0) return null;
-	const file = `${stem}.jpeg`;
-	await writeFile(join(evidenceDir, file), data);
-	return file;
-}
 //#endregion
 //#region src/targets/run-command-runner.ts
 /**
@@ -14313,6 +14462,8 @@ async function runOneSpec(ref, opts) {
 		evidence,
 		artifactsDir,
 		testCase,
+		caseKey: `${featureName}/${specName}`,
+		playwrightFrom: [dirname(resolve(opts.cwd, testFile)), opts.cwd],
 		...traceUnavailable !== void 0 ? { traceUnavailable } : {}
 	});
 	if (outcome.exitCode === 0) return {
@@ -14367,7 +14518,9 @@ async function loadStepEvidence(args) {
 	const evidenceDir = args.evidence.dir;
 	const reason = args.traceUnavailable ?? await captureStepEvidence({
 		artifactsDir: args.artifactsDir,
-		evidenceDir
+		evidenceDir,
+		playwrightFrom: args.playwrightFrom,
+		warn: (message) => warn(`${args.caseKey}: ${message}`)
 	});
 	const descriptions = stepCaptions(args.testCase);
 	const evidence = await loadEvidenceForSpec(evidenceDir, opts.reportDir, descriptions);
@@ -14863,7 +15016,9 @@ async function verifyRun(p, state, runCommand, attempt, captures) {
 		if (evidenceDir && result.exitCode === 0) {
 			const unavailable = traceUnavailable ?? await captureStepEvidence({
 				artifactsDir,
-				evidenceDir
+				evidenceDir,
+				playwrightFrom: [...testFiles.map((f) => dirname(join(p.ctx.cwd, f))), p.ctx.cwd],
+				warn: (message) => warn(`${p.ctx.ref.id}: ${message}`)
 			});
 			if (unavailable) warn(unavailable);
 		}
@@ -15704,7 +15859,7 @@ const CONFIG_NAMES = [
 ];
 async function acquirePlaywrightBrowser(ctx) {
 	await sweepStaleWrappersOnce(ctx.cwd);
-	const chromium = await resolveChromium(ctx.cwd);
+	const { chromium } = await loadPlaywright([ctx.cwd]);
 	const port = await freePort();
 	const server = await chromium.launchServer({ args: [`--remote-debugging-port=${port}`] });
 	let wrapperPath;
@@ -15762,25 +15917,6 @@ async function sweepStaleWrappers(cwd) {
 function shellQuote(s) {
 	return `'${s.replaceAll("'", `'\\''`)}'`;
 }
-/**
-* The consumer's Playwright, not a dependency of ccqa's: their tests speak
-* their version's protocol, and the server has to be the same animal. Their
-* `runCommand` runs `playwright test`, so the package is present — but under
-* pnpm's isolation it may only be resolvable through `@playwright/test`.
-*/
-async function resolveChromium(cwd) {
-	const fromProject = createRequire(join(cwd, "package.json"));
-	const origins = [];
-	try {
-		origins.push(fromProject.resolve("@playwright/test/package.json"));
-	} catch {}
-	for (const name of ["playwright", "playwright-core"]) for (const origin of [null, ...origins]) try {
-		const mod = await import(pathToFileURL((origin === null ? fromProject : createRequire(origin)).resolve(name)).href);
-		const chromium = mod.chromium ?? mod.default?.chromium;
-		if (chromium !== void 0) return chromium;
-	} catch {}
-	throw new Error(`could not resolve Playwright from ${cwd} — the playwright target's --coverage launches the browser with the project's own Playwright, which must be installed`);
-}
 async function writeWrapperConfig(ctx) {
 	const existing = CONFIG_NAMES.find((name) => existsSync(join(ctx.cwd, name)));
 	const wrapperName = `ccqa-coverage.${slug(ctx.featureName)}--${slug(ctx.specName)}.playwright.config.ts`;

package/dist/{evidence-constants-BkPzGtzI.cjs → evidence-constants-BNe7Q305.cjs}

@@ -5,8 +5,8 @@
 *
 * Several producers write the `<id>.png` + `<id>.json` pairs —
 * `abStepEvidence()` / `captureFailureEvidence()` in `test-helpers.ts`
-* (agent-browser replays), `targets/playwright/trace-capture.ts` (frames read
-* out of a run's Playwright trace), and `ccqaStepBefore`/`ccqaStepAfter` in
+* (agent-browser replays), `targets/playwright/trace-capture.ts` (snapshots
+* rendered from a run's Playwright trace), and `ccqaStepBefore`/`ccqaStepAfter` in
 * `step-evidence.ts` for tests generated before the capture calls left the
 * committed file — and one consumer reads them back (`loadEvidenceForSpec` in
 * `report/evidence.ts`). They agree only on the contract here, so it is kept

package/dist/{evidence-constants-BLXD0LRY.mjs → evidence-constants-WMpQPI8P.mjs}

@@ -5,8 +5,8 @@
 *
 * Several producers write the `<id>.png` + `<id>.json` pairs —
 * `abStepEvidence()` / `captureFailureEvidence()` in `test-helpers.ts`
-* (agent-browser replays), `targets/playwright/trace-capture.ts` (frames read
-* out of a run's Playwright trace), and `ccqaStepBefore`/`ccqaStepAfter` in
+* (agent-browser replays), `targets/playwright/trace-capture.ts` (snapshots
+* rendered from a run's Playwright trace), and `ccqaStepBefore`/`ccqaStepAfter` in
 * `step-evidence.ts` for tests generated before the capture calls left the
 * committed file — and one consumer reads them back (`loadEvidenceForSpec` in
 * `report/evidence.ts`). They agree only on the contract here, so it is kept

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.57.2",
+  "version": "1.57.3",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {

package/dist/runtime/step-evidence.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_evidence_constants = require("../evidence-constants-BkPzGtzI.cjs");
+const require_evidence_constants = require("../evidence-constants-BNe7Q305.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/runtime/step-evidence.ts

package/dist/runtime/step-evidence.mjs

@@ -1,4 +1,4 @@
-import { i as sanitizeStepId, t as EVIDENCE_DIR_ENV } from "../evidence-constants-BLXD0LRY.mjs";
+import { i as sanitizeStepId, t as EVIDENCE_DIR_ENV } from "../evidence-constants-WMpQPI8P.mjs";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/runtime/step-evidence.ts

package/dist/runtime/test-helpers.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_evidence_constants = require("../evidence-constants-BkPzGtzI.cjs");
+const require_evidence_constants = require("../evidence-constants-BNe7Q305.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_child_process = require("node:child_process");

package/dist/runtime/test-helpers.mjs

@@ -1,4 +1,4 @@
-import { i as sanitizeStepId, n as FAILURE_SOURCE, r as FAILURE_STEP_ID, t as EVIDENCE_DIR_ENV } from "../evidence-constants-BLXD0LRY.mjs";
+import { i as sanitizeStepId, n as FAILURE_SOURCE, r as FAILURE_STEP_ID, t as EVIDENCE_DIR_ENV } from "../evidence-constants-WMpQPI8P.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.57.2",
+  "version": "1.57.3",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {