@enricai/barnacle 1.6.12 → 1.6.13

package/dist/scraper/deep-locator-click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-locator-click.d.ts","sourceRoot":"","sources":["../../src/scraper/deep-locator-click.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAG9E;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,SAAS,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAElF,qJAAqJ;AACrJ,MAAM,MAAM,sBAAsB,GAAG,CAAC,SAAS,EAAE,oBAAoB,KAAK,OAAO,CAAC;AAElF,MAAM,WAAW,4BAA4B;IAC3C,iJAAiJ;IACjJ,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,+DAA+D;AAC/D,MAAM,WAAW,4BAA4B;IAC3C,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,iHAAiH;IACjH,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACvC,4JAA4J;IAC5J,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,SAAS,oBAAoB,EAAE,EAC3C,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,4BAA4B,CAAC,CAoBvC"}

package/dist/scraper/deep-locator-click.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Candidate-click cascade for `deep-locator-candidates.ts`'s ranked
+ * `DeepLocatorCandidate[]`: `flow-runner.ts` used to click only
+ * `deepLocatorCandidates[0]` (see the bug report's Issue #2), so a top pick
+ * that turned out to be unrendered — a click rejecting with the CDP `-32000
+ * Node does not have a layout object` error `isNodeNotActionableError`
+ * classifies — scored the whole attempt as a failed click instead of trying
+ * the next-ranked candidate. {@link clickFirstActionableCandidate} walks the
+ * list instead, so a not-actionable rejection or a caller-supplied deny hit
+ * costs only that one candidate, not the attempt.
+ *
+ * Extracted out of `flow-runner.ts` so the walk is unit-testable against a
+ * stub click function — no fake `Page`, no Stagehand — and so
+ * `flow-runner.ts`'s own edit stays a call swap (see `bugfix-005`).
+ *
+ * NOT IMPLEMENTED: escalating to Stagehand's `Locator.sendClickEvent()` (a
+ * layout-free actuation) as a rescue for a candidate that's genuinely never
+ * going to render. The report asks for skip-and-continue, not a rescue path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLICK_CANDIDATE_ATTEMPT_CAP = void 0;
+exports.clickFirstActionableCandidate = clickFirstActionableCandidate;
+const deep_locator_scan_1 = require("../scraper/deep-locator-scan");
+/**
+ * Upper bound on how many candidates a single {@link clickFirstActionableCandidate}
+ * call will actually click. Denied candidates are skipped without a click and
+ * don't count against this cap — only a real `click()` invocation does — so a
+ * dense post-filter list (a handful of controls, per bugfix-002's visibility
+ * filter and bugfix-005's interactive scoping) still resolves in one or two
+ * attempts, while a pathological list (371 candidates, the uchealth-7
+ * measurement) can't spend the whole step budget clicking its way through
+ * every entry.
+ */
+exports.DEFAULT_CLICK_CANDIDATE_ATTEMPT_CAP = 5;
+/**
+ * Walks `candidates` in rank order, clicking each via `click` until one
+ * succeeds. A candidate refused by `denyCandidate` is skipped without being
+ * clicked and doesn't count against `attemptCap`. A click rejection that
+ * {@link isNodeNotActionableError} classifies as "not actionable" (unrendered
+ * node) is treated as "skip this candidate, try the next"; any other
+ * rejection stops the walk immediately and rethrows, so a caller doesn't
+ * silently burn the remaining candidates on an error that had nothing to do
+ * with actionability (a detached frame, a wedged click's
+ * `WatchdogTimeoutError`). Never throws on exhaustion — an exhausted list
+ * (every candidate denied or not-actionable, or the cap reached) resolves to
+ * `{ clicked: false, candidate: null, triedSelectors }` instead.
+ */
+async function clickFirstActionableCandidate(candidates, click, options = {}) {
+    const attemptCap = options.attemptCap ?? exports.DEFAULT_CLICK_CANDIDATE_ATTEMPT_CAP;
+    const triedSelectors = [];
+    let attempts = 0;
+    for (const candidate of candidates) {
+        if (attempts >= attemptCap)
+            break;
+        if (options.denyCandidate?.(candidate))
+            continue;
+        attempts += 1;
+        triedSelectors.push(candidate.selector);
+        try {
+            await click(candidate);
+            return { clicked: true, candidate, triedSelectors };
+        }
+        catch (error) {
+            if (!(0, deep_locator_scan_1.isNodeNotActionableError)(error))
+                throw error;
+        }
+    }
+    return { clicked: false, candidate: null, triedSelectors };
+}
+//# sourceMappingURL=deep-locator-click.js.map

