@mind-harness/mh-browser 0.2.5 → 0.2.7

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,21 +6,25 @@ 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 { lstat, mkdir, open, readFile, readlink, realpath, unlink, writeFile } from "node:fs/promises";
+import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs";
+import { access, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, unlink, writeFile } from "node:fs/promises";
 import { z as z$1 } from "zod";
-import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { Service } from "@deepseek-ai/cordis";
 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
 const browserConfig = z.object({
 	presence: z.object({ maxBytes: z.number().step(1).min(1).required().description("Most bytes of page text one presence reminder may carry.") }).required().description("Pages kept in context across steps."),
 	browser: z.union([
+		"auto",
 		"chrome",
 		"msedge",
 		"chromium"
-	]).default("chrome").description("Which installed browser to drive. chromium is the one Playwright downloads."),
+	]).default("auto").volatile().description("Which browser to drive. auto keeps the one that launched last, or Chrome and then Edge. 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.")
 });
@@ -32,16 +36,22 @@ const browserConfig = z.object({
 function defaultProfileDir(profile, home = resolveDshHome()) {
 	return profile === void 0 ? join(home, "mh", "browser") : join(home, "mh", "profiles", profile.name, "browser");
 }
+/** One subdirectory of the default profile root per browser, so logins do not cross browsers. */
+function profileDirFor(root, browser) {
+	return join(root, browser);
+}
 //#endregion
 //#region lib/types/types.js
 var MhBrowserError = class extends Error {
 	code;
 	page;
-	constructor(code, message, page) {
+	notFound;
+	constructor(code, message, page, notFound) {
 		super(message);
 		this.name = "MhBrowserError";
 		this.code = code;
 		if (page !== void 0) this.page = page;
+		if (notFound !== void 0) this.notFound = notFound;
 	}
 };
 /** Owner of the person's own window. It belongs to no Session. */
@@ -554,13 +564,13 @@ function pageAttrs(view, screenshot) {
 		screenshot === void 0 ? "" : attr$1("screenshot", screenshot)
 	].join("");
 }
-const BODY_LIMIT = 2e5;
+const BODY_LIMIT$1 = 2e5;
 function pageBody(view) {
 	const representation = view.representation;
 	if (view.mediaType === void 0 || representation.kind !== "snapshot") return representation.text;
 	if (view.body !== void 0) {
-		if (view.body.length <= BODY_LIMIT) return view.body;
-		return `${view.body.slice(0, BODY_LIMIT)}\nCut at ${String(BODY_LIMIT)} characters; use browser_download to save the whole file into the workspace.`;
+		if (view.body.length <= BODY_LIMIT$1) return view.body;
+		return `${view.body.slice(0, BODY_LIMIT$1)}\nCut at ${String(BODY_LIMIT$1)} characters; use browser_download to save the whole file into the workspace.`;
 	}
 	if (view.status !== void 0) return `The site answered HTTP ${String(view.status)}; the ${view.mediaType} body is not shown.`;
 	return "Not an HTML page; use browser_download to save it into the workspace.";
@@ -2367,6 +2377,302 @@ function plainObject(keys) {
 	return z$1.custom((value) => value !== null && typeof value === "object" && keys.every((key) => key in value));
 }
 //#endregion
+//#region lib/types/routes.js
+/** Requests larger than this are refused before the service method runs. */
+const BODY_LIMIT = 65536;
+const PREFIX = "/mh-browser/api";
+var RouteFailure = class extends Error {
+	status;
+	body;
+	constructor(status, body) {
+		super(body.message);
+		this.name = "RouteFailure";
+		this.status = status;
+		this.body = body;
+	}
+};
+function method(spec) {
+	return {
+		verb: spec.verb,
+		input: spec.input,
+		run: (input, signal) => spec.run(input, signal)
+	};
+}
+const locateInput = z$1.object({ browser: z$1.enum([
+	"auto",
+	"chrome",
+	"msedge",
+	"chromium"
+]) }).strict();
+const revealInput = z$1.object({ sessionId: z$1.string() }).strict();
+/**
+* Routes for the browser client. A composition without `webServer` never
+* starts this plugin; the browser tools do not depend on it.
+*/
+const browserRoutesPlugin = {
+	name: "mh-browser-routes",
+	inject: [
+		"mhBrowser",
+		"webServer",
+		"connection"
+	],
+	apply(inner) {
+		registerBrowserRoutes(inner);
+	}
+};
+function registerBrowserRoutes(ctx) {
+	registerApiRoutes(ctx, {
+		prefix: PREFIX,
+		packageName: "mh-browser",
+		methods: {
+			"locate-for": method({
+				verb: "POST",
+				input: locateInput,
+				run: (input, signal) => ctx.mhBrowser.locateFor(input.browser, signal)
+			}),
+			"reveal-handover": method({
+				verb: "POST",
+				input: revealInput,
+				run: (input, signal) => ctx.mhBrowser.revealHandover(input.sessionId, signal)
+			})
+		},
+		mapError: browserFailure
+	});
+}
+function registerApiRoutes(host, routes) {
+	host.effect(() => host.webServer.register({
+		kind: "prefix",
+		path: routes.prefix,
+		handler: (req, res) => handle(req, res, host, routes)
+	}));
+}
+async function handle(req, res, host, routes) {
+	const name = routes.packageName;
+	try {
+		const admission = host.connection.admit({ headers: req.headers });
+		if ("rejection" in admission) {
+			const status = admission.rejection;
+			writeJson(res, status, fail(name, status === 401 ? "unadmitted" : "forbidden", status === 401 ? "sign in required" : "forbidden"), name);
+			return;
+		}
+		const found = methodOf(routes, segmentOf(req.url, routes.prefix));
+		if (found === void 0) {
+			writeJson(res, 404, fail(name, "not-found", "no such route"), name);
+			return;
+		}
+		if (req.method !== found.verb) {
+			writeJson(res, 405, fail(name, "method-not-allowed", "method not allowed"), name, { allow: found.verb });
+			return;
+		}
+		const controller = new AbortController();
+		const onClose = () => {
+			if (!res.writableEnded) controller.abort();
+		};
+		res.on("close", onClose);
+		if (req.destroyed || res.destroyed) controller.abort();
+		try {
+			if (signalAborted(controller, res, name)) return;
+			const input = found.verb === "GET" ? queryInput(req.url) : await readJson(req, name);
+			if (signalAborted(controller, res, name)) return;
+			const parsed = found.input.safeParse(input);
+			if (!parsed.success) {
+				writeJson(res, 400, {
+					ok: false,
+					error: {
+						code: `${name}/invalid-input`,
+						message: "invalid input",
+						details: { issues: parsed.error.issues.map((issue) => ({
+							path: issue.path.map((part) => String(part)).join("."),
+							message: issue.message
+						})) }
+					}
+				}, name);
+				return;
+			}
+			const value = await found.run(parsed.data, controller.signal);
+			writeJson(res, 200, {
+				ok: true,
+				value: value === void 0 ? null : value
+			}, name);
+		} finally {
+			res.removeListener("close", onClose);
+		}
+	} catch (error) {
+		const failed = error instanceof RouteFailure ? {
+			status: error.status,
+			error: error.body
+		} : routes.mapError(error);
+		writeJson(res, failed.status, {
+			ok: false,
+			error: failed.error
+		}, name);
+	}
+}
+/** Names on `Object.prototype` are not routes. */
+function methodOf(routes, segment) {
+	if (segment === void 0 || segment === "" || !Object.hasOwn(routes.methods, segment)) return;
+	return routes.methods[segment];
+}
+function signalAborted(controller, res, packageName) {
+	if (!controller.signal.aborted) return false;
+	writeJson(res, 400, fail(packageName, "cancelled", "cancelled"), packageName);
+	return true;
+}
+function browserFailure(error) {
+	if (error instanceof MhBrowserError) {
+		if (error.code === "INTERRUPTED") return {
+			status: 400,
+			error: {
+				code: "mh-browser/cancelled",
+				message: error.message
+			}
+		};
+		return {
+			status: error.code === "INVALID_ARGS" || error.code === "INVALID_INPUT" ? 400 : 500,
+			error: {
+				code: error.code,
+				message: error.message
+			}
+		};
+	}
+	return {
+		status: 500,
+		error: {
+			code: "mh-browser/failed",
+			message: error instanceof Error ? error.message : "request failed"
+		}
+	};
+}
+function fail(packageName, code, message) {
+	return {
+		ok: false,
+		error: {
+			code: `${packageName}/${code}`,
+			message
+		}
+	};
+}
+function segmentOf(url, prefix) {
+	let pathname;
+	try {
+		pathname = new URL(url ?? "/", "http://127.0.0.1").pathname;
+	} catch {
+		return;
+	}
+	if (pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+	if (pathname === prefix) return "";
+	const head = `${prefix}/`;
+	if (!pathname.startsWith(head)) return void 0;
+	const rest = pathname.slice(head.length);
+	if (rest === "" || rest.includes("/")) return void 0;
+	try {
+		return decodeURIComponent(rest);
+	} catch {
+		return;
+	}
+}
+function queryInput(url) {
+	const params = new URL(url ?? "/", "http://127.0.0.1").searchParams;
+	const input = {};
+	for (const [key, value] of params) input[key] = value;
+	return input;
+}
+async function readJson(req, packageName) {
+	const chunks = await readChunks(req);
+	if (chunks === void 0) throw new RouteFailure(400, {
+		code: `${packageName}/invalid-input`,
+		message: "request is too large"
+	});
+	const text = Buffer.concat(chunks).toString("utf8");
+	if (text.trim() === "") return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new RouteFailure(400, {
+			code: `${packageName}/invalid-input`,
+			message: "request is not json"
+		});
+	}
+}
+/** `undefined` means the body is over the limit. The socket stays open. */
+function readChunks(req) {
+	const declared = declaredLength(req);
+	if (declared !== void 0 && declared > BODY_LIMIT) {
+		req.on("error", () => void 0);
+		req.resume();
+		return Promise.resolve(void 0);
+	}
+	const chunks = [];
+	let size = 0;
+	return new Promise((resolve, reject) => {
+		const stop = () => {
+			req.off("data", onData);
+			req.off("end", onEnd);
+			req.off("error", onError);
+		};
+		const onData = (chunk) => {
+			const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			size += buffer.length;
+			if (size > BODY_LIMIT) {
+				stop();
+				req.on("error", () => void 0);
+				req.pause();
+				req.resume();
+				resolve(void 0);
+				return;
+			}
+			chunks.push(buffer);
+		};
+		const onEnd = () => {
+			stop();
+			resolve(chunks);
+		};
+		const onError = (error) => {
+			stop();
+			reject(error);
+		};
+		req.on("data", onData);
+		req.on("end", onEnd);
+		req.on("error", onError);
+	});
+}
+function declaredLength(req) {
+	const raw = req.headers["content-length"];
+	if (typeof raw !== "string" || !/^\d+$/.test(raw)) return void 0;
+	const length = Number(raw);
+	return Number.isSafeInteger(length) ? length : void 0;
+}
+function writeJson(res, status, body, packageName, extra) {
+	if (res.writableEnded || res.destroyed) return;
+	let payload;
+	let nextStatus = status;
+	let nextExtra = extra;
+	try {
+		payload = JSON.stringify(body);
+	} catch {
+		payload = JSON.stringify({
+			ok: false,
+			error: {
+				code: `${packageName}/failed`,
+				message: "request failed"
+			}
+		});
+		nextStatus = 500;
+		nextExtra = void 0;
+	}
+	const headers = {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	};
+	if (nextExtra !== void 0) Object.assign(headers, nextExtra);
+	try {
+		res.writeHead(nextStatus, headers);
+		res.end(payload);
+	} catch {
+		res.destroy();
+	}
+}
+//#endregion
 //#region lib/types/presence/book.js
 /** In-memory presence set for one process. The log is the source of a set that outlives the process. */
 var PresenceBook = class {
@@ -3069,16 +3375,309 @@ 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"
+};
+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}`);
+}
+/** Chrome and Edge were both missed. The message asks for Chrome only. */
+var BrowserNotFoundError = class extends Error {
+	notFound;
+	constructor(misses) {
+		const tried = misses.flatMap((item) => item.missing.map((miss) => ({
+			browser: item.browser,
+			path: miss.path,
+			reason: miss.reason
+		})));
+		const listed = tried.map((item) => `${item.path} (${item.reason})`).join("; ");
+		const detail = listed === "" ? "" : ` Tried: ${listed}.`;
+		super(`Neither Google Chrome nor Microsoft Edge was found.${detail} Ask the person to install Google Chrome, or set the browser's path in the configuration.`);
+		this.name = "BrowserNotFoundError";
+		this.notFound = {
+			browsers: misses.map((item) => item.browser),
+			tried
+		};
+	}
 };
