@orkestrel/browser 0.0.26 → 0.0.28

package/dist/src/core/index.d.cts

@@ -2,6 +2,7 @@ import type { EmitterErrorHandler } from '@orkestrel/emitter';
 import type { EmitterHooks } from '@orkestrel/emitter';
 import type { EmitterInterface } from '@orkestrel/emitter';
 import type { HTMLInterface } from '@orkestrel/html';
+import type { JSONRecord } from '@orkestrel/contract';
 import type { JSONValue } from '@orkestrel/contract';
 import type { ToolCall } from '@orkestrel/tool';
 import type { ToolContext } from '@orkestrel/tool';
@@ -10,26 +11,33 @@ import type { ToolInterface } from '@orkestrel/tool';
 import type { ToolManagerInterface } from '@orkestrel/tool';
 import type { ToolResult } from '@orkestrel/tool';
 
-/** Holds the index-ordered base64 alphabet used to build {@link BASE64_LOOKUP}. */
-export declare const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Abbreviates displayed metadata without splitting a Unicode code point.
+ * @param text - Metadata text
+ * @param limit - Available UTF-16 units
+ * @returns Normalized text with an ellipsis when abbreviated
+ */
+export declare function abbreviateBrowserText(text: string, limit: number): string;
 
-/** Maps each base64 character to its 6-bit value, derived from {@link BASE64_CHARS}. */
-export declare const BASE64_LOOKUP: Readonly<Record<string, number>>;
+/** Checks whether a node descends from another within one session's captured tree.
+ * @param node - Candidate descendant
+ * @param ancestor - Owning node
+ * @param indexed - Nodes indexed by session and accessibility identity
+ * @returns True if the node descends from the ancestor; false otherwise
+ */
+export declare function belongsBrowserOutline(node: BrowserOutlineNode, ancestor: BrowserOutlineNode, indexed: ReadonlyMap<string, BrowserOutlineNode>): boolean;
 
 /**
  * Bounds a tool string at a character limit, appending a footer that names the cut and the
  * caller's closing clause.
  *
  * @remarks
- * A string within the limit returns unchanged. A longer one keeps its first `limit` UTF-16 code
- * 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 an action or `dialog` receipt that carries a view and
- * `BROWSER_TOOL_CUT_FOOTER` for any other result, including `look` and `read` results.
+ * A string within the limit returns unchanged. Otherwise the cut text plus footer fits `limit`
+ * UTF-16 code units, without splitting a surrogate pair. When the character-range footer cannot
+ * fit, the result ends with an ellipsis instead. The footer has no default: each caller states
+ * what the reader does next. Numbered windows select whole rows through `renderBrowserWindow`.
  *
  * @param text - The page-authored or composed string
- * @param limit - The most characters kept before the footer, a positive integer
+ * @param limit - The whole-result character limit, a positive integer
  * @param footer - The clause that closes the footer after the character range
  * @returns The string, cut and footed when it exceeds the limit
  * @throws Thrown when `limit` is not a positive integer.
@@ -38,7 +46,7 @@ export declare const BASE64_LOOKUP: Readonly<Record<string, number>>;
  * ```ts
  * import { boundBrowserText } from '@orkestrel/browser'
  *
- * boundBrowserText('abcdef', 4, 'the rest was cut') // 'abcd\n[characters 0–4 of 6; the rest was cut]'
+ * boundBrowserText('abcdef', 4, 'the rest was cut') // 'abc…'
  * boundBrowserText('abc', 4, 'the rest was cut') // 'abc'
  * ```
  */
@@ -107,7 +115,7 @@ export declare const BROWSER_FRAME_WORLD_NAME = "__orkestrelBrowserFrame";
  */
 export declare const BROWSER_HAR_CREATOR: Readonly<{
     name: "@orkestrel/browser";
-    version: "0.0.26";
+    version: "0.0.28";
 }>;
 
 /** Names accessibility roles that receive actionable outline references. */
@@ -122,9 +130,18 @@ export declare const BROWSER_INTERACTIVE_ROLES: ReadonlySet<string>;
  */
 export declare const BROWSER_JOURNEY_ACTIONS: readonly BrowserToolName[];
 
+/** Holds the refusal `edit` returns without a journey when several journeys are saved. */
+export declare const BROWSER_JOURNEY_EDIT_CHOICE_REFUSAL = "Edit requires journey, one of {names}; call edit with that name beside edits.";
+
+/** Holds the refusal `edit` returns without a journey when no journey is saved. */
+export declare const BROWSER_JOURNEY_EDIT_EMPTY_REFUSAL = "No journey is saved, so there is nothing to edit; call record to start one.";
+
 /** Holds the result the `journeys` tool returns when no journey is saved. */
 export declare const BROWSER_JOURNEY_EMPTY_LISTING = "No journeys are saved; call record to start one.";
 
+/** Holds the refusal `save` returns while the recording has no steps. */
+export declare const BROWSER_JOURNEY_EMPTY_REFUSAL = "Nothing is recorded for {name} yet, and it is still recording. Click and type the flow's steps now, then call save.";
+
 /** Holds the journey and run file format this package writes and reads, `1`. */
 export declare const BROWSER_JOURNEY_FORMAT_VERSION: BrowserJourney['format'];
 
@@ -151,8 +168,17 @@ export declare const BROWSER_JOURNEY_PARAMETER_PATTERN: RegExp;
 /** Holds the refusal `record`, `save`, `edit`, and `forget` return when the journeys are read-only. */
 export declare const BROWSER_JOURNEY_READONLY_REFUSAL = "The journeys are read-only; call replay.";
 
+/** Holds the refusal `record` returns for the same empty recording. */
+export declare const BROWSER_JOURNEY_RECORD_EMPTY_REFUSAL = "{name} is already recording and has no steps yet. Click and type the flow's steps now, then call save.";
+
+/** Holds the refusal `record` returns for the same recording with steps. */
+export declare const BROWSER_JOURNEY_RECORD_STEPS_REFUSAL = "{name} is already recording with {count} {steps}; call save when the flow is done.";
+
 /** Holds the refusal `record` returns while another journey is recording. */
-export declare const BROWSER_JOURNEY_RECORDING_REFUSAL = "A journey is recording; call save first.";
+export declare const BROWSER_JOURNEY_RECORDING_REFUSAL = "{name} is recording; call save before you record another.";
+
+/** Holds the refusal `save` returns after a successful save when no journey is recording. */
+export declare const BROWSER_JOURNEY_SAVE_SAVED_REFUSAL = "Nothing is recording, so there is nothing to save; {name} is already saved. Answer the user.";
 
 /** Names native tool arguments represented by journey targets, tabs, or secret bindings. */
 export declare const BROWSER_JOURNEY_STEP_KEYS: readonly string[];
@@ -184,6 +210,21 @@ export declare const BROWSER_OUTLINE_LIMIT = 150;
 /** Names accessibility roles whose own rows add no outline content. */
 export declare const BROWSER_OUTLINE_OMITTED_ROLES: ReadonlySet<string>;
 
+/** Reports changed line numbers without restarting a continuation. */
+export declare const BROWSER_READ_CHANGED_NOTE = "The page changed since the last view; line numbers might differ.";
+
+/** Opens a search window one line before its first match. */
+export declare const BROWSER_READ_CONTEXT = 1;
+
+/** Caps a default reading window at 100 addressed lines. */
+export declare const BROWSER_READ_LINES = 100;
+
+/** Caps the displayed search hit list at 50 line numbers. */
+export declare const BROWSER_READ_MATCHES = 50;
+
+/** Wraps projection rows at 800 UTF-16 units, leaving room for receipt metadata. */
+export declare const BROWSER_READ_WIDTH = 800;
+
 /** Prefixes stable element references within a browser context. */
 export declare const BROWSER_REFERENCE_PREFIX = "e";
 
@@ -302,7 +343,7 @@ export declare const BROWSER_TOOL_CAPTURE_MS = 1000;
  * capture twice: once after the action, and again during the one retry that follows the page's
  * readiness.
  */
-export declare const BROWSER_TOOL_CHANGED_NOTE = "(The page changed before the view could be read; call look.)";
+export declare const BROWSER_TOOL_CHANGED_NOTE = "(The page changed before the view could be read; call read.)";
 
 /**
  * Holds the advertised definition of each reserved tool: its description, its JSON Schema
@@ -310,21 +351,25 @@ export declare const BROWSER_TOOL_CHANGED_NOTE = "(The page changed before the v
  *
  * @remarks
  * Every tool description is at most 25 words and says what the tool shows or does, and for
- * `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`, `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
+ * `read` when to call it; every parameter description is at most 100 characters.
+ * In the 2026-10-07 measurement, qwen3.5:2b-q4_K_M reads the `click` and `type` tool description
+ * bytes as instructions with thinking on, and the `type` tool focusing the field itself removes
+ * a click before each entry.
+ * `read` requires `from`: making it optional reduced search from 16/16 to 6/16 and paging from
+ * 16/16 to 0/6 in the 2026-10-07 qwen3.5:2b-q4_K_M store measurement.
+ * `journeys` keeps optional `from` with default 1 for the measured 2B `journeys{}` omission;
+ * the page tasks in that measurement never advertise it.
+ * Both tools accept optional `to` and `search`; an element's own reading is
+ * `BrowserElementInterface.read`. `read` and `journeys` annotate `pure` and
+ * `untrusted`, `wait` annotates `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`.
+ * `edit`, `replay`, `forget`, and `capture` are advertised only by a toolset constructed with `journeys`.
  * `wait` takes `absent` beside `text` and `timeout`.
  */
 export declare const BROWSER_TOOL_COPY: Readonly<Record<BrowserToolName, ToolDefinition>>;
 
 /**
- * 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.
+ * Holds the clause that ends a cut result without an addressed page window.
  */
 export declare const BROWSER_TOOL_CUT_FOOTER = "the rest was cut";
 
@@ -332,16 +377,15 @@ export declare const BROWSER_TOOL_CUT_FOOTER = "the rest was cut";
  * Holds the note an action receipt carries in place of the view when the receipt's deadline
  * passed before the view could be captured.
  */
-export declare const BROWSER_TOOL_DEADLINE_NOTE = "(The view could not be read before the deadline; call look.)";
+export declare const BROWSER_TOOL_DEADLINE_NOTE = "(The view could not be read before the deadline; call read.)";
 
 /**
- * Holds the status an action receipt carries after a submission a page listener prevented, with no
- * navigation after it, naming `wait` as the next call because the page's outcome can arrive later.
+ * Holds the status of a handled submission whose settle observed a change.
  */
-export declare const BROWSER_TOOL_HANDLED_STATUS = "the page handled the submission without navigating; call wait for the text you expect";
+export declare const BROWSER_TOOL_HANDLED_STATUS = "the page handled the submission and changed";
 
 /**
- * Bounds each tool result and error message at `4_000` UTF-16 code units before its footer.
+ * Bounds each tool result and error message at `4_000` UTF-16 code units including its footer.
  *
  * @remarks
  * A page tool's error message and JSON output reach the toolset already cut at
@@ -365,13 +409,13 @@ export declare const BROWSER_TOOL_LIMIT = 4000;
 export declare const BROWSER_TOOL_NAME_PATTERN: RegExp;
 
 /**
- * Names every tool the browser toolset reserves: `look`, `read`, `plain`, `click`, `type`, `press`,
- * `navigate`, `wait`, `dialog`, `tabs`, and `switch`.
+ * Names the eight page tools: `read`, `click`, `type`, `press`, `navigate`, `wait`, `dialog`,
+ * and `switch`.
  */
 export declare const BROWSER_TOOL_NAMES: readonly BrowserToolName[];
 
 /** Holds the refusal for a hold requested while an earlier input remains pending. */
-export declare const BROWSER_TOOL_PENDING_NOTE = "An earlier input is still pending; call look.";
+export declare const BROWSER_TOOL_PENDING_NOTE = "An earlier input is still pending; call read.";
 
 /** Caps the `wait` tool's `timeout` parameter at `30_000` milliseconds. */
 export declare const BROWSER_TOOL_TIMEOUT_LIMIT_MS = 30000;
@@ -387,11 +431,8 @@ export declare const BROWSER_TOOL_TIMEOUT_LIMIT_MS = 30000;
  */
 export declare const BROWSER_TOOL_TIMEOUT_MS = 5000;
 
-/**
- * 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.
- */
-export declare const BROWSER_TOOL_VIEW_FOOTER = "the rest was cut; call look with words to find";
+/** Holds the status of a handled submission with no rendered change before the deadline. */
+export declare const BROWSER_TOOL_UNCHANGED_STATUS = "the page handled the submission and has not changed yet; do not submit again; call read or wait for the text you expect";
 
 /**
  * Names the accessibility roles the `type` tool writes to: `textbox`, `searchbox`, and
@@ -415,23 +456,6 @@ export declare const BROWSER_TYPED_ROLES: ReadonlySet<string>;
  */
 export declare const BROWSER_WAIT_EVENTS: readonly string[];
 
