@mostra/verify 0.0.0-placeholder → 0.1.0

package/dist/runner-DCmzgY2w.js

@@ -0,0 +1,964 @@
+import { createRequire } from "node:module";
+import { RpcError, VERIFY_PROBE, createDiagnostic } from "@mostra/protocol";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import pixelmatch from "pixelmatch";
+import { chromium } from "playwright-core";
+import { PNG } from "pngjs";
+//#region src/recorder.ts
+/** The global the recorder keeps its entries on. */
+const RECORDER_GLOBAL = "__mostraVerifyLog";
+/** The recorder, as Playwright installs it in every frame before the page's scripts run. */
+function recorder() {
+	const scope = globalThis;
+	if (scope["__mostraVerifyLog"]) return;
+	const entries = [];
+	let seq = 0;
+	const codesOf = (value) => {
+		const codes = [];
+		let current = value;
+		for (let depth = 0; depth < 8 && current && typeof current === "object"; depth += 1) {
+			if (typeof current.code === "string") codes.push(current.code);
+			current = current.cause;
+		}
+		return codes;
+	};
+	const describe = (value) => {
+		if (value instanceof Error) return value.stack ?? `${value.name}: ${value.message}`;
+		if (typeof value === "string") return value;
+		try {
+			return JSON.stringify(value) ?? String(value);
+		} catch {
+			return String(value);
+		}
+	};
+	const record = (entry) => {
+		if (entries.length < 500) entries.push({
+			seq: ++seq,
+			...entry
+		});
+	};
+	for (const level of ["error", "warn"]) {
+		const original = console[level].bind(console);
+		console[level] = (...args) => {
+			record({
+				kind: level,
+				text: args.map(describe).join(" ").slice(0, 2e3),
+				codes: args.flatMap(codesOf)
+			});
+			original(...args);
+		};
+	}
+	addEventListener("error", (event) => {
+		const error = event.error;
+		record({
+			kind: "uncaught",
+			text: (error === void 0 ? event.message : describe(error)).slice(0, 2e3),
+			codes: codesOf(error)
+		});
+	});
+	addEventListener("unhandledrejection", (event) => {
+		const reason = event.reason;
+		const codes = codesOf(reason);
+		const dropped = codes.includes("MOSTRA_VERIFY_ACTION_SKIPPED");
+		if (dropped) event.preventDefault();
+		record({
+			kind: "rejection",
+			text: describe(reason).slice(0, 2e3),
+			codes,
+			...dropped ? { dropped: true } : {}
+		});
+	});
+	Object.defineProperty(scope, "__mostraVerifyReport", { value: (error) => record({
+		kind: "caught",
+		text: describe(error).slice(0, 2e3),
+		codes: codesOf(error)
+	}) });
+	Object.defineProperty(scope, "__mostraVerifyLog", { value: entries });
+}
+//#endregion
+//#region src/observe.ts
+/**
+* How the runner observes a rendered page: the quiescence wait, the recorder's entries, and the
+* judgement of what the page reported (D72, D138 items 2 and 3).
+*/
+/**
+* Waits until the frame's document has had no mutation for 200 ms, no request is in flight (the
+* page's event stream aside) and the client runtime waits on no server work (calls, runs, first
+* live values: the probe's `pending`, whose answers arrive on the event stream), at most `maxMs`,
+* or `serverMaxMs` while server work is still pending. A quiescence wait, never a fixed sleep: it
+* returns as soon as the page is still (EVAL-01b; Opus review finding 1).
+*/
+async function settle(frame, network, deadline, maxMs = 3e3, serverMaxMs = 1e4) {
+	const start = Date.now();
+	const end = (pending) => Math.min(start + (pending ? Math.max(maxMs, serverMaxMs) : maxMs), deadline);
+	try {
+		await frame.evaluate(() => {
+			const scope = globalThis;
+			if (scope.__mostraQuiet) return;
+			let last = performance.now();
+			new MutationObserver(() => {
+				last = performance.now();
+			}).observe(document, {
+				subtree: true,
+				childList: true,
+				attributes: true,
+				characterData: true
+			});
+			scope.__mostraQuiet = () => performance.now() - last;
+		});
+		for (;;) {
+			const state = await frame.evaluate((probe) => {
+				const scope = globalThis;
+				return {
+					quiet: scope["__mostraQuiet"](),
+					pending: scope[probe]?.pending?.() ?? 0
+				};
+			}, VERIFY_PROBE);
+			if (state.quiet >= 200 && network.inflight() === 0 && state.pending === 0) return true;
+			if (Date.now() >= end(state.pending > 0)) return false;
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+	} catch {}
+	return false;
+}
+/** Folds identical findings into one with a count. */
+function dedupe(findings) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const finding of findings) {
+		const key = `${finding.code}\u0000${finding.message}`;
+		const known = seen.get(key);
+		if (known) seen.set(key, {
+			...known,
+			count: (known.count ?? 1) + (finding.count ?? 1)
+		});
+		else seen.set(key, finding);
+	}
+	return [...seen.values()];
+}
+/** The recorder's entries in a frame from `from` on. */
+async function recorded(frame, from = 0) {
+	try {
+		return await frame.evaluate(([name, start]) => (globalThis[name] ?? []).slice(start), [RECORDER_GLOBAL, from]);
+	} catch {
+		return [];
+	}
+}
+const momentText = (moment) => moment.kind === "load" ? "while the page loaded" : `after the smoke test used ${moment.control}`;
+/**
+* Judges what the page reported in one moment (D138 items 2 and 3): its own faults are errors,
+* console warnings hints; a fault whose `cause` chain is verify's refusal, and any console error
+* in a moment when verify refused an action, is a hint naming the action; a missing secret is
+* the environment's, a warning.
+*/
+function judge(entries, moment, skipped, viewport) {
+	const findings = [];
+	const location = { viewport };
+	for (const entry of entries) {
+		if (entry.dropped) continue;
+		const text = entry.text.split("\n").slice(0, 6).join("\n");
+		const ownSkip = entry.codes.includes("MOSTRA_VERIFY_ACTION_SKIPPED");
+		const action = skipped.length > 0 ? skipped.join(", ") : "an action";
+		const inWindow = moment.kind === "interaction" && entry.kind === "error" && skipped.length > 0;
+		if (ownSkip || inWindow) {
+			findings.push(createDiagnostic("MOSTRA_VERIFY_SKIP_CONSEQUENCE", {
+				message: `After verify skipped ${action} ${momentText(moment)}, the page reported: ${text}`,
+				location
+			}));
+			continue;
+		}
+		if (entry.codes.includes("MOSTRA_SECRET_MISSING")) {
+			findings.push(createDiagnostic("MOSTRA_VERIFY_SECRET_MISSING", {
+				message: `Server code needed a secret ${momentText(moment)}: ${text}`,
+				location
+			}));
+			continue;
+		}
+		if (entry.kind === "warn") findings.push(createDiagnostic("MOSTRA_CONSOLE_WARNING", {
+			message: `The page logged a warning ${momentText(moment)}: ${text}`,
+			location
+		}));
+		else if (entry.kind === "error") findings.push(createDiagnostic("MOSTRA_CONSOLE_ERROR", {
+			message: `The page logged an error ${momentText(moment)}: ${text}`,
+			location
+		}));
+		else findings.push(createDiagnostic("MOSTRA_RUNTIME_PAGE_ERROR", {
+			message: `${entry.kind === "rejection" ? "A promise rejected with nothing to handle it" : entry.kind === "caught" ? "An error boundary caught an error" : "An error was thrown and nothing caught it"} ${momentText(moment)}: ${text}`,
+			location
+		}));
+	}
+	return findings;
+}
+//#endregion
+//#region src/network.ts
+/**
+* What a verify render's page does on the network (D138 item 3): requests in flight (for the
+* quiescence wait), failed requests for resources the artifact's frame loaded, the sandbox's
+* refusals of actions that didn't opt into `dryRun()`, and the field writes the page made.
+*
+* A failed request counts when the artifact's frame loaded it: its document, scripts, styles,
+* images, fonts and fetches. Requests the browser makes on its own (`/favicon.ico`) and Mostra's
+* protocol (`/_mostra/…`, whose answers the client runtime handles) don't. Chrome's own
+* "Failed to load resource" console line is never counted: the request's finding stands for it.
+*/
+/** Whether a request is the page's event stream, which stays open. */
+const isStream = (url) => /\/_mostra\/v\/[^/]+\/events(\/poll)?$/.test(url.pathname);
+/** Watches a page's network; `frame` finds the artifact's frame. */
+function watchNetwork(page, frame, viewport) {
+	const open = /* @__PURE__ */ new Set();
+	/** Events in order: skips, writes and protocol requests, each at its position. */
+	const log = [];
+	const failures = /* @__PURE__ */ new Map();
+	/** Protocol answers still being read: they count as in flight until their body is in. */
+	let reading = 0;
+	const fromArtifact = (request) => {
+		try {
+			const own = frame();
+			return own !== void 0 && request.frame() === own;
+		} catch {
+			return false;
+		}
+	};
+	const counted = (url, artifactOrigin) => {
+		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+		if (url.origin === artifactOrigin && url.pathname.startsWith("/_mostra/")) return false;
+		return url.pathname !== "/favicon.ico";
+	};
+	const fail = (request, why) => {
+		if (!fromArtifact(request)) return;
+		const url = new URL(request.url());
+		let artifactOrigin;
+		try {
+			artifactOrigin = new URL(frame()?.url() ?? "").origin;
+		} catch {
+			artifactOrigin = void 0;
+		}
+		if (!counted(url, artifactOrigin)) return;
+		const own = url.origin === artifactOrigin;
+		const shown = own ? url.pathname : `${url.origin}${url.pathname}`;
+		const key = `${request.method()} ${shown} ${why}`;
+		const known = failures.get(key);
+		if (known) {
+			failures.set(key, {
+				...known,
+				count: (known.count ?? 1) + 1
+			});
+			return;
+		}
+		failures.set(key, createDiagnostic(own ? "MOSTRA_NETWORK_REQUEST_FAILED" : "MOSTRA_NETWORK_EXTERNAL_FAILED", {
+			message: `${request.resourceType()} ${request.method()} ${shown} ${why}.`,
+			location: { viewport }
+		}));
+	};
+	page.on("request", (request) => {
+		const url = new URL(request.url());
+		if (isStream(url)) return;
+		open.add(request);
+		if (fromArtifact(request) && !url.pathname.startsWith("/_mostra/")) log.push({ kind: "request" });
+	});
+	const done = (request) => {
+		open.delete(request);
+	};
+	page.on("requestfinished", done);
+	page.on("requestfailed", (request) => {
+		done(request);
+		const text = request.failure()?.errorText ?? "failed";
+		if (/ERR_ABORTED|NS_BINDING_ABORTED|cancelled/i.test(text)) return;
+		fail(request, `failed (${text})`);
+	});
+	page.on("response", (response) => {
+		const request = response.request();
+		const url = new URL(request.url());
+		const status = response.status();
+		if (url.pathname.includes("/_mostra/v/")) {
+			reading += 1;
+			onProtocol(request, url, response).finally(() => {
+				reading -= 1;
+			});
+			return;
+		}
+		if (status >= 400) fail(request, `answered ${status}`);
+	});
+	const onProtocol = async (request, url, response) => {
+		if (request.method() !== "POST" || isStream(url)) return;
+		const route = /\/_mostra\/v\/[^/]+\/(fields|call\/.+|runs|signal|submit)$/.exec(url.pathname)?.[1];
+		if (!route) return;
+		log.push({ kind: "protocol" });
+		if (route === "fields" && response.ok()) {
+			const body = await response.json().catch(() => ({}));
+			log.push({
+				kind: "write",
+				ops: Array.isArray(body.applied) ? body.applied.length : 1
+			});
+			return;
+		}
+		if (response.status() !== 409 || !(route === "runs" || route.startsWith("call/"))) return;
+		if ((await response.json().catch(() => ({}))).code !== "MOSTRA_VERIFY_ACTION_SKIPPED") return;
+		const fn = route.startsWith("call/") ? decodeURIComponent(route.slice(5)) : String(request.postDataJSON()?.fnId ?? "an action");
+		log.push({
+			kind: "skip",
+			fn
+		});
+	};
+	return {
+		inflight: () => open.size + reading,
+		mark: () => log.length,
+		skippedSince: (from) => [...new Set(log.slice(from).flatMap((entry) => entry.kind === "skip" ? [entry.fn] : []))],
+		writesSince: (from) => log.slice(from).reduce((sum, entry) => sum + (entry.kind === "write" ? entry.ops : 0), 0),
+		requestsSince: (from) => log.slice(from).filter((entry) => entry.kind !== "write").length,
+		findings: () => [...failures.values()]
+	};
+}
+//#endregion
+//#region src/smoke.ts
+/**
+* The smoke test (ROUND-3 §9, D55, D72, D138): uses every enabled control of the rendered page
+* once, within 200 interactions or 60 s, and reports what it observed.
+*
+* - Buttons, tabs, menus and other triggers are clicked; tooltip and hover-card triggers hovered;
+*   context-menu triggers right-clicked. Disabled controls and already-active ones (the selected
+*   tab, the current page) are left alone, as EVAL-01's calibration showed they rightly do nothing.
+* - Inputs, text areas, selects, checkboxes and radios are filled or toggled with values that fit
+*   their type, then blurred so the page saves; one whose value saves nothing is unbound (a hint).
+* - Links to other origins, `mailto:`, downloads and links that open a new tab aren't followed.
+* - A control with no observable effect (no change to the page, no request, no saved field, no
+*   navigation) is a warning that says what was observed, never an error (D72).
+* - Actions that didn't opt into `dryRun()` are refused by the sandbox; faults that follow from
+*   the refusal are attributed to it (see `judge`).
+*/
+const MARK = "data-mostra-smoke";
+/** How many levels of revealed controls the smoke test follows: a dialog, then its menu. */
+const REVEAL_DEPTH = 2;
+/**
+* Finds the page's controls not marked yet and marks each with its index, numbering from `start`
+* (runs in the frame): the page's controls at first, then those an interaction revealed.
+*/
+function findControls([mark, start]) {
+	const selector = [
+		"button",
+		"[role=button]",
+		"a[href]",
+		"input:not([type=hidden])",
+		"textarea",
+		"select",
+		"summary",
+		"[role=tab]",
+		"[role=checkbox]",
+		"[role=switch]",
+		"[role=radio]",
+		"[role=menuitem]",
+		"[role=combobox]",
+		"[role=option]",
+		"[aria-haspopup]",
+		"[data-slot$=\"-trigger\"]",
+		"[contenteditable=\"true\"]",
+		"[contenteditable=\"\"]"
+	].join(",");
+	const controls = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const element of document.querySelectorAll(selector)) {
+		if (seen.has(element) || controls.length >= 400 || element.hasAttribute(mark)) continue;
+		seen.add(element);
+		const html = element;
+		const tag = element.tagName.toLowerCase();
+		const type = (element.getAttribute("type") ?? "").toLowerCase();
+		const role = element.getAttribute("role") ?? "";
+		const slot = element.getAttribute("data-slot") ?? "";
+		const name = (element.getAttribute("aria-label") ?? (html.labels?.[0]?.textContent || void 0) ?? element.getAttribute("placeholder") ?? element.getAttribute("title") ?? html.innerText ?? "").trim().replace(/\s+/g, " ").slice(0, 60);
+		let use = "click";
+		if (tag === "a") {
+			const anchor = element;
+			let url;
+			try {
+				url = new URL(anchor.href, location.href);
+			} catch {
+				url = void 0;
+			}
+			if (!url || url.origin !== location.origin || anchor.target === "_blank" || anchor.hasAttribute("download")) use = "skip";
+		} else if (slot === "tooltip-trigger" || slot === "hover-card-trigger") use = "hover";
+		else if (slot === "context-menu-trigger") use = "context";
+		else if (tag === "select") use = "select";
+		else if (tag === "textarea" || html.isContentEditable) use = "fill";
+		else if (tag === "input") {
+			if (type === "checkbox" || type === "radio") use = "toggle";
+			else if ([
+				"submit",
+				"button",
+				"reset",
+				"image"
+			].includes(type)) use = "click";
+			else if (type === "file") use = "skip";
+			else use = "fill";
+		}
+		const index = start + controls.length;
+		element.setAttribute(mark, String(index));
+		controls.push({
+			index,
+			tag,
+			role,
+			type,
+			name,
+			use
+		});
+	}
+	return controls;
+}
+/** Whether a control is disabled or already active, read live (runs in the frame). */
+function stateOf(element) {
+	const disabled = element.disabled === true || element.getAttribute("aria-disabled") === "true" || element.closest("fieldset[disabled]") !== null;
+	const current = element.getAttribute("aria-current");
+	return {
+		disabled,
+		active: element.getAttribute("aria-selected") === "true" || current !== null && current !== "false" || element.getAttribute("data-state") === "active" || element.hasAttribute("data-active") || element.hasAttribute("data-selected")
+	};
+}
+/** The attributes that show a control's state, as one string (runs in the frame). */
+function attributesOf(element) {
+	return [
+		"aria-expanded",
+		"aria-checked",
+		"aria-selected",
+		"aria-pressed",
+		"data-state",
+		"data-checked",
+		"data-open",
+		"data-popup-open",
+		"data-pressed",
+		"data-panel-open",
+		"open"
+	].map((name) => `${name}=${element.getAttribute(name)}`).join("|");
+}
+/** A value that fits an input's type. */
+function valueFor(type) {
+	return {
+		email: "verify@example.com",
+		number: "7",
+		range: "7",
+		date: "2026-01-15",
+		time: "12:30",
+		"datetime-local": "2026-01-15T12:30",
+		month: "2026-01",
+		week: "2026-W03",
+		url: "https://example.com/",
+		tel: "5550100",
+		color: "#336699",
+		password: "verify-pass"
+	}[type] ?? "Verify";
+}
+const describe = (control) => {
+	const kind = control.role || (control.tag === "input" ? `${control.type || "text"} input` : control.tag);
+	return control.name ? `${kind} "${control.name}"` : kind;
+};
+/** Counts the frame document's mutations from now on (runs in the frame). */
+function countMutations() {
+	const scope = globalThis;
+	if (scope.__mostraSmoke) return;
+	const state = { count: 0 };
+	scope.__mostraSmoke = state;
+	new MutationObserver((records) => {
+		state.count += records.length;
+	}).observe(document, {
+		subtree: true,
+		childList: true,
+		attributes: true,
+		characterData: true
+	});
+}
+const mutations = (frame) => frame.evaluate(() => globalThis.__mostraSmoke?.count ?? -1).catch(() => -1);
+/** Runs the smoke test on a rendered page. */
+async function runSmoke(options) {
+	const { page, frame, network, viewport } = options;
+	const findings = [];
+	const startMark = network.mark();
+	let seen = options.from;
+	let interactions = 0;
+	let budget = false;
+	let stopped = false;
+	await frame.evaluate(countMutations).catch(() => void 0);
+	const controls = await frame.evaluate(findControls, [MARK, 0]).catch(() => []);
+	const usable = controls.filter((control) => control.use !== "skip");
+	let next = controls.length;
+	/**
+	* Uses a control once and judges what the page reported meanwhile. Controls it revealed (a
+	* dialog's buttons, a menu's items, a tab's panel) are used too, before anything is dismissed,
+	* down to {@link REVEAL_DEPTH} levels (GPT review finding 3).
+	*/
+	const exercise = async (control, depth = 0) => {
+		const none = {
+			used: false,
+			changed: false,
+			writes: 0,
+			navigated: false,
+			newDocument: false,
+			mark: network.mark()
+		};
+		if (frame.isDetached()) return none;
+		const target = frame.locator(`[${MARK}="${control.index}"]`);
+		if (!await target.isVisible().catch(() => false)) return none;
+		const state = await target.evaluate(stateOf).catch(() => ({
+			disabled: true,
+			active: false
+		}));
+		if (state.disabled || state.active) return none;
+		const mark = network.mark();
+		const beforeMutations = await mutations(frame);
+		const beforeAttributes = await target.evaluate(attributesOf).catch(() => "");
+		const beforeUrl = frame.url();
+		try {
+			const timeout = Math.max(500, Math.min(2e3, options.deadline - Date.now()));
+			if (control.use === "hover") await target.hover({ timeout });
+			else if (control.use === "context") await target.click({
+				button: "right",
+				timeout
+			});
+			else if (control.use === "fill") {
+				await target.fill(valueFor(control.type), { timeout });
+				await target.press("Tab", { timeout });
+			} else if (control.use === "toggle") {
+				await target.click({ timeout });
+				await target.press("Tab", { timeout }).catch(() => void 0);
+			} else if (control.use === "select") {
+				const option = await target.evaluate((element) => {
+					return [...element.options].find((entry) => !entry.selected && !entry.disabled)?.value;
+				});
+				if (option === void 0) return none;
+				await target.selectOption(option, { timeout });
+				await target.press("Tab", { timeout }).catch(() => void 0);
+			} else await target.click({ timeout });
+		} catch {
+			return none;
+		}
+		interactions += 1;
+		await settle(frame, network, options.deadline, 2e3, 5e3);
+		const navigated = frame.url() !== beforeUrl;
+		const afterMutations = await mutations(frame);
+		const newDocument = afterMutations === -1;
+		const afterAttributes = newDocument ? beforeAttributes : await target.evaluate(attributesOf).catch(() => beforeAttributes);
+		const reported = (await recorded(frame, seen)).length > 0;
+		const changed = navigated || newDocument || reported || network.requestsSince(mark) > 0 || afterAttributes !== beforeAttributes || afterMutations > beforeMutations && beforeMutations >= 0;
+		const moment = {
+			kind: "interaction",
+			control: describe(control)
+		};
+		if (newDocument) {
+			findings.push(...judge(await recorded(frame), moment, network.skippedSince(mark), viewport));
+			stopped = true;
+		} else {
+			const entries = await recorded(frame, seen);
+			seen += entries.length;
+			findings.push(...judge(entries, moment, network.skippedSince(mark), viewport));
+			if (depth < REVEAL_DEPTH) await exerciseRevealed(depth);
+			if (depth === 0) {
+				await page.keyboard.press("Escape").catch(() => void 0);
+				await page.mouse.move(0, 0).catch(() => void 0);
+			}
+		}
+		return {
+			used: true,
+			changed,
+			writes: network.writesSince(mark),
+			navigated,
+			newDocument,
+			mark
+		};
+	};
+	const within = () => !stopped && interactions < options.maxInteractions && Date.now() < options.deadline;
+	/**
+	* Uses the controls the last interaction revealed. They are judged for what the page reports
+	* and for inputs that save nothing, never for having no effect: a second try would need their
+	* container opened again, and silence is the conservative answer (D72).
+	*/
+	const exerciseRevealed = async (depth) => {
+		if (!within() || frame.isDetached()) return;
+		const revealed = await frame.evaluate(findControls, [MARK, next]).catch(() => []);
+		next += revealed.length;
+		for (const control of revealed) {
+			if (!within()) break;
+			if (control.use === "skip" || control.tag === "a") continue;
+			const outcome = await exercise(control, depth + 1);
+			if (!outcome.used) continue;
+			unbound(control, outcome);
+		}
+	};
+	/** Reports an input the smoke test changed whose value saved nothing (a hint). */
+	const unbound = (control, outcome) => {
+		if (control.use !== "fill" && control.use !== "toggle" && control.use !== "select") return;
+		if (outcome.writes > 0 || outcome.navigated || outcome.newDocument) return;
+		findings.push(createDiagnostic("MOSTRA_FIELD_UNBOUND", {
+			message: `The smoke test changed ${describe(control)} and the page saved nothing: the input isn't bound to a field.`,
+			location: {
+				viewport,
+				selector: `[${MARK}="${control.index}"]`
+			}
+		}));
+	};
+	/** Controls that changed nothing the first time: tried again once the others were used. */
+	const again = [];
+	let used = 0;
+	const links = usable.filter((control) => control.tag === "a");
+	for (const control of usable.filter((entry) => entry.tag !== "a")) {
+		if (!within()) break;
+		used += 1;
+		const outcome = await exercise(control);
+		if (!outcome.used) continue;
+		if (control.use === "fill" || control.use === "toggle" || control.use === "select") unbound(control, outcome);
+		else if (!outcome.changed) again.push(control);
+	}
+	for (const control of again) {
+		if (!within()) break;
+		const outcome = await exercise(control);
+		if (!outcome.used || outcome.changed) continue;
+		findings.push(createDiagnostic("MOSTRA_SMOKE_NO_EFFECT", {
+			message: `Observed: ${control.use === "hover" ? "hovering over" : "clicking"} ${describe(control)} twice changed nothing verify could see (no change to the page, no request, no saved field, no navigation).`,
+			location: {
+				viewport,
+				selector: `[${MARK}="${control.index}"]`
+			}
+		}));
+	}
+	for (const control of links) {
+		if (!within()) break;
+		used += 1;
+		await exercise(control);
+	}
+	budget = !stopped && used < usable.length;
+	if (budget) findings.push(createDiagnostic("MOSTRA_SMOKE_BUDGET", {
+		message: `The smoke test stopped after ${interactions} interactions, at its budget of ${options.maxInteractions} interactions or 60 s; ${usable.length - used} controls weren't used.`,
+		location: { viewport }
+	}));
+	return {
+		findings,
+		interactions,
+		stateChanges: network.writesSince(startMark),
+		budget
+	};
+}
+//#endregion
+//#region src/runner.ts
+/**
+* The verify runner (ARCHITECTURE §1, ROUND-3 §9, D138): one warm headless Chromium that renders
+* capability links the supervisor's sandbox minted, each in a fresh browser context, and reports
+* what the page did. It decides what a page's behavior means for the verdict (D72): definite
+* failures are errors, observations warnings or hints, and faults that follow from verify's own
+* refusal of an action are attributed to it. The supervisor decides everything else.
+*/
+const require = createRequire(import.meta.url);
+/** How long the runner keeps its browser without work (ROUND-3 §9): 10 minutes. */
+const RUNNER_IDLE_MS = 6e5;
+/** The longest a page may take to report `mostra/ready` before it is judged never ready. */
+const READY_WAIT_MS = 15e3;
+/**
+* How long after its deadline a render is abandoned: its browser context is closed, which ends a
+* page that blocks its own main thread without touching other runs' pages (Opus review finding 5).
+*/
+const RENDER_ABANDON_MS = 1e3;
+/** The time the smoke test leaves before the run's deadline, for the regression stage after it. */
+const SMOKE_RESERVE_MS = 5e3;
+/** Whether a launch failed because the browser isn't installed. */
+function browserMissing(error) {
+	return /Executable doesn't exist|browserType\.launch: .*(not found|ENOENT)/i.test(String(error?.message ?? error));
+}
+/** Creates the runner; its browser starts on the first render. */
+function createRunner(options = {}) {
+	let browser;
+	let idleTimer;
+	let busy = 0;
+	let axeSource;
+	const touch = () => {
+		if (idleTimer) clearTimeout(idleTimer);
+		idleTimer = void 0;
+		if (busy > 0 || !options.onIdle) return;
+		idleTimer = setTimeout(() => options.onIdle?.(), options.idleMs ?? 6e5);
+		idleTimer.unref?.();
+	};
+	const launch = () => {
+		browser ??= chromium.launch({ headless: true }).catch((error) => {
+			browser = void 0;
+			if (browserMissing(error)) throw new RpcError(createDiagnostic("MOSTRA_ENV_BROWSER_MISSING", { message: "verify's browser, Playwright's Chromium headless shell, isn't installed for this runtime." }));
+			throw error;
+		});
+		return browser;
+	};
+	const work = async (task) => {
+		busy += 1;
+		touch();
+		try {
+			return await task();
+		} finally {
+			busy -= 1;
+			touch();
+		}
+	};
+	return {
+		render: (request) => work(async () => {
+			axeSource ??= await readFile(require.resolve("axe-core/axe.min.js"), "utf8");
+			return renderBounded(await launch(), request, axeSource);
+		}),
+		compare: (request) => work(() => compareImages(request)),
+		async close() {
+			if (idleTimer) clearTimeout(idleTimer);
+			const open = browser;
+			browser = void 0;
+			if (open) await (await open.catch(() => void 0))?.close();
+		}
+	};
+}
+/** The artifact's frame: the shell's only child frame. */
+function artifactFrame(page) {
+	return page.frames().find((frame) => frame.parentFrame() === page.mainFrame());
+}
+/** What the frame shows: whether any element has a visible box of nonzero area (D138 item 3). */
+function showsSomething() {
+	const visible = (element) => {
+		const rect = element.getBoundingClientRect();
+		if (rect.width <= 0 || rect.height <= 0) return false;
+		return element.checkVisibility({
+			opacityProperty: true,
+			visibilityProperty: true
+		});
+	};
+	for (const element of document.querySelectorAll("img, svg, canvas, video")) if (visible(element)) return true;
+	if (!document.body) return false;
+	const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+	while (walker.nextNode()) {
+		const node = walker.currentNode;
+		if (!node.textContent?.trim() || !node.parentElement || !visible(node.parentElement)) continue;
+		const range = document.createRange();
+		range.selectNodeContents(node);
+		const rect = range.getBoundingClientRect();
+		if (rect.width > 0 && rect.height > 0) return true;
+	}
+	return false;
+}
+/** Whether a PNG is one uniform color. */
+function uniform(png) {
+	const { data } = PNG.sync.read(png);
+	for (let offset = 4; offset < data.length; offset += 4) if (data[offset] !== data[0] || data[offset + 1] !== data[1] || data[offset + 2] !== data[2] || data[offset + 3] !== data[3]) return false;
+	return true;
+}
+/**
+* Waits for `work`, and gives up on it `graceMs` past `deadline`: `abandon()` is called (for a
+* render, closing its context, which ends a page whose code blocks its main thread) and `late` is
+* the answer, also when `work` then fails because of the abandon. A failure before that is
+* `work`'s own and is thrown (Opus review finding 5).
+*/
+async function bounded(work, options) {
+	let abandoning = false;
+	let timer;
+	const abandoned = new Promise((done) => {
+		timer = setTimeout(() => {
+			abandoning = true;
+			const closing = Promise.resolve(options.abandon()).catch(() => void 0);
+			Promise.race([closing, new Promise((wait) => setTimeout(wait, 2e3))]).then(() => done(options.late));
+		}, Math.max(0, options.deadline - Date.now()) + (options.graceMs ?? RENDER_ABANDON_MS));
+	});
+	const guarded = work.catch((error) => {
+		if (abandoning) return options.late;
+		throw error;
+	});
+	try {
+		return await Promise.race([guarded, abandoned]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Renders one capability link, and abandons it when it is still running past its deadline: its
+* context is closed (the page's renderer with it), and the render reports it ran out of time.
+*/
+async function renderBounded(browser, request, axeSource) {
+	const created = {};
+	return bounded(renderPage(browser, request, axeSource, created), {
+		deadline: request.deadline,
+		late: {
+			ready: false,
+			findings: [],
+			timedOut: true,
+			timingsMs: {}
+		},
+		abandon: () => created.context?.close()
+	});
+}
+/** Renders one capability link and reports what the page did. */
+async function renderPage(browser, request, axeSource, created) {
+	const started = Date.now();
+	const timings = {};
+	const findings = [];
+	const viewport = request.viewport.name;
+	const location = { viewport };
+	let timedOut = false;
+	const left = () => request.deadline - Date.now();
+	const context = await browser.newContext({
+		viewport: {
+			width: request.viewport.width,
+			height: request.viewport.height
+		},
+		deviceScaleFactor: 1,
+		reducedMotion: "reduce"
+	});
+	created.context = context;
+	try {
+		await context.clock.setFixedTime(request.clockMs);
+		await context.addInitScript(recorder);
+		const page = await context.newPage();
+		context.on("page", (other) => {
+			if (other !== page) other.close().catch(() => void 0);
+		});
+		const network = watchNetwork(page, () => artifactFrame(page), viewport);
+		await page.goto(request.url, {
+			waitUntil: "commit",
+			timeout: Math.max(1e3, left())
+		});
+		let ready = false;
+		try {
+			await page.waitForFunction(() => {
+				const state = document.documentElement.dataset["shell"];
+				return state === "ready" || state === "error";
+			}, void 0, { timeout: Math.max(1, Math.min(READY_WAIT_MS, left())) });
+			ready = await page.evaluate(() => document.documentElement.dataset["shell"]) === "ready";
+		} catch {
+			ready = false;
+			timedOut = left() <= 0;
+		}
+		timings["ready"] = Date.now() - started;
+		const frame = artifactFrame(page);
+		if (!ready || !frame) {
+			const shellError = await page.evaluate(() => document.documentElement.dataset["shellError"] ?? "").catch(() => "");
+			findings.push(createDiagnostic("MOSTRA_RUNTIME_NOT_READY", {
+				message: `The page didn't report it was ready${shellError ? ` (the shell reported ${shellError})` : ""}.`,
+				location
+			}));
+			if (frame) findings.push(...judge(await recorded(frame), { kind: "load" }, network.skippedSince(0), viewport));
+			findings.push(...network.findings());
+			return {
+				ready: false,
+				findings: dedupe(findings),
+				timedOut,
+				timingsMs: timings
+			};
+		}
+		await frame.evaluate(() => document.fonts.ready.then(() => true)).catch(() => false);
+		await settle(frame, network, request.deadline);
+		timings["settled"] = Date.now() - started;
+		let screenshot;
+		let shot;
+		if (request.collect.screenshot) {
+			const path = join(request.outDir, `${request.name}.png`);
+			shot = await page.screenshot({
+				path,
+				animations: "disabled",
+				caret: "hide"
+			});
+			screenshot = {
+				path,
+				width: request.viewport.width,
+				height: request.viewport.height
+			};
+			timings["screenshot"] = Date.now() - started;
+		}
+		if (!await frame.evaluate(showsSomething).catch(() => true) && shot && uniform(shot)) findings.push(createDiagnostic("MOSTRA_RUNTIME_BLANK", {
+			message: "The page reported ready but shows nothing: no visible text, image, SVG, canvas or video, and its screenshot is one color.",
+			location
+		}));
+		let aria;
+		if (request.collect.aria) {
+			const text = await frame.locator("body").ariaSnapshot({ timeout: Math.max(1e3, Math.min(1e4, left())) }).catch(() => {
+				if (left() <= 0) timedOut = true;
+				return "";
+			});
+			aria = {
+				path: join(request.outDir, `${request.name}.aria.yml`),
+				text
+			};
+			timings["aria"] = Date.now() - started;
+		}
+		let fields;
+		if (request.collect.fields) fields = await frame.evaluate((name) => globalThis[name]?.fields?.() ?? [], VERIFY_PROBE).catch(() => []);
+		if (request.collect.axe && left() <= 0) timedOut = true;
+		if (request.collect.axe && left() > 0) {
+			findings.push(...await runAxe(frame, axeSource, viewport));
+			timings["axe"] = Date.now() - started;
+		}
+		const loadEntries = await recorded(frame);
+		findings.push(...judge(loadEntries, { kind: "load" }, network.skippedSince(0), viewport));
+		let smoke;
+		if (request.collect.smoke && left() > 0) {
+			const outcome = await runSmoke({
+				page,
+				frame,
+				network,
+				viewport,
+				from: loadEntries.length,
+				maxInteractions: request.collect.smoke.maxInteractions,
+				deadline: Math.min(request.deadline - SMOKE_RESERVE_MS, Date.now() + request.collect.smoke.maxMs)
+			});
+			findings.push(...outcome.findings);
+			smoke = {
+				interactions: outcome.interactions,
+				stateChanges: outcome.stateChanges,
+				skipped: network.skippedSince(0),
+				budget: outcome.budget
+			};
+			timings["smoke"] = Date.now() - started;
+		}
+		findings.push(...network.findings());
+		return {
+			ready: true,
+			findings: dedupe(findings),
+			...screenshot ? { screenshot } : {},
+			...aria ? { aria } : {},
+			...fields ? { fields } : {},
+			...smoke ? { smoke } : {},
+			timedOut,
+			timingsMs: timings
+		};
+	} finally {
+		await context.close().catch(() => void 0);
+	}
+}
+/**
+* axe-core's violations in the frame (axe's `incomplete` results aren't reported): critical and
+* serious are warnings, moderate and minor hints (D138 item 3). Injected unmodified.
+*/
+async function runAxe(frame, source, viewport) {
+	try {
+		await frame.evaluate(source);
+		return (await frame.evaluate(() => globalThis.axe.run(document, { resultTypes: ["violations"] }))).violations.map((violation) => {
+			const targets = violation.nodes.slice(0, 3).map((node) => node.target.map(String).join(" "));
+			const serious = violation.impact === "critical" || violation.impact === "serious";
+			return createDiagnostic(serious ? "MOSTRA_A11Y_SERIOUS" : "MOSTRA_A11Y_MINOR", {
+				message: `axe ${violation.id} (${violation.impact ?? "unrated"}): ${violation.help}. Found at ${targets.join(", ")}${violation.nodes.length > 3 ? " and more" : ""}.`,
+				location: {
+					viewport,
+					...targets[0] ? { selector: targets[0] } : {}
+				},
+				count: Math.max(1, violation.nodes.length)
+			});
+		});
+	} catch {
+		return [];
+	}
+}
+/** Compares two screenshots with pixelmatch's perceptual threshold and writes the difference. */
+async function compareImages(request) {
+	const a = PNG.sync.read(await readFile(request.a));
+	const b = PNG.sync.read(await readFile(request.b));
+	if (a.width !== b.width || a.height !== b.height) return {
+		ratio: 1,
+		sizeChanged: true
+	};
+	const diff = new PNG({
+		width: a.width,
+		height: a.height
+	});
+	const changed = pixelmatch(a.data, b.data, diff.data, a.width, a.height, { threshold: .1 });
+	await writeFile(request.diff, PNG.sync.write(diff));
+	return {
+		ratio: changed / (a.width * a.height),
+		sizeChanged: false
+	};
+}
+//#endregion
+export { uniform as a, recorder as c, createRunner as i, bounded as n, dedupe as o, compareImages as r, judge as s, RUNNER_IDLE_MS as t };
+
+//# sourceMappingURL=runner-DCmzgY2w.js.map