-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);
+/**
+* The installed browser to launch when the choice is automatic.
+* The remembered browser wins while it can still be found; otherwise Chrome, then Edge.
+*/
+async function resolveAuto(env, remembered, signal) {
+	const order = [];
+	if (remembered === "chrome" || remembered === "msedge") order.push(remembered);
+	for (const name of ["chrome", "msedge"]) if (!order.includes(name)) order.push(name);
+	const misses = [];
+	for (const name of order) {
+		if (signal?.aborted === true) break;
+		const located = await locateInstalled(name, env, signal);
+		if ("found" in located) return {
+			browser: name,
+			path: located.found
+		};
+		misses.push({
+			browser: name,
+			missing: located.missing
+		});
+	}
+	throw new BrowserNotFoundError(misses);
+}
+/** 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
@@ -3089,34 +3688,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" && options.channel !== false ? { 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
@@ -3163,6 +3773,126 @@ async function closeOrKill(close, pid, waitMs = 1e3, kill = (target) => {
 	return "killed";
 }
 //#endregion
+//#region lib/types/service/profile.js
+const LAST_BROWSER = "last-browser.json";
+/** Subdirectories a split profile root keeps beside the browser that is launching. */
+const KEPT = /* @__PURE__ */ new Set([
+	"chrome",
+	"msedge",
+	"chromium",
+	"custom",
+	LAST_BROWSER
+]);
+/** The browser recorded after the last successful launch, if the file names one. */
+async function readLastBrowser(root) {
+	try {
+		const browser = JSON.parse(await readFile(join(root, LAST_BROWSER), "utf8")).browser;
+		if (browser === "chrome" || browser === "msedge" || browser === "chromium") return browser;
+	} catch {
+		return;
+	}
+}
+/** Remember which browser actually launched, so automatic selection keeps using it. */
+async function writeLastBrowser(root, browser) {
+	await mkdir(root, { recursive: true });
+	await writeFile(join(root, LAST_BROWSER), `${JSON.stringify({ browser })}\n`);
+}
+/**
+* Move a profile that older versions kept in the root into `browser`'s subdirectory.
+* A root without Chrome's `Local State`, or one whose subdirectory already exists, stays as it is.
+*/
+async function migrateLegacyProfile(root, browser) {
+	if (!KEPT.has(browser) || browser === LAST_BROWSER) return;
+	const target = join(root, browser);
+	try {
+		await access(join(root, "Local State"));
+	} catch {
+		return;
+	}
+	try {
+		await access(target);
+		return;
+	} catch {}
+	await mkdir(target, { recursive: true });
+	const names = await readdir(root);
+	for (const name of names) {
+		if (KEPT.has(name)) continue;
+		await rename(join(root, name), join(target, name));
+	}
+}
+//#endregion
+//#region lib/types/service/launch-plan.js
+/** Subdirectory for a configured path while automatic selection does not name a browser. */
+const CUSTOM = "custom";
+/**
+* Which browser, path, and profile directory to launch.
+* A configured path is checked and never replaced. Automatic selection keeps the
+* remembered browser while it can be found, then Chrome, then Edge.
+* Playwright's Chromium is used only when it is selected, or when it is the remembered one.
+*/
+async function planLaunch(input) {
+	const configured = input.configured?.trim() ?? "";
+	if (configured !== "") {
+		const checked = checkConfigured(configured, input.env);
+		if (!checked.ok) throw configuredPathError(checked.path, checked.code);
+		const named = input.choice === "auto" ? void 0 : input.choice;
+		if (named !== void 0) await settle(input, named);
+		return {
+			browser: named ?? "chrome",
+			channel: named !== void 0 && named !== "chromium",
+			profileDir: folder(input, named ?? CUSTOM),
+			executablePath: checked.path,
+			...named !== void 0 ? { remember: named } : {}
+		};
+	}
+	if (input.choice === "auto" && input.remembered === "chromium" && "found" in input.bundled) {
+		await settle(input, "chromium");
+		return {
+			browser: "chromium",
+			channel: false,
+			profileDir: folder(input, "chromium"),
+			remember: "chromium"
+		};
+	}
+	if (input.choice === "auto") {
+		const remembered = input.remembered === "chromium" ? void 0 : input.remembered;
+		const resolved = await resolveAuto(input.env, remembered, input.signal);
+		await settle(input, resolved.browser);
+		return {
+			browser: resolved.browser,
+			channel: true,
+			profileDir: folder(input, resolved.browser),
+			executablePath: resolved.path,
+			remember: resolved.browser
+		};
+	}
+	if (input.choice === "chromium") {
+		await settle(input, "chromium");
+		return {
+			browser: "chromium",
+			channel: false,
+			profileDir: folder(input, "chromium"),
+			remember: "chromium"
+		};
+	}
+	const located = await locateInstalled(input.choice, input.env, input.signal);
+	if (!("found" in located)) throw browserNotFoundError(input.choice, located.missing);
+	await settle(input, input.choice);
+	return {
+		browser: input.choice,
+		channel: true,
+		profileDir: folder(input, input.choice),
+		executablePath: located.found,
+		remember: input.choice
+	};
+}
+function folder(input, name) {
+	return input.split ? profileDirFor(input.root, name) : input.root;
+}
+async function settle(input, name) {
+	if (input.split) await migrateLegacyProfile(input.root, name);
+}
+//#endregion
 //#region lib/types/service/control.js
 /**
 * Who holds each tab of one session. Person input outside a service dispatch
@@ -3179,6 +3909,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";
@@ -4333,16 +5072,18 @@ function extensionDir() {
 var Extension = class Extension {
 	context;
 	id;
+	browserSession;
 	workerPage;
-	constructor(context, id, worker) {
+	constructor(context, id, browserSession, worker) {
 		this.context = context;
 		this.id = id;
+		this.browserSession = browserSession;
 		this.workerPage = worker;
 	}
 	static async load(context, browserSession) {
 		const loaded = await browserSession.send("Extensions.loadUnpacked", { path: extensionDir() });
 		const worker = await findWorker(context, loaded.id);
-		return new Extension(context, loaded.id, worker);
+		return new Extension(context, loaded.id, browserSession, worker);
 	}
 	/** Address of a page shipped in the extension directory. */
 	pageUrl(name) {
@@ -4426,11 +5167,32 @@ var Extension = class Extension {
 	async worker(signal) {
 		const current = this.workerPage;
 		if (current !== void 0 && this.context.serviceWorkers().includes(current)) return current;
-		const worker = await untilAborted(findWorker(this.context, this.id), capped(signal, CALL_MS$1));
+		const worker = await restoreWorker(this.context, this.id, async () => {
+			await this.browserSession.send("Extensions.loadUnpacked", { path: extensionDir() });
+		}, signal);
 		this.workerPage = worker;
 		return worker;
 	}
 };
+/**
+* The service worker, reloading the extension once when it is gone.
+* A worker that comes back on its own during the first wait is used as it is.
+* After a reload that still has no worker, the extension was turned off.
+*/
+async function restoreWorker(context, id, reload, signal, appearMs = 1e3) {
+	try {
+		return await untilAborted(findWorker(context, id, appearMs), signal);
+	} catch (error) {
+		if (isInterrupted(error)) throw error;
+	}
+	try {
+		await reload();
+		return await untilAborted(findWorker(context, id), signal);
+	} catch (error) {
+		if (isInterrupted(error)) throw error;
+		throw new Error("The agent extension in the browser was turned off.", { cause: error });
+	}
+}
 /** The extension's service worker. Looks once more after the wait times out. */
 async function findWorker(context, id, timeoutMs = WORKER_MS) {
 	const find = () => context.serviceWorkers().find((worker) => worker.url().includes(id));
@@ -5248,46 +6010,6 @@ async function writeCounter(profileDir, next) {
 const testHooks = Symbol("mh-browser test hooks");
 //#endregion
 //#region lib/types/service/service.js
-var __runInitializers = function(thisArg, initializers, value) {
-	var useValue = arguments.length > 2;
-	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-	return useValue ? value : void 0;
-};
-var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-	function accept(f) {
-		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
-		return f;
-	}
-	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-	var _, done = false;
-	for (var i = decorators.length - 1; i >= 0; i--) {
-		var context = {};
-		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-		context.addInitializer = function(f) {
-			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
-			extraInitializers.push(accept(f || null));
-		};
-		var result = (0, decorators[i])(kind === "accessor" ? {
-			get: descriptor.get,
-			set: descriptor.set
-		} : descriptor[key], context);
-		if (kind === "accessor") {
-			if (result === void 0) continue;
-			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-			if (_ = accept(result.get)) descriptor.get = _;
-			if (_ = accept(result.set)) descriptor.set = _;
-			if (_ = accept(result.init)) initializers.unshift(_);
-		} else if (_ = accept(result)) {
-			if (kind === "field") initializers.unshift(_);
-			else descriptor[key] = _;
-		}
-	}
-	if (target) Object.defineProperty(target, contextIn.name, descriptor);
-	done = true;
-};
 /** Navigation and back share this limit (§3.7). */
 const NAVIGATION_MS = 1e4;
 /** How long an open that started a download waits for the download event. */
@@ -5315,1469 +6037,1585 @@ const NO_WORKSPACE_REASON = "this session has no working directory";
 * the session's browser. `act` returns a snapshot, including on a page that
 * also has an Agent View.
 */
-let MhBrowserService = (() => {
-	let _classSuper = TypertRemoteService;
-	let _instanceExtraInitializers = [];
-	let _revealHandover_decorators;
-	return class MhBrowserService extends _classSuper {
-		static {
-			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-			_revealHandover_decorators = [Remote];
-			__esDecorate(this, null, _revealHandover_decorators, {
-				kind: "method",
-				name: "revealHandover",
-				static: false,
-				private: false,
-				access: {
-					has: (obj) => "revealHandover" in obj,
-					get: (obj) => obj.revealHandover
-				},
-				metadata: _metadata
-			}, null, _instanceExtraInitializers);
-			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
-				enumerable: true,
-				configurable: true,
-				writable: true,
-				value: _metadata
+var MhBrowserService = class extends Service {
+	windows = new Windows();
+	headless;
+	/** Profile root. The default root gets one subdirectory per browser at launch. */
+	profileRoot;
+	/** A configured profile directory is used as given, without a per-browser subdirectory. */
+	splitProfile;
+	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 = [];
+	/** One queue per owner: a slow wait in one Session does not hold up another. */
+	queues = /* @__PURE__ */ new Map();
+	shown = /* @__PURE__ */ new Map();
+	book = new PresenceBook();
+	maxBytes;
+	workspaces = /* @__PURE__ */ new Map();
+	control = new Control();
+	personTouch = /* @__PURE__ */ new Set();
+	/** Origins that have served a readable Agent View. Memory only; a restart clears it. */
+	agentViewOrigins = /* @__PURE__ */ new Set();
+	/** The last Agent View read for a page address, so a later read can send If-None-Match. */
+	documents = /* @__PURE__ */ new Map();
+	constructor(ctx, config) {
+		super(ctx, "mhBrowser");
+		this.maxBytes = config.presence.maxBytes;
+		this.headless = config.headless;
+		const configuredDir = config.profileDir;
+		this.splitProfile = configuredDir === void 0 || configuredDir === "";
+		this.profileRoot = this.splitProfile ? defaultProfileDir(ctx.get("profileContext")) : configuredDir;
+		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);
+			if (live !== void 0) this.windows.markMayHaveChanged(live);
+		});
+		this.windows.onTabClosed((tab) => {
+			this.shown.delete(tab.id);
+		});
+		this.up().catch(() => void 0);
+		ctx.on("session/disposed", (session) => {
+			const owner = session.id;
+			if (owner === void 0) return;
+			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);
+			this.control.forget(owner);
+			this.workspaces.delete(owner);
+		});
+		ctx.effect(() => async () => {
+			this.closing = true;
+			await this.stop();
+		});
+	}
+	/** Remember an origin whose pages offer Agent Views. A missing page does not remove it. */
+	declareAgentViewOrigin(origin) {
+		try {
+			const parsed = new URL(origin);
+			if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+			this.agentViewOrigins.add(parsed.origin);
+		} catch {}
+	}
+	async open(owner, items, signal, options) {
+		const reveal = options?.reveal === true;
+		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));
+				}
+				await this.enforceCap(owner);
+				return views;
+			}, signal);
+		} catch (error) {
+			if (!isInterrupted(error)) throw error;
+			return items.map((item) => ({
+				url: item.url,
+				reason: WAITING_STOPPED
+			}));
 		}