package/dist/scraper/deep-locator-click.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-locator-click.js","sourceRoot":"","sources":["../../src/scraper/deep-locator-click.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;;AAGH,mEAAuE;AAEvE;;;;;;;;;GASG;AACU,QAAA,mCAAmC,GAAG,CAAC,CAAC;AA+BrD;;;;;;;;;;;;GAYG;AACI,KAAK,wCACV,UAA2C,EAC3C,KAAuB,EACvB,OAAO,GAAiC,EAAE;IAE1C,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,QAAA,mCAAmC,CAAC;IAC7E,MAAM,cAAc,GAAa,EAAE,CAAC;IACpC,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,QAAQ,IAAI,UAAU;YAAE,MAAM;QAClC,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC;YAAE,SAAS;QAEjD,QAAQ,IAAI,CAAC,CAAC;QACd,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC;YACH,MAAM,KAAK,CAAC,SAAS,CAAC,CAAC;YACvB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;QACtD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,IAAA,4CAAwB,EAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC;QACpD,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;AAC7D,CAAC"}

package/dist/scraper/deep-locator-fake.d.ts

@@ -1,15 +1,58 @@
+import type { Page } from "@browserbasehq/stagehand";
 import type { DeepLocatorDelegate } from "@browserbasehq/stagehand/lib/v3/understudy/deepLocator.js";
+import { vi } from "vitest";
+import type { FrameCandidateScanResult, FrameCandidateWriteResult } from "../scraper/deep-locator-scan";
 /**
  * One candidate element registered at a hop selector. `registerDeepLocatorHop`
  * seeds a single-element hop by constructing one of these; multi-candidate
  * hops (`registerDeepLocatorHopElements`) hold an ordered array of them so
  * `nth(i)` can resolve to a distinct element's own click/fill/text state
- * instead of collapsing every index onto shared scalars.
+ * instead of collapsing every index onto shared scalars. `visible` models
+ * whether the element has a layout box — `false` reproduces the run-7 field
+ * condition of a candidate that exists in the DOM but has no rendered
+ * geometry (0x0 box, `display:none`), which a real click rejects against
+ * with the CDP `-32000 Node does not have a layout object` error
+ * ({@link NODE_NOT_ACTIONABLE_MESSAGE}).
  */
 export interface FakeDeepLocatorElement {
     clicks: number;
     filledWith: string | null;
+    selectedWith: string[] | null;
     text: string;
+    visible: boolean;
+    /**
+     * When set, `inputValue()` returns this instead of `filledWith` — models a
+     * write that doesn't stick (an SPA re-render normalizes/rejects the typed
+     * value) so a read-back-verified actuator
+     * (`fillDeepLocatorCandidate`/`selectDeepLocatorCandidateOption` in
+     * `deep-locator-actuate.ts`) has a fixture to prove it returns `false`
+     * rather than trusting the write blindly. Leave unset to have `inputValue()`
+     * mirror whatever was last written.
+     */
+    readBackValue?: string;
+    /**
+     * When set to anything other than `"select"`, `selectOption()` rejects with
+     * {@link NODE_NOT_ACTIONABLE_MESSAGE} — mirrors `buildSelectFrameCandidateExpr`
+     * (`deep-locator-scan.ts`), whose real `el.options || []` lookup is always
+     * empty for a non-`<select>` element, so a real select-write against a
+     * decoy `input`/`button` candidate reports `not-actionable` rather than
+     * silently succeeding. Left unset (the legacy default), `selectOption()`
+     * always succeeds regardless of tag — every existing tag-agnostic
+     * registration keeps behaving exactly as it always has.
+     */
+    tagName?: string;
+}
+/**
+ * Shorthand a caller can pass to {@link registerDeepLocatorHopElements}
+ * instead of a bare string when an element also needs non-default layout
+ * state — `visible` defaults to `true` (rendered) so every legacy
+ * string-only registration keeps behaving exactly as it always has.
+ */
+export interface FakeDeepLocatorElementSpec {
+    readonly text: string;
+    readonly visible?: boolean;
+    /** See {@link FakeDeepLocatorElement.tagName}. Omit to keep `selectOption()` tag-agnostic. */
+    readonly tagName?: string;
 }
 /**
  * Shared, in-memory model of a `page.deepLocator()`-reachable hop: the
@@ -25,6 +68,7 @@ export interface FakeDeepLocatorHop {
     readonly elements: FakeDeepLocatorElement[];
     readonly clicks: number;
     readonly filledWith: string | null;
+    readonly selectedWith: string[] | null;
     readonly text: string;
 }
 /**
@@ -42,19 +86,27 @@ export type FakeDeepLocatorFrame = Map<string, FakeDeepLocatorHop>;
 export declare function registerDeepLocatorHop(frame: FakeDeepLocatorFrame, selector: string, text?: string): FakeDeepLocatorHop;
 /**
  * Registers a hop selector with N ordered candidate elements so
- * `deepLocator(selector).count()` resolves to `texts.length` and
+ * `deepLocator(selector).count()` resolves to `elements.length` and
  * `nth(i).textContent()`/`nth(i).click()`/`nth(i).fill()` act on element `i`
  * specifically — the shape a real cross-origin OOPIF hop resolves to when
  * more than one element matches the inner selector (e.g. `"*"` matching
  * every node in the iframe), which the single-element
- * {@link registerDeepLocatorHop} path can't model.
+ * {@link registerDeepLocatorHop} path can't model. Each entry is either a
+ * bare string (rendered, `visible: true`) or a
+ * {@link FakeDeepLocatorElementSpec} for a candidate that also needs
+ * non-default layout state — mixing both in one call models a hop where
+ * only some candidates have a layout box, same as a real dense OOPIF form.
  */