-/**
- * Captures Chromium Accessibility-domain snapshots for one page.
- *
- * @example
- * ```ts
- * import { BrowserAccessibility } from '@orkestrel/browser'
- *
- * const accessibility = new BrowserAccessibility(page)
- * const tree = await accessibility.snapshot({ depth: 3 }) // { roots, nodes }
- * ```
- */
-export declare class BrowserAccessibility implements BrowserAccessibilityInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    snapshot(options?: BrowserAccessibilityOptions): Promise<BrowserAccessibilitySnapshot>;
-}
-
 /** Inspects the accessibility tree. */
 export declare interface BrowserAccessibilityInterface {
     /** Reads the full accessibility tree, optionally pruned to the interesting nodes. */
@@ -455,6 +479,7 @@ export declare interface BrowserAccessibilitySnapshot {
  *
  * @remarks
  * - `action` — the tool's name
+ * - `start` — the view's URL before dispatch, with registered secrets redacted
  * - `arguments` — the call's arguments, without the text of a secret `type`
  * - `target` — the element the call's reference resolved to, captured before the input was
  *   dispatched: its role, exact accessible name, reference, and, in the page placement, frame
@@ -470,6 +495,7 @@ export declare interface BrowserAccessibilitySnapshot {
  */
 export declare interface BrowserAction {
     readonly action: string;
+    readonly start?: string;
     readonly arguments: Readonly<Record<string, JSONValue>>;
     readonly target?: {
         readonly role: string;
@@ -534,6 +560,14 @@ export declare interface BrowserCallOptions {
     readonly signal?: AbortSignal;
 }
 
+/** Carries a receipt's capture or the bounded reason no capture was available. */
+export declare interface BrowserCaptureResult {
+    readonly outline?: BrowserOutline;
+    readonly note?: string;
+    readonly tabs: readonly BrowserTab[];
+    readonly focus: string | undefined;
+}
+
 /** Describes a parsed keyboard chord. */
 export declare interface BrowserChord {
     readonly modifiers: readonly string[];
@@ -552,35 +586,11 @@ export declare interface BrowserClickOptions extends BrowserInputOptions {
     readonly count?: number;
 }
 
-/**
- * Controls the Chromium virtual-time budget for deterministic page timers.
- *
- * @example
- * ```ts
- * import { BrowserClock } from '@orkestrel/browser'
- *
- * const clock = new BrowserClock(page)
- * await clock.install(Date.UTC(2026, 0, 1))
- * await clock.advance(5_000)
- * await clock.uninstall()
- * ```
- */
-export declare class BrowserClock implements BrowserClockInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    get installed(): boolean;
-    install(time?: number): Promise<void>;
-    pause(): Promise<void>;
-    resume(): Promise<void>;
-    advance(ms: number): Promise<void>;
-    uninstall(): Promise<void>;
-}
-
 /** Controls Chromium virtual time for deterministic page timers. */
 export declare interface BrowserClockInterface {
-    readonly installed: boolean;
+    readonly active: boolean;
     /** Takes over the page clock, optionally seeding it with an epoch time. */
-    install(time?: number): Promise<void>;
+    start(time?: number): Promise<void>;
     /** Suspends virtual time so no page timer advances. */
     pause(): Promise<void>;
     /** Continues virtual time after a pause. */
@@ -589,42 +599,8 @@ export declare interface BrowserClockInterface {
      * Moves virtual time forward by the given milliseconds, firing the timers that fall due.
      */
     advance(ms: number): Promise<void>;
-    /** Returns the page to the real clock, and does nothing when no clock was installed. */
-    uninstall(): Promise<void>;
-}
-
-/**
- * Records semantic page gestures and compiles them into a journey module.
- * @example
- * const recorder = await page.codegen()
- * await recorder.stop()
- * const script = recorder.script({ name: "add-note", description: "Add a note" })
- */
-export declare class BrowserCodegen implements BrowserCodegenInterface {
-    #private;
-    constructor(client: CDPClientInterface, session: string, options?: BrowserRecorderOptions, frames?: () => readonly string[]);
-    get emitter(): EmitterInterface<BrowserRecorderEventMap>;
-    get started(): boolean;
-    start(): Promise<void>;
-    /**
-     * Installs recording on an attached frame before its owner resumes it.
-     * @param session - The attached frame session
-     * @returns Completion of listener installation
-     */
-    attach(session: string): Promise<void>;
-    stop(): Promise<readonly BrowserJourneyStep[]>;
-    steps(): readonly BrowserJourneyStep[];
-    journey(options: {
-        readonly name: string;
-        readonly description: string;
-    }): BrowserJourney;
-    script(options: {
-        readonly name: string;
-        readonly description: string;
-        readonly language?: BrowserCodegenLanguage;
-    }): BrowserCodegenScript;
-    clear(): void;
-    destroy(): Promise<void>;
+    /** Returns the page to the real clock, and does nothing when no clock was active. */
+    stop(): Promise<void>;
 }
 
 /** Carries a sanitized gesture from the page listener without password values. */
@@ -642,18 +618,6 @@ export declare interface BrowserCodegenGesture {
     readonly gap?: string;
 }
 
-/** Records semantic page gestures and compiles the resulting journey. */
-export declare interface BrowserCodegenInterface extends BrowserRecorderInterface {
-    /** Installs recording on an attached frame before its owner resumes it. */
-    attach(session: string): Promise<void>;
-    /** Compiles the recorded journey into a standalone module and lists its gaps. */
-    script(options: {
-        readonly name: string;
-        readonly description: string;
-        readonly language?: BrowserCodegenLanguage;
-    }): BrowserCodegenScript;
-}
-
 /** Names the target language for a compiled codegen script. */
 export declare type BrowserCodegenLanguage = 'javascript' | 'typescript';
 
@@ -670,14 +634,6 @@ export declare interface BrowserCodegenScript {
     readonly gaps: readonly string[];
 }
 
-/**
- * Reports that a CDP connection, discovery, or launch attempt failed, under the code
- * `BROWSER_CONNECTION_ERROR`.
- */
-export declare class BrowserConnectionError extends BrowserError {
-    constructor(message: string, context?: Readonly<Record<string, unknown>>);
-}
-
 /** Represents one console API call. */
 export declare interface BrowserConsoleMessage {
     readonly level: string;
@@ -699,16 +655,16 @@ export declare interface BrowserConsoleMessage {
  *
  * @example
  * ```ts
- * import { BrowserContext } from '@orkestrel/browser'
+ * import { createBrowserContext } from '@orkestrel/browser'
  *
- * const context = new BrowserContext(client)
+ * const context = createBrowserContext(client)
  * const page = await context.create({ url: 'https://example.com' })
  * await context.destroy()
  * ```
  */
 export declare class BrowserContext implements BrowserContextInterface {
     #private;
-    constructor(client: CDPClientInterface, id?: string, viewport?: BrowserViewport, writer?: BrowserWriterInterface, emulation?: BrowserEmulationOptions, downloads?: BrowserDownloadOptions, options?: BrowserContextOptions);
+    constructor(client: CDPClientInterface, options?: BrowserContextOptions);
     get emitter(): EmitterInterface<BrowserContextEventMap>;
     get id(): string | undefined;
     get disposal(): BrowserContextDisposal | undefined;
@@ -786,23 +742,27 @@ export declare interface BrowserContextInterface {
 }
 
 /**
- * Describes the options for creating and configuring an isolated browser context.
+ * Configures a wrapper around an existing browser context.
  *
  * @remarks
  * - `on` — initial event listeners wired at construction
  * - `error` — observer error handler forwarded to the emitter
- * - `proxy` — proxy server and bypass list for the context
- * - `origins` — origins granted universal network access
+ * - `id` — existing remote context to wrap; omitted for the default context
+ * - `viewport` and `writer` — page defaults and persistence for the context
  * - `downloads` — download policy for the context
  * - `emulation` — emulation overrides inherited by every page of the context
  */
 export declare interface BrowserContextOptions {
+    /** Identifies an existing remote context. Omission addresses the default context. */
+    readonly id?: string;
+    /** Sets the default viewport for pages this context creates. */
+    readonly viewport?: BrowserViewport;
+    /** Persists captures and downloads requested through the context's pages. */
+    readonly writer?: BrowserWriterInterface;
     /** Names each element reference the context's pages issue. Default: a counter the context owns. */
     readonly reference?: BrowserReferenceFunction;
     readonly on?: EmitterHooks<BrowserContextEventMap>;
     readonly error?: EmitterErrorHandler;
-    readonly proxy?: BrowserProxy;
-    readonly origins?: readonly string[];
     readonly downloads?: BrowserDownloadOptions;
     readonly emulation?: BrowserEmulationOptions;
 }
@@ -820,7 +780,7 @@ export declare interface BrowserCookie {
     readonly partition: BrowserCookiePartition | undefined;
 }
 
-/** Describes optional narrowing criteria for clearing context cookies. */
+/** Describes narrowing criteria for removing context cookies. */
 export declare interface BrowserCookieFilter {
     readonly name?: string;
     readonly domain?: string;
@@ -842,34 +802,16 @@ export declare interface BrowserCookieInput {
     readonly partition?: BrowserCookiePartition;
 }
 
-/**
- * Performs cookie operations isolated to one browser context.
- *
- * @example
- * ```ts
- * import { BrowserCookieManager } from '@orkestrel/browser'
- *
- * const cookies = new BrowserCookieManager(client)
- * await cookies.set([{ name: 'session', value: 'value', url: 'https://example.com/' }])
- * const current = await cookies.cookies(['https://example.com/'])
- * ```
- */
-export declare class BrowserCookieManager implements BrowserCookieManagerInterface {
-    #private;
-    constructor(client: CDPClientInterface, context?: string);
-    cookies(urls?: readonly string[]): Promise<readonly BrowserCookie[]>;
-    set(cookies: readonly BrowserCookieInput[]): Promise<void>;
-    clear(filter?: BrowserCookieFilter): Promise<void>;
-}
-
 /** Provides cookie operations scoped to one browser context. */
 export declare interface BrowserCookieManagerInterface {
     /** Reads the context cookies, optionally narrowed to the given URLs. */
     cookies(urls?: readonly string[]): Promise<readonly BrowserCookie[]>;
     /** Writes the given cookies into the context. */
     set(cookies: readonly BrowserCookieInput[]): Promise<void>;
-    /** Deletes the context cookies matching the filter, or every cookie when given none. */
-    clear(filter?: BrowserCookieFilter): Promise<void>;
+    /** Removes the context cookies matching the filter; an empty filter is refused with `ARGUMENT`. */
+    remove(filter: BrowserCookieFilter): Promise<void>;
+    /** Removes every cookie from the context. */
+    clear(): Promise<void>;
 }
 
 /** Describes a cookie partition key used by CHIPS-partitioned cookies. */
@@ -878,27 +820,6 @@ export declare interface BrowserCookiePartition {
     readonly ancestor?: boolean;
 }
 
-/**
- * Collects JavaScript precise coverage and CSS rule usage for one page target.
- *
- * @example
- * ```ts
- * import { BrowserCoverage } from '@orkestrel/browser'
- *
- * const coverage = new BrowserCoverage(page)
- * await coverage.start({ javascript: true, css: true })
- * const usage = await coverage.stop() // { scripts, styles }
- * ```
- */
-export declare class BrowserCoverage implements BrowserCoverageInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    get active(): boolean;
-    start(options?: BrowserCoverageOptions): Promise<void>;
-    stop(): Promise<BrowserCoverageResult>;
-    destroy(): Promise<void>;
-}
-
 /** Drives the coverage capture lifecycle. */
 export declare interface BrowserCoverageInterface {
     readonly active: boolean;
@@ -960,28 +881,6 @@ export declare interface BrowserDestination {
  */
 export declare type BrowserDestinationRelationship = 'self' | 'parent' | 'top';
 
-/**
- * Groups the tracing, coverage, performance, and profiler classes beneath one page.
- *
- * @example
- * ```ts
- * import { BrowserDiagnostics } from '@orkestrel/browser'
- *
- * const diagnostics = new BrowserDiagnostics(page)
- * const metrics = await diagnostics.performance.metrics()
- * await diagnostics.destroy()
- * ```
- */
-export declare class BrowserDiagnostics implements BrowserDiagnosticsInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface, writer?: BrowserWriterInterface);
-    get tracing(): BrowserTracingInterface;
-    get coverage(): BrowserCoverageInterface;
-    get performance(): BrowserPerformanceInterface;
-    get profiler(): BrowserProfilerInterface;
-    destroy(): Promise<void>;
-}
-
 /** Groups the diagnostics by capability. */
 export declare interface BrowserDiagnosticsInterface {
     readonly tracing: BrowserTracingInterface;
@@ -1033,8 +932,7 @@ export declare type BrowserDownloadEventMap = {
  *
  * @remarks
  * Progress arrives from the owning page, which drives the concrete
- * `BrowserDownload`. `update` is on this contract because the class exposes
- * exactly its interface methods.
+ * `BrowserDownload` through private callbacks; consumers observe progress and may abort.
  */
 export declare interface BrowserDownloadInterface {
     readonly emitter: EmitterInterface<BrowserDownloadEventMap>;
@@ -1050,8 +948,6 @@ export declare interface BrowserDownloadInterface {
      * status is still pending. The status becomes `'aborted'` and the `abort` event fires.
      */
     abort(): Promise<void>;
-    /** Records one step of the download's progress. The owning page drives it. */
-    update(progress: BrowserDownloadProgress): void;
 }
 
 /** Describes the download policy for a browser context. */
@@ -1091,44 +987,19 @@ export declare interface BrowserDragOptions extends BrowserInputOptions {
     readonly steps?: number;
 }
 
-/**
- * Reports a refused element operation with a reason and, for `GONE`, the refresh directive.
- *
- * @remarks
- * The message names the element and the detail on one line. It ends with
- * `; call look for fresh refs.` for `GONE` alone, because only a changed page makes a fresh
- * reference the remedy; every other reason ends the message with a period, and a caller whose
- * refusal a fresh reference does fix names that remedy in its detail.
- */
-export declare class BrowserElementError extends BrowserError {
-    constructor(reference: string | BrowserElementSubject, reason: BrowserElementReason, detail?: string);
-}
-
 /** Retains both session-local and page-composed element geometry. */
 export declare interface BrowserElementGeometry {
     readonly local: BrowserQuad;
     readonly page: BrowserQuad;
 }
 
-/** Binds an element to its document identity and the page's shared protocol resources. */
-export declare interface BrowserElementInput extends BrowserElementManagerInput {
-    readonly description: () => BrowserOutlineNode;
-    readonly node: BrowserOutlineNode & {
-        readonly reference: string;
-    };
-    readonly backend: number;
-    readonly frame: string;
-    readonly current: () => boolean;
-    readonly point: BrowserElementPointFunction;
-}
-
 /** Provides actions and reading through a stable document element reference. */
 export declare interface BrowserElementInterface {
     readonly reference: string;
     readonly role: string;
     readonly name: string;
     /**
-     * Clicks the element, refusing with a coded `BrowserElementError` when it is gone, hidden,
+     * Clicks the element, refusing with a coded `BrowserError` when it is gone, hidden,
      * covered, or disabled.
      */
     click(options?: BrowserCallOptions): Promise<void>;
@@ -1159,35 +1030,11 @@ export declare interface BrowserElementInterface {
     submit(options?: BrowserCallOptions): Promise<void>;
 }
 
-/**
- * Captures accessibility trees and binds stable references to their owning frame sessions.
- *
- * @remarks
- * A reference is dropped when the page reports its frame's document replaced or detached through
- * `input.steps`, which carries only the steps of each frame's owning session.
- * @example
- * ```ts
- * const outline = await page.elements.outline()
- * const matches = await page.elements.find({ role: 'button', name: 'save' })
- * await matches[0]?.click()
- * ```
- */
-export declare class BrowserElementManager implements BrowserElementManagerInterface<BrowserPageElementInterface> {
-    #private;
-    constructor(input: BrowserElementManagerInput);
-    outline(options?: BrowserOutlineOptions): Promise<BrowserOutline>;
-    /** A CSS query searches the page's main-frame document; use the accessibility outline for in-process child documents. */
-    find(query: BrowserElementQuery, options?: BrowserCallOptions): Promise<readonly BrowserPageElementInterface[]>;
-    wait(query: BrowserElementQuery, options?: BrowserWaitOptions): Promise<readonly BrowserPageElementInterface[]>;
-    element(reference: string): BrowserPageElementInterface | undefined;
-    elements(): readonly BrowserPageElementInterface[];
-    clear(): void;
-}
-
 /**
  * Provides the protocol and ownership boundaries used by a page element manager.
  *
  * @remarks
+ * Shared by BrowserElementManager and BrowserPageElement.
  * - `steps` — the navigation steps the page accepts from the session that owns each frame
  */
 export declare interface BrowserElementManagerInput {
@@ -1208,8 +1055,8 @@ export declare interface BrowserElementManagerInput {
 export declare interface BrowserElementManagerInterface<TElement extends BrowserElementInterface = BrowserElementInterface> {
     /**
      * Captures the view's document as a document-order outline, binding a reference to each
-     * interactive element and bounding the referenced rows by `limit`. The outline also lists the
-     * rows that best match `search` and names the focused referenced row, both past `limit`.
+     * interactive element and bounding the referenced rows by `limit`. The outline carries
+     * wrapped lines and names the focused referenced row even past `limit`.
      */
     outline(options?: BrowserOutlineOptions): Promise<BrowserOutline>;
     /**
@@ -1233,9 +1080,6 @@ export declare interface BrowserElementManagerInterface<TElement extends Browser
     clear(): void;
 }
 
-/** Composes a frame-local point into page coordinates. */
-export declare type BrowserElementPointFunction = (frame: string, point: BrowserPoint, options?: BrowserCallOptions) => Promise<BrowserPoint>;
-
 /**
  * Describes an accessibility or CSS query within an optional element reference.
  *
@@ -1275,28 +1119,10 @@ export declare interface BrowserElementSubject {
     readonly subject: string;
 }
 
-/** Resolves the page-owned isolated world for a particular frame and session. */
-export declare type BrowserElementWorldFunction = (frame: string, session: string, options?: BrowserCallOptions) => Promise<number>;
-
-/**
- * Applies rendering, identity, location, and network emulation for context pages.
- *
- * @example
- * ```ts
- * import { BrowserEmulationManager } from '@orkestrel/browser'
- *
- * const emulation = new BrowserEmulationManager(() => context.pages())
- * await emulation.apply({ locale: 'en-US', media: { scheme: 'dark' } })
- * await emulation.clear()
- * ```
+/** Resolves the page-owned isolated world for a particular frame and session.
+ * @remarks Shared by BrowserElementManager and BrowserPageElement.
  */
-export declare class BrowserEmulationManager implements BrowserEmulationManagerInterface {
-    #private;
-    constructor(pages: BrowserPagesFunction, options?: BrowserEmulationOptions);
-    apply(options: BrowserEmulationOptions): Promise<void>;
-    clear(): Promise<void>;
-    attach(page: BrowserPageInterface): Promise<void>;
-}
+export declare type BrowserElementWorldFunction = (frame: string, session: string, options?: BrowserCallOptions) => Promise<number>;
 
 /** Configures context-scoped emulation. */
 export declare interface BrowserEmulationManagerInterface {
@@ -1306,8 +1132,6 @@ export declare interface BrowserEmulationManagerInterface {
     apply(options: BrowserEmulationOptions): Promise<void>;
     /** Removes every override this manager applied. */
     clear(): Promise<void>;
-    /** Applies the retained overrides to a newly created page. */
-    attach(page: BrowserPageInterface): Promise<void>;
 }
 
 /** Describes network and rendering overrides inherited by context pages. */
@@ -1331,18 +1155,26 @@ export declare interface BrowserEmulationOptions {
 export declare type BrowserEpochFunction = () => number;
 
 /**
- * Represents the base error for all browser automation operations, carrying the code
- * `BROWSER_ERROR` and a `context` record.
+ * Reports a browser failure with a typed code and optional JSON context.
  *
  * @remarks
- * A caller branches in a `catch` on the `code` rather than parsing message strings.
+ * A caller branches on `code` rather than parsing the message.
  */
 export declare class BrowserError extends Error {
-    readonly code: string;
-    readonly context: Readonly<Record<string, unknown>> | undefined;
-    constructor(message: string, code?: string, context?: Readonly<Record<string, unknown>>);
+    readonly code: BrowserErrorCode;
+    readonly context: JSONRecord | undefined;
+    constructor(code: BrowserErrorCode, message: string, context?: JSONRecord);
 }
 
+/**
+ * Identifies a browser refusal, lifecycle failure, or protocol failure.
+ *
+ * @remarks
+ * `TOOLSET_SETTLED` and `TOOLSET_RECEIPT` stop internal toolset work.
+ * Callers receive their resulting receipt rather than these internal signals.
+ */
+export declare type BrowserErrorCode = 'ARGUMENT' | 'CAPTURE_UNAVAILABLE' | 'CAPTURE_UNTRUSTED' | 'CLOSED' | 'CONNECTION' | 'DISCONNECTED' | 'DOCUMENT' | 'DOCUMENT_DESTROYED' | 'DOCUMENT_OWN' | 'DOCUMENT_SUBMIT' | 'ELEMENT' | 'ELEMENT_QUERY' | 'HAR' | 'STORE_ACCESS' | 'JOURNEY_AMBIGUOUS' | 'JOURNEY_DIALOG' | 'JOURNEY_EDIT' | 'JOURNEY_EMPTY' | 'STORE_FILE' | 'STORE_FORMAT' | 'JOURNEY_GAP' | 'JOURNEY_INPUT' | 'JOURNEY_INVALID' | 'STORE_LOCKED' | 'JOURNEY_MISSING' | 'STORE_PATH' | 'JOURNEY_PLACEMENT' | 'JOURNEY_READONLY' | 'JOURNEY_RECORDING' | 'JOURNEY_SAVED' | 'JOURNEY_STALE' | 'JOURNEY_TARGET' | 'JSON' | 'NAVIGATION' | 'PROTOCOL' | 'REMOTE' | 'RESULT_LIMIT' | 'SERVER_BUSY' | 'SERVER_CRASH' | 'SERVER_ENVIRONMENT' | 'SERVER_EXHAUSTED' | 'SERVER_HOLDER' | 'SERVER_LAUNCH' | 'SERVER_SWEEP' | 'SERVER_TEARDOWN' | 'SERVER_UNAVAILABLE' | 'SERVER_UNRESOLVED' | 'STEP' | 'TARGET_HELD' | 'TIMEOUT' | 'TOOLSET_BUSY' | 'TOOLSET_CAPTURE' | 'TOOLSET_CONTEXT' | 'TOOLSET_DIALOG' | 'TOOLSET_LIMIT' | 'TOOLSET_OBSERVE' | 'TOOLSET_PAGE' | 'TOOLSET_RECEIPT' | 'TOOLSET_RESERVED' | 'TOOLSET_ROLE' | 'TOOLSET_SCHEME' | 'TOOLSET_SETTLED' | 'TOOLSET_TAB';
+
 /** Represents one intercepted file chooser. */
 export declare interface BrowserFileChooserInterface {
     readonly multiple: boolean;
@@ -1369,44 +1201,6 @@ export declare interface BrowserFollowOptions extends BrowserCallOptions {
     readonly secret?: boolean;
 }
 
-/**
- * Represents one attached document frame, evaluated through its own CDP execution world.
- *
- * @remarks
- * The optional `epoch` constructor parameter reads the frame's navigation counter, which lets
- * `read()` mark a reading stale after a later navigation. The optional `world` parameter
- * resolves a cached isolated-world context, which lets a page share one world across reads.
- * A standalone frame built with neither returns readings whose `stale` stays `false`, because
- * no navigation counter is available to it, and creates a fresh world for each read.
- *
- * @example
- * ```ts
- * import { BrowserFrame } from '@orkestrel/browser'
- *
- * const frame = new BrowserFrame(client, 'session-1', 'frame-1', 'https://example.com')
- * const title = await frame.title()
- * const reading = await frame.read()
- * ```
- */
-export declare class BrowserFrame implements BrowserFrameInterface {
-    #private;
-    constructor(client: CDPClientInterface, session: string | BrowserSessionFunction, id: string, url: string, parent?: string, name?: string, isolated?: boolean, epoch?: BrowserEpochFunction, world?: BrowserWorldFunction);
-    get id(): string;
-    get parent(): string | undefined;
-    get name(): string | undefined;
-    get url(): string;
-    title(options?: BrowserCallOptions): Promise<string>;
-    read(options?: BrowserCallOptions): Promise<BrowserReadingInterface>;
-    evaluate(expression: string, options?: BrowserCallOptions): Promise<unknown>;
-    handle(expression: string, options?: BrowserCallOptions): Promise<BrowserHandleInterface>;
-    send(method: string, params?: Readonly<Record<string, unknown>>, options?: BrowserCallOptions): Promise<unknown>;
-    subscribe(method: string, handler: CDPHandler): Promise<void>;
-    unsubscribe(method: string, handler: CDPHandler): Promise<void>;
-    save(path: string, _bytes: Uint8Array): Promise<void>;
-    assert(): void;
-    update(url: string): void;
-}
-
 /**
  * Describes serializable frame metadata decoded from CDP `Page.getFrameTree`.
  *
@@ -1436,8 +1230,6 @@ export declare interface BrowserFrameInfo {
  * - `evaluate` — execute a JavaScript expression in the page context
  * - `wait` — wait for an element state
  * - `send` — issue a raw CDP method in the frame's current target session, with an optional per-call timeout
- * - `assert` — throw when the frame can no longer accept protocol work
- * - `update` — record an externally observed URL as the frame's current URL
  */
 export declare interface BrowserFrameInterface {
     readonly id: string;
@@ -1449,9 +1241,8 @@ export declare interface BrowserFrameInterface {
     /**
      * Captures the document URL, title, and rendered HTML in one size-guarded evaluation in the frame's
      * isolated world and returns them as a reading whose `stale` flag tracks later navigations.
-     * A frame constructed without an epoch source (a standalone `BrowserFrame` with no `epoch`
-     * argument) returns readings whose `stale` stays `false`, because no navigation counter is
-     * available to it. {@link BrowserReadingInput} defines the rendered markup.
+     * The owning page supplies the navigation counter. {@link BrowserReadingInput} defines
+     * the rendered markup.
      */
     read(options?: BrowserCallOptions): Promise<BrowserReadingInterface>;
     /** Evaluates an expression in the frame execution world under the result-size guard. */
@@ -1470,21 +1261,6 @@ export declare interface BrowserFrameInterface {
     subscribe(method: string, handler: CDPHandler): Promise<void>;
     /** Removes a frame-session CDP event subscription. */
     unsubscribe(method: string, handler: CDPHandler): Promise<void>;
-    /**
-     * Persists bytes through a page writer; a child frame rejects because it owns no writer.
-     */
-    save(path: string, bytes: Uint8Array): Promise<void>;
-    /**
-     * Throws a coded `BrowserError` when the frame can no longer accept protocol work: a frame
-     * throws after the CDP client disconnects, and a page also throws after it closes. Every
-     * other member here calls it first.
-     */
-    assert(): void;
-    /**
-     * Records an externally observed URL as the frame's current `url`, which a page calls from
-     * its own `Page.frameNavigated` handler.
-     */
-    update(url: string): void;
 }
 
 /** Describes function coverage inside one script. */
@@ -1518,7 +1294,7 @@ export declare interface BrowserHandleInterface {
     /** Reads every own property by value. */
     properties(options?: BrowserCallOptions): Promise<Readonly<Record<string, unknown>>>;
     /** Releases the retained remote object. Idempotent. */
-    dispose(): Promise<void>;
+    destroy(): Promise<void>;
 }
 
 /** Describes the standards-shaped HAR 1.2 document produced by the network manager. */
@@ -1581,31 +1357,9 @@ export declare interface BrowserHARLog {
     readonly entries: readonly BrowserHAREntry[];
 }
 
-/**
- * Records and replays HTTP archives over one page network manager.
- *
- * @example
- * ```ts
- * import { BrowserHARManager } from '@orkestrel/browser'
- *
- * const har = new BrowserHARManager(page.network)
- * await har.start({ content: true })
- * const archive = await har.stop() // { log: { version: '1.2', creator, entries } }
- * ```
- */
-export declare class BrowserHARManager implements BrowserHARManagerInterface {
-    #private;
-    constructor(network: BrowserNetworkManagerInterface, writer?: BrowserWriterInterface);
-    get recording(): boolean;
-    start(options?: BrowserHAROptions): Promise<void>;
-    stop(): Promise<BrowserHAR>;
-    replay(har: BrowserHAR, options?: BrowserHARReplayOptions): Promise<void>;
-    clear(): Promise<void>;
-}
-
 /** Provides HAR recording and replay operations. */
 export declare interface BrowserHARManagerInterface {
-    readonly recording: boolean;
+    readonly active: boolean;
     /** Begins recording exchanges, optionally capturing response content. */
     start(options?: BrowserHAROptions): Promise<void>;
     /** Ends recording and returns the archive, writing it when a path was given. */
@@ -1622,13 +1376,6 @@ export declare interface BrowserHAROptions {
     readonly content?: boolean;
 }
 
-/** Holds recording state until a request finishes; a new value replaces it on each update. */
-export declare interface BrowserHARPending {
-    readonly request: BrowserRequest;
-    readonly started: number;
-    readonly response: BrowserResponse | undefined;
-}
-
 /** Describes request body metadata in an HTTP archive. */
 export declare interface BrowserHARPost {
     readonly mimeType: string;
@@ -1731,6 +1478,19 @@ export declare interface BrowserInvocationResult {
     readonly error: string | undefined;
 }
 
+/**
+ * Configures a new isolated browser context.
+ * @remarks
+ * Inherits page defaults, downloads, emulation, references, and listeners from the wrapper options.
+ * - `proxy` — proxy server and bypass list for the new context
+ * - `origins` — origins granted universal network access
+ * The browser assigns the remote context id.
+ */
+export declare interface BrowserIsolateOptions extends Omit<BrowserContextOptions, 'id'> {
+    readonly proxy?: BrowserProxy;
+    readonly origins?: readonly string[];
+}
+
 /**
  * Describes one user intent as data; `next` is the number the next added step takes.
  *
@@ -1738,6 +1498,9 @@ export declare interface BrowserInvocationResult {
  * - `format` — the file format, `BROWSER_JOURNEY_FORMAT_VERSION`
  * - `name` — the journey's name, matching `BROWSER_JOURNEY_NAME_PATTERN`
  * - `description` — what the journey achieves, in one sentence
+ * - `start` — the first recorded step's page URL, redacted before storage; absent for an
+ *   `about:` page such as `about:blank` or `about:srcdoc`. Edits retain it, including removal
+ *   of the first step. Format 1 files without it replay on the current page.
  * - `parameters` — the declared parameters by name
  * - `next` — the number the next added step takes, persisted so a removed id is never reused
  * - `steps` — the steps in order
@@ -1746,6 +1509,7 @@ export declare interface BrowserJourney {
     readonly format: 1;
     readonly name: string;
     readonly description: string;
+    readonly start?: string;
     readonly parameters: Readonly<Record<string, BrowserJourneyParameter>>;
     readonly next: number;
     readonly steps: readonly BrowserJourneyStep[];
@@ -1763,11 +1527,10 @@ export declare type BrowserJourneyBinding = string | {
  * @remarks
  * - `add` — inserts `step` with the next id, before or after the step `before` or `after` names
  * - `remove` — removes the step `id` names
- * - `update` — merges `arguments` into the step `id` names by key, and replaces its `target` or
  *   `tab`
  * - `declare` — declares the parameter `name` names, which a step binds at the end of the batch
  *
- * A refused batch rejects with `BROWSER_JOURNEY_EDIT`, naming the edit's index and the reason.
+ * A refused batch rejects with `JOURNEY_EDIT`, naming the edit's index and the reason.
  */
 export declare type BrowserJourneyEdit = {
     readonly operation: 'add';
@@ -1807,12 +1570,18 @@ export declare type BrowserJourneyEditRequest = BrowserJourneyEdit | {
     readonly arguments?: Readonly<Record<string, BrowserJourneyBinding | JSONValue>>;
 };
 
+/** Names and describes a journey built from recorded steps. */
+export declare interface BrowserJourneyInput {
+    readonly name: string;
+    readonly description: string;
+}
+
 /**
  * Configures the journey toolset a toolset constructs.
  *
  * @remarks
  * - `store` — keeps the journeys the tools record, list, edit, and replay
- * - `runs` — keeps each replay's run and saves standalone images when it provides `snapshot`
+ * - `runs` — keeps each replay's run and saves standalone images when it provides `write`
  * - `limit` — positive integer listing cap in characters; Default: the owner's `limit`, including direct construction
  * - `readonly` — if `true`, refuses `record`, `save`, `edit`, and `forget` before any store access, and
  *   `replay` still writes runs; if `false` or omitted, every tool runs
@@ -1882,23 +1651,24 @@ export declare interface BrowserJourneyStepInput {
 export declare interface BrowserJourneyStoreInterface {
     /**
      * Returns the journey saved under `name` with its revision, or `undefined` when none is saved.
-     * Rejects with `BROWSER_JOURNEY_FILE` for a malformed entry, `BROWSER_JOURNEY_FORMAT` for an
-     * unknown format, and `BROWSER_JOURNEY_ACCESS` for a permission error, each naming the path.
+     * Rejects with `STORE_FILE` for a malformed entry, `STORE_FORMAT` for an
+     * unknown format, and `STORE_ACCESS` for a permission error, each naming the path.
      */
     get(name: string, options?: BrowserStoreOptions): Promise<BrowserJourneyRevision | undefined>;
     /**
      * Saves the journey under its name with the next revision and returns it.
      *
      * @remarks
-     * Rejects with `BROWSER_JOURNEY_STALE` when `expected` differs from the stored revision, and
-     * with `BROWSER_JOURNEY_LOCKED` when another write holds the name. An omitted `expected`
-     * permits replacement; `expected: 0` requires no stored journey, including after deletion,
-     * while the retained revision count still advances on recreation.
+     * Rejects with `JOURNEY_STALE` when `revision` does not match a saved journey or
+     * `exclusive: true` finds an existing journey, and with `STORE_LOCKED` when another
+     * write holds the name. Omitting both conditions permits replacement. Supplying both
+     * conditions, or a revision that is not a positive safe integer, rejects with `ARGUMENT`
+     * before writing. Revisions keep advancing across deletion and recreation.
      */
-    set(journey: BrowserJourney, expected?: number, options?: BrowserStoreOptions): Promise<BrowserJourneyRevision>;
+    set(journey: BrowserJourney, options?: BrowserJourneyWriteOptions): Promise<BrowserJourneyRevision>;
     /**
      * Removes the journey saved under `name` and keeps its revision count, so a recreated journey
-     * continues it; a missing name is a no-op. Rejects with `BROWSER_JOURNEY_LOCKED` when another
+     * continues it; a missing name is a no-op. Rejects with `STORE_LOCKED` when another
      * write holds the name.
      */
     delete(name: string, options?: BrowserStoreOptions): Promise<void>;
@@ -1906,10 +1676,7 @@ export declare interface BrowserJourneyStoreInterface {
      * Returns one page of the saved journeys sorted by name, starting at `offset` and holding at
      * most `limit` entries, with the entries it could not read in `faults`.
      */
-    list(options?: BrowserStoreOptions & {
-        readonly offset?: number;
-        readonly limit?: number;
-    }): Promise<BrowserStorePage<BrowserJourneyRevision>>;
+    list(options?: BrowserStorePageOptions): Promise<BrowserStorePage<BrowserJourneyRevision>>;
 }
 
 /**
@@ -1940,62 +1707,6 @@ export declare interface BrowserJourneyTarget {
     readonly reference?: string;
 }
 
-/**
- * Registers the journey tools `record`, `save`, `journeys`, `edit`, `replay`, `forget`, and `capture` over a toolset
- * and owns the recording and the active replay.
- *
- * @remarks
- * The journey toolset composes the toolset's public members: `perform` reads the view a receipt
- * carries through `look`, `hold` and `emitter` drive the recorder and the replay, `view` converts
- * an edit's `ref` to a target, and `tools` receives the journey tools at construction, which refuses
- * with `BROWSER_TOOLSET_RESERVED` when the manager already holds one of the names. Every refusal
- * is a sentence that names the next call, and a reason inside it is a clause without a directive
- * or a final period.
- *
- * `readonly` refuses `record`, `save`, `edit`, and `forget` before any store access; `replay` still writes
- * its run. The call's signal reaches every store call and every replayed step, and `destroy()`
- * aborts it as well. `save` writes a snapshot before it ends the recording, so a failed or
- * locked write keeps the recorder recording with its steps for the next
- * `save`. An empty snapshot refuses with `BROWSER_JOURNEY_EMPTY` and keeps recording.
- * `edit` accepts an array or its JSON string and names a parse error when the string is invalid.
- * `journeys` joins the listings with one blank line and cuts the result at `limit`
- * characters with a footer that names the next offset. `replay` returns the run's render followed
- * by the view after the run.
- *
- * `destroy()` aborts the active replay and waits for it to finish, stops a recording without
- * saving it, and removes the journey tools the manager still holds under the instances it added.
- *
- * @example
- * ```ts
- * import { BrowserJourneyToolset, createMemoryBrowserJourneyStore } from '@orkestrel/browser'
- *
- * const journeys = new BrowserJourneyToolset(toolset, { store: createMemoryBrowserJourneyStore() })
- * await toolset.tools.execute({ id: '1', name: 'record', arguments: { journey: 'add-kettle' } })
- * await journeys.destroy()
- * ```
- */
-export declare class BrowserJourneyToolset implements BrowserJourneyToolsetInterface {
-    #private;
-    constructor(toolset: BrowserToolsetInterface, options: BrowserJourneyOptions);
-    get recording(): string | undefined;
-    get replaying(): string | undefined;
-    destroy(): Promise<void>;
-}
-
-/**
- * Registers the journey tools over a toolset and owns the recording and the active replay.
- *
- * @remarks
- * - `recording` — the name of the journey being recorded, or `undefined` when none is
- * - `replaying` — the name of the journey being replayed, or `undefined` when none is
- */
-export declare interface BrowserJourneyToolsetInterface {
-    readonly recording: string | undefined;
-    readonly replaying: string | undefined;
-    /** Aborts the active replay and removes the journey tools from the manager. */
-    destroy(): Promise<void>;
-}
-
 /** Identifies the parameter binding that failed journey validation. */
 export declare interface BrowserJourneyValidationContext {
     readonly parameter: string;
@@ -2003,6 +1714,14 @@ export declare interface BrowserJourneyValidationContext {
     readonly field: string;
 }
 
+/** Constrains a journey write atomically at the store. */
+export declare interface BrowserJourneyWriteOptions extends BrowserStoreOptions {
+    /** Requires the saved journey to have this positive revision. */
+    readonly revision?: number;
+    /** If true, requires absence and refuses revision; false is the same as omission. */
+    readonly exclusive?: boolean;
+}
+
 /** Describes normalized CDP keyboard key data. */
 export declare interface BrowserKey {
     readonly key: string;
@@ -2011,28 +1730,6 @@ export declare interface BrowserKey {
     readonly number: number;
 }
 
-/**
- * Sends trusted keyboard input through Chromium's CDP Input domain.
- *
- * @example
- * ```ts
- * import { BrowserKeyboard } from '@orkestrel/browser'
- *
- * const keyboard = new BrowserKeyboard(page)
- * await keyboard.type('orkestrel', { delay: 10 })
- * await keyboard.press('Control+Enter')
- * ```
- */
-export declare class BrowserKeyboard implements BrowserKeyboardInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    down(value: string): Promise<void>;
-    up(value: string): Promise<void>;
-    press(value: string, options?: BrowserInputOptions): Promise<void>;
-    type(value: string, options?: BrowserInputOptions): Promise<void>;
-    insert(value: string): Promise<void>;
-}
-
 /** Provides keyboard input operations bound to one frame target session. */
 export declare interface BrowserKeyboardInterface {
     /**
@@ -2065,8 +1762,16 @@ export declare interface BrowserLayout {
     readonly client: BrowserRect | undefined;
 }
 
-/** Reads the loader id of the page's current document, undefined before the first commit. */
-export declare type BrowserLoaderFunction = () => string | undefined;
+/** Carries the ordered spans of one addressed document line. */
+export declare interface BrowserLine {
+    readonly spans: readonly BrowserLineSpan[];
+}
+
+/** Distinguishes searchable text from generated syntax and actionable references. */
+export declare interface BrowserLineSpan {
+    readonly category: 'text' | 'syntax' | 'reference';
+    readonly text: string;
+}
 
 /** Describes the paper margin lengths accepted by Chromium print-to-PDF. */
 export declare interface BrowserMargin {
@@ -2100,29 +1805,6 @@ export declare interface BrowserMetric {
     readonly value: number;
 }
 
-/**
- * Sends trusted mouse input through Chromium's CDP Input domain.
- *
- * @example
- * ```ts
- * import { BrowserMouse } from '@orkestrel/browser'
- *
- * const mouse = new BrowserMouse(page)
- * await mouse.click({ x: 50, y: 20 }, { button: 'left', count: 2 })
- * await mouse.drag({ x: 10, y: 10 }, { x: 90, y: 90 }, { steps: 20 })
- * ```
- */
-export declare class BrowserMouse implements BrowserMouseInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    move(point: BrowserPoint): Promise<void>;
-    down(button?: BrowserMouseButton, count?: number): Promise<void>;
-    up(button?: BrowserMouseButton, count?: number): Promise<void>;
-    click(point: BrowserPoint, options?: BrowserClickOptions): Promise<void>;
-    drag(start: BrowserPoint, end: BrowserPoint, options?: BrowserDragOptions): Promise<void>;
-    wheel(delta: BrowserPoint): Promise<void>;
-}
-
 /** Names a mouse button understood by Chromium's Input domain. */
 export declare type BrowserMouseButton = 'left' | 'middle' | 'right' | 'back' | 'forward';
 
@@ -2145,6 +1827,9 @@ export declare interface BrowserMouseInterface {
     wheel(delta: BrowserPoint): Promise<void>;
 }
 
+/** Names the page load condition for navigation — the CDP load event awaited by `navigate()`. */
+export declare type BrowserNavigationCondition = 'commit' | 'load' | 'domcontentloaded' | 'idle';
+
 /**
  * Maps the navigation steps a page accepts from the session that owns each frame, which it hands to
  * its navigation and element managers.
@@ -2171,34 +1856,6 @@ export declare type BrowserNavigationEventMap = {
     readonly detach: readonly [frame: string, swapped: boolean];
 };
 
-/**
- * Parks URL-pattern and network-idle waits on page events and abort signals, and opens the records
- * that settle the navigation an input starts.
- *
- * @remarks
- * `steps` carries the navigation steps the page accepts from the session that owns each frame,
- * and `parent` returns the parent the page last recorded for a frame, or `undefined` when the
- * page cannot name it. A record opened here rejects its pending waits with the page-closed error
- * when the page closes.
- *
- * @example
- * ```ts
- * import { BrowserNavigationManager } from '@orkestrel/browser'
- *
- * const navigation = new BrowserNavigationManager(page, client, 'session-1', () => loader, steps, parent)
- * const url = await navigation.wait('https://example.com/checkout', { timeout: 5_000 })
- * await navigation.idle({ signal: AbortSignal.timeout(10_000) })
- * const record = navigation.record(page.id)
- * ```
- */
-export declare class BrowserNavigationManager implements BrowserNavigationManagerInterface {
-    #private;
-    constructor(page: BrowserPageInterface, client: CDPClientInterface, session: string, loader: BrowserLoaderFunction, steps: EmitterInterface<BrowserNavigationEventMap>, parent: (frame: string) => string | undefined);
-    wait(pattern: string, options?: BrowserCallOptions): Promise<string>;
-    idle(options?: BrowserCallOptions): Promise<void>;
-    record(frame: string): BrowserNavigationRecordInterface;
-}
-
 /** Provides URL and network-idle waits associated with one page. */
 export declare interface BrowserNavigationManagerInterface {
     /**
@@ -2228,7 +1885,7 @@ export declare interface BrowserNavigationManagerInterface {
  * - `signal` — aborts the `Page.navigate` send
  */
 export declare interface BrowserNavigationOptions extends BrowserCallOptions {
-    readonly condition?: BrowserWaitUntil;
+    readonly condition?: BrowserNavigationCondition;
 }
 
 /**
@@ -2252,7 +1909,7 @@ export declare interface BrowserNavigationRecordInterface {
     /**
      * Resolves when the record's frame or one of its ancestors starts a navigation after the record
      * opened; `settle` reports that navigation's reason. Rejects at `timeout` with
-     * `BROWSER_NAVIGATION_TIMEOUT`, with `signal.reason` on abort, and when the record ends or the
+     * `TIMEOUT`, with `signal.reason` on abort, and when the record ends or the
      * page closes.
      */
     wait(options?: BrowserCallOptions): Promise<void>;
@@ -2279,27 +1936,6 @@ export declare interface BrowserNavigationResult {
 /** Names how far a settled navigation got: requested, committed, or loaded. */
 export declare type BrowserNavigationStage = 'requested' | 'committed' | 'loaded';
 
-/**
- * Represents one pending navigation or network-idle wait.
- *
- * @remarks
- * - `pattern` — the URL glob, undefined for a network-idle wait
- * - `listener` — the abort listener registered on `signal`, undefined without a signal
- */
-export declare interface BrowserNavigationWait {
-    readonly pattern: string | undefined;
-    readonly timer: ReturnType<typeof setTimeout>;
-    readonly signal: AbortSignal | undefined;
-    readonly listener: (() => void) | undefined;
-    readonly resolve: (url: string) => void;
-    readonly reject: (error: unknown) => void;
-}
-
-/** Holds the state retained while correlating navigation with Network events. */
-export declare interface BrowserNavigationWatch {
-    readonly responses: readonly BrowserResponse[];
-}
-
 /** Maps the network events a page's network manager emits. */
 export declare type BrowserNetworkEventMap = {
     readonly request: readonly [request: BrowserRequest];
@@ -2309,38 +1945,13 @@ export declare type BrowserNetworkEventMap = {
     readonly socket: readonly [socket: BrowserWebSocketInterface];
 };
 
-/**
- * Drives the page-scoped Network and Fetch domain lifecycle.
- *
- * @example
- * ```ts
- * import { BrowserNetworkManager } from '@orkestrel/browser'
- *
- * const network = new BrowserNetworkManager(page)
- * await network.start()
- * network.emitter.on('response', (response) => log(response.status))
- * await network.destroy()
- * ```
- */
-export declare class BrowserNetworkManager implements BrowserNetworkManagerInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface, writer?: BrowserWriterInterface);
-    get emitter(): EmitterInterface<BrowserNetworkEventMap>;
-    get har(): BrowserHARManagerInterface;
-    start(): Promise<void>;
-    body(id: string): Promise<Uint8Array>;
-    text(id: string): Promise<string>;
-    json(id: string): Promise<unknown>;
-    route(query: BrowserRouteQuery, handler: BrowserRouteHandler): Promise<void>;
-    unroute(handler?: BrowserRouteHandler): Promise<void>;
-    headers(headers: Readonly<Record<string, string>>): Promise<void>;
-    offline(offline: boolean): Promise<void>;
-    credentials(credentials?: BrowserCredentials): Promise<void>;
-    destroy(): Promise<void>;
-}
-
 /** Provides page-scoped network observation and interception. */
 export declare interface BrowserNetworkManagerInterface {
+    /** Clears headers, offline mode, and credentials without removing routes. */
+    clear(): Promise<void>;
+    readonly routes: BrowserRouteManagerInterface;
+    /** Applies the supplied network overrides; omitted keys retain their values. */
+    apply(options: BrowserNetworkOptions): Promise<void>;
     readonly emitter: EmitterInterface<BrowserNetworkEventMap>;
     readonly har: BrowserHARManagerInterface;
     /** Enables the Network domain and subscribes to its events. Idempotent. */
@@ -2351,20 +1962,18 @@ export declare interface BrowserNetworkManagerInterface {
     text(id: string): Promise<string>;
     /** Reads one observed response body as parsed JSON. */
     json(id: string): Promise<unknown>;
-    /** Intercepts requests matching the query and hands each one to the handler. */
-    route(query: BrowserRouteQuery, handler: BrowserRouteHandler): Promise<void>;
-    /** Removes one handler's routes, or every route when given none. */
-    unroute(handler?: BrowserRouteHandler): Promise<void>;
-    /** Applies extra HTTP headers to every request the page makes. */
-    headers(headers: Readonly<Record<string, string>>): Promise<void>;
-    /** Emulates an offline connection, or restores connectivity. */
-    offline(offline: boolean): Promise<void>;
-    /** Applies HTTP basic-auth credentials, or clears them when given none. */
-    credentials(credentials?: BrowserCredentials): Promise<void>;
     /** Removes every route, unsubscribes, and disables the domains this manager enabled. */
     destroy(): Promise<void>;
 }
 
+/** Configures the supplied network overrides without changing omitted keys. */
+export declare interface BrowserNetworkOptions {
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    readonly offline?: boolean | undefined;
+    /** Supplies credentials; undefined and omission retain the current credentials. */
+    readonly credentials?: BrowserCredentials | undefined;
+}
+
 /**
  * Represents one serializable DOM node decoded from a CDP DOM snapshot.
  *
@@ -2424,23 +2033,15 @@ export declare interface BrowserNodeQuery {
  */
 export declare type BrowserOperationOptions = BrowserClickOptions & BrowserDragOptions;
 
-/**
- * Carries a document-order outline and its included and available element counts.
- *
- * @remarks
- * - `matches` — the rendered rows that best match the options' `search`, in document order and
- *   past `limit` included; empty without a `search` or without a match
- * - `focus` — the rendered row of the referenced element that has focus, past `limit` included;
- *   the last such row in document order when several do, and `undefined` when focus is on no
- *   referenced element
- */
+/** Carries document-order lines, element counts, and the focused element's row. */
 export declare interface BrowserOutline {
     readonly url: string;
     readonly title: string;
-    readonly text: string;
-    readonly count: number;
-    readonly total: number;
-    readonly matches: readonly string[];
+    readonly lines: readonly BrowserLine[];
+    /** Referenced rows carried in this outline. */
+    readonly listed: number;
+    /** Referenced nodes in the complete outline tree. */
+    readonly found: number;
     readonly focus: string | undefined;
 }
 
@@ -2451,118 +2052,11 @@ export declare interface BrowserOutlineNode extends BrowserAXNode {
     readonly tool?: string;
 }
 
-/**
- * Configures an outline's element limit, optional subtree, and search.
- *
- * @remarks
- * - `search` — the words that select the outline's `matches`: the text is lowercased and split
- *   into whole words of at least 3 letters or digits (`BROWSER_SEARCH_PATTERN`), each referenced
- *   row's role and accessible name are split the same way, and a row scores the number of distinct
- *   search words equal to one of its words; every referenced row with the highest score above 0
- *   matches
- */
+/** Configures an outline's element limit and optional subtree. */
 export declare interface BrowserOutlineOptions extends BrowserCallOptions {
     readonly limit?: number;
     readonly within?: string;
-    readonly search?: string;
-}
-
-/**
- * Represents a top-level browser page, including its target lifecycle and child frames.
- *
- * @remarks
- * Only a page constructed with a `reference` function, as `BrowserContext` constructs every page,
- * takes part in target ownership and discovery. Such a page holds its target on the client's
- * current connection until it closes, its connection ends, or the `ready` promise its constructing
- * path passes rejects: constructing a second such page for a target a live page holds throws
- * `BROWSER_TARGET_HELD`, and the first such page on a connection enables
- * `Target.setDiscoverTargets` for it. A page constructed without `ready`, with or without an
- * `opener`, is complete as constructed; `ready` is the constructing path's completion, and a
- * popup a page constructs is complete when that page emits it.
- *
- * A page publishes each page it opens through `popup` once, never a closed one, and only after it
- * is complete itself. An unattached page target that discovery reports with this page as
- * `openerId`, live or before this page existed, is attached on the browser session, so the popup
- * outlives its opener; an attachment on this page's session is taken as it arrives; a target
- * another page holds is published as that page after its `ready` resolves, while it still holds
- * the target; and the second session for one target is detached. A page detaches its own session
- * through the session it was attached through.
- *
- * @example
- * ```ts
- * import { BrowserPage } from '@orkestrel/browser'
- *
- * const page = new BrowserPage(client, 'target-1', 'session-1')
- * await page.navigate('https://example.com')
- * const shot = await page.screenshot({ format: 'png' })
- * await page.close()
- * ```
- */
-export declare class BrowserPage extends BrowserFrame implements BrowserPageInterface {
-    #private;
-    constructor(client: CDPClientInterface, targetId: string, sessionId: string, writer?: BrowserWriterInterface, url?: string, frameId?: string, contextId?: string, opener?: BrowserPageInterface, options?: BrowserPageOptions, reference?: BrowserReferenceFunction, ready?: Promise<void>);
-    get emitter(): EmitterInterface<BrowserPageEventMap>;
-    get elements(): BrowserElementManagerInterface<BrowserPageElementInterface>;
-    get trusted(): true;
-    get keyboard(): BrowserKeyboardInterface;
-    get mouse(): BrowserMouseInterface;
-    get touch(): BrowserTouchInterface;
-    read(options?: BrowserCallOptions): Promise<BrowserReadingInterface>;
-    wait(text: string, options?: BrowserWaitOptions): Promise<void>;
-    get network(): BrowserNetworkManagerInterface;
-    get registry(): BrowserRegistryInterface;
-    get navigation(): BrowserNavigationManagerInterface;
-    get popups(): BrowserPopupManagerInterface;
-    get scripts(): BrowserScriptManagerInterface;
-    get accessibility(): BrowserAccessibilityInterface;
-    get diagnostics(): BrowserDiagnosticsInterface;
-    get clock(): BrowserClockInterface;
-    get opener(): BrowserPageInterface | undefined;
-    get target(): string;
-    get closed(): boolean;
-    navigate(url: string, options?: BrowserNavigationOptions): Promise<BrowserNavigationResult>;
-    reload(options?: BrowserNavigationOptions): Promise<BrowserNavigationResult>;
-    back(options?: BrowserNavigationOptions): Promise<BrowserNavigationResult>;
-    forward(options?: BrowserNavigationOptions): Promise<BrowserNavigationResult>;
-    screenshot(options?: BrowserScreenshotOptions): Promise<BrowserScreenshotResult>;
-    pdf(options?: BrowserPDFOptions): Promise<BrowserPDFResult>;
-    save(path: string, bytes: Uint8Array): Promise<void>;
-    frame(name: string): Promise<BrowserFrameInterface | undefined>;
-    frames(): Promise<readonly BrowserFrameInterface[]>;
-    snapshot(options?: BrowserSnapshotOptions): Promise<BrowserSnapshotInterface>;
-    codegen(options?: BrowserRecorderOptions): Promise<BrowserCodegenInterface>;
-    destroy(): Promise<void>;
-    close(): Promise<void>;
-    assert(): void;
-}
-
-/**
- * Drives a referenced DOM element through its document's isolated world and the page input stream.
- * @example
- * ```ts
- * const element = page.elements.element('e1')
- * await element?.click()
- * ```
- */
-export declare class BrowserPageElement implements BrowserPageElementInterface {
-    #private;
-    constructor(input: BrowserElementInput);
-    get reference(): string;
-    get frame(): string;
-    get role(): string;
-    get name(): string;
-    click(options?: BrowserCallOptions): Promise<void>;
-    fill(value: string, options?: BrowserCallOptions): Promise<void>;
-    select(values: readonly string[], options?: BrowserCallOptions): Promise<void>;
-    focus(options?: BrowserCallOptions): Promise<void>;
-    read(options?: BrowserCallOptions): Promise<BrowserReadingInterface>;
-    hover(options?: BrowserCallOptions): Promise<void>;
-    press(value: string, options?: BrowserCallOptions): Promise<void>;
-    submit(options?: BrowserCallOptions): Promise<void>;
-    upload(files: readonly string[], options?: BrowserCallOptions): Promise<void>;
-    drag(target: BrowserPageElementInterface, options?: BrowserCallOptions): Promise<void>;
-    quad(options?: BrowserCallOptions): Promise<BrowserQuad>;
-    screenshot(options?: BrowserScreenshotOptions): Promise<BrowserScreenshotResult>;
+    readonly secrets?: readonly string[];
 }
 
 /** Provides trusted page input and capture for a referenced element. */
@@ -2619,7 +2113,7 @@ export declare type BrowserPageEventMap = {
 
 /**
  * Abstracts a single top-level browser page, extending `BrowserFrameInterface` with
- * navigation, screenshots, frame discovery, DOM snapshots, codegen, and target teardown.
+ * navigation, screenshots, frame discovery, DOM snapshots, a journey recorder, and target teardown.
  *
  * @remarks
  * Inherits every {@link BrowserFrameInterface} document operation for the
@@ -2632,7 +2126,7 @@ export declare type BrowserPageEventMap = {
  * - `frame` — look up a frame by name or URL in the page's flattened frame tree
  * - `frames` — list the page's flattened frame tree, main frame first
  * - `snapshot` — capture every attached document as serializable DOM data
- * - `codegen` — start (or return the existing) action recorder for this page
+ * - `recorder` — the stable page recorder; call `start()` to begin recording
  * - `destroy` — release local resources and detach from the target
  * - `close` — close the remote target and release local resources
  */
@@ -2687,8 +2181,8 @@ export declare interface BrowserPageInterface extends BrowserFrameInterface, Bro
      * and requested computed style.
      */
     snapshot(options?: BrowserSnapshotOptions): Promise<BrowserSnapshotInterface>;
-    /** Starts the action recorder, or returns the running one. */
-    codegen(options?: BrowserRecorderOptions): Promise<BrowserCodegenInterface>;
+    /** Returns the page recorder; call start() to begin capturing gestures. */
+    readonly recorder: BrowserRecorderInterface;
     /** Releases local resources and detaches without closing the remote target. */
     destroy(): Promise<void>;
     /** Closes the remote target and releases its resources. */
@@ -2696,7 +2190,7 @@ export declare interface BrowserPageInterface extends BrowserFrameInterface, Bro
 }
 
 /**
- * Describes the options for creating a `BrowserPage` instance.
+ * Describes the options for creating a page through its context.
  *
  * @remarks
  * - `on` — initial event listeners wired at construction
@@ -2713,9 +2207,24 @@ export declare interface BrowserPageOptions {
     readonly timeout?: number;
 }
 
-/** Returns the context's live pages at call time. */
+/** Returns the context's live pages at call time.
+ * @remarks Shared by BrowserEmulationManager and BrowserStorageManager.
+ */
 export declare type BrowserPagesFunction = () => readonly BrowserPageInterface[];
 
+/** Describes the projection and context of one bounded reading window. */
+export declare interface BrowserPassage {
+    readonly url: string;
+    readonly title: string;
+    readonly lines: readonly BrowserLine[];
+    readonly from: number;
+    readonly to?: number;
+    readonly search?: string;
+    readonly tabs: readonly BrowserTab[];
+    readonly changed: boolean;
+    readonly note?: string;
+}
+
 /** Describes the options for printing a Chromium page to PDF. */
 export declare interface BrowserPDFOptions {
     readonly path?: string;
@@ -2746,23 +2255,6 @@ export declare interface BrowserPDFResult {
  */
 export declare function browserPDFToParams(options?: BrowserPDFOptions): Readonly<Record<string, unknown>>;
 
-/**
- * Reads Performance-domain metrics for one frame.
- *
- * @example
- * ```ts
- * import { BrowserPerformance } from '@orkestrel/browser'
- *
- * const performance = new BrowserPerformance(page)
- * const metrics = await performance.metrics() // readonly BrowserMetric[]
- * ```
- */
-export declare class BrowserPerformance implements BrowserPerformanceInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    metrics(): Promise<readonly BrowserMetric[]>;
-}
-
 /**
  * Reads Performance-domain metrics.
  *
@@ -2776,33 +2268,13 @@ export declare interface BrowserPerformanceInterface {
     metrics(): Promise<readonly BrowserMetric[]>;
 }
 
-/**
- * Applies permission overrides isolated to one browser context.
- *
- * @example
- * ```ts
- * import { BrowserPermissionManager } from '@orkestrel/browser'
- *
- * const permissions = new BrowserPermissionManager(client)
- * await permissions.grant(['geolocation'], 'https://example.com')
- * await permissions.clear()
- * ```
- */
-export declare class BrowserPermissionManager implements BrowserPermissionManagerInterface {
-    #private;
-    constructor(client: CDPClientInterface, context?: string);
-    grant(permissions: readonly string[], origin?: string): Promise<void>;
-    deny(permissions: readonly string[], origin?: string): Promise<void>;
-    clear(): Promise<void>;
-}
-
 /** Provides permission override operations scoped to one browser context. */
 export declare interface BrowserPermissionManagerInterface {
     /** Grants each named permission, optionally for one origin, as its own CDP frame. */
     grant(permissions: readonly string[], origin?: string): Promise<void>;
     /** Denies each named permission, optionally for one origin, as its own CDP frame. */
     deny(permissions: readonly string[], origin?: string): Promise<void>;
-    /** Resets every permission override on the context. */
+    /** Removes every permission override on the context. */
     clear(): Promise<void>;
 }
 
@@ -2874,27 +2346,6 @@ export declare interface BrowserProfileNode {
     readonly children: readonly number[];
 }
 
-/**
- * Records sampled JavaScript CPU profiles over one frame's Profiler domain.
- *
- * @example
- * ```ts
- * import { BrowserProfiler } from '@orkestrel/browser'
- *
- * const profiler = new BrowserProfiler(page)
- * await profiler.start(100)
- * const profile = await profiler.stop() // { start, end, nodes, samples, deltas }
- * ```
- */
-export declare class BrowserProfiler implements BrowserProfilerInterface {
-    #private;
-    constructor(frame: BrowserFrameInterface);
-    get active(): boolean;
-    start(interval?: number): Promise<void>;
-    stop(): Promise<BrowserProfile>;
-    destroy(): Promise<void>;
-}
-
 /** Drives the sampled CPU profile lifecycle. */
 export declare interface BrowserProfilerInterface {
     readonly active: boolean;
@@ -2923,18 +2374,11 @@ export declare interface BrowserQuad {
     readonly center: BrowserPoint;
 }
 
-/** Waits for the current document's DOM readiness. */
+/** Waits for the current document's DOM readiness.
+ * @remarks Shared by BrowserElementManager and BrowserPageElement.
+ */
 export declare type BrowserReadinessFunction = (options?: BrowserCallOptions) => Promise<void>;
 
-/** Holds the resources of one lifecycle-event readiness wait. */
-export declare interface BrowserReadinessWait {
-    readonly resolve: () => void;
-    readonly reject: (error: unknown) => void;
-    readonly timer: ReturnType<typeof setTimeout>;
-    readonly signal: AbortSignal | undefined;
-    readonly listener: (() => void) | undefined;
-}
-
 /**
  * Represents one captured document, parsed one time and projected to Markdown or plain text in
  * bounded slices.
@@ -3048,17 +2492,6 @@ export declare interface BrowserReadingInterface {
     text(options?: BrowserReadOptions): BrowserReadResult;
 }
 
-/**
- * Describes a matching line and its character offset in a reading's projection.
- *
- * @remarks
- * Offsets count UTF-16 code units in the original text, including preceding line breaks.
- */
-export declare interface BrowserReadMatch {
-    readonly offset: number;
-    readonly text: string;
-}
-
 /**
  * Describes the options for one slice of a reading's Markdown or plain-text projection.
  *
@@ -3097,7 +2530,7 @@ export declare interface BrowserReadResult {
  * Describes one tool receipt before rendering.
  *
  * @remarks
- * - `action` — what the tool did, without a closing period, such as `Clicked e4 button "Save"`;
+ * - `action` — what the tool did, without a closing period, such as `Clicked button "Save" [ref=e4]`;
  *   empty when the tool did nothing the receipt names
  * - `status` — a clause joined to the action with a semicolon, such as
  *   `the page is still loading URL`
@@ -3124,21 +2557,18 @@ export declare interface BrowserReceipt {
  * @example
  * const recorder = new BrowserRecorder(toolset)
  * await recorder.start()
- * await toolset.perform(call)
+ * await toolset.execute(call)
  * const steps = await recorder.stop()
  */
 export declare class BrowserRecorder implements BrowserRecorderInterface {
     #private;
     constructor(toolset: BrowserToolsetInterface, options?: BrowserRecorderOptions);
     get emitter(): EmitterInterface<BrowserRecorderEventMap>;
-    get started(): boolean;
+    get active(): boolean;
     start(): Promise<void>;
     stop(): Promise<readonly BrowserJourneyStep[]>;
     steps(): readonly BrowserJourneyStep[];
-    journey(options: {
-        readonly name: string;
-        readonly description: string;
-    }): BrowserJourney;
+    journey(options: BrowserJourneyInput): BrowserJourney;
     clear(): void;
     destroy(): Promise<void>;
 }
@@ -3164,11 +2594,11 @@ export declare type BrowserRecorderEventMap = {
  *
  * @remarks
  * - `emitter` — emits `start`, `step`, `stop`, and `clear`
- * - `started` — true while recording; false otherwise
+ * - `active` — true while recording; false otherwise
  */
 export declare interface BrowserRecorderInterface {
     readonly emitter: EmitterInterface<BrowserRecorderEventMap>;
-    readonly started: boolean;
+    readonly active: boolean;
     /** Begins recording from the recorder's source. */
     start(): Promise<void>;
     /** Stops recording and returns the recorded steps. */
@@ -3185,10 +2615,7 @@ export declare interface BrowserRecorderInterface {
      * The toolset recorder includes an unanswered interrupted action as a gap in this snapshot
      * without stopping the recording or consuming that action's pending dialog continuation.
      */
-    journey(options: {
-        readonly name: string;
-        readonly description: string;
-    }): BrowserJourney;
+    journey(input: BrowserJourneyInput): BrowserJourney;
     /** Drops the recorded steps. */
     clear(): void;
     /** Stops recording and releases the recorder's listeners. */
@@ -3210,7 +2637,12 @@ export declare interface BrowserRecorderOptions {
 /** Represents a rectangle in CSS pixels: x, y, width, height. */
 export declare type BrowserRect = readonly [x: number, y: number, width: number, height: number];
 
-/** Allocates the next reference from the owning browser context. */
+/** Allocates the next reference from the owning browser context.
+ * @remarks
+ * Within a tab, a link retains its previous document's reference when its role, accessible name,
+ * and resolved href match exactly one link in each document. Other elements receive fresh
+ * references after navigation; buttons never carry. Allocation never reuses a number.
+ */
 export declare type BrowserReferenceFunction = () => string;
 
 /** Maps registry changes and observed WebMCP invocation events. */
@@ -3243,17 +2675,6 @@ export declare interface BrowserRegistryOptions {
     readonly error?: EmitterErrorHandler;
 }
 
-/** Holds one unsettled registry execution and its resource cleanup. */
-export declare interface BrowserRegistryPending {
-    readonly frame: string;
-    readonly session: string;
-    readonly signal: AbortSignal | undefined;
-    readonly controller: AbortController;
-    readonly timer: ReturnType<typeof setTimeout>;
-    readonly resolve: (result: BrowserInvocationResult) => void;
-    readonly reject: (error: unknown) => void;
-}
-
 /**
  * Prepares and replays a journey under a toolset hold, retaining its executed prefix.
  * @example
@@ -3289,6 +2710,12 @@ export declare interface BrowserReplayInterface {
      * Prepares the journey, holds the toolset, performs each step in order, and resolves with the
      * run, which stops at the first step that did not complete. Rejects with a coded `BrowserError`
      * at preparation, before any side effect, and on a destroyed toolset.
+     *
+     * @remarks
+     * When the journey carries `start`, navigates the current tab there before resolving s1,
+     * using the toolset's schemes and navigation settlement. A refused or unsettled start
+     * stops the run before s1 and retains the navigation failure in `fault`. Without `start`,
+     * resolves steps against the current page.
      */
     execute(options?: BrowserCallOptions): Promise<BrowserRun>;
 }
@@ -3352,15 +2779,6 @@ export declare interface BrowserResponse {
     readonly security: BrowserSecurity | undefined;
 }
 
-/**
- * Reports that an `evaluate()`/`read()` result exceeded {@link BROWSER_RESULT_LIMIT} and
- * was rejected in-page before it could overflow the CDP transport frame, under the code
- * `BROWSER_RESULT_LIMIT_ERROR`.
- */
-export declare class BrowserResultLimitError extends BrowserError {
-    constructor(message: string, context?: Readonly<Record<string, unknown>>);
-}
-
 /** Describes the overrides supplied when continuing an intercepted request. */
 export declare interface BrowserRouteContinueOptions {
     readonly url?: string;
@@ -3403,6 +2821,16 @@ export declare interface BrowserRouteInterface {
     fulfill(options: BrowserRouteFulfillOptions): Promise<void>;
 }
 
+/** Manages the request handlers installed on a page network. */
+export declare interface BrowserRouteManagerInterface {
+    /** Intercepts matching requests with this handler. */
+    add(query: BrowserRouteQuery, handler: BrowserRouteHandler): Promise<void>;
+    /** Removes every route belonging to this handler. */
+    remove(handler: BrowserRouteHandler): Promise<void>;
+    /** Removes every route. */
+    clear(): Promise<void>;
+}
+
 /** Describes route matching criteria. Omitted fields match all values. */
 export declare interface BrowserRouteQuery {
     readonly url?: string;
@@ -3412,7 +2840,7 @@ export declare interface BrowserRouteQuery {
 
 /**
  * Describes one run of a journey; `inputs` omits secret values; `fault` carries the run file's
- * write failure.
+ * write failure or the failure that stopped it before a step ran.
  *
  * @remarks
  * - `format` — the file format, `BROWSER_JOURNEY_FORMAT_VERSION`
@@ -3424,7 +2852,7 @@ export declare interface BrowserRouteQuery {
  * - `output` — the `console` and `error` events of a trusted view that declares `emitter`,
  *   during the run; absent for an untrusted view and for a journey with a secret parameter
  * - `elapsed` — the milliseconds the run took
- * - `fault` — why writing the run file failed
+ * - `fault` — why writing the run file failed or why it stopped before a step ran
  */
 export declare interface BrowserRun {
     readonly format: 1;
@@ -3450,7 +2878,7 @@ export declare interface BrowserRun {
 export declare type BrowserRunOutcome = 'complete' | 'stopped' | 'aborted';
 
 /**
- * Names the run directory a store opened, as data.
+ * Names the run directory a store created, as data.
  *
  * @remarks
  * - `id` — the run id
@@ -3501,29 +2929,29 @@ export declare interface BrowserRunStoreInterface {
      * @returns Absolute path of the saved image
      * @remarks Stores without standalone file storage omit this capability.
      */
-    snapshot?(bytes: Uint8Array, options?: BrowserStoreOptions): Promise<string>;
+    write?(bytes: Uint8Array, options?: BrowserStoreOptions): Promise<string>;
     /** Mints a run id for the journey and creates its run directory exclusively. */
-    open(name: string, options?: BrowserStoreOptions): Promise<BrowserRunSlot>;
+    create(name: string, options?: BrowserStoreOptions): Promise<BrowserRunSlot>;
     /** Returns the run stored under the journey name and id, or `undefined` when none is stored. */
     get(name: string, id: string, options?: BrowserStoreOptions): Promise<BrowserRun | undefined>;
     /** Writes the run under the journey name and the run id it carries. */
     set(run: BrowserRun, options?: BrowserStoreOptions): Promise<void>;
     /**
-     * Writes capture bytes under the name into the run directory `open` created for the slot.
-     * @param slot - Slot opened by this store
+     * Writes capture bytes under the name into the run directory `create` created for the slot.
+     * @param slot - Slot created by this store
      * @param name - Capture file name
      * @param bytes - Screenshot bytes to persist
      * @param options - Cancellation options
      * @returns Name the step records, or `undefined` for a store without directories
-     * @throws {@link BrowserError} Thrown with `BROWSER_JOURNEY_PATH` when this store did not open the slot.
+     * @throws {@link BrowserError} Thrown with `STORE_PATH` when this store did not create the slot.
          */
      capture(slot: BrowserRunSlot, name: string, bytes: Uint8Array, options?: BrowserStoreOptions): Promise<string | undefined>;
      /** Removes the run stored under the journey name and id; a missing run is a no-op. */
      delete(name: string, id: string, options?: BrowserStoreOptions): Promise<void>;
      /**
-      * Removes every run and opened slot of a journey and returns their count, including unsaved
+      * Removes every run and created slot of a journey and returns their count, including unsaved
       * slots; a missing name returns zero. File stores exclude concurrent allocation with the
-      * journey lock and refuse a held lock with `BROWSER_JOURNEY_LOCKED`.
+      * journey lock and refuse a held lock with `STORE_LOCKED`.
       * @param name - Journey name
       * @param options - Cancellation options
       * @returns Number of removed runs, including unsaved slots
@@ -3533,10 +2961,7 @@ export declare interface BrowserRunStoreInterface {
       * Returns one page of the journey's runs, starting at `offset` and holding at most `limit`
       * entries, with the entries it could not read in `faults`.
       */
-     list(name: string, options?: BrowserStoreOptions & {
-         readonly offset?: number;
-         readonly limit?: number;
-     }): Promise<BrowserStorePage<BrowserRun>>;
+     list(name: string, options?: BrowserStorePageOptions): Promise<BrowserStorePage<BrowserRun>>;
     }
 
     /** Names a cookie same-site policy understood by Chromium. */
@@ -3596,34 +3021,6 @@ export declare interface BrowserRunStoreInterface {
         readonly functions: readonly BrowserFunctionCoverage[];
     }
 
-    /** Represents one installed new-document script and its optional host binding owner. */
-    export declare interface BrowserScriptEntry {
-        readonly source: string;
-        readonly binding: string | undefined;
-    }
-
-    /**
-     * Installs new-document scripts and promise-based host functions for one page.
-     *
-     * @example
-     * ```ts
-     * import { BrowserScriptManager } from '@orkestrel/browser'
-     *
-     * const scripts = new BrowserScriptManager(page)
-     * const id = await scripts.add('window.__ready = true')
-     * await scripts.remove(id)
-     * ```
-     */
-    export declare class BrowserScriptManager implements BrowserScriptManagerInterface {
-        #private;
-        constructor(frame: BrowserFrameInterface);
-        add(source: string): Promise<string>;
-        remove(id: string): Promise<void>;
-        expose(name: string, handler: BrowserBindingHandler): Promise<void>;
-        revoke(name: string): Promise<void>;
-        destroy(): Promise<void>;
-    }
-
     /** Manages initialization scripts and host bindings for one page. */
     export declare interface BrowserScriptManagerInterface {
         /** Installs a script evaluated on every new document, and returns its identifier. */
@@ -3638,6 +3035,12 @@ export declare interface BrowserRunStoreInterface {
         destroy(): Promise<void>;
     }
 
+    /** Carries the opening line and optional search text of an addressed window. */
+    export declare interface BrowserSearch {
+        readonly from: number;
+        readonly text?: string;
+    }
+
     /** Describes the TLS details supplied with a browser response. */
     export declare interface BrowserSecurity {
         readonly protocol: string;
@@ -3646,7 +3049,9 @@ export declare interface BrowserRunStoreInterface {
         readonly to: number;
     }
 
-    /** Resolves the current CDP session for a frame id. */
+    /** Resolves the current CDP session for a frame id.
+     * @remarks Shared by BrowserFrame, BrowserElementManager, and BrowserPageElement.
+     */
     export declare type BrowserSessionFunction = (frame: string) => Promise<string>;
 
     /**
@@ -3696,7 +3101,6 @@ export declare interface BrowserRunStoreInterface {
         readonly documents: readonly BrowserDocument[];
         readonly styles: readonly string[];
         constructor(input: BrowserSnapshotInput);
-        walk(options?: BrowserWalkOptions): Generator<BrowserNode, void, unknown>;
         descendants(node: BrowserNode): Generator<BrowserNode, void, unknown>;
         document(node: BrowserNode): BrowserDocument | undefined;
         children(node: BrowserNode): readonly BrowserNode[];
@@ -3709,6 +3113,8 @@ export declare interface BrowserRunStoreInterface {
         filter(query: BrowserNodeQuery | BrowserNodePredicate, limit?: number): readonly BrowserNode[];
         closest(node: BrowserNode, query: BrowserNodeQuery | BrowserNodePredicate): BrowserNode | undefined;
         path(node: BrowserNode): string;
+        depth(options?: BrowserTraversalOptions): Generator<BrowserNode, void, unknown>;
+        breadth(options?: BrowserTraversalOptions): Generator<BrowserNode, void, unknown>;
     }
 
     /**
@@ -3728,9 +3134,11 @@ export declare interface BrowserRunStoreInterface {
     export declare interface BrowserSnapshotInterface extends BrowserSnapshotInput {
         /**
          * Traverses the whole capture, or one subtree when `root` is given and yielded first, in
-         * `'depth'` order by default or in `'breadth'` order. Visits each node exactly once.
+         * depth-first order. Visits each node exactly once.
          */
-        walk(options?: BrowserWalkOptions): Generator<BrowserNode, void, unknown>;
+        depth(options?: BrowserTraversalOptions): Generator<BrowserNode, void, unknown>;
+        /** Traverses the capture or a subtree breadth-first, yielding its root first. */
+        breadth(options?: BrowserTraversalOptions): Generator<BrowserNode, void, unknown>;
         /** Traverses one node's subtree in depth-first order, excluding the node itself. */
         descendants(node: BrowserNode): Generator<BrowserNode, void, unknown>;
         /** Resolves the captured document a node belongs to. */
@@ -3804,13 +3212,11 @@ export declare interface BrowserRunStoreInterface {
     }
 
     /**
-     * Reports a journey step whose action did not complete, under the code `BROWSER_STEP_ERROR`, with
-     * the performed action in `action`.
+     * Reports an incomplete journey step with its action and the code `STEP`.
      *
      * @remarks
-     * The message is `ID: RECEIPT`, where `ID` is the step's id and `RECEIPT` the action's receipt, and
-     * `context` names the step under `step`. A caller reads the outcome, stage, reason, receipt, and
-     * elapsed time from `action` rather than from the message.
+     * The message is `ID: RECEIPT`, and `context.step` names the step.
+     * The action carries the outcome, stage, reason, receipt, and elapsed time.
      */
     export declare class BrowserStepError extends BrowserError {
         readonly action: BrowserAction;
@@ -3834,30 +3240,10 @@ export declare interface BrowserRunStoreInterface {
         readonly value: string;
     }
 
-    /**
-     * Imports, exports, and clears cookie and web-storage state for one browser context.
-     *
-     * @example
-     * ```ts
-     * import { BrowserStorageManager } from '@orkestrel/browser'
-     *
-     * const storage = new BrowserStorageManager(context.cookies, () => context.pages())
-     * const state = await storage.state({ origins: ['https://example.com'] })
-     * await storage.restore(state)
-     * ```
-     */
-    export declare class BrowserStorageManager implements BrowserStorageManagerInterface {
-        #private;
-        constructor(cookies: BrowserCookieManagerInterface, pages: BrowserPagesFunction);
-        state(options?: BrowserStorageOptions): Promise<BrowserStorageState>;
-        restore(state: BrowserStorageState): Promise<void>;
-        clear(origin?: string): Promise<void>;
-    }
-
     /** Provides storage-state import, export, and clearing operations. */
     export declare interface BrowserStorageManagerInterface {
         /** Reads the context cookies and the per-origin local and session storage. */
-        state(options?: BrowserStorageOptions): Promise<BrowserStorageState>;
+        snapshot(options?: BrowserStorageOptions): Promise<BrowserStorageState>;
         /** Writes a previously read state back into the context. */
         restore(state: BrowserStorageState): Promise<void>;
         /** Drops the storage of one origin, or of every origin when given none. */
@@ -3918,6 +3304,12 @@ export declare interface BrowserRunStoreInterface {
         readonly faults: readonly BrowserStoreFault[];
     }
 
+    /** Configures one page of a store listing, with cancellation. */
+    export declare interface BrowserStorePageOptions extends BrowserStoreOptions {
+        readonly offset?: number;
+        readonly limit?: number;
+    }
+
     /** Represents one decoded IO stream read. */
     export declare interface BrowserStreamChunk {
         readonly bytes: Uint8Array;
@@ -3931,7 +3323,7 @@ export declare interface BrowserRunStoreInterface {
     }
 
     /**
-     * Describes one open tab of a toolset's context, which the `tabs` tool lists one per line.
+     * Describes one open tab of a toolset's context, which the `read` header lists.
      *
      * @remarks
      * - `id` — `t` followed by the tab's one-based position in the context, which `switch` takes
@@ -3985,10 +3377,10 @@ export declare interface BrowserRunStoreInterface {
 
     /**
      * Names a tool the browser toolset reserves: the generic tools, the staged `dialog`, the
-     * opt-in `tabs` and `switch`, and the journey tools `record`, `save`, `journeys`, `edit`,
+     * opt-in `switch`, and the journey tools `record`, `save`, `journeys`, `edit`,
      * `replay`, `forget`, and `capture`, which a toolset constructed with `journeys` reserves.
      */
-    export declare type BrowserToolName = 'look' | 'read' | 'plain' | 'click' | 'type' | 'press' | 'navigate' | 'wait' | 'dialog' | 'tabs' | 'switch' | 'record' | 'save' | 'journeys' | 'edit' | 'replay' | 'forget' | 'capture';
+    export declare type BrowserToolName = 'read' | 'click' | 'type' | 'press' | 'navigate' | 'wait' | 'dialog' | 'switch' | 'record' | 'save' | 'journeys' | 'edit' | 'replay' | 'forget' | 'capture';
 
     /** Identifies a removed WebMCP tool by document and name. */
     export declare interface BrowserToolRemoval {
@@ -4001,11 +3393,11 @@ export declare interface BrowserRunStoreInterface {
      * view's own tools beside them.
      *
      * @remarks
-     * 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`
+     * Every toolset advertises `read`, `click`, `type`, and `wait`, which need only the
+     * `BrowserViewInterface` it is constructed over. When `isBrowserPage(view)` holds 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
-     * `page.registry` by default; with `options.context` as well it advertises `tabs` and `switch`.
+     * `page.registry` by default; with `options.context` as well it advertises `switch` and lists tabs in each window.
      * With `options.journeys` the constructor constructs a `BrowserJourneyToolset`, which adds
      * `record`, `save`, `journeys`, `edit`, and `replay` to the manager and reserves those names, and
      * `destroy()` destroys it first. The result that carries the view after a move names the move.
@@ -4014,13 +3406,18 @@ export declare interface BrowserRunStoreInterface {
      * `the browser session ended` after `destroy()`, refuses an aborted signal before the tool runs,
      * 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 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.
+     * advertise, and bounds every complete result and thrown message, including its footer, by
+     * the smaller of the configured limit and 4,000 UTF-16 units. Every read and action window
+     * recaptures numbered accessibility lines. Inclusive ranges use required tool parameter
+     * `from` and optional `to`; search scores text spans and opens near the first best match.
+     * Wrapping precedes numbering, and every continuation names the next complete line. An
+     * unchanged page keeps its addresses; a changed read includes a change note, even from line 1.
+     * A trailing heading opens the next window unless it is the only row or ends the page.
+     * A partial-view line follows the page header when rows remain after the window. A search
+     * missing its range reports the first page-wide best match only when that line carries an
+     * element reference, without moving that window; otherwise it keeps the plain miss.
+     * An unquoted miss appears immediately before the footer, with its space reserved before
+     * fitting rows. Quoted best matches and in-range hits remain under the header.
      * 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
@@ -4045,20 +3442,21 @@ export declare interface BrowserRunStoreInterface {
      * navigation record opens, `click` and `type` with `submit` install a `submit` observer in the
      * isolated world of the element's document, and `press` in every document one `page.frames()`
      * call lists; an action whose input
-     * document cannot be observed is refused with `BROWSER_TOOLSET_OBSERVE` before any input, and a
+     * document cannot be observed is refused with `TOOLSET_OBSERVE` before any input, and a
      * document `press` did not list is not observed. A navigation that starts in the input's frame or
      * an ancestor before the input settles is followed; when the input settles first, each observed
      * submission that kept its default action names its destination frame, and the receipt waits for
      * the navigation the record selects to commit and load under the receipt's deadline; a submission
-     * every listener prevented adds no wait. When the reads name no surviving destination and no
-     * navigation followed, the receipt's status is `BROWSER_TOOL_HANDLED_STATUS`, which names `wait` as
-     * the next call, after a prevented submission, and `no form received the submission` when `type`
+     * every listener prevented waits for a rendered change, navigation, dialog, abort, or detachment.
+     * Change observation starts in capture-phase submit before application handlers. Reading its
+     * state preserves it, and every exit releases it. Hidden and bookkeeping mutations do not count.
+     * The status is `BROWSER_TOOL_HANDLED_STATUS` after a change or `BROWSER_TOOL_UNCHANGED_STATUS`
+     * at the deadline. The status is `no form received the submission` when `type`
      * with `submit`, or a `press` of Enter that an input a form owns received, recorded none. The
      * 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` or `plain`
-     * at an offset at or past its retained reading's end restarts that reading at 0. A receipt that
+     * otherwise. 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
      * deadline runs from the moment the receipt starts waiting, after any time the action spent
@@ -4066,7 +3464,8 @@ export declare interface BrowserRunStoreInterface {
      * receipt aborts the capture. A capture that the page's change makes stale waits for the page's
      * readiness and reads the view once more inside the same deadline, and reports
      * `BROWSER_TOOL_CHANGED_NOTE` when that read fails too. `type` refuses an element whose role is
-     * not in `BROWSER_TYPED_ROLES` before it sends anything, naming `click` as the next call. A `click` on an element whose role is in `BROWSER_TYPED_ROLES`
+     * not in `BROWSER_TYPED_ROLES` before it sends anything, naming the view's text-taking fields,
+     * or `click` when there are none. A `click` on an element whose role is in `BROWSER_TYPED_ROLES`
      * adds `; call type with REF to enter text` to its receipt line. A click
      * or type over a view whose `trusted` is `false` ends its receipt line with ` (untrusted event)`.
      *
@@ -4078,15 +3477,15 @@ export declare interface BrowserRunStoreInterface {
      * 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.
+     * closes or destroys its caller-owned view.
      *
      * @example
      * ```ts
      * import { BrowserToolset } from '@orkestrel/browser'
      *
-     * const toolset = new BrowserToolset(page, { page })
+     * const toolset = new BrowserToolset(page)
      * await toolset.start()
-     * const result = await toolset.tools.execute({ id: '1', name: 'look', arguments: { search: 'cart' } })
+     * const result = await toolset.tools.execute({ id: '1', name: 'read', arguments: { from: 1, search: 'cart' } })
      * await toolset.destroy()
      * ```
      */
@@ -4099,12 +3498,15 @@ export declare interface BrowserRunStoreInterface {
         get native(): readonly ToolInterface[];
         get view(): BrowserViewInterface;
         get held(): string | undefined;
-        perform(call: ToolCall, context?: ToolContext): Promise<BrowserToolsetResult>;
+        redact(text: string): string;
+        describe(reference: string): string;
+        execute(call: ToolCall, context?: ToolContext): Promise<BrowserToolsetResult>;
         hold(name: string, options?: BrowserCallOptions): Promise<BrowserHoldInterface>;
         follow(id: string, step: BrowserJourneyStepInput, options?: BrowserFollowOptions): Promise<BrowserAction>;
         tabs(options?: BrowserCallOptions): Promise<readonly BrowserTab[]>;
         start(options?: BrowserCallOptions): Promise<void>;
         destroy(): Promise<void>;
+        read(options?: BrowserToolsetReadOptions): Promise<string>;
     }
 
     /**
@@ -4127,40 +3529,50 @@ export declare interface BrowserRunStoreInterface {
         readonly release: readonly [name: string];
     };
 
-    /**
-     * Runs one toolset tool inside the toolset's boundary.
-     *
-     * @param args - The arguments the caller supplied
-     * @param context - The call's context, whose signal also aborts when the toolset is destroyed
-     * @returns The result body, which the boundary bounds, and a footer it appends after the bound
-     */
-    export declare type BrowserToolsetHandler = (args: Readonly<Record<string, unknown>>, context: ToolContext) => Promise<readonly [body: string, footer: string]>;
-
     /**
      * Publishes the browser vocabulary as tools over one current view and adopts the page's own
      * tools beside them.
      *
      * @remarks
      * - `emitter` — emits `adopt`, `skip`, `select`, `action`, `hold`, and `release`
-     * - `tools` — the manager the toolset fills, with execution through the `perform` boundary
+     * - `tools` — the manager the toolset fills, with execution through the `execute` boundary
      * - `native` — the generic tools alone, which a consumer publishes to a built-in agent: the
-     *   `look`, `read`, `plain`, `click`, `type`, `press`, `navigate`, and `wait` for a page-backed
-     *   toolset, and `look`, `read`, `plain`, `click`, `type`, and `wait` for a view-backed one
+     *   `read`, `click`, `type`, `press`, `navigate`, and `wait` for a page-backed
+     *   toolset, and `read`, `click`, `type`, and `wait` for a view-backed one
      * - `view` — the view the tools act on
      */
     export declare interface BrowserToolsetInterface {
+        /** Describes a missing reference using its last shown role and name, or the unknown-reference refusal.
+         * @param reference - Canonical element reference
+         * @returns The refusal text
+         */
+        describe(reference: string): string;
+        /** Redacts registered secrets from unnumbered text before composing a result.
+         * @param text - Unbounded, unnumbered text
+         * @returns Text with registered secrets removed
+         */
+        redact(text: string): string;
+        /** Renders a fresh page window, including pending move notes, within the requested limit.
+         * @remarks
+         * A unique link with the same role, accessible name, and resolved href in consecutive documents
+         * of one tab keeps its reference. A successful action still resets the accepted set; carried
+         * references are accepted again when its result lists them.
+         * @param options - Inclusive range, search, cancellation, and character room
+         * @returns Numbered lines with an exact continuation footer
+         */
+        read(options?: BrowserToolsetReadOptions): Promise<string>;
         readonly emitter: EmitterInterface<BrowserToolsetEventMap>;
         readonly tools: ToolManagerInterface;
         readonly native: readonly ToolInterface[];
         readonly view: BrowserViewInterface;
-        /** Reports the character limit before a result or error footer. */
+        /** Reports the whole-result character limit, including a result or error footer. */
         readonly limit: number;
         /** Names the acquired hold, or returns undefined while no hold owns the toolset. */
         readonly held: string | undefined;
         /** Performs a tool call and returns its structured action when a handler ran. */
-        perform(call: ToolCall, context?: ToolContext): Promise<BrowserToolsetResult>;
+        execute(call: ToolCall, context?: ToolContext): Promise<BrowserToolsetResult>;
         /**
-         * Performs one recorded step on the current view through `perform` and returns its action.
+         * Performs one recorded step on the current view through `execute` and returns its action.
          *
          * @remarks
          * A `click` or `type` step with a target resolves the one element of the current view that
@@ -4168,8 +3580,8 @@ export declare interface BrowserRunStoreInterface {
          * `reference` and `css` are evidence only. A `switch` step on a toolset with `context` resolves
          * the one tab `tabs()` lists with the step's URL and title, and sends the tab's id as `tab`.
          * Every other step sends its arguments unchanged, a page tool's included. A missing target or
-         * tab refuses with `BROWSER_JOURNEY_TARGET`, several refuse with `BROWSER_JOURNEY_AMBIGUOUS`, and
-         * a target name that binds a parameter refuses with `BROWSER_JOURNEY_INPUT`, each naming the
+         * tab refuses with `JOURNEY_TARGET`, several refuse with `JOURNEY_AMBIGUOUS`, and
+         * a target name that binds a parameter refuses with `JOURNEY_INPUT`, each naming the
          * step before any input. An action that is `done`, or `interrupted` by a dialog a following
          * `dialog` step answers, returns; any other outcome, and a navigation that stopped at
          * `requested` or `committed`, throws a `BrowserStepError` whose `action` is the performed
@@ -4177,26 +3589,26 @@ export declare interface BrowserRunStoreInterface {
          */
         follow(id: string, step: BrowserJourneyStepInput, options?: BrowserFollowOptions): Promise<BrowserAction>;
         /**
-         * Lists the open tabs of the toolset's context in the order the `tabs` tool lists them.
+         * Lists the open tabs of the toolset's context in the order the `read` header lists them.
          *
          * @remarks
          * A tab whose title does not answer within `BROWSER_TOOL_TIMEOUT_MS` lists an empty title, and a
          * toolset without `context` lists none. Rejects with `the browser session ended` after
          * `destroy()`, with the signal's reason when `options.signal` aborts, and with
-         * `BROWSER_TOOLSET_DIALOG` while a dialog is open on the current tab.
+         * `TOOLSET_DIALOG` while a dialog is open on the current tab.
          */
         tabs(options?: BrowserCallOptions): Promise<readonly BrowserTab[]>;
         /**
          * Takes a queue turn and reserves action admission from the call for the returned caller token.
          *
          * @remarks
-         * An action without the token that arrives after the call is refused with `BROWSER_TOOLSET_BUSY`
-         * and `The toolset is replaying NAME until it finishes; call look.`, while waiting and while held;
+         * An action without the token that arrives after the call is refused with `TOOLSET_BUSY`
+         * and `The toolset is replaying NAME until it finishes; call read.`, while waiting and while held;
          * the actions admitted before the call complete first; a wait that aborts or fails releases the
          * pending reservation.
          * A second hold waits for earlier holds to release and honours its signal while waiting.
          * An open dialog or an input left pending by an earlier receipt refuses with
-         * `BROWSER_TOOLSET_DIALOG` before admission is reserved. A dialog that opens while the
+         * `TOOLSET_DIALOG` before admission is reserved. A dialog that opens while the
          * queue drains also refuses the hold, leaving its answer admissible.
          */
         hold(name: string, options?: BrowserCallOptions): Promise<BrowserHoldInterface>;
@@ -4209,7 +3621,7 @@ export declare interface BrowserRunStoreInterface {
         start(options?: BrowserCallOptions): Promise<void>;
         /**
          * Stops following the view, rejects queued actions, and removes every tool the toolset added
-         * that the manager still holds, then calls the `release` option one time; a second call
+         * that the manager still holds. The caller retains ownership of the view. A second call
          * returns the first call's promise.
          */
         destroy(): Promise<void>;
@@ -4219,37 +3631,52 @@ export declare interface BrowserRunStoreInterface {
      * Configures a browser toolset.
      *
      * @remarks
+     * - `notes` — supplies host notices before the result is budgeted
+     * - `on` — initial event listeners
+     * - `error` — observer error handler
      * - `tools` — the manager the toolset fills. Default: a manager the toolset creates
-     * - `page` — the page behind the view, which adds `press`, `navigate`, the staged `dialog`,
-     *   popup following, and the protocol subscriptions; omitting it leaves the five view tools
-     * - `source` — a fixed source of page tools. Default: `page.registry` when `page` is supplied,
-     *   which the toolset starts and which follows the current page; no source otherwise
-     * - `context` — the browser context whose pages the `tabs` and `switch` tools list and select;
-     *   it requires `page`, and omitting it leaves both tools unadvertised
-     * - `limit` — the most characters of a result or error message before its footer, a positive
+     * - `source` — fixed page-tool source. Default: the view's registry when `isBrowserPage` holds;
+     *   the toolset starts that registry and follows the current page; no source for other views
+     * - `context` — context whose pages `read` lists and `switch` selects; requires a page view
+     * - `limit` — the most characters of a complete result or error message, including its footer, a positive
      *   integer. Default: `BROWSER_TOOL_LIMIT`
      * - `schemes` — the URL schemes `navigate` accepts, each with its colon. Default:
      *   `BROWSER_SCHEMES`
-     * - `release` — releases a resource the caller hands to the toolset, such as a view created for
-     *   it alone; `destroy()` calls it one time, after the toolset's own teardown, and rejects with
-     *   its rejection. A view or page supplied without it stays the caller's to end. Default: nothing
-     *   is released
      * - `journeys` — the stores behind the journey tools, which the toolset registers and reserves
      *   through a journey toolset it constructs; omitting it leaves the journey tools unadvertised
+     *
+     * The caller owns the view and releases it after the toolset is destroyed.
      */
     export declare interface BrowserToolsetOptions {
+        /** Supplies and consumes host notices before the complete result is budgeted. */
+        readonly notes?: () => string;
         readonly on?: EmitterHooks<BrowserToolsetEventMap>;
         readonly error?: EmitterErrorHandler;
         readonly tools?: ToolManagerInterface;
-        readonly page?: BrowserPageInterface;
         readonly source?: BrowserToolSourceInterface;
         readonly context?: BrowserContextInterface;
         readonly limit?: number;
         readonly schemes?: readonly string[];
-        readonly release?: () => Promise<void> | void;
         readonly journeys?: BrowserJourneyOptions;
     }
 
+    /** Configures a fresh line window within a whole-result character limit.
+     * @remarks
+     * - `from` — first line, inclusive. Default: 1
+     * - `to` — last line, inclusive. Default: as many lines as fit
+     * - `search` — words whose best in-range match opens the window; a range miss reports the
+     *   first page-wide best match only when it carries an element reference, without moving
+     *   the window; otherwise it keeps the plain miss. Unquoted misses appear before the footer;
+     *   quoted best matches and in-range hits stay under the header
+     * - `limit` — character room including the header and footer. Default: the toolset limit
+     */
+    export declare interface BrowserToolsetReadOptions extends BrowserCallOptions {
+        readonly from?: number;
+        readonly to?: number;
+        readonly search?: string;
+        readonly limit?: number;
+    }
+
     /**
      * Names why a toolset declined a page tool.
      *
@@ -4280,14 +3707,6 @@ export declare interface BrowserRunStoreInterface {
         readonly fault?: unknown;
     }
 
-    /** Holds the listeners a toolset attaches to one followed page. */
-    export declare interface BrowserToolsetWatch {
-        readonly dialog: (dialog: BrowserDialogInterface) => void;
-        readonly popup: (page: BrowserPageInterface) => void;
-        readonly close: () => void;
-        readonly closed: CDPHandler;
-    }
-
     /** Maps the signal a tool source emits when its page's tools change. */
     export declare type BrowserToolSourceEventMap = {
         readonly change: readonly [];
@@ -4315,23 +3734,6 @@ export declare interface BrowserRunStoreInterface {
         tools?(): readonly BrowserTool[];
     }
 
-    /**
-     * Sends trusted touch input through Chromium's CDP Input domain.
-     *
-     * @example
-     * ```ts
-     * import { BrowserTouch } from '@orkestrel/browser'
-     *
-     * const touch = new BrowserTouch(page)
-     * await touch.tap({ x: 120, y: 240 })
-     * ```
-     */
-    export declare class BrowserTouch implements BrowserTouchInterface {
-        #private;
-        constructor(frame: BrowserFrameInterface);
-        tap(point: BrowserPoint): Promise<void>;
-    }
-
     /** Provides touch input operations bound to one frame target session. */
     export declare interface BrowserTouchInterface {
         /**
@@ -4340,27 +3742,6 @@ export declare interface BrowserRunStoreInterface {
         tap(point: BrowserPoint): Promise<void>;
     }
 
-    /**
-     * Captures Chromium traces streamed through the IO domain.
-     *
-     * @example
-     * ```ts
-     * import { BrowserTracing } from '@orkestrel/browser'
-     *
-     * const tracing = new BrowserTracing(page)
-     * await tracing.start({ screenshots: true })
-     * const trace = await tracing.stop() // { bytes, path }
-     * ```
-     */
-    export declare class BrowserTracing implements BrowserTracingInterface {
-        #private;
-        constructor(frame: BrowserFrameInterface, writer?: BrowserWriterInterface);
-        get active(): boolean;
-        start(options?: BrowserTracingOptions): Promise<void>;
-        stop(): Promise<BrowserTracingResult>;
-        destroy(): Promise<void>;
-    }
-
     /** Drives the trace capture lifecycle. */
     export declare interface BrowserTracingInterface {
         readonly active: boolean;
@@ -4443,6 +3824,16 @@ export declare interface BrowserRunStoreInterface {
         execute(work: BrowserTransitionFunction<T>): Promise<T>;
     }
 
+    /**
+     * Describes the options for traversing a browser snapshot.
+     *
+     * @remarks
+     * - `root` — optional subtree root, included in the walk
+     */
+    export declare interface BrowserTraversalOptions {
+        readonly root?: BrowserNode;
+    }
+
     /** Describes user-agent metadata accepted by Chromium emulation. */
     export declare interface BrowserUserAgent {
         readonly value: string;
@@ -4480,7 +3871,7 @@ export declare interface BrowserRunStoreInterface {
         read(options?: BrowserCallOptions): Promise<BrowserReadingInterface>;
         /**
          * Resolves when the main document body’s `innerText` contains `text`, or lacks it with `absent`; rejects with a `BrowserError` coded
-         * `BROWSER_WAIT_TIMEOUT` at the deadline, and with `signal.reason` on abort.
+         * `TIMEOUT` at the deadline, and with `signal.reason` on abort.
          */
         wait(text: string, options?: BrowserWaitOptions): Promise<void>;
     }
@@ -4507,47 +3898,6 @@ export declare interface BrowserRunStoreInterface {
         readonly absent?: boolean;
     }
 
-    /** Names the page load condition for navigation — the CDP load event awaited by `navigate()`. */
-    export declare type BrowserWaitUntil = 'commit' | 'load' | 'domcontentloaded' | 'idle';
-
-    /**
-     * Describes the options for walking a browser snapshot.
-     *
-     * @remarks
-     * - `root` — optional subtree root, included in the walk
-     * - `order` — structural traversal order, defaulting to depth-first
-     */
-    export declare interface BrowserWalkOptions {
-        readonly root?: BrowserNode;
-        readonly order?: BrowserWalkOrder;
-    }
-
-    /** Names the structural ordering for a browser snapshot walk. */
-    export declare type BrowserWalkOrder = 'depth' | 'breadth';
-
-    /**
-     * Represents an observable WebSocket connection reconstructed from Network-domain events.
-     *
-     * @example
-     * ```ts
-     * import { BrowserWebSocket } from '@orkestrel/browser'
-     *
-     * const socket = new BrowserWebSocket('request-1', 'wss://example.com/live')
-     * socket.emitter.on('receive', (frame) => log(frame.data))
-     * ```
-     */
-    export declare class BrowserWebSocket implements BrowserWebSocketInterface {
-        #private;
-        constructor(id: string, url: string);
-        get emitter(): EmitterInterface<BrowserWebSocketEventMap>;
-        get id(): string;
-        get url(): string;
-        receive(frame: BrowserWebSocketFrame): void;
-        transmit(frame: BrowserWebSocketFrame): void;
-        fail(message: string): void;
-        close(timestamp: number): void;
-    }
-
     /** Maps the WebSocket lifecycle events. */
     export declare type BrowserWebSocketEventMap = {
         readonly receive: readonly [frame: BrowserWebSocketFrame];
@@ -4569,22 +3919,12 @@ export declare interface BrowserRunStoreInterface {
      *
      * @remarks
      * The connection is an observation: a page's network manager reconstructs it
-     * from Network-domain events and drives the concrete `BrowserWebSocket`. The
-     * drive methods are on this contract because the class exposes exactly its
-     * interface methods.
+     * from network events through private callbacks; consumers observe its events.
      */
     export declare interface BrowserWebSocketInterface {
         readonly emitter: EmitterInterface<BrowserWebSocketEventMap>;
         readonly id: string;
         readonly url: string;
-        /** Reports one received frame. The page's network manager drives it. */
-        receive(frame: BrowserWebSocketFrame): void;
-        /** Reports one sent frame. The page's network manager drives it. */
-        transmit(frame: BrowserWebSocketFrame): void;
-        /** Reports a connection fault. The page's network manager drives it. */
-        fail(message: string): void;
-        /** Reports the connection closing and destroys the emitter. The page's network manager drives it. */
-        close(timestamp: number): void;
     }
 
     /** Names a worker target category. */
@@ -4600,21 +3940,11 @@ export declare interface BrowserRunStoreInterface {
         /** Issues one CDP method call on the worker's session. */
         send(method: string, params?: Readonly<Record<string, unknown>>, options?: BrowserCallOptions): Promise<unknown>;
         /** Stops driving the worker locally without closing its target. */
-        detach(): void;
+        destroy(): void;
         /** Closes the worker target, tolerating a worker that already terminated. Idempotent. */
         close(): Promise<void>;
     }
 
-    /**
-     * Resolves the isolated-world execution context a page caches for one frame document, creating
-     * the world on the given session when none is cached.
-     *
-     * @param session - The CDP session that owns the frame
-     * @param options - The deadline and signal for the creation call
-     * @returns The isolated-world execution context id
-     */
-    export declare type BrowserWorldFunction = (session: string, options?: BrowserCallOptions) => Promise<number>;
-
     /**
      * Provides a pluggable sink for persisting captured browser bytes to a path.
      *
@@ -4628,6 +3958,21 @@ export declare interface BrowserRunStoreInterface {
         write(path: string, data: Uint8Array): Promise<void>;
     }
 
+    /**
+     * Builds a standards-shaped HAR 1.2 entry from one observed exchange.
+     *
+     * @param pending - Request and optional response captured by the recorder
+     * @param duration - Whole exchange duration in milliseconds
+     * @param body - Optional decoded response body
+     * @param error - Optional request failure description
+     * @returns HAR 1.2 entry
+     */
+    export declare function buildBrowserHAREntry(pending: {
+        readonly request: BrowserRequest;
+        readonly started: number;
+        readonly response: BrowserResponse | undefined;
+    }, duration: number, body?: Uint8Array, error?: string): BrowserHAREntry;
+
     /**
      * Builds a validated journey from recorded steps and declares their secret bindings.
      * @param steps - Recorded steps in order
@@ -4635,10 +3980,7 @@ export declare interface BrowserRunStoreInterface {
      * @returns An owned journey with its next id and secret declarations
      * @throws BrowserError - Thrown when the assembled journey fails validation
      */
-    export declare function buildBrowserJourney(steps: readonly BrowserJourneyStep[], options: Pick<BrowserJourney, 'name' | 'description'>): BrowserJourney;
-
-    /** Decodes UTF-8 bytes as text. */
-    export declare function bytesToText(value: Uint8Array): string;
+    export declare function buildBrowserJourney(steps: readonly BrowserJourneyStep[], options: BrowserJourneyInput): BrowserJourney;
 
     /**
      * Provides a lightweight Chrome DevTools Protocol client over a {@link CDPTransportInterface}.
@@ -4771,25 +4113,6 @@ export declare interface BrowserRunStoreInterface {
         readonly error?: EmitterErrorHandler;
     }
 
-    /**
-     * Reports that a CDP request could not be sent or completed because the client was not connected, closed while connecting, lost its connection, or lost the request's target session, under the code `BROWSER_CDP_CONNECTION_ERROR`.
-     */
-    export declare class CDPConnectionError extends BrowserError {
-        constructor(message: string, context?: Readonly<Record<string, unknown>>);
-    }
-
-    /**
-     * Reports that a CDP request received an error response from the remote endpoint, under the
-     * code `BROWSER_CDP_ERROR`, with the `method`, the CDP `code`, the `message`, and any `data`
-     * in its context.
-     *
-     * @remarks
-     * Branch on the protocol-level error in `context` instead of parsing the message string.
-     */
-    export declare class CDPError extends BrowserError {
-        constructor(message: string, context?: Readonly<Record<string, unknown>>);
-    }
-
     /** Receives a subscribed CDP event with its params record. */
     export declare type CDPHandler = (params: Readonly<Record<string, unknown>>) => void;
 
@@ -4821,14 +4144,6 @@ export declare interface BrowserRunStoreInterface {
         readonly url: string;
     }
 
-    /**
-     * Reports that a pending CDP request was not answered within its timeout window, under the
-     * code `BROWSER_CDP_TIMEOUT_ERROR`.
-     */
-    export declare class CDPTimeoutError extends BrowserError {
-        constructor(message: string, context?: Readonly<Record<string, unknown>>);
-    }
-
     /**
      * Maps the events emitted by a {@link CDPTransportInterface} — the raw text pipe a
      * {@link CDPClientInterface} sends and receives JSON-RPC frames over.
@@ -4859,7 +4174,7 @@ export declare interface BrowserRunStoreInterface {
         /** Opens the underlying connection. */
         start(): Promise<void>;
         /**
-         * Writes one raw text frame to the connection. Throws a coded `BrowserConnectionError`
+         * Writes one raw text frame to the connection. Throws a coded `BrowserError`
          * carrying the transport `url` when called before the connection opens or after it closes.
          */
         send(data: string): Promise<void>;
@@ -4970,7 +4285,7 @@ export declare interface BrowserRunStoreInterface {
      * @param journey - The journey to compile
      * @param options - The target language
      * @returns The module source and the gap step ids in step order
-     * @throws BrowserError - Thrown with `BROWSER_JOURNEY_FORMAT` or `BROWSER_JOURNEY_INVALID` when the
+     * @throws BrowserError - Thrown with `STORE_FORMAT` or `JOURNEY_INVALID` when the
      * journey fails validation, before any source is compiled
      * @example
      * ```ts
@@ -5011,7 +4326,7 @@ export declare interface BrowserRunStoreInterface {
      * A result whose `JSON.stringify` length exceeds `limit` throws
      * `Error('BROWSER_RESULT_LIMIT: <length>')` inside the page instead of being
      * returned — the caller maps that sentinel to a coded
-     * {@link BrowserResultLimitError}. A non-serializable result (`undefined`,
+     * {@link BrowserError}. A non-serializable result (`undefined`,
      * a function, a symbol) makes `JSON.stringify` return `undefined`, so the
      * length check is skipped and today's undefined-passthrough behavior is
      * unchanged.
@@ -5110,7 +4425,7 @@ export declare interface BrowserRunStoreInterface {
      *
      * @remarks
      * The observer records every `submit` event the window sees from installation until
-     * {@link compileSubmitReadExpression} with the same `token` reads and removes it, under
+     * {@link compileSubmitReadExpression} with the same `token` reads it without removing it, under
      * {@link BROWSER_SUBMIT_KEY}, and replaces an observer an earlier installation left in place,
      * whatever its token. A capture-phase `keydown` listener beside it records whether an Enter's
      * target is an `input` a form owns, before any handler of the page can move the focus. A listener
@@ -5124,7 +4439,7 @@ export declare interface BrowserRunStoreInterface {
 
     /**
      * Compiles the read of the `submit` observer {@link compileSubmitObserverExpression} installs for
-     * `token`, removing the observer.
+     * `token`, preserving the observer until cleanup.
      *
      * @remarks
      * The read resolves an object of four members:
@@ -5150,6 +4465,19 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function compileSubmitReadExpression(token: number): string;
 
+    /** Compiles token-scoped cleanup of submission listeners and change observation.
+     * @param token - Action owning the observation
+     * @returns An expression releasing only that action's observation
+     */
+    export declare function compileSubmitReleaseExpression(token: number): string;
+
+    /** Compiles a bounded wait for the first rendered change after submission.
+     * @param token - Action owning the observation
+     * @param timeout - Remaining settle time in milliseconds
+     * @returns An expression resolving true for a rendered change and false at the deadline
+     */
+    export declare function compileSubmitWaitExpression(token: number, timeout: number): string;
+
     /**
      * Compiles a wait for the presence or absence of visible text, coalesced by tasks.
      * @param text - Text to find in the main document body
@@ -5201,15 +4529,23 @@ export declare interface BrowserRunStoreInterface {
     export declare function cookieToProtocol(cookie: BrowserCookieInput): Readonly<Record<string, unknown>>;
 
     /**
-     * Builds a standards-shaped HAR 1.2 entry from one observed exchange.
+     * Creates a wrapper over an existing browser context on a CDP client.
      *
-     * @param pending - Request and optional response captured by the recorder
-     * @param duration - Whole exchange duration in milliseconds
-     * @param body - Optional decoded response body
-     * @param error - Optional request failure description
-     * @returns HAR 1.2 entry
+     * @remarks
+     * `id` selects an existing remote context; omission selects the default context.
+     * The caller owns the client. Use `browser.isolate` to create a remote context with
+     * `proxy` or `origins`; this factory refuses those options.
+     *
+     * @param client - The client whose connection carries the context's pages
+     * @param options - Context identity, page defaults, writer, and event hooks
+     * @returns The context wrapper
+     * @throws Thrown with `ARGUMENT` when `proxy` or `origins` is supplied.
+     * @example
+     * const context = createBrowserContext(client, { viewport: { width: 1280, height: 720 } })
+     * const page = await context.create({ url: 'https://example.com/' })
+     * await context.destroy()
      */
-    export declare function createBrowserHAREntry(pending: BrowserHARPending, duration: number, body?: Uint8Array, error?: string): BrowserHAREntry;
+    export declare function createBrowserContext(client: CDPClientInterface, options?: BrowserContextOptions): BrowserContextInterface;
 
     /**
      * Creates a `BrowserReadingInterface` over a captured document, parsing its HTML one time.
@@ -5274,19 +4610,17 @@ export declare interface BrowserRunStoreInterface {
     export declare function createBrowserSnapshot(input: BrowserSnapshotInput): BrowserSnapshotInterface;
 
     /**
-     * Creates a `BrowserToolsetInterface` that publishes the browser vocabulary over one page into a
-     * `@orkestrel/tool` manager.
+     * Creates a toolset over a caller-owned view, enabling page tools when the view is a page.
      *
      * @remarks
-     * The page is both the toolset's view and its `page` option, so the toolset advertises the seven
-     * CDP tools. It registers its tools during `start()`: the generic tools first, then the page
-     * tools as their adoption resolves. Its options are described on {@link BrowserToolsetOptions};
-     * hand `toolset.tools` to an agent, and publish `toolset.native` to a built-in browser agent.
+     * A structural {@link isBrowserPage} guard selects page features, including navigation,
+     * trusted keyboard input, dialogs, and popup following. Other views publish the document
+     * vocabulary. Tools register during `start()`; `destroy()` leaves the view with its caller.
+     * Hand `toolset.tools` to an agent and publish `toolset.native` to a built-in browser agent.
      *
-     * @param page - The page the tools act on first
-     * @param options - The manager, page-tool source, context, bound, and schemes; `page` is replaced
-     * by the page argument
-     * @returns A {@link BrowserToolsetInterface}
+     * @param view - The view the tools act on first
+     * @param options - Tool manager, source, context, bounds, schemes, and journey stores
+     * @returns The toolset
      *
      * @example
      * ```ts
@@ -5294,7 +4628,7 @@ export declare interface BrowserRunStoreInterface {
      *
      * const toolset = createBrowserToolset(page, { context })
      * await toolset.start()
-     * const result = await toolset.tools.execute({ id: '1', name: 'look', arguments: { search: 'cart' } })
+     * const result = await toolset.tools.execute({ id: '1', name: 'read', arguments: { from: 1, search: 'cart' } })
      * ```
      *
      * @example Drive a page with a small model
@@ -5307,8 +4641,8 @@ export declare interface BrowserRunStoreInterface {
      *
      * 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 search set to words from your question; when its result ends by naming an offset, call read again with that offset. ' +
+     * 	'The first message shows numbered page lines; references such as e4 name its elements. ' +
+     * 	'To learn a fact, call read with from 1 and search words from your question; follow a footer by calling read with its from line. ' +
      * 	"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. ' +
@@ -5319,11 +4653,11 @@ export declare interface BrowserRunStoreInterface {
      * 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', 'plain', 'click', 'type', 'press', 'navigate', 'wait']
+     * toolset.tools.tools().map((tool) => tool.name) // ['read', 'click', 'type', 'press', 'navigate', 'wait']
      * const seeded = await toolset.tools.execute({
      * 	id: 'seed',
-     * 	name: 'look',
-     * 	arguments: { search: '' },
+     * 	name: 'read',
+     * 	arguments: { from: 1 },
      * })
      * const view = seeded.success ? String(seeded.value) : seeded.error
      * const agent = createAgent(createOllama({ model: 'qwen3.5:2b-q4_K_M' }), {
@@ -5332,14 +4666,14 @@ export declare interface BrowserRunStoreInterface {
      * })
      * agent.context.messages.add({
      * 	role: 'user',
-     * 	content: `What does the Alpine Kettle cost?\n\nThe browser shows this page:\n${view}`,
+     * 	content: `What does the Alpine Kettle cost?\n\nThe browser's first read of the page:\n${view}`,
      * })
      * const result = await agent.generate()
      * await toolset.destroy()
      * await browser.destroy()
      * ```
      */
-    export declare function createBrowserToolset(page: BrowserPageInterface, options?: BrowserToolsetOptions): BrowserToolsetInterface;
+    export declare function createBrowserToolset(view: BrowserViewInterface, options?: BrowserToolsetOptions): BrowserToolsetInterface;
 
     /**
      * Creates a `CDPClientInterface` bound to the given `CDPTransportInterface`.
@@ -5375,24 +4709,6 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function createMemoryBrowserRunStore(): BrowserRunStoreInterface;
 
-    /**
-     * Decodes a base64-encoded string into raw bytes.
-     *
-     * @remarks
-     * Pure JS implementation — no `Buffer`, no `atob` (DOM-only) — so it runs
-     * identically in Node and browser environments. Whitespace and `=` padding
-     * are ignored; invalid characters are skipped.
-     *
-     * @param text - Base64-encoded input string
-     * @returns Decoded bytes
-     *
-     * @example
-     * ```ts
-     * decodeBase64('aGVsbG8=') // Uint8Array [104, 101, 108, 108, 111]
-     * ```
-     */
-    export declare function decodeBase64(text: string): Uint8Array;
-
     /**
      * Derives an unused lower camel case secret parameter name from an accessible name.
      * @param name - Accessible name of the control
@@ -5417,23 +4733,31 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function deriveBrowserToolSchema(schema: Readonly<Record<string, unknown>> | undefined): Readonly<Record<string, unknown>> | undefined;
 
+    /**
+     * Describes an element refusal, adding a fresh-reference instruction for `GONE`.
+     *
+     * @param subject - Element reference or named subject
+     * @param reason - Reason the operation was refused
+     * @param detail - Specific explanation replacing the default reason text
+     * @returns The refusal message with its final punctuation
+     *
+     * @example
+     * ```ts
+     * describeBrowserRefusal('e4', 'GONE')
+     * // 'Element [ref=e4] is gone because the page changed; call read for fresh refs.'
+     * ```
+     */
+    export declare function describeBrowserRefusal(subject: string | BrowserElementSubject, reason: BrowserElementReason, detail?: string): string;
+
     /**
      * Applies an ordered edit batch to a copy and validates its nonempty result and final bindings.
      * @param journey - Valid journey to edit
      * @param edits - Edits in application order
      * @returns The edited journey, with unbound parameters removed
-     * @throws BrowserError - Thrown with BROWSER_JOURNEY_EDIT, a one-based index, and a reason clause when the batch fails
+     * @throws BrowserError - Thrown with JOURNEY_EDIT, a one-based index, and a reason clause when the batch fails
      */
     export declare function editBrowserJourney(journey: BrowserJourney, edits: readonly BrowserJourneyEdit[]): BrowserJourney;
 
-    /**
-     * Encodes raw bytes as base64 without relying on Node or DOM globals.
-     *
-     * @param bytes - Raw input bytes
-     * @returns Base64 text
-     */
-    export declare function encodeBase64(bytes: Uint8Array): string;
-
     /**
      * Extracts a keyboard chord such as `Control+Shift+P` into its parts, throwing a
      * `BrowserError` on an empty chord or an unsupported modifier.
@@ -5478,6 +4802,13 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function filterBrowserOutline(nodes: readonly BrowserOutlineNode[], query: BrowserElementQuery): readonly BrowserOutlineNode[];
 
+    /** Finds the first line contributing a whitespace-normalized match across consecutive text spans.
+     * @param lines - Wrapped projection
+     * @param text - Visible text to locate
+     * @returns One-based opening line, or 1 when no match exists
+     */
+    export declare function findBrowserText(lines: readonly BrowserLine[], text: string): number;
+
     /**
      * Generates a run id from an ISO timestamp and a cryptographic hexadecimal suffix.
      * @returns An ISO timestamp with hyphens replacing colons, followed by four hexadecimal digits
@@ -5485,25 +4816,9 @@ export declare interface BrowserRunStoreInterface {
     export declare function generateBrowserRunId(): string;
 
     /**
-     * Narrows an unknown value to a `BrowserConnectionError`.
-     *
-     * @param value - Value to check
-     * @returns True if value is a BrowserConnectionError instance; false otherwise
-     */
-    export declare function isBrowserConnectionError(value: unknown): value is BrowserConnectionError;
-
-    /**
-     * Checks whether a value is an element refusal.
-     * @param value - Caught value
-     * @returns True if the value is an element error; false otherwise
-     */
-    export declare function isBrowserElementError(value: unknown): value is BrowserElementError;
-
-    /**
-     * Narrows an unknown value to a `BrowserError`.
-     *
+     * Checks whether a value is a browser error.
      * @param value - Value to check
-     * @returns True if value is a BrowserError instance; false otherwise
+     * @returns True if the value is a browser error; false otherwise
      */
     export declare function isBrowserError(value: unknown): value is BrowserError;
 
@@ -5562,12 +4877,19 @@ export declare interface BrowserRunStoreInterface {
     export declare function isBrowserNodeVisible(node: BrowserNode): boolean;
 
     /**
-     * Narrows an unknown value to a `BrowserResultLimitError`.
+     * Checks whether a value exposes the page capabilities used by a browser toolset.
      *
-     * @param value - Value to check
-     * @returns True if value is a BrowserResultLimitError instance; false otherwise
+     * @remarks
+     * Reads structural members, including inherited accessors, without invoking page operations.
+     * A trusted view alone is insufficient. Hostile getters and revoked proxies return false.
+     *
+     * @param value - The candidate page or view
+     * @returns True if the value exposes the page's protocol and toolset capabilities; false otherwise
+     * @example
+     * isBrowserPage(page) // true
+     * isBrowserPage(view) // false for a DOM document view
      */
-    export declare function isBrowserResultLimitError(value: unknown): value is BrowserResultLimitError;
+    export declare function isBrowserPage(value: unknown): value is BrowserPageInterface;
 
     /**
      * Checks whether a step binds a declared secret through type.text.
@@ -5586,35 +4908,11 @@ export declare interface BrowserRunStoreInterface {
 
     /**
      * Checks whether a value is a journey step error.
-     * @param value - Caught value
+     * @param value - Value to check
      * @returns True if the value is a step error; false otherwise
      */
     export declare function isBrowserStepError(value: unknown): value is BrowserStepError;
 
-    /**
-     * Narrows an unknown value to a `CDPConnectionError`.
-     *
-     * @param value - Value to check
-     * @returns True if value is a CDPConnectionError instance; false otherwise
-     */
-    export declare function isCDPConnectionError(value: unknown): value is CDPConnectionError;
-
-    /**
-     * Narrows an unknown value to a `CDPError`.
-     *
-     * @param value - Value to check
-     * @returns True if value is a CDPError instance; false otherwise
-     */
-    export declare function isCDPError(value: unknown): value is CDPError;
-
-    /**
-     * Narrows an unknown value to a `CDPTimeoutError`.
-     *
-     * @param value - Value to check
-     * @returns True if value is a CDPTimeoutError instance; false otherwise
-     */
-    export declare function isCDPTimeoutError(value: unknown): value is CDPTimeoutError;
-
     /**
      * Normalizes one key to CDP keyboard event data.
      *
@@ -5676,32 +4974,26 @@ export declare interface BrowserRunStoreInterface {
     export declare class MemoryBrowserJourneyStore implements BrowserJourneyStoreInterface {
         #private;
         get(name: string, options?: BrowserStoreOptions): Promise<BrowserJourneyRevision | undefined>;
-        set(journey: BrowserJourney, expected?: number, options?: BrowserStoreOptions): Promise<BrowserJourneyRevision>;
+        set(journey: BrowserJourney, options?: BrowserJourneyWriteOptions): Promise<BrowserJourneyRevision>;
         delete(name: string, options?: BrowserStoreOptions): Promise<void>;
-        list(options?: BrowserStoreOptions & {
-            readonly offset?: number;
-            readonly limit?: number;
-        }): Promise<BrowserStorePage<BrowserJourneyRevision>>;
+        list(options?: BrowserStorePageOptions): Promise<BrowserStorePage<BrowserJourneyRevision>>;
     }
 
     /**
      * Keeps owned runs under their journey names and producer ids without directories.
      * @example
      * const store = new MemoryBrowserRunStore()
-     * const slot = await store.open('add-kettle')
+     * const slot = await store.create('add-kettle')
      */
     export declare class MemoryBrowserRunStore implements BrowserRunStoreInterface {
         #private;
-        open(name: string, options?: BrowserStoreOptions): Promise<BrowserRunSlot>;
+        create(name: string, options?: BrowserStoreOptions): Promise<BrowserRunSlot>;
         get(name: string, id: string, options?: BrowserStoreOptions): Promise<BrowserRun | undefined>;
         set(run: BrowserRun, options?: BrowserStoreOptions): Promise<void>;
         capture(slot: BrowserRunSlot, _name: string, _bytes: Uint8Array, options?: BrowserStoreOptions): Promise<string | undefined>;
         delete(name: string, id: string, options?: BrowserStoreOptions): Promise<void>;
         clear(name: string, options?: BrowserStoreOptions): Promise<number>;
-        list(name: string, options?: BrowserStoreOptions & {
-            readonly offset?: number;
-            readonly limit?: number;
-        }): Promise<BrowserStorePage<BrowserRun>>;
+        list(name: string, options?: BrowserStorePageOptions): Promise<BrowserStorePage<BrowserRun>>;
     }
 
     /**
@@ -5924,6 +5216,13 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function parseBrowserTool(value: unknown): BrowserTool | undefined;
 
+    /**
+     * Parses an integer or a canonical unsigned decimal string for a tool coordinate.
+     * @param value - The supplied coordinate
+     * @returns The integer, or undefined when the value or spelling is invalid
+     */
+    export declare function parseBrowserToolInteger(value: unknown): number | undefined;
+
     /**
      * Coerces one WebSocket frame event to a `BrowserWebSocketFrame`, or
      * `undefined` off-shape.
@@ -6094,7 +5393,7 @@ export declare interface BrowserRunStoreInterface {
 
     /**
      * Decodes a CDP `DOMSnapshot.captureSnapshot` result into a serializable
-     * `BrowserSnapshotInput`, throwing a `BrowserError` off-shape and a `BrowserResultLimitError`
+     * `BrowserSnapshotInput`, throwing a `BrowserError` off-shape and a `BrowserError`
      * past the configured node limit.
      *
      * @param value - Unknown CDP result
@@ -6153,7 +5452,7 @@ export declare interface BrowserRunStoreInterface {
      * @param args - The arguments a model supplied
      * @param key - The parameter name
      * @returns The string the argument holds
-     * @throws Thrown as a `BrowserError` coded `BROWSER_TOOLSET_ARGUMENT` when the argument is not a
+     * @throws Thrown as a `BrowserError` coded `ARGUMENT` when the argument is not a
      * string.
      *
      * @example
@@ -6177,7 +5476,7 @@ export declare interface BrowserRunStoreInterface {
 
     /**
      * Decodes one CDP `Runtime.evaluate` result, throwing a `BrowserError` on a failed evaluation
-     * and a `BrowserResultLimitError` past the guarded result size.
+     * and a `BrowserError` past the guarded result size.
      *
      * @param value - Unknown CDP result
      * @returns The returned by-value payload, or undefined
@@ -6212,22 +5511,38 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function readRareStringData(value: unknown, strings: readonly string[]): ReadonlyMap<number, string>;
 
+    /** Redacts registered secrets before projection wrapping or output clipping.
+     * @param text - Unbounded text
+     * @param secrets - Registered secret values
+     * @returns Text with literal and JSON-escaped secret occurrences replaced
+     */
+    export declare function redactBrowserText(text: string, secrets: readonly string[]): string;
+
     /**
-     * Renders an element as its outline row reads: reference, role, and quoted name.
+     * Renders an element as its outline row reads: role, quoted name, and reference.
      *
      * @param element - The referenced element
-     * @returns The element's reference, role, and JSON-quoted name
+     * @returns The role, optional JSON-quoted name, and `[ref=eN]` reference
      *
      * @example
      * ```ts
      * import { renderBrowserElement } from '@orkestrel/browser'
      *
      * const element = page.elements.element('e4')
-     * if (element !== undefined) renderBrowserElement(element) // 'e4 button "Place order"'
+     * if (element !== undefined) renderBrowserElement(element) // 'button "Place order" [ref=e4]'
      * ```
      */
     export declare function renderBrowserElement(element: BrowserElementInterface): string;
 
+    /** Renders an exact addressed-range footer, including the next line when content remains.
+     * @param from - First returned line
+     * @param to - Last returned line
+     * @param total - Total projected lines
+     * @param tool - Tool that serves the continuation. Default: read
+     * @returns Complete footer
+     */
+    export declare function renderBrowserFooter(from: number, to: number, total: number, tool?: string): string;
+
     /**
      * Renders a journey with its parameter declarations and stable step ids.
      * @param journey - Valid journey
@@ -6244,82 +5559,33 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function renderBrowserJourneyFault(fault: BrowserStoreFault): string;
 
-    /**
-     * 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'
-     * ```
+    /** Joins a projected line's spans without adding an address.
+     * @param line - Projected line
+     * @returns Rendered content
      */
-    export declare function renderBrowserMatches(heading: string, rows: readonly string[], room: number): string;
+    export declare function renderBrowserLine(line: BrowserLine): string;
 
-    /**
-     * 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`.
-     *
+    /** Renders document-order accessibility lines with a bounded element count.
      * @param url - Document address
      * @param title - Document title
-     * @param nodes - Ordered accessibility rows
-     * @param limit - Maximum referenced rows to include
-     * @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
-     *
+     * @param nodes - Ordered accessibility nodes from one capture
+     * @param limit - Maximum referenced elements
+     * @param secrets - Registered text to redact before wrapping
+     * @returns Wrapped lines, element counts, and the focused element
      * @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"'
+     * const outline = renderBrowserOutline('https://shop.example/', 'Shop', [], 150)
+     * outline.lines // []
      * ```
      */
-    export declare function renderBrowserOutline(url: string, title: string, nodes: readonly BrowserOutlineNode[], limit: number, search?: string): BrowserOutline;
+    export declare function renderBrowserOutline(url: string, title: string, source: readonly BrowserOutlineNode[], limit: number, secrets?: readonly string[]): BrowserOutline;
 
     /**
-     * Renders one outline row: the node's reference, its role, its quoted accessible name, and the
-     * states it carries.
+     * Renders one outline row: the node's role, quoted accessible name, reference, and states.
      *
      * @remarks
-     * After the name the row appends `value="V"` when the node carries a non-empty value,
+     * The reference renders as `[ref=eN]` after the name, or after the role when the name is empty.
+     * After the reference 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.
@@ -6345,11 +5611,27 @@ export declare interface BrowserRunStoreInterface {
      * 	properties: { checked: 'true' },
      * 	session: 'main',
      * 	reference: 'e4',
-     * }) // 'e4 checkbox "Gift wrap" [checked]'
+     * }) // 'checkbox "Gift wrap" [ref=e4] [checked]'
      * ```
      */
     export declare function renderBrowserOutlineRow(node: BrowserOutlineNode): string;
 
+    /** Renders a bounded window with numbered rows and an exact continuation.
+     * @remarks A partial-view line follows the page header when rows remain after the window.
+     * A changed projection carries its change note even from line 1. A search missing its range
+     * reports the first page-wide best match only when that line carries an element reference,
+     * without moving the window; otherwise it keeps the plain miss. Its query is abbreviated
+     * to 120 UTF-16 units. The miss sentence is reserved with the minimum window; when the whole
+     * quoted row cannot also fit, only the sentence is shown, ending with a period.
+     * An unquoted miss is reserved before fitting and appears immediately before the footer.
+     * Quoted best matches and in-range hits remain under the header.
+     * @param passage - Projection and contextual metadata
+     * @param limit - Whole-result character room
+     * @returns A complete window
+     * @throws Thrown when the range is invalid or room cannot hold metadata and a complete row
+     */
+    export declare function renderBrowserPassage(passage: BrowserPassage, limit: number): string;
+
     /**
      * Renders a tool receipt: the action and its status on one line, the interrupting dialog, then
      * a blank line and the fresh view.
@@ -6368,14 +5650,22 @@ export declare interface BrowserRunStoreInterface {
      * import { renderBrowserReceipt } from '@orkestrel/browser'
      *
      * renderBrowserReceipt({
-     * 	action: 'Clicked e7 button "Delete"',
+     * 	action: 'Clicked button "Delete" [ref=e7]',
      * 	dialog: { category: 'confirm', message: 'Delete the draft?' },
      * })
-     * // 'Clicked e7 button "Delete". A confirm dialog is open: "Delete the draft?"; call dialog.'
+     * // 'Clicked button "Delete" [ref=e7]. A confirm dialog is open: "Delete the draft?"; call dialog.'
      * ```
      */
     export declare function renderBrowserReceipt(receipt: BrowserReceipt): string;
 
+    /** Fits an unnumbered receipt and a complete page window inside one result limit.
+     * @param passage - Redacted projection and metadata, with the opening line already selected
+     * @param receipt - Redacted unnumbered status
+     * @param limit - Whole-result character room
+     * @returns Receipt followed by complete addressed rows and their exact footer
+     */
+    export declare function renderBrowserReceiptWindow(passage: BrowserPassage, receipt: string, limit: number): string;
+
     /**
      * Renders a run heading and its receipts, followed by the supplied final view.
      * @param run - Run to render
@@ -6391,6 +5681,23 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function renderBrowserRunResult(result: string): string;
 
+    /** Renders shared search text and chooses its context line within the requested range.
+     * @remarks A miss names `to` when it ends before the last line; an unbounded miss keeps its usual wording.
+     * @param lines - Wrapped projection
+     * @param from - Inclusive first candidate line
+     * @param to - Inclusive last candidate line
+     * @param search - Optional words to find
+     * @returns Opening line and optional match or miss text
+     */
+    export declare function renderBrowserSearch(lines: readonly BrowserLine[], from: number, to?: number, search?: string): BrowserSearch;
+
+    /** Renders an element as searchable text separated from references and syntax.
+     * @param node - Captured element
+     * @param url - Owning document address
+     * @returns Ordered row spans
+     */
+    export declare function renderBrowserSpans(node: BrowserOutlineNode, url: string): readonly BrowserLineSpan[];
+
     /**
      * Renders tool strings unchanged, content-array text blocks joined, and other values as bounded JSON.
      * @param value - Untrusted tool output
@@ -6398,14 +5705,28 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function renderBrowserToolOutput(value: unknown): string;
 
+    /** Selects whole addressed rows after reserving the header and exact footer.
+     * @remarks The partial switch reserves a partial-view line before selecting rows, independently of header text.
+     * A trailing heading opens the next window unless it is the only row or ends the page.
+     * @param lines - Complete projection
+     * @param from - Inclusive first line
+     * @param to - Inclusive last line, or the default window
+     * @param header - Bounded preceding text
+     * @param limit - Whole-result room
+     * @param tool - Continuation tool. Default: read
+     * @param partial - Whether to show a partial-view line after the first header line. Default: false
+     * @returns A complete bounded result
+     */
+    export declare function renderBrowserWindow(lines: readonly BrowserLine[], from: number, to: number | undefined, header: string, limit: number, tool?: string, partial?: boolean): string;
+
     /**
      * Requires a tool argument to be an element reference in any spelling `parseBrowserReference`
      * accepts, and returns its canonical form.
      *
      * @param value - The argument a model supplied
      * @returns The canonical reference, such as `e12`
-     * @throws Thrown as a `BrowserElementError` with reason `UNKNOWN` when the value is not a
-     * reference, naming `look` as the next call.
+     * @throws Thrown as a `BrowserError` with reason `UNKNOWN` when the value is not a
+     * reference, naming `read` as the next call.
      *
      * @example
      * ```ts
@@ -6434,60 +5755,14 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function resolveBrowserJourneyBinding(value: unknown, inputs: Readonly<Record<string, string>>): string;
 
-    /**
-     * 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']
-     * ```
-     */
-    export declare function scanBrowserOutline(nodes: readonly BrowserOutlineNode[], search: string): readonly BrowserOutlineNode[];
-
-    /**
-     * 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' }]
-     * ```
+    /** Finds the highest-scoring text lines within an inclusive range using whole words and prefixes.
+     * @param lines - Complete wrapped projection
+     * @param search - Words to find
+     * @param from - First candidate line. Default: 1
+     * @param to - Last candidate line. Default: the end
+     * @returns One-based best-scoring line numbers
      */
-    export declare function scanBrowserText(text: string, search: string): readonly BrowserReadMatch[];
+    export declare function scanBrowserLines(lines: readonly BrowserLine[], search: string, from?: number, to?: number): readonly number[];
 
     /**
      * Awaits every teardown step in order and returns the first failure.
@@ -6517,9 +5792,6 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function settleBrowserTeardown(...steps: readonly BrowserTeardownFunction[]): Promise<unknown>;
 
-    /** Encodes UTF-8 text as bytes. */
-    export declare function textToBytes(value: string): Uint8Array;
-
     /**
      * Validates Accessibility-domain snapshot bounds.
      *
@@ -6532,7 +5804,7 @@ export declare interface BrowserRunStoreInterface {
      *
      * @param options - Public context configuration
      */
-    export declare function validateBrowserContextOptions(options?: BrowserContextOptions): void;
+    export declare function validateBrowserContextOptions(options?: BrowserIsolateOptions): void;
 
     /**
      * Validates context emulation boundaries before partial application.
@@ -6562,7 +5834,7 @@ export declare interface BrowserRunStoreInterface {
     /**
      * Validates the journey format and its name, nonempty steps, ids, bindings, secrets, JSON, and actions.
      * @param value - Candidate journey
-     * @throws BrowserError - Thrown with BROWSER_JOURNEY_FORMAT for an unknown format, or BROWSER_JOURNEY_INVALID naming the failed invariant
+     * @throws BrowserError - Thrown with STORE_FORMAT for an unknown format, or JOURNEY_INVALID naming the failed invariant
      */
     export declare function validateBrowserJourney(value: unknown): asserts value is BrowserJourney;
 
@@ -6576,7 +5848,7 @@ export declare interface BrowserRunStoreInterface {
     /**
      * Checks a journey name before store access.
      * @param name - Journey name
-     * @throws BrowserError - Thrown with BROWSER_JOURNEY_PATH when the name is invalid
+     * @throws BrowserError - Thrown with STORE_PATH when the name is invalid
      * @example
      * validateBrowserJourneyName('add-kettle')
      */
@@ -6596,6 +5868,33 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function validateBrowserJourneyStep(value: unknown): asserts value is BrowserJourneyStepInput;
 
+    /**
+     * Validates the mutually exclusive conditions of a journey write before side effects.
+     * @param options - Conditional write and cancellation options
+     * @throws Thrown with ARGUMENT for conflicting conditions or an invalid revision.
+     * @example
+     * validateBrowserJourneyWriteOptions({ exclusive: true })
+     */
+    export declare function validateBrowserJourneyWriteOptions(options?: BrowserJourneyWriteOptions): void;
+
+    /** Refuses invalid line coordinates before selecting content.
+     * @param from - Inclusive first line
+     * @param to - Optional inclusive last line
+     * @param total - Available lines, when captured
+     * @returns Nothing
+     */
+    export declare function validateBrowserLines(from: number, to?: number, total?: number): void;
+
+    /**
+     * Refuses work on a disconnected or closed page.
+     * @param page - The page whose lifecycle permits the operation
+     * @param client - The client's connection carrying the page
+     * @throws Thrown with CLOSED when the client disconnected or the page closed.
+     * @example
+     * validateBrowserPageOpen(page, client)
+     */
+    export declare function validateBrowserPageOpen(page: BrowserPageInterface, client: CDPClientInterface): void;
+
     /**
      * Validates viewport input coordinates.
      *
@@ -6625,7 +5924,7 @@ export declare interface BrowserRunStoreInterface {
      * Checks the offset and limit of a store page.
      * @param offset - Nonnegative safe integer offset
      * @param limit - Positive safe integer limit
-     * @throws BrowserError - Thrown with BROWSER_JOURNEY_ARGUMENT when either bound is invalid
+     * @throws BrowserError - Thrown with ARGUMENT when either bound is invalid
      * @example
      * validateBrowserStorePage(0, 10)
      */
@@ -6645,15 +5944,15 @@ export declare interface BrowserRunStoreInterface {
      * @param definition - The advertised tool definition whose `parameters.properties` names the
      * accepted keys
      * @param args - The arguments a model supplied
-     * @throws Thrown as a `BrowserError` coded `BROWSER_TOOLSET_ARGUMENT`, with the refused key in its
+     * @throws Thrown as a `BrowserError` coded `ARGUMENT`, with the refused key in its
      * context, when an argument key is not an advertised parameter.
      *
      * @example
      * ```ts
      * import { BROWSER_TOOL_COPY, validateBrowserToolArguments } from '@orkestrel/browser'
      *
-     * validateBrowserToolArguments(BROWSER_TOOL_COPY.look, { search: 'cart', ref: 'e1' })
-     * // throws 'The look tool takes no ref parameter; call look with search and offset.'
+     * validateBrowserToolArguments(BROWSER_TOOL_COPY.read, { search: 'cart', ref: 'e1' })
+     * // throws 'The read tool takes no ref parameter; call read with from, to, and search.'
      * ```
      */
     export declare function validateBrowserToolArguments(definition: ToolDefinition, args: Readonly<Record<string, unknown>>): void;
@@ -6665,4 +5964,11 @@ export declare interface BrowserRunStoreInterface {
      */
     export declare function validateBrowserViewport(viewport: BrowserViewport): void;
 
+    /** Wraps spans before numbering, marking hard continuations with a leading ↳.
+     * @remarks A soft wrap breaks before the end of a name rather than before its reference span.
+     * @param line - Unwrapped semantic row
+     * @returns Lines no wider than the projection width, preserving code points and reference tokens
+     */
+    export declare function wrapBrowserLine(line: BrowserLine): readonly BrowserLine[];
+
     export { }