@marver-design/marver 0.16.0 → 0.17.0

package/dist/shot-DlmTO8AF.mjs

@@ -0,0 +1,926 @@
+import { a as slideSize, i as ROUTE } from "./cli.mjs";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { availableParallelism, tmpdir } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+//#region src/server/cdp.ts
+/**
+* A headless Chrome driven over CDP through Chrome's own debugging PIPE - fds 3 (we write,
+* Chrome reads) and 4 (Chrome writes, we read), NUL-terminated JSON. No port, no stderr
+* scrape, no WebSocket - and the one property everything else here rests on: when the read
+* side of that pipe hits EOF Chrome shuts itself down, and the kernel closes the pipe on ANY
+* death of this process (Ctrl-C, a closed terminal, `kill -9`, OOM). A shot browser cannot
+* outlive the server that started it, whatever happens to the server.
+*
+* One browser belongs to one operation (a shot, a batch, a poster): `launch()` → sends →
+* `close()` in a finally. Nothing is shared or kept warm - a headless instance of the user's
+* own Chrome registers with macOS Launch Services as that Chrome, and a stray one can swallow
+* the machine's link opens; the shortest possible life is the fix.
+*/
+const CHROMES = [
+	"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+	"/Applications/Chromium.app/Contents/MacOS/Chromium",
+	"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+	"/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+	"/usr/bin/google-chrome-stable",
+	"/usr/bin/google-chrome",
+	"/usr/bin/chromium",
+	"/usr/bin/chromium-browser"
+];
+/** The browser binary to drive, or null. MARVER_CHROME overrides; otherwise first known install. */
+function findChrome() {
+	const env = process.env.MARVER_CHROME;
+	if (env) return existsSync(env) ? env : null;
+	return CHROMES.find((p) => existsSync(p)) ?? null;
+}
+/** Profile directories marver has ever created (the sweep in shot.ts looks for both). */
+const PROFILE_PREFIXES = ["mv-shot-", "mv-browser-"];
+const FLAGS = [
+	"--headless=new",
+	"--hide-scrollbars",
+	"--no-first-run",
+	"--no-default-browser-check",
+	"--disable-extensions"
+];
+const HANDSHAKE_MS = 15e3;
+const MAX_MESSAGE = 1 << 30;
+/** The pipe's framing: NUL-terminated messages, arriving in chunks split anywhere - inside a
+*  message, inside a multibyte character, or several messages in one chunk. Segments are held
+*  and concatenated ONCE per delimiter (a screenshot answer is many chunks; re-concatenating
+*  the remainder per chunk would be quadratic). The size guard runs BEFORE a segment is held. */
+var Frames = class {
+	max;
+	chunks = [];
+	held = 0;
+	constructor(max = MAX_MESSAGE) {
+		this.max = max;
+	}
+	/** Feed one chunk; returns the complete messages it finished, or throws on a runaway. */
+	push(d) {
+		const out = [];
+		let from = 0;
+		for (;;) {
+			const nul = d.indexOf(0, from);
+			if (nul < 0) break;
+			this.hold(d.subarray(from, nul));
+			out.push(Buffer.concat(this.chunks).toString("utf8"));
+			this.chunks = [];
+			this.held = 0;
+			from = nul + 1;
+		}
+		if (from < d.length) this.hold(d.subarray(from));
+		return out;
+	}
+	hold(seg) {
+		if (this.held + seg.length > this.max) {
+			this.chunks = [];
+			this.held = 0;
+			throw new Error("the browser sent a runaway message");
+		}
+		this.chunks.push(seg);
+		this.held += seg.length;
+	}
+};
+var Browser = class Browser {
+	proc;
+	out;
+	seq = 0;
+	pending = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	profile;
+	/** Set once the browser is gone or unusable; every send after that rejects at once. */
+	dead = null;
+	exited = Promise.resolve();
+	get pid() {
+		return this.proc.pid;
+	}
+	/** Spawn and handshake (`Browser.getVersion` within 15s), or throw with the reason. A Chrome
+	*  that starts but never brings up CDP is killed here - it can never hold a lane. */
+	static async launch(prefix = "mv-shot-") {
+		const bin = findChrome();
+		if (!bin) throw new Error("no Chrome/Chromium found - install one or set MARVER_CHROME to a browser binary");
+		const b = new Browser();
+		b.profile = mkdtempSync(join(tmpdir(), prefix));
+		b.proc = spawn(bin, [
+			...FLAGS,
+			`--user-data-dir=${b.profile}`,
+			"--remote-debugging-pipe",
+			"about:blank"
+		], { stdio: [
+			"ignore",
+			"ignore",
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		b.out = b.proc.stdio[3];
+		const inp = b.proc.stdio[4];
+		b.exited = new Promise((res) => b.proc.once("exit", () => res()));
+		inp.on("data", (d) => b.feed(d));
+		inp.on("end", () => b.fail("the browser closed its devtools pipe"));
+		inp.on("error", () => b.fail("devtools pipe error"));
+		inp.on("close", () => b.fail("the browser closed its devtools pipe"));
+		b.out.on("error", () => b.fail("devtools pipe error"));
+		b.proc.on("error", (e) => b.fail(`could not start the browser - ${e.message}`));
+		b.proc.on("exit", (code, sig) => b.fail(`the browser exited (${sig ?? code})`));
+		b.proc.once("exit", () => {
+			b.rmProfile();
+		});
+		const handshake = setTimeout(() => b.fail("the browser did not answer in time"), HANDSHAKE_MS);
+		try {
+			await b.send("Browser.getVersion");
+		} catch (e) {
+			await b.close();
+			throw e;
+		} finally {
+			clearTimeout(handshake);
+		}
+		return b;
+	}
+	frames = new Frames();
+	feed(d) {
+		let msgs;
+		try {
+			msgs = this.frames.push(d);
+		} catch (e) {
+			return this.fail(e.message);
+		}
+		for (const text of msgs) {
+			let m;
+			try {
+				m = JSON.parse(text);
+			} catch {
+				continue;
+			}
+			if (m.id != null && this.pending.has(m.id)) {
+				const p = this.pending.get(m.id);
+				this.pending.delete(m.id);
+				m.error ? p.reject(/* @__PURE__ */ new Error(`${p.method}: ${m.error.message}`)) : p.resolve(m.result);
+			} else for (const l of this.listeners) l(m);
+		}
+	}
+	fail(why) {
+		if (this.dead) return;
+		this.dead = why;
+		for (const [id, p] of this.pending) {
+			this.pending.delete(id);
+			p.reject(/* @__PURE__ */ new Error(`${p.method}: ${why}`));
+		}
+		try {
+			this.proc.kill("SIGKILL");
+		} catch {}
+	}
+	/** Send one CDP command. `owner` tags the call so `abort(owner)` can settle a shot's calls
+	*  without touching another shot's in the same browser. */
+	send(method, params = {}, sessionId, owner) {
+		return new Promise((resolve, reject) => {
+			if (this.dead) return reject(/* @__PURE__ */ new Error(`${method}: ${this.dead}`));
+			const gone = owner && this.aborted.get(owner);
+			if (gone) return reject(/* @__PURE__ */ new Error(`${method}: ${gone}`));
+			const id = ++this.seq;
+			this.pending.set(id, {
+				owner,
+				resolve,
+				reject,
+				method
+			});
+			try {
+				this.out.write(JSON.stringify({
+					id,
+					method,
+					params,
+					sessionId
+				}) + "\0");
+			} catch (e) {
+				this.pending.delete(id);
+				reject(e);
+			}
+		});
+	}
+	aborted = /* @__PURE__ */ new WeakMap();
+	/** Reject every pending call tagged `owner` AND every later one (a shot's watchdog fired:
+	*  nothing of that shot may run past its deadline); the browser lives on. */
+	abort(owner, why) {
+		this.aborted.set(owner, why);
+		for (const [id, p] of this.pending) if (p.owner === owner) {
+			this.pending.delete(id);
+			p.reject(/* @__PURE__ */ new Error(`${p.method}: ${why}`));
+		}
+	}
+	/** Subscribe to CDP events (anything without an `id`); returns the unsubscribe. */
+	on(l) {
+		this.listeners.add(l);
+		return () => this.listeners.delete(l);
+	}
+	/** End the pipe (Chrome exits on EOF within ~60ms), SIGKILL after 1s if it is still there,
+	*  then the profile goes once the process has actually exited. Safe to call twice. */
+	async close() {
+		try {
+			this.out.end();
+		} catch {}
+		const kill = setTimeout(() => {
+			try {
+				this.proc.kill("SIGKILL");
+			} catch {}
+		}, 1e3);
+		if (this.proc.exitCode == null && this.proc.signalCode == null) await this.exited;
+		clearTimeout(kill);
+		this.fail("the browser was closed");
+		await this.rmProfile();
+	}
+	rm;
+	rmProfile() {
+		return this.rm ??= (async () => {
+			for (let i = 0; i < 3; i++) try {
+				rmSync(this.profile, {
+					recursive: true,
+					force: true
+				});
+				return;
+			} catch {
+				await new Promise((r) => setTimeout(r, 200));
+			}
+			try {
+				rmSync(this.profile, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		})();
+	}
+};
+//#endregion
+//#region src/server/shot.ts
+/**
+* Frame screenshots without a dependency - the system's own Chrome, driven over CDP through
+* its debugging pipe (cdp.ts has the transport and the lifetime story).
+*
+* This exists for Live Jam's verify loop: a jam agent has no shell (deliberately - the job
+* packet carries untrusted text), so "look at what you built" must be a capability the dev
+* server provides, not a command the agent runs. The /api/shot and /api/shots endpoints call
+* this; the `marver shot` CLI and the file-drop inbox both reach those.
+*
+* Readiness is DETERMINISTIC, not a sleep: poll until #root (or body, for html frames) has
+* children, then wait for fonts. A frame that never mounts fails with the page's own
+* exception text - which is exactly what the agent needs to fix it.
+*
+* One browser per OPERATION (a shot, a batch, a poster), N frames at a time inside a batch,
+* and the browser closed in the operation's finally - never idle, never shared, never
+* outliving the server.
+*/
+const slug = (frameId) => frameId.replace(/\//g, "--");
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : void 0;
+function planShot(frame, viewports, override = {}) {
+	const cw = num(frame.contentWidth);
+	const vpObj = frame.viewport ? viewports[frame.viewport] : void 0;
+	const ow = num(override.w), oh = num(override.h);
+	const sl = slideSize(frame);
+	if (sl) return {
+		width: sl.width,
+		initialHeight: sl.height,
+		fullHeight: false
+	};
+	const fallback = viewports.mobile ?? {
+		width: 390,
+		height: 844
+	};
+	if (cw) {
+		const width = clamp(ow ?? vpObj?.width ?? cw, 320, 1600);
+		return {
+			width,
+			initialHeight: Math.round(width * .75),
+			fullHeight: true
+		};
+	}
+	const vp = vpObj ?? fallback;
+	if (ow || oh) return {
+		width: clamp(ow ?? vp.width, 120, 3840),
+		initialHeight: clamp(oh ?? vp.height, 80, 2160),
+		fullHeight: false
+	};
+	return {
+		width: vp.width,
+		initialHeight: vp.height,
+		fullHeight: false
+	};
+}
+/** Resolve a frame from the manifest and screenshot it - the shared core behind BOTH
+*  transports (the HTTP /api/shot endpoint and the file-drop inbox), so they validate and
+*  name output identically. `origin` is the dev server's own base URL. */
+async function shootFrame(opts) {
+	const { root, viewports, frameId, theme, origin, scale = 2, size, browser } = opts;
+	if (!/^[a-z0-9-]+$/i.test(theme)) return {
+		ok: false,
+		error: "invalid theme"
+	};
+	if (!Number.isInteger(scale) || scale < 1 || scale > 4) return {
+		ok: false,
+		error: "invalid scale"
+	};
+	let manifest = {};
+	try {
+		manifest = JSON.parse(readFileSync(join(root, "design", "manifest.json"), "utf8"));
+	} catch {}
+	const frame = (manifest.frames ?? []).find((f) => f.id === frameId);
+	if (!frame) return {
+		ok: false,
+		error: `unknown frame "${frameId}" - ids are in design/manifest.json`
+	};
+	const plan = planShot(frame, viewports, size);
+	if (frame.kind !== "html") try {
+		const { scanAssetRefs } = await import("./build-D_g53Bp2.mjs");
+		const { ensurePoster } = await import("./poster-BEjUcQP3.mjs");
+		const refs = scanAssetRefs(readFileSync(join(root, frame.file), "utf8"), frame.file);
+		for (const r of refs) if (r.endsWith(".poster.png")) await ensurePoster(join(root, "design", "assets"), r.slice(0, -11));
+	} catch {}
+	const shotsDir = join(root, "design", ".local", "shots");
+	mkdirSync(shotsDir, { recursive: true });
+	sweepTemps(shotsDir);
+	const explicit = opts.scale !== void 0;
+	const relFor = (used) => {
+		const tag = !explicit || scale === 2 && used === 2 ? "" : used === scale ? `@${scale}x` : `@${scale}x-as-${used}x`;
+		return `design/.local/shots/${slug(frameId)}--${theme}${tag}.png`;
+	};
+	const tmp = join(shotsDir, `.${slug(frameId)}--${theme}.${randomBytes(6).toString("hex")}.tmp.png`);
+	const req = {
+		url: frame.kind === "html" ? `${origin}/${frame.file}?theme=${encodeURIComponent(theme)}` : `${origin}${ROUTE}/frame/?id=${encodeURIComponent(frameId)}&theme=${encodeURIComponent(theme)}`,
+		width: plan.width,
+		height: plan.initialHeight,
+		out: tmp,
+		fullHeight: plan.fullHeight,
+		scale
+	};
+	const result = browser ? await captureIn(req, browser) : await capture(req);
+	if (!result.ok) {
+		rmSync(tmp, { force: true });
+		return result;
+	}
+	const rel = relFor(result.scale);
+	try {
+		try {
+			renameSync(tmp, join(root, rel));
+		} catch (err) {
+			const code = err.code;
+			if (code !== "EEXIST" && code !== "EPERM") throw err;
+			copyFileSync(tmp, join(root, rel));
+		}
+	} catch (err) {
+		return {
+			ok: false,
+			error: `could not write the shot - ${err.message}`
+		};
+	} finally {
+		rmSync(tmp, { force: true });
+	}
+	return {
+		ok: true,
+		path: rel,
+		width: result.width,
+		height: result.height,
+		scale: result.scale,
+		...result.truncated ? { truncated: true } : {},
+		...result.unsettled ? { unsettled: true } : {},
+		...result.note ? { note: result.note } : {}
+	};
+}
+/** Turn a selector into the ordered list of frame ids to shoot, or an error with the HTTP
+*  status it deserves. Ids the manifest does not know are kept (each fails its own entry);
+*  duplicates, an empty or oversize list, and a scene nobody belongs to are refused whole. */
+function resolveFrames(root, sel) {
+	const keys = [
+		"frames",
+		"scene",
+		"all"
+	].filter((k) => sel[k] !== void 0);
+	if (keys.length !== 1) return {
+		ok: false,
+		status: 400,
+		error: "name exactly one of frames (an array of ids), scene (a name) or all (true)"
+	};
+	let manifest = {};
+	try {
+		manifest = JSON.parse(readFileSync(join(root, "design", "manifest.json"), "utf8"));
+	} catch {}
+	const entries = manifest.frames ?? [];
+	const listed = entries.map((f) => f.id);
+	let frames;
+	if (keys[0] === "frames") {
+		if (!Array.isArray(sel.frames) || !sel.frames.every((f) => typeof f === "string" && f)) return {
+			ok: false,
+			status: 400,
+			error: "frames must be an array of frame ids"
+		};
+		frames = sel.frames;
+		if (new Set(frames).size !== frames.length) return {
+			ok: false,
+			status: 400,
+			error: "frames lists the same id twice"
+		};
+	} else if (keys[0] === "scene") {
+		if (typeof sel.scene !== "string" || !sel.scene) return {
+			ok: false,
+			status: 400,
+			error: "scene must be a scene name"
+		};
+		frames = entries.filter((f) => f.scene === sel.scene).map((f) => f.id);
+		if (!frames.length) return {
+			ok: false,
+			status: 404,
+			error: `no frames in scene "${sel.scene}" - scenes are in design/manifest.json`
+		};
+	} else {
+		if (sel.all !== true) return {
+			ok: false,
+			status: 400,
+			error: "all must be true"
+		};
+		frames = listed;
+	}
+	if (!frames.length) return {
+		ok: false,
+		status: 400,
+		error: "nothing to shoot"
+	};
+	if (frames.length > 200) return {
+		ok: false,
+		status: 400,
+		error: `${frames.length} frames - a batch takes 200 at most`
+	};
+	return {
+		ok: true,
+		frames
+	};
+}
+/** Shoot many frames as ONE operation: one browser, `shotConcurrency()` frames at a time
+*  inside it, results in the order asked. Every entry answers for itself - an unknown id or a
+*  frame that throws fails alone; only a browser that could not start fails the whole batch
+*  (the thrown error, for the caller to turn into a 503). Once work has begun a browser that
+*  dies fails the remaining entries individually. */
+async function shootBatch(opts) {
+	const { root, viewports, frames, theme, origin, scale } = opts;
+	return withBrowser("shot", (b) => pool(shotConcurrency(), frames, async (frameId) => {
+		return {
+			frame: frameId,
+			...await shootFrame({
+				root,
+				viewports,
+				frameId,
+				theme,
+				origin,
+				scale,
+				browser: b
+			}).catch((e) => ({
+				ok: false,
+				error: e.message
+			}))
+		};
+	}));
+}
+/** Kill the headless browsers earlier versions left behind (they outlived their server, and
+*  on macOS such a ghost of the user's own Chrome can swallow every link the machine opens),
+*  then remove the profile directories nothing references. Runs once at `dev()` start,
+*  best-effort, never throws. Orphaned is the rule: a live browser of ANY running marver
+*  server has that server as its parent, and ours die with it - so a headless Chrome on one
+*  of our profiles whose parent is 1 can only be a leak. darwin and linux (`ps -o`); anywhere
+*  else this is a no-op. */
+const BROWSER_NAMES = /* @__PURE__ */ new Set([
+	"Google Chrome",
+	"Chromium",
+	"Microsoft Edge",
+	"Brave Browser",
+	"chrome",
+	"chromium",
+	"chromium-browser",
+	"google-chrome",
+	"google-chrome-stable",
+	"msedge",
+	"brave",
+	"brave-browser"
+]);
+async function sweepGhosts(log = () => {}) {
+	if (process.platform !== "darwin" && process.platform !== "linux") return;
+	const tmp = tmpdir();
+	const bins = /* @__PURE__ */ new Set([...CHROMES, ...process.env.MARVER_CHROME ? [process.env.MARVER_CHROME] : []]);
+	const profileOf = (cmd) => {
+		const m = /(?:^|\s)--user-data-dir=(\S+)/.exec(cmd);
+		if (!m) return null;
+		const dir = m[1];
+		return PROFILE_PREFIXES.some((pre) => dir.startsWith(join(tmp, pre))) ? dir : null;
+	};
+	const isBrowser = (cmd) => {
+		const exe = cmd.split(" --")[0];
+		if ([...bins].some((b) => exe === b || exe.startsWith(`${b} `))) return true;
+		return BROWSER_NAMES.has(exe.slice(exe.lastIndexOf("/") + 1));
+	};
+	const ps = (args) => {
+		try {
+			return execFileSync("ps", args, { encoding: "utf8" }).split("\n").map((l) => {
+				const m = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(l);
+				return m ? {
+					pid: Number(m[1]),
+					ppid: Number(m[2]),
+					cmd: m[3]
+				} : null;
+			}).filter((r) => !!r);
+		} catch {
+			return null;
+		}
+	};
+	const rows = ps(["-axo", "pid=,ppid=,command="]);
+	if (!rows) return;
+	const isGhost = (r) => r.ppid === 1 && r.cmd.includes("--headless") && !!profileOf(r.cmd) && isBrowser(r.cmd);
+	const referenced = /* @__PURE__ */ new Set();
+	for (const r of rows) {
+		const dir = profileOf(r.cmd);
+		if (dir) referenced.add(dir);
+	}
+	for (const g of rows.filter(isGhost)) {
+		const now = ps([
+			"-o",
+			"pid=,ppid=,command=",
+			"-p",
+			String(g.pid)
+		])?.[0];
+		if (!now || now.cmd !== g.cmd || now.ppid !== g.ppid) continue;
+		try {
+			process.kill(g.pid, "SIGKILL");
+		} catch {
+			continue;
+		}
+		const by = Date.now() + 2e3;
+		while (Date.now() < by) try {
+			process.kill(g.pid, 0);
+			await new Promise((r) => setTimeout(r, 50));
+		} catch {
+			break;
+		}
+		log(`shot: removed a headless browser left by an earlier version (pid ${g.pid})`);
+		referenced.delete(profileOf(g.cmd));
+	}
+	let names = [];
+	try {
+		names = readdirSync(tmp).filter((n) => PROFILE_PREFIXES.some((pre) => n.startsWith(pre)));
+	} catch {
+		return;
+	}
+	for (const n of names) {
+		const dir = join(tmp, n);
+		if (referenced.has(dir)) continue;
+		try {
+			if (Date.now() - statSync(dir).mtimeMs < 6e5) continue;
+		} catch {
+			continue;
+		}
+		try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+/** A crashed process can leave a `.tmp.png` behind; sweep them (older than a minute, so an in-
+*  flight capture in this process is never touched) at the next shot. */
+const sweptAt = /* @__PURE__ */ new Map();
+function sweepTemps(dir) {
+	if (Date.now() - (sweptAt.get(dir) ?? 0) < 6e4) return;
+	sweptAt.set(dir, Date.now());
+	try {
+		for (const f of readdirSync(dir)) {
+			if (!f.endsWith(".tmp.png")) continue;
+			const p = join(dir, f);
+			try {
+				if (Date.now() - statSync(p).mtimeMs > 6e4) rmSync(p, { force: true });
+			} catch {}
+		}
+	} catch {}
+}
+/** One OPERATION at a time PER LANE, and one browser per operation. An operation is a shot,
+*  a batch or a poster: it starts its browser, runs its frames through it (a batch runs N at
+*  once inside), and closes it in the finally - no browser is ever shared between operations
+*  or left idle. Operations on a lane queue as shots always did, so two operations never
+*  write the same output at the same time. Posters have their own lane - a frame being shot
+*  may ask for its poster mid-render, and on the shot's lane that request would wait for the
+*  very shot that is waiting for it. */
+const chains = /* @__PURE__ */ new Map();
+function withBrowser(lane, fn) {
+	const run = async () => {
+		const b = await Browser.launch();
+		try {
+			return await fn(b);
+		} finally {
+			await b.close();
+		}
+	};
+	const next = (chains.get(lane) ?? Promise.resolve()).then(run, run);
+	chains.set(lane, next);
+	return next;
+}
+/** One frame as its own operation (a poster, the shell's copy-as-image, a single `shot`). */
+function capture(req, lane = "shot") {
+	return withBrowser(lane, (b) => captureIn(req, b)).catch((e) => ({
+		ok: false,
+		error: e.message
+	}));
+}
+/** How many frames a batch renders at once inside its browser. Six at most by default, fewer
+*  on a small machine: the settle and grow passes are wall-clock budgets, and past a few
+*  concurrent renderers a frame starts spending its budget waiting for CPU instead of for its
+*  own content (measured 2026-09-04: 31 frames, no unsettled capture up to 8 on 18 cores). */
+function shotConcurrency() {
+	const n = Number(process.env.MARVER_SHOT_CONCURRENCY);
+	if (Number.isInteger(n) && n >= 1 && n <= 16) return n;
+	return Math.max(2, Math.min(6, availableParallelism() - 2));
+}
+/** Run `fn` over `items` with at most `n` in flight; results in input order. */
+async function pool(n, items, fn) {
+	const results = new Array(items.length);
+	let next = 0;
+	const worker = async () => {
+		for (;;) {
+			const i = next++;
+			if (i >= items.length) return;
+			results[i] = await fn(items[i], i);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(n, items.length) }, worker));
+	return results;
+}
+/** The capture budget. Chrome's surface tops out near 16384 device px per SIDE, and a bitmap is
+*  also bounded by its AREA: 64M device px (~256 MiB RGBA) is comfortably rendered, encoded and
+*  pasted, where a 3840×2160@4 (133M px) can stall the renderer or the paste target. Both limits
+*  are exported so the tests hold the same numbers. */
+const SURFACE = 16384;
+const AREA = 64e6;
+const fits = (w, h, dsf) => w * dsf <= 16384 && h * dsf <= 16384 && w * h * dsf * dsf <= 64e6;
+/** The tallest CSS height a full-height capture of `width` can hold at `dsf`. */
+const capFor = (width, dsf) => Math.max(1, Math.min(Math.floor(SURFACE / dsf), Math.floor(AREA / (width * dsf * dsf))));
+async function captureIn({ url, width, height, out, fullHeight = false, timeoutMs = 3e4, scale: wantScale = 2, clip }, b) {
+	let scale = Math.min(4, Math.max(1, Math.round(wantScale)));
+	while (scale > 1 && !fits(width, height, scale)) scale--;
+	const me = {};
+	let watchdog;
+	let targetId;
+	let sessionId;
+	let off = () => {};
+	try {
+		let lastException = "";
+		const send = (method, params = {}, sid) => b.send(method, params, sid, me);
+		const sendD = (method, params, ms = 1500) => {
+			let timer;
+			return Promise.race([send(method, params, sessionId), new Promise((_, rej) => {
+				timer = setTimeout(() => rej(/* @__PURE__ */ new Error(`${method} timed out`)), ms);
+			})]).finally(() => clearTimeout(timer));
+		};
+		const hardBy = Date.now() + timeoutMs + 15e3;
+		watchdog = setTimeout(() => b.abort(me, "the shot timed out"), timeoutMs + 15e3);
+		const RESERVE = 21e3;
+		const discretionary = () => hardBy - RESERVE - Date.now();
+		targetId = (await send("Target.createTarget", { url: "about:blank" })).targetId;
+		sessionId = (await send("Target.attachToTarget", {
+			targetId,
+			flatten: true
+		})).sessionId;
+		off = b.on((m) => {
+			if (m.sessionId === sessionId && m.method === "Runtime.exceptionThrown") {
+				const d = m.params?.exceptionDetails;
+				lastException = String(d?.exception?.description ?? d?.text ?? "").split("\n")[0];
+			}
+		});
+		await send("Emulation.setDeviceMetricsOverride", {
+			width,
+			height,
+			deviceScaleFactor: scale,
+			mobile: false
+		}, sessionId);
+		await send("Page.enable", {}, sessionId);
+		await send("Runtime.enable", {}, sessionId);
+		const nav = await send("Page.navigate", { url }, sessionId);
+		if (nav?.errorText && nav.errorText !== "net::ERR_ABORTED") return {
+			ok: false,
+			error: `could not load the frame (${nav.errorText}) - is the dev server reachable at ${new URL(url).origin}?`
+		};
+		const t0 = Date.now();
+		let ready = false;
+		while (Date.now() - t0 < timeoutMs) {
+			if ((await send("Runtime.evaluate", {
+				expression: `(() => { const el = document.getElementById('root') ?? document.body; return !!el && el.childElementCount > 0 && document.readyState !== 'loading' })()`,
+				returnByValue: true
+			}, sessionId).catch(() => null))?.result?.value) {
+				ready = true;
+				break;
+			}
+			await new Promise((r2) => setTimeout(r2, 150));
+		}
+		if (!ready) return {
+			ok: false,
+			error: `the frame never rendered${lastException ? ` - the page threw: ${lastException}` : " (no exception surfaced - is the dev server reachable from this machine?)"}`
+		};
+		const SETTLED = `(() => {
+      if (typeof window.__mvLodBusy === 'function' && window.__mvLodBusy() > 0) return false
+      if (typeof window.__mvPosterBusy === 'function' && window.__mvPosterBusy() > 0) return false
+      const H = window.innerHeight, W = window.innerWidth
+      for (const im of document.images) {
+        if (im.complete) continue
+        const r = im.getBoundingClientRect()
+        if (r.bottom < 0 || r.top > H || r.right < 0 || r.left > W) continue
+        return false
+      }
+      for (const c of document.querySelectorAll('.mv-chart')) if (!c.querySelector('svg, canvas')) return false
+      for (const d of document.querySelectorAll('.mv-diagram')) if (!d.querySelector('.mv-diagram-svg svg, .mv-diagram-err')) return false
+      return true
+    })()`;
+		const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+		const settle = async (budgetMs) => {
+			const total = Math.min(budgetMs, discretionary());
+			if (total <= 0) return false;
+			const by = Date.now() + total;
+			const left = () => Math.max(1, by - Date.now());
+			await sendD("Runtime.evaluate", {
+				expression: `window.postMessage({type:'sh:camera',moving:false,scale:1}, location.origin)`,
+				returnByValue: true
+			}, left()).catch(() => null);
+			await sendD("Runtime.evaluate", {
+				expression: "document.fonts.ready.then(() => true)",
+				awaitPromise: true,
+				returnByValue: true
+			}, left()).catch(() => null);
+			let ok = false;
+			while (Date.now() < by) {
+				if ((await sendD("Runtime.evaluate", {
+					expression: SETTLED,
+					returnByValue: true
+				}, left()).catch(() => null))?.result?.value === true) {
+					ok = true;
+					break;
+				}
+				await wait(Math.min(100, left()));
+			}
+			if (Date.now() < by) await sendD("Runtime.evaluate", {
+				expression: "new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(() => r(true))))",
+				awaitPromise: true,
+				returnByValue: true
+			}, Math.min(1e3, left())).catch(() => null);
+			if (Date.now() < by) await wait(Math.min(ok ? 150 : 250, left()));
+			return ok;
+		};
+		let settled = await settle(3e3);
+		const errEval = await send("Runtime.evaluate", {
+			expression: "window.__mvFrameError || \"\"",
+			returnByValue: true
+		}, sessionId).catch(() => null);
+		const frameError = typeof errEval?.result?.value === "string" ? errEval.result.value : "";
+		if (frameError) return {
+			ok: false,
+			error: `the frame rendered an error - ${frameError}`
+		};
+		let capW = width, capH = height, truncated = false, note = "";
+		if (fullHeight) {
+			const measureH = async () => {
+				const v = (await sendD("Runtime.evaluate", {
+					expression: `Math.ceil((document.querySelector('.mv-doc')||document.getElementById('root')||document.body).getBoundingClientRect().height)`,
+					returnByValue: true
+				}).catch(() => null))?.result?.value;
+				return typeof v === "number" && Number.isFinite(v) ? v : 0;
+			};
+			const lodIdle = async () => {
+				const v = (await sendD("Runtime.evaluate", {
+					expression: `(typeof window.__mvLodBusy==='function')?window.__mvLodBusy():0`,
+					returnByValue: true
+				}).catch(() => null))?.result?.value;
+				return typeof v === "number" ? v === 0 : true;
+			};
+			let measured = 0;
+			const growFit = async (dsf, capCss, deadline) => {
+				let h = Math.max(height, 2e3), prev = -1;
+				for (let i = 0; i < 8 && Date.now() < deadline; i++) {
+					await sendD("Emulation.setDeviceMetricsOverride", {
+						width,
+						height: Math.min(h, capCss),
+						deviceScaleFactor: dsf,
+						mobile: false
+					}).catch(() => {});
+					if (Date.now() >= deadline) break;
+					await sendD("Runtime.evaluate", {
+						expression: "document.fonts.ready.then(()=>true)",
+						awaitPromise: true,
+						returnByValue: true
+					}).catch(() => null);
+					if (Date.now() >= deadline) break;
+					for (let j = 0; j < 10 && Date.now() < deadline && !await lodIdle(); j++) await wait(100);
+					if (Date.now() >= deadline) break;
+					await wait(150);
+					if (Date.now() >= deadline) break;
+					const m = await measureH();
+					if (m > 0) measured = m;
+					const capped = Math.min(h, capCss);
+					if (capped >= capCss) break;
+					if (m > 0 && m <= capped && m === prev) break;
+					prev = m;
+					h = Math.max(m, capped);
+				}
+			};
+			const settleDeadline = Date.now() + Math.max(0, Math.min(6e3, discretionary()));
+			const asked = scale;
+			await growFit(scale, capFor(width, scale), settleDeadline);
+			if (measured > capFor(width, scale) && scale > 2) {
+				scale = 2;
+				await growFit(2, capFor(width, 2), settleDeadline);
+			}
+			if (measured > capFor(width, scale) && scale > 1) {
+				scale = 1;
+				await growFit(1, capFor(width, 1), settleDeadline);
+			}
+			const cap = capFor(width, scale);
+			capW = width;
+			if (measured > cap) {
+				capH = cap;
+				truncated = true;
+				note = `frame is ${measured}px tall; captured the top ${cap}px - split it or reduce its height`;
+			} else capH = clamp(measured || height, 80, cap);
+			if (scale < asked && !truncated) note = `frame is ${measured}px tall - too tall for ${asked}x, captured at ${scale}x`;
+			await sendD("Emulation.setDeviceMetricsOverride", {
+				width: capW,
+				height: capH,
+				deviceScaleFactor: scale,
+				mobile: false
+			}, 5e3);
+			await wait(Math.min(300, Math.max(0, discretionary())));
+			settled = await settle(Math.max(1200, settleDeadline - Date.now()));
+			const m2 = await measureH();
+			if (m2 > capH) {
+				if (m2 <= cap) capH = m2;
+				else {
+					capH = cap;
+					truncated = true;
+					note = `frame is ${m2}px tall; captured the top ${cap}px - split it or reduce its height`;
+				}
+				await sendD("Emulation.setDeviceMetricsOverride", {
+					width: capW,
+					height: capH,
+					deviceScaleFactor: scale,
+					mobile: false
+				}, 5e3);
+				settled = await settle(600);
+			}
+		}
+		let capX = 0, capY = 0;
+		if (clip) {
+			const box = (await sendD("Runtime.evaluate", {
+				expression: `(() => { const el = document.querySelector(${JSON.stringify(clip)}); if (!el) return null; const b = el.getBoundingClientRect(); return { x: b.x, y: b.y, w: b.width, h: b.height } })()`,
+				returnByValue: true
+			}, 2e3).catch(() => null))?.result?.value;
+			if (!box || box.w < 1 || box.h < 1) return {
+				ok: false,
+				error: `nothing to capture at "${clip}"`
+			};
+			capX = Math.max(0, Math.floor(box.x));
+			capY = Math.max(0, Math.floor(box.y));
+			capW = Math.max(1, Math.round(box.w));
+			capH = Math.max(1, Math.round(box.h));
+		}
+		const shot = await sendD("Page.captureScreenshot", {
+			format: "png",
+			captureBeyondViewport: true,
+			clip: {
+				x: capX,
+				y: capY,
+				width: capW,
+				height: capH,
+				scale: 1
+			}
+		}, 15e3);
+		writeFileSync(out, Buffer.from(String(shot.data), "base64"));
+		const unsettled = !settled;
+		if (unsettled) note = `${note ? note + "; " : ""}captured before the frame settled - images, charts or diagrams may be missing; shoot it alone or lower MARVER_SHOT_CONCURRENCY`;
+		return {
+			ok: true,
+			width: capW,
+			height: capH,
+			scale,
+			...truncated ? { truncated: true } : {},
+			...unsettled ? { unsettled: true } : {},
+			...note ? { note } : {}
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: err.message
+		};
+	} finally {
+		if (watchdog) clearTimeout(watchdog);
+		off();
+		if (targetId && !b.dead) {
+			let t;
+			await Promise.race([b.send("Target.closeTarget", { targetId }, void 0, me).catch(() => {}), new Promise((r) => {
+				t = setTimeout(r, 2e3);
+			})]);
+			clearTimeout(t);
+		}
+		b.abort(me, "the shot finished");
+	}
+}
+//#endregion
+export { capture, resolveFrames, shootBatch, shootFrame, sweepGhosts, findChrome as t };