-export declare function registerDeepLocatorHopElements(frame: FakeDeepLocatorFrame, selector: string, texts: string[]): FakeDeepLocatorHop;
+export declare function registerDeepLocatorHopElements(frame: FakeDeepLocatorFrame, selector: string, elements: ReadonlyArray<string | FakeDeepLocatorElementSpec>): FakeDeepLocatorHop;
 /**
  * The `FakeDeepLocatorDelegate` methods `registerDeepLocatorHangingHop` can
  * pin open, modeling a wedged OOPIF CDP call (the run-6 78-minute hang).
+ * `fill`/`selectOption`/`inputValue` model the same wedge for
+ * `deep-locator-actuate.ts`'s write/read-back seam — e.g. a wedged `fill`
+ * proving `fillDeepLocatorCandidate` rejects via its watchdog instead of
+ * hanging.
  */
-export type HangingDeepLocatorMethod = "click" | "count" | "textContent";
+export type HangingDeepLocatorMethod = "click" | "count" | "textContent" | "fill" | "selectOption" | "inputValue";
 export interface RegisterDeepLocatorHangingHopOptions {
     /** Which method(s) resolve to a never-settling promise until `release()` is called. */
     readonly hangOn: HangingDeepLocatorMethod | readonly HangingDeepLocatorMethod[];
@@ -78,19 +130,48 @@ export interface FakeDeepLocatorHangingHop {
  * wedged `deepLocator().count()`/`.click()` CDP call without a real browser.
  */
 export declare function registerDeepLocatorHangingHop(frame: FakeDeepLocatorFrame, selector: string, options: RegisterDeepLocatorHangingHopOptions): FakeDeepLocatorHangingHop;
+/**
+ * The delegate methods plus {@link makeFakeFrameScan}'s batched evaluate,
+ * {@link makeFakeFrameClickByIndex}'s batched click, and
+ * {@link makeFakeFrameFillByIndex}'s/{@link makeFakeFrameSelectByIndex}'s
+ * batched writes a hop's {@link registerDeepLocatorHopLatency} profile can
+ * delay.
+ */
+export type LatencyDeepLocatorMethod = HangingDeepLocatorMethod | "scan" | "clickByIndex" | "fillByIndex" | "selectByIndex";
+export interface RegisterDeepLocatorHopLatencyOptions {
+    /** Which method(s) resolve after `delayMs` instead of immediately. */
+    readonly delayOn: LatencyDeepLocatorMethod | readonly LatencyDeepLocatorMethod[];
+    readonly delayMs: number;
+}
+/**
+ * Attaches a finite per-call delay to an already-registered hop's `delayOn`
+ * methods, leaving every other method — and every other hop — immediate.
+ * This is the seam a test uses to prove a batched fix collapses N serial
+ * round-trips into one: register the same `delayMs` against `"textContent"`/
+ * `"click"`/`"fill"`/`"selectOption"`/`"inputValue"` (the legacy per-index
+ * paths, charged `index + 1` times — see {@link INDEXED_RESOLVE_METHODS}) and
+ * `"scan"`/`"clickByIndex"` (the batched paths, always charged once) on the
+ * same hop, then compare how time scales
+ * with candidate count/index through each. Unlike
+ * {@link registerDeepLocatorHangingHop}, calls resolve on their own after
+ * `delayMs` — there is no `release()`.
+ */
+export declare function registerDeepLocatorHopLatency(hop: FakeDeepLocatorHop, options: RegisterDeepLocatorHopLatencyOptions): void;
 /**
  * Only the methods `src/scraper/flow-runner.ts`'s deepLocator-routed call
  * sites (`observe-act`, rephrase evidence, the pre-cascade probe) actually
  * invoke, via `deep-locator-candidates.ts`: `count()` to check candidate
- * existence, `click()`/`fill()` to act, `textContent()` to read
- * `accessibleText`, `first()`/`nth()` for the same chaining
- * `buildHopSelector`-composed multi-match selectors need. `hover`/`type`/
- * `selectOption`/`isVisible`/`isChecked`/`inputValue`/`innerHtml`/
- * `innerText`/`setInputFiles`/`scrollTo`/`centroid`/`backendNodeId`/
- * `highlight`/`sendClickEvent` are declared on the real `DeepLocatorDelegate`
- * but no planned call site routes through them, so they are omitted here —
- * adding one only when a call site actually needs it keeps this fake from
- * drifting out of sync with what's exercised.
+ * existence, `click()` to act, `textContent()` to read `accessibleText`,
+ * `first()`/`nth()` for the same chaining `buildHopSelector`-composed
+ * multi-match selectors need. `fill()`/`selectOption()`/`inputValue()` back
+ * `deep-locator-actuate.ts`'s fill/select actuation seam — the write
+ * primitives and the read-back that confirms a write stuck. `hover`/`type`/
+ * `isVisible`/`isChecked`/`innerHtml`/`innerText`/
+ * `setInputFiles`/`scrollTo`/`centroid`/`backendNodeId`/`highlight`/
+ * `sendClickEvent` are declared on the real `DeepLocatorDelegate` but no
+ * planned call site routes through them, so they are omitted here — adding
+ * one only when a call site actually needs it keeps this fake from drifting
+ * out of sync with what's exercised.
  *
  * `first`/`nth` return `FakeDeepLocatorDelegate` (not the real
  * `DeepLocatorDelegate` class a `Pick` would demand) since a fake has no
@@ -102,10 +183,20 @@ export interface FakeDeepLocatorDelegate {
     click: DeepLocatorDelegate["click"];
     count: DeepLocatorDelegate["count"];
     fill: DeepLocatorDelegate["fill"];
+    inputValue: DeepLocatorDelegate["inputValue"];
+    selectOption: DeepLocatorDelegate["selectOption"];
     textContent: DeepLocatorDelegate["textContent"];
     first(): FakeDeepLocatorDelegate;
     nth(index: number): FakeDeepLocatorDelegate;
 }
+/**
+ * The literal CDP error message a real `DOM.getBoxModel`/
+ * `DOM.scrollIntoViewIfNeeded` failure over "no layout object" arrives as
+ * (`understudy/cdp.js`) — exported so both this fake's click rejection and a
+ * consuming test assert against the same string bugfix-001's
+ * `isNodeNotActionableError` (`deep-locator-scan.ts`) matches.
+ */
+export declare const NODE_NOT_ACTIONABLE_MESSAGE = "-32000 Node does not have a layout object";
 /**
  * Fake `page.deepLocator` bound to an in-memory hop registry — pass the same
  * `FakeDeepLocatorFrame` into a fake `Page`'s `deepLocator` field so a fix
@@ -113,4 +204,243 @@ export interface FakeDeepLocatorDelegate {
  * fixture state instead of a browser.
  */
 export declare function makeFakeDeepLocator(frame: FakeDeepLocatorFrame): (selector: string) => FakeDeepLocatorDelegate;
+/**
+ * Minimal fake DOM element supporting exactly the surface
+ * {@link buildScanFrameCandidatesExpr} (`deep-locator-scan.ts`) touches:
+ * `textContent`, `getBoundingClientRect`, `getAttribute`, `closest`, plus a
+ * `computedStyle` bag the fake global `getComputedStyle` reads from. Shared
+ * here (not duplicated per test file) so `deep-locator-scan.dense-form.
+ * test.ts` and Stagehand-contract tests can execute the SAME generated
+ * expression against the SAME fixture shape as `deep-locator-scan.test.ts`'s
+ * own hand-built fixture. `value`/`dispatchEvent`/`focus` model the write
+ * half of that same contract — a generated fill/select expression reads and
+ * writes `el.value` and fires bubbling `input`/`change`/`blur` events the
+ * same way `flow-runner.ts`'s existing `.value =` + `dispatchEvent` write
+ * paths do, so a fake candidate can stand in for a real writable `<input>`/
+ * `<select>` instead of only the read-only surface a click/scan needs.
+ */
+export interface FakeDomElement {
+    readonly textContent: string;
+    readonly tagName: string;
+    readonly attributes: Readonly<Record<string, string>>;
+    readonly rect: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly computedStyle: {
+        readonly display: string;
+        readonly visibility: string;
+    };
+    readonly parent: FakeDomElement | null;
+    value: string;
+    /** `<select>`-only: the `<option>` collection {@link buildSelectFrameCandidateExpr}'s (`deep-locator-scan.ts`) value-then-label match reads. Empty for every non-`<select>` fixture. */
+    readonly options: readonly {
+        readonly value: string;
+        readonly textContent: string;
+    }[];
+    readonly dispatchedEvents: readonly string[];
+    getBoundingClientRect(): {
+        readonly width: number;
+        readonly height: number;
+    };
+    getAttribute(name: string): string | null;
+    closest(selector: string): FakeDomElement | null;
+    dispatchEvent(event: {
+        readonly type: string;
+    }): boolean;
+    focus(): void;
+}
+/** Fake `document`/frame-document surface: the two lookups the accessible-name precedence chain needs beyond the matched candidate set itself. */
+export interface FakeDomRoot {
+    querySelectorAll(selector: string): FakeDomElement[];
+    getElementById(id: string): FakeDomElement | null;
+}
+/** Optional overrides {@link makeFakeDomElement} accepts beyond its default rendered `div`. */
+export interface MakeFakeDomElementOptions {
+    readonly tagName?: string;
+    readonly attributes?: Record<string, string>;
+    readonly rect?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly computedStyle?: {
+        readonly display: string;
+        readonly visibility: string;
+    };
+    readonly parent?: FakeDomElement | null;
+    /** Seeds `value` — the initial `.value` a write expression reads before overwriting it. Defaults to `""`, matching an unfilled `<input>`. */
+    readonly value?: string;
+    /** Seeds `options` — a `<select>` fixture's option collection. Defaults to `[]`, matching every non-`<select>` element. */
+    readonly options?: readonly {
+        readonly value: string;
+        readonly textContent: string;
+    }[];
+}
+/**
+ * Builds one fake DOM element. Defaults model a rendered, tag-less `div`
+ * with no accessible-name signal — the "structural filler" shape a dense
+ * form fixture needs many of — so a caller building a large fixture only
+ * spells out the overrides that make a specific element interesting.
+ */
+export declare function makeFakeDomElement(textContent?: string, options?: MakeFakeDomElementOptions): FakeDomElement;
+/**
+ * Builds a selector-aware fake `document` root: `querySelectorAll` supports
+ * the exact clause shapes {@link INTERACTIVE_CANDIDATE_SELECTOR} needs (a
+ * bare tag, `[attr]`, `[attr=value]`, comma-joined, or `"*"`) instead of
+ * `deep-locator-scan.test.ts`'s tag-only `makeRoot`, so a fixture exercising
+ * that constant's `[role=button]` / `[tabindex]` clauses actually selects
+ * against them.
+ */
+export declare function makeSelectorAwareDomRoot(elements: readonly FakeDomElement[]): FakeDomRoot;
+/** Total node count {@link buildDenseFormFixture} produces — the live-measured `#talemetry_apply_iframe >> *` match count from the uchealth-7 bug report. */
+export declare const DENSE_FORM_TOTAL_COUNT = 371;
+/** Accessible name {@link buildDenseFormFixture}'s icon-only target button resolves to — mirrors the live report's `button.c-SocialButton-button-25:has(svg[data-testid='EditIcon'])` control, modeled here as a plain icon-only `button` named via `aria-label` since `:has()` support is not what this fixture is for. */
+export declare const DENSE_FORM_TARGET_TEXT = "Manual Application";
+/** Accessible names of {@link buildDenseFormFixture}'s two unrendered decoys — one `display:none`, one a 0x0 layout box — the two shapes a real click rejects with the CDP `-32000 Node does not have a layout object` error. */
+export declare const DENSE_FORM_DECOY_TEXTS: readonly ["Upload a Resume/CV", "Use LinkedIn Profile"];
+/** {@link buildDenseFormFixture}'s return shape: the assembled root plus its flat element list, so a caller can assert against fixture composition (e.g. total count) without re-deriving it from the root. */
+export interface DenseFormFixture {
+    readonly root: FakeDomRoot;
+    readonly elements: readonly FakeDomElement[];
+}
+/**
+ * Builds the {@link DENSE_FORM_TOTAL_COUNT}-node dense-OOPIF-shaped fixture
+ * the uchealth-7 bug report measured (`#talemetry_apply_iframe >> *`
+ * matching 371 elements): mostly structural `div`/`span` filler, a handful
+ * of real form controls, an icon-only target button, and two unrendered
+ * decoys. Exported (not inlined per test file) so `test-002`'s Stagehand-
+ * resolver-contract pin can run the installed dependency's own resolver
+ * against the IDENTICAL fixture `deep-locator-scan.dense-form.test.ts`
+ * proves {@link buildScanFrameCandidatesExpr} against.
+ */
+export declare function buildDenseFormFixture(): DenseFormFixture;
+/**
+ * Fake frame-scoped batched evaluate bound to `selector` — models the seam
+ * `resolveDeepLocatorCandidates`'s batched-scan fix calls once per frame via
+ * `FrameTarget.evaluate(buildScanFrameCandidatesExpr(innerSelector))`
+ * (`deep-locator-scan.ts`). Ignores whatever expression string it's called
+ * with — a fake cannot execute browser-side code, and `deep-locator-scan.
+ * test.ts`'s `node:vm` test is what proves the expression itself is correct
+ * — and instead returns the hop registered at `selector` as
+ * `FrameCandidateScanResult[]`, in registration order: the exact payload
+ * shape a real `Frame.evaluate` call resolves to. Pass the result into a
+ * fake `FrameTarget`'s `evaluate` field so a caller that reads through
+ * `target.evaluate(...)` resolves against fixture state instead of a
+ * browser.
+ */
+export declare function makeFakeFrameScan(frame: FakeDeepLocatorFrame, selector: string): (expression?: unknown) => Promise<FrameCandidateScanResult[]>;
+/**
+ * Result of the fake batched click-by-index seam
+ * ({@link makeFakeFrameClickByIndex}): `clicked` mirrors whether the click
+ * landed on a rendered node. `reason` is set instead of the fake throwing —
+ * a single batched evaluate call reports what it observed rather than
+ * surfacing a per-call CDP rejection — and carries
+ * {@link NODE_NOT_ACTIONABLE_MESSAGE} for the unrendered-node case so a
+ * caller can still classify it via {@link isNodeNotActionableError}
+ * (`deep-locator-scan.ts`).
+ */
+export interface FakeBatchedClickResult {
+    clicked: boolean;
+    reason?: string;
+}
+/**
+ * Fake frame-scoped batched click-by-index bound to `selector` — models the
+ * seam a click-by-index fix would call once per click via a single frame
+ * evaluate, instead of the legacy delegate's `nth(index).click()` walking
+ * `resolveAtIndex`'s serial per-index loop (see {@link INDEXED_RESOLVE_METHODS}).
+ * Same "ignore the expression string, resolve against the hop registry"
+ * contract as {@link makeFakeFrameScan}: a fake cannot execute browser-side
+ * code, so the `expression` argument is accepted (mirroring `evaluate`'s
+ * signature) but never inspected. Increments `elements[index].clicks` when
+ * the targeted element is registered and `visible`, so an assertion like
+ * `hop.elements[i]?.clicks` reads the same regardless of which click path a
+ * consumer routes through. Resolves `{ clicked: false, reason }` — never
+ * throws — when `index` doesn't resolve to a registered element (hop
+ * unregistered, or `index` out of range) or the element is `visible: false`.
+ */
+export declare function makeFakeFrameClickByIndex(frame: FakeDeepLocatorFrame, selector: string): (index: number, expression?: unknown) => Promise<FakeBatchedClickResult>;
+/**
+ * Fake frame-scoped batched fill-by-index bound to `selector` — models the
+ * seam a batched-fill fix would call once per fill via a single frame
+ * evaluate (`buildFillFrameCandidateExpr`, `deep-locator-scan.ts`), instead
+ * of the legacy delegate's `nth(index).fill()`. Same "ignore the expression
+ * string, resolve against the hop registry" contract as
+ * {@link makeFakeFrameClickByIndex}: the fake cannot execute browser-side
+ * code, so `expression` is accepted (mirroring the real seam's signature)
+ * but never inspected — `value` is passed explicitly since it's what a real
+ * expression bakes in rather than something the fake could read back out of
+ * a string it never parses. See {@link resolveFakeBatchedWrite} for the
+ * shared not-actionable/out-of-range/write contract.
+ */
+export declare function makeFakeFrameFillByIndex(frame: FakeDeepLocatorFrame, selector: string): (index: number, value: string, expression?: unknown) => Promise<FrameCandidateWriteResult>;
+/**
+ * Fake frame-scoped batched select-by-index bound to `selector` — models the
+ * seam a batched-select fix would call once per select via a single frame
+ * evaluate (`buildSelectFrameCandidateExpr`, `deep-locator-scan.ts`),
+ * instead of the legacy delegate's `nth(index).selectOption()`. Writes
+ * `optionValue` into the same `filledWith` field {@link makeFakeFrameFillByIndex}
+ * does rather than `selectedWith` — the real expression matches and reports a
+ * single option `value` (`FrameCandidateWriteResult.readBack` is one string,
+ * not the delegate's array-shaped `selectedWith`/multi-value `selectOption()`),
+ * so this batched primitive models the same single-value write shape as fill.
+ * Same "ignore the expression string" contract as
+ * {@link makeFakeFrameClickByIndex}; see {@link resolveFakeBatchedWrite} for
+ * the shared not-actionable/out-of-range/write contract.
+ */
+export declare function makeFakeFrameSelectByIndex(frame: FakeDeepLocatorFrame, selector: string): (index: number, optionValue: string, expression?: unknown) => Promise<FrameCandidateWriteResult>;
+/**
+ * Options for {@link makeFakeFrameResolutionPage}.
+ */
+export interface MakeFakeFrameResolutionPageOptions {
+    /** CSS selector of the `<iframe>` element in the top document — the exact `frameSelector` a caller passes to `resolveFrameTarget`. */
+    readonly iframeSelector: string;
+    /** Answers both the iframe's `src` attribute and the child frame's own `location.href` — same origin for both, matching every existing hand-rolled OOPIF throughput fixture (`flow-runner.oopif-*-throughput.test.ts`), which only needs the two to diverge post-navigation, not at resolution time. */
+    readonly childSrc: string;
+    /**
+     * Milliseconds each of `tryResolveChildFrame`'s two probes (the iframe-src
+     * read and the candidate `location.href` read) waits before resolving.
+     * `0` (default) resolves same-tick, matching every existing hand-rolled
+     * throughput fixture's fake `evaluate` exactly — which is what lets those
+     * fixtures' internal `resolveFrameTarget(..., { timeoutMs: 0 })` pass win
+     * a race it would always lose against genuine CDP latency in production
+     * (see `deep-locator-candidates.internal-frame-resolution.test.ts`'s
+     * docblock). A positive value reproduces that production loss offline —
+     * the dial the throughput-only fixtures never needed, but a fix for the
+     * zero-budget race itself does.
+     */
+    readonly probeDelayMs?: number;
+    /**
+     * Extra `childFrame.evaluate` handling beyond the `location.href` probe
+     * this factory already answers (e.g. a batched-scan/click/fill expression
+     * a consuming fixture needs) — tried, undelayed, after the probe, before
+     * the default `null` fallback. Omit for a bare resolution-only fixture.
+     */
+    readonly onFrameEvaluate?: (expression: unknown) => unknown | Promise<unknown>;
+}
+/** {@link makeFakeFrameResolutionPage}'s return shape. */
+export interface FakeFrameResolutionPage {
+    /** Fake top `Page`, castable straight into `resolveFrameTarget`'s `page` parameter. */
+    readonly page: Page;
+    /** The single child frame `page.frames()` resolves to. */
+    readonly childFrame: ReturnType<Page["frames"]>[number];
+    /** Fires once per iframe-src probe (`document.querySelector(<iframeSelector>)`-shaped evaluate) the fake page answers. */
+    readonly iframeProbeSpy: ReturnType<typeof vi.fn>;
+    /** Fires once per `"location.href"` probe the fake child frame answers. */
+    readonly locationProbeSpy: ReturnType<typeof vi.fn>;
+}
+/**
+ * Builds a fake top `Page` + single child `Frame` pair bound to
+ * `iframeSelector` — the shared instrument every OOPIF throughput fixture
+ * hand-rolls a variant of (`flow-runner.oopif-click-throughput.test.ts` et
+ * al.) but none of which can model production CDP latency at frame-
+ * RESOLUTION time: every one of those resolves both of
+ * `tryResolveChildFrame`'s probes with no internal `await`, a same-tick
+ * microtask that always wins a `{ timeoutMs: 0 }` watchdog race and
+ * therefore MASKS the production degrade this fake exists to make
+ * testable. `probeDelayMs: 0` (the default) reproduces those fixtures'
+ * timing exactly, so nothing that later adopts this factory sees a timing
+ * change; a positive value reproduces the production degrade those
+ * fixtures structurally cannot.
+ */
+export declare function makeFakeFrameResolutionPage(options: MakeFakeFrameResolutionPageOptions): FakeFrameResolutionPage;
 //# sourceMappingURL=deep-locator-fake.d.ts.map

package/dist/scraper/deep-locator-fake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deep-locator-fake.d.ts","sourceRoot":"","sources":["../../src/scraper/deep-locator-fake.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AAErG;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAmBD;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,MAAM,EAChB,IAAI,SAAK,GACR,kBAAkB,CAEpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,GACd,kBAAkB,CAKpB;AAED;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,OAAO,GAAG,OAAO,GAAG,aAAa,CAAC;AA6BzE,MAAM,WAAW,oCAAoC;IACnD,uFAAuF;IACvF,QAAQ,CAAC,MAAM,EAAE,wBAAwB,GAAG,SAAS,wBAAwB,EAAE,CAAC;IAChF,wGAAwG;IACxG,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,GAAG,EAAE,kBAAkB,CAAC;IACjC;;;;;OAKG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,oCAAoC,GAC5C,yBAAyB,CAM3B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACpC,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACpC,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAClC,WAAW,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAChD,KAAK,IAAI,uBAAuB,CAAC;IACjC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAAC;CAC7C;AAkDD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,oBAAoB,GAC1B,CAAC,QAAQ,EAAE,MAAM,KAAK,uBAAuB,CAE/C"}
+{"version":3,"file":"deep-locator-fake.d.ts","sourceRoot":"","sources":["../../src/scraper/deep-locator-fake.ts"],"names":[],"mappings":"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"}