@enricai/barnacle 1.9.12 → 1.10.1

package/dist/scraper/flow-runner.js

@@ -5572,6 +5572,114 @@ async function executeStepWithHealing(params) {
     // observable effect (see classifyPhantomClick). Reroutes attempt 2 to
     // deep-submit-locator instead of observe-act, since re-resolving via the
     // same light-DOM view cannot reach a target the resolver can't see.
+    // Shared deepLocator actionable-candidate walk, invoked by BOTH the
+    // observe-blind attempt-2/4 branch and the phantom-driven `trusted-click-retry`
+    // branch. Walks ranked `candidates`, skipping wizard-exit and not-actionable
+    // ones, actuating the first that sticks (`clickFirstActionableCandidate`), then
+    // synthesizes a `resolvedAction` the standard verifier consumes. Returns
+    // `resolvedAction` on success, or `null` on failure (the caller `continue`s).
+    // `preferTrustedClick` forwards to `clickDeepLocatorCandidate` so the retry
+    // path activates via the trusted CDP click; `labelPrefix` distinguishes the
+    // two callers in the audit record. On failure the running `triedSelectors`
+    // (which already holds prior attempts' resolved xpath) is written to
+    // `record.triedSelectors`, not just this walk's own — so a walk that resolved
+    // only deny-listed candidates still exposes a prior xpath to
+    // `shouldSkipTechnique`'s `anyXpathResolved` gate, keeping `structured-click`
+    // reachable at attempt 3.
+    const runDeepLocatorClickWalk = async (args) => {
+        const { candidates, innerSelector, preferTrustedClick, labelPrefix, record, attempt, pre } = args;
+        const attemptTriedSelectors = [];
+        const denyCandidate = (candidate) => {
+            const denied = isWizardExitAction(candidate.accessibleText, wizardExitButtonLabels);
+            if (denied) {
+                logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: refused wizard-exit control: "${candidate.accessibleText.slice(0, 60)}"`);
+            }
+            return denied;
+        };
+        const actuation = resolveDeepLocatorActuation(step);
+        const isSelectionIntentClick = actuation.kind === "click" && parseSelectStep(step) !== null;
+        const baselineSelectionCount = isSelectionIntentClick
+            ? selectionCountFromSignature(pre.visibleTextSignature)
+            : null;
+        const readSelectionCount = isSelectionIntentClick
+            ? async () => {
+                try {
+                    const snap = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
+                    return selectionCountFromSignature(snap.visibleTextSignature);
+                }
+                catch {
+                    return null;
+                }
+            }
+            : undefined;
+        const cascadeResult = await (0, deep_locator_click_1.clickFirstActionableCandidate)(candidates, async (candidate) => {
+            attemptTriedSelectors.push(candidate.selector);
+            if (actuation.kind === "select") {
+                const verified = await (0, deep_locator_actuate_1.selectDeepLocatorCandidateOption)(page, frameTarget?.frameSelector, innerSelector, candidate.index, actuation.value, { frameTarget });
+                // selectDeepLocatorCandidateOption never throws on an ordinary failed
+                // write (see deep-locator-actuate.ts's writeAndVerify) — it resolves
+                // `false` for both a rejected selectOption() and a read-back mismatch.
+                // clickFirstActionableCandidate infers success from "didn't throw", so
+                // a `false` here must become a throw or the walk would wrongly report
+                // this candidate as actuated.
+                if (!verified)
+                    throw new Error("-32000 Node does not have a layout object");
+            }
+            else if (actuation.kind === "fill") {
+                const verified = await (0, deep_locator_actuate_1.fillDeepLocatorCandidate)(page, frameTarget?.frameSelector, innerSelector, candidate.index, actuation.value, { frameTarget });
+                if (!verified)
+                    throw new Error("-32000 Node does not have a layout object");
+            }
+            else {
+                await (0, deep_locator_candidates_1.clickDeepLocatorCandidate)(page, frameTarget?.frameSelector, innerSelector, candidate.index, {
+                    frameTarget,
+                    preferTrustedClick,
+                });
+            }
+        }, { denyCandidate, readSelectionCount, baselineSelectionCount })
+            .then((outcome) => ({ outcome, error: null }))
+            .catch((error) => ({ outcome: null, error }));
+        triedSelectors.push(...attemptTriedSelectors);
+        if (cascadeResult.outcome?.clicked && cascadeResult.outcome.candidate) {
+            const acted = cascadeResult.outcome.candidate;
+            record.triedSelectors = [...attemptTriedSelectors];
+            const verb = actuation.kind === "select" ? "selected" : actuation.kind === "fill" ? "filled" : "clicked";
+            record.instruction = `${labelPrefix}: ${acted.accessibleText || "(no accessible text)"}`;
+            record.actResultSuccess = true;
+            record.actResultDescription = `${labelPrefix} ${verb} "${acted.accessibleText || acted.selector}"`;
+            // Synthesize an action matching the actuation kind so downstream
+            // verification (network/url/dom — STATE_CLASS_METHODS treats
+            // fill/selectOption as DOM-verifiable, not click) treats this exactly like
+            // any other resolved action — same idiom as deep-submit-locator/structured-click.
+            const resolvedAction = actuation.kind === "click"
+                ? { selector: acted.selector, description: record.actResultDescription, method: "click" }
+                : {
+                    selector: acted.selector,
+                    description: record.actResultDescription,
+                    method: actuation.kind === "select" ? "selectOption" : "fill",
+                    arguments: [actuation.value],
+                };
+            return { resolvedAction };
+        }
+        // Failure: carry the running triedSelectors (prior xpath + this walk's own)
+        // into the record so anyXpathResolved stays true even when every resolved
+        // candidate was deny-listed (attemptTriedSelectors would be empty then).
+        record.triedSelectors = [...triedSelectors];
+        const counterStalledCount = cascadeResult.outcome?.counterStalledSelectors.length ?? 0;
+        const failureMessage = cascadeResult.error
+            ? `${labelPrefix}: ${actuation.kind} threw ${(0, errors_1.toErrorMessage)(cascadeResult.error)}`
+            : counterStalledCount > 0
+                ? `${labelPrefix}: clicked ${counterStalledCount} candidate(s) but the "N selected" counter never rose (no selection registered)`
+                : attemptTriedSelectors.length > 0
+                    ? `${labelPrefix}: no actionable candidate (${attemptTriedSelectors.length} not-actionable)`
+                    : `${labelPrefix}: no actionable candidate (every candidate refused by the wizard-exit deny-list)`;
+        record.actResultSuccess = false;
+        record.errorMessage = failureMessage;
+        attempts.push(record);
+        failureReasons.push(failureMessage);
+        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${failureMessage}`);
+        return { resolvedAction: null };
+    };
     let phantomClickAfterAttempt1 = false;
     for (let attempt = 1; attempt <= MAX_STEP_ATTEMPTS; attempt++) {
         // Telemetry-driven technique-skip: when a cascade technique's
@@ -5583,7 +5691,9 @@ async function executeStepWithHealing(params) {
             const wouldBeTechnique = attempt === 2
                 ? phantomClickAfterAttempt1 && (isFinalStep || submitStep)
                     ? "deep-submit-locator"
-                    : "observe-act"
+                    : phantomClickAfterAttempt1
+                        ? "trusted-click-retry"
+                        : "observe-act"
                 : attempt === 3
                     ? "structured-click"
                     : attempt === 4
@@ -5842,6 +5952,113 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
+            else if (attempt === 2 && phantomClickAfterAttempt1 && !(isFinalStep || submitStep)) {
+                // Trusted-click retry: attempt 1 phantom-clicked a NON-submit control —
+                // Stagehand reported success but pre/post showed zero effect. On a
+                // design-system widget (React synthetic-event delegation, custom
+                // event-bound wrappers) the likely cause is that the attempt-1 click was
+                // an in-page, `isTrusted=false` activation the handler ignores — the
+                // element resolves fine, but only a REAL user gesture registers. So
+                // re-click the target with a TRUSTED gesture. Two arms by page shape:
+                // a top-window (no frame seam) page re-clicks attempt-1's resolved xpath
+                // via a Playwright `.locator().first().click()` on the main frame; an
+                // OOPIF/cross-origin page re-resolves via the frame-seam deepLocator and
+                // clicks through `clickDeepLocatorCandidate` → `deepLocator().nth().click()`
+                // (an `Input.dispatchMouseEvent`). Both deliver `isTrusted=true`. This is
+                // the non-submit sibling of the deep-submit-locator escalation above.
+                record.technique = "trusted-click-retry";
+                // Carry forward any selector prior attempts already resolved (e.g.
+                // attempt-1 act-string's xpath) so a trusted-click-retry that can't
+                // resolve a deepLocator candidate doesn't erase the xpath signal
+                // structured-click's precondition (shouldSkipTechnique) depends on —
+                // this attempt is an ADDITIONAL recovery, not a replacement that
+                // demotes the rest of the ladder.
+                if (!frameTarget?.frame) {
+                    // Top-window path: this wizard renders in the top document with no
+                    // cross-origin OOPIF, so `deepLocator` (which is built entirely on a
+                    // frame seam — deep-locator-candidates.ts's resolveScanFrameTarget
+                    // returns null when no frameSelector resolves) yields nothing. The
+                    // trusted-click primitive `deepLocator().nth().click()` is therefore
+                    // unreachable, but the ACTIVATION we need — a real `isTrusted=true`
+                    // gesture the Base Web handler honours — is still deliverable via a
+                    // Playwright Locator click on the top frame (the same trusted click
+                    // applyRadioSelection uses at Tier A). Re-click attempt-1's resolved
+                    // xpath through the main-frame FrameTarget's `.locator()` instead of
+                    // bailing; the synthesized click action flows through the standard
+                    // verifier exactly like the frame-seam path's result.
+                    //
+                    // FIRST xpath, not last: attempt-1's act pushes every resolved
+                    // action's selector into `triedSelectors` in order but binds the
+                    // phantom-classified `resolvedAction` to the FIRST (see the
+                    // `if (!resolvedAction)` at the attempt-1 branch). On a multi-action
+                    // attempt-1 the last entry is a different control than the one that
+                    // was clicked, so the first match is the phantomed target.
+                    const topWindowSelector = triedSelectors.find((sel) => xpathBodyForEvaluate(sel) !== null);
+                    if (!topWindowSelector) {
+                        const failureMessage = "trusted-click-retry: no top-window selector resolved for the phantomed target";
+                        record.actResultSuccess = false;
+                        record.errorMessage = failureMessage;
+                        record.triedSelectors = [...triedSelectors];
+                        attempts.push(record);
+                        failureReasons.push(failureMessage);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${failureMessage}`);
+                        continue;
+                    }
+                    const topWindowTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+                    try {
+                        await topWindowTarget.locator(topWindowSelector).first().click();
+                    }
+                    catch (err) {
+                        const failureMessage = `trusted-click-retry: top-window trusted click threw ${(0, errors_1.toErrorMessage)(err)}`;
+                        record.actResultSuccess = false;
+                        record.errorMessage = failureMessage;
+                        record.triedSelectors = [...triedSelectors];
+                        attempts.push(record);
+                        failureReasons.push(failureMessage);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${failureMessage}`);
+                        continue;
+                    }
+                    record.instruction = `trusted-click-retry (top-window): ${topWindowSelector}`;
+                    record.actResultSuccess = true;
+                    record.actResultDescription = `trusted-click-retry clicked "${topWindowSelector}" via top-window locator`;
+                    record.triedSelectors = [...triedSelectors];
+                    logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: trusted-click-retry: top-window trusted locator click on the resolved target`);
+                    resolvedAction = {
+                        selector: topWindowSelector,
+                        description: record.actResultDescription,
+                        method: "click",
+                    };
+                }
+                else {
+                    await reresolveFrameTargetIfLost();
+                    const { candidates: retryCandidates, innerSelector: retryInnerSelector } = await resolveDeepLocatorCandidatesWithWidening(page, frameTarget.frameSelector, step, {
+                        frameTarget,
+                    });
+                    const deepLocatorCandidates = retryCandidates.filter((c) => !triedSelectors.includes(c.selector));
+                    if (deepLocatorCandidates.length === 0) {
+                        const failureMessage = "trusted-click-retry: no deepLocator candidate resolved for the phantomed target";
+                        record.actResultSuccess = false;
+                        record.errorMessage = failureMessage;
+                        record.triedSelectors = [...triedSelectors];
+                        attempts.push(record);
+                        failureReasons.push(failureMessage);
+                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${failureMessage}`);
+                        continue;
+                    }
+                    const { resolvedAction: retryResolvedAction } = await runDeepLocatorClickWalk({
+                        candidates: deepLocatorCandidates,
+                        innerSelector: retryInnerSelector,
+                        preferTrustedClick: true,
+                        labelPrefix: "trusted-click-retry",
+                        record,
+                        attempt,
+                        pre,
+                    });
+                    if (!retryResolvedAction)
+                        continue;
+                    resolvedAction = retryResolvedAction;
+                }
+            }
             else if (attempt === 2 || attempt === 4) {
                 record.technique = attempt === 2 ? "observe-act" : "observe-act-exclude";
                 const observeOptions = attempt === 4 && triedSelectors.length > 0
@@ -5929,128 +6146,26 @@ async function executeStepWithHealing(params) {
                             continue;
                         }
                     }
-                    // Actionable-candidate walk: a top pick that rejects with the CDP
-                    // `-32000 Node does not have a layout object` error (an unrendered
-                    // node) or is refused by the wizard-exit deny-list costs only that
-                    // one candidate, not the whole attempt — the next ranked candidate
-                    // is tried instead. `attemptTriedSelectors` parallels the walk's own
-                    // click attempts as they happen (not just on a successful return)
-                    // so a click that throws a REAL error (e.g. a wedged
-                    // `WatchdogTimeoutError`) still feeds attempt 4's exclusion filter.
-                    const attemptTriedSelectors = [];
-                    const denyCandidate = (candidate) => {
-                        const denied = isWizardExitAction(candidate.accessibleText, wizardExitButtonLabels);
-                        if (denied) {
-                            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: refused wizard-exit control: "${candidate.accessibleText.slice(0, 60)}"`);
-                        }
-                        return denied;
-                    };
-                    // Intent discrimination: observe()'s Stagehand-resolved action
-                    // carries its own method + fill/select arguments (see attempt 1's
-                    // `target.method === "fill"` handling above); the deepLocator
-                    // fallback has no such resolved action, so the step prose is the
-                    // only place the fill/select value can come from. Derived once per
-                    // attempt (not per candidate) — every candidate in this walk is a
-                    // guess at the SAME step's target, so they all actuate the same way.
-                    const actuation = resolveDeepLocatorActuation(step);
-                    // Next-best-candidate recovery for a markerless multi-select phantom:
-                    // a click-to-toggle option (not a native <select> write, which
-                    // already read-back-verifies) whose "N selected" counter doesn't rise
-                    // means the click landed but didn't register — so the walk should try
-                    // the next real option before this attempt is scored a failure and a
-                    // replan is spent. Only wired for a selection-intent CLICK step; the
-                    // reader re-reads the same counter `pre` captured (via
-                    // `selectionCountFromSignature`) so no extra pre-snapshot is paid, and
-                    // returns `null` on any frame hiccup so a read failure never converts
-                    // to a walk-stopping throw. Non-selection steps pass `undefined` and
-                    // the walk behaves exactly as before.
-                    const isSelectionIntentClick = actuation.kind === "click" && parseSelectStep(step) !== null;
-                    const baselineSelectionCount = isSelectionIntentClick
-                        ? selectionCountFromSignature(pre.visibleTextSignature)
-                        : null;
-                    const readSelectionCount = isSelectionIntentClick
-                        ? async () => {
-                            try {
-                                const snap = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
-                                return selectionCountFromSignature(snap.visibleTextSignature);
-                            }
-                            catch {
-                                return null;
-                            }
-                        }
-                        : undefined;
-                    const cascadeResult = await (0, deep_locator_click_1.clickFirstActionableCandidate)(deepLocatorCandidates, async (candidate) => {
-                        attemptTriedSelectors.push(candidate.selector);
-                        if (actuation.kind === "select") {
-                            const verified = await (0, deep_locator_actuate_1.selectDeepLocatorCandidateOption)(page, frameTarget?.frameSelector, deepLocatorInnerSelector, candidate.index, actuation.value, { frameTarget });
-                            // selectDeepLocatorCandidateOption never throws on an ordinary
-                            // failed write (see deep-locator-actuate.ts's writeAndVerify) —
-                            // it resolves `false` for both a rejected selectOption() and a
-                            // read-back mismatch. clickFirstActionableCandidate infers
-                            // success from "didn't throw", so a `false` here must become a
-                            // throw or the walk would wrongly report this candidate as
-                            // actuated.
-                            if (!verified)
-                                throw new Error("-32000 Node does not have a layout object");
-                        }
-                        else if (actuation.kind === "fill") {
-                            const verified = await (0, deep_locator_actuate_1.fillDeepLocatorCandidate)(page, frameTarget?.frameSelector, deepLocatorInnerSelector, candidate.index, actuation.value, { frameTarget });
-                            if (!verified)
-                                throw new Error("-32000 Node does not have a layout object");
-                        }
-                        else {
-                            await (0, deep_locator_candidates_1.clickDeepLocatorCandidate)(page, frameTarget?.frameSelector, deepLocatorInnerSelector, candidate.index, { frameTarget });
-                        }
-                    }, { denyCandidate, readSelectionCount, baselineSelectionCount })
-                        .then((outcome) => ({ outcome, error: null }))
-                        .catch((error) => ({ outcome: null, error }));
-                    triedSelectors.push(...attemptTriedSelectors);
-                    record.triedSelectors = [...attemptTriedSelectors];
-                    if (cascadeResult.outcome?.clicked && cascadeResult.outcome.candidate) {
-                        const acted = cascadeResult.outcome.candidate;
-                        const verb = actuation.kind === "select"
-                            ? "selected"
-                            : actuation.kind === "fill"
-                                ? "filled"
-                                : "clicked";
-                        record.instruction = `deepLocator: ${acted.accessibleText || "(no accessible text)"}`;
-                        record.actResultSuccess = true;
-                        record.actResultDescription = `deepLocator ${verb} "${acted.accessibleText || acted.selector}"`;
-                        // Synthesize an action matching the actuation kind so downstream
-                        // verification (network/url/dom — STATE_CLASS_METHODS treats
-                        // fill/selectOption as DOM-verifiable, not click) treats this
-                        // exactly like any other resolved action — same idiom as
-                        // deep-submit-locator/structured-click.
-                        resolvedAction =
-                            actuation.kind === "click"
-                                ? {
-                                    selector: acted.selector,
-                                    description: record.actResultDescription,
-                                    method: "click",
-                                }
-                                : {
-                                    selector: acted.selector,
-                                    description: record.actResultDescription,
-                                    method: actuation.kind === "select" ? "selectOption" : "fill",
-                                    arguments: [actuation.value],
-                                };
-                    }
-                    else {
-                        const counterStalledCount = cascadeResult.outcome?.counterStalledSelectors.length ?? 0;
-                        const failureMessage = cascadeResult.error
-                            ? `deepLocator: ${actuation.kind} threw ${(0, errors_1.toErrorMessage)(cascadeResult.error)}`
-                            : counterStalledCount > 0
-                                ? `deepLocator: clicked ${counterStalledCount} candidate(s) but the "N selected" counter never rose (no selection registered)`
-                                : attemptTriedSelectors.length > 0
-                                    ? `deepLocator: no actionable candidate (${attemptTriedSelectors.length} not-actionable)`
-                                    : "deepLocator: no actionable candidate (every candidate refused by the wizard-exit deny-list)";
-                        record.actResultSuccess = false;
-                        record.errorMessage = failureMessage;
-                        attempts.push(record);
-                        failureReasons.push(failureMessage);
-                        logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${failureMessage}`);
+                    // Actionable-candidate walk (shared with the trusted-click-retry
+                    // branch): a top pick that rejects with the CDP `-32000 Node does not
+                    // have a layout object` error (an unrendered node) or is refused by
+                    // the wizard-exit deny-list costs only that one candidate, not the
+                    // whole attempt — the next ranked candidate is tried instead. The
+                    // observe-act path activates via the synthetic fast click
+                    // (preferTrustedClick: false); the trusted CDP click is the
+                    // phantom-retry escalation.
+                    const { resolvedAction: walkResolvedAction } = await runDeepLocatorClickWalk({
+                        candidates: deepLocatorCandidates,
+                        innerSelector: deepLocatorInnerSelector,
+                        preferTrustedClick: false,
+                        labelPrefix: "deepLocator",
+                        record,
+                        attempt,
+                        pre,
+                    });
+                    if (!walkResolvedAction)
                         continue;
-                    }
+                    resolvedAction = walkResolvedAction;
                 }
                 else if (candidates.length === 0) {
                     record.errorMessage = "observe returned no candidates";
@@ -7149,7 +7264,7 @@ async function executeStepWithHealing(params) {
                 const suppressedCount = getSuppressedAisdkElementIdErrorCount?.();
                 const escalationTarget = isFinalStep || submitStep
                     ? "escalating attempt 2 to deep-submit-locator"
-                    : "non-submit step — leaving the normal structured-click/observe-act-exclude ladder intact";
+                    : "non-submit step — escalating attempt 2 to trusted-click-retry (trusted CDP click on the resolved target)";
                 logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} phantom click detected on attempt 1 (${record.technique}): reported success with no network/url/dom change${suppressedCount !== undefined ? `; ${suppressedCount} AISDK elementId errors suppressed this session (corroborating, not causal)` : ""} — ${escalationTarget}`);
             }
             const postAttemptInvalidCount = await countNgInvalidContainers(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page));