@mind-harness/mh-browser 0.2.4 → 0.2.6

package/lib/index.js

@@ -1,4 +1,4 @@
-import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, win32 } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { isDeepStrictEqual } from "node:util";
@@ -6,11 +6,13 @@ import { HarnessError, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { assertSupportedJsonSchema, defineTool, validateJsonSchemaValue } from "@deepseek-ai/dsh-tools";
 import { createHash, randomUUID } from "node:crypto";
 import { parse } from "yaml";
-import { constants, readFileSync } from "node:fs";
+import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs";
 import { lstat, mkdir, open, readFile, readlink, realpath, unlink, writeFile } from "node:fs/promises";
 import { z as z$1 } from "zod";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { chromium } from "playwright";
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { UserQuestionError } from "@deepseek-ai/dsh-user-questions";
 //#region lib/types/config.js
@@ -20,7 +22,8 @@ const browserConfig = z.object({
 		"chrome",
 		"msedge",
 		"chromium"
-	]).default("chrome").description("Which installed browser to drive. chromium is the one Playwright downloads."),
+	]).default("chrome").volatile().description("Which browser to drive. chromium is the one Playwright downloads. A new value restarts the browser once it is idle."),
+	executablePath: z.string().volatile().description("Absolute path of the browser executable. `~` is expanded. Leave empty to locate one. A new value restarts the browser once it is idle."),
 	profileDir: z.string().description("Browser profile directory, kept between runs. Defaults to mh/profiles/<dsh profile>/browser under the dsh home."),
 	headless: z.boolean().default(false).description("Run the browser without a window.")
 });
@@ -33,6 +36,146 @@ function defaultProfileDir(profile, home = resolveDshHome()) {
 	return profile === void 0 ? join(home, "mh", "browser") : join(home, "mh", "profiles", profile.name, "browser");
 }
 //#endregion