-		static Config = browserConfig;
-		windows = (__runInitializers(this, _instanceExtraInitializers), new Windows());
-		launchOptions;
-		context;
-		pids = /* @__PURE__ */ new WeakMap();
-		ready = Promise.resolve();
-		closing = false;
-		/** The browser is not running. The next call that needs a page starts it. */
-		exited = true;
-		exits = [];
-		/** One queue per owner: a slow wait in one Session does not hold up another. */
-		queues = /* @__PURE__ */ new Map();
-		shown = /* @__PURE__ */ new Map();
-		book = new PresenceBook();
-		maxBytes;
-		workspaces = /* @__PURE__ */ new Map();
-		control = new Control();
-		personTouch = /* @__PURE__ */ new Set();
-		/** Origins that have served a readable Agent View. Memory only; a restart clears it. */
-		agentViewOrigins = /* @__PURE__ */ new Set();
-		/** The last Agent View read for a page address, so a later read can send If-None-Match. */
-		documents = /* @__PURE__ */ new Map();
-		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"))
+	}
+	async view(owner, tab, signal) {
+		return this.exclusive(owner, async () => {
+			await this.ready;
+			const live = this.windows.get(owner, tab);
+			if (live === void 0) return unknownTab();
+			if (signal?.aborted) return {
+				tab,
+				url: live.url,
+				reason: WAITING_STOPPED
 			};
-			this.windows.setPersonInput((owner, tab) => {
-				const live = tab === void 0 ? void 0 : this.windows.get(owner, tab);
-				this.control.note(owner, tab);
-				if (live !== void 0) this.windows.markMayHaveChanged(live);
-			});
-			this.windows.onTabClosed((tab) => {
-				this.shown.delete(tab.id);
-			});
-			this.up().catch(() => void 0);
-			ctx.on("session/disposed", (session) => {
-				const owner = session.id;
-				if (owner === void 0) return;
-				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);
+			return this.refreshView(live, signal);
+		}, signal);
+	}
+	/** Pages whose current representation is already in the model's presence. */
+	rememberPresence(owner, urls) {
+		this.book.remember(owner, urls.map((url) => canonical(url)));
+	}
+	presenceList(owner) {
+		return this.book.entries(owner);
+	}
+	presencePut(owner, urls, source) {
+		return this.book.put(owner, urls.map((url) => canonical(url)), source);
+	}
+	presenceRemove(owner, urls) {
+		return this.book.remove(owner, urls.map((url) => canonical(url)));
+	}
+	/** The set the session log folds to; taken once per process. */
+	presenceLoad(owner, folded) {
+		this.book.load(owner, folded);
+	}
+	presenceTakeResume(owner) {
+		return this.book.takeResume(owner);
+	}
+	/**
+	* Re-read presence pages and build the next reminder.
+	* A tab already on the address is read in place. A check that has to open
+	* one closes it before returning. Removals are included, and they cause
+	* every remaining page to be read so a page kept out by the byte budget
+	* can come back. An empty set has nothing to read and does not wait for the
+	* browser; a browser that is down makes every page absent.
+	*/
+	async presenceCheck(owner, which, opts) {
+		if (this.book.entries(owner).length === 0 && this.book.peekRemovals(owner).length === 0) return;
+		return this.exclusive(owner, async () => {
+			const down = await this.up().then(() => void 0, (error) => error instanceof Error ? error.message : String(error));
+			const pages = this.book.entries(owner);
+			const removals = this.book.peekRemovals(owner);
+			const wanted = new Set(which === "all" ? pages.map((page) => page.url) : which.map(canonical));
+			if (removals.length > 0) for (const page of pages) wanted.add(page.url);
+			const observations = [];
+			for (const page of pages) {
+				if (!wanted.has(page.url)) continue;
+				observations.push(down === void 0 ? await this.observePresence(owner, page.url, opts?.signal) : {
+					url: page.url,
+					ok: false,
+					reason: `browser not running: ${down}`,
+					title: "",
+					observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					bytes: 0
 				});
-				this.book.forget(owner);
-				this.control.forget(owner);
-				this.workspaces.delete(owner);
-			});
-			ctx.effect(() => async () => {
-				this.closing = true;
-				await this.stop();
+			}
+			const planned = planReminder({
+				pages,
+				observations,
+				removals,
+				maxBytes: this.maxBytes,
+				baseline: opts?.baseline === true,
+				replaces: opts?.replaces === true,
+				...opts?.force === true ? { force: true } : {}
 			});
-		}
-		/** Remember an origin whose pages offer Agent Views. A missing page does not remove it. */
-		declareAgentViewOrigin(origin) {
-			try {
-				const parsed = new URL(origin);
-				if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
-				this.agentViewOrigins.add(parsed.origin);
-			} catch {}
-		}
-		async open(owner, items, signal, options) {
-			const reveal = options?.reveal === true;
-			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));
-					}
-					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 () => {
-				await this.ready;
-				const live = this.windows.get(owner, tab);
-				if (live === void 0) return unknownTab();
-				if (signal?.aborted) return {
-					tab,
-					url: live.url,
-					reason: WAITING_STOPPED
-				};
-				return this.refreshView(live, signal);
-			}, signal);
-		}
-		/** Pages whose current representation is already in the model's presence. */
-		rememberPresence(owner, urls) {
-			this.book.remember(owner, urls.map((url) => canonical(url)));
-		}
-		presenceList(owner) {
-			return this.book.entries(owner);
-		}
-		presencePut(owner, urls, source) {
-			return this.book.put(owner, urls.map((url) => canonical(url)), source);
-		}
-		presenceRemove(owner, urls) {
-			return this.book.remove(owner, urls.map((url) => canonical(url)));
-		}
-		/** The set the session log folds to; taken once per process. */
-		presenceLoad(owner, folded) {
-			this.book.load(owner, folded);
-		}
-		presenceTakeResume(owner) {
-			return this.book.takeResume(owner);
-		}
-		/**
-		* Re-read presence pages and build the next reminder.
-		* A tab already on the address is read in place. A check that has to open
-		* one closes it before returning. Removals are included, and they cause
-		* every remaining page to be read so a page kept out by the byte budget
-		* can come back. An empty set has nothing to read and does not wait for the
-		* browser; a browser that is down makes every page absent.
-		*/
-		async presenceCheck(owner, which, opts) {
-			if (this.book.entries(owner).length === 0 && this.book.peekRemovals(owner).length === 0) return;
-			return this.exclusive(owner, async () => {
-				const down = await this.up().then(() => void 0, (error) => error instanceof Error ? error.message : String(error));
-				const pages = this.book.entries(owner);
-				const removals = this.book.peekRemovals(owner);
-				const wanted = new Set(which === "all" ? pages.map((page) => page.url) : which.map(canonical));
-				if (removals.length > 0) for (const page of pages) wanted.add(page.url);
-				const observations = [];
-				for (const page of pages) {
-					if (!wanted.has(page.url)) continue;
-					observations.push(down === void 0 ? await this.observePresence(owner, page.url, opts?.signal) : {
-						url: page.url,
-						ok: false,
-						reason: `browser not running: ${down}`,
-						title: "",
-						observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-						bytes: 0
-					});
-				}
-				const planned = planReminder({
-					pages,
-					observations,
-					removals,
-					maxBytes: this.maxBytes,
-					baseline: opts?.baseline === true,
-					replaces: opts?.replaces === true,
-					...opts?.force === true ? { force: true } : {}
-				});
-				if (planned === void 0) return void 0;
-				this.book.apply(owner, planned.next);
-				this.book.clearRemovals(owner);
-				return {
-					text: planned.text,
-					record: planned.record
-				};
-			}, opts?.signal);
-		}
-		/**
-		* Where a download the page starts may be written: the session's writable
-		* root, or why it may not write at all.
-		*/
-		noteWorkspace(owner, target) {
-			this.workspaces.set(owner, target);
-		}
-		tabs(owner) {
-			return this.windows.list(owner);
-		}
-		takeClosed(owner) {
-			return this.windows.takeClosed(owner);
-		}
-		windowId(owner, tab) {
-			return this.exclusive(owner, async () => {
-				await this.ready;
-				return this.windows.windowId(owner, tab);
+			if (planned === void 0) return void 0;
+			this.book.apply(owner, planned.next);
+			this.book.clearRemovals(owner);
+			return {
+				text: planned.text,
+				record: planned.record
+			};
+		}, opts?.signal);
+	}
+	/**
+	* Where a download the page starts may be written: the session's writable
+	* root, or why it may not write at all.
+	*/
+	noteWorkspace(owner, target) {
+		this.workspaces.set(owner, target);
+	}
+	tabs(owner) {
+		return this.windows.list(owner);
+	}
+	takeClosed(owner) {
+		return this.windows.takeClosed(owner);
+	}
+	windowId(owner, tab) {
+		return this.exclusive(owner, async () => {
+			await this.ready;
+			return this.windows.windowId(owner, tab);
+		});
+	}
+	async fetch(url, opts) {
+		try {
+			await this.up();
+			const context = this.context;
+			if (context === void 0) return {
+				kind: "error",
+				reason: "browser is not running"
+			};
+			const headers = {};
+			if (opts?.accept !== void 0) headers.accept = opts.accept;
+			if (opts?.ifNoneMatch !== void 0) headers["if-none-match"] = opts.ifNoneMatch;
+			const response = await context.request.get(url, {
+				headers,
+				failOnStatusCode: false,
+				...opts?.signal !== void 0 ? { signal: opts.signal } : {}
 			});
+			const headerMap = response.headers();
+			const body = {
+				kind: "response",
+				finalUrl: response.url(),
+				status: response.status(),
+				body: new Uint8Array(await untilAborted(response.body(), capped(opts?.signal, READ_MS)))
+			};
+			const mediaType = headerMap["content-type"];
+			const etag = headerMap.etag;
+			const link = headerMap.link;
+			if (mediaType !== void 0) body.mediaType = mediaType;
+			if (etag !== void 0) body.etag = etag;
+			if (link !== void 0) body.link = link;
+			return body;
+		} catch (error) {
+			return {
+				kind: "error",
+				reason: error instanceof Error ? error.message : String(error)
+			};
 		}
-		async fetch(url, opts) {
-			try {
-				await this.up();
-				const context = this.context;
-				if (context === void 0) return {
-					kind: "error",
-					reason: "browser is not running"
-				};
-				const headers = {};
-				if (opts?.accept !== void 0) headers.accept = opts.accept;
-				if (opts?.ifNoneMatch !== void 0) headers["if-none-match"] = opts.ifNoneMatch;
-				const response = await context.request.get(url, {
-					headers,
-					failOnStatusCode: false,
-					...opts?.signal !== void 0 ? { signal: opts.signal } : {}
-				});
-				const headerMap = response.headers();
-				const body = {
-					kind: "response",
-					finalUrl: response.url(),
-					status: response.status(),
-					body: new Uint8Array(await untilAborted(response.body(), capped(opts?.signal, READ_MS)))
-				};
-				const mediaType = headerMap["content-type"];
-				const etag = headerMap.etag;
-				const link = headerMap.link;
-				if (mediaType !== void 0) body.mediaType = mediaType;
-				if (etag !== void 0) body.etag = etag;
-				if (link !== void 0) body.link = link;
-				return body;
-			} catch (error) {
-				return {
-					kind: "error",
-					reason: error instanceof Error ? error.message : String(error)
-				};
+	}
+	async pushPath(owner, tab, path) {
+		await this.ready;
+		const live = this.windows.get(owner, tab);
+		if (live === void 0) return;
+		await live.page.evaluate((next) => {
+			history.pushState({}, "", next);
+		}, path);
+	}
+	async started() {
+		await this.ready;
+	}
+	/** The person asked for the browser: start it if it exited, past the exit limit. */
+	startForPerson() {
+		return this.up(true);
+	}
+	[testHooks]() {
+		return {
+			crash: async () => {
+				this.windows.suppressPersonInput();
+				await (this.context?.browser())?.close();
+			},
+			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),
+			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.
+	* `auto` reports the browser automatic selection would launch.
+	*/
+	async locateFor(browser, signal) {
+		const stopped = () => signal?.aborted === true;
+		if (stopped()) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+		if (browser !== "auto" && browser !== "chrome" && browser !== "msedge" && browser !== "chromium") throw new MhBrowserError("INVALID_ARGS", "browser must be auto, chrome, msedge, or chromium");
+		const env = this.locateEnv();
+		if (browser === "auto") return this.locateAuto(env, signal);
+		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 locateAuto(env, signal) {
+		const stopped = () => signal?.aborted === true;
+		const remembered = await readLastBrowser(this.profileRoot);
+		if (remembered === "chromium") {
+			const bundled = bundledChromiumLocation(env.access);
+			if ("found" in bundled) return {
+				found: bundled.found,
+				browser: "chromium"
+			};
 		}
-		async pushPath(owner, tab, path) {
-			await this.ready;
-			const live = this.windows.get(owner, tab);
-			if (live === void 0) return;
-			await live.page.evaluate((next) => {
-				history.pushState({}, "", next);
-			}, path);
-		}
-		async started() {
-			await this.ready;
-		}
-		/** The person asked for the browser: start it if it exited, past the exit limit. */
-		startForPerson() {
-			return this.up(true);
-		}
-		[testHooks]() {
+		try {
+			const resolved = await resolveAuto(env, remembered === "chromium" ? void 0 : remembered, signal);
+			if (stopped()) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
 			return {
-				crash: async () => {
-					this.windows.suppressPersonInput();
-					await (this.context?.browser())?.close();
-				},
-				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)
+				found: resolved.path,
+				browser: resolved.browser
 			};
+		} catch (error) {
+			if (stopped()) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+			if (error instanceof BrowserNotFoundError) return { missing: error.notFound.tried };
+			throw error;
 		}
-		async act(owner, tab, op, signal) {
-			return this.exclusive(owner, async () => {
-				await this.ready;
-				this.refuseIfPerson(owner, tab);
-				const live = this.windows.get(owner, tab);
-				if (live === void 0) throw new MhBrowserError(UNKNOWN_TAB, UNKNOWN_TAB_REASON);
-				if (signal?.aborted) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
-				const linked = this.control.link(owner, signal, tab);
-				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" }, signal);
-						blocked.dialog = {
-							type: "filechooser",
-							message: live.fileChooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
-						};
-						throw new MhBrowserError("MODAL_STATE", "a file chooser is open; use browser_file_upload", blocked);
-					}
-					const outcome = await this.perform(live, op, linked.signal);
-					if (op.kind === "fill_form" || op.kind === "select_option" || op.kind === "type" || op.kind === "file_upload") {
-						if (outcome.navigated) this.windows.onNavigated(live);
-						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, 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, {
-						surface: "snapshot",
-						...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
-					};
-					if (!showsSnapshot(op)) {
-						const summary = outcome.summary ?? summaryOf(op);
-						if (summary !== void 0) view.summary = summary;
-						if (outcome.detail !== void 0 && outcome.detail !== "") view.detail = outcome.detail;
-					}
-					if (op.kind === "take_screenshot") view.summary = "";
-					if (outcome.shot !== void 0) view.shot = outcome.shot;
-					if (outcome.writes !== void 0) view.writes = outcome.writes;
-					return this.attachDownload(live, view, false);
-				} 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" }, signal));
-					throw error;
-				} finally {
-					linked.release();
-				}
-			}, signal);
-		}
-		holdHandover(owner, tab) {
+	}
+	async act(owner, tab, op, signal) {
+		return this.exclusive(owner, async () => {
+			await this.ready;
+			this.refuseIfPerson(owner, tab);
 			const live = this.windows.get(owner, tab);
 			if (live === void 0) throw new MhBrowserError(UNKNOWN_TAB, UNKNOWN_TAB_REASON);
-			this.windows.holdHandover(live);
-		}
-		releaseHandover(owner) {
-			this.windows.releaseHandover(owner);
-			this.windows.markWaiting(owner, false);
-		}
-		/** `undefined` when no screenshot can be taken now: a dialog is open, or the page refused. */
-		capture(owner, tab, signal) {
-			return this.exclusive(owner, async () => {
-				await this.ready;
-				const live = this.windows.get(owner, tab);
-				if (live === void 0 || live.dialogHeld) return void 0;
-				try {
-					const limit = capped(signal, READ_MS);
-					const bytes = await untilAborted(live.page.screenshot({
-						type: "png",
-						signal: limit
-					}), limit);
-					return new Uint8Array(bytes);
-				} catch {
-					return;
+			if (signal?.aborted) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+			const linked = this.control.link(owner, signal, tab);
+			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" }, signal);
+					blocked.dialog = {
+						type: "filechooser",
+						message: live.fileChooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
+					};
+					throw new MhBrowserError("MODAL_STATE", "a file chooser is open; use browser_file_upload", blocked);
 				}
-			}, signal);
-		}
-		invoke(owner, _page, call, opts) {
-			return this.exclusive(owner, async () => {
-				await this.up();
-				if (opts?.signal?.aborted) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
-				const signal = opts?.signal;
-				const sent = await runInvoke({
-					open: (url) => this.openAddress(owner, { url }, signal),
-					refreshIdle: (url, except) => this.refreshIdle(owner, url, except, signal),
-					send: (request) => this.sendAction(request, signal),
-					readFile: opts?.readFile ?? (async () => {
-						throw new MhBrowserError("NO_WORKSPACE", NO_WORKSPACE_REASON);
-					})
-				}, call);
-				await this.enforceCap(owner);
-				return sent;
-			}, opts?.signal);
-		}
-		/**
-		* Not queued: it opens no tab, and a long body must not hold up the
-		* Session's other calls. `root` is the directory the session may write.
-		*/
-		async download(_owner, url, root, signal) {
-			await this.up();
-			return this.saveResponse(url, root, signal);
-		}
-		controlOf(owner) {
-			return this.control.of(owner);
-		}
-		/** Presence registers this. A hand-back calls it with the touched presence pages. */
-		bindPersonTouch(fn) {
-			this.personTouch.add(fn);
-			return () => {
-				this.personTouch.delete(fn);
-			};
-		}
-		/**
-		* Give the browser to the person. The named tab stays in use until hand-back.
-		* This does not wait; the tool waits on the question card.
-		*/
-		handover(owner, req, signal) {
-			return this.exclusive(owner, async () => {
-				await this.up();
-				if (signal?.aborted === true) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
-				if (req.tab !== void 0) {
-					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, signal).catch(() => void 0);
+				const outcome = await this.perform(live, op, linked.signal);
+				if (op.kind === "fill_form" || op.kind === "select_option" || op.kind === "type" || op.kind === "file_upload") {
+					if (outcome.navigated) this.windows.onNavigated(live);
+					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, 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, {
+					surface: "snapshot",
+					...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
+				};
+				if (!showsSnapshot(op)) {
+					const summary = outcome.summary ?? summaryOf(op);
+					if (summary !== void 0) view.summary = summary;
+					if (outcome.detail !== void 0 && outcome.detail !== "") view.detail = outcome.detail;
 				}
-				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) {
-			this.windows.setTitle(owner, title);
-		}
-		/** Raise the window of this owner's latest tab. False when it has no tab. */
-		async bringToFront(owner) {
+				if (op.kind === "take_screenshot") view.summary = "";
+				if (outcome.shot !== void 0) view.shot = outcome.shot;
+				if (outcome.writes !== void 0) view.writes = outcome.writes;
+				return this.attachDownload(live, view, false);
+			} 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" }, signal));
+				throw error;
+			} finally {
+				linked.release();
+			}
+		}, signal);
+	}
+	holdHandover(owner, tab) {
+		const live = this.windows.get(owner, tab);
+		if (live === void 0) throw new MhBrowserError(UNKNOWN_TAB, UNKNOWN_TAB_REASON);
+		this.windows.holdHandover(live);
+	}
+	releaseHandover(owner) {
+		this.windows.releaseHandover(owner);
+		this.windows.markWaiting(owner, false);
+	}
+	/** `undefined` when no screenshot can be taken now: a dialog is open, or the page refused. */
+	capture(owner, tab, signal) {
+		return this.exclusive(owner, async () => {
 			await this.ready;
-			const live = this.windows.latest(owner);
-			if (live === void 0) return false;
-			await untilAborted(live.page.bringToFront(), AbortSignal.timeout(READ_MS));
-			return true;
-		}
-		/** The person asked to see the page this Session handed over. */
-		async revealHandover(sessionId, signal) {
+			const live = this.windows.get(owner, tab);
+			if (live === void 0 || live.dialogHeld) return void 0;
+			try {
+				const limit = capped(signal, READ_MS);
+				const bytes = await untilAborted(live.page.screenshot({
+					type: "png",
+					signal: limit
+				}), limit);
+				return new Uint8Array(bytes);
+			} catch {
+				return;
+			}
+		}, signal);
+	}
+	invoke(owner, _page, call, opts) {
+		return this.exclusive(owner, async () => {
+			await this.up();
+			if (opts?.signal?.aborted) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+			const signal = opts?.signal;
+			const sent = await runInvoke({
+				open: (url) => this.openAddress(owner, { url }, signal),
+				refreshIdle: (url, except) => this.refreshIdle(owner, url, except, signal),
+				send: (request) => this.sendAction(request, signal),
+				readFile: opts?.readFile ?? (async () => {
+					throw new MhBrowserError("NO_WORKSPACE", NO_WORKSPACE_REASON);
+				})
+			}, call);
+			await this.enforceCap(owner);
+			return sent;
+		}, opts?.signal);
+	}
+	/**
+	* Not queued: it opens no tab, and a long body must not hold up the
+	* Session's other calls. `root` is the directory the session may write.
+	*/
+	async download(_owner, url, root, signal) {
+		await this.up();
+		return this.saveResponse(url, root, signal);
+	}
+	controlOf(owner) {
+		return this.control.of(owner);
+	}
+	/** Presence registers this. A hand-back calls it with the touched presence pages. */
+	bindPersonTouch(fn) {
+		this.personTouch.add(fn);
+		return () => {
+			this.personTouch.delete(fn);
+		};
+	}
+	/**
+	* Give the browser to the person. The named tab stays in use until hand-back.
+	* This does not wait; the tool waits on the question card.
+	*/
+	handover(owner, req, signal) {
+		return this.exclusive(owner, async () => {
+			await this.up();
+			if (signal?.aborted === true) throw new MhBrowserError(INTERRUPTED, WAITING_STOPPED);
+			if (req.tab !== void 0) {
+				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, 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) {
+		this.windows.setTitle(owner, title);
+	}
+	/** Raise the window of this owner's latest tab. False when it has no tab. */
+	async bringToFront(owner) {
+		await this.ready;
+		const live = this.windows.latest(owner);
+		if (live === void 0) return false;
+		await untilAborted(live.page.bringToFront(), AbortSignal.timeout(READ_MS));
+		return true;
+	}
+	/** The person asked to see the page this Session handed over. */
+	async revealHandover(sessionId, signal) {
+		await this.ready;
+		if (signal?.aborted === true) return { status: "not-handing-over" };
+		if (!this.control.holds(sessionId)) return { status: "not-handing-over" };
+		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 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;
-			if (signal?.aborted === true) return { status: "not-handing-over" };
-			if (!this.control.holds(sessionId)) return { status: "not-handing-over" };
-			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 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);
-				if (taken === void 0) throw new MhBrowserError("INVALID_ARGS", "the browser is not with the person");
-				this.windows.releaseHandover(owner);
-				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, 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;
+			const taken = this.control.finish(owner);
+			if (taken === void 0) throw new MhBrowserError("INVALID_ARGS", "the browser is not with the person");
 			this.windows.releaseHandover(owner);
 			this.windows.markWaiting(owner, false);
-		}
-		/**
-		* 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.
-		*/
-		takePersonHandback(owner) {
-			const taken = this.control.takePerson(owner);
-			if (taken === void 0) return void 0;
-			this.windows.releaseHandover(owner);
+			const urls = this.presenceUrls(owner, taken.tabs);
+			for (const touch of this.personTouch) touch(owner, urls);
+			const page = await this.snapshotNamed(owner, taken.tab, signal);
 			return {
 				...taken,
-				urls: this.presenceUrls(owner, taken.tabs)
+				urls,
+				...note !== void 0 && note !== "" ? { note } : {},
+				...page !== void 0 ? { page } : {}
 			};
-		}
-		/**
-		* Read one address. A known origin is tried on the request channel first.
-		* A readable Agent View found on a tab this call opened is returned without
-		* the tab, and that tab is not listed as closed.
-		*/
-		async openAddress(owner, item, signal, reveal = false) {
-			if (!openableAddress(item.url)) return {
+		}, 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
+		};
+	}
+	/**
+	* Read one address. A known origin is tried on the request channel first.
+	* A readable Agent View found on a tab this call opened is returned without
+	* the tab, and that tab is not listed as closed.
+	*/
+	async openAddress(owner, item, signal, reveal = false) {
+		if (!openableAddress(item.url)) return {
+			url: item.url,
+			reason: OPEN_ADDRESS_REASON
+		};
+		const wantsTab = owner === "person" || item.snapshot === true || item.waitFor !== void 0;
+		if (!wantsTab && this.knownOrigin(item.url)) {
+			const via = await this.readKnown(owner, item.url, signal);
+			if (via === STOPPED) return {
 				url: item.url,
-				reason: OPEN_ADDRESS_REASON
+				reason: WAITING_STOPPED
 			};
-			const wantsTab = owner === "person" || item.snapshot === true || item.waitFor !== void 0;
-			if (!wantsTab && this.knownOrigin(item.url)) {
-				const via = await this.readKnown(owner, item.url, signal);
-				if (via === STOPPED) return {
-					url: item.url,
-					reason: WAITING_STOPPED
-				};
-				if (via !== void 0) return via;
-			}
-			const opened = await this.openOne(owner, item.url, item.waitFor, signal, item.snapshot === true, reveal);
-			this.keepAgentView(opened);
-			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;
-				return view;
-			}
-			return opened.view;
+			if (via !== void 0) return via;
+		}
+		const opened = await this.openOne(owner, item.url, item.waitFor, signal, item.snapshot === true, reveal);
+		this.keepAgentView(opened);
+		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;
+			return view;
 		}
-		/** A tab this call opened can be closed again unless the person took it or it holds input. */
-		closable(owner, live) {
-			return this.control.ofTab(owner, live.id) !== "person" && !live.occupied;
+		return opened.view;
+	}
+	/** A tab this call opened can be closed again unless the person took it or it holds input. */
+	closable(owner, live) {
+		return this.control.ofTab(owner, live.id) !== "person" && !live.occupied;
+	}
+	knownOrigin(url) {
+		try {
+			return this.agentViewOrigins.has(new URL(url).origin);
+		} catch {
+			return false;
 		}
-		knownOrigin(url) {
-			try {
-				return this.agentViewOrigins.has(new URL(url).origin);
-			} catch {
-				return false;
-			}
+	}
+	rememberOrigin(url) {
+		try {
+			this.agentViewOrigins.add(new URL(url).origin);
+		} catch {}
+	}
+	/** 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;
+		this.rememberOrigin(opened.view.url);
+		const shown = this.shown.get(opened.live.id);
+		if (shown?.kind === "agent-view") this.rememberDocument(shown.pageUrl, shown);
+	}
+	/**
+	* Read a known origin without a tab. `undefined` means this page has to be
+	* opened in a tab: nothing declared, the declaration could not be read, or
+	* the request failed. The origin stays on the list either way. A stop
+	* ends the read without falling back to a tab.
+	*/
+	async readKnown(owner, url, signal) {
+		const key = canonical(url);
+		const previous = this.documents.get(key);
+		const servedAtPage = previous?.kind === "agent-view" && previous.href !== void 0 && canonical(previous.href) === canonical(previous.pageUrl);
+		let response;
+		try {
+			const got = await this.fetchSameOrigin(url, PAGE_ACCEPT, servedAtPage ? previous.etag : void 0, signal);
+			if (signal?.aborted === true) return STOPPED;
+			if (got === void 0) return void 0;
+			response = got;
+		} catch {
+			return signal?.aborted === true ? STOPPED : void 0;
+		}
+		if (response.status === 304 && previous?.kind === "agent-view") return this.pageOfShown(owner, previous);
+		const text = new TextDecoder().decode(response.body);
+		const pageUrl = canonical(response.finalUrl === "" ? url : response.finalUrl);
+		const cached = this.documents.get(pageUrl);
+		const shown = await loadShown({
+			pageUrl,
+			...optionalFragment(response.finalUrl === "" ? url : response.finalUrl),
+			snapshot: "",
+			main: {
+				status: response.status,
+				...response.mediaType !== void 0 ? { mediaType: response.mediaType } : {},
+				finalUrl: response.finalUrl === "" ? url : response.finalUrl,
+				...response.link !== void 0 ? { link: response.link } : {},
+				...response.etag !== void 0 ? { etag: response.etag } : {},
+				body: text
+			},
+			domLinks: linksInHtml(text, response.finalUrl === "" ? url : response.finalUrl),
+			...cached !== void 0 ? { previous: cached } : {},
+			relocate: false,
+			fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch, signal)
+		});
+		if (stopped(signal)) return STOPPED;
+		if (shown.kind !== "agent-view") return void 0;
+		this.rememberDocument(pageUrl, shown);
+		this.rememberOrigin(pageUrl);
+		return this.pageOfShown(owner, shown);
+	}
+	/** Keep the newest Agent Views. A dropped one is read in full the next time. */
+	rememberDocument(url, shown) {
+		const key = canonical(url);
+		this.documents.delete(key);
+		this.documents.set(key, shown);
+		while (this.documents.size > DOCUMENT_CAP) {
+			const oldest = this.documents.keys().next().value;
+			if (oldest === void 0) return;
+			this.documents.delete(oldest);
+		}
+	}
+	/** One page from a document, with no tab. */
+	pageOfShown(owner, shown) {
+		const view = {
+			url: shown.pageUrl,
+			title: "",
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			representation: shown.kind === "agent-view" ? {
+				kind: "agent-view",
+				text: shown.text,
+				...shown.version !== void 0 ? { version: shown.version } : {},
+				...shown.href !== void 0 ? { href: shown.href } : {}
+			} : {
+				kind: "snapshot",
+				text: shown.snapshot,
+				...shown.agentViewError !== void 0 ? { agentViewError: shown.agentViewError } : {}
+			},
+			inPresence: this.book.isShown(owner, canonical(shown.pageUrl))
+		};
+		if (shown.fragment !== void 0) view.fragment = shown.fragment;
+		if (shown.status !== void 0) view.status = shown.status;
+		if (shown.mediaType !== void 0) view.mediaType = shown.mediaType;
+		if (shown.body !== void 0) view.body = shown.body;
+		return view;
+	}
+	/**
+	* GET that follows same-origin redirects only. `undefined` when it cannot.
+	* A body that is neither text nor an Agent View is not read: the page then
+	* goes to a tab, which loads it anyway.
+	*/
+	async fetchSameOrigin(url, accept, ifNoneMatch, signal) {
+		const context = this.context;
+		if (context === void 0) return void 0;
+		let current = url;
+		let origin;
+		try {
+			origin = new URL(url).origin;
+		} catch {
+			return;
 		}
-		rememberOrigin(url) {
-			try {
-				this.agentViewOrigins.add(new URL(url).origin);
-			} catch {}
-		}
-		/** 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;
-			this.rememberOrigin(opened.view.url);
-			const shown = this.shown.get(opened.live.id);
-			if (shown?.kind === "agent-view") this.rememberDocument(shown.pageUrl, shown);
-		}
-		/**
-		* Read a known origin without a tab. `undefined` means this page has to be
-		* opened in a tab: nothing declared, the declaration could not be read, or
-		* the request failed. The origin stays on the list either way. A stop
-		* ends the read without falling back to a tab.
-		*/
-		async readKnown(owner, url, signal) {
-			const key = canonical(url);
-			const previous = this.documents.get(key);
-			const servedAtPage = previous?.kind === "agent-view" && previous.href !== void 0 && canonical(previous.href) === canonical(previous.pageUrl);
-			let response;
-			try {
-				const got = await this.fetchSameOrigin(url, PAGE_ACCEPT, servedAtPage ? previous.etag : void 0, signal);
-				if (signal?.aborted === true) return STOPPED;
-				if (got === void 0) return void 0;
-				response = got;
-			} catch {
-				return signal?.aborted === true ? STOPPED : void 0;
-			}
-			if (response.status === 304 && previous?.kind === "agent-view") return this.pageOfShown(owner, previous);
-			const text = new TextDecoder().decode(response.body);
-			const pageUrl = canonical(response.finalUrl === "" ? url : response.finalUrl);
-			const cached = this.documents.get(pageUrl);
-			const shown = await loadShown({
-				pageUrl,
-				...optionalFragment(response.finalUrl === "" ? url : response.finalUrl),
-				snapshot: "",
-				main: {
-					status: response.status,
-					...response.mediaType !== void 0 ? { mediaType: response.mediaType } : {},
-					finalUrl: response.finalUrl === "" ? url : response.finalUrl,
-					...response.link !== void 0 ? { link: response.link } : {},
-					...response.etag !== void 0 ? { etag: response.etag } : {},
-					body: text
-				},
-				domLinks: linksInHtml(text, response.finalUrl === "" ? url : response.finalUrl),
-				...cached !== void 0 ? { previous: cached } : {},
-				relocate: false,
-				fetch: (target, accept, ifNoneMatch) => this.fetchForRead(target, accept, ifNoneMatch, signal)
+		for (let hop = 0; hop < 10; hop += 1) {
+			const headers = { accept };
+			if (ifNoneMatch !== void 0 && hop === 0) headers["if-none-match"] = ifNoneMatch;
+			const response = await context.request.get(current, {
+				headers,
+				maxRedirects: 0,
+				failOnStatusCode: false,
+				...signal !== void 0 ? { signal } : {}
 			});
-			if (stopped(signal)) return STOPPED;
-			if (shown.kind !== "agent-view") return void 0;
-			this.rememberDocument(pageUrl, shown);
-			this.rememberOrigin(pageUrl);
-			return this.pageOfShown(owner, shown);
-		}
-		/** Keep the newest Agent Views. A dropped one is read in full the next time. */
-		rememberDocument(url, shown) {
-			const key = canonical(url);
-			this.documents.delete(key);
-			this.documents.set(key, shown);
-			while (this.documents.size > DOCUMENT_CAP) {
-				const oldest = this.documents.keys().next().value;
-				if (oldest === void 0) return;
-				this.documents.delete(oldest);
+			const status = response.status();
+			const location = response.headers().location;
+			if (status >= 300 && status < 400 && location !== void 0 && location !== "") {
+				let next;
+				try {
+					next = new URL(location, current);
+				} catch {
+					return;
+				}
+				if (next.origin !== origin) return void 0;
+				current = next.href;
+				continue;
 			}
-		}
-		/** One page from a document, with no tab. */
-		pageOfShown(owner, shown) {
-			const view = {
-				url: shown.pageUrl,
-				title: "",
-				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				representation: shown.kind === "agent-view" ? {
-					kind: "agent-view",
-					text: shown.text,
-					...shown.version !== void 0 ? { version: shown.version } : {},
-					...shown.href !== void 0 ? { href: shown.href } : {}
-				} : {
-					kind: "snapshot",
-					text: shown.snapshot,
-					...shown.agentViewError !== void 0 ? { agentViewError: shown.agentViewError } : {}
+			const headerMap = response.headers();
+			const mediaType = headerMap["content-type"];
+			const body = {
+				kind: "response",
+				finalUrl: current,
+				status,
+				body: readsAsText(mediaType) ? new Uint8Array(await untilAborted(response.body(), capped(signal, READ_MS))) : /* @__PURE__ */ new Uint8Array()
+			};
+			const etag = headerMap.etag;
+			const link = headerMap.link;
+			if (mediaType !== void 0) body.mediaType = mediaType;
+			if (etag !== void 0) body.etag = etag;
+			if (link !== void 0) body.link = link;
+			return body;
+		}
+	}
+	async openOne(owner, url, waitFor, signal, snapshot = false, reveal = false) {
+		assertWaitFor(waitFor);
+		const reused = this.idleTabOn(owner, url);
+		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
 				},
-				inPresence: this.book.isShown(owner, canonical(shown.pageUrl))
+				fresh
 			};
-			if (shown.fragment !== void 0) view.fragment = shown.fragment;
-			if (shown.status !== void 0) view.status = shown.status;
-			if (shown.mediaType !== void 0) view.mediaType = shown.mediaType;
-			if (shown.body !== void 0) view.body = shown.body;
-			return view;
-		}
-		/**
-		* GET that follows same-origin redirects only. `undefined` when it cannot.
-		* A body that is neither text nor an Agent View is not read: the page then
-		* goes to a tab, which loads it anyway.
-		*/
-		async fetchSameOrigin(url, accept, ifNoneMatch, signal) {
-			const context = this.context;
-			if (context === void 0) return void 0;
-			let current = url;
-			let origin;
-			try {
-				origin = new URL(url).origin;
-			} catch {
-				return;
-			}
-			for (let hop = 0; hop < 10; hop += 1) {
-				const headers = { accept };
-				if (ifNoneMatch !== void 0 && hop === 0) headers["if-none-match"] = ifNoneMatch;
-				const response = await context.request.get(current, {
-					headers,
-					maxRedirects: 0,
-					failOnStatusCode: false,
-					...signal !== void 0 ? { signal } : {}
-				});
-				const status = response.status();
-				const location = response.headers().location;
-				if (status >= 300 && status < 400 && location !== void 0 && location !== "") {
-					let next;
-					try {
-						next = new URL(location, current);
-					} catch {
-						return;
-					}
-					if (next.origin !== origin) return void 0;
-					current = next.href;
-					continue;
-				}
-				const headerMap = response.headers();
-				const mediaType = headerMap["content-type"];
-				const body = {
-					kind: "response",
-					finalUrl: current,
-					status,
-					body: readsAsText(mediaType) ? new Uint8Array(await untilAborted(response.body(), capped(signal, READ_MS))) : /* @__PURE__ */ new Uint8Array()
-				};
-				const etag = headerMap.etag;
-				const link = headerMap.link;
-				if (mediaType !== void 0) body.mediaType = mediaType;
-				if (etag !== void 0) body.etag = etag;
-				if (link !== void 0) body.link = link;
-				return body;
-			}
-		}
-		async openOne(owner, url, waitFor, signal, snapshot = false, reveal = false) {
-			assertWaitFor(waitFor);
-			const reused = this.idleTabOn(owner, url);
-			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);
-			try {
-				let seenDialog;
-				const dialogDuringGoto = nextDialog.dialog.then((dialog) => {
-					seenDialog = dialog;
-					return dialog;
-				});
-				let navigationError;
-				let response = null;
-				const raced = this.goto(live.page, url, linked.signal).then((value) => {
-					response = value;
-					return "navigated";
-				}, (error) => {
-					navigationError = error;
-					return "failed";
-				});
-				const winner = await Promise.race([raced, dialogDuringGoto.then((dialog) => ({ dialog }))]);
-				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), void 0, signal);
-						if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
-						this.applyDocumentType(live, view);
-						return {
-							view: await this.attachDownload(live, view, true),
-							fresh,
-							live
-						};
-					}
-					throw navigationError;
-				}
-				if (linked.signal.aborted) return {
-					view: {
-						tab: live.id,
-						url,
-						reason: WAITING_STOPPED
-					},
-					fresh,
-					live
-				};
-				const current = live.page.url();
-				const address = current === "about:blank" ? url : current;
-				this.windows.noteUrl(live, address);
-				const held = seenDialog ?? (typeof winner === "object" ? winner.dialog : void 0);
-				const dialog = held === void 0 ? void 0 : {
-					type: held.type(),
-					message: held.message()
-				};
-				if (held !== void 0) this.windows.holdDialog(live, held);
-				else this.windows.onNavigated(live);
-				const load = dialog !== void 0 ? {
-					load: false,
-					pendingRequests: 0,
-					dialog
-				} : await waitForLoad(live.page, linked.signal);
-				if (load.dialog !== void 0) this.windows.holdDialog(live);
-				let waited;
-				if (waitFor !== void 0 && load.dialog === void 0) {
-					const text = await waitForText(live.page, waitFor, linked.signal);
-					waited = {
-						met: text.met,
-						seconds: text.seconds
-					};
-					if (text.dialog !== void 0) this.windows.holdDialog(live);
-				}
-				this.windows.touch(live);
-				const shown = load.dialog !== void 0 ? await loadShown({
-					pageUrl: canonical(address),
-					...optionalFragment(address),
-					snapshot: "",
-					relocate: false,
-					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" } : {},
-					...load.load ? {} : { incomplete: {
-						load: load.load,
-						pendingRequests: load.pendingRequests
-					} },
-					...load.dialog !== void 0 ? { dialog: load.dialog } : {},
-					...waited !== void 0 ? { waited } : {}
-				}, signal);
-				return {
-					view: await this.attachDownload(live, view, false),
-					fresh,
-					live
-				};
-			} catch (error) {
-				nextDialog.cancel();
-				if (this.control.ofTab(owner, live.id) === "person") throw await this.takenOver(live);
-				if (linked.signal.aborted || error instanceof MhBrowserError && error.code === "INTERRUPTED") return {
-					view: {
-						tab: live.id,
-						url,
-						reason: WAITING_STOPPED
-					},
-					fresh,
-					live
-				};
-				return {
-					view: {
-						tab: live.id,
-						url,
-						reason: error instanceof Error ? error.message : String(error)
-					},
-					fresh,
-					live
-				};
-			} finally {
-				linked.release();
-			}
+			throw error;
 		}
-		async perform(live, op, signal) {
-			if (op.kind === "snapshot") return { navigated: false };
-			if (op.kind === "find") return {
-				navigated: false,
-				summary: findInSnapshot(await this.aria(live, signal), op)
-			};
-			if (op.kind === "evaluate") {
-				const snapshot = this.shown.get(live.id)?.snapshot ?? "";
-				const target = op.target === void 0 ? void 0 : await locate(live.page, op.target, snapshot);
-				return this.evaluateOn(live, op, target, signal);
-			}
-			if (op.kind === "take_screenshot") return this.shoot(live, op, signal);
-			if (op.kind === "file_upload") return this.uploadHeld(live, op, signal);
-			if (op.kind === "wait_for") {
-				const waitFor = waitFrom(op);
-				assertWaitFor(waitFor);
-				const text = await waitForText(live.page, waitFor, signal);
-				if (text.dialog !== void 0) this.windows.holdDialog(live);
-				return {
-					navigated: false,
-					waited: {
-						met: text.met,
-						seconds: text.seconds
-					},
-					...text.dialog !== void 0 ? { dialog: text.dialog } : {}
-				};
-			}
-			if (op.kind === "handle_dialog") {
-				const dialog = live.pendingDialog;
-				if (dialog === void 0) throw new MhBrowserError("INVALID_ARGS", "this page has no dialog");
-				const before = live.page.url();
-				if (op.accept) await (op.promptText !== void 0 ? dialog.accept(op.promptText) : dialog.accept());
-				else await dialog.dismiss();
-				this.windows.clearDialog(live);
-				const navigated = live.page.url() !== before;
-				return {
-					navigated,
-					...settled(await settleAction(live.page, navigated, void 0, signal))
-				};
-			}
-			const requests = trackActionRequests(live.page);
-			const nextDialog = this.windows.nextDialog(live);
-			const chooser = watchFileChooser(live.page);
-			const snapshot = this.shown.get(live.id)?.snapshot ?? "";
-			this.windows.beginDispatch(live.page);
-			try {
-				const finished = runAction(live.page, op, snapshot, signal).then((navigated) => ({
-					kind: "done",
-					navigated
-				}));
-				const appeared = nextDialog.dialog.then((dialog) => ({
-					kind: "dialog",
-					dialog
-				}));
-				const chose = chooser.opened.then((opened) => ({
-					kind: "chooser",
-					opened
-				}));
-				const winner = await Promise.race([
-					finished,
-					appeared,
-					chose
-				]).finally(() => {
-					this.windows.endDispatch(live.page);
-				});
-				if (winner.kind === "dialog") {
-					this.windows.holdDialog(live, winner.dialog);
-					finished.catch(() => void 0);
-					return {
-						navigated: false,
-						dialog: {
-							type: winner.dialog.type(),
-							message: winner.dialog.message()
-						}
-					};
-				}
-				if (winner.kind === "chooser") {
-					finished.catch(() => void 0);
+		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);
+		try {
+			let seenDialog;
+			const dialogDuringGoto = nextDialog.dialog.then((dialog) => {
+				seenDialog = dialog;
+				return dialog;
+			});
+			let navigationError;
+			let response = null;
+			const raced = this.goto(live.page, url, linked.signal).then((value) => {
+				response = value;
+				return "navigated";
+			}, (error) => {
+				navigationError = error;
+				return "failed";
+			});
+			const winner = await Promise.race([raced, dialogDuringGoto.then((dialog) => ({ dialog }))]);
+			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), void 0, signal);
+					if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
+					this.applyDocumentType(live, view);
 					return {
-						navigated: false,
-						dialog: this.chooserHeld(live, winner.opened)
+						view: await this.attachDownload(live, view, true),
+						fresh,
+						live
 					};
 				}
-				const settledLoad = await Promise.race([settleAction(live.page, winner.navigated, requests, signal), chooser.opened.then((opened) => ({
-					load: true,
-					pendingRequests: 0,
-					dialog: this.chooserHeld(live, opened)
-				}))]);
-				return {
-					navigated: winner.navigated,
-					...settled(settledLoad)
-				};
-			} finally {
-				requests.stop();
-				nextDialog.cancel();
-				chooser.stop();
+				throw navigationError;
 			}
-		}
-		/**
-		* `browser_evaluate`. A dialog the function opens is held like any other; a
-		* stop or a takeover ends the wait and still reports the writes already sent.
-		*/
-		async evaluateOn(live, op, target, signal) {
-			const nextDialog = this.windows.nextDialog(live);
-			let navigated = false;
-			const onNav = (frame) => {
-				if (frame.parentFrame() === null) navigated = true;
+			if (linked.signal.aborted) return {
+				view: {
+					tab: live.id,
+					url,
+					reason: WAITING_STOPPED
+				},
+				fresh,
+				live
 			};
-			live.page.on("framenavigated", onNav);
-			try {
-				const evaluated = await evaluateMarked(live.page, op.function, target, op.callId, signal, nextDialog.dialog);
-				const writes = formatWrites(evaluated.writes);
-				const counted = evaluated.writes.length === 0 ? {} : { writes: evaluated.writes };
-				if (evaluated.kind === "stopped") {
-					const note = writes === "" ? "" : `\n${writes}`;
-					if (this.control.ofTab(live.owner, live.id) === "person") throw await this.takenOver(live, note);
-					throw new MhBrowserError(INTERRUPTED, `${WAITING_STOPPED}${note}`);
-				}
-				if (evaluated.kind === "dialog") {
-					this.windows.holdDialog(live, evaluated.dialog);
-					return {
-						navigated: false,
-						dialog: {
-							type: evaluated.dialog.type(),
-							message: evaluated.dialog.message()
-						},
-						summary: "",
-						detail: writes,
-						...counted
-					};
-				}
-				if (evaluated.kind === "navigated") return {
-					navigated: true,
-					summary: NAVIGATED_DURING_EVALUATE,
-					detail: writes,
-					...counted
-				};
-				return {
-					navigated,
-					summary: evaluated.value,
-					detail: writes,
-					...counted
-				};
-			} finally {
-				live.page.off("framenavigated", onNav);
-				nextDialog.cancel();
-			}
-		}
-		async uploadHeld(live, op, signal) {
-			const chooser = live.fileChooser;
-			if (chooser === void 0) throw new MhBrowserError("INVALID_ARGS", "No file chooser visible");
-			const paths = op.paths;
-			if (paths === void 0 || paths.length === 0) {
-				live.fileChooser = void 0;
-				return { navigated: false };
-			}
-			const requests = trackActionRequests(live.page);
-			let navigated = false;
-			const onNav = (frame) => {
-				if (frame.parentFrame() === null) navigated = true;
+			const current = live.page.url();
+			const address = current === "about:blank" ? url : current;
+			this.windows.noteUrl(live, address);
+			const held = seenDialog ?? (typeof winner === "object" ? winner.dialog : void 0);
+			const dialog = held === void 0 ? void 0 : {
+				type: held.type(),
+				message: held.message()
 			};
-			live.page.on("framenavigated", onNav);
-			this.windows.beginDispatch(live.page);
-			try {
-				await chooser.setFiles(paths, signal === void 0 ? {} : { signal });
-				live.fileChooser = void 0;
-				await settleAction(live.page, navigated, requests, signal);
-				return { navigated };
-			} finally {
-				live.page.off("framenavigated", onNav);
-				this.windows.endDispatch(live.page);
-				requests.stop();
+			if (held !== void 0) this.windows.holdDialog(live, held);
+			else this.windows.onNavigated(live);
+			const load = dialog !== void 0 ? {
+				load: false,
+				pendingRequests: 0,
+				dialog
+			} : await waitForLoad(live.page, linked.signal);
+			if (load.dialog !== void 0) this.windows.holdDialog(live);
+			let waited;
+			if (waitFor !== void 0 && load.dialog === void 0) {
+				const text = await waitForText(live.page, waitFor, linked.signal);
+				waited = {
+					met: text.met,
+					seconds: text.seconds
+				};
+				if (text.dialog !== void 0) this.windows.holdDialog(live);
 			}
-		}
-		async shoot(live, op, signal) {
-			if (op.fullPage === true && op.target !== void 0) throw new MhBrowserError("INVALID_ARGS", "fullPage cannot be used with element screenshots.");
-			const type = op.type ?? "png";
-			const snapshot = this.shown.get(live.id)?.snapshot ?? "";
-			const locator = op.target === void 0 ? void 0 : await locate(live.page, op.target, snapshot);
-			const options = {
-				type,
-				...type === "jpeg" ? { quality: 90 } : {},
-				...op.scale !== void 0 ? { scale: op.scale } : {},
-				...op.fullPage === true ? { fullPage: true } : {},
-				...signal !== void 0 ? { signal } : {}
-			};
-			const bytes = locator === void 0 ? await live.page.screenshot(options) : await locator.screenshot(options);
-			return {
-				navigated: false,
-				shot: {
-					mediaType: `image/${type}`,
-					bytes: new Uint8Array(bytes)
-				}
-			};
-		}
-		/** A snapshot limited to a target, a depth, or boxes. Refs still resolve against the full one. */
-		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 ?? "";
-			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) {
-			live.fileChooser = chooser;
-			this.windows.holdInput(live);
+			this.windows.touch(live);
+			const shown = load.dialog !== void 0 ? await loadShown({
+				pageUrl: canonical(address),
+				...optionalFragment(address),
+				snapshot: "",
+				relocate: false,
+				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" } : {},
+				...load.load ? {} : { incomplete: {
+					load: load.load,
+					pendingRequests: load.pendingRequests
+				} },
+				...load.dialog !== void 0 ? { dialog: load.dialog } : {},
+				...waited !== void 0 ? { waited } : {}
+			}, signal);
 			return {
-				type: "filechooser",
-				message: chooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
+				view: await this.attachDownload(live, view, false),
+				fresh,
+				live
 			};
-		}
-		async refreshSnapshot(tab, signal) {
-			const previous = this.shown.get(tab.id);
-			const snapshot = tab.dialogHeld ? "" : await this.aria(tab, signal);
-			if (previous === void 0) return {
-				pageUrl: canonical(tab.page.url()),
-				digest: "",
-				kind: "snapshot",
-				text: snapshot,
-				snapshot
+		} catch (error) {
+			nextDialog.cancel();
+			if (this.control.ofTab(owner, live.id) === "person") throw await this.takenOver(live);
+			if (linked.signal.aborted || error instanceof MhBrowserError && error.code === "INTERRUPTED") return {
+				view: {
+					tab: live.id,
+					url,
+					reason: WAITING_STOPPED
+				},
+				fresh,
+				live
 			};
 			return {
-				...previous,
-				snapshot
+				view: {
+					tab: live.id,
+					url,
+					reason: error instanceof Error ? error.message : String(error)
+				},
+				fresh,
+				live
 			};
+		} finally {
+			linked.release();
 		}
-		async blockedView(tab) {
-			const dialog = tab.pendingDialog;
-			return this.pageFromShown(tab, this.shown.get(tab.id), {
-				surface: "snapshot",
-				...dialog !== void 0 ? { dialog: {
-					type: dialog.type(),
-					message: dialog.message()
-				} } : {}
-			});
-		}
-		async goto(page, url, signal) {
-			this.windows.beginDispatch(page);
-			try {
-				return await page.goto(url, {
-					waitUntil: "domcontentloaded",
-					timeout: NAVIGATION_MS,
-					...signal !== void 0 ? { signal } : {}
-				});
-			} finally {
-				this.windows.endDispatch(page);
-			}
-		}
-		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, signal);
-			const previous = this.shown.get(tab.id);
-			return loadShown({
-				pageUrl: canonical(address),
-				...optionalFragment(address),
-				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, signal)
-			});
-		}
-		fetchForRead(url, accept, ifNoneMatch, signal) {
-			return this.fetch(url, {
-				accept,
-				...ifNoneMatch !== void 0 ? { ifNoneMatch } : {},
-				...signal !== void 0 ? { signal } : {}
-			});
-		}
-		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, signal) {
-			const current = shown ?? {
-				pageUrl: canonical(tab.url),
-				digest: "",
-				kind: "snapshot",
-				text: "",
-				snapshot: ""
-			};
-			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,
-				url: current.pageUrl,
-				title,
-				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				representation: current.kind === "agent-view" ? {
-					kind: "agent-view",
-					text: current.text,
-					...current.version !== void 0 ? { version: current.version } : {},
-					...current.href !== void 0 ? { href: current.href } : {}
-				} : {
-					kind: "snapshot",
-					text: current.snapshot,
-					...current.agentViewError !== void 0 ? { agentViewError: current.agentViewError } : {}
+	}
+	async perform(live, op, signal) {
+		if (op.kind === "snapshot") return { navigated: false };
+		if (op.kind === "find") return {
+			navigated: false,
+			summary: findInSnapshot(await this.aria(live, signal), op)
+		};
+		if (op.kind === "evaluate") {
+			const snapshot = this.shown.get(live.id)?.snapshot ?? "";
+			const target = op.target === void 0 ? void 0 : await locate(live.page, op.target, snapshot);
+			return this.evaluateOn(live, op, target, signal);
+		}
+		if (op.kind === "take_screenshot") return this.shoot(live, op, signal);
+		if (op.kind === "file_upload") return this.uploadHeld(live, op, signal);
+		if (op.kind === "wait_for") {
+			const waitFor = waitFrom(op);
+			assertWaitFor(waitFor);
+			const text = await waitForText(live.page, waitFor, signal);
+			if (text.dialog !== void 0) this.windows.holdDialog(live);
+			return {
+				navigated: false,
+				waited: {
+					met: text.met,
+					seconds: text.seconds
 				},
-				inPresence: this.book.isShown(tab.owner, canonical(current.pageUrl))
+				...text.dialog !== void 0 ? { dialog: text.dialog } : {}
 			};
-			tab.inPresence = view.inPresence;
-			if (extra?.surface === "snapshot") view.representation = snapshotSurface(current);
-			if (current.fragment !== void 0) view.fragment = current.fragment;
-			if (current.status !== void 0) view.status = current.status;
-			if (current.mediaType !== void 0) view.mediaType = current.mediaType;
-			if (current.body !== void 0) view.body = current.body;
-			if (extra?.dialog !== void 0) view.dialog = extra.dialog;
-			if (extra?.incomplete !== void 0) view.incomplete = extra.incomplete;
-			if (extra?.waited !== void 0) view.waited = extra.waited;
-			return view;
-		}
-		/**
-		* Read one presence page. A known origin is read on the request channel,
-		* with If-None-Match when the document was read before. Anything else uses
-		* a tab already on the address, or opens one and closes it again.
-		*/
-		async observePresence(owner, url, signal) {
-			if (this.knownOrigin(url)) {
-				const via = await this.readKnown(owner, url, signal);
-				if (via === STOPPED) return observationOf(url, {
-					url,
-					reason: WAITING_STOPPED
-				});
-				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, signal));
-			const opened = await this.openOne(owner, url, void 0, signal, false);
-			this.keepAgentView(opened);
-			const view = opened.view;
-			if (opened.fresh && "tab" in view && view.tab !== void 0) {
-				const live = this.windows.get(owner, view.tab);
-				if (live !== void 0 && this.closable(owner, live)) {
-					const agent = "representation" in view && view.representation.kind === "agent-view";
-					await this.windows.closeTab(live, agent ? void 0 : `${live.id} (idle)`);
-					if (agent) {
-						const shown = { ...view };
-						delete shown.tab;
-						return observationOf(url, shown);
-					}
-				}
-			}
-			return observationOf(url, view);
 		}
-		tabOn(owner, url) {
-			const pageUrl = canonical(url);
-			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((tab) => tab !== void 0 && canonical(tab.url) === pageUrl);
-			tabs.sort((left, right) => right.touchedAt - left.touchedAt);
-			return tabs[0];
+		if (op.kind === "handle_dialog") {
+			const dialog = live.pendingDialog;
+			if (dialog === void 0) throw new MhBrowserError("INVALID_ARGS", "this page has no dialog");
+			const before = live.page.url();
+			if (op.accept) await (op.promptText !== void 0 ? dialog.accept(op.promptText) : dialog.accept());
+			else await dialog.dismiss();
+			this.windows.clearDialog(live);
+			const navigated = live.page.url() !== before;
+			return {
+				navigated,
+				...settled(await settleAction(live.page, navigated, void 0, signal))
+			};
 		}
-		async refreshView(live, signal) {
-			this.windows.touch(live);
-			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, signal),
-				...previous !== void 0 ? { previous } : {},
-				relocate: previous !== void 0 && !samePage(previous.pageUrl, address),
-				fetch: (url, accept, ifNoneMatch) => this.fetchForRead(url, accept, ifNoneMatch, signal)
+		const requests = trackActionRequests(live.page);
+		const nextDialog = this.windows.nextDialog(live);
+		const chooser = watchFileChooser(live.page);
+		const snapshot = this.shown.get(live.id)?.snapshot ?? "";
+		this.windows.beginDispatch(live.page);
+		try {
+			const finished = runAction(live.page, op, snapshot, signal).then((navigated) => ({
+				kind: "done",
+				navigated
+			}));
+			const appeared = nextDialog.dialog.then((dialog) => ({
+				kind: "dialog",
+				dialog
+			}));
+			const chose = chooser.opened.then((opened) => ({
+				kind: "chooser",
+				opened
+			}));
+			const winner = await Promise.race([
+				finished,
+				appeared,
+				chose
+			]).finally(() => {
+				this.windows.endDispatch(live.page);
 			});
-			this.shown.set(live.id, shown);
-			this.windows.noteUrl(live, address);
-			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) {
-			const pageUrl = canonical(url);
-			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((tab) => tab !== void 0 && canonical(tab.url) === pageUrl && !tab.occupied && this.control.ofTab(owner, tab.id) !== "person");
-			tabs.sort((left, right) => right.touchedAt - left.touchedAt);
-			return tabs[0];
-		}
-		/** Only Session windows are capped; the person's window is theirs to close. */
-		async enforceCap(owner) {
-			if (owner === "person") return;
-			await this.windows.enforceCap(owner);
-		}
-		/** Other tabs on this address: idle ones reload, occupied or taken ones are marked. */
-		async refreshIdle(owner, url, except, signal) {
-			const pageUrl = canonical(url);
-			const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((item) => item !== void 0 && canonical(item.url) === pageUrl);
-			for (const item of tabs) {
-				if (item.id === except) continue;
-				if (item.occupied || this.control.ofTab(owner, item.id) === "person") this.windows.markMayHaveChanged(item);
-				else await this.navigateTab(item, item.page.url(), signal);
+			if (winner.kind === "dialog") {
+				this.windows.holdDialog(live, winner.dialog);
+				finished.catch(() => void 0);
+				return {
+					navigated: false,
+					dialog: {
+						type: winner.dialog.type(),
+						message: winner.dialog.message()
+					}
+				};
 			}
-		}
-		async navigateTab(live, url, signal) {
-			try {
-				const response = await this.goto(live.page, url, signal);
-				this.windows.onNavigated(live);
-				const address = live.page.url();
-				this.windows.noteUrl(live, address === "about:blank" ? url : address);
-				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, signal);
-				this.shown.set(live.id, shown);
-				const view = await this.pageFromShown(live, shown, {
-					...load.load ? {} : { incomplete: {
-						load: load.load,
-						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), void 0, signal);
-					if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
-					this.applyDocumentType(live, view);
-					return this.attachDownload(live, view, true);
-				}
+			if (winner.kind === "chooser") {
+				finished.catch(() => void 0);
 				return {
-					tab: live.id,
-					url,
-					reason: error instanceof Error ? error.message : String(error)
+					navigated: false,
+					dialog: this.chooserHeld(live, winner.opened)
 				};
 			}
+			const settledLoad = await Promise.race([settleAction(live.page, winner.navigated, requests, signal), chooser.opened.then((opened) => ({
+				load: true,
+				pendingRequests: 0,
+				dialog: this.chooserHeld(live, opened)
+			}))]);
+			return {
+				navigated: winner.navigated,
+				...settled(settledLoad)
+			};
+		} finally {
+			requests.stop();
+			nextDialog.cancel();
+			chooser.stop();
 		}
-		async sendAction(request, signal) {
-			const context = this.context;
-			if (context === void 0) return { kind: "lost" };
-			try {
-				const response = await context.request.fetch(request.url, {
-					method: request.method,
-					headers: request.headers,
-					maxRedirects: 0,
-					maxRetries: 0,
-					failOnStatusCode: false,
-					...signal !== void 0 ? { signal } : {},
-					...request.multipart !== void 0 ? { multipart: request.multipart } : {},
-					...request.data !== void 0 ? { data: request.data } : {}
-				});
-				const headers = response.headers();
-				const location = headers.location;
-				const mediaType = headers["content-type"];
+	}
+	/**
+	* `browser_evaluate`. A dialog the function opens is held like any other; a
+	* stop or a takeover ends the wait and still reports the writes already sent.
+	*/
+	async evaluateOn(live, op, target, signal) {
+		const nextDialog = this.windows.nextDialog(live);
+		let navigated = false;
+		const onNav = (frame) => {
+			if (frame.parentFrame() === null) navigated = true;
+		};
+		live.page.on("framenavigated", onNav);
+		try {
+			const evaluated = await evaluateMarked(live.page, op.function, target, op.callId, signal, nextDialog.dialog);
+			const writes = formatWrites(evaluated.writes);
+			const counted = evaluated.writes.length === 0 ? {} : { writes: evaluated.writes };
+			if (evaluated.kind === "stopped") {
+				const note = writes === "" ? "" : `\n${writes}`;
+				if (this.control.ofTab(live.owner, live.id) === "person") throw await this.takenOver(live, note);
+				throw new MhBrowserError(INTERRUPTED, `${WAITING_STOPPED}${note}`);
+			}
+			if (evaluated.kind === "dialog") {
+				this.windows.holdDialog(live, evaluated.dialog);
 				return {
-					kind: "response",
-					status: response.status(),
-					body: new Uint8Array(await untilAborted(response.body(), capped(signal, READ_MS))),
-					...location === void 0 || location === "" ? {} : { location },
-					...mediaType === void 0 ? {} : { mediaType }
+					navigated: false,
+					dialog: {
+						type: evaluated.dialog.type(),
+						message: evaluated.dialog.message()
+					},
+					summary: "",
+					detail: writes,
+					...counted
 				};
-			} catch (error) {
-				if (signal?.aborted === true) throw new MhBrowserError(INTERRUPTED, "stopped after sending; it may have taken effect");
-				this.ctx.logger.debug("declared action was not answered: %s", errorText(error));
-				return { kind: "lost" };
 			}
+			if (evaluated.kind === "navigated") return {
+				navigated: true,
+				summary: NAVIGATED_DURING_EVALUATE,
+				detail: writes,
+				...counted
+			};
+			return {
+				navigated,
+				summary: evaluated.value,
+				detail: writes,
+				...counted
+			};
+		} finally {
+			live.page.off("framenavigated", onNav);
+			nextDialog.cancel();
+		}
+	}
+	async uploadHeld(live, op, signal) {
+		const chooser = live.fileChooser;
+		if (chooser === void 0) throw new MhBrowserError("INVALID_ARGS", "No file chooser visible");
+		const paths = op.paths;
+		if (paths === void 0 || paths.length === 0) {
+			live.fileChooser = void 0;
+			return { navigated: false };
+		}
+		const requests = trackActionRequests(live.page);
+		let navigated = false;
+		const onNav = (frame) => {
+			if (frame.parentFrame() === null) navigated = true;
+		};
+		live.page.on("framenavigated", onNav);
+		this.windows.beginDispatch(live.page);
+		try {
+			await chooser.setFiles(paths, signal === void 0 ? {} : { signal });
+			live.fileChooser = void 0;
+			await settleAction(live.page, navigated, requests, signal);
+			return { navigated };
+		} finally {
+			live.page.off("framenavigated", onNav);
+			this.windows.endDispatch(live.page);
+			requests.stop();
 		}
-		async saveResponse(url, root, signal) {
-			const context = this.context;
-			if (context === void 0) return {
-				kind: "error",
+	}
+	async shoot(live, op, signal) {
+		if (op.fullPage === true && op.target !== void 0) throw new MhBrowserError("INVALID_ARGS", "fullPage cannot be used with element screenshots.");
+		const type = op.type ?? "png";
+		const snapshot = this.shown.get(live.id)?.snapshot ?? "";
+		const locator = op.target === void 0 ? void 0 : await locate(live.page, op.target, snapshot);
+		const options = {
+			type,
+			...type === "jpeg" ? { quality: 90 } : {},
+			...op.scale !== void 0 ? { scale: op.scale } : {},
+			...op.fullPage === true ? { fullPage: true } : {},
+			...signal !== void 0 ? { signal } : {}
+		};
+		const bytes = locator === void 0 ? await live.page.screenshot(options) : await locator.screenshot(options);
+		return {
+			navigated: false,
+			shot: {
+				mediaType: `image/${type}`,
+				bytes: new Uint8Array(bytes)
+			}
+		};
+	}
+	/** A snapshot limited to a target, a depth, or boxes. Refs still resolve against the full one. */
+	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 ?? "";
+		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) {
+		live.fileChooser = chooser;
+		this.windows.holdInput(live);
+		return {
+			type: "filechooser",
+			message: chooser.isMultiple() ? "choose files (several allowed) with browser_file_upload" : "choose one file with browser_file_upload"
+		};
+	}
+	async refreshSnapshot(tab, signal) {
+		const previous = this.shown.get(tab.id);
+		const snapshot = tab.dialogHeld ? "" : await this.aria(tab, signal);
+		if (previous === void 0) return {
+			pageUrl: canonical(tab.page.url()),
+			digest: "",
+			kind: "snapshot",
+			text: snapshot,
+			snapshot
+		};
+		return {
+			...previous,
+			snapshot
+		};
+	}
+	async blockedView(tab) {
+		const dialog = tab.pendingDialog;
+		return this.pageFromShown(tab, this.shown.get(tab.id), {
+			surface: "snapshot",
+			...dialog !== void 0 ? { dialog: {
+				type: dialog.type(),
+				message: dialog.message()
+			} } : {}
+		});
+	}
+	async goto(page, url, signal) {
+		this.windows.beginDispatch(page);
+		try {
+			return await page.goto(url, {
+				waitUntil: "domcontentloaded",
+				timeout: NAVIGATION_MS,
+				...signal !== void 0 ? { signal } : {}
+			});
+		} finally {
+			this.windows.endDispatch(page);
+		}
+	}
+	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, signal);
+		const previous = this.shown.get(tab.id);
+		return loadShown({
+			pageUrl: canonical(address),
+			...optionalFragment(address),
+			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, signal)
+		});
+	}
+	fetchForRead(url, accept, ifNoneMatch, signal) {
+		return this.fetch(url, {
+			accept,
+			...ifNoneMatch !== void 0 ? { ifNoneMatch } : {},
+			...signal !== void 0 ? { signal } : {}
+		});
+	}
+	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, signal) {
+		const current = shown ?? {
+			pageUrl: canonical(tab.url),
+			digest: "",
+			kind: "snapshot",
+			text: "",
+			snapshot: ""
+		};
+		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,
+			url: current.pageUrl,
+			title,
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			representation: current.kind === "agent-view" ? {
+				kind: "agent-view",
+				text: current.text,
+				...current.version !== void 0 ? { version: current.version } : {},
+				...current.href !== void 0 ? { href: current.href } : {}
+			} : {
+				kind: "snapshot",
+				text: current.snapshot,
+				...current.agentViewError !== void 0 ? { agentViewError: current.agentViewError } : {}
+			},
+			inPresence: this.book.isShown(tab.owner, canonical(current.pageUrl))
+		};
+		tab.inPresence = view.inPresence;
+		if (extra?.surface === "snapshot") view.representation = snapshotSurface(current);
+		if (current.fragment !== void 0) view.fragment = current.fragment;
+		if (current.status !== void 0) view.status = current.status;
+		if (current.mediaType !== void 0) view.mediaType = current.mediaType;
+		if (current.body !== void 0) view.body = current.body;
+		if (extra?.dialog !== void 0) view.dialog = extra.dialog;
+		if (extra?.incomplete !== void 0) view.incomplete = extra.incomplete;
+		if (extra?.waited !== void 0) view.waited = extra.waited;
+		return view;
+	}
+	/**
+	* Read one presence page. A known origin is read on the request channel,
+	* with If-None-Match when the document was read before. Anything else uses
+	* a tab already on the address, or opens one and closes it again.
+	*/
+	async observePresence(owner, url, signal) {
+		if (this.knownOrigin(url)) {
+			const via = await this.readKnown(owner, url, signal);
+			if (via === STOPPED) return observationOf(url, {
 				url,
-				reason: "browser is not running"
-			};
-			try {
-				const { response, finalUrl } = await getWithCookies(context, url, signal);
-				const status = response.status;
-				const mediaType = response.headers.get("content-type") ?? void 0;
-				if (status < 200 || status >= 300) {
-					await response.body?.cancel().catch(() => void 0);
-					return {
-						kind: "error",
-						url: finalUrl,
-						status,
-						reason: `HTTP ${String(status)}`
-					};
+				reason: WAITING_STOPPED
+			});
+			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, signal));
+		const opened = await this.openOne(owner, url, void 0, signal, false);
+		this.keepAgentView(opened);
+		const view = opened.view;
+		if (opened.fresh && "tab" in view && view.tab !== void 0) {
+			const live = this.windows.get(owner, view.tab);
+			if (live !== void 0 && this.closable(owner, live)) {
+				const agent = "representation" in view && view.representation.kind === "agent-view";
+				await this.windows.closeTab(live, agent ? void 0 : `${live.id} (idle)`);
+				if (agent) {
+					const shown = { ...view };
+					delete shown.tab;
+					return observationOf(url, shown);
 				}
-				const written = await writeDownload(root, filenameFrom(response.headers.get("content-disposition") ?? void 0, finalUrl), response.body ?? emptyBody());
-				return {
-					kind: "saved",
-					path: written.path,
-					url: finalUrl,
-					bytes: written.bytes,
-					sha256: written.sha256,
-					observed: (/* @__PURE__ */ new Date()).toISOString(),
-					...mediaType === void 0 ? {} : { mediaType }
-				};
-			} catch (error) {
-				if (error instanceof MhBrowserError) throw error;
-				return {
-					kind: "error",
-					url,
-					reason: error instanceof Error ? error.message : String(error)
-				};
 			}
 		}
-		async attachDownload(live, view, wait) {
-			const saved = await this.takePendingDownload(live, wait);
-			if (saved !== void 0) view.download = saved;
-			return view;
+		return observationOf(url, view);
+	}
+	tabOn(owner, url) {
+		const pageUrl = canonical(url);
+		const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((tab) => tab !== void 0 && canonical(tab.url) === pageUrl);
+		tabs.sort((left, right) => right.touchedAt - left.touchedAt);
+		return tabs[0];
+	}
+	async refreshView(live, signal) {
+		this.windows.touch(live);
+		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, signal),
+			...previous !== void 0 ? { previous } : {},
+			relocate: previous !== void 0 && !samePage(previous.pageUrl, address),
+			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, void 0, signal);
+	}
+	/** The most recently touched idle tab on this address. A tab the person holds is left alone. */
+	idleTabOn(owner, url) {
+		const pageUrl = canonical(url);
+		const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((tab) => tab !== void 0 && canonical(tab.url) === pageUrl && !tab.occupied && this.control.ofTab(owner, tab.id) !== "person");
+		tabs.sort((left, right) => right.touchedAt - left.touchedAt);
+		return tabs[0];
+	}
+	/** Only Session windows are capped; the person's window is theirs to close. */
+	async enforceCap(owner) {
+		if (owner === "person") return;
+		await this.windows.enforceCap(owner);
+	}
+	/** Other tabs on this address: idle ones reload, occupied or taken ones are marked. */
+	async refreshIdle(owner, url, except, signal) {
+		const pageUrl = canonical(url);
+		const tabs = this.windows.list(owner).map((info) => this.windows.get(owner, info.tab)).filter((item) => item !== void 0 && canonical(item.url) === pageUrl);
+		for (const item of tabs) {
+			if (item.id === except) continue;
+			if (item.occupied || this.control.ofTab(owner, item.id) === "person") this.windows.markMayHaveChanged(item);
+			else await this.navigateTab(item, item.page.url(), signal);
 		}
-		async takePendingDownload(live, wait) {
-			if (live.pendingDownload === void 0 && wait) await live.page.waitForEvent("download", { timeout: DOWNLOAD_EVENT_MS }).catch(() => void 0);
-			const download = live.pendingDownload;
-			if (download === void 0) return void 0;
-			live.pendingDownload = void 0;
-			return this.savePlaywrightDownload(live.owner, download);
-		}
-		async savePlaywrightDownload(owner, download) {
-			const target = this.workspaces.get(owner);
-			const url = download.url();
-			if (target === void 0) return {
-				kind: "error",
+	}
+	async navigateTab(live, url, signal) {
+		try {
+			const response = await this.goto(live.page, url, signal);
+			this.windows.onNavigated(live);
+			const address = live.page.url();
+			this.windows.noteUrl(live, address === "about:blank" ? url : address);
+			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, signal);
+			this.shown.set(live.id, shown);
+			const view = await this.pageFromShown(live, shown, {
+				...load.load ? {} : { incomplete: {
+					load: load.load,
+					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), void 0, signal);
+				if (view.url === "" || view.url === "about:blank") view.url = canonical(url);
+				this.applyDocumentType(live, view);
+				return this.attachDownload(live, view, true);
+			}
+			return {
+				tab: live.id,
 				url,
-				reason: NO_WORKSPACE_REASON
+				reason: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	async sendAction(request, signal) {
+		const context = this.context;
+		if (context === void 0) return { kind: "lost" };
+		try {
+			const response = await context.request.fetch(request.url, {
+				method: request.method,
+				headers: request.headers,
+				maxRedirects: 0,
+				maxRetries: 0,
+				failOnStatusCode: false,
+				...signal !== void 0 ? { signal } : {},
+				...request.multipart !== void 0 ? { multipart: request.multipart } : {},
+				...request.data !== void 0 ? { data: request.data } : {}
+			});
+			const headers = response.headers();
+			const location = headers.location;
+			const mediaType = headers["content-type"];
+			return {
+				kind: "response",
+				status: response.status(),
+				body: new Uint8Array(await untilAborted(response.body(), capped(signal, READ_MS))),
+				...location === void 0 || location === "" ? {} : { location },
+				...mediaType === void 0 ? {} : { mediaType }
 			};
-			if ("denied" in target) {
-				await download.cancel().catch(() => void 0);
+		} catch (error) {
+			if (signal?.aborted === true) throw new MhBrowserError(INTERRUPTED, "stopped after sending; it may have taken effect");
+			this.ctx.logger.debug("declared action was not answered: %s", errorText(error));
+			return { kind: "lost" };
+		}
+	}
+	async saveResponse(url, root, signal) {
+		const context = this.context;
+		if (context === void 0) return {
+			kind: "error",
+			url,
+			reason: "browser is not running"
+		};
+		try {
+			const { response, finalUrl } = await getWithCookies(context, url, signal);
+			const status = response.status;
+			const mediaType = response.headers.get("content-type") ?? void 0;
+			if (status < 200 || status >= 300) {
+				await response.body?.cancel().catch(() => void 0);
 				return {
 					kind: "error",
-					url,
-					reason: target.denied
+					url: finalUrl,
+					status,
+					reason: `HTTP ${String(status)}`
 				};
 			}
-			const written = await writeDownload(target.root, download.suggestedFilename(), await download.createReadStream());
+			const written = await writeDownload(root, filenameFrom(response.headers.get("content-disposition") ?? void 0, finalUrl), response.body ?? emptyBody());
 			return {
 				kind: "saved",
 				path: written.path,
-				url,
+				url: finalUrl,
 				bytes: written.bytes,
 				sha256: written.sha256,
-				observed: (/* @__PURE__ */ new Date()).toISOString()
+				observed: (/* @__PURE__ */ new Date()).toISOString(),
+				...mediaType === void 0 ? {} : { mediaType }
+			};
+		} catch (error) {
+			if (error instanceof MhBrowserError) throw error;
+			return {
+				kind: "error",
+				url,
+				reason: error instanceof Error ? error.message : String(error)
 			};
 		}
-		applyDocumentType(live, view) {
-			const type = live.documentType;
-			if (view.mediaType === void 0 && type !== void 0) {
-				const bare = type.split(";")[0]?.trim().toLowerCase() ?? "";
-				if (bare !== "" && bare !== "text/html") view.mediaType = type;
-			}
-			if (view.status === void 0 && live.documentStatus !== void 0 && live.documentStatus >= 300) view.status = live.documentStatus;
-		}
-		/** A failed launch is logged here; calls that need the browser see it as `BROWSER_UNAVAILABLE`. */
-		launch() {
-			const started = this.start().catch((error) => {
-				const reason = error instanceof Error ? error.message : String(error);
-				this.ctx.logger.warn("browser did not start: %s", reason);
-				throw new MhBrowserError(BROWSER_UNAVAILABLE, `the browser did not start: ${reason}`);
-			});
-			started.catch(() => void 0);
-			return started;
-		}
-		async start() {
-			const context = await launchBrowser(this.launchOptions);
-			const pid = await browserPid(context, this.launchOptions.profileDir);
-			if (pid !== void 0) this.pids.set(context, pid);
-			if (this.closing) {
-				await this.closeContext(context);
-				return;
-			}
-			this.context = context;
-			try {
-				await this.windows.attach(context, this.launchOptions.profileDir, { headed: !this.launchOptions.headless });
-			} catch (error) {
-				this.context = void 0;
-				this.windows.dropPages();
-				await this.closeContext(context);
-				throw error;
-			}
-			context.browser()?.on("disconnected", () => {
-				if (this.closing || this.context !== context) return;
-				this.onExit();
-			});
+	}
+	async attachDownload(live, view, wait) {
+		const saved = await this.takePendingDownload(live, wait);
+		if (saved !== void 0) view.download = saved;
+		return view;
+	}
+	async takePendingDownload(live, wait) {
+		if (live.pendingDownload === void 0 && wait) await live.page.waitForEvent("download", { timeout: DOWNLOAD_EVENT_MS }).catch(() => void 0);
+		const download = live.pendingDownload;
+		if (download === void 0) return void 0;
+		live.pendingDownload = void 0;
+		return this.savePlaywrightDownload(live.owner, download);
+	}
+	async savePlaywrightDownload(owner, download) {
+		const target = this.workspaces.get(owner);
+		const url = download.url();
+		if (target === void 0) return {
+			kind: "error",
+			url,
+			reason: NO_WORKSPACE_REASON
+		};
+		if ("denied" in target) {
+			await download.cancel().catch(() => void 0);
+			return {
+				kind: "error",
+				url,
+				reason: target.denied
+			};
 		}
-		/** No window opens on exit: the person may have quit it. Calls on old tabs find none. */
-		onExit() {
-			this.windows.suppressPersonInput();
-			this.windows.dropPages();
-			this.context = void 0;
-			this.exits.push(Date.now());
-			this.exited = true;
-			this.ready = Promise.resolve();
-		}
-		/**
-		* The browser for a call that needs a page. One that is not running starts
-		* again here. The exit limit stops unattended restarts; a person's request
-		* is one start per click and skips it.
-		*/
-		up(byPerson = false) {
-			if (!this.exited || this.closing) return this.ready;
-			const now = Date.now();
-			while (this.exits.length > 0 && now - (this.exits[0] ?? now) > RELAUNCH_WINDOW_MS) this.exits.shift();
-			if (!byPerson && this.exits.length > RELAUNCH_LIMIT) {
-				this.ctx.logger.warn("browser keeps stopping; not starting it again yet");
-				return Promise.reject(new MhBrowserError(BROWSER_UNAVAILABLE, `the browser stopped or did not start ${String(this.exits.length)} times within ${String(RELAUNCH_WINDOW_MS / 1e3)} s; try again in a minute`));
-			}
-			this.exited = false;
-			const started = this.launch();
-			started.then(() => this.windows.resumePersonInput(), () => {
-				this.exited = true;
-				if (!this.closing) this.exits.push(Date.now());
-			});
-			this.ready = started;
-			return started;
+		const written = await writeDownload(target.root, download.suggestedFilename(), await download.createReadStream());
+		return {
+			kind: "saved",
+			path: written.path,
+			url,
+			bytes: written.bytes,
+			sha256: written.sha256,
+			observed: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	applyDocumentType(live, view) {
+		const type = live.documentType;
+		if (view.mediaType === void 0 && type !== void 0) {
+			const bare = type.split(";")[0]?.trim().toLowerCase() ?? "";
+			if (bare !== "" && bare !== "text/html") view.mediaType = type;
+		}
+		if (view.status === void 0 && live.documentStatus !== void 0 && live.documentStatus >= 300) view.status = live.documentStatus;
+	}
+	/** A failed launch is logged here; calls that need the browser see it as `BROWSER_UNAVAILABLE`. */
+	launch() {
+		const started = this.start().catch((error) => {
+			const reason = error instanceof Error ? error.message : String(error);
+			this.ctx.logger.warn("browser did not start: %s", reason);
+			const notFound = error instanceof BrowserNotFoundError ? error.notFound : void 0;
+			throw new MhBrowserError(BROWSER_UNAVAILABLE, `the browser did not start: ${reason}`, void 0, notFound);
+		});
+		started.catch(() => void 0);
+		return started;
+	}
+	async start() {
+		const env = this.locateEnv();
+		const remembered = await readLastBrowser(this.profileRoot);
+		const configured = this.executablePath.get();
+		const plan = await planLaunch({
+			choice: this.browserName.get(),
+			configured,
+			root: this.profileRoot,
+			split: this.splitProfile,
+			env,
+			remembered,
+			bundled: bundledChromiumLocation(env.access)
+		});
+		const epoch = this.configEpoch;
+		const context = await launchBrowser({
+			browser: plan.browser,
+			headless: this.headless,
+			profileDir: plan.profileDir,
+			...plan.channel ? {} : { channel: false },
+			...plan.executablePath !== void 0 ? { executablePath: plan.executablePath } : {}
+		}, env);
+		const pid = await browserPid(context, plan.profileDir);
+		if (pid !== void 0) this.pids.set(context, pid);
+		if (this.closing) {
+			await this.closeContext(context);
+			return;
 		}
-		async stop() {
-			this.windows.suppressPersonInput();
-			await Promise.race([this.ready.catch(() => void 0), new Promise((resolve) => setTimeout(resolve, STOP_WAIT_MS))]);
-			const context = this.context;
+		this.context = context;
+		try {
+			await this.windows.attach(context, plan.profileDir, { headed: !this.headless });
+		} catch (error) {
 			this.context = void 0;
-			if (context !== void 0) await this.closeContext(context);
-		}
-		/** Close a context the service is done with, and kill it if close stalls. */
-		async closeContext(context) {
-			await closeOrKill(() => context.close(), this.pids.get(context));
-			this.pids.delete(context);
+			this.windows.dropPages();
+			await this.closeContext(context);
+			throw error;
 		}
-		refuseIfPerson(owner, tab) {
-			if (this.control.ofTab(owner, tab) !== "person") return;
-			throw new MhBrowserError("PERSON_IN_CONTROL", "the person is using this tab; call browser_handover with this tab to wait until they hand it back, or work in another tab");
+		if (plan.remember !== void 0) await writeLastBrowser(this.profileRoot, plan.remember).catch((error) => {
+			const reason = error instanceof Error ? error.message : String(error);
+			this.ctx.logger.warn("browser choice was not recorded: %s", reason);
+		});
+		if (this.configEpoch === epoch) this.relaunchWanted = false;
+		context.browser()?.on("disconnected", () => {
+			if (this.closing || this.replacing || this.context !== context) return;
+			this.onExit();
+		});
+	}
+	/** No window opens on exit: the person may have quit it. Calls on old tabs find none. */
+	onExit() {
+		this.windows.suppressPersonInput();
+		this.windows.dropPages();
+		this.context = void 0;
+		this.exits.push(Date.now());
+		this.exited = true;
+		this.ready = Promise.resolve();
+	}
+	/**
+	* The browser for a call that needs a page. One that is not running starts
+	* again here. The exit limit stops unattended restarts; a person's request
+	* is one start per click and skips it.
+	*/
+	up(byPerson = false) {
+		if (!this.exited || this.closing) return this.ready;
+		const now = Date.now();
+		while (this.exits.length > 0 && now - (this.exits[0] ?? now) > RELAUNCH_WINDOW_MS) this.exits.shift();
+		if (!byPerson && this.exits.length > RELAUNCH_LIMIT) {
+			this.ctx.logger.warn("browser keeps stopping; not starting it again yet");
+			return Promise.reject(new MhBrowserError(BROWSER_UNAVAILABLE, `the browser stopped or did not start ${String(this.exits.length)} times within ${String(RELAUNCH_WINDOW_MS / 1e3)} s; try again in a minute`));
+		}
+		this.exited = false;
+		const started = this.launch();
+		started.then(() => this.windows.resumePersonInput(), () => {
+			this.exited = true;
+			if (!this.closing) this.exits.push(Date.now());
+		});
+		this.ready = started;
+		return started;
+	}
+	async stop() {
+		this.windows.suppressPersonInput();
+		await Promise.race([this.ready.catch(() => void 0), new Promise((resolve) => setTimeout(resolve, STOP_WAIT_MS))]);
+		const context = this.context;
+		this.context = void 0;
+		if (context !== void 0) await this.closeContext(context);
+	}
+	/** Close a context the service is done with, and kill it if close stalls. */
+	async closeContext(context) {
+		await closeOrKill(() => context.close(), this.pids.get(context));
+		this.pids.delete(context);
+	}
+	refuseIfPerson(owner, tab) {
+		if (this.control.ofTab(owner, tab) !== "person") return;
+		throw new MhBrowserError("PERSON_IN_CONTROL", "the person is using this tab; call browser_handover with this tab to wait until they hand it back, or work in another tab");
+	}
+	async takenOver(live, note = "") {
+		try {
+			const page = await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" });
+			return new MhBrowserError("TAKEN_OVER", `${MAY_HAVE_TAKEN_EFFECT}${note}`, page);
+		} catch {
+			return new MhBrowserError("TAKEN_OVER", `${MAY_HAVE_TAKEN_EFFECT}${note}`);
 		}
-		async takenOver(live, note = "") {
-			try {
-				const page = await this.pageFromShown(live, this.shown.get(live.id), { surface: "snapshot" });
-				return new MhBrowserError("TAKEN_OVER", `${MAY_HAVE_TAKEN_EFFECT}${note}`, page);
-			} catch {
-				return new MhBrowserError("TAKEN_OVER", `${MAY_HAVE_TAKEN_EFFECT}${note}`);
-			}
+	}
+	presenceUrls(owner, tabs) {
+		const known = new Set(this.book.entries(owner).map((page) => page.url));
+		const urls = [];
+		for (const id of tabs) {
+			const address = this.windows.urlOf(owner, id);
+			if (address === void 0) continue;
+			const url = canonical(address);
+			if (!known.has(url) || urls.includes(url)) continue;
+			urls.push(url);
 		}
-		presenceUrls(owner, tabs) {
-			const known = new Set(this.book.entries(owner).map((page) => page.url));
-			const urls = [];
-			for (const id of tabs) {
-				const address = this.windows.urlOf(owner, id);
-				if (address === void 0) continue;
-				const url = canonical(address);
-				if (!known.has(url) || urls.includes(url)) continue;
-				urls.push(url);
+		return urls;
+	}
+	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, signal);
+		this.shown.set(live.id, shown);
+		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 queued.run;
+	}
+	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;
 			}
-			return urls;
-		}
-		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, signal);
-			this.shown.set(live.id, shown);
-			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);
+			this.ready.then(() => this.relaunchIfIdle(), () => {
+				this.relaunchWanted = false;
 			});
-			return queued.run;
+			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;
+		}
+	}
+};
 const MAX_REDIRECTS = 10;
 /** GET with the profile's cookies for each hop, so the body can be streamed. */
 async function getWithCookies(context, url, signal) {
@@ -7541,6 +8379,7 @@ const inject = [
 ];
 const Config = browserConfig;
 async function apply(ctx, config) {
+	const resolved = browserSettings(config);
 	ctx.plugin({
 		name: "mh-browser-slot",
 		inject: ["browserUse", "mhBrowser"],
@@ -7548,16 +8387,30 @@ async function apply(ctx, config) {
 			inner.browserUse.register("mh-browser");
 		}
 	});
-	await ctx.plugin(MhBrowserService, config);
+	await ctx.plugin(MhBrowserService, resolved);
+	ctx.plugin(browserRoutesPlugin);
 	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 };