@orkestrel/browser 0.0.20 → 0.0.22

package/dist/src/core/index.cjs

@@ -128,6 +128,16 @@ var BROWSER_SNAPSHOT_NODE_LIMIT = 1e5;
 var BROWSER_FRAME_WORLD_NAME = "__orkestrelBrowserFrame";
 /** Sets the number of animation frames whose element bounds must agree before trusted input. */
 var BROWSER_STABLE_FRAME_COUNT = 2;
+/**
+* Names the finished transitions and animations that wake a parked wait.
+*
+* @remarks
+* Chromium 154.0.4258.53 delivers these events in main and isolated worlds after a
+* visibility or discrete display exit. Opacity alone leaves text in `innerText`.
+*/
+var BROWSER_WAIT_EVENTS = Object.freeze(["transitionend", "animationend"]);
+/** Matches protocol errors caused by replacement or closure of an execution context. */
+var BROWSER_CONTEXT_LOSS_PATTERN = /execution context was destroyed|cannot find context with specified id|inspected target navigated or closed/i;
 /** Maps a canonical modifier name to its CDP Input modifier bit value. */
 var BROWSER_KEY_MODIFIERS = Object.freeze({
 	Alt: 1,
@@ -153,7 +163,7 @@ var BROWSER_MOUSE_BUTTON_MASKS = Object.freeze({
 */
 var BROWSER_HAR_CREATOR = Object.freeze({
 	name: "@orkestrel/browser",
-	version: "0.0.20"
+	version: "0.0.22"
 });
 /** Names the attribute that tags temporary screenshot styles and masks. */
 var BROWSER_SCREENSHOT_ATTRIBUTE = "data-orkestrel-screenshot";
@@ -263,6 +273,15 @@ var BROWSER_REGISTRY_OUTPUT_LIMIT = 4096;
 var BROWSER_REFERENCE_PREFIX = "e";
 /** Bounds the default number of actionable elements in an outline. */
 var BROWSER_OUTLINE_LIMIT = 150;
+/**
+* Matches one word of an outline search and of a row's role and name: a run of at least 3 letters
+* or digits.
+*
+* @remarks
+* The 3-character floor drops words such as `a`, `to`, and `of`, which would otherwise score a row
+* whose name shares them with the search.
+*/
+var BROWSER_SEARCH_PATTERN = /[\p{L}\p{N}]{3,}/gu;
 /** Names accessibility roles that receive actionable outline references. */
 var BROWSER_INTERACTIVE_ROLES = Object.freeze(/* @__PURE__ */ new Set([
 	"button",
@@ -384,6 +403,7 @@ var BROWSER_TOOL_PENDING_NOTE = "An earlier input is still pending; call look.";
 var BROWSER_OBSERVATION_TOOL_NAMES = Object.freeze([
 	"look",
 	"read",
+	"plain",
 	"tabs"
 ]);
 /**
@@ -393,15 +413,15 @@ var BROWSER_OBSERVATION_TOOL_NAMES = Object.freeze([
 */
 var BROWSER_TOOL_CHANGED_NOTE = "(The page changed before the view could be read; call look.)";
 /**
-* Holds the clause that ends the footer of a cut result that carries no view: a read note, a tab
-* list, a wait, a page tool's output, or an error message.
+* Holds the clause that ends the footer of a cut result other than an action or `dialog` receipt
+* that carries a view, including `look` and `read` results.
 */
 var BROWSER_TOOL_CUT_FOOTER = "the rest was cut";
 /**
-* Holds the clause that ends the footer of a cut result that carries a view, the result of
-* `look` and of every action, and names `read` as the call that returns the page's text.
+* Holds the clause that ends the footer of a cut action or `dialog` receipt that carries a view,
+* and names `look` as the call that finds an element the cut view leaves out.
 */
-var BROWSER_TOOL_VIEW_FOOTER = "the rest was cut; call read for the page's text";
+var BROWSER_TOOL_VIEW_FOOTER = "the rest was cut; call look with words to find";
 /**
 * Names the accessibility roles the `type` tool writes to: `textbox`, `searchbox`, and
 * `spinbutton` take typed text, and `combobox` and `listbox` take a select control's option
@@ -423,12 +443,13 @@ var BROWSER_TYPED_ROLES = Object.freeze(/* @__PURE__ */ new Set([
 /** Caps the `wait` tool's `timeout` parameter at `30_000` milliseconds. */
 var BROWSER_TOOL_TIMEOUT_LIMIT_MS = 3e4;
 /**
-* Names every tool the browser toolset reserves: `look`, `read`, `click`, `type`, `press`,
+* Names every tool the browser toolset reserves: `look`, `read`, `plain`, `click`, `type`, `press`,
 * `navigate`, `wait`, `dialog`, `tabs`, and `switch`.
 */
 var BROWSER_TOOL_NAMES = Object.freeze([
 	"look",
 	"read",
+	"plain",
 	"click",
 	"type",
 	"press",
@@ -459,14 +480,15 @@ var BROWSER_SCHEMES = Object.freeze(["http:", "https:"]);
 *
 * @remarks
 * Every tool description is at most 25 words and says what the tool shows or does, and for
-* `look` and `read` when to call it; every parameter description is at most 100 characters.
+* `look`, `read`, and `plain` when to call it; every parameter description is at most 100 characters.
 * Every tool declares at least one required parameter, because the streamed tool-call parser of
-* Ollama 0.34.4 rejects a call to a tool that declares no parameter. `look` takes `what` alone
-* and `read` takes `what` and `offset`; neither is scoped to an element, and an element's own
-* reading is `BrowserElementInterface.read`. `look`, `read`, and `journeys` annotate `pure` and
+* Ollama 0.34.4 rejects a call to a tool that declares no parameter. `look`, `read`, and `plain` take
+* `search` and `offset`; an element's own reading is `BrowserElementInterface.read`.
+* `look`, `read`, `plain`, and `journeys` annotate `pure` and
 * `untrusted`, `wait` and `tabs` annotate `pure`, and the rest carry no annotation. `type` takes
 * `secret` beside `ref`, `text`, and `submit`. The journey tools `record`, `save`, `journeys`,
 * `edit`, and `replay` are advertised only by a toolset constructed with `journeys`.
+* `wait` takes `absent` beside `text` and `timeout`.
 */
 var BROWSER_TOOL_COPY = Object.freeze({
 	look: Object.freeze({
@@ -474,11 +496,17 @@ var BROWSER_TOOL_COPY = Object.freeze({
 		description: "Shows the page's text and the elements you can act on, each with a reference like e4. Call it first and after the page changes.",
 		parameters: Object.freeze({
 			type: "object",
-			properties: Object.freeze({ what: Object.freeze({
-				type: "string",
-				description: "What you want to find or act on."
-			}) }),
-			required: Object.freeze(["what"])
+			properties: Object.freeze({
+				search: Object.freeze({
+					type: "string",
+					description: "Words to find on this page; matching elements come first."
+				}),
+				offset: Object.freeze({
+					type: "integer",
+					description: "The character to continue from, as the last reply names. Default: 0."
+				})
+			}),
+			required: Object.freeze(["search"])
 		}),
 		annotations: Object.freeze({
 			pure: true,
@@ -487,20 +515,42 @@ var BROWSER_TOOL_COPY = Object.freeze({
 	}),
 	read: Object.freeze({
 		name: "read",
-		description: "Reads the page's text for what you name. Call it to learn a fact; continue with the offset a cut result names.",
+		description: "Reads the page as Markdown, with headings, tables, and link addresses. Call it to learn a fact; continue with the offset a cut result names.",
+		parameters: Object.freeze({
+			type: "object",
+			properties: Object.freeze({
+				search: Object.freeze({
+					type: "string",
+					description: "Words to find on this page; the lines that share them come first."
+				}),
+				offset: Object.freeze({
+					type: "integer",
+					description: "The character to continue from, as the last reply names. Default: 0."
+				})
+			}),
+			required: Object.freeze(["search"])
+		}),
+		annotations: Object.freeze({
+			pure: true,
+			untrusted: true
+		})
+	}),
+	plain: Object.freeze({
+		name: "plain",
+		description: "Reads the page as plain text, without Markdown, link addresses, or image text. Call it for words to pass to wait or type.",
 		parameters: Object.freeze({
 			type: "object",
 			properties: Object.freeze({
-				what: Object.freeze({
+				search: Object.freeze({
 					type: "string",
-					description: "What you want to learn from the page."
+					description: "Words to find on this page; the lines that share them come first."
 				}),
 				offset: Object.freeze({
 					type: "integer",
 					description: "The character to continue from, as the last reply names. Default: 0."
 				})
 			}),
-			required: Object.freeze(["what"])
+			required: Object.freeze(["search"])
 		}),
 		annotations: Object.freeze({
 			pure: true,
@@ -571,7 +621,7 @@ var BROWSER_TOOL_COPY = Object.freeze({
 	}),
 	wait: Object.freeze({
 		name: "wait",
-		description: "Waits for that text to appear on the page.",
+		description: "Waits for text to appear; set absent to true to wait for it to leave.",
 		parameters: Object.freeze({
 			type: "object",
 			properties: Object.freeze({
@@ -579,6 +629,10 @@ var BROWSER_TOOL_COPY = Object.freeze({
 					type: "string",
 					description: "The text to wait for."
 				}),
+				absent: Object.freeze({
+					type: "boolean",
+					description: "True to wait for the text to leave the page."
+				}),
 				timeout: Object.freeze({
 					type: "integer",
 					description: "The most seconds to wait, at most 30. Default: 5."
@@ -611,11 +665,11 @@ var BROWSER_TOOL_COPY = Object.freeze({
 		description: "Lists the open tabs; the current one is marked.",
 		parameters: Object.freeze({
 			type: "object",
-			properties: Object.freeze({ what: Object.freeze({
+			properties: Object.freeze({ search: Object.freeze({
 				type: "string",
-				description: "What you are looking for."
+				description: "Words to find; matching tabs come first."
 			}) }),
-			required: Object.freeze(["what"])
+			required: Object.freeze(["search"])
 		}),
 		annotations: Object.freeze({ pure: true })
 	}),
@@ -661,16 +715,16 @@ var BROWSER_TOOL_COPY = Object.freeze({
 		parameters: Object.freeze({
 			type: "object",
 			properties: Object.freeze({
-				what: Object.freeze({
+				search: Object.freeze({
 					type: "string",
-					description: "What you are looking for."
+					description: "Words to find; matching journeys come first."
 				}),
 				offset: Object.freeze({
 					type: "integer",
 					description: "The character to continue from, as the last reply names. Default: 0."
 				})
 			}),
-			required: Object.freeze(["what"])
+			required: Object.freeze(["search"])
 		}),
 		annotations: Object.freeze({
 			pure: true,
@@ -1627,17 +1681,265 @@ function filterBrowserOutline(nodes, query) {
 	return nodes.filter((node) => !node.ignored && !BROWSER_OUTLINE_OMITTED_ROLES.has(node.role ?? "") && (query.role === void 0 || node.role === query.role) && (query.name === void 0 || (query.exact === true ? normalizeBrowserName(node.name ?? "") === normalizeBrowserName(query.name) : normalizeBrowserName(node.name ?? "").toLowerCase().includes(normalizeBrowserName(query.name).toLowerCase()))));
 }
 /**
+* Renders one outline row: the node's reference, its role, its quoted accessible name, and the
+* states it carries.
+*
+* @remarks
+* After the name the row appends `value="V"` when the node carries a non-empty value,
+* `pressed=true|false|mixed`, `expanded=true|false`, and `selected=true|false` when present,
+* `[checked]` when checked, `[disabled]` when disabled, and `[tool=NAME]` for a page tool's form,
+* in that order. A node without a reference renders without one.
+*
+* @param node - The outline node
+* @returns The rendered row
+*
+* @example
+* ```ts
+* import { renderBrowserOutlineRow } from '@orkestrel/browser'
+*
+* renderBrowserOutlineRow({
+* 	id: '4',
+* 	parent: undefined,
+* 	children: [],
+* 	backend: undefined,
+* 	frame: undefined,
+* 	ignored: false,
+* 	role: 'checkbox',
+* 	name: ' Gift  wrap ',
+* 	description: undefined,
+* 	value: undefined,
+* 	properties: { checked: 'true' },
+* 	session: 'main',
+* 	reference: 'e4',
+* }) // 'e4 checkbox "Gift wrap" [checked]'
+* ```
+*/
+function renderBrowserOutlineRow(node) {
+	const name = JSON.stringify(normalizeBrowserName(node.name ?? ""));
+	const role = node.role ?? "unknown";
+	let row = node.reference === void 0 ? `${role} ${name}` : `${node.reference} ${role} ${name}`;
+	if (node.value !== void 0 && node.value !== "") row += ` value=${JSON.stringify(String(node.value))}`;
+	for (const key of [
+		"pressed",
+		"expanded",
+		"selected"
+	]) {
+		const value = node.properties[key];
+		if ((0, _orkestrel_contract.isString)(value) || (0, _orkestrel_contract.isBoolean)(value)) row += ` ${key}=${String(value)}`;
+	}
+	if (node.properties["checked"] === true || node.properties["checked"] === "true") row += " [checked]";
+	if (node.properties["disabled"] === true) row += " [disabled]";
+	if (node.tool !== void 0) row += ` [tool=${node.tool}]`;
+	return row;
+}
+/**
+* Returns the referenced outline nodes whose role and accessible name share the most words with a
+* search, in document order.
+*
+* @remarks
+* The search and each node's role and name are lowercased and split into whole words by
+* `BROWSER_SEARCH_PATTERN`, so a word shorter than 3 letters or digits never counts, and words
+* compare whole, with no substring or prefix match. A node scores the number of distinct search
+* words equal to one of its words, and every node with the highest score above 0 matches. Only a
+* node an outline renders as a referenced row takes part: one that is not ignored, carries a
+* reference, and whose role is not omitted, a heading, or text.
+*
+* @param nodes - Ordered accessibility rows
+* @param search - The words to match
+* @returns The best-matching nodes in document order; empty when no node shares a word
+*
+* @example
+* ```ts
+* import { scanBrowserOutline } from '@orkestrel/browser'
+*
+* const node = {
+* 	parent: undefined,
+* 	children: [],
+* 	backend: undefined,
+* 	frame: undefined,
+* 	ignored: false,
+* 	description: undefined,
+* 	value: undefined,
+* 	properties: {},
+* 	session: 'main',
+* }
+* const nodes = [
+* 	{ ...node, id: '1', role: 'button', name: 'Close', reference: 'e1' },
+* 	{ ...node, id: '2', role: 'button', name: 'Archive', reference: 'e2' },
+* ]
+* scanBrowserOutline(nodes, 'archive dialog button').map((match) => match.reference) // ['e2']
+* ```
+*/
+function scanBrowserOutline(nodes, search) {
+	const words = collectBrowserWords(search);
+	if (words.size === 0) return [];
+	let best = 0;
+	const scored = [];
+	for (const node of nodes) {
+		const role = node.role ?? "";
+		if (node.ignored || node.reference === void 0 || BROWSER_OUTLINE_OMITTED_ROLES.has(role) || role === "heading" || role === "StaticText") continue;
+		const own = collectBrowserWords(`${role} ${node.name ?? ""}`);
+		let score = 0;
+		for (const word of words) if (own.has(word)) score += 1;
+		if (score === 0) continue;
+		best = Math.max(best, score);
+		scored.push({
+			node,
+			score
+		});
+	}
+	return scored.filter((entry) => entry.score === best).map((entry) => entry.node);
+}
+/**
+* Collects distinct lowercase words of at least 3 letters or digits.
+*
+* @param text - Text to scan
+* @returns The searchable whole words
+*
+* @example
+* ```ts
+* import { collectBrowserWords } from '@orkestrel/browser'
+* [...collectBrowserWords('The cart, the bag')] // ['the', 'cart', 'bag']
+* ```
+*/
+function collectBrowserWords(text) {
+	return new Set(Array.from(text.toLowerCase().matchAll(BROWSER_SEARCH_PATTERN), (match) => match[0]));
+}
+/**
+* Matches the lines sharing the most distinct search words, in document order.
+*
+* @param text - The complete projection
+* @param search - Words to match, using the outline's word rule
+* @returns The best-scoring lines and their original UTF-16 offsets; empty without a shared word
+*
+* @example
+* ```ts
+* import { scanBrowserText } from '@orkestrel/browser'
+* scanBrowserText('Cart\nBlue kettle', 'kettle') // [{ offset: 5, text: 'Blue kettle' }]
+* ```
+*/
+function scanBrowserText(text, search) {
+	const words = collectBrowserWords(search);
+	if (words.size === 0) return [];
+	let best = 0;
+	const scored = [];
+	for (const line of text.matchAll(/[^\r\n]+/g)) {
+		const own = collectBrowserWords(line[0]);
+		let score = 0;
+		for (const word of words) if (own.has(word)) score += 1;
+		if (score === 0) continue;
+		best = Math.max(best, score);
+		scored.push({
+			match: {
+				offset: line.index,
+				text: line[0]
+			},
+			score
+		});
+	}
+	return scored.filter((entry) => entry.score === best).map((entry) => entry.match);
+}
+/**
+* Renders matching rows in at most half the available reply room.
+*
+* @remarks
+* An oversized first row is cut with an ellipsis without splitting a surrogate pair, reserving
+* room for the first later row that can fit beside it only when the cut keeps the leading token
+* through its first space. Otherwise it cuts without reserving. Later rows that do not fit are
+* skipped. An empty collection or a cut with no character before the ellipsis produces no block.
+*
+* @param heading - The match count and search, ending with a colon
+* @param rows - Matching rows in document order
+* @param room - Characters available in the reply
+* @returns The bounded block with a trailing blank line, or an empty string
+*
+* @example
+* ```ts
+* import { renderBrowserMatches } from '@orkestrel/browser'
+* renderBrowserMatches('Matches:', ['[5] Cart'], 100) // 'Matches:\n[5] Cart\n\n'
+* ```
+*/
+function renderBrowserMatches(heading, rows, room) {
+	const half = Math.floor(room / 2);
+	let text = `${heading}\n`;
+	let count = 0;
+	for (const row of rows) {
+		const space = half - text.length - 2;
+		if (space < 1) break;
+		if (row.length > space) {
+			if (count > 0) continue;
+			let end = space - 1;
+			const later = rows.slice(1).find((candidate) => candidate.length + 2 <= space);
+			if (later !== void 0 && end - later.length - 1 >= row.indexOf(" ") + 1) end -= later.length + 1;
+			const last = row.charCodeAt(end - 1);
+			if (last >= 55296 && last <= 56319) end -= 1;
+			if (end < 1) break;
+			text += `${row.slice(0, end)}…\n`;
+		} else text += `${row}\n`;
+		count += 1;
+	}
+	return count === 0 ? "" : `${text}\n`;
+}
+/**
 * Renders document-order text and referenced elements with a bounded element count.
+*
+* @remarks
+* Each referenced row renders through `renderBrowserOutlineRow`, and the closing
+* `(COUNT of TOTAL elements)` line counts the rows included and available. `matches` holds the
+* rows `scanBrowserOutline` returns for `search`, and `focus` the last referenced row whose node
+* carries a `focused` property of `true`; both reach past `limit`.
+*
 * @param url - Document address
 * @param title - Document title
 * @param nodes - Ordered accessibility rows
 * @param limit - Maximum referenced rows to include
-* @returns Outline text and element counts
+* @param search - The words whose best-matching rows `matches` lists. Default: none, which lists
+* none
+* @returns Outline text, element counts, matching rows, and the focused row
+*
+* @example
+* ```ts
+* import { renderBrowserOutline } from '@orkestrel/browser'
+*
+* const node = {
+* 	parent: undefined,
+* 	children: [],
+* 	backend: undefined,
+* 	frame: undefined,
+* 	ignored: false,
+* 	description: undefined,
+* 	value: undefined,
+* 	session: 'main',
+* }
+* const outline = renderBrowserOutline(
+* 	'https://shop.example/cart',
+* 	'Cart',
+* 	[
+* 		{ ...node, id: '1', role: 'button', name: 'Close', properties: {}, reference: 'e1' },
+* 		{ ...node, id: '2', role: 'button', name: 'Archive', properties: { focused: true }, reference: 'e2' },
+* 	],
+* 	1,
+* 	'archive button',
+* )
+* outline.text // 'page "Cart" https://shop.example/cart\ne1 button "Close"\n(1 of 2 elements)'
+* outline.matches // ['e2 button "Archive"']
+* outline.focus // 'e2 button "Archive"'
+* ```
 */
-function renderBrowserOutline(url, title, nodes, limit) {
+function renderBrowserOutline(url, title, nodes, limit, search) {
 	const rows = [`page ${JSON.stringify(title)} ${url}`];
+	const sessions = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		let parents = sessions.get(node.session);
+		if (parents === void 0) {
+			parents = /* @__PURE__ */ new Map();
+			sessions.set(node.session, parents);
+		}
+		if (!parents.has(node.id)) parents.set(node.id, node);
+	}
 	let count = 0;
 	let total = 0;
+	let focus;
 	for (const node of nodes) {
 		if (node.ignored || BROWSER_OUTLINE_OMITTED_ROLES.has(node.role ?? "")) continue;
 		const name = normalizeBrowserName(node.name ?? "");
@@ -1646,20 +1948,16 @@ function renderBrowserOutline(url, title, nodes, limit) {
 			continue;
 		}
 		if (node.role === "StaticText") {
-			const parent = nodes.find((candidate) => candidate.session === node.session && candidate.id === node.parent);
+			const parent = node.parent === void 0 ? void 0 : sessions.get(node.session)?.get(node.parent);
 			if (name !== "" && name !== normalizeBrowserName(parent?.name ?? "")) rows.push(name);
 			continue;
 		}
 		if (node.reference === void 0) continue;
 		total += 1;
+		if (node.properties["focused"] === true) focus = node;
 		if (count >= limit) continue;
 		count += 1;
-		let row = `${node.reference} ${node.role ?? "unknown"} ${JSON.stringify(name)}`;
-		if (node.value !== void 0 && node.value !== "") row += ` value=${JSON.stringify(String(node.value))}`;
-		if (node.properties["checked"] === true || node.properties["checked"] === "true") row += " [checked]";
-		if (node.properties["disabled"] === true) row += " [disabled]";
-		if (node.tool !== void 0) row += ` [tool=${node.tool}]`;
-		rows.push(row);
+		rows.push(renderBrowserOutlineRow(node));
 	}
 	rows.push(`(${count} of ${total} elements)`);
 	return {
@@ -1667,7 +1965,9 @@ function renderBrowserOutline(url, title, nodes, limit) {
 		title,
 		text: rows.join("\n"),
 		count,
-		total
+		total,
+		matches: search === void 0 ? [] : scanBrowserOutline(nodes, search).map(renderBrowserOutlineRow),
+		focus: focus === void 0 ? void 0 : renderBrowserOutlineRow(focus)
 	};
 }
 /**
@@ -1748,27 +2048,27 @@ function renderBrowserToolOutput(value) {
 	return (rendered.success ? rendered.value ?? String(value) : "[Unserializable tool output]").slice(0, BROWSER_REGISTRY_OUTPUT_LIMIT);
 }
 /**
-* Derives the advertised input schema from an authored one, adding a required `what` parameter when the schema requires nothing.
+* Derives the advertised input schema from an authored one, adding a required `purpose` parameter when the schema requires nothing.
 * @param schema - Authored input schema, or undefined for a parameterless tool
-* @returns An advertised schema, or undefined when the authored `what` parameter is optional
-* @remarks The caller strips only a synthetic `what` parameter before invoking the page tool.
+* @returns An advertised schema, or undefined when the authored `purpose` parameter is optional
+* @remarks The caller strips only a synthetic `purpose` parameter before invoking the page tool.
 */
 function deriveBrowserToolSchema(schema) {
 	const properties = (0, _orkestrel_contract.isRecord)(schema?.["properties"]) ? schema["properties"] : {};
 	const required = (0, _orkestrel_contract.isArray)(schema?.["required"]) ? schema["required"].filter(_orkestrel_contract.isString) : [];
-	if (Object.hasOwn(properties, "what") && !required.includes("what")) return void 0;
+	if (Object.hasOwn(properties, "purpose") && !required.includes("purpose")) return void 0;
 	if (required.length > 0) return schema;
 	return {
 		...schema,
 		type: "object",
 		properties: {
 			...properties,
-			what: {
+			purpose: {
 				type: "string",
 				description: "Describe the purpose of this action."
 			}
 		},
-		required: ["what"]
+		required: ["purpose"]
 	};
 }
 /**
@@ -1780,8 +2080,8 @@ function deriveBrowserToolSchema(schema) {
 * units, one fewer when the last would split a surrogate pair (so a limit of 1 before a pair keeps
 * nothing), followed by `\n[characters 0–END of TOTAL; FOOTER]`. The footer has no default, so
 * every caller states what the cut result's reader does next: the toolset passes
-* `BROWSER_TOOL_VIEW_FOOTER` for a result that carries a view and `BROWSER_TOOL_CUT_FOOTER` for
-* any other.
+* `BROWSER_TOOL_VIEW_FOOTER` for an action or `dialog` receipt that carries a view and
+* `BROWSER_TOOL_CUT_FOOTER` for any other result, including `look` and `read` results.
 *
 * @param text - The page-authored or composed string
 * @param limit - The most characters kept before the footer, a positive integer
@@ -1818,8 +2118,8 @@ function boundBrowserText(text, limit, footer) {
 * ```ts
 * import { BROWSER_TOOL_COPY, validateBrowserToolArguments } from '@orkestrel/browser'
 *
-* validateBrowserToolArguments(BROWSER_TOOL_COPY.look, { what: 'cart', ref: 'e1' })
-* // throws 'The look tool takes no ref parameter; call look with what.'
+* validateBrowserToolArguments(BROWSER_TOOL_COPY.look, { search: 'cart', ref: 'e1' })
+* // throws 'The look tool takes no ref parameter; call look with search and offset.'
 * ```
 */
 function validateBrowserToolArguments(definition, args) {
@@ -3599,7 +3899,7 @@ function renderBrowserJourney(journey) {
 				return `${step.id} type ${secret ? "(secret)" : JSON.stringify(text)}${suffix} into ${name}${step.arguments["submit"] === true ? ", submit" : ""}`;
 			}
 			case "press": return `${step.id} press ${text}${suffix}`;
-			case "wait": return `${step.id} wait ${JSON.stringify(text)}${suffix}`;
+			case "wait": return `${step.id} wait ${JSON.stringify(text)}${suffix}${step.arguments["absent"] === true ? ", absent" : ""}`;
 			case "dialog": return `${step.id} dialog ${step.arguments["accept"] === true ? "accept" : "dismiss"}${binding === void 0 ? "" : ` ${JSON.stringify(text)}${suffix}`}`;
 			case "switch": return `${step.id} switch ${JSON.stringify(step.tab?.title)} ${step.tab?.url}`;
 			case "unresolved": return `${step.id} unresolved: ${step.gap}`;
@@ -3907,46 +4207,55 @@ function buildBrowserJourney(steps, options) {
 //#endregion
 //#region src/core/compilers.ts
 /**
-* Compiles a mutation-driven wait with one deadline and explicit disconnect ownership.
+* Compiles a wait woken by mutations and finished transitions and animations, with one deadline and explicit disconnect ownership.
+* @remarks
+* `transitionend` and `animationend` inside a shadow root are not composed in Chromium
+* 154.0.4258.53, so this document listener does not see them. Mutations inside that root are
+* not observed either.
 * @param deadline - Maximum time in milliseconds
 * @param key - Isolated-world property owning this observer
-* @param predicate - Optional expression checked immediately and after each mutation batch
+* @param predicate - Optional expression checked immediately and on the task after a mutation batch or a `BROWSER_WAIT_EVENTS` event
 * @returns Promise expression resolving true on a match or change, false at the deadline
 */
 function compileQueryWaitExpression(deadline, key, predicate) {
 	return `new Promise((resolve) => {
-	let frame
+	let task
 	let timer
 	let observer
+	const events = new AbortController()
 	const finish = (value) => {
 		observer?.disconnect()
-		if (frame !== undefined) cancelAnimationFrame(frame)
+		events.abort()
+		if (task !== undefined) clearTimeout(task)
 		clearTimeout(timer)
 		delete globalThis[${JSON.stringify(key)}]
 		resolve(value)
 	}
 	const check = () => {
-		frame = undefined
+		task = undefined
 		if (${predicate ?? "true"}) finish(true)
 	}
 	globalThis[${JSON.stringify(key)}] = () => finish(false)
-	observer = new MutationObserver(() => {
-		if (frame === undefined) frame = requestAnimationFrame(check)
-	})
+	const schedule = () => {
+		if (task === undefined) task = setTimeout(check, 0)
+	}
+	observer = new MutationObserver(schedule)
 	observer.observe(document, { childList: true, attributes: true, characterData: true, subtree: true })
+	for (const name of ${JSON.stringify(BROWSER_WAIT_EVENTS)}) document.addEventListener(name, schedule, { capture: true, signal: events.signal })
 	timer = setTimeout(() => finish(false), ${JSON.stringify(deadline)})
 	${predicate === void 0 ? "" : "check()"}
 })`;
 }
 /**
-* Compiles a visible-text wait coalesced by animation frames.
+* Compiles a wait for the presence or absence of visible text, coalesced by tasks.
 * @param text - Text to find in the main document body
 * @param deadline - Maximum time in milliseconds
 * @param key - Isolated-world property owning this observer
+* @param absent - If `true`, resolves when the body's `innerText` lacks `text`; if `false`, when it contains it. Default: `false`
 * @returns Mutation-driven promise expression with one deadline
 */
-function compileTextWaitExpression(text, deadline, key) {
-	return compileQueryWaitExpression(deadline, key, `(document.body?.innerText ?? '').includes(${JSON.stringify(text)})`);
+function compileTextWaitExpression(text, deadline, key, absent = false) {
+	return compileQueryWaitExpression(deadline, key, `${absent ? "!" : ""}(document.body?.innerText ?? '').includes(${JSON.stringify(text)})`);
 }
 /**
 * Compiles text selection or select-option assignment against the resolved element.
@@ -4258,20 +4567,337 @@ ${expression}
 ); const s = JSON.stringify(r); if (typeof s === 'string' && s.length > ${limit}) throw new Error(${JSON.stringify(BROWSER_RESULT_LIMIT_SENTINEL_PREFIX)} + s.length); return r })()`;
 }
 /**
-* Compiles the in-page function that reads the document's URL, title, and serialized HTML.
+* Compiles the in-page function that reads the document's URL, title, and rendered HTML.
 *
 * @remarks
-* The declaration takes no arguments and returns `{ url, title, html }` from `location.href`,
-* `document.title`, and `document.documentElement.outerHTML`, with `html` empty for a document
-* that has no root element. Call it inside {@link compileGuardedEvaluateExpression} to bound the
-* result under {@link BROWSER_RESULT_LIMIT}.
+* The optional root defaults to `document.documentElement`. {@link BrowserReadingInput}
+* defines its inert capture, lowering, redaction, and limits. A missing root yields empty HTML.
+* Call it inside {@link compileGuardedEvaluateExpression} to bound the final serialized result
+* under {@link BROWSER_RESULT_LIMIT}.
 *
 * @returns A function declaration source
 */
 function compileReadFunction() {
-	return `function() {
-	const root = document.documentElement
-	return { url: location.href, title: document.title, html: root ? root.outerHTML : '' }
+	return `function(node = document.documentElement) {
+	const owner = node?.ownerDocument ?? document
+	if (!node) return { url: owner.URL, title: owner.title, html: '' }
+	const capture = { url: owner.URL, title: owner.title, html: '' }
+	const view = owner.defaultView
+	const rendered = view !== null && node.isConnected
+	const inert = owner.implementation.createHTMLDocument('')
+	let root = inert.importNode(node, true)
+	const pending = [{ live: node, twin: root, visited: false }]
+	if (rendered) {
+		let child = node
+		for (
+			let parent = node;
+			parent?.ownerDocument === owner;
+			parent = parent.assignedSlot ?? parent.parentElement ?? (parent.parentNode instanceof view.ShadowRoot ? parent.parentNode.host : null)
+		) {
+			const style = view.getComputedStyle(parent)
+			const outside =
+				parent !== node &&
+				(style.contentVisibility === 'hidden' ||
+					['canvas', 'video', 'audio'].includes(parent.localName) ||
+					parent instanceof view.HTMLInputElement ||
+					parent instanceof view.HTMLTextAreaElement ||
+					parent instanceof view.HTMLOptionElement ||
+					(parent.namespaceURI === 'http://www.w3.org/2000/svg' &&
+						parent.localName === 'switch' &&
+						child !== (Array.from(parent.children).find((candidate) => candidate.getClientRects().length > 0) ?? parent.firstElementChild)) ||
+					((parent instanceof view.HTMLSelectElement || parent instanceof view.HTMLOptGroupElement) &&
+						!(node instanceof view.HTMLOptionElement || node instanceof view.HTMLOptGroupElement)) ||
+					[
+						'script',
+						'style',
+						'template',
+						'frame',
+						'frameset',
+						'iframe',
+						'object',
+						'embed',
+						'applet',
+						'noscript',
+						'meta',
+						'link',
+						'base',
+						'math',
+					].includes(parent.localName) ||
+					(parent.localName === 'details' &&
+						!parent.hasAttribute('open') &&
+						child !== parent.querySelector(':scope > summary')))
+			const unassigned =
+				child.parentElement?.shadowRoot !== null &&
+				child.parentElement?.shadowRoot !== undefined &&
+				child.assignedSlot === null
+			if (style.display === 'none' || outside || unassigned) {
+				root = undefined
+				pending.length = 0
+				break
+			}
+			child = parent
+		}
+	}
+	while (pending.length > 0) {
+		const entry = pending.pop()
+		if (entry === undefined) continue
+		const { live, twin, visited } = entry
+		const tag = live.localName
+		const input = tag === 'input' ? (live.getAttribute('type')?.toLowerCase() ?? 'text') : ''
+		if (
+			[
+				'script',
+				'style',
+				'template',
+				'frame',
+				'frameset',
+				'iframe',
+				'object',
+				'embed',
+				'applet',
+				'noscript',
+				'meta',
+				'link',
+				'base',
+				'math',
+			].includes(tag) ||
+			(tag === 'input' && ['password', 'hidden'].includes(input))
+		) {
+			twin.remove()
+			if (twin === root) root = undefined
+			continue
+		}
+		const style = entry.style ?? (rendered ? view.getComputedStyle(live) : undefined)
+		const invisible = style?.visibility === 'hidden' || style?.visibility === 'collapse'
+		if (style?.display === 'none' || (invisible && !live.hasChildNodes())) {
+			twin.remove()
+			if (twin === root) root = undefined
+			continue
+		}
+		if (!visited) {
+			pending.push({ live, twin, style, visited: true })
+			if (rendered) {
+				twin.removeAttribute('hidden')
+				twin.removeAttribute('aria-hidden')
+			}
+			if (
+				rendered &&
+				(live instanceof view.HTMLAnchorElement || live instanceof view.HTMLAreaElement) &&
+				live.hasAttribute('href')
+			)
+				twin.setAttribute('href', live.href)
+			if (style?.contentVisibility === 'hidden' || ['canvas', 'video', 'audio'].includes(tag)) {
+				twin.replaceChildren()
+				continue
+			}
+			if (
+				rendered &&
+				(live instanceof view.HTMLInputElement ||
+					live instanceof view.HTMLTextAreaElement ||
+					live instanceof view.HTMLSelectElement ||
+					live instanceof view.HTMLOptionElement ||
+					live instanceof view.HTMLOptGroupElement)
+			)
+				continue
+			const summary =
+				tag === 'details' && !live.hasAttribute('open')
+					? live.querySelector(':scope > summary')
+					: undefined
+
+			// Native layout selects the switch branch after its conditional processing tests.
+			const conditional = tag === 'switch' && live.namespaceURI === 'http://www.w3.org/2000/svg'
+			const branch = rendered && conditional
+				? (Array.from(live.children).find((candidate) => candidate.getClientRects().length > 0) ?? live.firstElementChild)
+				: undefined
+			// Save sibling pointers before pruning invalidates the copied child collections.
+			let element = live.lastElementChild
+			let counterpart = twin.lastElementChild
+			let child = live.lastChild
+			let mirror = twin.lastChild
+			while (child !== null && mirror !== null) {
+				const previous = child.previousSibling
+				const previousMirror = mirror.previousSibling
+				const previousElement = element?.previousElementSibling ?? null
+				const previousCounterpart = counterpart?.previousElementSibling ?? null
+				let omitted = rendered && ((summary !== undefined && child !== summary) || (conditional && child !== branch))
+				if (rendered && live.shadowRoot !== null) {
+					const slot =
+						child instanceof view.Element || child instanceof view.Text ? child.assignedSlot : null
+					if (slot === null) omitted = true
+					else {
+						for (
+							let parent = slot;
+							parent !== null && parent !== live;
+							parent = parent.assignedSlot ?? parent.parentElement ?? (parent.parentNode instanceof view.ShadowRoot ? parent.parentNode.host : null)
+						) {
+							if (view.getComputedStyle(parent).display === 'none') omitted = true
+						}
+					}
+				}
+				if (omitted || (child.nodeType === 3 && invisible)) mirror.parentNode?.removeChild(mirror)
+				else if (child.nodeType === 1) {
+					// Element sibling pointers retain their type across windowless owner realms.
+					if (element !== null && counterpart !== null)
+						pending.push({ live: element, twin: counterpart, visited: false })
+				}
+				if (child.nodeType === 1) {
+					element = previousElement
+					counterpart = previousCounterpart
+				}
+				child = previous
+				mirror = previousMirror
+			}
+			continue
+		}
+		if (!rendered || style?.contentVisibility === 'hidden') continue
+		if (
+			['div', 'summary', 'details'].includes(tag) &&
+			!style?.display.startsWith('inline') &&
+			style?.display !== 'contents' &&
+			twin.hasChildNodes()
+		) {
+			twin.prepend(inert.createElement('br'))
+			twin.append(inert.createElement('br'))
+		}
+		let fragments
+		let lines
+		let container = false
+		if (live instanceof view.HTMLInputElement) {
+			lines = []
+			if (['text', 'email', 'search', 'tel', 'url', 'number'].includes(live.type)) {
+				if (live.type !== 'number' || !live.validity.badInput) {
+					const placeholder = view.getComputedStyle(live, '::placeholder')
+					lines = [
+						live.value ||
+							(live.matches(':placeholder-shown') &&
+							placeholder.visibility === 'visible' &&
+							placeholder.opacity !== '0' &&
+							placeholder.color !== 'rgba(0, 0, 0, 0)'
+								? live.placeholder
+								: ''),
+					]
+				}
+			} else if (['submit', 'reset', 'button'].includes(live.type)) lines = [live.value]
+			else if (live.type === 'file' && live.files?.length === 1)
+				lines = Array.from(live.files ?? [], (file) => file.name)
+			else if (live.type === 'image' && live.getAttribute('aria-hidden') !== 'true')
+				lines = [live.getAttribute('aria-label')?.trim() || live.alt]
+		} else if (live instanceof view.HTMLTextAreaElement) {
+			const placeholder = view.getComputedStyle(live, '::placeholder')
+			const value =
+				live.value ||
+				(live.matches(':placeholder-shown') &&
+				placeholder.visibility === 'visible' &&
+				placeholder.opacity !== '0' &&
+				placeholder.color !== 'rgba(0, 0, 0, 0)'
+					? live.placeholder
+					: '')
+			lines = value.split(/\\r?\\n/)
+		} else if (
+			live instanceof view.HTMLSelectElement ||
+			live instanceof view.HTMLOptionElement ||
+			live instanceof view.HTMLOptGroupElement
+		) {
+			lines = []
+			const select = live instanceof view.HTMLSelectElement ? live : live.closest('select')
+			if (select !== null) {
+				if (!select.multiple && select.size <= 1) {
+					const option = select.selectedOptions[0]
+					if (option !== undefined && (live === select || live === option || live.contains(option)))
+						lines.push(option.label)
+				} else {
+					const box = select.getBoundingClientRect()
+					const top = box.top + select.clientTop
+					const bottom = top + select.clientHeight
+					const rows =
+						live === select
+							? select.querySelectorAll('option,optgroup')
+							: [live, ...live.querySelectorAll('option')]
+					for (const row of rows) {
+						const rowStyle = view.getComputedStyle(row)
+						const groupStyle =
+							row.parentElement instanceof view.HTMLOptGroupElement
+								? view.getComputedStyle(row.parentElement)
+								: undefined
+						if (
+							rowStyle.display === 'none' ||
+							rowStyle.visibility !== 'visible' ||
+							groupStyle?.display === 'none'
+						)
+							continue
+						const rect = row.getBoundingClientRect()
+						// The group box includes its options; its caption ends where the first row starts.
+						const end =
+							row instanceof view.HTMLOptGroupElement
+								? (Array.from(row.querySelectorAll('option'))
+										.find((option) => option.getClientRects().length > 0)
+										?.getBoundingClientRect().top ?? rect.bottom)
+								: rect.bottom
+						if (
+							end > top &&
+							rect.top < bottom &&
+							rect.right > box.left + select.clientLeft &&
+							rect.left < box.left + select.clientLeft + select.clientWidth &&
+							(row instanceof view.HTMLOptionElement || row instanceof view.HTMLOptGroupElement)
+						)
+							lines.push(row.label)
+					}
+				}
+			}
+		} else if (tag === 'svg') {
+			if (twin.parentElement?.closest('svg, foreignObject')?.localName === 'svg') continue
+			lines = []
+			fragments = []
+			for (const content of twin.querySelectorAll('text, foreignObject')) {
+				if (content.parentElement?.closest('svg, foreignObject')?.localName === 'foreignObject') continue
+				if (content.localName === 'text' && content.parentElement?.closest('text')?.closest('svg') === content.closest('svg')) continue
+				if (content.localName === 'foreignObject') fragments.push(...content.childNodes)
+				else if (content.textContent) fragments.push(inert.createTextNode(content.textContent))
+			}
+			if (fragments.length === 0) fragments = undefined
+			if (!invisible && fragments === undefined && live.getAttribute('aria-hidden') !== 'true')
+				lines.push(
+					live.getAttribute('aria-label')?.trim() ||
+						live.querySelector(':scope > title')?.textContent ||
+						'',
+				)
+		} else if (['form', 'dialog', 'button'].includes(tag)) {
+			container = true
+			if (live instanceof view.HTMLButtonElement && !invisible && live.innerText.trim() === '') {
+				const name = live.getAttribute('aria-label')?.trim()
+				if (name) {
+					lines = [name]
+					container = false
+				}
+			}
+		}
+		if (lines === undefined && !container) continue
+		if (invisible && !container && tag !== 'svg') lines = []
+		const block = !style?.display.startsWith('inline') && style?.display !== 'contents'
+		const carrier = inert.createElement(block ? 'div' : 'span')
+		if (container) carrier.append(...twin.childNodes)
+		else if (fragments !== undefined) {
+			for (const fragment of fragments) {
+				carrier.append(fragment, inert.createElement('br'))
+			}
+		} else
+			for (const [index, line] of (lines ?? []).entries()) {
+				if (index > 0) carrier.append(inert.createElement('br'))
+				carrier.append(inert.createTextNode(line))
+			}
+		if (carrier.hasChildNodes()) {
+			carrier.prepend(inert.createElement('br'))
+			carrier.append(inert.createElement('br'))
+		}
+		twin.replaceWith(carrier)
+		if (twin === root) root = carrier
+	}
+	// Guard a copy that has fallen out of step with the live tree.
+	for (const input of root?.querySelectorAll('input[type="password" i],input[type="hidden" i]') ??
+		[])
+		input.remove()
+	capture.html = root?.outerHTML ?? ''
+	return capture
 }`;
 }
 /**
@@ -4425,7 +5051,7 @@ function compileActionabilityFunction(options) {
 	if (${JSON.stringify(options.enabled === true)} && this.matches(':disabled')) throw new Error('Element is disabled')
 	if (${JSON.stringify(options.editable === true)} && (this.matches('[readonly]') || (!this.isContentEditable && !('value' in this)))) throw new Error('Element is not editable')
 	let previous
-	for (let index = 0; index < 2; index += 1) {
+	for (let index = 0; index < ${options.stable === true ? 2 : 0}; index += 1) {
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		const rect = this.getBoundingClientRect()
 		const current = [rect.x, rect.y, rect.width, rect.height]
@@ -5558,7 +6184,7 @@ var BrowserCodegen = class {
 * 	title: 'Example',
 * 	html: '<nav>Menu</nav><main><p>Body</p></main>',
 * })
-* reading.markdown() // { text: 'Body', offset: 0, total: 4 }
+* reading.markdown({ distill: true }) // { text: 'Body', offset: 0, total: 4 }
 * ```
 */
 var BrowserReading = class {
@@ -5590,7 +6216,7 @@ var BrowserReading = class {
 		return this.#navigation !== void 0 && this.#navigation() !== this.#epoch;
 	}
 	markdown(options) {
-		const distill = options?.distill ?? true;
+		const distill = options?.distill ?? false;
 		let text = this.#markdowns.get(distill);
 		if (text === void 0) {
 			text = (0, _orkestrel_markdown.renderMarkdown)((0, _orkestrel_markdown.htmlToMarkdown)(this.#source(distill).document));
@@ -5599,7 +6225,7 @@ var BrowserReading = class {
 		return extractBrowserSlice(text, options?.offset, options?.limit);
 	}
 	text(options) {
-		const distill = options?.distill ?? true;
+		const distill = options?.distill ?? false;
 		let text = this.#texts.get(distill);
 		if (text === void 0) {
 			text = (0, _orkestrel_html.renderText)(this.#source(distill).document);
@@ -5608,7 +6234,10 @@ var BrowserReading = class {
 		return extractBrowserSlice(text, options?.offset, options?.limit);
 	}
 	#source(distill) {
-		if (!distill) return this.#html;
+		if (!distill) return this.#html.map((node) => node.category === "element" ? {
+			...node,
+			attributes: (0, _orkestrel_html.resolveAttributes)(node, this.#url)
+		} : node);
 		this.#distilled ??= this.#html.distill({ base: this.#url });
 		return this.#distilled;
 	}
@@ -5679,8 +6308,7 @@ var BrowserPageElement = class {
 	async read(options) {
 		const epoch = this.#epoch();
 		const capture = await this.#call(`function() {
-		const capture = (${compileReadFunction()})()
-		capture.html = this.outerHTML
+		const capture = (${compileReadFunction()})(this)
 		return ${compileGuardedEvaluateExpression("capture", BROWSER_RESULT_LIMIT)}
 	}`, options);
 		if (!(0, _orkestrel_contract.isRecord)(capture)) throw new BrowserElementError(this.reference, "UNKNOWN", "returned an invalid reading");
@@ -5881,6 +6509,7 @@ var BrowserPageElement = class {
 	}
 	async #pointer(options) {
 		this.#assert(options);
+		await this.#input.page.send("Page.bringToFront", void 0, options);
 		await this.#input.client.send("DOM.scrollIntoViewIfNeeded", { backendNodeId: this.#input.backend }, {
 			session: this.#input.node.session,
 			...options
@@ -6001,7 +6630,7 @@ var BrowserElementManager = class {
 				...options
 			});
 			this.#assertCapture(this.#input.page.id, epoch);
-			return renderBrowserOutline(this.#input.page.url, requireBrowserString(readEvaluationResult(result), "Document title"), this.#within(rows, options?.within), limit);
+			return renderBrowserOutline(this.#input.page.url, requireBrowserString(readEvaluationResult(result), "Document title"), this.#within(rows, options?.within), limit, options?.search);
 		} catch (error) {
 			if (options?.signal?.aborted === true || this.#changes === changes) throw error;
 			this.#lifetime.signal.throwIfAborted();
@@ -6091,34 +6720,52 @@ var BrowserElementManager = class {
 		const signal = options?.signal === void 0 ? this.#lifetime.signal : AbortSignal.any([options.signal, this.#lifetime.signal]);
 		while (true) {
 			signal.throwIfAborted();
-			const remaining = Math.max(0, end - performance.now());
-			const call = {
-				timeout: remaining,
-				signal
-			};
-			await this.#input.ready(call);
-			const frame = this.#scopeFrame(query.within);
-			const session = await this.#input.resolve(frame);
-			const context = await this.#input.world(frame, session, call);
 			const key = `__browserQueryWait${++this.#sequence}`;
-			const pending = this.#input.client.send("Runtime.evaluate", {
-				expression: compileQueryWaitExpression(remaining, key),
-				contextId: context,
-				returnByValue: true,
-				awaitPromise: true
-			}, {
-				session,
-				timeout: remaining + 1e3,
-				signal
-			}).then((result) => ({ result }), (error) => ({ error }));
+			let session;
+			let context;
+			const changes = this.#changes;
 			try {
+				await this.#input.ready({
+					timeout: this.#remaining(end),
+					signal
+				});
+				const frame = this.#scopeFrame(query.within);
+				session = await this.#input.resolve(frame);
+				context = await this.#input.world(frame, session, {
+					timeout: this.#remaining(end),
+					signal
+				});
+				const remaining = this.#remaining(end);
+				const call = {
+					timeout: remaining,
+					signal
+				};
+				const pending = this.#input.client.send("Runtime.evaluate", {
+					expression: compileQueryWaitExpression(remaining, key),
+					contextId: context,
+					returnByValue: true,
+					awaitPromise: true
+				}, {
+					session,
+					timeout: remaining + 1e3,
+					signal
+				}).then((result) => ({ result }), (error) => ({ error }));
 				const found = await this.find(query, call);
 				if (options?.absent === true ? found.length === 0 : found.length > 0) return found;
 				const outcome = await pending;
 				if ("error" in outcome) throw outcome.error;
 				if (readEvaluationResult(outcome.result) !== true || performance.now() >= end) throw new BrowserError("Element wait timed out", "BROWSER_WAIT_TIMEOUT");
+			} catch (error) {
+				signal.throwIfAborted();
+				if (isCDPTimeoutError(error)) throw new BrowserError("Element wait timed out", "BROWSER_WAIT_TIMEOUT");
+				if (this.#input.page.closed || this.#changes === changes && (!(0, _orkestrel_contract.isError)(error) || !BROWSER_CONTEXT_LOSS_PATTERN.test(error.message))) throw error;
+				const remaining = this.#remaining(end);
+				if (this.#changes === changes) await this.#input.recover({
+					signal,
+					timeout: remaining
+				});
 			} finally {
-				await this.#input.client.send("Runtime.evaluate", {
+				if (context !== void 0 && session !== void 0) await this.#input.client.send("Runtime.evaluate", {
 					expression: `globalThis[${JSON.stringify(key)}]?.()`,
 					contextId: context,
 					returnByValue: true
@@ -6129,6 +6776,11 @@ var BrowserElementManager = class {
 			}
 		}
 	}
+	#remaining(end) {
+		const remaining = end - performance.now();
+		if (remaining <= 0) throw new BrowserError("Element wait timed out", "BROWSER_WAIT_TIMEOUT");
+		return remaining;
+	}
 	element(reference) {
 		const canonical = parseBrowserReference(reference);
 		return [...this.#records.values()].find((entry) => entry.node.reference === canonical)?.element;
@@ -6636,7 +7288,7 @@ var BrowserRegistry = class {
 		pending.reject(error);
 	}
 	async #executeAdopted(tool, synthetic, input, context) {
-		const parameters = synthetic ? Object.fromEntries(Object.entries(input).filter(([key]) => key !== "what")) : input;
+		const parameters = synthetic ? Object.fromEntries(Object.entries(input).filter(([key]) => key !== "purpose")) : input;
 		const result = await this.execute(tool, parameters, { signal: context.signal });
 		if (result.status !== "Completed") throw new BrowserError(`Browser tool ${result.status}: ${result.error ?? "No error description"}`.slice(0, BROWSER_REGISTRY_OUTPUT_LIMIT));
 		return renderBrowserToolOutput(result.output);
@@ -8953,6 +9605,8 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 	#epoch = 0;
 	#floor = 0;
 	#closed = false;
+	#waitRelease = new AbortController();
+	#textWaits = /* @__PURE__ */ new Map();
 	#codegen;
 	#registry;
 	#codegenStart = new BrowserTransition();
@@ -9003,6 +9657,7 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 			session: sessionId,
 			resolve: this.#resolveFrameSession.bind(this),
 			world: this.#world.bind(this),
+			recover: this.#recoverReadiness.bind(this),
 			reference: this.#reference,
 			ready: this.#ready.bind(this)
 		});
@@ -9066,6 +9721,10 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 	}
 	async wait(text, options) {
 		this.assert();
+		options = {
+			...options,
+			signal: options?.signal === void 0 ? this.#waitRelease.signal : AbortSignal.any([options.signal, this.#waitRelease.signal])
+		};
 		const timeout = options?.timeout ?? 3e4;
 		validateBrowserTimeout(timeout);
 		const end = performance.now() + timeout;
@@ -9078,9 +9737,10 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 			});
 			const context = await this.#world(this.id, this.#sessionId, options);
 			const key = `__browserTextWait${++this.#waitSequence}`;
+			this.#textWaits.set(key, context);
 			try {
 				if (readEvaluationResult(await this.send("Runtime.evaluate", {
-					expression: compileTextWaitExpression(text, remaining, key),
+					expression: compileTextWaitExpression(text, remaining, key, options?.absent === true),
 					contextId: context,
 					returnByValue: true,
 					awaitPromise: true
@@ -9094,23 +9754,20 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 				return;
 			} catch (error) {
 				if (options?.signal?.aborted === true) {
-					await this.send("Runtime.evaluate", {
-						expression: `globalThis[${JSON.stringify(key)}]?.()`,
-						contextId: context,
-						returnByValue: true
-					}, { timeout: 1e3 }).catch(() => void 0);
+					if (!this.#closed) await this.#releaseTextWait(key, context);
 					throw options.signal.reason;
 				}
-				if (!(0, _orkestrel_contract.isError)(error) || !/execution context was destroyed|cannot find context with specified id/i.test(error.message)) throw error;
-				this.#dom = void 0;
+				if (!(0, _orkestrel_contract.isError)(error) || !BROWSER_CONTEXT_LOSS_PATTERN.test(error.message)) throw error;
 				if (performance.now() >= end) throw new BrowserError("Browser text wait timed out", "BROWSER_WAIT_TIMEOUT", {
 					text,
 					timeout
 				});
-				await this.#parkReadiness({
+				await this.#recoverReadiness({
 					...options,
 					timeout: Math.max(0, end - performance.now())
 				});
+			} finally {
+				this.#textWaits.delete(key);
 			}
 		}
 	}
@@ -9498,6 +10155,8 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 		return release;
 	}
 	async #releaseResources() {
+		this.#waitRelease.abort(new BrowserError("Browser page is closed"));
+		await Promise.all([...this.#textWaits].map(([key, context]) => this.#releaseTextWait(key, context)));
 		this.#unhold();
 		this.#announcement.reject(new BrowserError("Browser session ended"));
 		this.#client.unsubscribe("Page.lifecycleEvent", this.#lifecycleHandler, this.#sessionId);
@@ -9547,6 +10206,16 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 		}
 		this.#steps.destroy();
 	}
+	async #releaseTextWait(key, context) {
+		await this.#client.send("Runtime.evaluate", {
+			expression: `globalThis[${JSON.stringify(key)}]?.()`,
+			contextId: context,
+			returnByValue: true
+		}, {
+			session: this.#sessionId,
+			timeout: 1e3
+		}).catch(() => void 0);
+	}
 	#frame(frame) {
 		return new BrowserFrame(this.#client, (id) => this.#resolveFrameSession(id), frame.id, frame.url, frame.parent, frame.name, true, () => this.#epochOf(frame.id), (session, call) => this.#world(frame.id, session, call));
 	}
@@ -9590,6 +10259,10 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 	#rejectSeed(seed) {
 		if (this.#seed === seed) this.#seed = void 0;
 	}
+	#recoverReadiness(options) {
+		this.#dom = void 0;
+		return this.#parkReadiness(options);
+	}
 	async #seedReadiness(options) {
 		const document = this.#floor;
 		const context = await this.#world(this.id, this.#sessionId, options);
@@ -9637,24 +10310,44 @@ var BrowserPage = class BrowserPage extends BrowserFrame {
 		this.#dom = this.#loader ?? "initial";
 		for (const id of this.#readiness.keys()) this.#settleReadiness(id)?.resolve();
 	}
-	#world(frame, session, options) {
+	async #world(frame, session, options) {
+		options?.signal?.throwIfAborted();
 		const cached = this.#worlds.get(frame);
 		if (cached !== void 0) return Promise.resolve(cached.context);
 		const existing = this.#creating.get(frame);
-		if (existing !== void 0) return existing.promise;
+		if (existing !== void 0) return await this.#awaitWorld(existing.promise, options);
 		const pending = this.#client.send("Page.createIsolatedWorld", {
 			frameId: frame,
 			worldName: BROWSER_FRAME_WORLD_NAME
 		}, {
 			session,
-			...options
+			signal: this.#waitRelease.signal
 		}).then(this.#decodeWorld.bind(this, frame));
 		this.#creating.set(frame, {
 			session,
 			promise: pending
 		});
 		pending.then(this.#publishWorld.bind(this, frame, session, pending), this.#settleWorld.bind(this, frame, pending));
-		return pending;
+		return await this.#awaitWorld(pending, options);
+	}
+	async #awaitWorld(pending, options) {
+		const signal = options?.signal;
+		signal?.throwIfAborted();
+		const timeout = options?.timeout ?? 3e4;
+		validateBrowserTimeout(timeout);
+		const abandoned = Promise.withResolvers();
+		const abort = this.#abandonWorld.bind(this, abandoned, signal);
+		const timer = setTimeout(() => abandoned.reject(new CDPTimeoutError("Isolated world wait timed out")), timeout);
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			return await Promise.race([pending, abandoned.promise]);
+		} finally {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+		}
+	}
+	#abandonWorld(pending, signal) {
+		pending.reject(signal?.reason);
 	}
 	#decodeWorld(frame, world) {
 		return readBrowserWorld(world, frame);
@@ -11485,7 +12178,7 @@ function createBrowserReading(input) {
 *
 * const toolset = createBrowserToolset(page, { context })
 * await toolset.start()
-* const result = await toolset.tools.execute({ id: '1', name: 'look', arguments: { what: 'cart' } })
+* const result = await toolset.tools.execute({ id: '1', name: 'look', arguments: { search: 'cart' } })
 * ```
 *
 * @example Drive a page with a small model
@@ -11499,8 +12192,8 @@ function createBrowserReading(input) {
 * const system =
 * 	'You control a web browser with tools and must call a tool before you answer. ' +
 * 	'The first message shows the page as look returns it; references such as e4 name its elements. ' +
-* 	'To learn a fact, call read with what set to your question; when its result ends by naming an offset, call read again with that offset. ' +
-* 	'To search, call type with the search box reference, the words, and submit true. ' +
+* 	'To learn a fact, call read with search set to words from your question; when its result ends by naming an offset, call read again with that offset. ' +
+* 	"To use the site's search box, call type with its reference, the words, and submit true. " +
 * 	'To press a button or follow a link, call click with its reference from the latest result. Never invent a reference. ' +
 * 	'If text you expect has not appeared, call wait once. ' +
 * 	'When the task is done, answer in one short sentence.'
@@ -11510,11 +12203,11 @@ function createBrowserReading(input) {
 * const page = await browser.create({ url: 'https://shop.example.test/' })
 * const toolset = createBrowserToolset(page, { tools: createToolManager() })
 * await toolset.start()
-* toolset.tools.tools().map((tool) => tool.name) // ['look', 'read', 'click', 'type', 'press', 'navigate', 'wait']
+* toolset.tools.tools().map((tool) => tool.name) // ['look', 'read', 'plain', 'click', 'type', 'press', 'navigate', 'wait']
 * const seeded = await toolset.tools.execute({
 * 	id: 'seed',
 * 	name: 'look',
-* 	arguments: { what: 'the page' },
+* 	arguments: { search: '' },
 * })
 * const view = seeded.success ? String(seeded.value) : seeded.error
 * const agent = createAgent(createOllama({ model: 'qwen3.5:2b-q4_K_M' }), {
@@ -11734,6 +12427,10 @@ var BrowserJourneyToolset = class {
 		const offset = args["offset"] ?? 0;
 		if (!(0, _orkestrel_contract.isInteger)(offset) || offset < 0) throw new BrowserError("The offset parameter must be a non-negative integer.", "BROWSER_JOURNEY_ARGUMENT", { key: "offset" });
 		const listings = [];
+		const headings = [];
+		const offsets = /* @__PURE__ */ new Map();
+		let headingOffset = 0;
+		let listingOffset = 0;
 		const faults = /* @__PURE__ */ new Set();
 		let position = 0;
 		for (;;) {
@@ -11741,11 +12438,21 @@ var BrowserJourneyToolset = class {
 				signal,
 				offset: position
 			});
-			listings.push(...page.entries.map((entry) => renderBrowserJourney(entry.journey)));
+			for (const entry of page.entries) {
+				const listing = renderBrowserJourney(entry.journey);
+				const heading = listing.split("\n", 1)[0] ?? "";
+				headings.push(heading);
+				offsets.set(headingOffset, listingOffset);
+				headingOffset += heading.length + 1;
+				listingOffset += listing.length + 2;
+				listings.push(listing);
+			}
 			for (const fault of page.faults) {
 				if (faults.has(fault.name)) continue;
 				faults.add(fault.name);
-				listings.push(renderBrowserJourneyFault(fault));
+				const listing = renderBrowserJourneyFault(fault);
+				listings.push(listing);
+				listingOffset += listing.length + 2;
 			}
 			const span = page.entries.length;
 			position += span;
@@ -11754,7 +12461,11 @@ var BrowserJourneyToolset = class {
 		if (listings.length === 0) return BROWSER_JOURNEY_EMPTY_LISTING;
 		const listing = listings.join("\n\n");
 		const start = offset < listing.length ? offset : 0;
-		let end = Math.min(listing.length, start + this.#limit);
+		const search = (0, _orkestrel_contract.isString)(args["search"]) ? args["search"] : "";
+		const matches = start === 0 ? scanBrowserText(headings.join("\n"), search) : [];
+		const count = matches.length;
+		const block = renderBrowserMatches(`${count} ${count === 1 ? "journey matches" : "journeys match"} ${JSON.stringify(search)}:`, matches.map((match) => `[${offsets.get(match.offset)}] ${match.text}`), this.#limit);
+		let end = Math.min(listing.length, start + this.#limit - block.length);
 		const last = listing.charCodeAt(end - 1);
 		if (end < listing.length && last >= 55296 && last <= 56319) end -= 1;
 		if (end === start) throw new BrowserError(`The journeys limit of ${this.#limit} characters cannot hold the next character at offset ${start}; raise the journeys limit.`, "BROWSER_TOOLSET_LIMIT", {
@@ -11762,8 +12473,8 @@ var BrowserJourneyToolset = class {
 			offset: start
 		});
 		const text = listing.slice(start, end);
-		if (start === 0 && end === listing.length) return text;
-		return `${text}\n\n[characters ${start}–${end} of ${listing.length}${end < listing.length ? `; call journeys with offset ${end} for more` : ""}]`;
+		if (start === 0 && end === listing.length) return `${block}${text}`;
+		return `${block}${text}\n\n[characters ${start}–${end} of ${listing.length}${end < listing.length ? `; call journeys with offset ${end} for more` : ""}]`;
 	}
 	async #edit(args, signal) {
 		if (this.#readonly) throw new BrowserError(BROWSER_JOURNEY_READONLY_REFUSAL, "BROWSER_JOURNEY_READONLY");
@@ -11929,7 +12640,7 @@ var BrowserJourneyToolset = class {
 		const performed = await this.#toolset.perform({
 			id: "journey",
 			name: "look",
-			arguments: { what: "the page" }
+			arguments: { search: "" }
 		}, { signal });
 		return performed.result.success ? String(performed.result.value) : performed.result.error;
 	}
@@ -11957,7 +12668,7 @@ var BrowserJourneyToolset = class {
 * view's own tools beside them.
 *
 * @remarks
-* Every toolset advertises `look`, `read`, `click`, `type`, and `wait`, which need only the
+* Every toolset advertises `look`, `read`, `plain`, `click`, `type`, and `wait`, which need only the
 * `BrowserViewInterface` it is constructed over. With `options.page` it also advertises `press`
 * and `navigate`, stages the `dialog` tool while a dialog is open on the current page, follows a
 * popup the current page opens and returns to the opener when the popup closes, and adopts
@@ -11971,11 +12682,18 @@ var BrowserJourneyToolset = class {
 * refuses every tool but `dialog` while a dialog is open, forwards `ToolContext.signal` into every
 * protocol call, refuses a call to a toolset tool that carries a parameter the tool does not
 * advertise, and cuts every returned string and every thrown message at `limit` characters plus
-* a footer; the footer of a cut result that carries a view names `read` as the next call. `look`
-* and `read` read the page, never one element. A page tool's error message and JSON output reach
-* the toolset already cut at `BROWSER_REGISTRY_OUTPUT_LIMIT` (4 096) by the registry, so a
-* `limit` over that shows at most 4 096 characters of either; a page tool's text output reaches
-* the boundary whole.
+* a footer; the footer of a cut action or `dialog` receipt that carries a view names `look` as the next
+* call. `look`, `read`, and `plain` read the page and return pages of at most `limit`
+* characters and name the offset the next page starts at. A page ends after the last line break
+* in its window that lies past the page's start, or at the window's end when no such break fits,
+* without splitting a surrogate pair. The last page ends at the end of the outline or reading. A `look` whose
+* `search` matches referenced rows lists those rows first, and its pages reach every referenced row.
+* A `press` receipt names the referenced element that has focus after the key. A page tool's
+* error message and JSON output reach the toolset already cut at `BROWSER_REGISTRY_OUTPUT_LIMIT`
+* (4 096) by the registry, so a `limit` over that shows at most 4 096 characters of either; a page
+* tool's text output reaches the boundary whole.
+* `wait` with `absent` set to `true` settles when the text is not on the page, and a miss
+* returns the `timeout` outcome as an appearance miss does.
 *
 * `click`, `type`, `press`, `navigate`, and `switch` are actions: one runs at a time, in call
 * order, and holds the queue until its receipt. A queued action whose signal aborts leaves
@@ -12006,7 +12724,7 @@ var BrowserJourneyToolset = class {
 * page placement's `type` with `submit` ends its action with `and submitted the form` when a read
 * recorded a submission, or when the navigation the receipt settled names `formSubmissionGet` or
 * `formSubmissionPost` as its reason, whatever the read answered, and with `and pressed Enter`
-* otherwise. A `read`
+* otherwise. A `read` or `plain`
 * at an offset at or past its retained reading's end restarts that reading at 0. A receipt that
 * waits for a requested navigation shares one `BROWSER_TOOL_TIMEOUT_MS` deadline between that
 * wait and its view capture, of which `BROWSER_TOOL_CAPTURE_MS` is reserved for the capture. The
@@ -12022,9 +12740,9 @@ var BrowserJourneyToolset = class {
 * A page tool is skipped, with `skip` emitted, when its name is reserved (`unresolved` included), when the manager holds
 * its name under a tool the toolset did not add (checked again immediately before each addition),
 * when its name falls outside `BROWSER_TOOL_NAME_PATTERN`, when its parameters or, for a source
-* that supplies `tools()`, its selected registration declare `what` optional, or when that
+* that supplies `tools()`, its selected registration declare `purpose` optional, or when that
 * registration is marked `debugging`. The selected registration is the main frame's, then the
-* earlier one. A page tool whose parameters require nothing advertises a required `what`, which
+* earlier one. A page tool whose parameters require nothing advertises a required `purpose`, which
 * is stripped before the tool runs. Every adopted tool is advertised `untrusted`. `destroy()`
 * removes only the tools the manager still holds under the instances the toolset added, never
 * closes a page, and ends only what `options.release` hands over, calling it one time last.
@@ -12035,7 +12753,7 @@ var BrowserJourneyToolset = class {
 *
 * const toolset = new BrowserToolset(page, { page })
 * await toolset.start()
-* const result = await toolset.tools.execute({ id: '1', name: 'look', arguments: { what: 'cart' } })
+* const result = await toolset.tools.execute({ id: '1', name: 'look', arguments: { search: 'cart' } })
 * await toolset.destroy()
 * ```
 */
@@ -12099,20 +12817,23 @@ var BrowserToolset = class {
 			...options?.on === void 0 ? {} : { on: options.on },
 			...options?.error === void 0 ? {} : { error: options.error }
 		});
-		const look = this.#create("look", this.#look.bind(this), BROWSER_TOOL_VIEW_FOOTER);
-		const read = this.#create("read", this.#read.bind(this), BROWSER_TOOL_CUT_FOOTER);
+		const look = this.#create("look", this.#look.bind(this), BROWSER_TOOL_CUT_FOOTER);
+		const read = this.#create("read", this.#read.bind(this, "read", (reading) => reading.markdown()), BROWSER_TOOL_CUT_FOOTER);
+		const plain = this.#create("plain", this.#read.bind(this, "plain", (reading) => reading.text()), BROWSER_TOOL_CUT_FOOTER);
 		const click = this.#create("click", this.#click.bind(this), BROWSER_TOOL_VIEW_FOOTER);
 		const type = this.#create("type", this.#type.bind(this), BROWSER_TOOL_VIEW_FOOTER);
 		const wait = this.#create("wait", this.#wait.bind(this), BROWSER_TOOL_CUT_FOOTER);
 		this.#native = Object.freeze(options?.page === void 0 ? [
 			look,
 			read,
+			plain,
 			click,
 			type,
 			wait
 		] : [
 			look,
 			read,
+			plain,
 			click,
 			type,
 			this.#create("press", this.#press.bind(this), BROWSER_TOOL_VIEW_FOOTER),
@@ -12415,44 +13136,74 @@ var BrowserToolset = class {
 		if ((0, _orkestrel_contract.isString)(secret) && secret.length > 0) message = message.replaceAll(JSON.stringify(secret), "[redacted]").replaceAll(secret, "[redacted]");
 		return clause === void 0 ? message : boundBrowserText(message, this.#limit, clause);
 	}
-	async #look(_args, context) {
-		return [(await this.#race(this.#cursor.elements.outline({ signal: context.signal }), "")).text, ""];
+	async #look(args, context) {
+		const offset = this.#readOffset(args);
+		const search = (0, _orkestrel_contract.isString)(args["search"]) ? args["search"] : "";
+		const outline = await this.#race(this.#cursor.elements.outline({
+			signal: context.signal,
+			limit: Number.MAX_SAFE_INTEGER,
+			search
+		}), "");
+		const total = outline.text.length;
+		const start = offset < total ? offset : 0;
+		const note = this.#drainNote();
+		const room = this.#limit - note.length;
+		const count = outline.matches.length;
+		const block = start === 0 ? renderBrowserMatches(`${count} ${count === 1 ? "element matches" : "elements match"} ${JSON.stringify(search)}:`, outline.matches, room) : "";
+		const space = room - block.length;
+		const slice = space < 1 ? {
+			text: "",
+			offset: start,
+			total
+		} : extractBrowserSlice(outline.text, start, space);
+		return this.#pageSlice("look", note, slice, block);
 	}
-	async #read(args, context) {
-		const offset = args["offset"] ?? 0;
-		if (!(0, _orkestrel_contract.isInteger)(offset) || offset < 0) throw new BrowserError("The offset parameter must be a non-negative integer.", "BROWSER_TOOLSET_ARGUMENT", { key: "offset" });
+	async #read(name, project, args, context) {
+		const offset = this.#readOffset(args);
 		const view = this.#cursor;
 		const retained = this.#reading;
 		let reading = retained?.reading;
-		if (offset === 0 || retained === void 0 || reading === void 0 || retained.view !== view || reading.stale) {
+		if (offset === 0 || retained === void 0 || reading === void 0 || retained.name !== name || retained.view !== view || reading.stale) {
 			reading = await this.#race(view.read({ signal: context.signal }), "", context.signal);
 			this.#reading = {
 				view,
-				reading
+				reading,
+				name
 			};
 		}
-		const start = reading === retained?.reading && offset < reading.markdown({
-			offset: 0,
-			limit: 1
-		}).total ? offset : 0;
-		const note = boundBrowserText(this.#drain(), Math.max(1, this.#limit - 1), BROWSER_TOOL_CUT_FOOTER);
+		const whole = project(reading);
+		const start = reading === retained?.reading && offset < whole.total ? offset : 0;
+		const note = this.#drainNote();
 		const room = this.#limit - note.length;
-		const slice = room < 1 ? {
+		const search = (0, _orkestrel_contract.isString)(args["search"]) ? args["search"] : "";
+		const matches = start === 0 ? scanBrowserText(whole.text, search) : [];
+		const count = matches.length;
+		const block = renderBrowserMatches(`${count} ${count === 1 ? "line matches" : "lines match"} ${JSON.stringify(search)}:`, matches.map((match) => `[${match.offset}] ${match.text}`), room);
+		const space = room - block.length;
+		const slice = space < 1 ? {
 			text: "",
 			offset: start,
-			total: reading.markdown({ offset: 0 }).total
-		} : reading.markdown({
-			offset: start,
-			limit: room
-		});
-		if (note === "" && slice.text === "" && slice.offset < slice.total) throw new BrowserError(`The read limit of ${this.#limit} characters cannot hold the next character at offset ${start}; raise the toolset limit.`, "BROWSER_TOOLSET_LIMIT", {
+			total: whole.total
+		} : extractBrowserSlice(whole.text, start, space);
+		return this.#pageSlice(name, note, slice, block);
+	}
+	#readOffset(args) {
+		const offset = args["offset"] ?? 0;
+		if (!(0, _orkestrel_contract.isInteger)(offset) || offset < 0) throw new BrowserError("The offset parameter must be a non-negative integer.", "BROWSER_TOOLSET_ARGUMENT", { key: "offset" });
+		return offset;
+	}
+	#drainNote() {
+		return boundBrowserText(this.#drain(), Math.max(1, this.#limit - 1), BROWSER_TOOL_CUT_FOOTER);
+	}
+	#pageSlice(name, note, slice, block = "") {
+		if (note === "" && slice.text === "" && slice.offset < slice.total) throw new BrowserError(`The ${name} limit of ${this.#limit} characters cannot hold the next character at offset ${slice.offset}; raise the toolset limit.`, "BROWSER_TOOLSET_LIMIT", {
 			limit: this.#limit,
-			offset: start
+			offset: slice.offset
 		});
 		const end = slice.offset + slice.text.length;
 		const more = end < slice.total;
-		if (start === 0 && !more) return [`${note}${slice.text}`, ""];
-		return [`${note}${slice.text}`, `\n\n[characters ${start}–${end} of ${slice.total}${more ? `; call read with offset ${end} for more` : ""}]`];
+		if (slice.offset === 0 && !more) return [`${note}${block}${slice.text}`, ""];
+		return [`${note}${block}${slice.text}`, `\n\n[characters ${slice.offset}–${end} of ${slice.total}${more ? `; call ${name} with offset ${end} for more` : ""}]`];
 	}
 	async #click(args, context) {
 		const turn = await this.#acquire(context.signal);
@@ -12555,7 +13306,7 @@ var BrowserToolset = class {
 			return [await this.#settle(page.keyboard.press(key), action, context.signal, true, record, popups, observation, key === "Enter" ? {
 				explicit: false,
 				action
-			} : void 0), ""];
+			} : void 0, true), ""];
 		} finally {
 			record?.destroy();
 			popups?.destroy();
@@ -12594,7 +13345,7 @@ var BrowserToolset = class {
 			const action = `Navigated to ${result.url}`;
 			return [renderBrowserReceipt({
 				action,
-				view: await this.#capture(action, context.signal)
+				view: (await this.#capture(action, context.signal)).view
 			}), ""];
 		} finally {
 			if (this.#navigating === page) this.#navigating = void 0;
@@ -12605,22 +13356,25 @@ var BrowserToolset = class {
 	async #wait(args, context) {
 		const text = readBrowserToolString(args, "text");
 		const seconds = args["timeout"];
+		const absent = args["absent"];
+		if (absent !== void 0 && !(0, _orkestrel_contract.isBoolean)(absent)) throw new BrowserError("The absent parameter must be a boolean.", "BROWSER_TOOLSET_ARGUMENT", { key: "absent" });
 		if (seconds !== void 0 && (!(0, _orkestrel_contract.isFiniteNumber)(seconds) || seconds <= 0)) throw new BrowserError("The timeout parameter must be a positive number of seconds.", "BROWSER_TOOLSET_ARGUMENT", { key: "timeout" });
 		const timeout = Math.min(seconds === void 0 ? BROWSER_TOOL_TIMEOUT_MS : Math.ceil(seconds * 1e3), BROWSER_TOOL_TIMEOUT_LIMIT_MS);
 		const quoted = JSON.stringify(text);
 		try {
 			await this.#race(this.#cursor.wait(text, {
 				timeout,
-				signal: context.signal
-			}), `Waited for ${quoted}`, context.signal);
-			return [`${quoted} is on the page.`, ""];
+				signal: context.signal,
+				absent: absent === true
+			}), `Waited for ${quoted}${absent === true ? " to leave" : ""}`, context.signal);
+			return [`${quoted} is ${absent === true ? "not " : ""}on the page.`, ""];
 		} catch (error) {
 			if (!context.signal.aborted && isBrowserError(error) && error.code === "BROWSER_WAIT_TIMEOUT") {
 				this.#actions.set(context.signal, {
 					...this.#actions.get(context.signal),
 					outcome: "timeout"
 				});
-				return [`${quoted} did not appear within ${timeout / 1e3} s.`, ""];
+				return [absent === true ? `${quoted} is still on the page after ${timeout / 1e3} s.` : `${quoted} did not appear within ${timeout / 1e3} s.`, ""];
 			}
 			throw error;
 		}
@@ -12643,14 +13397,19 @@ var BrowserToolset = class {
 			const action = `${accept ? "Accepted" : "Dismissed"} the ${dialog.category} dialog ${JSON.stringify(dialog.message)}`;
 			return [renderBrowserReceipt({
 				action,
-				view: await this.#capture(action, context.signal)
+				view: (await this.#capture(action, context.signal)).view
 			}), ""];
 		} finally {
 			turn.resolve();
 		}
 	}
-	async #tabs(_args, context) {
-		return [(await this.#list(context.signal, true)).map((tab) => `${tab.id} ${JSON.stringify(tab.title)} ${tab.url}${tab.current ? " (current)" : ""}`).join("\n"), ""];
+	async #tabs(args, context) {
+		const text = (await this.#list(context.signal, true)).map((tab) => `${tab.id} ${JSON.stringify(tab.title)} ${tab.url}${tab.current ? " (current)" : ""}`).join("\n");
+		const search = (0, _orkestrel_contract.isString)(args["search"]) ? args["search"] : "";
+		const matches = scanBrowserText(text, search);
+		const count = matches.length;
+		const note = this.#drainNote();
+		return [`${note}${renderBrowserMatches(`${count} ${count === 1 ? "tab matches" : "tabs match"} ${JSON.stringify(search)}:`, matches.map((match) => match.text), this.#limit - note.length)}${text}`, ""];
 	}
 	async #switch(args, context) {
 		const tab = readBrowserToolString(args, "tab");
@@ -12673,7 +13432,7 @@ var BrowserToolset = class {
 			await this.#command(front, action, front);
 			return [renderBrowserReceipt({
 				action,
-				view: await this.#capture(action, context.signal)
+				view: (await this.#capture(action, context.signal)).view
 			}), ""];
 		} finally {
 			turn.resolve();
@@ -12682,7 +13441,7 @@ var BrowserToolset = class {
 	async #invoke(tool, synthetic, args, context) {
 		const turn = await this.#acquire(context.signal);
 		try {
-			const input = synthetic ? Object.fromEntries(Object.entries(args).filter(([key]) => key !== "what")) : args;
+			const input = synthetic ? Object.fromEntries(Object.entries(args).filter(([key]) => key !== "purpose")) : args;
 			const command = Promise.resolve(tool.execute(input, context));
 			return [renderBrowserToolOutput(await this.#command(command, `Called ${tool.name}`, command, context.signal)), ""];
 		} finally {
@@ -12762,7 +13521,7 @@ var BrowserToolset = class {
 		}
 		return turn;
 	}
-	async #settle(command, action, signal, trusted, record, popups, observation, enter) {
+	async #settle(command, action, signal, trusted, record, popups, observation, enter, focus = false) {
 		let deadline;
 		try {
 			const started = record?.wait({ signal }).then(() => true, () => new Promise(() => void 0));
@@ -12798,11 +13557,13 @@ var BrowserToolset = class {
 			const unmoved = settled === void 0 && submissions.destinations.length === 0;
 			const status = settled?.stage === "committed" ? `the page is still loading ${settled.url}` : settled?.stage === "requested" ? `it requested ${settled.url} and the page did not change` : unmoved && submissions.prevented ? BROWSER_TOOL_HANDLED_STATUS : unmoved && submissions.submitted === false && (enter?.explicit === true || enter !== void 0 && submissions.implicit) ? "no form received the submission" : void 0;
 			const line = enter !== void 0 && (submissions.submitted === true || settled?.reason === "formSubmissionGet" || settled?.reason === "formSubmissionPost") ? enter.action : action;
+			const captured = await this.#capture(line, signal, deadline);
+			const parts = [status, focus && captured.focus !== void 0 ? `focus is on ${captured.focus}` : void 0].filter((part) => part !== void 0);
 			return renderBrowserReceipt({
 				action: line,
 				trusted,
-				...status === void 0 ? {} : { status },
-				view: await this.#capture(line, signal, deadline)
+				...parts.length === 0 ? {} : { status: parts.join("; ") },
+				view: captured.view
 			});
 		} finally {
 			record?.destroy();
@@ -12969,7 +13730,10 @@ var BrowserToolset = class {
 		}
 	}
 	async #capture(action, signal, deadline = performance.now() + BROWSER_TOOL_TIMEOUT_MS) {
-		if (deadline - performance.now() < 1) return BROWSER_TOOL_DEADLINE_NOTE;
+		if (deadline - performance.now() < 1) return {
+			view: BROWSER_TOOL_DEADLINE_NOTE,
+			focus: void 0
+		};
 		const receipt = new AbortController();
 		const options = {
 			signal: AbortSignal.any([signal, receipt.signal]),
@@ -12977,16 +13741,34 @@ var BrowserToolset = class {
 		};
 		try {
 			const outline = await this.#bounded(this.#cursor.elements.outline(options), deadline, action);
-			return outline === void 0 ? BROWSER_TOOL_DEADLINE_NOTE : outline.text;
+			return outline === void 0 ? {
+				view: BROWSER_TOOL_DEADLINE_NOTE,
+				focus: void 0
+			} : {
+				view: outline.text,
+				focus: outline.focus
+			};
 		} catch (error) {
 			if (signal.aborted || isBrowserError(error) && error.code === "BROWSER_TOOLSET_RECEIPT") throw error;
-			if (!isBrowserElementError(error) || error.context?.["reason"] !== "GONE") return `(The view could not be read: ${(0, _orkestrel_contract.isError)(error) ? error.message : String(error)}; call look.)`;
+			if (!isBrowserElementError(error) || error.context?.["reason"] !== "GONE") return {
+				view: `(The view could not be read: ${(0, _orkestrel_contract.isError)(error) ? error.message : String(error)}; call look.)`,
+				focus: void 0
+			};
 			try {
 				const outline = await this.#bounded(this.#cursor.elements.outline(options), deadline, action);
-				return outline === void 0 ? BROWSER_TOOL_DEADLINE_NOTE : outline.text;
+				return outline === void 0 ? {
+					view: BROWSER_TOOL_DEADLINE_NOTE,
+					focus: void 0
+				} : {
+					view: outline.text,
+					focus: outline.focus
+				};
 			} catch (retry) {
 				if (signal.aborted || isBrowserError(retry) && retry.code === "BROWSER_TOOLSET_RECEIPT") throw retry;
-				return BROWSER_TOOL_CHANGED_NOTE;
+				return {
+					view: BROWSER_TOOL_CHANGED_NOTE,
+					focus: void 0
+				};
 			}
 		} finally {
 			receipt.abort(new BrowserError("the receipt settled", "BROWSER_TOOLSET_SETTLED"));
@@ -13226,6 +14008,7 @@ exports.BROWSER_ACTION_OUTCOMES = BROWSER_ACTION_OUTCOMES;
 exports.BROWSER_ACTION_STAGES = BROWSER_ACTION_STAGES;
 exports.BROWSER_CODEGEN_BINDING_NAME = BROWSER_CODEGEN_BINDING_NAME;
 exports.BROWSER_CODEGEN_SOURCE = BROWSER_CODEGEN_SOURCE;
+exports.BROWSER_CONTEXT_LOSS_PATTERN = BROWSER_CONTEXT_LOSS_PATTERN;
 exports.BROWSER_DEFAULT_TIMEOUT_MS = BROWSER_DEFAULT_TIMEOUT_MS;
 exports.BROWSER_DEFAULT_VIEWPORT_HEIGHT = BROWSER_DEFAULT_VIEWPORT_HEIGHT;
 exports.BROWSER_DEFAULT_VIEWPORT_WIDTH = BROWSER_DEFAULT_VIEWPORT_WIDTH;
@@ -13260,6 +14043,7 @@ exports.BROWSER_RESULT_LIMIT_SENTINEL_PREFIX = BROWSER_RESULT_LIMIT_SENTINEL_PRE
 exports.BROWSER_RUN_ID_PATTERN = BROWSER_RUN_ID_PATTERN;
 exports.BROWSER_SCHEMES = BROWSER_SCHEMES;
 exports.BROWSER_SCREENSHOT_ATTRIBUTE = BROWSER_SCREENSHOT_ATTRIBUTE;
+exports.BROWSER_SEARCH_PATTERN = BROWSER_SEARCH_PATTERN;
 exports.BROWSER_SNAPSHOT_NODE_LIMIT = BROWSER_SNAPSHOT_NODE_LIMIT;
 exports.BROWSER_STABLE_FRAME_COUNT = BROWSER_STABLE_FRAME_COUNT;
 exports.BROWSER_STOP_LOADING_TIMEOUT_MS = BROWSER_STOP_LOADING_TIMEOUT_MS;
@@ -13279,6 +14063,7 @@ exports.BROWSER_TOOL_TIMEOUT_LIMIT_MS = BROWSER_TOOL_TIMEOUT_LIMIT_MS;
 exports.BROWSER_TOOL_TIMEOUT_MS = BROWSER_TOOL_TIMEOUT_MS;
 exports.BROWSER_TOOL_VIEW_FOOTER = BROWSER_TOOL_VIEW_FOOTER;
 exports.BROWSER_TYPED_ROLES = BROWSER_TYPED_ROLES;
+exports.BROWSER_WAIT_EVENTS = BROWSER_WAIT_EVENTS;
 exports.BrowserAccessibility = BrowserAccessibility;
 exports.BrowserClock = BrowserClock;
 exports.BrowserCodegen = BrowserCodegen;
@@ -13331,6 +14116,7 @@ exports.buildBrowserJourney = buildBrowserJourney;
 exports.bytesToText = bytesToText;
 exports.collectBrowserJourneyBindings = collectBrowserJourneyBindings;
 exports.collectBrowserJourneyTextBindings = collectBrowserJourneyTextBindings;
+exports.collectBrowserWords = collectBrowserWords;
 exports.compileActionabilityFunction = compileActionabilityFunction;
 exports.compileBrowserBindingCleanup = compileBrowserBindingCleanup;
 exports.compileBrowserBindingResult = compileBrowserBindingResult;
@@ -13455,7 +14241,9 @@ exports.readRareStringData = readRareStringData;
 exports.renderBrowserElement = renderBrowserElement;
 exports.renderBrowserJourney = renderBrowserJourney;
 exports.renderBrowserJourneyFault = renderBrowserJourneyFault;
+exports.renderBrowserMatches = renderBrowserMatches;
 exports.renderBrowserOutline = renderBrowserOutline;
+exports.renderBrowserOutlineRow = renderBrowserOutlineRow;
 exports.renderBrowserReceipt = renderBrowserReceipt;
 exports.renderBrowserRun = renderBrowserRun;
 exports.renderBrowserRunResult = renderBrowserRunResult;
@@ -13463,6 +14251,8 @@ exports.renderBrowserToolOutput = renderBrowserToolOutput;
 exports.requireBrowserReference = requireBrowserReference;
 exports.requireBrowserString = requireBrowserString;
 exports.resolveBrowserJourneyBinding = resolveBrowserJourneyBinding;
+exports.scanBrowserOutline = scanBrowserOutline;
+exports.scanBrowserText = scanBrowserText;
 exports.settleBrowserTeardown = settleBrowserTeardown;
 exports.textToBytes = textToBytes;
 exports.validateBrowserAccessibilityOptions = validateBrowserAccessibilityOptions;