+//#region lib/types/types.js
+var MhBrowserError = class extends Error {
+	code;
+	page;
+	constructor(code, message, page) {
+		super(message);
+		this.name = "MhBrowserError";
+		this.code = code;
+		if (page !== void 0) this.page = page;
+	}
+};
+/** Owner of the person's own window. It belongs to no Session. */
+const PERSON_OWNER = "person";
+const UNKNOWN_TAB = "UNKNOWN_TAB";
+const UNKNOWN_TAB_REASON = "no such tab in this session";
+/**
+* Internal: a wait ended because its signal aborted. A tool never reports it:
+* a stopped call ends as the tool runtime's abort, a takeover as `TAKEN_OVER`.
+*/
+const INTERRUPTED = "INTERRUPTED";
+/** The browser did not start or could not be restarted. */
+const BROWSER_UNAVAILABLE = "BROWSER_UNAVAILABLE";
+function unknownTab() {
+	return {
+		url: "",
+		reason: UNKNOWN_TAB_REASON
+	};
+}
+//#endregion
+//#region lib/types/service/abortable.js
+const WAITING_STOPPED$1 = "stopped while waiting";
+/** A wait ended because its signal aborted, including a deadline synthesized here. */
+function stopped$1() {
+	return new MhBrowserError(INTERRUPTED, WAITING_STOPPED$1);
+}
+function isInterrupted(error) {
+	return error instanceof MhBrowserError && error.code === "INTERRUPTED";
+}
+/**
+* `promise`, or a rejection when `signal` aborts. The original promise is
+* always observed, so abandoning it leaves no unhandled rejection.
+*/
+function untilAborted(promise, signal) {
+	const settled = promise.then((value) => ({
+		ok: true,
+		value
+	}), (error) => ({
+		ok: false,
+		error
+	}));
+	if (signal === void 0) return unwrap(settled);
+	return new Promise((resolve, reject) => {
+		let done = false;
+		const finish = (run) => {
+			if (done) return;
+			done = true;
+			signal.removeEventListener("abort", onAbort);
+			run();
+		};
+		const onAbort = () => {
+			finish(() => reject(stopped$1()));
+		};
+		if (signal.aborted) {
+			finish(() => reject(stopped$1()));
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+		settled.then((result) => {
+			finish(() => {
+				if (result.ok) resolve(result.value);
+				else reject(result.error);
+			});
+		});
+	});
+}
+/** `signal`, a deadline of `ms`, or whichever of the two aborts first. */
+function capped(signal, ms) {
+	const limit = AbortSignal.timeout(ms);
+	if (signal === void 0) return limit;
+	return AbortSignal.any([signal, limit]);
+}
+/**
+* Run `op` once `previous` settles. Aborting `signal` while waiting rejects
+* `run` and does not call `op`. `tail` still follows `previous`, and `op`
+* when `op` has started, so a later caller cannot overlap the work.
+*/
+function enqueue(previous, op, signal) {
+	let started = Promise.resolve();
+	let began = false;
+	return {
+		run: new Promise((resolve, reject) => {
+			let settled = false;
+			const fail = () => {
+				if (settled) return;
+				settled = true;
+				reject(stopped$1());
+			};
+			const onAbort = () => {
+				if (began) return;
+				fail();
+			};
+			const start = () => {
+				signal?.removeEventListener("abort", onAbort);
+				if (settled || signal?.aborted === true) {
+					fail();
+					return;
+				}
+				let work;
+				try {
+					began = true;
+					work = op();
+				} catch (error) {
+					started = Promise.reject(error);
+					started.catch(() => void 0);
+					if (!settled) {
+						settled = true;
+						reject(error);
+					}
+					return;
+				}
+				started = work;
+				resolve(work);
+			};
+			if (signal?.aborted === true) {
+				fail();
+				return;
+			}
+			if (signal !== void 0) signal.addEventListener("abort", onAbort, { once: true });
+			previous.then(start, start);
+		}),
+		tail: previous.then(() => started, () => started).then(() => void 0, () => void 0)
+	};
+}
+function unwrap(settled) {
+	return settled.then((result) => {
+		if (result.ok) return result.value;
+		throw result.error;
+	});
+}
+//#endregion
 //#region lib/types/representation/agent-view.js
 const AGENT_VIEW_VERSION = "0.1";
 const AGENT_VIEW_ACCEPT = "text/markdown; variant=agent-view";
@@ -446,35 +589,6 @@ function formatSeconds(seconds) {
 	return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
 }
 //#endregion
-//#region lib/types/types.js
-var MhBrowserError = class extends Error {
-	code;
-	page;
-	constructor(code, message, page) {
-		super(message);
-		this.name = "MhBrowserError";
-		this.code = code;
-		if (page !== void 0) this.page = page;
-	}
-};
-/** Owner of the person's own window. It belongs to no Session. */
-const PERSON_OWNER = "person";
-const UNKNOWN_TAB = "UNKNOWN_TAB";
-const UNKNOWN_TAB_REASON = "no such tab in this session";
-/**
-* Internal: a wait ended because its signal aborted. A tool never reports it:
-* a stopped call ends as the tool runtime's abort, a takeover as `TAKEN_OVER`.
-*/
-const INTERRUPTED = "INTERRUPTED";
-/** The browser did not start or could not be restarted. */
-const BROWSER_UNAVAILABLE = "BROWSER_UNAVAILABLE";
-function unknownTab() {
-	return {
-		url: "",
-		reason: UNKNOWN_TAB_REASON
-	};
-}
-//#endregion
 //#region lib/types/tools/session.js
 /** dsh shows the model only the message, so the message starts with the code. */
 var BrowserToolError = class extends HarnessError {
@@ -694,6 +808,18 @@ function visit(value, depth, found) {
 	for (const item of Object.values(row)) visit(item, depth + 1, found);
 }
 //#endregion
+//#region lib/types/tools/given.js
+/** A string the caller gave. Blank is the same as omitting it; the text itself is kept. */
+function givenString(value) {
+	if (typeof value !== "string" || value.trim() === "") return void 0;
+	return value;
+}
+/** Seconds to wait. Zero is the same as omitting it; any other number is kept. */
+function givenTime(value) {
+	if (typeof value !== "number" || value === 0) return void 0;
+	return value;
+}
+//#endregion
 //#region lib/types/tools/delivery.js
 /** Every mh-browser tool result's `meta.by`; a result without it is not a delivery. */
 const META_BY = "mh-browser";
@@ -1370,9 +1496,9 @@ const OPS = [
 		},
 		build: async (args) => ({
 			kind: "wait_for",
-			...typeof args.text === "string" ? { text: args.text } : {},
-			...typeof args.textGone === "string" ? { textGone: args.textGone } : {},
-			...typeof args.time === "number" ? { time: args.time } : {}
+			...stringField("text", args.text),
+			...stringField("textGone", args.textGone),
+			...timeField(args.time)
 		})
 	},
 	{
@@ -1399,7 +1525,7 @@ const OPS = [
 		filename: true,
 		build: async (args) => ({
 			kind: "snapshot",
-			...typeof args.target === "string" ? { target: args.target } : {},
+			...stringField("target", args.target),
 			...typeof args.depth === "number" ? { depth: args.depth } : {},
 			...args.boxes === true ? { boxes: true } : {}
 		})
@@ -1428,8 +1554,8 @@ const OPS = [
 		filename: true,
 		build: async (args) => ({
 			kind: "find",
-			...typeof args.text === "string" ? { text: args.text } : {},
-			...typeof args.regex === "string" ? { regex: args.regex } : {},
+			...stringField("text", args.text),
+			...stringField("regex", args.regex),
 			...typeof args.maxResults === "number" ? { maxResults: args.maxResults } : {}
 		})
 	},
@@ -1473,7 +1599,7 @@ const OPS = [
 		build: async (args) => ({
 			kind: "take_screenshot",
 			...typeof args.element === "string" ? { element: args.element } : {},
-			...typeof args.target === "string" ? { target: args.target } : {},
+			...stringField("target", args.target),
 			...args.type === "png" || args.type === "jpeg" || args.type === "webp" ? { type: args.type } : {},
 			...args.fullPage === true ? { fullPage: true } : {},
 			...args.scale === "css" || args.scale === "device" ? { scale: args.scale } : {}
@@ -1507,7 +1633,7 @@ const OPS = [
 			function: string(args.function),
 			callId: callIdOf(exec),
 			...typeof args.element === "string" ? { element: args.element } : {},
-			...typeof args.target === "string" ? { target: args.target } : {}
+			...stringField("target", args.target)
 		})
 	}
 ];
@@ -1542,7 +1668,7 @@ function defineOperation(ctx, reader, spec) {
 			const target = writeTarget(ctx, session);
 			ctx.mhBrowser.noteWorkspace(session.id, target);
 			const input = args;
-			const filename = spec.filename === true && typeof input.filename === "string" ? input.filename : void 0;
+			const filename = spec.filename === true ? givenString(input.filename) : void 0;
 			if (filename !== void 0) await assertInside(target, filename);
 			try {
 				const tab = tabOf(reader, session, args.tab);
@@ -1600,6 +1726,18 @@ function string(value) {
 function stringList$1(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
+function stringField(key, value) {
+	const given = givenString(value);
+	if (given === void 0) return {};
+	if (key === "target") return { target: given };
+	if (key === "text") return { text: given };
+	if (key === "textGone") return { textGone: given };
+	return { regex: given };
+}
+function timeField(value) {
+	const given = givenTime(value);
+	return given === void 0 ? {} : { time: given };
+}
 function optionalString(args, key) {
 	return typeof args[key] === "string" ? { element: args[key] } : {};
 }
@@ -1911,6 +2049,8 @@ function takeoverText(taken) {
 }
 //#endregion
 //#region lib/types/presence/register.js
+/** A presence read that stops answering. One stuck page must not hold the next step. */
+const CHECK_MS = 6e4;
 const BROWSER_TOOLS = /* @__PURE__ */ new Set([
 	"browser_open",
 	"browser_invoke",
@@ -1931,14 +2071,17 @@ function registerPresence(ctx, reader) {
 	ctx.effect(() => () => {
 		lifetime.abort();
 	});
-	const waitForChecks = async (agent) => {
+	const waitForChecks = async (agent, signal) => {
 		let pending;
-		while ((pending = tails.get(agent)) !== void 0) await pending;
+		while ((pending = tails.get(agent)) !== void 0) {
+			await untilAborted(pending, signal).catch(() => void 0);
+			if (signal.aborted) return;
+		}
 	};
 	const queue = (agent, urls) => {
 		const current = (tails.get(agent) ?? Promise.resolve()).then(async () => {
 			if (lifetime.signal.aborted) return;
-			const reminder = await ctx.mhBrowser.presenceCheck(agent.session.id, urls, { signal: lifetime.signal });
+			const reminder = await ctx.mhBrowser.presenceCheck(agent.session.id, urls, { signal: AbortSignal.any([lifetime.signal, AbortSignal.timeout(CHECK_MS)]) });
 			if (reminder === void 0 || lifetime.signal.aborted) return;
 			syncInbox(agent, reader.presence(agent.session), [], reminderMessage(reminder));
 		}).catch((error) => {
@@ -2015,7 +2158,7 @@ function registerPresence(ctx, reader) {
 		agents.set(agent.session.id, agent);
 		const handed = messages.some((message) => message.source.kind === "user") ? ctx.mhBrowser.takePersonHandback(agent.session.id) : void 0;
 		if (handed !== void 0 && handed.urls.length > 0) queue(agent, handed.urls);
-		await waitForChecks(agent);
+		await waitForChecks(agent, signal);
 		signal.throwIfAborted();
 		const desired = await compose(ctx.mhBrowser, agent, reader.presence(agent.session), messages, signal);
 		signal.throwIfAborted();
@@ -2159,11 +2302,10 @@ function record(value) {
 	return {};
 }
 function checkOptions(signal, extra) {
-	const options = {};
+	const options = { signal: capped(signal, CHECK_MS) };
 	if (extra?.baseline === true) options.baseline = true;
 	if (extra?.replaces === true) options.replaces = true;
 	if (extra?.force === true) options.force = true;
-	if (signal !== void 0) options.signal = signal;
 	return options;
 }
 function canonical$1(url) {
@@ -2930,17 +3072,268 @@ function sameOrigin$1(left, right) {
 	}
 }
 //#endregion
-//#region lib/types/service/browser.js
-const MISSING = {
-	chrome: "Google Chrome not found; install it, or change `browser` in the configuration",
-	msedge: "Microsoft Edge not found; install it, or change `browser` in the configuration",
-	chromium: "Playwright's Chromium not found; install it, or change `browser` in the configuration"
+//#region lib/types/service/locate.js
+const MAC_APP = {
+	chrome: [
+		"Google Chrome.app",
+		"Contents",
+		"MacOS",
+		"Google Chrome"
+	],
+	msedge: [
+		"Microsoft Edge.app",
+		"Contents",
+		"MacOS",
+		"Microsoft Edge"
+	]
+};
+const LINUX_PATH = {
+	chrome: "/opt/google/chrome/chrome",
+	msedge: "/opt/microsoft/msedge/msedge"
 };
-function missingExecutable(error) {
-	const message = error instanceof Error ? error.message : String(error);
-	return /ENOENT|doesn.t exist|Executable doesn't exist|not found/i.test(message);
+const WIN_SUFFIX = {
+	chrome: "Google\\Chrome\\Application\\chrome.exe",
+	msedge: "Microsoft\\Edge\\Application\\msedge.exe"
+};
+const MAC_BUNDLE = {
+	chrome: {
+		id: "com.google.Chrome",
+		binary: "Google Chrome"
+	},
+	msedge: {
+		id: "com.microsoft.edgemac",
+		binary: "Microsoft Edge"
+	}
+};
+const LINUX_NAMES = {
+	chrome: ["google-chrome-stable", "google-chrome"],
+	msedge: ["microsoft-edge-stable", "microsoft-edge"]
+};
+const WIN_EXE = {
+	chrome: "chrome.exe",
+	msedge: "msedge.exe"
+};
+const TITLE = {
+	chrome: "Google Chrome",
+	msedge: "Microsoft Edge"
+};
+const DISCOVER_MS = 2e3;
+/** The fixed paths checked for `browser` on `env`, in the order they are tried. */
+function candidatePaths(browser, env) {
+	if (env.platform === "darwin") return ["/Applications", posix.join(env.home, "Applications")].map((root) => posix.join(root, ...MAC_APP[browser]));
+	if (env.platform === "linux") return [LINUX_PATH[browser]];
+	if (env.platform !== "win32") return [];
+	const drive = env.env.HOMEDRIVE;
+	const roots = [
+		env.env.LOCALAPPDATA,
+		env.env.PROGRAMFILES,
+		env.env["PROGRAMFILES(X86)"],
+		typeof drive === "string" && drive !== "" ? `${drive}\\Program Files` : void 0,
+		typeof drive === "string" && drive !== "" ? `${drive}\\Program Files (x86)` : void 0
+	];
+	const suffix = WIN_SUFFIX[browser];
+	const paths = [];
+	for (const root of roots) {
+		if (root === void 0 || root === "") continue;
+		paths.push(win32.join(root, suffix));
+	}
+	return paths;
 }
 /**
+* `configured` is used as given: a path that cannot be run is a failure, and
+* nothing else is searched. `~` expands to `env.home`.
+*/
+function checkConfigured(configured, env) {
+	const path = expandHome(configured, env.home, env.platform);
+	if (!(env.platform === "win32" ? win32 : posix).isAbsolute(path)) return {
+		ok: false,
+		path,
+		code: "not-absolute"
+	};
+	const access = env.access(path);
+	if (access !== "ok") return {
+		ok: false,
+		path,
+		code: access.code
+	};
+	return {
+		ok: true,
+		path
+	};
+}
+/** Failure for a path the configuration names. */
+function configuredPathError(path, code) {
+	if (code === "not-absolute") return /* @__PURE__ */ new Error(`The configured browser path must be absolute: ${path}`);
+	return /* @__PURE__ */ new Error(`The configured browser path cannot be run (${code}): ${path}`);
+}
+/** Failure listing every path that was tried. */
+function browserNotFoundError(browser, missing) {
+	const tried = missing.map((item) => `${item.path} (${item.reason})`).join("; ");
+	const detail = tried === "" ? "" : ` Tried: ${tried}.`;
+	return /* @__PURE__ */ new Error(`${TITLE[browser]} not found.${detail} Install it, or set the browser's path in the configuration.`);
+}
+/**
+* The path to launch. A configured path is checked and never replaced.
+* `chromium` without one returns undefined, so Playwright uses its own build.
+* An installed browser that cannot be found throws.
+*/
+async function resolveExecutable(browser, configured, env, signal) {
+	if (configured !== void 0 && configured !== "") {
+		const checked = checkConfigured(configured, env);
+		if (!checked.ok) throw configuredPathError(checked.path, checked.code);
+		return checked.path;
+	}
+	if (browser === "chromium") return void 0;
+	const located = await locateInstalled(browser, env, signal);
+	if ("found" in located) return located.found;
+	throw browserNotFoundError(browser, located.missing);
+}
+/**
+* Where `browser` is installed when the configuration names no path.
+* Fixed candidates first, then `env.discover`.
+*/
+async function locateInstalled(browser, env, signal) {
+	const missing = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (path) => {
+		if (seen.has(path)) return void 0;
+		seen.add(path);
+		const access = env.access(path);
+		if (access === "ok") return path;
+		missing.push({
+			path,
+			reason: reasonForCode(access.code)
+		});
+	};
+	for (const path of candidatePaths(browser, env)) {
+		const found = visit(path);
+		if (found !== void 0) return { found };
+	}
+	if (signal?.aborted === true) return { missing };
+	for (const path of await env.discover(browser, signal)) {
+		const found = visit(path);
+		if (found !== void 0) return { found };
+	}
+	return { missing };
+}
+/** `path` is Playwright's Chromium. Missing or not executable is `missing`. */
+function locateBundled(path, access) {
+	const result = access(path);
+	if (result === "ok") return { found: path };
+	return { missing: [{
+		path,
+		reason: reasonForCode(result.code)
+	}] };
+}
+/** This machine: fixed paths, then Spotlight, App Paths, or `PATH`. */
+function hostLocateEnv() {
+	const env = {
+		platform: process.platform,
+		env: process.env,
+		home: homedir(),
+		access: accessFile,
+		discover: (browser, signal) => discoverInstalled(browser, env, signal)
+	};
+	return env;
+}
+/** A `.app` bundle path reported by Spotlight, turned into its executable. */
+function executableInApp(reported, binary) {
+	const at = reported.indexOf(".app");
+	if (at < 0) return void 0;
+	return posix.join(reported.slice(0, at + 4), "Contents", "MacOS", binary);
+}
+/** The default value from `reg query ... /ve` output. */
+function regValue(stdout) {
+	for (const line of stdout.split(/\r?\n/)) {
+		const value = /\bREG_(?:EXPAND_)?SZ\s+(\S.*?)\s*$/.exec(line)?.[1]?.trim();
+		if (value !== void 0 && value !== "") return value;
+	}
+}
+/** Text for an errno from {@link LocateEnv.access}. */
+function reasonForCode(code) {
+	if (code === "ENOENT" || code === "ENOTDIR") return "does not exist";
+	if (code === "EISDIR") return "is a directory";
+	return `permission denied: ${code}`;
+}
+function expandHome(configured, home, platform) {
+	const slash = platform === "win32" ? win32 : posix;
+	if (configured === "~") return home;
+	if (configured.startsWith("~/") || configured.startsWith("~\\")) return slash.join(home, configured.slice(2));
+	return configured;
+}
+function accessFile(path) {
+	try {
+		if (statSync(path).isDirectory()) return { code: "EISDIR" };
+		accessSync(path, constants.X_OK);
+		return "ok";
+	} catch (error) {
+		return { code: error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : "EACCES" };
+	}
+}
+async function discoverInstalled(browser, env, signal) {
+	try {
+		if (env.platform === "darwin") return await discoverMac(browser, signal);
+		if (env.platform === "win32") return await discoverWindows(browser, signal);
+		if (env.platform === "linux") return discoverLinux(browser, env);
+	} catch {}
+	return [];
+}
+async function discoverMac(browser, signal) {
+	const bundle = MAC_BUNDLE[browser];
+	const stdout = await command("mdfind", [`kMDItemCFBundleIdentifier == '${bundle.id}'`], signal);
+	const found = [];
+	for (const line of stdout.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (trimmed === "") continue;
+		const executable = executableInApp(trimmed, bundle.binary);
+		if (executable !== void 0) found.push(executable);
+	}
+	return found;
+}
+async function discoverWindows(browser, signal) {
+	const exe = WIN_EXE[browser];
+	const found = [];
+	for (const hive of ["HKCU", "HKLM"]) {
+		const value = regValue(await command("reg", [
+			"query",
+			`${hive}\\Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\${exe}`,
+			"/ve"
+		], signal));
+		if (value !== void 0) found.push(value);
+	}
+	return found;
+}
+function discoverLinux(browser, env) {
+	const entries = (env.env.PATH ?? "").split(posix.delimiter);
+	const found = [];
+	for (const name of LINUX_NAMES[browser]) for (const dir of entries) {
+		if (dir === "") continue;
+		const candidate = posix.join(dir, name);
+		if (env.access(candidate) !== "ok") continue;
+		try {
+			found.push(realpathSync(candidate));
+		} catch {
+			found.push(candidate);
+		}
+	}
+	return found;
+}
+function command(file, args, signal) {
+	if (signal?.aborted === true) return Promise.resolve("");
+	const timer = AbortSignal.timeout(DISCOVER_MS);
+	const stop = signal === void 0 ? timer : AbortSignal.any([signal, timer]);
+	return new Promise((resolve) => {
+		execFile(file, args, {
+			windowsHide: true,
+			signal: stop
+		}, (error, stdout) => {
+			resolve(error ? "" : String(stdout));
+		});
+	});
+}
+//#endregion
+//#region lib/types/service/browser.js
+/**
 * Playwright appends `--no-sandbox` unless this is true, and branded Chrome
 * then warns that stability and security will suffer. An installed browser
 * sandboxes on every platform. Playwright's own Chromium does too, except on
@@ -2950,34 +3343,45 @@ function chromiumSandboxEnabled(browser, platform = process.platform) {
 	return platform !== "linux" || browser !== "chromium";
 }
 /**
-* One persistent context for the whole process. `chromium` omits `channel`
-* so Playwright uses its own browser; the others use a local install.
-* A missing browser is reported and not downloaded.
+* One persistent context for the whole process. An installed browser is located
+* here and passed as `executablePath`; `channel` names which install that was.
+* `chromium` omits `channel` so Playwright uses its own browser unless a path
+* is configured. A missing browser is reported and not downloaded. A launch
+* that fails after the executable was found is reported as Playwright said.
 */
-async function launchBrowser(options) {
+async function launchBrowser(options, env = hostLocateEnv()) {
 	await mkdir(options.profileDir, { recursive: true });
+	const executablePath = await resolveExecutable(options.browser, options.executablePath, env);
+	return chromium.launchPersistentContext(options.profileDir, {
+		headless: options.headless,
+		acceptDownloads: true,
+		chromiumSandbox: chromiumSandboxEnabled(options.browser),
+		...options.headless ? {} : {
+			viewport: null,
+			ignoreDefaultArgs: ["--disable-extensions"],
+			args: [
+				"--enable-unsafe-extension-debugging",
+				"--keep-alive-for-test",
+				"--disable-blink-features=AutomationControlled",
+				"--test-type"
+			]
+		},
+		...options.browser === "chromium" ? {} : { channel: options.browser },
+		...executablePath !== void 0 ? { executablePath } : {}
+	});
+}
+/** Playwright's own Chromium, or why that file cannot be run. */
+function bundledChromiumLocation(access) {
+	let path;
 	try {
-		return await chromium.launchPersistentContext(options.profileDir, {
-			headless: options.headless,
-			acceptDownloads: true,
-			chromiumSandbox: chromiumSandboxEnabled(options.browser),
-			...options.headless ? {} : {
-				viewport: null,
-				ignoreDefaultArgs: ["--disable-extensions"],
-				args: [
-					"--enable-unsafe-extension-debugging",
-					"--keep-alive-for-test",
-					"--disable-blink-features=AutomationControlled",
-					"--test-type"
-				]
-			},
-			...options.browser === "chromium" ? {} : { channel: options.browser },
-			...options.executablePath !== void 0 ? { executablePath: options.executablePath } : {}
-		});
+		path = chromium.executablePath();
 	} catch (error) {
-		if (missingExecutable(error) || options.executablePath !== void 0) throw new Error(MISSING[options.browser]);
-		throw error;
+		return { missing: [{
+			path: "chromium",
+			reason: error instanceof Error ? error.message : "does not exist"
+		}] };
 	}
+	return locateBundled(path, access);
 }
 /**
 * Process id of the browser's main process. Playwright gives none for a
@@ -3040,6 +3444,15 @@ var Control = class {
 	tabs = /* @__PURE__ */ new Map();
 	since = /* @__PURE__ */ new Map();
 	named = /* @__PURE__ */ new Map();
+	/**
+	* A handover is waiting, or the person holds a tab. The browser is not
+	* restarted out from under either.
+	*/
+	busy() {
+		if (this.holding.size > 0) return true;
+		for (const who of this.who.values()) if (who === "person") return true;
+		return false;
+	}
 	/** Whether the person holds any tab, or a handover is waiting. */
 	of(owner) {
 		return this.who.get(owner) ?? "model";
@@ -3684,6 +4097,8 @@ async function dispatch(page, op, snapshot, signal) {
 //#region lib/types/service/evaluate.js
 /** How long requests the function started are still collected after it returns. */
 const SETTLE_MS$1 = 50;
+/** A debugger call or a detach the page no longer answers. */
+const CALL_MS$2 = 15e3;
 /**
 * Run the expression in the page and collect write requests.
 * A request is from this call when its initiator stack, including parents,
@@ -3693,7 +4108,8 @@ const SETTLE_MS$1 = 50;
 */
 async function evaluateMarked(page, source, target, callId, signal, dialog) {
 	const marker = `mh-evaluate-${callId}-${randomUUID().slice(0, 8)}`;
-	const client = await page.context().newCDPSession(page);
+	const limit = capped(signal, CALL_MS$2);
+	const client = await untilAborted(page.context().newCDPSession(page), limit);
 	const notes = /* @__PURE__ */ new Map();
 	const onRequest = (event) => {
 		const method = event.request?.method?.toUpperCase();
@@ -3713,10 +4129,10 @@ async function evaluateMarked(page, source, target, callId, signal, dialog) {
 	const stop = whenAborted(signal);
 	let dialogOpen = false;
 	try {
-		await client.send("Network.enable");
-		await client.send("Debugger.enable");
-		await client.send("Debugger.setSkipAllPauses", { skip: true });
-		await client.send("Debugger.setAsyncCallStackDepth", { maxDepth: 32 });
+		await untilAborted(client.send("Network.enable"), limit);
+		await untilAborted(client.send("Debugger.enable"), limit);
+		await untilAborted(client.send("Debugger.setSkipAllPauses", { skip: true }), limit);
+		await untilAborted(client.send("Debugger.setAsyncCallStackDepth", { maxDepth: 32 }), limit);
 		const evaluation = (target === void 0 ? page.evaluate(runSource, {
 			expr: source,
 			marker
@@ -3768,7 +4184,7 @@ async function evaluateMarked(page, source, target, callId, signal, dialog) {
 		stop.dispose();
 		client.off("Network.requestWillBeSent", onRequest);
 		const detached = client.detach().catch(() => void 0);
-		if (!dialogOpen) await detached;
+		if (!dialogOpen) await untilAborted(detached, capped(signal, CALL_MS$2)).catch(() => void 0);
 	}
 }
 /** One line per group: `POST https://site × 2 (this call)`. */
@@ -4166,6 +4582,8 @@ const REPLIED = "继续";
 //#region lib/types/service/extension.js
 const PACKAGE = "@mind-harness/mh-browser";
 const WORKER_MS = 15e3;
+/** A service-worker call that does not answer. The caller's signal can end it sooner. */
+const CALL_MS$1 = 15e3;
 /**
 * Directory of the unpacked extension shipped with this package.
 * Walks up from this module: sources live in `src/`, the bundle in `lib/`.
@@ -4205,8 +4623,9 @@ var Extension = class Extension {
 		return `chrome-extension://${this.id}/${name}`;
 	}
 	/** `chrome.tabs.create` in the named window. Returns the extension's tab id. */
-	async createTab(windowId, url) {
-		return (await this.worker()).evaluate(async (arg) => {
+	async createTab(windowId, url, signal) {
+		const worker = await this.worker(signal);
+		return this.answer(worker.evaluate(async (arg) => {
 			const tab = await globalThis.chrome.tabs.create({
 				windowId: arg.windowId,
 				url: arg.url,
@@ -4217,23 +4636,25 @@ var Extension = class Extension {
 		}, {
 			windowId,
 			url
-		});
+		}), signal);
 	}
-	async tabIdsIn(windowId) {
-		return (await this.worker()).evaluate(async (target) => {
+	async tabIdsIn(windowId, signal) {
+		const worker = await this.worker(signal);
+		return this.answer(worker.evaluate(async (target) => {
 			return (await globalThis.chrome.tabs.query({ windowId: target })).flatMap((tab) => tab.id === void 0 ? [] : [tab.id]);
-		}, windowId);
+		}, windowId), signal);
 	}
-	async activate(tabId) {
-		await (await this.worker()).evaluate(async (id) => {
+	async activate(tabId, signal) {
+		const worker = await this.worker(signal);
+		await this.answer(worker.evaluate(async (id) => {
 			await globalThis.chrome.tabs.update(id, { active: true });
-		}, tabId);
+		}, tabId), signal);
 	}
-	async group(tabId, target) {
-		const worker = await this.worker();
+	async group(tabId, target, signal) {
+		const worker = await this.worker(signal);
 		if ("groupId" in target) {
 			const groupId = target.groupId;
-			return worker.evaluate(async (arg) => {
+			return this.answer(worker.evaluate(async (arg) => {
 				return globalThis.chrome.tabs.group({
 					tabIds: [arg.tabId],
 					groupId: arg.groupId
@@ -4241,10 +4662,10 @@ var Extension = class Extension {
 			}, {
 				tabId,
 				groupId
-			});
+			}), signal);
 		}
 		const windowId = target.windowId;
-		return worker.evaluate(async (arg) => {
+		return this.answer(worker.evaluate(async (arg) => {
 			return globalThis.chrome.tabs.group({
 				tabIds: [arg.tabId],
 				createProperties: { windowId: arg.windowId }
@@ -4252,10 +4673,11 @@ var Extension = class Extension {
 		}, {
 			tabId,
 			windowId
-		});
+		}), signal);
 	}
-	async styleGroup(groupId, title, color) {
-		await (await this.worker()).evaluate(async (arg) => {
+	async styleGroup(groupId, title, color, signal) {
+		const worker = await this.worker(signal);
+		await this.answer(worker.evaluate(async (arg) => {
 			await globalThis.chrome.tabGroups.update(arg.groupId, {
 				title: arg.title,
 				color: arg.color
@@ -4264,17 +4686,21 @@ var Extension = class Extension {
 			groupId,
 			title,
 			color
-		});
+		}), signal);
 	}
-	async ungroup(tabId) {
-		await (await this.worker()).evaluate(async (id) => {
+	async ungroup(tabId, signal) {
+		const worker = await this.worker(signal);
+		await this.answer(worker.evaluate(async (id) => {
 			await globalThis.chrome.tabs.ungroup(id);
-		}, tabId);
+		}, tabId), signal);
+	}
+	answer(pending, signal) {
+		return untilAborted(pending, capped(signal, CALL_MS$1));
 	}
-	async worker() {
+	async worker(signal) {
 		const current = this.workerPage;
 		if (current !== void 0 && this.context.serviceWorkers().includes(current)) return current;
-		const worker = await findWorker(this.context, this.id);
+		const worker = await untilAborted(findWorker(this.context, this.id), capped(signal, CALL_MS$1));
 		this.workerPage = worker;
 		return worker;
 	}
@@ -4300,6 +4726,10 @@ async function findWorker(context, id, timeoutMs = WORKER_MS) {
 const TAB_CAP = 8;
 /** How long a new window or tab may take to appear. */
 const TARGET_MS = 5e3;
+/** A CDP or extension call that does not answer. The caller's signal can end it sooner. */
+const CALL_MS = 15e3;
+/** Closing a page the renderer no longer answers. */
+const CLOSE_MS = 5e3;
 const WORLD = "mh-browser";
 const BINDING = "mhBrowserInput";
 const LISTENER = `(() => {
@@ -4521,10 +4951,10 @@ var Windows = class {
 		return open.reduce((best, tab) => tab.touchedAt >= best.touchedAt ? tab : best);
 	}
 	/** Make this tab the current one in its window. Does not raise the browser. */
-	async activate(tab) {
+	async activate(tab, signal) {
 		const extension = this.extension;
 		if (extension === void 0 || tab.chromeTabId === void 0) return;
-		await extension.activate(tab.chromeTabId);
+		await extension.activate(tab.chromeTabId, signal);
 	}
 	/** Group title for the person. Empty until a title is known. */
 	setTitle(owner, title) {
@@ -4551,54 +4981,70 @@ var Windows = class {
 	* use the extension. Without a window, later pages use `window.open` from
 	* an isolated world so they stay in that window.
 	*/
-	openBlank(owner) {
+	openBlank(owner, signal) {
 		this.pendingCreates.set(owner, (this.pendingCreates.get(owner) ?? 0) + 1);
-		const create = () => this.createTab(owner);
-		const run = this.creating.then(create, create).finally(() => {
+		const queued = enqueue(this.creating, () => this.createTab(owner, signal), signal);
+		const run = queued.run.finally(() => {
 			const left = (this.pendingCreates.get(owner) ?? 1) - 1;
 			if (left <= 0) this.pendingCreates.delete(owner);
 			else this.pendingCreates.set(owner, left);
 		});
-		this.creating = run.catch(() => void 0);
+		this.creating = queued.tail;
 		return run;
 	}
-	async createTab(owner) {
+	async createTab(owner, signal) {
 		const extension = this.extension;
 		if (extension === void 0) {
-			const opener = await this.openerFor(owner);
-			const page = await this.openTabIn(opener);
-			return this.keep(owner, page, void 0);
+			const opener = await this.openerFor(owner, signal);
+			const page = await this.openTabIn(opener, signal);
+			return this.keep(owner, page, void 0, void 0, signal);
 		}
 		const open = this.owned(owner);
 		if (open.length === 0) {
-			const page = await this.openWindow();
-			const windowId = await this.windowIdOf(page);
-			const chromeTabId = await this.extensionTabIn(extension, windowId);
-			const tab = await this.keep(owner, page, chromeTabId);
-			this.groupTab(tab);
+			const page = await this.openWindow(signal);
+			const windowId = await this.windowIdOf(page, signal);
+			const chromeTabId = await this.extensionTabIn(extension, windowId, signal);
+			const tab = await this.keep(owner, page, chromeTabId, void 0, signal);
+			this.groupTab(tab, signal);
 			return tab;
 		}
 		const anchor = open.reduce((best, tab) => tab.touchedAt >= best.touchedAt ? tab : best);
-		const opened = await this.openTabViaExtension(anchor.windowId);
-		const tab = await this.keep(owner, opened.page, opened.chromeTabId, anchor.windowId);
-		this.groupTab(tab);
+		const opened = await this.openTabViaExtension(anchor.windowId, signal);
+		const tab = await this.keep(owner, opened.page, opened.chromeTabId, anchor.windowId, signal);
+		this.groupTab(tab, signal);
 		return tab;
 	}
-	async keep(owner, page, chromeTabId, windowId) {
-		const tab = {
-			id: await this.allocate(),
-			owner,
-			page,
-			targetId: await this.targetIdOf(page),
-			windowId: windowId ?? await this.windowIdOf(page),
-			chromeTabId,
-			url: page.url(),
-			touchedAt: Date.now(),
-			...idleTab()
-		};
-		this.remember(tab);
-		await this.arm(page, owner, tab.id);
-		return tab;
+	async keep(owner, page, chromeTabId, windowId, signal) {
+		let tab;
+		try {
+			tab = {
+				id: await this.allocate(),
+				owner,
+				page,
+				targetId: await this.targetIdOf(page, signal),
+				windowId: windowId ?? await this.windowIdOf(page, signal),
+				chromeTabId,
+				url: page.url(),
+				touchedAt: Date.now(),
+				...idleTab()
+			};
+			this.remember(tab);
+			await this.arm(page, owner, tab.id, signal);
+			return tab;
+		} catch (error) {
+			if (tab !== void 0 && this.byPage.get(page) === tab) await this.closePage(tab);
+			else await this.shutdown(page);
+			throw error;
+		}
+	}
+	/** The page from a create, or close it when this wait is abandoned. */
+	async claimedPage(pending, signal) {
+		try {
+			return await untilAborted(pending, capped(signal, TARGET_MS));
+		} catch (error) {
+			pending.then((page) => this.shutdown(page)).catch(() => void 0);
+			throw error;
+		}
 	}
 	/**
 	* Close one tab. `note` is listed in the next `<tabs>` block. A tab the
@@ -4612,9 +5058,12 @@ var Windows = class {
 		}
 		await this.closePage(tab);
 	}
-	async closeOwner(owner) {
-		for (const tab of this.owned(owner)) await this.closePage(tab);
-		await this.closeOpener(owner);
+	async closeOwner(owner, signal) {
+		for (const tab of this.owned(owner)) {
+			if (signal?.aborted === true) break;
+			await this.closePage(tab);
+		}
+		if (signal?.aborted !== true) await this.closeOpener(owner);
 		this.closedNotes.delete(owner);
 		for (const [id, last] of this.lastUrls) if (last.owner === owner) this.lastUrls.delete(id);
 		this.groups.delete(owner);
@@ -4632,7 +5081,7 @@ var Windows = class {
 		}
 		this.serviceClose.add(tab.page);
 		this.forget(tab);
-		if (!tab.page.isClosed()) await tab.page.close().catch(() => void 0);
+		if (!tab.page.isClosed()) await this.shutdown(tab.page);
 	}
 	/** A tab leaves the registry. The window closes with its last tab. */
 	forget(tab) {
@@ -4660,7 +5109,7 @@ var Windows = class {
 		session?.detach().catch(() => void 0);
 		if (opener.isClosed()) return;
 		this.serviceClose.add(opener);
-		await opener.close().catch(() => void 0);
+		await this.shutdown(opener);
 	}
 	/** Close least-recently touched idle tabs until the owner is within the cap. */
 	async enforceCap(owner) {
@@ -4707,57 +5156,58 @@ var Windows = class {
 		await writeCounter(this.profileDir, this.nextId);
 		return id;
 	}
-	async openerFor(owner) {
+	async openerFor(owner, signal) {
 		const existing = this.openers.get(owner);
 		if (existing !== void 0 && !existing.isClosed()) return existing;
-		const opener = await this.openWindow();
+		const opener = await this.openWindow(signal);
 		this.openers.set(owner, opener);
-		await this.arm(opener, owner, void 0);
+		await this.arm(opener, owner, void 0, signal);
 		return opener;
 	}
-	async openWindow() {
+	async openWindow(signal) {
 		const session = this.browserSession;
 		if (session === void 0) throw new Error("browser is not running");
-		const created = await this.createWindowTarget(session);
-		return this.waitForTarget(created.targetId);
+		const created = await this.createWindowTarget(session, signal);
+		const pending = this.waitForTarget(created.targetId);
+		return this.claimedPage(pending, signal);
 	}
 	/** Headed windows pass `focus: false`. A browser that rejects it is opened without the flag. */
-	async createWindowTarget(session) {
+	async createWindowTarget(session, signal) {
 		const base = {
 			url: "about:blank",
 			newWindow: true
 		};
-		if (!this.headed) return await session.send("Target.createTarget", base);
+		if (!this.headed) return this.cdp(session, "Target.createTarget", base, signal);
 		try {
-			return await session.send("Target.createTarget", {
+			return await this.cdp(session, "Target.createTarget", {
 				...base,
 				focus: false
-			});
-		} catch {
-			return await session.send("Target.createTarget", base);
+			}, signal);
+		} catch (error) {
+			if (signal?.aborted === true || isInterrupted(error)) throw error;
+			return this.cdp(session, "Target.createTarget", base, signal);
 		}
 	}
-	async openTabIn(anchor) {
-		const context = this.context;
-		if (context === void 0) throw new Error("browser is not running");
+	async openTabIn(anchor, signal) {
+		if (this.context === void 0) throw new Error("browser is not running");
 		const claim = this.claimBlank();
 		try {
-			const session = await context.newCDPSession(anchor);
+			const session = await this.pageSession(anchor, signal);
 			try {
-				const tree = await session.send("Page.getFrameTree");
-				const world = await session.send("Page.createIsolatedWorld", {
+				const tree = await this.cdp(session, "Page.getFrameTree", void 0, signal);
+				const world = await this.cdp(session, "Page.createIsolatedWorld", {
 					frameId: tree.frameTree.frame.id,
 					worldName: WORLD,
 					grantUniveralAccess: true
-				});
-				await session.send("Runtime.evaluate", {
+				}, signal);
+				await this.cdp(session, "Runtime.evaluate", {
 					expression: `window.open(${JSON.stringify(claim.url)},'_blank','noopener,noreferrer')`,
 					contextId: world.executionContextId
-				});
+				}, signal);
 			} finally {
-				await session.detach().catch(() => void 0);
+				await this.shutdownSession(session);
 			}
-			return await claim.page;
+			return await this.claimedPage(claim.page, signal);
 		} finally {
 			claim.drop();
 		}
@@ -4800,22 +5250,23 @@ var Windows = class {
 		};
 	}
 	/** The extension's id for the only tab in a window just opened. */
-	async extensionTabIn(extension, windowId) {
+	async extensionTabIn(extension, windowId, signal) {
 		for (let attempt = 0; attempt < 5; attempt += 1) {
-			const id = (await extension.tabIdsIn(windowId))[0];
+			if (signal?.aborted === true) return void 0;
+			const id = (await extension.tabIdsIn(windowId, signal))[0];
 			if (id !== void 0) return id;
-			await new Promise((resolve) => setTimeout(resolve, 100));
+			await untilAborted(new Promise((resolve) => setTimeout(resolve, 100)), signal).catch(() => void 0);
 		}
 	}
 	/** Ask the extension to open a blank tab in `windowId`, and claim it. */
-	async openTabViaExtension(windowId) {
+	async openTabViaExtension(windowId, signal) {
 		const extension = this.extension;
 		if (extension === void 0) throw new Error("browser is not running");
 		const claim = this.claimBlank();
 		try {
-			const chromeTabId = await extension.createTab(windowId, claim.url);
+			const chromeTabId = await extension.createTab(windowId, claim.url, signal);
 			return {
-				page: await claim.page,
+				page: await this.claimedPage(claim.page, signal),
 				chromeTabId
 			};
 		} finally {
@@ -4823,28 +5274,29 @@ var Windows = class {
 		}
 	}
 	/** Put a Session's tab in its group. The person's window is not a Session and stays ungrouped. */
-	async groupTab(tab) {
+	async groupTab(tab, signal) {
 		const extension = this.extension;
 		const chromeTabId = tab.chromeTabId;
 		if (extension === void 0 || chromeTabId === void 0 || tab.owner === "person") return;
 		try {
 			const known = this.groups.get(tab.owner);
-			if (known === void 0) this.groups.set(tab.owner, await extension.group(chromeTabId, { windowId: tab.windowId }));
+			if (known === void 0) this.groups.set(tab.owner, await extension.group(chromeTabId, { windowId: tab.windowId }, signal));
 			else try {
-				await extension.group(chromeTabId, { groupId: known });
-			} catch {
-				this.groups.set(tab.owner, await extension.group(chromeTabId, { windowId: tab.windowId }));
+				await extension.group(chromeTabId, { groupId: known }, signal);
+			} catch (error) {
+				if (isInterrupted(error)) return;
+				this.groups.set(tab.owner, await extension.group(chromeTabId, { windowId: tab.windowId }, signal));
 			}
-			await this.applyGroupStyle(tab.owner);
+			await this.applyGroupStyle(tab.owner, signal);
 		} catch {}
 	}
-	async applyGroupStyle(owner) {
+	async applyGroupStyle(owner, signal) {
 		const extension = this.extension;
 		const groupId = this.groups.get(owner);
 		if (extension === void 0 || groupId === void 0) return;
 		const title = this.titles.get(owner) ?? "";
 		const waiting = this.waiting.has(owner);
-		await extension.styleGroup(groupId, waiting ? `${WAITING_TITLE}${title}` : title, waiting ? "red" : "blue");
+		await extension.styleGroup(groupId, waiting ? `${WAITING_TITLE}${title}` : title, waiting ? "red" : "blue", signal);
 	}
 	async ingest(page) {
 		if (this.byPage.has(page)) return;
@@ -4866,6 +5318,10 @@ var Windows = class {
 			slot.accept(page);
 			return;
 		}
+		if (page.url().startsWith("about:blank#mh-")) {
+			await this.shutdown(page);
+			return;
+		}
 		const opener = await page.opener().catch(() => null);
 		const fromOpener = opener === null ? void 0 : this.byPage.get(opener);
 		if (fromOpener !== void 0) {
@@ -4907,10 +5363,9 @@ var Windows = class {
 	* or a close the service did not start counts as well. A page the content
 	* tab opened itself is not counted for its first navigation or its close.
 	*/
-	async arm(page, owner, tab) {
+	async arm(page, owner, tab, signal) {
 		if (this.armed.has(page)) return;
-		const context = this.context;
-		if (context === void 0) return;
+		if (this.context === void 0) return;
 		this.armed.add(page);
 		page.on("close", () => {
 			const live = this.context;
@@ -4928,19 +5383,19 @@ var Windows = class {
 		});
 		let session;
 		try {
-			session = await context.newCDPSession(page);
+			session = await this.pageSession(page, signal);
 			this.sessions.set(page, session);
-			await session.send("Runtime.enable");
-			await session.send("Page.enable");
-			await session.send("Runtime.addBinding", {
+			await this.cdp(session, "Runtime.enable", void 0, signal);
+			await this.cdp(session, "Page.enable", void 0, signal);
+			await this.cdp(session, "Runtime.addBinding", {
 				name: BINDING,
 				executionContextName: WORLD
-			});
-			await session.send("Page.addScriptToEvaluateOnNewDocument", {
+			}, signal);
+			await this.cdp(session, "Page.addScriptToEvaluateOnNewDocument", {
 				source: LISTENER,
 				worldName: WORLD,
 				runImmediately: true
-			});
+			}, signal);
 		} catch (error) {
 			if (closedTarget(error)) {
 				const known = this.byPage.get(page);
@@ -4997,21 +5452,35 @@ var Windows = class {
 		this.sessions.delete(page);
 		session?.detach().catch(() => void 0);
 	}
-	async targetIdOf(page) {
-		const context = this.context;
-		if (context === void 0) throw new Error("browser is not running");
-		const session = await context.newCDPSession(page);
+	async targetIdOf(page, signal) {
+		const session = await this.pageSession(page, signal);
 		try {
-			return (await session.send("Target.getTargetInfo")).targetInfo.targetId;
+			return (await this.cdp(session, "Target.getTargetInfo", void 0, signal)).targetInfo.targetId;
 		} finally {
-			await session.detach().catch(() => void 0);
+			await this.shutdownSession(session);
 		}
 	}
-	async windowIdOf(page) {
+	async windowIdOf(page, signal) {
 		const session = this.browserSession;
 		if (session === void 0) throw new Error("browser is not running");
-		const targetId = await this.targetIdOf(page);
-		return (await session.send("Browser.getWindowForTarget", { targetId })).windowId;
+		const targetId = await this.targetIdOf(page, signal);
+		return (await this.cdp(session, "Browser.getWindowForTarget", { targetId }, signal)).windowId;
+	}
+	pageSession(page, signal) {
+		const context = this.context;
+		if (context === void 0) return Promise.reject(/* @__PURE__ */ new Error("browser is not running"));
+		return untilAborted(context.newCDPSession(page), capped(signal, CALL_MS));
+	}
+	cdp(session, method, params, signal) {
+		const send = session.send.bind(session);
+		return untilAborted(params === void 0 ? send(method) : send(method, params), capped(signal, CALL_MS));
+	}
+	/** Close a page that may no longer answer. A stall ends at `CLOSE_MS`. */
+	shutdown(page) {
+		return untilAborted(page.close(), AbortSignal.timeout(CLOSE_MS)).catch(() => void 0);
+	}
+	shutdownSession(session) {
+		return untilAborted(session.detach(), AbortSignal.timeout(CLOSE_MS)).catch(() => void 0);
 	}
 };
 /** Playwright's error once the page, its context, or the browser has gone. */
@@ -5104,6 +5573,10 @@ const RELAUNCH_WINDOW_MS = 6e4;
 const DOCUMENT_CAP = 64;
 const OPEN_ADDRESS_REASON = "only http and https addresses are opened";
 const STOP_WAIT_MS = 5e3;
+/** A page read the renderer no longer answers. The caller's signal can end it sooner. */
+const READ_MS = 15e3;
+/** Closing one Session's windows must not wait on a renderer that stopped answering. */
+const DISPOSE_MS = 3e4;
 const WAITING_STOPPED = "stopped while waiting";
 const STOPPED = Symbol("stopped");
 const NAVIGATED_DURING_EVALUATE = "The page navigated before the function returned.";
@@ -5119,11 +5592,24 @@ const NO_WORKSPACE_REASON = "this session has no working directory";
 let MhBrowserService = (() => {
 	let _classSuper = TypertRemoteService;
 	let _instanceExtraInitializers = [];
+	let _locateFor_decorators;
 	let _revealHandover_decorators;
 	return class MhBrowserService extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_locateFor_decorators = [Remote];
 			_revealHandover_decorators = [Remote];
+			__esDecorate(this, null, _locateFor_decorators, {
+				kind: "method",
+				name: "locateFor",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "locateFor" in obj,
+					get: (obj) => obj.locateFor
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			__esDecorate(this, null, _revealHandover_decorators, {
 				kind: "method",
 				name: "revealHandover",
@@ -5142,13 +5628,23 @@ let MhBrowserService = (() => {
 				value: _metadata
 			});
 		}
-		static Config = browserConfig;
 		windows = (__runInitializers(this, _instanceExtraInitializers), new Windows());
-		launchOptions;
+		headless;
+		profileDir;
+		browserName;
+		executablePath;
+		/** Tests replace the machine lookup. Unset uses this machine. */
+		locator;
 		context;
 		pids = /* @__PURE__ */ new WeakMap();
 		ready = Promise.resolve();
 		closing = false;
+		/** A browser restart was requested and has not run yet. */
+		relaunchWanted = false;
+		/** Counts browser and path changes. A start that sampled the latest one clears the restart. */
+		configEpoch = 0;
+		/** The running browser is being closed so the new configuration can start. */
+		replacing = false;
 		/** The browser is not running. The next call that needs a page starts it. */
 		exited = true;
 		exits = [];
@@ -5167,11 +5663,16 @@ let MhBrowserService = (() => {
 		constructor(ctx, config) {
 			super(ctx, "mhBrowser");
 			this.maxBytes = config.presence.maxBytes;
-			this.launchOptions = {
-				browser: config.browser,
-				headless: config.headless,
-				profileDir: config.profileDir ?? defaultProfileDir(ctx.get("profileContext"))
-			};
+			this.headless = config.headless;
+			this.profileDir = config.profileDir ?? defaultProfileDir(ctx.get("profileContext"));
+			this.browserName = config.browser;
+			this.executablePath = config.executablePath ?? { get: () => void 0 };
+			Object.getPrototypeOf(ctx).on("loader/volatile-update", (paths) => {
+				if (!paths.some((path) => path.includes("browser") || path.includes("executablePath"))) return;
+				this.configEpoch += 1;
+				this.relaunchWanted = true;
+				this.relaunchIfIdle();
+			});
 			this.windows.setPersonInput((owner, tab) => {
 				const live = tab === void 0 ? void 0 : this.windows.get(owner, tab);
 				this.control.note(owner, tab);
@@ -5184,7 +5685,7 @@ let MhBrowserService = (() => {
 			ctx.on("session/disposed", (session) => {
 				const owner = session.id;
 				if (owner === void 0) return;
-				this.exclusive(owner, () => this.windows.closeOwner(owner)).catch((error) => {
+				this.exclusive(owner, () => this.windows.closeOwner(owner, AbortSignal.timeout(DISPOSE_MS)), AbortSignal.timeout(DISPOSE_MS)).catch((error) => {
 					ctx.logger.warn("closing the windows of %s failed: %o", owner, error);
 				});
 				this.book.forget(owner);
@@ -5206,22 +5707,30 @@ let MhBrowserService = (() => {
 		}
 		async open(owner, items, signal, options) {
 			const reveal = options?.reveal === true;
-			return this.exclusive(owner, async () => {
-				await this.up(owner === PERSON_OWNER);
-				const views = [];
-				for (const item of items) {
-					if (signal?.aborted) {
-						views.push({
-							url: item.url,
-							reason: WAITING_STOPPED
-						});
-						continue;
+			try {
+				return await this.exclusive(owner, async () => {
+					await this.up(owner === PERSON_OWNER);
+					const views = [];
+					for (const item of items) {
+						if (signal?.aborted) {
+							views.push({
+								url: item.url,
+								reason: WAITING_STOPPED
+							});
+							continue;
+						}
+						views.push(await this.openAddress(owner, item, signal, reveal));
 					}
-					views.push(await this.openAddress(owner, item, signal, reveal));
-				}
-				await this.enforceCap(owner);
-				return views;
-			});
+					await this.enforceCap(owner);
+					return views;
+				}, signal);
+			} catch (error) {
+				if (!isInterrupted(error)) throw error;
+				return items.map((item) => ({
+					url: item.url,
+					reason: WAITING_STOPPED
+				}));
+			}
 		}
 		async view(owner, tab, signal) {
 			return this.exclusive(owner, async () => {
@@ -5233,8 +5742,8 @@ let MhBrowserService = (() => {
 					url: live.url,
 					reason: WAITING_STOPPED
 				};
-				return this.refreshView(live);
-			});
+				return this.refreshView(live, signal);
+			}, signal);
 		}
 		/** Pages whose current representation is already in the model's presence. */
 		rememberPresence(owner, urls) {
@@ -5300,7 +5809,7 @@ let MhBrowserService = (() => {
 					text: planned.text,
 					record: planned.record
 				};
-			});
+			}, opts?.signal);
 		}
 		/**
 		* Where a download the page starts may be written: the session's writable
@@ -5342,7 +5851,7 @@ let MhBrowserService = (() => {
 					kind: "response",
 					finalUrl: response.url(),
 					status: response.status(),
-					body: new Uint8Array(await response.body())
+					body: new Uint8Array(await untilAborted(response.body(), capped(opts?.signal, READ_MS)))
 				};
 				const mediaType = headerMap["content-type"];
 				const etag = headerMap.etag;
@@ -5382,9 +5891,26 @@ let MhBrowserService = (() => {
 				page: (owner, tab) => this.windows.get(owner, tab)?.page,
 				running: () => this.context !== void 0,
 				pages: () => this.context?.pages() ?? [],
-				pid: () => this.context === void 0 ? void 0 : this.pids.get(this.context)
+				pid: () => this.context === void 0 ? void 0 : this.pids.get(this.context),
+				useLocator: (env) => {
+					this.locator = env;
+				}
 			};
 		}
+		/**
+		* Where `browser` would be launched from when no path is configured.
+		* The configured path is not consulted: the answer is what an empty path uses.
+		*/
+		async locateFor(browser, signal) {
+			const stopped = () => signal?.aborted === true;
+			if (stopped()) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+			if (browser !== "chrome" && browser !== "msedge" && browser !== "chromium") throw new MhBrowserError("INVALID_ARGS", "browser must be chrome, msedge, or chromium");
+			const env = this.locateEnv();
+			if (browser === "chromium") return bundledChromiumLocation(env.access);
+			const located = await locateInstalled(browser, env, signal);
+			if (stopped()) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+			return located;
+		}
 		async act(owner, tab, op, signal) {
 			return this.exclusive(owner, async () => {
 				await this.ready;
@@ -5396,7 +5922,7 @@ let MhBrowserService = (() => {
 				try {
 					if (live.dialogHeld && op.kind !== "handle_dialog") throw new MhBrowserError("MODAL_STATE", "a dialog is open; use browser_handle_dialog", await this.blockedView(live));
 					if (live.fileChooser !== void 0 && op.kind !== "file_upload") {
-						const blocked = await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" });
+						const blocked = await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" }, signal);
 						blocked.dialog = {
 							type: "filechooser",
 							message: live.fileChooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
@@ -5409,8 +5935,8 @@ let MhBrowserService = (() => {
 						else this.windows.holdInput(live);
 					} else if (outcome.navigated) this.windows.onNavigated(live);
 					this.windows.touch(live);
-					const shown = outcome.navigated ? await this.discover(live, live.page.url(), null) : await this.refreshSnapshot(live);
-					const scoped = op.kind === "snapshot" && (op.target !== void 0 || op.depth !== void 0 || op.boxes === true) ? await this.scopedSnapshot(live, op) : void 0;
+					const shown = outcome.navigated ? await this.discover(live, live.page.url(), null, signal) : await this.refreshSnapshot(live, signal);
+					const scoped = op.kind === "snapshot" && (op.target !== void 0 || op.depth !== void 0 || op.boxes === true) ? await this.scopedSnapshot(live, op, signal) : void 0;
 					this.shown.set(live.id, shown);
 					this.windows.noteUrl(live, live.page.url());
 					const view = await this.pageFromShown(live, shown, {
@@ -5418,7 +5944,7 @@ let MhBrowserService = (() => {
 						...outcome.dialog !== void 0 ? { dialog: outcome.dialog } : {},
 						...outcome.incomplete !== void 0 ? { incomplete: outcome.incomplete } : {},
 						...outcome.waited !== void 0 ? { waited: outcome.waited } : {}
-					});
+					}, signal);
 					if (scoped !== void 0 && view.representation.kind === "snapshot") view.representation = {
 						...view.representation,
 						text: scoped
@@ -5435,12 +5961,12 @@ let MhBrowserService = (() => {
 				} catch (error) {
 					if (error instanceof MhBrowserError && error.code === "TAKEN_OVER") throw error;
 					if (this.control.ofTab(owner, tab) === "person") throw await this.takenOver(live);
-					if (error instanceof MhBrowserError && error.code === "STALE_REF" && error.page === void 0) throw new MhBrowserError(error.code, error.message, await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" }));
+					if (error instanceof MhBrowserError && error.code === "STALE_REF" && error.page === void 0) throw new MhBrowserError(error.code, error.message, await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" }, signal));
 					throw error;
 				} finally {
 					linked.release();
 				}
-			});
+			}, signal);
 		}
 		holdHandover(owner, tab) {
 			const live = this.windows.get(owner, tab);
@@ -5458,15 +5984,16 @@ let MhBrowserService = (() => {
 				const live = this.windows.get(owner, tab);
 				if (live === void 0 || live.dialogHeld) return void 0;
 				try {
-					const bytes = await live.page.screenshot({
+					const limit = capped(signal, READ_MS);
+					const bytes = await untilAborted(live.page.screenshot({
 						type: "png",
-						...signal !== void 0 ? { signal } : {}
-					});
+						signal: limit
+					}), limit);
 					return new Uint8Array(bytes);
 				} catch {
 					return;
 				}
-			});
+			}, signal);
 		}
 		invoke(owner, _page, call, opts) {
 			return this.exclusive(owner, async () => {
@@ -5483,7 +6010,7 @@ let MhBrowserService = (() => {
 				}, call);
 				await this.enforceCap(owner);
 				return sent;
-			});
+			}, opts?.signal);
 		}
 		/**
 		* Not queued: it opens no tab, and a long body must not hold up the
@@ -5515,11 +6042,11 @@ let MhBrowserService = (() => {
 					const live = this.windows.get(owner, req.tab);
 					if (live === void 0) throw new MhBrowserError(UNKNOWN_TAB, UNKNOWN_TAB_REASON);
 					this.windows.holdHandover(live);
-					await this.windows.activate(live).catch(() => void 0);
+					await this.windows.activate(live, signal).catch(() => void 0);
 				}
 				this.control.handover(owner, req.tab);
 				this.windows.markWaiting(owner, true);
-			});
+			}, signal);
 		}
 		/** Remember the Session title for its tab group. Empty when the host has none. */
 		noteSessionTitle(owner, title) {
@@ -5530,7 +6057,7 @@ let MhBrowserService = (() => {
 			await this.ready;
 			const live = this.windows.latest(owner);
 			if (live === void 0) return false;
-			await live.page.bringToFront();
+			await untilAborted(live.page.bringToFront(), AbortSignal.timeout(READ_MS));
 			return true;
 		}
 		/** The person asked to see the page this Session handed over. */
@@ -5541,11 +6068,12 @@ let MhBrowserService = (() => {
 			const named = this.control.namedTab(sessionId);
 			const live = (named === void 0 ? void 0 : this.windows.get(sessionId, named)) ?? this.windows.latest(sessionId);
 			if (live === void 0) return { status: "no-tab" };
-			await live.page.bringToFront();
+			await untilAborted(live.page.bringToFront(), capped(signal, READ_MS));
 			return { status: "revealed" };
 		}
 		/** The person answered. Returns the note, the operation count, and the named tab. */
 		async handBack(owner, note) {
+			const signal = capped(void 0, READ_MS);
 			return this.exclusive(owner, async () => {
 				await this.ready;
 				const taken = this.control.finish(owner);
@@ -5554,32 +6082,36 @@ let MhBrowserService = (() => {
 				this.windows.markWaiting(owner, false);
 				const urls = this.presenceUrls(owner, taken.tabs);
 				for (const touch of this.personTouch) touch(owner, urls);
-				const page = await this.snapshotNamed(owner, taken.tab);
+				const page = await this.snapshotNamed(owner, taken.tab, signal);
 				return {
 					...taken,
 					urls,
 					...note !== void 0 && note !== "" ? { note } : {},
 					...page !== void 0 ? { page } : {}
 				};
-			});
+			}, signal);
 		}
 		/** A stopped handover gives control back. A finished hand-back is left alone. */
 		releaseIfHeld(owner) {
 			if (!this.control.releaseIfHeld(owner)) return;
 			this.windows.releaseHandover(owner);
 			this.windows.markWaiting(owner, false);
+			this.relaunchIfIdle();
 		}
 		/**
 		* The person took over between turns. The next message they send is the
 		* hand-back. A handover that is still waiting on its card is not.
+		* The addresses are read before a waiting restart closes the pages.
 		*/
 		takePersonHandback(owner) {
 			const taken = this.control.takePerson(owner);
 			if (taken === void 0) return void 0;
+			const urls = this.presenceUrls(owner, taken.tabs);
 			this.windows.releaseHandover(owner);
+			this.relaunchIfIdle();
 			return {
 				...taken,
-				urls: this.presenceUrls(owner, taken.tabs)
+				urls
 			};
 		}
 		/**
@@ -5603,7 +6135,7 @@ let MhBrowserService = (() => {
 			}
 			const opened = await this.openOne(owner, item.url, item.waitFor, signal, item.snapshot === true, reveal);
 			this.keepAgentView(opened);
-			if (!wantsTab && opened.fresh && this.closable(owner, opened.live) && "representation" in opened.view && opened.view.representation.kind === "agent-view") {
+			if (opened.live !== void 0 && !wantsTab && opened.fresh && this.closable(owner, opened.live) && "representation" in opened.view && opened.view.representation.kind === "agent-view") {
 				await this.windows.closeTab(opened.live);
 				const view = { ...opened.view };
 				delete view.tab;
@@ -5629,6 +6161,7 @@ let MhBrowserService = (() => {
 		}
 		/** A readable Agent View puts its origin on the list and keeps the document for the next read. */
 		keepAgentView(opened) {
+			if (opened.live === void 0) return;
 			if (!("representation" in opened.view)) return;
 			const representation = opened.view.representation;
 			if (!(representation.kind === "agent-view" || representation.kind === "snapshot" && representation.agentView !== void 0)) return;
@@ -5760,7 +6293,7 @@ let MhBrowserService = (() => {
 					kind: "response",
 					finalUrl: current,
 					status,
-					body: readsAsText(mediaType) ? new Uint8Array(await response.body()) : /* @__PURE__ */ new Uint8Array()
+					body: readsAsText(mediaType) ? new Uint8Array(await untilAborted(response.body(), capped(signal, READ_MS))) : /* @__PURE__ */ new Uint8Array()
 				};
 				const etag = headerMap.etag;
 				const link = headerMap.link;
@@ -5773,8 +6306,20 @@ let MhBrowserService = (() => {
 		async openOne(owner, url, waitFor, signal, snapshot = false, reveal = false) {
 			assertWaitFor(waitFor);
 			const reused = this.idleTabOn(owner, url);
-			const live = reused ?? await this.windows.openBlank(owner);
 			const fresh = reused === void 0;
+			let live;
+			try {
+				live = reused ?? await this.windows.openBlank(owner, signal);
+			} catch (error) {
+				if (signal?.aborted === true || isInterrupted(error)) return {
+					view: {
+						url,
+						reason: WAITING_STOPPED
+					},
+					fresh
+				};
+				throw error;
+			}
 			const linked = this.control.link(owner, signal, live.id);
 			if (reveal && !linked.signal.aborted) await live.page.bringToFront().catch(() => void 0);
 			const nextDialog = this.windows.nextDialog(live);
@@ -5797,7 +6342,7 @@ let MhBrowserService = (() => {
 				nextDialog.cancel();
 				if (winner === "failed" && seenDialog === void 0) {
 					if (isDownloadStart(navigationError) || live.pendingDownload !== void 0) {
-						const view = await this.pageFromShown(live, this.shown.get(live.id));
+						const view = await this.pageFromShown(live, this.shown.get(live.id), void 0, signal);
 						if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
 						this.applyDocumentType(live, view);
 						return {
@@ -5848,8 +6393,8 @@ let MhBrowserService = (() => {
 					...optionalFragment(address),
 					snapshot: "",
 					relocate: false,
-					fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch)
-				}) : await this.discover(live, address, response);
+					fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch, signal)
+				}) : await this.discover(live, address, response, signal);
 				this.shown.set(live.id, shown);
 				const view = await this.pageFromShown(live, shown, {
 					...snapshot ? { surface: "snapshot" } : {},
@@ -5859,7 +6404,7 @@ let MhBrowserService = (() => {
 					} },
 					...load.dialog !== void 0 ? { dialog: load.dialog } : {},
 					...waited !== void 0 ? { waited } : {}
-				});
+				}, signal);
 				return {
 					view: await this.attachDownload(live, view, false),
 					fresh,
@@ -5894,7 +6439,7 @@ let MhBrowserService = (() => {
 			if (op.kind === "snapshot") return { navigated: false };
 			if (op.kind === "find") return {
 				navigated: false,
-				summary: findInSnapshot(await this.aria(live), op)
+				summary: findInSnapshot(await this.aria(live, signal), op)
 			};
 			if (op.kind === "evaluate") {
 				const snapshot = this.shown.get(live.id)?.snapshot ?? "";
@@ -6086,15 +6631,16 @@ let MhBrowserService = (() => {
 			};
 		}
 		/** A snapshot limited to a target, a depth, or boxes. Refs still resolve against the full one. */
-		async scopedSnapshot(tab, op) {
+		async scopedSnapshot(tab, op, signal) {
 			const options = {
 				mode: "ai",
 				...op.depth !== void 0 ? { depth: op.depth } : {},
 				...op.boxes === true ? { boxes: true } : {}
 			};
 			const snapshot = this.shown.get(tab.id)?.snapshot ?? "";
-			if (op.target !== void 0) return (await locate(tab.page, op.target, snapshot)).ariaSnapshot(options);
-			return tab.page.ariaSnapshot(options);
+			const limit = capped(signal, READ_MS);
+			if (op.target !== void 0) return untilAborted((await locate(tab.page, op.target, snapshot)).ariaSnapshot(options), limit);
+			return untilAborted(tab.page.ariaSnapshot(options), limit);
 		}
 		/** A file chooser the action opened. The tab stays in use until it navigates. */
 		chooserHeld(live, chooser) {
@@ -6105,9 +6651,9 @@ let MhBrowserService = (() => {
 				message: chooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
 			};
 		}
-		async refreshSnapshot(tab) {
+		async refreshSnapshot(tab, signal) {
 			const previous = this.shown.get(tab.id);
-			const snapshot = tab.dialogHeld ? "" : await this.aria(tab);
+			const snapshot = tab.dialogHeld ? "" : await this.aria(tab, signal);
 			if (previous === void 0) return {
 				pageUrl: canonical(tab.page.url()),
 				digest: "",
@@ -6142,20 +6688,20 @@ let MhBrowserService = (() => {
 				this.windows.endDispatch(page);
 			}
 		}
-		async discover(tab, address, response) {
-			const main = response === null ? void 0 : await mainDocument(response);
+		async discover(tab, address, response, signal) {
+			const main = response === null ? void 0 : await mainDocument(response, signal);
 			const relocated = main !== void 0 && !samePage(main.finalUrl, address);
-			const domLinks = relocated ? [] : await readDomLinks(tab.page);
+			const domLinks = relocated ? [] : await readDomLinks(tab.page, signal);
 			const previous = this.shown.get(tab.id);
 			return loadShown({
 				pageUrl: canonical(address),
 				...optionalFragment(address),
-				snapshot: await this.aria(tab),
+				snapshot: await this.aria(tab, signal),
 				...main !== void 0 && !relocated ? { main } : {},
 				...domLinks.length > 0 ? { domLinks } : {},
 				...previous !== void 0 ? { previous } : {},
 				relocate: relocated,
-				fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch)
+				fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch, signal)
 			});
 		}
 		fetchForRead(url, accept, ifNoneMatch, signal) {
@@ -6165,13 +6711,13 @@ let MhBrowserService = (() => {
 				...signal !== void 0 ? { signal } : {}
 			});
 		}
-		async aria(tab) {
-			return tab.page.ariaSnapshot({ mode: "ai" }).catch((error) => {
+		async aria(tab, signal) {
+			return untilAborted(tab.page.ariaSnapshot({ mode: "ai" }).catch((error) => {
 				this.ctx.logger.debug("aria snapshot failed: %s", errorText(error));
 				return "";
-			});
+			}), capped(signal, READ_MS));
 		}
-		async pageFromShown(tab, shown, extra) {
+		async pageFromShown(tab, shown, extra, signal) {
 			const current = shown ?? {
 				pageUrl: canonical(tab.url),
 				digest: "",
@@ -6179,10 +6725,10 @@ let MhBrowserService = (() => {
 				text: "",
 				snapshot: ""
 			};
-			const title = tab.dialogHeld ? "" : await tab.page.title().catch((error) => {
+			const title = tab.dialogHeld ? "" : await untilAborted(tab.page.title().catch((error) => {
 				this.ctx.logger.debug("page title failed: %s", errorText(error));
 				return "";
-			});
+			}), capped(signal, READ_MS));
 			this.windows.noteTitle(tab, title);
 			const view = {
 				tab: tab.id,
@@ -6227,7 +6773,7 @@ let MhBrowserService = (() => {
 				if (via !== void 0) return observationOf(url, via);
 			}
 			const existing = this.tabOn(owner, url);
-			if (existing !== void 0) return observationOf(url, await this.refreshView(existing));
+			if (existing !== void 0) return observationOf(url, await this.refreshView(existing, signal));
 			const opened = await this.openOne(owner, url, void 0, signal, false);
 			this.keepAgentView(opened);
 			const view = opened.view;
@@ -6251,22 +6797,22 @@ let MhBrowserService = (() => {
 			tabs.sort((left, right) => right.touchedAt - left.touchedAt);
 			return tabs[0];
 		}
-		async refreshView(live) {
+		async refreshView(live, signal) {
 			this.windows.touch(live);
-			if (live.dialogHeld) return this.pageFromShown(live, this.shown.get(live.id));
+			if (live.dialogHeld) return this.pageFromShown(live, this.shown.get(live.id), void 0, signal);
 			const address = live.page.url();
 			const previous = this.shown.get(live.id);
 			const shown = await loadShown({
 				pageUrl: canonical(address),
 				...optionalFragment(address),
-				snapshot: await this.aria(live),
+				snapshot: await this.aria(live, signal),
 				...previous !== void 0 ? { previous } : {},
 				relocate: previous !== void 0 && !samePage(previous.pageUrl, address),
-				fetch: (url, accept, ifNoneMatch) => this.fetchForRead(url, accept, ifNoneMatch)
+				fetch: (url, accept, ifNoneMatch) => this.fetchForRead(url, accept, ifNoneMatch, signal)
 			});
 			this.shown.set(live.id, shown);
 			this.windows.noteUrl(live, address);
-			return this.pageFromShown(live, shown);
+			return this.pageFromShown(live, shown, void 0, signal);
 		}
 		/** The most recently touched idle tab on this address. A tab the person holds is left alone. */
 		idleTabOn(owner, url) {
@@ -6299,7 +6845,7 @@ let MhBrowserService = (() => {
 				const load = await waitForLoad(live.page, signal);
 				if (load.dialog !== void 0) this.windows.holdDialog(live);
 				this.windows.touch(live);
-				const shown = await this.discover(live, live.page.url(), response);
+				const shown = await this.discover(live, live.page.url(), response, signal);
 				this.shown.set(live.id, shown);
 				const view = await this.pageFromShown(live, shown, {
 					...load.load ? {} : { incomplete: {
@@ -6307,11 +6853,11 @@ let MhBrowserService = (() => {
 						pendingRequests: load.pendingRequests
 					} },
 					...load.dialog !== void 0 ? { dialog: load.dialog } : {}
-				});
+				}, signal);
 				return this.attachDownload(live, view, false);
 			} catch (error) {
 				if (isDownloadStart(error) || live.pendingDownload !== void 0) {
-					const view = await this.pageFromShown(live, this.shown.get(live.id));
+					const view = await this.pageFromShown(live, this.shown.get(live.id), void 0, signal);
 					if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
 					this.applyDocumentType(live, view);
 					return this.attachDownload(live, view, true);
@@ -6343,7 +6889,7 @@ let MhBrowserService = (() => {
 				return {
 					kind: "response",
 					status: response.status(),
-					body: new Uint8Array(await response.body()),
+					body: new Uint8Array(await untilAborted(response.body(), capped(signal, READ_MS))),
 					...location === void 0 || location === "" ? {} : { location },
 					...mediaType === void 0 ? {} : { mediaType }
 				};
@@ -6449,8 +6995,10 @@ let MhBrowserService = (() => {
 			return started;
 		}
 		async start() {
-			const context = await launchBrowser(this.launchOptions);
-			const pid = await browserPid(context, this.launchOptions.profileDir);
+			const choice = this.launchChoice();
+			const epoch = this.configEpoch;
+			const context = await launchBrowser(choice, this.locateEnv());
+			const pid = await browserPid(context, choice.profileDir);
 			if (pid !== void 0) this.pids.set(context, pid);
 			if (this.closing) {
 				await this.closeContext(context);
@@ -6458,15 +7006,16 @@ let MhBrowserService = (() => {
 			}
 			this.context = context;
 			try {
-				await this.windows.attach(context, this.launchOptions.profileDir, { headed: !this.launchOptions.headless });
+				await this.windows.attach(context, choice.profileDir, { headed: !choice.headless });
 			} catch (error) {
 				this.context = void 0;
 				this.windows.dropPages();
 				await this.closeContext(context);
 				throw error;
 			}
+			if (this.configEpoch === epoch) this.relaunchWanted = false;
 			context.browser()?.on("disconnected", () => {
-				if (this.closing || this.context !== context) return;
+				if (this.closing || this.replacing || this.context !== context) return;
 				this.onExit();
 			});
 		}
@@ -6537,22 +7086,81 @@ let MhBrowserService = (() => {
 			}
 			return urls;
 		}
-		async snapshotNamed(owner, tab) {
+		async snapshotNamed(owner, tab, signal) {
 			if (tab === void 0) return void 0;
 			const live = this.windows.get(owner, tab);
 			if (live === void 0) return void 0;
-			const shown = await this.refreshSnapshot(live);
+			const shown = await this.refreshSnapshot(live, signal);
 			this.shown.set(live.id, shown);
-			return this.pageFromShown(live, shown, { surface: "snapshot" });
-		}
-		exclusive(owner, op) {
-			const run = (this.queues.get(owner) ?? Promise.resolve()).then(op, op);
-			const tail = run.then(() => void 0, () => void 0);
-			this.queues.set(owner, tail);
-			tail.then(() => {
-				if (this.queues.get(owner) === tail) this.queues.delete(owner);
+			return this.pageFromShown(live, shown, { surface: "snapshot" }, signal);
+		}
+		exclusive(owner, op, signal) {
+			const queued = enqueue(this.queues.get(owner) ?? Promise.resolve(), op, signal);
+			this.queues.set(owner, queued.tail);
+			queued.tail.then(() => {
+				if (this.queues.get(owner) === queued.tail) this.queues.delete(owner);
+				if (this.queues.size === 0) this.relaunchIfIdle();
 			});
-			return run;
+			return queued.run;
+		}
+		launchChoice() {
+			const configured = this.executablePath.get();
+			return {
+				browser: this.browserName.get(),
+				headless: this.headless,
+				profileDir: this.profileDir,
+				...configured !== void 0 && configured !== "" ? { executablePath: configured } : {}
+			};
+		}
+		locateEnv() {
+			return this.locator ?? hostLocateEnv();
+		}
+		idle() {
+			return this.queues.size === 0 && !this.control.busy();
+		}
+		/**
+		* Close and start again when a configuration change is waiting and nothing
+		* is using the browser. A browser that is not running keeps the new values
+		* for the next start. The close is not counted as a crash.
+		*/
+		relaunchIfIdle() {
+			if (!this.relaunchWanted || this.closing || this.replacing) return;
+			if (!this.idle()) return;
+			if (this.context === void 0) {
+				if (this.exited) {
+					this.relaunchWanted = false;
+					return;
+				}
+				this.ready.then(() => this.relaunchIfIdle(), () => {
+					this.relaunchWanted = false;
+				});
+				return;
+			}
+			this.relaunchWanted = false;
+			this.replacing = true;
+			const run = this.replaceBrowser();
+			this.ready = run;
+			const finish = () => {
+				this.replacing = false;
+				if (this.relaunchWanted) this.relaunchIfIdle();
+			};
+			run.then(finish, finish);
+		}
+		async replaceBrowser() {
+			this.windows.suppressPersonInput();
+			const context = this.context;
+			this.context = void 0;
+			this.windows.dropPages();
+			if (context !== void 0) await this.closeContext(context);
+			if (this.closing) return;
+			this.exited = false;
+			try {
+				await this.launch();
+				this.windows.resumePersonInput();
+			} catch (error) {
+				this.exited = true;
+				throw error;
+			}
 		}
 	};
 })();
@@ -6600,24 +7208,24 @@ function fragmentOf(url) {
 		return;
 	}
 }
-async function mainDocument(response) {
+async function mainDocument(response, signal) {
 	const headers = response.headers();
 	const mediaType = headers["content-type"];
 	const link = headers.link;
 	return {
 		status: response.status(),
 		finalUrl: response.url(),
-		body: await response.text(),
+		body: await untilAborted(response.text(), capped(signal, READ_MS)),
 		...mediaType !== void 0 ? { mediaType } : {},
 		...link !== void 0 ? { link } : {}
 	};
 }
-async function readDomLinks(page) {
-	return (await page.locator("link").evaluateAll((elements) => elements.map((element) => ({
+async function readDomLinks(page, signal) {
+	return (await untilAborted(page.locator("link").evaluateAll((elements) => elements.map((element) => ({
 		rel: element.getAttribute("rel") ?? "",
 		href: element.getAttribute("href") ?? "",
 		title: element.getAttribute("title") ?? ""
-	}))).catch(() => [])).filter((row) => row.rel !== "" && row.href !== "").map((row) => ({
+	}))).catch(() => []), capped(signal, READ_MS))).filter((row) => row.rel !== "" && row.href !== "").map((row) => ({
 		rel: row.rel,
 		href: row.href,
 		...row.title !== "" ? { title: row.title } : {}
@@ -6890,9 +7498,10 @@ function browserHandoverTool(ctx, reader, headed = true) {
 			if (exec.signal.aborted) return quiet();
 			const session = sessionFor(ctx, exec);
 			try {
+				const tab = givenString(args.tab);
 				await ctx.mhBrowser.handover(session.id, {
 					reason: args.reason,
-					...args.tab === void 0 ? {} : { tab: args.tab }
+					...tab === void 0 ? {} : { tab }
 				}, exec.signal);
 				const answer = await askUntilAnswered(ctx, args.reason, exec, headed);
 				if (answer === ABORT || exec.signal.aborted) return quiet();
@@ -7036,6 +7645,7 @@ function browserInvokeTool(ctx, reader) {
 			if (resolved === void 0) throw new BrowserToolError("NOT_DELIVERED", `${NOT_DELIVERED_REASON}: ${args.page}`);
 			if ("ambiguous" in resolved) throw new BrowserToolError("INVALID_ARGS", `${args.page} is the id of more than one page shown to you; give the url of one: ${resolved.ambiguous.join(", ")}`);
 			const input = args.input === void 0 ? void 0 : asObject(args.input);
+			const item = givenString(args.item);
 			try {
 				const sent = await ctx.mhBrowser.invoke(session.id, resolved.url, {
 					name: args.name,
@@ -7043,7 +7653,7 @@ function browserInvokeTool(ctx, reader) {
 						url: resolved.url,
 						text: resolved.text
 					},
-					...args.item === void 0 ? {} : { item: args.item },
+					...item === void 0 ? {} : { item },
 					...input === void 0 ? {} : { input }
 				}, {
 					signal: exec.signal,
@@ -7168,18 +7778,19 @@ function browserOpenTool(ctx, reader) {
 		}),
 		async execute(args, exec) {
 			if (args.pages.length < 1 || args.pages.length > 8) throw new BrowserToolError("INVALID_ARGS", "pages takes 1 to 8 entries");
-			for (const page of args.pages) {
-				const waitFor = page.waitFor;
+			const items = args.pages.map((page) => {
+				const waitFor = page.waitFor === void 0 ? void 0 : compactWait(page.waitFor);
 				if (waitFor !== void 0 && waitFor.text === void 0 && waitFor.textGone === void 0 && waitFor.time === void 0) throw new BrowserToolError("INVALID_ARGS", "waitFor needs text, textGone, or time");
-			}
+				return {
+					url: page.url,
+					...page.snapshot === true ? { snapshot: true } : {},
+					...waitFor === void 0 ? {} : { waitFor }
+				};
+			});
 			const session = sessionFor(ctx, exec);
 			ctx.mhBrowser.noteWorkspace(session.id, writeTarget(ctx, session));
 			try {
-				const pages = await ctx.mhBrowser.open(session.id, args.pages.map((page) => ({
-					url: page.url,
-					...page.snapshot === true ? { snapshot: true } : {},
-					...page.waitFor === void 0 ? {} : { waitFor: compactWait(page.waitFor) }
-				})), exec.signal);
+				const pages = await ctx.mhBrowser.open(session.id, items, exec.signal);
 				const block = tabBlock(ctx, reader, session);
 				return {
 					text: `${renderOutcome(pages, void 0, true)}${block.suffix}`,
@@ -7196,10 +7807,13 @@ function browserOpenTool(ctx, reader) {
 	});
 }
 function compactWait(waitFor) {
+	const text = givenString(waitFor.text);
+	const textGone = givenString(waitFor.textGone);
+	const time = givenTime(waitFor.time);
 	return {
-		...waitFor.text !== void 0 ? { text: waitFor.text } : {},
-		...waitFor.textGone !== void 0 ? { textGone: waitFor.textGone } : {},
-		...waitFor.time !== void 0 ? { time: waitFor.time } : {}
+		...text === void 0 ? {} : { text },
+		...textGone === void 0 ? {} : { textGone },
+		...time === void 0 ? {} : { time }
 	};
 }
 function titleOf(name, url) {
@@ -7313,6 +7927,7 @@ const inject = [
 ];
 const Config = browserConfig;
 async function apply(ctx, config) {
+	const resolved = browserSettings(config);
 	ctx.plugin({
 		name: "mh-browser-slot",
 		inject: ["browserUse", "mhBrowser"],
@@ -7320,16 +7935,29 @@ async function apply(ctx, config) {
 			inner.browserUse.register("mh-browser");
 		}
 	});
-	await ctx.plugin(MhBrowserService, config);
+	await ctx.plugin(MhBrowserService, resolved);
 	await ctx.plugin({
 		name: "mh-browser-runtime",
 		inject: ["mhBrowser", ...inject],
 		async apply(inner) {
 			const reader = await registerProjections(inner);
-			registerBrowserTools(inner, reader, !config.headless);
+			registerBrowserTools(inner, reader, !resolved.headless);
 			registerPresence(inner, reader);
 		}
 	});
 }
+/**
+* The loader passes a config it has already resolved, including the volatile
+* fields. A direct caller passes the raw values, which are resolved here.
+* Resolving twice rejects a volatile value as if it were the wrong type.
+*/
+function browserSettings(config) {
+	if (isResolved(config)) return config;
+	return browserConfig(config);
+}
+function isResolved(config) {
+	const browser = config.browser;
+	return typeof browser === "object" && browser !== null && "get" in browser;
+}
 //#endregion
 export { Config, MhBrowserError, MhBrowserService, UNKNOWN_TAB, UNKNOWN_TAB_REASON, apply, inject, name, readAgentView, unknownTab };