@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/page.d.ts

@@ -0,0 +1,1166 @@
+/** The page module of the 1.1.88 consolidation: every correlated variation of the page logic interned in this one file, so the module family carries one surface without duplicate variations. */
+import type { capabilityreport, toolstep, keyholdstate, columnspec, datasetrow, sourceref, transformrule, loglevel, bannerreport, listpattern, dialogpolicy, fielderror, fieldkind, fieldmatch, formrecord, formentry, retryrule, navtarget, urlpattern, waitprofile, authrecord, curatedlink, redirectchain, ratelimit, ratelimitstate, safetyverdict, a11ynode, readerarticle, pointpath, speedprofile, clickablemap, resolvedtarget, targetmode, diffentry, jsonstate, mutationevent, mutationwatch, selectorcandidate, wizardstate } from "./types.js";
+/**
+ * Browser-level command surface for reviewed steps.
+ * Every correlated rule for tab, window, zoom, snapshot and download actions plus capability negotiation lives in this file.
+ */
+export type browserresult = {
+    ok: boolean;
+    summary: string;
+    details?: Record<string, unknown>;
+};
+/** True when the kind executes against browser-level surfaces instead of the page. */
+export declare function isbrowserkind(kind: string): boolean;
+/** Builds the live capability report from the optional permissions the user granted. */
+export declare function readcapabilities(): Promise<capabilityreport>;
+/** Executes one reviewed browser-level action kind against the live browser. */
+export declare function runbrowseraction(step: toolstep, sessiontabid: number, windowid: number): Promise<browserresult>;
+/**
+ * Mutating page interactions for reviewed steps.
+ * Every correlated rule for pointer, key, drag, upload, form, attribute, storage and evaluation actions lives in this file.
+ */
+export type stepresult = {
+    ok: boolean;
+    summary: string;
+    details?: Record<string, unknown>;
+};
+/** Runs one mutating page action after the background policy gate and a fresh target check. */
+export declare function runpageaction(step: toolstep, target: Element | null): stepresult | Promise<stepresult>;
+/**
+ * Field and control interactions for reviewed steps.
+ * Every correlated rule for timed typing, value setting, key holds, search submission, multi selects, radio choices, sliders, dates, colors, details sections and the hold registry lives in this file.
+ */
+/** Builds the per keystroke schedule of one reviewed typetime step. */
+export declare function typetimeschedule(text: string, delay: number): Array<{
+    key: string;
+    delay: number;
+}>;
+/** Appends reviewed text to the current field value. */
+export declare function appendvalue(current: string, addition: string): string;
+/** Event order delivered after one reviewed value change. */
+export declare function valueevents(): string[];
+/** Splits reviewed multi select values into present and missing entries against the declared options. */
+export declare function multichoices(values: string[], options: Array<{
+    value: string;
+    label: string;
+}>): {
+    present: string[];
+    missing: string[];
+};
+/** Picks the reviewed radio input by value or label from one radio group; the index of the match or minus one. */
+export declare function radiochoice(inputs: Array<{
+    value: string;
+    label: string;
+}>, choice: string): number;
+/** Clamps one reviewed slider value to the declared range and step grid. */
+export declare function slidervalue(requested: number, min: number, max: number, step: number): number;
+/** Validates and normalizes one reviewed yyyy-mm-dd date. */
+export declare function datevalue(requested: string): string | null;
+/** Validates and normalizes one reviewed #rrggbb color. */
+export declare function colorvalue(requested: string): string | null;
+/** Decides whether one reviewed details section still needs opening. */
+export declare function expandstate(open: boolean): {
+    open: boolean;
+    changed: boolean;
+};
+/** Records one held key under its hold id; a repeated active hold id is refused. */
+export declare function presshold(holds: keyholdstate[], hold: keyholdstate): {
+    holds: keyholdstate[];
+    ok: boolean;
+};
+/** Releases one held key by hold id, keeping the release timestamp. */
+export declare function releasehold(holds: keyholdstate[], holdid: string, releasedat: number): {
+    holds: keyholdstate[];
+    released?: keyholdstate;
+};
+/** Returns the keys currently held, optionally filtered to one tab. */
+export declare function heldkeys(holds: keyholdstate[], tabid?: number): keyholdstate[];
+/** Runs one reviewed control interaction after the background policy gate and a fresh target check; frame routed steps receive their frame document as the root. */
+export declare function runpagecontrol(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Table and dataset logics for reviewed steps.
+ * Every correlated rule for header normalization, span expansion, nested table walking, pagination following, row hashing, transform expressions, dataset merging, row sampling and csv, json and excel serialization lives in this file.
+ */
+/** One raw table cell with its text, header flag, span geometry and an optional nested table. */
+export interface cellshape {
+    text: string;
+    header: boolean;
+    rowspan: number;
+    colspan: number;
+    nested?: {
+        selector: string;
+        rows: rowshape[];
+    };
+}
+/** One raw table row of span carrying cells. */
+export interface rowshape {
+    cells: cellshape[];
+    header: boolean;
+}
+/** One nested child table linked to the body row it belongs to. */
+export interface childtable {
+    parentrow: number;
+    selector: string;
+    columns: columnspec[];
+    rows: datasetrow[];
+}
+/** Result of the table reader: normalized column specs, keyed body rows and child datasets. */
+export interface gridresult {
+    columns: columnspec[];
+    rows: datasetrow[];
+    children: childtable[];
+}
+/** Trims, lowercases and slugifies one header cell into a stable column key. */
+export declare function normalizeheader(label: string): string;
+/** Builds one column spec from a header label with a unique stable key and the normalized name. */
+export declare function columnspecof(label: string, used?: Set<string>): columnspec;
+/** Classifies a column as number only when every non-empty value parses as a number. */
+export declare function classifycolumn(values: string[]): "text" | "number";
+/** Expands rowspan and colspan cells into a filled rectangular grid of values. */
+export declare function expandspans(rows: rowshape[]): string[][];
+/** Reads header and body rows into normalized column specs and keyed body rows, extracting nested tables into child datasets. */
+export declare function readgrid(rows: rowshape[]): gridresult;
+/** Resolves the next pagination control from numbered page entries: the entry after the current one or a next word control. */
+export declare function nextcontrol(entries: Array<{
+    text: string;
+    selector: string;
+    current: boolean;
+}>): string | undefined;
+/** True when the current row set contains at least one row the previous set did not carry. */
+export declare function rowsfresh(previous: datasetrow[], current: datasetrow[]): boolean;
+/** Computes a stable row hash over the reviewed keys; an empty key list hashes every column. */
+export declare function rowhash(row: datasetrow, keys: string[]): string;
+/** Deduplicates rows by reviewed keys, keeping the first occurrence of every key set. */
+export declare function dedupebykeys(rows: datasetrow[], keys: string[]): {
+    kept: datasetrow[];
+    removed: number;
+};
+/** Applies one reviewed transform expression to a value; unsupported expressions are refused. */
+export declare function applyexpression(value: string, expression: string): string;
+/** Applies reviewed transform rules to dataset rows, surfacing per rule errors and keeping the original values on failure. */
+export declare function transformrows(rows: datasetrow[], rules: transformrule[]): {
+    rows: datasetrow[];
+    errors: string[];
+};
+/** Merges datasets across pages: columns align by key with gaps filled empty and rows concatenate in page order. */
+export declare function mergedatasets(datasets: Array<{
+    columns: columnspec[];
+    rows: datasetrow[];
+}>): {
+    columns: columnspec[];
+    rows: datasetrow[];
+};
+/** Attaches the source url, timestamp and step ref to every row and returns the matching source refs. */
+export declare function samplerows(rows: datasetrow[], url: string, stepid: string, at: number): {
+    rows: datasetrow[];
+    sources: sourceref[];
+};
+/** Serializes columns and rows into csv text. */
+export declare function tocsv(columns: columnspec[], rows: datasetrow[], delimiter?: string): string;
+/** Parses csv text into headers and raw rows, honoring quoted fields and escaped quotes. */
+export declare function parsecsv(text: string, delimiter?: string): {
+    headers: string[];
+    rows: string[][];
+};
+/** Maps parsed csv headers onto dataset column specs through a reviewed mapping of csv names to target keys. */
+export declare function mapcolumns(headers: string[], mapping?: Record<string, string>): columnspec[];
+/** Serializes columns and rows into a json dataset payload. */
+export declare function tojson(columns: columnspec[], rows: datasetrow[]): string;
+/** Serializes columns and rows into an Excel SpreadsheetML 2003 workbook that Excel opens natively. */
+export declare function toexcel(columns: columnspec[], rows: datasetrow[], name: string): string;
+/** Runs one reviewed data step on the page: table scraping into datasets and pagination following with fresh row waits. */
+export declare function runpagedata(step: toolstep, target: Element | null, root?: Document): Promise<stepresult>;
+/** Exposes the pagination entries of the current document so plan review can suggest next controls. */
+export declare function pagepagination(root?: Document): Array<{
+    text: string;
+    selector: string;
+    current: boolean;
+}>;
+/** Queues one console line of the 1.1.78 forensic family for the next step completion flush; the line keeps its level, its masked text and its capture time. */
+export declare function queueconsoleentry(entry: {
+    level: loglevel;
+    text: string;
+    at: number;
+    reload?: number;
+}): void;
+/** Flushes the pending console entries of the 1.1.78 forensic family on step completion: the buffered console lines return once and the buffer empties, so the background consoletimeline stamps their run wide sequence numbers in capture order across page reloads. */
+export declare function flushconsole(): Array<{
+    level: string;
+    text: string;
+    source: string;
+    at: number;
+    reload?: number;
+}>;
+/** Parsed cdp step options: the enabled domains, the teardown plan, the raw command, the event rules with the watch window, the breakpoint, the step mode, the watch expression and the script override. */
+export interface cdpstepoptions {
+    domains: string[];
+    teardown?: {
+        revertsteps: string[];
+        resumepolicy: string;
+    };
+    command?: {
+        method: string;
+        params?: Record<string, unknown>;
+        resultpath?: string;
+    };
+    events?: Array<{
+        domain: string;
+        event: string;
+        match?: string;
+    }>;
+    watchwindow: number;
+    breakpoint?: {
+        url: string;
+        line: number;
+        column?: number;
+        condition?: string;
+    };
+    mode?: string;
+    expression?: {
+        expression: string;
+        scope: string;
+    };
+    override?: {
+        urlpattern: string;
+        source: string;
+    };
+}
+/** Parses the reviewed cdp options of one devtools protocol step through the shared cdpbus normalizers. */
+export declare function cdpstepoptions(step: toolstep): cdpstepoptions;
+/** Runs one reviewed devtools protocol step inside the page through the instrumented harness: the harness attaches and detaches cleanly, raw commands of the instrumented surface run with duration and error class, domain events observe through the console and navigation hooks, breakpoints pause instrumented probes, stepping advances the pause, watch expressions evaluate in the pause scope and script overrides apply the reviewed fixture. */
+export declare function runcdpstep(step: toolstep): Promise<stepresult>;
+/** Parsed debug watch options: the window, level floor, serialization depth, redaction patterns, spam rule, rotation rule and long task threshold. */
+export interface debugwatchoptions {
+    window: number;
+    level?: loglevel;
+    depth: number;
+    redact: string[];
+    spam?: {
+        pattern: string;
+        windowsize: number;
+        collapse: number;
+    };
+    rotation?: {
+        maxentries: number;
+        overflowtarget: string;
+    };
+    threshold: number;
+}
+/** Parses the reviewed debug watch options of one watch step; absent windows watch nothing and the depth bound defaults shallow. */
+export declare function debugwatchoptions(step: toolstep): debugwatchoptions;
+/** Runs one reviewed debugging watch inside the page: console methods are hooked, error and rejection listeners installed and the longtask buffer observed for the reviewed window; every hook detaches cleanly at the end. */
+export declare function rundebugwatch(step: toolstep): Promise<stepresult>;
+/**
+ * Page shape detection for reviewed steps.
+ * Every correlated rule for repeated list detection, table shape normalization, pagination estimates, infinite scroll ranges, virtualization, lazy images, sticky overlays, scroll locks, consent banner shapes, template classification, section fingerprints and scroll positions lives in this file.
+ */
+/** Serializable sibling sample of one container element used by the list detector. */
+export interface siblingsample {
+    container: string;
+    children: Array<{
+        tag: string;
+        classes: string;
+        text: string;
+        selector: string;
+    }>;
+}
+/** Finds repeated item lists with a shared item selector from sibling samples. */
+export declare function detectlistpatterns(samples: siblingsample[]): listpattern[];
+/** Normalizes one table row structure into header row, column specs and caption. */
+export declare function normalizetable(rows: Array<{
+    cells: string[];
+    header: boolean;
+}>, caption: string): {
+    headers: string[];
+    columns: Array<{
+        label: string;
+        cells: number;
+    }>;
+    rows: number;
+    caption: string;
+};
+/** Counts pagination entries and estimates the total page count from the numbers they carry. */
+export declare function paginationestimate(entries: Array<{
+    text: string;
+    selector: string;
+    current: boolean;
+}>): {
+    current: number;
+    total: number;
+    links: number;
+    pages: number[];
+};
+/** Serializable scroll range input of one scrollable container. */
+export interface scrollrangeshape {
+    selector: string;
+    scrollheight: number;
+    clientheight: number;
+    triggers: string[];
+}
+/** Flags infinite scroll containers from measured scroll ranges and their load more triggers. */
+export declare function infinitescrollranges(ranges: scrollrangeshape[]): Array<{
+    selector: string;
+    scrollrange: number;
+    triggers: string[];
+}>;
+/** Detects virtualized lists whose uniform rendered rows do not fill the measured scroll range. */
+export declare function virtualizedcontainers(containers: Array<{
+    selector: string;
+    scrollheight: number;
+    rows: Array<{
+        selector: string;
+        height: number;
+        classes: string;
+    }>;
+}>): Array<{
+    selector: string;
+    rendered: number;
+    estimated: number;
+}>;
+/** Serializable image shape used by the lazy detector. */
+export interface imageshape {
+    selector: string;
+    src: string;
+    datasrc: string;
+    loading: string;
+    width: number;
+    height: number;
+}
+/** Detects lazy loaded images from loading attributes and deferred sources, and placeholder states from inline data or empty sources. */
+export declare function lazysurvey(images: imageshape[]): {
+    lazy: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    placeholders: Array<{
+        selector: string;
+        reason: string;
+    }>;
+};
+/** Detects sticky headers and overlays from fixed and sticky geometry measured against the viewport. */
+export declare function overlaygeometry(elements: Array<{
+    selector: string;
+    position: string;
+    top: number;
+    height: number;
+    width: number;
+}>, viewport: {
+    width: number;
+    height: number;
+}): Array<{
+    selector: string;
+    position: string;
+    coverage: number;
+    hides: boolean;
+}>;
+/** Detects scroll locks and modal states from body overflow, body position and modal presence signals. */
+export declare function scrolllockstate(signals: {
+    bodyoverflow: string;
+    htmloverflow: string;
+    bodyposition: string;
+    modal: boolean;
+    scrollable: boolean;
+}): {
+    locked: boolean;
+    reasons: string[];
+    scrollable: boolean;
+};
+/** Serializable consent banner candidate collected by the banner watcher glue. */
+export interface bannercandidate {
+    selector: string;
+    id: string;
+    classes: string[];
+    text: string;
+    controls: string[];
+}
+/** Consent banner keywords the shape matcher recognizes across locales. */
+export declare const consentkeywords: string[];
+/** Matches consent banner shapes against the known keyword vocabulary and reports their controls. */
+export declare function bannermatches(candidates: bannercandidate[], at: number): bannerreport[];
+/** Classifies the page template from its dominant structural signals. */
+export declare function classifytemplate(signals: {
+    paragraphs: number;
+    headings: number;
+    lists: number;
+    tables: number;
+    forms: number;
+    inputs: number;
+    password: boolean;
+}): string;
+/** Computes a stable structural fingerprint of one page section from its tag, attributes, child count and text length. */
+export declare function sectionfingerprint(section: {
+    tag: string;
+    attributes: Record<string, string>;
+    children: number;
+    textlength: number;
+}): string;
+/** Normalizes the scroll position of the window and its scrollable containers with edge flags. */
+export declare function scrollreport(window: {
+    scrollx: number;
+    scrolly: number;
+    scrollheight: number;
+    clientheight: number;
+}, containers: Array<{
+    selector: string;
+    scrolltop: number;
+    scrollleft: number;
+    scrollheight: number;
+    clientheight: number;
+}>): {
+    window: {
+        x: number;
+        y: number;
+        attop: boolean;
+        atbottom: boolean;
+        height: number;
+    };
+    containers: Array<{
+        selector: string;
+        scrolltop: number;
+        scrollleft: number;
+        scrollrange: number;
+        atbottom: boolean;
+    }>;
+};
+/** Collects the sibling samples of one document for the list detector. */
+export declare function collectsiblings(root: Document): siblingsample[];
+/** Collects the data table structures of one document for the table shape normalizer. */
+export declare function collecttables(root: Document): Array<{
+    selector: string;
+    rows: Array<{
+        cells: string[];
+        header: boolean;
+    }>;
+    caption: string;
+}>;
+/** Collects the consent banner candidates of one document for the banner shape matcher. */
+export declare function collectbannercandidates(root: Document): bannercandidate[];
+/** Runs one page shape detection after the background policy gate; frame routed steps receive their frame document as the root. */
+export declare function runpagedetection(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Dialog policy logics for reviewed steps.
+ * Every correlated rule for policy parsing, dialog answers, main world handler installation and observed dialog harvesting lives in this file.
+ * The isolated world cannot override window.confirm, window.alert or window.prompt, so the background installs these wrappers through the scripting api in the main world.
+ */
+/** One dialog observed by the main world handler, recorded on the shared document. */
+export interface observeddialog {
+    dialog: string;
+    text: string;
+    result: string | boolean | null;
+    at: number;
+}
+/** Parses the reviewed dialog policy from step options; prompts need a reviewed answer. */
+export declare function parsedialogpolicy(step: toolstep): dialogpolicy | null;
+/** Decides how the reviewed policy answers one dialog kind; a prompt without a reviewed answer is dismissed. */
+export declare function dialoganswer(policy: dialogpolicy, dialog: "confirm" | "alert" | "prompt"): {
+    accept: boolean;
+    answer?: string;
+};
+/** Reads and clears the dialog log the main world handler recorded on the shared document. */
+export declare function harvestdialoglog(root: Document): observeddialog[];
+/** Installs confirm, alert and prompt wrappers in the page main world answering per the reviewed policy; runs through chrome.scripting with world main. */
+export declare function installdialoghandler(accept: boolean, answer: string, persistent: boolean): void;
+/** Returns the active blackbox patterns of the page registry for the stack capture filters. */
+export declare function activeblackboxpatterns(): string[];
+/** Runs one reviewed emulation step inside the page: the family of the kind decides the mask, the prior state is captured for the exact revert and the honest derivation note stays beside the result. */
+export declare function runemulationstep(step: toolstep): Promise<stepresult>;
+/** Reverts one emulation layer inside the page by restoring the captured prior state; the revert is idempotent for a context the navigation already destroyed. */
+export declare function revertemulationlayer(family: string, prior: Record<string, unknown> | undefined): {
+    ok: boolean;
+    summary: string;
+};
+/**
+ * Form field logics for reviewed steps.
+ * Every correlated rule for field matching, field kind classification, seeded value generation, native value fills, honeypot detection, login and template detection, error association and form record parsing lives in this file.
+ */
+/** One serializable form field shape resolved against the page controls. */
+export interface fieldshape {
+    selector: string;
+    tag: string;
+    type: string;
+    name: string;
+    label: string;
+    placeholder: string;
+    arialabel: string;
+    autocomplete: string;
+    options?: string[];
+}
+/** One surveyed field shape carrying the visibility, geometry and timing evidence the honeypot detector reads. */
+export interface fieldsurvey extends fieldshape {
+    hidden: boolean;
+    offscreen: boolean;
+    createdat?: number;
+}
+/** One honeypot field flagged by hidden, offscreen or time trap evidence. */
+export interface honeypotevidence {
+    selector: string;
+    reason: "hidden" | "offscreen" | "timetrap";
+}
+/** One surveyed field with the aria describedby ref and the sibling message texts the error reader associates. */
+export interface errorcontext extends fieldshape {
+    describedby?: string;
+    siblings: string[];
+}
+/** Resolves controls by label, placeholder, aria label and name attributes; matches are case insensitive substrings. */
+export declare function matchfield(fields: fieldshape[], match: fieldmatch): fieldshape[];
+/** Infers the field kind of one control from its input type, autocomplete hint and label text. */
+export declare function classifyfield(input: {
+    type: string;
+    autocomplete: string;
+    label: string;
+}): fieldkind;
+/** Generates one realistic value for a field kind, deterministically seeded and locale aware for names, emails and phones. */
+export declare function generatevalue(kind: fieldkind, rule: {
+    locale?: string;
+    seed?: number;
+}): string;
+/** Builds a deterministic values hash of the reviewed field values a submission ticket records. */
+export declare function valueshash(values: Array<{
+    label: string;
+    value: string;
+}>): string;
+/** Parses the reviewed structured form record of a step; null when the step reviews none or the shape is invalid. */
+export declare function parseformrecord(value: unknown): formrecord | null;
+/** Builds form record entries from reviewed label or placeholder value pairs. */
+export declare function pairentries(pairs: Array<{
+    label?: string;
+    placeholder?: string;
+    value: string;
+}>, mode: "label" | "placeholder"): formrecord;
+/** One fill operation outcome: the entry, the matched control, the honeypot skip flag or the refusal reason. */
+export interface filloutcome {
+    entry: formentry;
+    matched?: fieldshape;
+    skipped?: boolean;
+    reason?: string;
+}
+/** Resolves every entry of a form record against the surveyed fields, skipping honeypots and refusing unmatched or ambiguous entries. */
+export declare function filloperations(record: formrecord, fields: fieldshape[], skippedselectors?: string[]): filloutcome[];
+/** Masks one card segment so side panels can render card fills without exposing the full value. */
+export declare function cardmask(value: string): string;
+/** Flags hidden, offscreen and time trap fields so fill steps skip them instead of tripping anti bot defenses. */
+export declare function detecthoneypots(surveys: fieldsurvey[], loadedat: number): honeypotevidence[];
+/** Detects a login form: a password field plus an identifier field with session links nearby. */
+export declare function detectlogin(fields: fieldshape[], links: string[]): {
+    login: boolean;
+    markers: string[];
+};
+/** Detects signup and checkout templates by matching the field labels, autocompletes and page text against known markers. */
+export declare function detecttemplate(fields: fieldshape[], text: string): {
+    template: "signup" | "checkout" | "unknown";
+    markers: string[];
+};
+/** Associates validation messages with fields through aria describedby refs and the sibling text next to each field. */
+export declare function associateerrors(contexts: errorcontext[], messages: Array<{
+    id?: string;
+    text: string;
+}>): fielderror[];
+/** Resolves one reviewed artifact name against the run store before a file input is filled. */
+export declare function attachplan(name: string, artifacts: Array<{
+    id: string;
+    name: string;
+    kind: string;
+}>): {
+    artifact?: {
+        id: string;
+        name: string;
+        kind: string;
+    };
+    reason?: string;
+};
+/** Selectors the captcha detector probes; a hit hands control back to the user instead of forcing the page. */
+export declare const captchamarkers: string[];
+/** True when any captcha marker matched, so the plan pauses and hands control to the user. */
+export declare function captchadetected(matched: string[]): boolean;
+/** Fills one control through the native setter with input and change eventsforms; checks, radios and selects use their own grammar. */
+export declare function fillcontrol(element: Element, entry: formentry): boolean;
+/** Runs one reviewed forms and data step inside the page: fills, surveys, detects and reads errors without leaving the form scope. */
+export declare function runpageform(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/** Extracts the reviewed inner step of a retry or frame wrapper from its inline options. */
+export declare function innerstep(step: toolstep): toolstep | null;
+export interface retryoutcomeplan {
+    ok: boolean;
+    attempts: number;
+    movement: number;
+    summary: string;
+}
+/** Runs the reviewed retry loop: each failed attempt waits the settle window, revalidates the target geometry and reruns only when the element moved beyond the tolerance. */
+export declare function runretries(rule: retryrule, probe: () => Promise<{
+    x: number;
+    y: number;
+} | null>, execute: (attempt: number) => Promise<{
+    ok: boolean;
+    summary: string;
+}>): Promise<retryoutcomeplan>;
+/** Runs one resolution driven interaction: text, aria and name clicks, shadow piercing and frame routing. */
+export declare function runinteractstep(step: toolstep, expectedorigin: string, dispatch: (inner: toolstep, origin: string, root?: Document) => stepresult | Promise<stepresult>): stepresult | Promise<stepresult>;
+/**
+ * Page navigation logics for reviewed steps.
+ * Every correlated rule for navigation targets, container resolution, waitnav profiles, url patterns, link following, spa routing, query rewriting, deep links and recent tabs lives in this file.
+ */
+/** One link shape matched by followlink and spanav, serializable for fixtures. */
+export interface linkshape {
+    text: string;
+    href: string;
+    selector: string;
+}
+/** One collected load signal sample with the signals that held true at its time. */
+export interface signalsample {
+    at: number;
+    signals: string[];
+}
+/** Resolved container plan of one navigation target across tabs, windows and private profiles. */
+export interface containerplan {
+    kind: "current" | "tab" | "window" | "private";
+    incognito: boolean;
+    windowid?: number;
+    position: "adjacent" | "end";
+}
+/** Reads the reviewed navtarget of a navigation step; null when the step reviews none. */
+export declare function parsenavtarget(step: toolstep): navtarget | null;
+/** Resolves the container plan of one navigation target: the current task tab, a new tab, a new window or a private window profile separated from normal windows. */
+export declare function resolvecontainer(target: navtarget, windows: Array<{
+    id: number;
+    incognito: boolean;
+    focused: boolean;
+}>): containerplan;
+/** Reads the reviewed waitprofile of a navprofile step; null when the step reviews none. */
+export declare function parsewaitprofile(step: toolstep): waitprofile | null;
+/** Resolves the effective signals and thresholds of one waitnav profile for an origin by folding the per origin overrides in. */
+export declare function profilefororigin(profile: waitprofile, origin: string): {
+    signals: string[];
+    idle: number;
+    timeout: number;
+};
+/** Maps a document ready state onto the live navigation load phase. */
+export declare function loadphase(readystate: string): "loading" | "interactive" | "complete";
+/** Decides the waitnav outcome of a waitnav profile from collected load signal samples: every required signal must hold in the latest sample inside the timeout. */
+export declare function evaluatesignals(required: string[], samples: signalsample[], timeout: number): {
+    ok: boolean;
+    satisfied: string[];
+    waited: number;
+    samples: number;
+};
+/** Reads the reviewed urlpattern of a waiturl, spanav or spawait step; null when the step reviews none. */
+export declare function parseurlpattern(step: toolstep, key?: string): urlpattern | null;
+/** Matches one url against a reviewed urlpattern by mode plus required query and fragment parts. */
+export declare function urlmatches(url: string, pattern: urlpattern): boolean;
+/** Result of one query rewrite with the parameters read, written and the new url. */
+export interface queryrewriteoutcome {
+    url: string;
+    before: Record<string, string>;
+    after: Record<string, string>;
+    set: string[];
+    removed: string[];
+}
+/** Rewrites the query parameters of one url: reviewed values are set, reviewed names removed and the rest preserved. */
+export declare function rewritequeryurl(url: string, set: Record<string, string>, remove: string[]): queryrewriteoutcome;
+/** Applies one reviewed fragment to a url, keeping every other part untouched. */
+export declare function fragmenturl(url: string, fragment: string): string;
+/** Matches links by their visible text, case insensitively, refusing ambiguity through multiple matches. */
+export declare function matchlinktext(links: linkshape[], text: string): linkshape[];
+/** Matches links by their href fragment when the reviewed option asks for fragment resolution. */
+export declare function matchlinkfragment(links: linkshape[], fragment: string): linkshape[];
+/** Builds a deep link into a common web app from a reviewed app pattern and its string params; unknown apps are refused. */
+export declare function deeplinkurl(app: string, params: Record<string, string>): string | null;
+/** True when the current url of a single page app changed without a reload, keeping the origin. */
+export declare function spauroutechanged(previousurl: string, currenturl: string): boolean;
+/** Picks the most recently closed tab whose url is no longer open; null when every recent tab is already restored. */
+export declare function pickrecenttab(recenttabs: Array<{
+    url: string;
+    tabid: number;
+    closedat: number;
+}>, openurls: string[]): {
+    url: string;
+    tabid: number;
+    closedat: number;
+} | null;
+/** Runs one reviewed page navigation kind inside the page world. */
+export declare function runpagenav(step: toolstep, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Navigation network state logics for reviewed steps.
+ * Every correlated rule for redirect chain assembly, http error and interstitial classification, per domain rate limit windows, url safety verdicts, curated batch lists, prefetch verification, preconnect origins and basic auth credential gating lives in this file.
+ */
+/** One navigation watch event as observed from browser navigation listeners, serializable for fixtures. */
+export interface navwatchevent {
+    event: "beforenavigate" | "committed" | "completed" | "error" | "urlchange";
+    url: string;
+    timestamp: number;
+    status?: number;
+    redirect?: boolean;
+    error?: string;
+}
+/** Assembles one redirect chain from navigation watch events: successive url changes become hops with statuses and timing, and the chain closes on completion or error. */
+export declare function buildredirectchain(events: navwatchevent[]): redirectchain;
+/** Returns the final url of a redirect chain: the url of its last hop. */
+export declare function finalurl(chain: redirectchain): string;
+/** Counts the redirect hops of a chain, ignoring the first and the final urls when no intermediary hop exists. */
+export declare function redirectcount(chain: redirectchain): number;
+/** Classifies a navigation url change: a full load, a spa route change without reload, a reload or no change. */
+export declare function classifynavchange(previousurl: string, currenturl: string, status: string | undefined): "load" | "route" | "reload" | "none";
+/** One classified http state of a navigation: http error, offline and certificate interstitial flags with reasons. */
+export interface httpstate {
+    httperror: boolean;
+    offline: boolean;
+    certificate: boolean;
+    reasons: string[];
+}
+/** Detects the http error, offline and certificate interstitial states from the offline flag, error strings and observed statuses. */
+export declare function detecthttpstate(input: {
+    offline: boolean;
+    errors?: string[];
+    statuses?: number[];
+}): httpstate;
+/** Applies the certificate interstitial policy: interstitials are reported for review, never bypassed. */
+export declare function interstitialpolicy(state: httpstate): {
+    interstitial: boolean;
+    bypass: boolean;
+    guidance: string;
+};
+/** Reads the reviewed ratelimit of a navrate step; null when the step reviews none. */
+export declare function parseratelimit(step: toolstep): ratelimit | null;
+/** Reads the domain of a url for rate limit accounting. */
+export declare function domainof(url: string): string;
+/** Returns the live rate limit window state of one domain, opening a fresh window when the reviewed window has elapsed. */
+export declare function ratewindow(state: ratelimitstate | undefined, limit: ratelimit, now: number): ratelimitstate;
+/** Decides whether one more navigation fits inside the reviewed per domain rate limit window. */
+export declare function rateallows(state: ratelimitstate, now: number): {
+    allowed: boolean;
+    remaining: number;
+    retryafter: number;
+};
+/** Records one navigation hit inside the live rate limit window of a domain. */
+export declare function recordratehit(state: ratelimitstate, now: number): ratelimitstate;
+/** Verifies one url for safety: HTTPS only, no embedded credentials and no private network or raw ip targets. */
+export declare function checksafe(url: string): safetyverdict;
+/** Builds the curated link list of a batchopen step from per url safety verdicts. */
+export declare function curatelinks(urls: string[], verifier: (url: string) => safetyverdict): curatedlink[];
+/** Splits a curated link list into the urls batch opening may open and the unsafe ones it refuses. */
+export declare function batchopenset(links: curatedlink[]): {
+    open: string[];
+    refused: Array<{
+        url: string;
+        reasons: string[];
+    }>;
+};
+/** Verifies prefetch candidates against the session grants: only granted urls may be prefetched. */
+export declare function prefetchcandidates(urls: string[], grants: string[]): {
+    allowed: string[];
+    refused: string[];
+};
+/** Deduplicates the preconnect origins of one preconnect step. */
+export declare function preconnectorigins(origins: string[]): string[];
+/** Finds the reviewed basic auth credentials of one origin; the auth flow refuses to run without them. */
+export declare function authfor(auths: authrecord[], url: string): authrecord | undefined;
+/**
+ * Semantic page observation for reviewed steps.
+ * Every correlated rule for the shadow and frame piercing walker, the accessibility tree, visible text, the reader heuristic, the heading outline, the selection read, open graph extraction, language detection and the shadow and frame inventories lives in this file.
+ */
+/** Serializable page node used by the observation engine; the live glue attaches the element. */
+export interface pagenode {
+    tag: string;
+    selector: string;
+    id: string;
+    classes: string[];
+    role: string;
+    name: string;
+    text: string;
+    value: string;
+    states: string[];
+    hidden: boolean;
+    children: pagenode[];
+    element?: Element;
+}
+/** Builds the serializable page node tree, piercing open shadow roots and same origin iframes. */
+export declare function buildpagetree(scope: ParentNode): pagenode;
+/** Converts one page node tree into the accessibility tree with roles, names, states and child refs; hidden subtrees stay excluded. */
+export declare function builda11ytree(node: pagenode): a11ynode;
+/** Returns the rendered text of each visible element; hidden nodes and their subtrees stay excluded. */
+export declare function visibleentries(node: pagenode): Array<{
+    selector: string;
+    text: string;
+}>;
+/** Joins the rendered text of every visible node into one stream. */
+export declare function visibletext(node: pagenode): string;
+/** Scores page nodes by text density and splits the densest article region into reader blocks, separating them from page chrome. */
+export declare function buildreader(root: pagenode, title: string): readerarticle;
+/** Returns the title and headings outline of the page. */
+export declare function pageoutline(root: pagenode, title: string): {
+    title: string;
+    headings: Array<{
+        level: number;
+        text: string;
+    }>;
+};
+/** Reads the text of the current user selection through the document selection api. */
+export declare function captureselection(root: {
+    getSelection?: () => {
+        toString(): string;
+    } | null;
+}): {
+    text: string;
+    length: number;
+};
+/** Extracts open graph meta properties and structured data payloads; malformed structured payloads are refused and counted. */
+export declare function opengraphfields(meta: Array<{
+    property: string;
+    name: string;
+    content: string;
+}>, jsonld: string[]): {
+    graph: Record<string, string>;
+    structured: unknown[];
+    refused: number;
+};
+/** Detects the language of extracted text from stopword frequency; an undetermined text returns an empty code. */
+export declare function detecttextlanguage(text: string): string;
+/** Tags extracted text with its detected language code, routing it to the matching language stream. */
+export declare function taglanguage(text: string): {
+    text: string;
+    language: string;
+};
+/** Resolves the page language from the document lang attribute, the content language meta and the content signals, in that order. */
+export declare function documentlanguage(signals: {
+    lang: string;
+    meta: string;
+    text: string;
+}): {
+    language: string;
+    source: string;
+};
+/** Lists the host paths of every open shadow root nested inside one scope tree. */
+export declare function shadowpaths(scope: scopetree<candidatefields>): string[];
+/** Enumerates the iframes of one document with their origins and sizes; cross origin frames report no origin. */
+export declare function framelist(root: Document): Array<{
+    index: number;
+    origin: string;
+    sameorigin: boolean;
+    width: number;
+    height: number;
+}>;
+/** Runs one passive page observation after the background policy gate; frame routed steps receive their frame document as the root. */
+export declare function runpageobservation(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Pointer path and coordinate click logics for reviewed steps.
+ * Every correlated rule for waypoint interpolation, easing, jitter, hop settling, pointer sequences and coordinate clicks lives in this file.
+ */
+/** One interpolated pointer position with the settlepointer delay before it is dispatched. */
+export interface pointerhop {
+    x: number;
+    y: number;
+    delay: number;
+}
+/** One planned pointer or mouse event of a coordinate click sequence. */
+export interface plannedevent {
+    type: string;
+    eventkind: "pointer" | "mouse";
+    x: number;
+    y: number;
+    shift: boolean;
+}
+/** Interpolates one reviewed pointer path into settlepointer-delimited hops, honoring the reviewed easing, peak velocity and jitter window. */
+export declare function pathhops(path: pointpath, profile: speedprofile | undefined, random?: () => number, cadence?: number): pointerhop[];
+/** Builds the pointer event sequence around a reviewed path: pointerover, one pointermove per hop, then pointerout. */
+export declare function pointersequence(hopcount: number): string[];
+/** Builds the full pointer click sequence for reviewed coordinates and modifiers. */
+export declare function clickplan(x: number, y: number, modifiers: string[]): plannedevent[];
+/** Dispatches the full pointer click sequence on one element with the reviewed modifiers. */
+export declare function dispatchclick(element: HTMLElement, modifiers?: string[]): void;
+/** Scrolls one target into view before any pointer interaction. */
+export declare function ensurevisible(element: HTMLElement): void;
+/** Runs one reviewed pointer step: movepointer paths, clickpoint coordinate clicks and shiftclick modified clicks. */
+export declare function runpointerstep(step: toolstep, resolution: stepresolution): stepresult | Promise<stepresult>;
+/**
+ * Page-side profiling capture for the reviewed 1.1.47 steps.
+ * Correlated rules for the profiling option parsing live here while the flow, heap, cpu, shift, trace and source map math lives in the root profilers module: performance marks carry the step windows of the flow spec, the paint, navigation, longtask, layout shift and event buffers are observed for the reviewed window only, heap samples derive from the page performance memory buffer and the dom node count, and source map declarations are read from the loaded same origin scripts.
+ * Every measurement derives from the performance timeline buffers and the injected instrumentation probes through the scripting api, so no debugger permission exists anywhere in the manifest.
+ */
+/** Parses the reviewed profiling options of one profiling step; absent windows watch nothing and the depth of capture stays the reviewed window only. */
+export declare function profilestepoptions(step: toolstep): {
+    flow?: {
+        prefix: string;
+        steps: string[];
+        metrics: string[];
+    };
+    watchwindow: number;
+    heapinterval: number;
+    growth?: {
+        slope: number;
+        interval: number;
+    };
+    duration: number;
+    threshold: number;
+    categories: string[];
+    exporttarget?: string;
+    traceid?: string;
+    scripts: string[];
+};
+declare function waitprofile(milliseconds: number): Promise<void>;
+/** Runs one reviewed profiling step inside the page: the flow spec marks the start and end of every step in the window while the performance buffers feed the metric math of the root profilers module, the heap snapshot reads the memory buffer and the node count, the cpu window observes the long task and event timing samples, the layout shift watch scores the shifts of the window with their impacted selectors, the trace record categorizes the observed entries of the reviewed categories, and the source map capture reads the sourceMappingURL declarations of the loaded same origin scripts. */
+export declare function runprofilestep(step: toolstep): Promise<stepresult>;
+/** Runs one read-only page observation after the background policy gate. */
+export declare function runpageread(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Target resolution engine for reviewed steps.
+ * Every correlated rule for element summaries, targetref modes, ambiguity reports, shadow piercing, frame walking and the numbered clickable map lives in this file.
+ */
+/** Descriptive fields shared by every resolution candidate; the live dom glue attaches the element. */
+export interface candidatefields {
+    tag: string;
+    id: string;
+    role: string;
+    name: string;
+    label: string;
+    text: string;
+    selector: string;
+}
+/** One live dom candidate: descriptive fields plus the element itself. */
+export interface livecandidate extends candidatefields {
+    element: Element;
+}
+/** Serializable description of one document with nested frames; the glue attaches the live document. */
+export interface framedescription {
+    frames: frameentry[];
+    live?: Document;
+}
+/** One nested frame: same origin frames expose their document, cross origin frames do not. */
+export interface frameentry {
+    sameorigin: boolean;
+    document?: framedescription;
+}
+/** Serializable scope tree: one scope's candidates plus the open shadow scopes nested inside it. */
+export interface scopetree<T extends candidatefields = livecandidate> {
+    host?: T;
+    candidates: T[];
+    shadows: scopetree<T>[];
+}
+export declare function clean(value: string): string;
+/** Computes the accessible style label of an element from aria hints, linked labels, title and content. */
+export declare function elementlabel(element: Element): string;
+/** Computes the implicit aria role of common elements when no explicit role attribute exists. */
+export declare function implicitrole(element: Element): string;
+/** Builds the css selector that re-finds one element inside its document. */
+export declare function elementselector(element: Element): string;
+/** Own text of an element: only its direct text nodes, so parents do not shadow their children. */
+export declare function owntext(element: Element): string;
+/** Summarizes one live element into the candidate shape used by every resolution mode. */
+export declare function summarize(element: Element): livecandidate;
+/** Collects every clickable candidate in document order. */
+export declare function collectclickable(root: ParentNode): livecandidate[];
+/** Collects every element as a resolution candidate in document order. */
+export declare function collectcandidates(root: ParentNode): livecandidate[];
+/** Matches candidates whose visible own text or label equals or contains the reviewed text. */
+export declare function matchtext<T extends candidatefields>(candidates: T[], text: string): T[];
+/** Matches candidates by the aria role and accessible name pair. */
+export declare function matcharia<T extends candidatefields>(candidates: T[], role: string, name: string): T[];
+/** Matches candidates by accessible name, preferring clickable elements when several share one name. */
+export declare function matchname<T extends candidatefields>(candidates: T[], name: string, clickable?: (candidate: T) => boolean): T[];
+/** Matches one clickable map number; map numbers are one based and stable inside one observation version. */
+export declare function matchindex<T extends candidatefields>(candidates: T[], index: number): T[];
+/** Builds the numbered clickable map from clickable candidates in document order. */
+export declare function buildclickablemap<T extends candidatefields>(candidates: T[], version: number, builtat?: number): clickablemap;
+/** Describes the nested frame structure of one live document; cross origin frames stay opaque. */
+export declare function describeframes(root: Document): framedescription;
+/** Walks a reviewed frame path through same origin frames and refuses cross origin or absent hops. */
+export declare function walkframepath(root: framedescription, path: number[]): {
+    ok: true;
+    document: framedescription;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Describes one document or shadow root scope with every nested open shadow scope. */
+export declare function describescopes(root: ParentNode): scopetree;
+/** Searches one scope tree depth first for candidates matching the predicate, piercing open shadow scopes recursively. */
+export declare function piercescopes<T extends candidatefields>(scope: scopetree<T>, match: (candidate: T) => boolean): T[];
+/** Resolves a reviewed selector chain through open shadow roots: each selector resolves inside the previous scope. */
+export declare function queryshadowchain(root: ParentNode, selectors: string[]): Element | null;
+/** Finds the first element matching a selector in the scope or any nested open shadow root. */
+export declare function queryscoped(root: ParentNode, selector: string): Element | null;
+/** Builds the matched element summary attached to step results for review. */
+export declare function targetsummary(mode: targetmode, element: HTMLElement): resolvedtarget;
+export type stepresolution = {
+    status: "none";
+} | {
+    status: "resolved";
+    element: HTMLElement;
+    target: resolvedtarget;
+} | {
+    status: "ambiguous";
+    mode: targetmode;
+    candidates: string[];
+} | {
+    status: "absent";
+    mode?: targetmode;
+};
+/** Resolves the reviewed target of a step: the options targetref when present, otherwise the css target. */
+export declare function resolvestep(step: toolstep, root: Document): stepresolution;
+/**
+ * Page seam of the 1.1.49 session memory family: per tab scroll position, form state, local storage and cookie name capture plus the scroll and form restore.
+ * Every function stays self contained so the scripting api can serialize it into any granted tab; password fields never join a capture and cookie values never leave the page.
+ */
+/** Captures the reviewed sections of one tab: the scroll position, the form state of non password fields, the local storage pairs and the cookie names. */
+export declare function capturepagestate(sections: string[]): {
+    scrollx: number;
+    scrolly: number;
+    forms: Array<{
+        selector: string;
+        value: string;
+    }>;
+    storagekeys: string[];
+    storagevalues: string[];
+    cookienames: string[];
+};
+/** Restores the scroll position and the form state of one reopened tab; the restore only touches the captured selectors of the saved record. */
+export declare function restorepagestate(state: {
+    scrollx: number;
+    scrolly: number;
+    forms: Array<{
+        selector: string;
+        value: string;
+    }>;
+}): {
+    restored: number;
+    summary: string;
+};
+/** Parsed watch options of one watch step: the mutationwatch fields plus the poll interval. */
+export type watchoptions = mutationwatch & {
+    watchid: string;
+    poll: number;
+};
+/** Parses the reviewed watch options of one watch step into its mutationwatch shape with a poll interval. */
+export declare function parsewatchoptions(step: toolstep, fallbackid: string): watchoptions;
+/** Batches mutation records so records arriving inside one throttle window flush to the bridge together. */
+export declare function batchmutations(records: mutationevent[], windowms: number): mutationevent[][];
+/** Measures how long the network has stayed quiet from the resource timing entries completed so far. */
+export declare function quietfor(entries: Array<{
+    responseend: number;
+}>, now: number): number;
+/** Decides the network quiet outcome from collected probe samples against the reviewed idle threshold and timeout. */
+export declare function quietresolution(samples: Array<{
+    at: number;
+    quietfor: number;
+}>, idle: number, timeout: number): {
+    ok: boolean;
+    quietfor: number;
+    waited: number;
+    samples: number;
+};
+/** Serializable node summary the diff engine compares between observation versions. */
+export interface nodesummary {
+    selector: string;
+    tag: string;
+    text: string;
+    attributes: Record<string, string>;
+}
+/** Hashes one node summary into a stable digest used by the diff engine. */
+export declare function nodehash(summary: nodesummary): string;
+/** Diffs two node summary sets into added, removed and changed entries by hashing node summaries. */
+export declare function diffsummaries(base: nodesummary[], target: nodesummary[]): {
+    added: diffentry[];
+    removed: diffentry[];
+    changed: diffentry[];
+};
+/** Scans inline script payloads for embedded json state; malformed payloads are refused and counted. */
+export declare function scanjson(scripts: Array<{
+    src: string;
+    type: string;
+    id: string;
+    content: string;
+}>): {
+    states: jsonstate[];
+    refused: number;
+};
+/** Ranks selector candidates of one element shape by stability: id, attribute, text and structural strategies. */
+export declare function rankselectors(shape: {
+    id: string;
+    tag: string;
+    attributes: Record<string, string>;
+    text: string;
+    index: number;
+    siblings: number;
+}): selectorcandidate[];
+/** Runs one watched observation after the background policy gate; the reviewed lifetime window bounds every watch. */
+export declare function runpagewatch(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Wizard, dependent control and payment field logics for reviewed steps.
+ * Every correlated rule for wizard tracking, dependent option waits, typeahead picks, calendar navigation, card segment typing, one time code sources and submission retry backoff lives in this file.
+ */
+/** Advances one wizard step, recording the completion signal of the executed step and the new step index. */
+export declare function wizardadvance(state: wizardstate, completed: boolean, at: number): wizardstate;
+/** True when the dependent child options finished loading after a parent selection changed their count. */
+export declare function dependentloaded(previouscount: number, currentcount: number): boolean;
+/** Picks the reviewed suggestion entry from a typeahead list, case insensitive; undefined when the entry is absent. */
+export declare function typeaheadpick(suggestions: string[], pick: string): string | undefined;
+/** Parses one reviewed yyyy-mm-dd date into its year, month and day parts; null when the form is invalid. */
+export declare function parsedateparts(value: string): {
+    year: number;
+    month: number;
+    day: number;
+} | null;
+/** Plans the calendar navigation to the reviewed date: the month delta and the day cell to click. */
+export declare function calendarplan(view: {
+    year: number;
+    month: number;
+}, date: {
+    year: number;
+    month: number;
+    day: number;
+}): {
+    months: number;
+    day: number;
+};
+/** Splits one card number into its typed groups so the filler pauses between groups. */
+export declare function cardgroups(number: string): string[];
+/** True when the reviewed one time code source is ready to deliver the code before typing. */
+export declare function codeready(source: string, value: string | undefined): boolean;
+/** One reviewed retry backoff rule with an attempt count, a waitwizards window and a growth factor, all user configured. */
+export interface backoffrule {
+    attempts: number;
+    wait: number;
+    factor: number;
+}
+/** Parses the reviewed backoff rule of a retryform step; null when the step reviews none. */
+export declare function parsebackoff(step: toolstep): backoffrule | null;
+/** Computes the reviewed backoff windows between submission retries; no code ceiling applies. */
+export declare function backoffwaits(attempts: number, wait: number, factor: number): number[];
+/** Runs one reviewed wizard or payment field step inside the page, from multi step wizards to card segments and one time codes. */
+export declare function runpagewizard(step: toolstep, target: Element | null, root?: Document): stepresult | Promise<stepresult>;
+/**
+ * Xpath resolution subset for reviewed steps.
+ * Every correlated rule for expression parsing, node trees and evaluation of the supported xpath grammar lives in this file.
+ * The engine supports absolute and descendant steps, tag or wildcard names, attribute predicates, text predicates and positional predicates.
+ */
+/** Serializable dom node used by the xpath engine; the live glue attaches the element. */
+export interface xnode {
+    tag: string;
+    attributes: Record<string, string>;
+    text: string;
+    children: xnode[];
+    element?: Element;
+}
+type xpathpredicate = {
+    kind: "attr";
+    name: string;
+    value?: string;
+    contains?: boolean;
+} | {
+    kind: "text";
+    value: string;
+    contains?: boolean;
+} | {
+    kind: "position";
+    index: number;
+};
+interface xpathstep {
+    descendant: boolean;
+    tag: string;
+    predicates: xpathpredicate[];
+}
+/** Builds the serializable node tree of one live document for the xpath engine. */
+export declare function buildxtree(root: Document): xnode;
+/** Parses the reviewed xpath expression into evaluation steps; unsupported syntax is refused. */
+export declare function parsexpath(expression: string): xpathstep[];
+/** Evaluates the supported xpath subset against a serializable node tree and returns every matched node in document order. */
+export declare function evaluatexpath(root: xnode, expression: string): xnode[];
+export {};
+//# sourceMappingURL=page.d.ts.map