@orkestrel/browser 0.0.28 → 0.0.30

package/dist/bin/main.js

@@ -2,7 +2,7 @@
 import { parseBoolean, parseInteger } from "@orkestrel/contract";
 import { BrowserError, isBrowserError } from "../src/core/index.js";
 import { createBrowserMCPServer, parseBrowserViewport } from "../src/server/index.js";
-//#region src/bin/main.ts
+// src/bin/main.ts
 process.stderr.on("error", () => {
 	process.exitCode = 1;
 });
@@ -55,6 +55,5 @@ try {
 	console.error(`browse: ${error.code}: ${error.message.split(/\r\n|\n/u).join(" ")}`);
 	process.exitCode = 1;
 }
-//#endregion
 
 //# sourceMappingURL=main.js.map

package/dist/src/browser/index.d.ts

@@ -1,8 +1,9 @@
 import type { BrowserCallOptions } from '@orkestrel/browser';
+import type { BrowserContentInput } from '@orkestrel/browser';
+import type { BrowserContentInterface } from '@orkestrel/browser';
 import type { BrowserElementInterface } from '@orkestrel/browser';
 import type { BrowserElementManagerInterface } from '@orkestrel/browser';
-import type { BrowserReadingInput } from '@orkestrel/browser';
-import type { BrowserReadingInterface } from '@orkestrel/browser';
+import type { BrowserOutlineNode } from '@orkestrel/browser';
 import type { BrowserViewInterface } from '@orkestrel/browser';
 import type { BrowserWaitOptions } from '@orkestrel/browser';
 import type { CDPTransportEventMap } from '@orkestrel/browser';
@@ -71,6 +72,47 @@ export declare const BROWSER_SELECTED_ROLES: ReadonlySet<string>;
 /** Names the `input` type states whose value an untrusted `fill` sets as typed text. */
 export declare const BROWSER_TYPED_INPUTS: ReadonlySet<string>;
 
+/** Reads the next ancestor, ending at the platform's null boundary. */
+export declare type BrowserAncestorReader<T> = (node: T) => T | null;
+
+/** Traverses ancestors lazily while retaining the previously yielded node. */
+export declare class BrowserAncestors<T> extends Iterator<T, undefined> {
+    #private;
+    constructor(node: T | null, parent: BrowserAncestorReader<T>);
+    next(): IteratorResult<T, undefined>;
+    get previous(): T | null;
+}
+
+/** Retains the sibling pointers read before a capture prunes its copy. */
+export declare interface BrowserCaptureCursor {
+    readonly child: Node | null;
+    readonly mirror: Node | null;
+    readonly element: Element | null;
+    readonly counterpart: Element | null;
+}
+
+/** Pairs the current live and inert nodes during sibling traversal. */
+export declare interface BrowserCaptureSibling {
+    readonly child: Node;
+    readonly mirror: Node;
+    readonly element: Element | null;
+    readonly counterpart: Element | null;
+}
+
+/** Traverses paired live and inert siblings while preserving pointers across pruning. */
+export declare class BrowserCaptureSiblings extends Iterator<BrowserCaptureSibling, undefined> {
+    #private;
+    constructor(live: Element, twin: Element);
+    next(): IteratorResult<BrowserCaptureSibling, undefined>;
+}
+
+/** Carries rendered lines, fragments, or a container retained by a capture. */
+export declare interface BrowserCaptureValue {
+    readonly fragments?: readonly Node[];
+    readonly lines?: readonly string[];
+    readonly container?: boolean;
+}
+
 /**
  * Provides DOM actions through a stable element reference, without trusted input.
  *
@@ -83,6 +125,38 @@ export declare const BROWSER_TYPED_INPUTS: ReadonlySet<string>;
 export declare interface BrowserDOMElementInterface extends BrowserElementInterface {
 }
 
+/** Captures one flat-tree subtree while retaining its text and visibility state. */
+export declare class BrowserDOMOutline implements BrowserDOMOutlineInterface {
+    #private;
+    constructor(input: BrowserDOMOutlineInput);
+    capture(): void;
+}
+
+/** Supplies the document subtree, row sinks, and traversal operations for an outline. */
+export declare interface BrowserDOMOutlineInput {
+    readonly root: Element | ShadowRoot;
+    readonly rows: BrowserOutlineNode[];
+    readonly muted: boolean;
+    readonly positions: WeakMap<Node, string>;
+    readonly watch: (document: Document) => void;
+    readonly walk: (root: Element | ShadowRoot, rows: BrowserOutlineNode[], muted: boolean) => void;
+    readonly text: (rows: BrowserOutlineNode[], text: string, parent?: Node) => void;
+    readonly row: (element: Element, role: string, view: Window & typeof globalThis, id: string) => BrowserOutlineNode;
+}
+
+/** Captures the rows of one document subtree. */
+export declare interface BrowserDOMOutlineInterface {
+    /** Appends the captured rows through the supplied outline operations. */
+    capture(): void;
+}
+
+/** Observes whether one form submission dispatches its submit event. */
+export declare class BrowserDOMSubmission implements EventListenerObject {
+    #private;
+    get submitted(): boolean;
+    handleEvent(): void;
+}
+
 /**
  * Reads and drives a DOM document from a realm that can reach it, without trusted input.
  *
@@ -116,7 +190,7 @@ export declare class BrowserDOMView implements BrowserDOMViewInterface {
     get trusted(): boolean;
     get elements(): BrowserElementManagerInterface<BrowserDOMElementInterface>;
     title(options?: BrowserCallOptions): Promise<string>;
-    read(options?: BrowserCallOptions): Promise<BrowserReadingInterface>;
+    read(options?: BrowserCallOptions): Promise<BrowserContentInterface>;
     wait(text: string, options?: BrowserWaitOptions): Promise<void>;
     destroy(): void;
 }
@@ -568,8 +642,8 @@ export declare function readBrowserBlock(element: Element | null, root: Node): N
  * @remarks
  * The measure is the length of `JSON.stringify({ url, title, html })`, the form the CDP capture
  * guard compares with `BROWSER_RESULT_LIMIT`, so a character JSON escapes counts as its escape
- * sequence. A reading a caller builds with `createBrowserReading` passes through no limit.
- * {@link BrowserReadingInput} defines the inert capture, lowering, redaction, and limits.
+ * sequence. A reading a caller builds with `createBrowserContent` passes through no limit.
+ * {@link BrowserContentInput} defines the inert capture, lowering, redaction, and limits.
  *
  * @param node - The root whose rendered markup is captured; its owner document supplies `URL`
  * and `title`
@@ -577,7 +651,13 @@ export declare function readBrowserBlock(element: Element | null, root: Node): N
  * @throws Thrown as a `BrowserError` when the serialized capture is longer than
  * `BROWSER_RESULT_LIMIT` characters, with `length` and `limit` in its context.
  */
-export declare function readBrowserCapture(node: Element): BrowserReadingInput;
+export declare function readBrowserCapture(node: Element): BrowserContentInput;
+
+/** Checks shadow-slot ancestors for capture omission without skipping style reads. */
+export declare function readBrowserCaptureOmission(live: Element, child: Node, view: (Window & typeof globalThis) | null, rendered: boolean, excluded: boolean): boolean;
+
+/** Derives rendered form values and SVG fragments for an inert capture. */
+export declare function readBrowserCaptureValue(live: Element, twin: Element, view: Window & typeof globalThis, inert: Document, invisible: boolean, tag: string): BrowserCaptureValue | undefined;
 
 /**
  * Reads the untrimmed text an element's content contributes to an accessible name, in the flat