reeval 0.7.0 → 0.9.0

package/dist/capture-Bp74Z6Fr.js

@@ -0,0 +1,1257 @@
+import { t as parseDuration } from "./duration-JsJrIWXq.js";
+import { s as cacheDir } from "./root-CvdRlRZX.js";
+import { t as InfraError } from "./types-C5vI3g1C.js";
+import { l as sha256 } from "./ids-Bp6ut7ZD.js";
+import { l as judgeRoute } from "./judge-CeYPN8P_.js";
+import { n as shellQuote } from "./process-CSVO_jsc.js";
+import { n as getRunContext, o as SUBJECT } from "./runtime-DdsfnRz_.js";
+import { i as debugTrace, r as debugLog } from "./attempt-CGPV3BZY.js";
+import { n as clip, r as formatDuration } from "./text-gEcKjAyp.js";
+import { a as providerModel } from "./model-B1BZoZ9b.js";
+import { r as isWaitStep, t as fakeInstructionSteps } from "./fake-instructions-CUI33I_F.js";
+import { t as addUsage } from "./usage-DDF_6tkV.js";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, posix } from "node:path";
+import { createServer } from "node:net";
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { generateText, stepCountIs, tool } from "ai";
+import { z } from "zod";
+import { crc32, deflateSync, inflateRawSync } from "node:zlib";
+//#region src/capture/zip.ts
+const LOCAL = 67324752;
+/** Extracts a zip (store or deflate) into `files` keyed by posix path. */
+function unzip(bytes) {
+	const buf = Buffer.from(bytes);
+	const files = /* @__PURE__ */ new Map();
+	let i = 0;
+	while (i + 30 <= buf.length) {
+		if (buf.readUInt32LE(i) !== LOCAL) break;
+		const method = buf.readUInt16LE(i + 8);
+		const comp = buf.readUInt32LE(i + 18);
+		const nameLen = buf.readUInt16LE(i + 26);
+		const extra = buf.readUInt16LE(i + 28);
+		const name = buf.toString("utf8", i + 30, i + 30 + nameLen);
+		const start = i + 30 + nameLen + extra;
+		const raw = buf.subarray(start, start + comp);
+		if (name.endsWith("/")) {
+			i = start + comp;
+			continue;
+		}
+		if (method === 0) files.set(name, Buffer.from(raw));
+		else if (method === 8) files.set(name, Buffer.from(inflateRawSync(raw)));
+		else throw new Error(`zip method ${method} is not supported (${name})`);
+		i = start + comp;
+	}
+	return files;
+}
+//#endregion
+//#region src/capture/browser.ts
+const isMs = (wait) => typeof wait === "object" && wait !== null;
+/** The CDP event `'idle'` waits for; `'load'` is `Page.loadEventFired`. */
+function captureWaitLabel(wait) {
+	return wait === "idle" ? "networkAlmostIdle" : "load";
+}
+function captureWaitTimeout(wait) {
+	return /* @__PURE__ */ new Error(`c.capture() timed out waiting for ${captureWaitLabel(wait)}`);
+}
+function waitTimeout(wait, detail) {
+	if (isMs(wait)) return /* @__PURE__ */ new Error(`c.capture() timed out${detail ? ` on ${detail}` : ""} waiting ${wait.ms}ms`);
+	return captureWaitTimeout(wait);
+}
+async function waitForPage(cdp, wait, timeoutMs, nav) {
+	if (isMs(wait)) {
+		if (timeoutMs <= 0) throw waitTimeout(wait);
+		const ms = Math.min(wait.ms, timeoutMs);
+		await new Promise((resolve) => setTimeout(resolve, ms));
+		return;
+	}
+	const page = listenForCaptureWait(cdp, wait);
+	page.arm();
+	await page.ready(nav, timeoutMs);
+}
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+/** Map a full-page click onto the live window, scrolling with the wheel if needed. */
+function mapPagePoint(x, y, window, page, scrollY) {
+	const maxY = Math.max(0, (page?.height ?? window.height) - window.height);
+	const target = y >= window.height || y < 0 ? clamp(y - window.height / 2, 0, maxY) : scrollY;
+	const nextY = clamp(target, 0, maxY);
+	return {
+		x: clamp(x, 0, window.width - 1),
+		y: clamp(y - nextY, 0, window.height - 1),
+		scrollY: nextY,
+		dy: nextY - scrollY
+	};
+}
+async function dispatchInput(cdp, action, window, page, scrollY = 0) {
+	if (action.type === "done") return scrollY;
+	if (action.type === "type") {
+		await cdp.send("Input.insertText", { text: action.text });
+		return scrollY;
+	}
+	if (action.type === "key") {
+		const key = action.key;
+		const vk = key === "Tab" ? 9 : 13;
+		await cdp.send("Input.dispatchKeyEvent", {
+			type: "keyDown",
+			key,
+			code: key,
+			windowsVirtualKeyCode: vk
+		});
+		await cdp.send("Input.dispatchKeyEvent", {
+			type: "keyUp",
+			key,
+			code: key,
+			windowsVirtualKeyCode: vk
+		});
+		return scrollY;
+	}
+	if (action.type === "scroll") {
+		await cdp.send("Input.dispatchMouseEvent", {
+			type: "mouseWheel",
+			x: action.x,
+			y: action.y,
+			deltaX: 0,
+			deltaY: action.dy
+		});
+		return scrollY + action.dy;
+	}
+	const mapped = mapPagePoint(action.type === "drag" ? action.x : action.x, action.type === "drag" ? action.y : action.y, window, page, scrollY);
+	if (mapped.dy !== 0) await cdp.send("Input.dispatchMouseEvent", {
+		type: "mouseWheel",
+		x: window.width / 2,
+		y: window.height / 2,
+		deltaX: 0,
+		deltaY: mapped.dy
+	});
+	const at = {
+		x: mapped.x,
+		y: mapped.y
+	};
+	if (action.type === "hover") {
+		await cdp.send("Input.dispatchMouseEvent", {
+			type: "mouseMoved",
+			...at
+		});
+		return mapped.scrollY;
+	}
+	if (action.type === "click") {
+		await cdp.send("Input.dispatchMouseEvent", {
+			type: "mouseMoved",
+			...at,
+			button: "left"
+		});
+		await cdp.send("Input.dispatchMouseEvent", {
+			type: "mousePressed",
+			...at,
+			button: "left",
+			clickCount: 1
+		});
+		await cdp.send("Input.dispatchMouseEvent", {
+			type: "mouseReleased",
+			...at,
+			button: "left",
+			clickCount: 1
+		});
+		return mapped.scrollY;
+	}
+	const end = mapPagePoint(action.toX, action.toY, window, page, mapped.scrollY);
+	if (end.dy !== 0) await cdp.send("Input.dispatchMouseEvent", {
+		type: "mouseWheel",
+		x: window.width / 2,
+		y: window.height / 2,
+		deltaX: 0,
+		deltaY: end.dy
+	});
+	await cdp.send("Input.dispatchMouseEvent", {
+		type: "mouseMoved",
+		x: at.x,
+		y: at.y,
+		button: "left"
+	});
+	await cdp.send("Input.dispatchMouseEvent", {
+		type: "mousePressed",
+		x: at.x,
+		y: at.y,
+		button: "left",
+		clickCount: 1
+	});
+	await cdp.send("Input.dispatchMouseEvent", {
+		type: "mouseMoved",
+		x: end.x,
+		y: end.y,
+		button: "left"
+	});
+	await cdp.send("Input.dispatchMouseEvent", {
+		type: "mouseReleased",
+		x: end.x,
+		y: end.y,
+		button: "left",
+		clickCount: 1
+	});
+	return end.scrollY;
+}
+function lifecycleParams(msg) {
+	const body = msg;
+	return body.params ?? body;
+}
+/**
+* Arms after `Page.enable` so about:blank's events cannot resolve the wait.
+* Call `arm` immediately before `Page.navigate`.
+*/
+function listenForCaptureWait(cdp, wait) {
+	const method = wait === "idle" ? "Page.lifecycleEvent" : "Page.loadEventFired";
+	const pending = [];
+	let deliver;
+	let started = false;
+	cdp.on(method, (msg) => {
+		if (!started) return;
+		if (deliver) deliver(msg);
+		else pending.push(msg);
+	});
+	const matches = (msg, loaderId) => {
+		if (wait === "load") return true;
+		const params = lifecycleParams(msg);
+		if (params.name !== "networkAlmostIdle") return false;
+		return !loaderId || params.loaderId === loaderId;
+	};
+	return {
+		arm() {
+			started = true;
+		},
+		ready(nav, timeoutMs) {
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => reject(captureWaitTimeout(wait)), timeoutMs);
+				const finish = () => {
+					clearTimeout(timer);
+					resolve();
+				};
+				deliver = (msg) => {
+					if (matches(msg, nav?.loaderId)) finish();
+				};
+				if (pending.some((msg) => matches(msg, nav?.loaderId))) finish();
+			});
+		}
+	};
+}
+/** Pinned Chrome for Testing `chrome-headless-shell` build. */
+const CHROME_VERSION = "140.0.7339.185";
+const CHROME_NAME = "chrome-headless-shell";
+function chromePlatform() {
+	if (process.platform === "darwin") return process.arch === "arm64" ? "mac-arm64" : "mac-x64";
+	if (process.platform === "win32") return "win64";
+	return "linux64";
+}
+function chromeUrl(platform) {
+	return `https://storage.googleapis.com/chrome-for-testing-public/${CHROME_VERSION}/${platform}/${CHROME_NAME}-${platform}.zip`;
+}
+function binaryName() {
+	return process.platform === "win32" ? `${CHROME_NAME}.exe` : CHROME_NAME;
+}
+async function downloadZip(url, onProgress, cacheLabel, signal) {
+	const res = await fetch(url, { signal });
+	if (!res.ok) throw new Error(`download failed: HTTP ${res.status}`);
+	const total = Number(res.headers.get("content-length")) || null;
+	const report = (received) => onProgress?.({
+		name: CHROME_NAME,
+		version: CHROME_VERSION,
+		bytes: total,
+		received,
+		cache: cacheLabel
+	});
+	report(0);
+	if (!res.body) return Buffer.from(await res.arrayBuffer());
+	const reader = res.body.getReader();
+	const chunks = [];
+	let received = 0;
+	let last = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		received += value.length;
+		if (received - last >= 262144 || total && received === total) {
+			report(received);
+			last = received;
+		}
+	}
+	if (received !== last) report(received);
+	return Buffer.concat(chunks);
+}
+function extractBinary(zip, dest, platform) {
+	const files = unzip(zip);
+	const needle = `/${binaryName()}`;
+	const entry = [...files.entries()].find(([name]) => name.endsWith(needle) || name === binaryName() || name.endsWith(`\\${binaryName()}`));
+	if (!entry) {
+		const names = [...files.keys()].slice(0, 8).join(", ");
+		throw new Error(`zip has no ${binaryName()} (saw ${names || "nothing"})`);
+	}
+	const prefix = entry[0].slice(0, -binaryName().length);
+	mkdirSync(dest, { recursive: true });
+	for (const [name, data] of files) {
+		const rel = prefix && name.startsWith(prefix) ? name.slice(prefix.length) : name;
+		if (!rel || rel.endsWith("/")) continue;
+		const target = join(dest, ...rel.split("/"));
+		mkdirSync(join(target, ".."), { recursive: true });
+		writeFileSync(target, data);
+	}
+	const bin = join(dest, binaryName());
+	if (!existsSync(bin)) writeFileSync(bin, entry[1]);
+	if (process.platform !== "win32") chmodSync(bin, 493);
+}
+/**
+* Returns the cached binary, downloading on a miss. `onProgress` runs only for a download.
+*/
+async function ensureChrome(cacheRoot, options = { cacheLabel: cacheRoot }) {
+	const platform = chromePlatform();
+	const dest = join(cacheRoot, CHROME_NAME, CHROME_VERSION, platform);
+	const bin = join(dest, binaryName());
+	if (existsSync(bin)) return bin;
+	mkdirSync(join(cacheRoot, CHROME_NAME, CHROME_VERSION), { recursive: true });
+	const partial = `${dest}.${process.pid}.partial`;
+	rmSync(partial, {
+		recursive: true,
+		force: true
+	});
+	try {
+		extractBinary(await downloadZip(chromeUrl(platform), options.onProgress, options.cacheLabel, options.signal), partial, platform);
+		try {
+			renameSync(partial, dest);
+		} catch (error) {
+			rmSync(partial, {
+				recursive: true,
+				force: true
+			});
+			if (!existsSync(bin)) throw error;
+		}
+	} catch (error) {
+		rmSync(partial, {
+			recursive: true,
+			force: true
+		});
+		if (existsSync(bin)) return bin;
+		throw error;
+	}
+	return bin;
+}
+var Cdp = class {
+	#ws;
+	#next = 0;
+	#pending = /* @__PURE__ */ new Map();
+	#events = /* @__PURE__ */ new Map();
+	constructor(ws) {
+		this.#ws = ws;
+		ws.addEventListener("message", (ev) => {
+			const msg = JSON.parse(String(ev.data));
+			if (msg.id !== void 0) {
+				const p = this.#pending.get(msg.id);
+				if (!p) return;
+				this.#pending.delete(msg.id);
+				if (msg.error) p.reject(new Error(msg.error.message));
+				else p.resolve(msg.result);
+				return;
+			}
+			if (msg.method) for (const fn of this.#events.get(msg.method) ?? []) fn(msg);
+		});
+	}
+	on(method, fn) {
+		const list = this.#events.get(method) ?? [];
+		list.push(fn);
+		this.#events.set(method, list);
+	}
+	send(method, params) {
+		const id = ++this.#next;
+		this.#ws.send(JSON.stringify({
+			id,
+			method,
+			params
+		}));
+		return new Promise((resolve, reject) => this.#pending.set(id, {
+			resolve,
+			reject
+		}));
+	}
+	close() {
+		this.#ws.close();
+	}
+};
+function waitForPortFile(file, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	return new Promise((resolve, reject) => {
+		const tick = () => {
+			if (existsSync(file)) {
+				const line = readFileSync(file, "utf8").split(/\r?\n/)[0];
+				const port = Number(line);
+				if (port > 0) {
+					resolve(port);
+					return;
+				}
+			}
+			if (Date.now() > deadline) {
+				reject(/* @__PURE__ */ new Error("chrome-headless-shell did not open a DevTools port"));
+				return;
+			}
+			setTimeout(tick, 50);
+		};
+		tick();
+	});
+}
+function pickPageDebuggerUrl(targets) {
+	return targets.find((t) => t.webSocketDebuggerUrl && t.type !== "browser")?.webSocketDebuggerUrl;
+}
+async function pageDebuggerUrl(port, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	const listPages = async () => {
+		const res = await fetch(`http://127.0.0.1:${port}/json/list`);
+		if (!res.ok) return void 0;
+		return pickPageDebuggerUrl(await res.json());
+	};
+	for (;;) {
+		const url = await listPages();
+		if (url) return url;
+		if (Date.now() > deadline) break;
+		await new Promise((r) => setTimeout(r, 50));
+	}
+	const version = await (await fetch(`http://127.0.0.1:${port}/json/version`)).json();
+	if (!version.webSocketDebuggerUrl) throw new Error("chrome-headless-shell reported no DevTools URL");
+	const browser = await cdpConnect(version.webSocketDebuggerUrl, timeoutMs);
+	try {
+		await browser.send("Target.createTarget", { url: "about:blank" });
+	} finally {
+		browser.close();
+	}
+	const created = await listPages();
+	if (!created) throw new Error("chrome-headless-shell reported no page target");
+	return created;
+}
+async function cdpConnect(url, timeoutMs) {
+	const ws = new WebSocket(url);
+	await new Promise((resolve, reject) => {
+		const t = setTimeout(() => reject(/* @__PURE__ */ new Error("CDP websocket timed out")), timeoutMs);
+		ws.addEventListener("open", () => {
+			clearTimeout(t);
+			resolve();
+		});
+		ws.addEventListener("error", () => {
+			clearTimeout(t);
+			reject(/* @__PURE__ */ new Error("CDP websocket failed"));
+		});
+	});
+	return new Cdp(ws);
+}
+/**
+* Drops a chrome-headless-shell profile. Chrome can still write after SIGKILL,
+* so `ENOTEMPTY` / `EBUSY` must not replace a PNG already in hand.
+*/
+function removeChromeProfile(dir, rm = rmSync) {
+	try {
+		rm(dir, {
+			recursive: true,
+			force: true,
+			maxRetries: 5,
+			retryDelay: 20
+		});
+	} catch {
+		scheduleChromeProfileSweep(dir, rm);
+	}
+}
+function scheduleChromeProfileSweep(dir, rm) {
+	setTimeout(() => {
+		try {
+			rm(dir, {
+				recursive: true,
+				force: true,
+				maxRetries: 5,
+				retryDelay: 50
+			});
+		} catch {}
+	}, 250).unref();
+}
+function waitForExit(child, timeoutMs) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
+	return new Promise((resolve) => {
+		const finish = () => {
+			clearTimeout(timer);
+			child.off("exit", finish);
+			resolve();
+		};
+		const timer = setTimeout(finish, timeoutMs);
+		child.once("exit", finish);
+	});
+}
+/** Kills the shell and drops its profile. Never throws: the PNG is already in hand. */
+async function disposeChrome(child, userData) {
+	try {
+		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+		await waitForExit(child, 1e3);
+	} catch {}
+	removeChromeProfile(userData);
+}
+/** One Chrome process, one tab. `fn` must not keep the session after it returns. */
+async function withChrome(bin, window, timeoutMs, fn) {
+	const userData = mkdtempSync(join(tmpdir(), `reeval-chrome-${process.pid}-`));
+	const child = spawn(bin, [
+		"--headless",
+		"--disable-gpu",
+		"--no-sandbox",
+		"--disable-dev-shm-usage",
+		"--hide-scrollbars",
+		"--remote-allow-origins=*",
+		`--window-size=${window.width},${window.height}`,
+		`--user-data-dir=${userData}`,
+		"--remote-debugging-port=0",
+		"about:blank"
+	], { stdio: [
+		"ignore",
+		"ignore",
+		"pipe"
+	] });
+	try {
+		const cdp = await cdpConnect(await pageDebuggerUrl(await waitForPortFile(join(userData, "DevToolsActivePort"), timeoutMs), timeoutMs), timeoutMs);
+		try {
+			await cdp.send("Page.enable");
+			await cdp.send("Page.setLifecycleEventsEnabled", { enabled: true });
+			await cdp.send("Emulation.setDeviceMetricsOverride", {
+				width: window.width,
+				height: window.height,
+				deviceScaleFactor: 1,
+				mobile: false
+			});
+			let scrollY = 0;
+			return await fn({
+				cdp,
+				window,
+				async navigate(url) {
+					scrollY = 0;
+					const nav = await cdp.send("Page.navigate", { url });
+					if (nav?.errorText) throw new Error(`c.capture() navigation failed: ${nav.errorText}`);
+					return nav;
+				},
+				wait(wait, waitMs, nav) {
+					return waitForPage(cdp, wait, waitMs, nav);
+				},
+				async screenshot(fullPage) {
+					const shot = await cdp.send("Page.captureScreenshot", {
+						format: "png",
+						captureBeyondViewport: fullPage
+					});
+					if (!shot.data) throw new Error("Page.captureScreenshot returned no data");
+					return Buffer.from(shot.data, "base64");
+				},
+				async dispatch(action, page) {
+					scrollY = await dispatchInput(cdp, action, window, page, scrollY);
+				}
+			});
+		} finally {
+			cdp.close();
+		}
+	} finally {
+		await disposeChrome(child, userData);
+	}
+}
+/** Arm the wait, then navigate, then wait. `arm` is before `Page.navigate`. */
+async function navigateAndWait(session, url, wait, timeoutMs) {
+	if (isMs(wait)) {
+		const nav = await session.navigate(url);
+		await session.wait(wait, timeoutMs, nav);
+		return;
+	}
+	const page = listenForCaptureWait(session.cdp, wait);
+	page.arm();
+	const nav = await session.navigate(url);
+	await page.ready(nav, timeoutMs);
+}
+//#endregion
+//#region src/capture/poll.ts
+/** Any HTTP response, including 404, means something accepted the connection. */
+async function pollHttp(url, timeoutMs, signal) {
+	const deadline = Date.now() + timeoutMs;
+	let last;
+	while (Date.now() < deadline) {
+		signal?.throwIfAborted();
+		const left = Math.max(1, deadline - Date.now());
+		try {
+			await fetch(url, { signal: AbortSignal.any([AbortSignal.timeout(Math.min(1e3, left)), ...signal ? [signal] : []]) });
+			return;
+		} catch (error) {
+			last = error;
+			if (signal?.aborted) throw error;
+			await new Promise((r) => setTimeout(r, 100));
+		}
+	}
+	throw last instanceof Error ? last : /* @__PURE__ */ new Error("poll timed out");
+}
+//#endregion
+//#region src/capture/stub.ts
+const PNG_SIG = Buffer.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function chunk(type, data) {
+	const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+	const out = Buffer.alloc(12 + data.length);
+	out.writeUInt32BE(data.length, 0);
+	body.copy(out, 4);
+	out.writeUInt32BE(crc32(body), 8 + data.length);
+	return out;
+}
+/** A valid 1×1 PNG whose bytes are unique for `(name, port, path, viewport)`. */
+function stubPng(name, port, path, viewport) {
+	const digest = createHash("sha256").update(`${name}\0${port}\0${path}\0${viewport === "full-page" ? "full-page" : `${viewport.width}x${viewport.height}`}`).digest();
+	const ihdr = Buffer.alloc(13);
+	ihdr.writeUInt32BE(1, 0);
+	ihdr.writeUInt32BE(1, 4);
+	ihdr[8] = 8;
+	ihdr[9] = 2;
+	const scanline = Buffer.from([
+		0,
+		digest[0] ?? 0,
+		digest[1] ?? 0,
+		digest[2] ?? 0
+	]);
+	const idat = deflateSync(scanline);
+	const text = Buffer.concat([Buffer.from("Comment\0", "ascii"), Buffer.from(digest.toString("hex"), "ascii")]);
+	return Buffer.concat([
+		PNG_SIG,
+		chunk("IHDR", ihdr),
+		chunk("tEXt", text),
+		chunk("IDAT", idat),
+		chunk("IEND", Buffer.alloc(0))
+	]);
+}
+/** PNG IHDR width and height; throws if the bytes are not a PNG. */
+function pngSize(bytes) {
+	if (bytes.length < 24 || Buffer.from(bytes.subarray(0, 8)).compare(PNG_SIG) !== 0) throw new Error("not a PNG");
+	const view = Buffer.from(bytes.subarray(16, 24));
+	return {
+		width: view.readUInt32BE(0),
+		height: view.readUInt32BE(4)
+	};
+}
+//#endregion
+//#region src/capture/index.ts
+/** Default CSS pixels when the call and cascade omit `viewport`. */
+const DEFAULT_VIEWPORT = {
+	width: 1280,
+	height: 720
+};
+const CAPTURE_NAME = /^[a-z0-9_-]+$/;
+const CAPTURE_WAITS = ["load", "idle"];
+/** `'load'` when the call omits `wait`. `'load'`, `'idle'` or `{ ms }`. */
+function resolveWait(wait) {
+	if (wait === void 0) return "load";
+	if (CAPTURE_WAITS.includes(wait)) return wait;
+	if (typeof wait === "object" && wait !== null && Number.isFinite(wait.ms) && wait.ms >= 0 && Object.keys(wait).every((k) => k === "ms")) return { ms: wait.ms };
+	throw new Error(`c.capture() wait is 'load', 'idle' or { ms } (got ${JSON.stringify(wait)})`);
+}
+function parseInstructions(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`c.capture() instructions is an array of strings and { wait } (got ${JSON.stringify(value)})`);
+	return value.map((step, i) => {
+		if (typeof step === "string") {
+			if (!step.trim()) throw new Error(`c.capture() instructions[${i}] is an empty string`);
+			return step;
+		}
+		if (typeof step === "object" && step !== null && "wait" in step) return { wait: resolveWait(step.wait) };
+		throw new Error(`c.capture() instructions[${i}] is a string or { wait } (got ${JSON.stringify(step)})`);
+	});
+}
+function instructionGoals(steps) {
+	return steps.filter((s) => typeof s === "string");
+}
+/** Live window and whether the saved PNG uses `captureBeyondViewport`. */
+function resolveCaptureViewport(viewport) {
+	const asked = viewport ?? DEFAULT_VIEWPORT;
+	if (asked === "full-page") return {
+		viewport: "full-page",
+		window: DEFAULT_VIEWPORT,
+		fullPage: true
+	};
+	return {
+		viewport: asked,
+		window: asked,
+		fullPage: false
+	};
+}
+/** `~/.cache/reeval` when that's the resolved dir; otherwise the absolute path. */
+function cacheLabel(dir = cacheDir()) {
+	const home = homedir();
+	if (dir.replaceAll("\\", "/") === join(home, ".cache", "reeval").replaceAll("\\", "/")) return "~/.cache/reeval";
+	return dir;
+}
+/**
+* Env is named first when both refuse. `undefined` means the host binary is allowed.
+*/
+function refusedBrowser(capture) {
+	if (process.env.REEVAL_CAPTURE_BROWSER === "0") return "c.capture() is refused: REEVAL_CAPTURE_BROWSER=0";
+	if (capture.browser === false) return "c.capture() is refused: capture.browser is false";
+}
+function resolveCaptureTarget(target) {
+	if (typeof target === "number") {
+		if (!(Number.isInteger(target) && target >= 1 && target <= 65535)) throw new Error(`c.capture() port is a container port from 1 to 65535 (got ${String(target)})`);
+		return target;
+	}
+	if (target !== null && typeof target === "object" && typeof target.port === "number" && typeof target.kill === "function") return resolveCaptureTarget(target.port);
+	throw new Error("c.capture() needs a port or a ServeHandle as the first argument");
+}
+/** Artifact name from a path: `/login` → `login`, `/foo/bar` → `foo-bar`, `/` → `root`. */
+function nameFromPath(path) {
+	return (path.split(/[?#]/, 1)[0] ?? "").replaceAll("\\", "/").split("/").filter(Boolean).join("-").toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "root";
+}
+function resolveCaptureCall(target, call, cascade) {
+	if (call && Object.hasOwn(call, "port")) throw new Error("c.capture() takes the port as the first argument, not in the options");
+	if (call && Object.hasOwn(call, "use")) throw new Error("c.capture() has no use. Set model, or pass fakeInstructions from reeval/testing as instructions.");
+	if (call && Object.hasOwn(call, "fake")) throw new Error("c.capture() has no fake. Tests pass fakeInstructions(...) as instructions.");
+	if (call?.model !== void 0) checkCallModel(call.model);
+	const port = resolveCaptureTarget(target);
+	const path = call?.path || "/";
+	const name = call?.name ?? nameFromPath(path);
+	checkCaptureName(name);
+	const asked = resolveCaptureViewport(call?.viewport ?? cascade.viewport);
+	return {
+		port,
+		name,
+		path,
+		viewport: asked.viewport,
+		window: asked.window,
+		fullPage: asked.fullPage,
+		timeoutMs: parseDuration(call?.timeout ?? cascade.timeout ?? "60s"),
+		wait: resolveWait(call?.wait),
+		instructions: parseInstructions(call?.instructions),
+		model: call?.model ?? cascade.model,
+		fake: fakeScriptFrom(call?.instructions)
+	};
+}
+function fakeScriptFrom(value) {
+	const steps = fakeInstructionSteps(value);
+	if (!steps) return void 0;
+	const script = [];
+	for (const step of steps) {
+		if (isWaitStep(step)) continue;
+		script.push(step);
+	}
+	return script;
+}
+function checkCallModel(model) {
+	if (!model.includes("/")) throw new Error(`c.capture() model is a 'provider/model' string, e.g. 'google/gemini-3.8-flash' (got ${JSON.stringify(model)})`);
+	if (model.startsWith("typesafe-ai/")) throw new Error(`c.capture() model "${model}" is an evaluation model: it scores yes/no questions and can't drive a capture. Use a language model that accepts images, e.g. 'google/gemini-3.8-flash'.`);
+}
+function checkCaptureName(name) {
+	if (!CAPTURE_NAME.test(name)) throw new Error(`c.capture() name must match [a-z0-9_-]+ (got ${JSON.stringify(name)})`);
+}
+/** A free host port. Closed before the promise resolves, so the caller can bind it. */
+function allocatePort() {
+	return new Promise((resolve, reject) => {
+		const server = createServer();
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const addr = server.address();
+			const port = typeof addr === "object" && addr ? addr.port : 0;
+			server.close((error) => error ? reject(error) : resolve(port));
+		});
+	});
+}
+/** Origin plus a path (`/login`), without a doubled slash. */
+function pageUrl(origin, path) {
+	const base = origin.endsWith("/") ? origin : `${origin}/`;
+	const rel = path.startsWith("/") ? path.slice(1) : path;
+	return new URL(rel, base).href;
+}
+/** Internal settle between moves; not an authored wait. */
+const SETTLE_MS = 80;
+function remainingOrThrow(remaining, detail) {
+	const left = remaining();
+	if (left <= 0) throw new Error(`c.capture() timed out on ${detail}`);
+	return left;
+}
+async function settle() {
+	await new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
+}
+function asUsage(value) {
+	return {
+		input: typeof value.inputTokens === "number" ? value.inputTokens : value.inputTokens?.total ?? 0,
+		output: typeof value.outputTokens === "number" ? value.outputTokens : value.outputTokens?.total ?? 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		reasoning: null
+	};
+}
+function actionFromTool(name, input) {
+	if (name === "done") return { type: "done" };
+	if (name === "type") return {
+		type: "type",
+		text: String(input.text ?? "")
+	};
+	if (name === "key") return {
+		type: "key",
+		key: input.key === "Tab" ? "Tab" : "Enter"
+	};
+	if (name === "scroll") return {
+		type: "scroll",
+		x: Number(input.x),
+		y: Number(input.y),
+		dy: Number(input.dy)
+	};
+	if (name === "drag") return {
+		type: "drag",
+		x: Number(input.x),
+		y: Number(input.y),
+		toX: Number(input.toX),
+		toY: Number(input.toY)
+	};
+	if (name === "hover") return {
+		type: "hover",
+		x: Number(input.x),
+		y: Number(input.y)
+	};
+	return {
+		type: "click",
+		x: Number(input.x),
+		y: Number(input.y)
+	};
+}
+const useTools = {
+	click: tool({
+		description: "Click at CSS pixels on the screenshot.",
+		inputSchema: z.object({
+			x: z.number(),
+			y: z.number()
+		})
+	}),
+	type: tool({
+		description: "Insert text into the focused field. Click the field first.",
+		inputSchema: z.object({ text: z.string() })
+	}),
+	key: tool({
+		description: "Press Tab or Enter.",
+		inputSchema: z.object({ key: z.enum(["Tab", "Enter"]) })
+	}),
+	scroll: tool({
+		description: "Wheel-scroll a constrained scroller at (x, y).",
+		inputSchema: z.object({
+			x: z.number(),
+			y: z.number(),
+			dy: z.number()
+		})
+	}),
+	drag: tool({
+		description: "Drag from (x, y) to (toX, toY).",
+		inputSchema: z.object({
+			x: z.number(),
+			y: z.number(),
+			toX: z.number(),
+			toY: z.number()
+		})
+	}),
+	hover: tool({
+		description: "Move the pointer to (x, y).",
+		inputSchema: z.object({
+			x: z.number(),
+			y: z.number()
+		})
+	}),
+	done: tool({
+		description: "The goal is finished. Leave the loop.",
+		inputSchema: z.object({})
+	})
+};
+async function runFakeScript(session, script, goal, remaining) {
+	let moves = 0;
+	for (const action of script) {
+		remainingOrThrow(remaining, JSON.stringify(goal));
+		if (action.type === "done") return moves;
+		if (moves >= 32) throw new Error(`c.capture() instruction ${JSON.stringify(goal)} did not finish in 32 moves`);
+		const page = pngSize(await session.screenshot(true));
+		debugTrace("check", "capture-use", {
+			goal,
+			action,
+			page
+		}, `capture use ${action.type}`);
+		await session.dispatch(action, page);
+		moves++;
+		await settle();
+	}
+	while (remaining() > 0) await settle();
+	throw new Error(`c.capture() timed out on ${JSON.stringify(goal)}`);
+}
+async function runModelGoal(session, goal, modelName, remaining, loadModel) {
+	const model = await loadModel(modelName);
+	let moves = 0;
+	let usage = null;
+	while (moves < 32) {
+		remainingOrThrow(remaining, JSON.stringify(goal));
+		const ephemeral = await session.screenshot(true);
+		const page = pngSize(ephemeral);
+		debugTrace("check", "capture-shot", {
+			goal,
+			bytes: ephemeral.length,
+			page
+		}, false);
+		let chosen;
+		const result = await generateText({
+			model,
+			system: "You drive a web page from screenshots. Call one tool. Coordinates are CSS pixels on the full-page image. Call done when the goal is met. Do not mention CDP.",
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: goal
+				}, {
+					type: "image",
+					image: ephemeral
+				}]
+			}],
+			tools: useTools,
+			toolChoice: "required",
+			stopWhen: stepCountIs(1),
+			abortSignal: AbortSignal.timeout(remainingOrThrow(remaining, JSON.stringify(goal)))
+		});
+		usage = addUsage(usage, asUsage(result.usage ?? {}));
+		const call = result.toolCalls?.[0];
+		if (call) chosen = actionFromTool(call.toolName, call.input ?? {});
+		if (!chosen) throw new Error(`c.capture() instruction ${JSON.stringify(goal)} returned no action`);
+		debugLog("check", `capture use ${chosen.type} on ${JSON.stringify(goal)}`);
+		debugTrace("check", "capture-use", {
+			goal,
+			action: chosen,
+			page
+		}, `capture use ${chosen.type}`);
+		if (chosen.type === "done") return {
+			moves,
+			usage
+		};
+		await session.dispatch(chosen, page);
+		moves++;
+		await settle();
+	}
+	throw new Error(`c.capture() instruction ${JSON.stringify(goal)} did not finish in 32 moves`);
+}
+/**
+* Top-level wait, then the instruction loop, then the saved PNG.
+* Throws before `screenshot` when the budget or move cap is hit.
+*/
+async function runJourney(session, url, options) {
+	const { wait, timeoutMs, fullPage, instructions, use, remaining } = options;
+	remainingOrThrow(remaining, "navigate");
+	await navigateAndWait(session, url, wait, Math.min(timeoutMs, remaining()));
+	let moves = 0;
+	let usage = null;
+	let stringIndex = 0;
+	for (const step of instructions) {
+		if (typeof step !== "string") {
+			remainingOrThrow(remaining, "wait");
+			await session.wait(step.wait, remaining(), void 0);
+			continue;
+		}
+		remainingOrThrow(remaining, JSON.stringify(step));
+		debugLog("check", `capture instruction ${JSON.stringify(step)}`);
+		if (use && "fake" in use) {
+			const script = use.fake[stringIndex] ?? [];
+			moves += await runFakeScript(session, script, step, remaining);
+		} else if (use && "model" in use) {
+			if (!options.loadModel) throw new Error("c.capture() instructions need a model loader");
+			const ran = await runModelGoal(session, step, use.model, remaining, options.loadModel);
+			moves += ran.moves;
+			usage = addUsage(usage, ran.usage);
+		}
+		stringIndex++;
+		await settle();
+	}
+	remainingOrThrow(remaining, "screenshot");
+	return {
+		png: await session.screenshot(fullPage),
+		moves,
+		model: use && "model" in use ? use.model : use && "fake" in use ? "fake" : void 0,
+		usage
+	};
+}
+function captureUseSpend(result) {
+	if (!result.model) return void 0;
+	return {
+		model: result.model,
+		moves: result.moves,
+		usage: result.usage
+	};
+}
+//#endregion
+//#region src/diff.ts
+const GIT = "git -c user.name=reeval -c user.email=reeval@localhost -c core.hooksPath=/dev/null";
+const SNAPSHOT_ENV = "export GIT_DIR=\"$PWD/../.reeval-git-$(basename \"$PWD\")\" GIT_WORK_TREE=\"$PWD\"";
+/** Records the workspace state before the agent runs, in a git dir outside the workspace. */
+async function snapshot(sandbox, signal) {
+	const r = await sandbox.exec(`${SNAPSHOT_ENV} && ${GIT} init -q && ${GIT} add -A && ${GIT} commit -q --allow-empty -m base`, { signal });
+	if (r.exitCode !== 0) throw new InfraError(`Failed to snapshot the workspace: ${r.stderr.trim()}`);
+}
+/**
+* Moves the snapshot forward for one workspace file as it is now, so later diffs show only
+* changes made to it after this. Only that path is committed: the other changes stay in the
+* diff. `-f` tracks a file the workspace's `.gitignore` covers, so a later edit to it shows too.
+*/
+async function acceptIntoSnapshot(sandbox, path, signal) {
+	const quoted = shellQuote(path);
+	const r = await sandbox.exec(`${SNAPSHOT_ENV} && export GIT_LITERAL_PATHSPECS=1 && ${GIT} add -f -- ${quoted} && ${GIT} commit -q --allow-empty --no-verify -m ${shellQuote(`place ${path}`)} --only -- ${quoted}`, { signal });
+	if (r.exitCode !== 0) throw new InfraError(`Failed to keep ${path} out of the diff: ${r.stderr.trim()}`);
+}
+async function diffSinceSnapshot(sandbox, signal) {
+	const env = `${SNAPSHOT_ENV} && ${GIT} add -A && `;
+	const patch = await sandbox.exec(`${env}${GIT} diff --cached --binary HEAD`, { signal });
+	const names = await sandbox.exec(`${env}${GIT} diff --cached --name-status --no-renames HEAD`, { signal });
+	if (patch.exitCode !== 0 || names.exitCode !== 0) throw new InfraError(`Failed to diff the workspace: ${patch.stderr || names.stderr}`);
+	const status = {
+		A: "added",
+		M: "modified",
+		D: "deleted"
+	};
+	const files = names.stdout.split("\n").filter(Boolean).map((line) => {
+		const [code = "M", ...rest] = line.split("	");
+		return {
+			path: rest.join("	"),
+			status: status[code[0]] ?? "modified"
+		};
+	});
+	return {
+		patch: patch.stdout,
+		files
+	};
+}
+//#endregion
+//#region src/attempt/checks.ts
+/** Runs a check or setup step with the checks' brokered secrets swapped in (see brokerPhases). */
+const asCheck = (a, fn) => a.phases ? a.phases.checks(fn) : fn();
+function requireSandbox(a, who = "c.exec() or c.readFile()") {
+	if (!a.sandbox) throw new Error(`No sandbox yet: call c.send() or await c.sandbox() before ${who}`);
+	return a.sandbox;
+}
+/**
+* `c.exec` runs with the checks' variables and secrets, each run recorded and
+* timed; `c.readFile` reads the sandbox as is; `c.writeFile` places a file the diff leaves out.
+*/
+function createChecks(a) {
+	const checkEnv = () => a.env?.checkVars ?? {};
+	const execForeground = async (command) => {
+		const box = requireSandbox(a);
+		const start = performance.now();
+		a.report({
+			kind: "check-start",
+			command
+		});
+		const r = await a.timed("checksMs", () => asCheck(a, () => box.exec(command, {
+			signal: a.signal,
+			env: checkEnv()
+		})));
+		const durationMs = Math.round(performance.now() - start);
+		a.record.checks.push({
+			command,
+			...r,
+			durationMs
+		});
+		debugLog("check", `$ ${clip(command, 160)} → exit ${r.exitCode} · ${formatDuration(durationMs)}`);
+		debugTrace("check", "output", {
+			command,
+			...r,
+			durationMs
+		}, `check output: ${clip(command, 80)}`);
+		a.report({
+			kind: "check-end",
+			command,
+			exitCode: r.exitCode,
+			ms: durationMs
+		});
+		return r;
+	};
+	function exec(command, options) {
+		if (options?.background) return import("./capture-DS-cPyuE.js").then(({ startBackground }) => startBackground(a, command));
+		return Object.defineProperty(execForeground(command), SUBJECT, { value: command });
+	}
+	const readFile = (path) => requireSandbox(a).readFile(path);
+	const writeFile = async (path, contents) => {
+		const box = requireSandbox(a, "c.writeFile()");
+		const home = path.startsWith("~/");
+		const normal = posix.normalize((home ? path.slice(2) : path).replaceAll("\\", "/"));
+		if (normal === "." || /^([a-zA-Z]:)?\//.test(normal) || /^\.\.(\/|$)/.test(normal)) throw new Error(`c.writeFile() takes a workspace-relative path or ~/…, not ${JSON.stringify(path)}`);
+		a.signal.throwIfAborted();
+		await box.writeFile(home ? `~/${normal}` : normal, contents);
+		if (!home) await acceptIntoSnapshot(box, normal, a.signal);
+		const bytes = typeof contents === "string" ? Buffer.byteLength(contents) : contents.byteLength;
+		debugLog("check", `wrote ${path} (${bytes} bytes)${home ? "" : ", kept out of the diff until something changes it"}`);
+	};
+	return {
+		exec,
+		readFile,
+		writeFile
+	};
+}
+//#endregion
+//#region src/attempt/capture.ts
+const BG_LOG = "/tmp/reeval-bg.log";
+const isEvaluationModel = (model) => model.startsWith("typesafe-ai/");
+function defaultCaptureModel() {
+	try {
+		const { config } = getRunContext();
+		const analysis = config.analysis.model;
+		if (typeof analysis === "string" && !isEvaluationModel(analysis)) return analysis;
+		const judge = config.judge.model;
+		if (typeof judge === "string" && !isEvaluationModel(judge)) return judge;
+	} catch {
+		return;
+	}
+}
+function resolveUse(resolved, fakeSandbox) {
+	if (resolved.fake) return { fake: resolved.fake };
+	if (resolved.model) return { model: resolved.model };
+	if (!resolved.instructions.length) return void 0;
+	const fallback = defaultCaptureModel();
+	if (fallback) return { model: fallback };
+	if (fakeSandbox) return void 0;
+	throw new Error("c.capture() instructions need a vision model. Set capture.model, pass model on the call, or analysis.model to a language model that accepts images. Tests pass fakeInstructions from reeval/testing.");
+}
+/** Starts `command` without waiting for exit. Teardown kills it if the eval didn't. */
+async function startBackground(a, command, extraEnv = {}) {
+	const box = requireSandbox(a);
+	const wrapped = `${command} >${BG_LOG} 2>&1 & echo $!`;
+	const r = await asCheck(a, () => box.exec(wrapped, {
+		signal: a.signal,
+		env: {
+			...a.env?.checkVars ?? {},
+			...extraEnv
+		}
+	}));
+	const pid = r.stdout.trim().split(/\s+/).at(-1) ?? "";
+	if (!/^\d+$/.test(pid)) throw new Error(`c.exec({ background: true }) did not start (no pid):\n${(r.stderr || r.stdout).trim()}`);
+	let killed = false;
+	const handle = { async kill() {
+		if (killed) return;
+		killed = true;
+		const win = a.spec.sandbox.kind === "fake" && process.platform === "win32" ? `; wp=$(tr -d '\\r\\n' < /proc/${pid}/winpid 2>/dev/null) && taskkill /F /PID "$wp" >/dev/null 2>&1 || true` : "";
+		await box.exec(`kill -9 ${pid} 2>/dev/null || true${win}`).catch(() => {});
+	} };
+	a.backgrounds.push(handle);
+	return handle;
+}
+async function serveCommand(a, command, port) {
+	const bound = port ?? await allocatePort();
+	return {
+		...await startBackground(a, command, { PORT: String(bound) }),
+		port: bound
+	};
+}
+async function capturePage(a, target, call) {
+	const refused = refusedBrowser(a.spec.capture);
+	if (refused) throw new Error(refused);
+	const resolved = resolveCaptureCall(target, call, a.spec.capture);
+	if (a.captureNames.has(resolved.name)) throw new Error(`c.capture() reused the name "${resolved.name}"`);
+	const box = requireSandbox(a, "c.capture()");
+	if (!box.getPortEndpoint) throw new Error("c.capture() needs a sandbox that can tunnel a port");
+	const { url: origin } = await box.getPortEndpoint({
+		port: resolved.port,
+		protocol: "http"
+	});
+	try {
+		await pollHttp(pageUrl(origin, "/"), resolved.timeoutMs, a.signal);
+	} catch {
+		throw new Error(`nothing listening on port ${resolved.port}`);
+	}
+	const fake = a.spec.sandbox.kind === "fake";
+	const use = resolveUse(resolved, fake);
+	a.captureNames.add(resolved.name);
+	const started = Date.now();
+	const remaining = () => Math.max(0, resolved.timeoutMs - (Date.now() - started));
+	let moves = 0;
+	const png = fake ? stubPng(resolved.name, resolved.port, resolved.path, resolved.viewport) : await shot(a, pageUrl(origin, resolved.path), {
+		...resolved,
+		use
+	}, remaining, (n) => {
+		moves = n;
+	});
+	const digest = sha256(png);
+	const file = {
+		path: `artifacts/${resolved.name}.png`,
+		sha256: digest,
+		bytes: png.length
+	};
+	const goals = instructionGoals(resolved.instructions);
+	const capture = {
+		port: resolved.port,
+		path: resolved.path,
+		viewport: resolved.window,
+		...resolved.fullPage ? { fullPage: true } : {},
+		...goals.length ? { instructions: goals } : {},
+		...use ? { use: {
+			model: "model" in use ? use.model : "fake",
+			moves
+		} } : {}
+	};
+	a.record.artifacts = a.record.artifacts ?? [];
+	a.record.artifacts.push({
+		name: resolved.name,
+		mediaType: "image/png",
+		sha256: digest,
+		bytes: png.length,
+		capture
+	});
+	a.artifactBlobs.set(resolved.name, png);
+	return {
+		name: resolved.name,
+		port: resolved.port,
+		path: resolved.path,
+		viewport: resolved.viewport,
+		file
+	};
+}
+async function shot(a, url, resolved, remaining, onMoves) {
+	const cache = cacheDir();
+	return withChrome(await ensureChrome(cache, {
+		cacheLabel: cacheLabel(cache),
+		signal: a.signal,
+		onProgress: (p) => a.report({
+			kind: "browser-download",
+			...p
+		})
+	}), resolved.window, remaining(), async (session) => {
+		const result = await runJourney(session, url, {
+			wait: resolved.wait,
+			timeoutMs: remaining(),
+			fullPage: resolved.fullPage,
+			instructions: resolved.instructions,
+			use: resolved.use,
+			remaining,
+			loadModel: async (name) => {
+				const route = judgeRoute(name);
+				return providerModel({
+					name,
+					route: route.kind === "direct" ? "direct" : "gateway"
+				});
+			}
+		});
+		onMoves(result.moves);
+		const spend = captureUseSpend(result);
+		if (spend) {
+			const prev = a.record.captureUse;
+			a.record.captureUse = prev ? {
+				model: spend.model,
+				moves: prev.moves + spend.moves,
+				usage: addUsage(prev.usage, spend.usage)
+			} : spend;
+		}
+		return result.png;
+	});
+}
+/** Writes PNG sidecars next to the staging eval JSON so redact never sees the bytes. */
+async function writeCaptureSidecars(stagingDir, recordFile, blobs) {
+	if (blobs.size === 0) return;
+	const dir = join(stagingDir, "evals", recordFile.replace(/\.json$/, ".artifacts"));
+	await mkdir(dir, { recursive: true });
+	for (const [name, png] of blobs) await writeFile(join(dir, `${name}.png`), png);
+}
+//#endregion
+export { asCheck as a, snapshot as c, writeCaptureSidecars as i, serveCommand as n, createChecks as o, startBackground as r, diffSinceSnapshot as s, capturePage as t };
+
+//# sourceMappingURL=capture-Bp74Z6Fr.js.map