@enricai/barnacle 1.9.10 → 1.9.12

package/dist/scraper/flow-runner.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRAILING_GRACE_WINDOW = exports.STEP_WATCHDOG_MS = exports.GOTO_TIMEOUT_MS = void 0;
 exports.mergeResponseHeaders = mergeResponseHeaders;
 exports.wireSignalCapture = wireSignalCapture;
+exports.prepareFailureDumpBody = prepareFailureDumpBody;
 exports.snapshotPage = snapshotPage;
 exports.findRecentBackendError = findRecentBackendError;
 exports.findRecentPageTransition = findRecentPageTransition;
@@ -32,6 +33,8 @@ exports.shouldVetoFallbackAdvance = shouldVetoFallbackAdvance;
 exports.isDomOnlyAdvanceVerified = isDomOnlyAdvanceVerified;
 exports.isClickViewSwapVerified = isClickViewSwapVerified;
 exports.isClickStateToggleVerified = isClickStateToggleVerified;
+exports.selectionCountFromSignature = selectionCountFromSignature;
+exports.isSelectionCounterStalled = isSelectionCounterStalled;
 exports.shouldReadbackFillOnActSuccess = shouldReadbackFillOnActSuccess;
 exports.countNgInvalidContainers = countNgInvalidContainers;
 exports.describeAttemptEffectSignals = describeAttemptEffectSignals;
@@ -95,6 +98,7 @@ const schemas_1 = require("../lib/llm/schemas");
 const logging_1 = require("../lib/logging");
 const call_capture_1 = require("../lib/telemetry/call-capture");
 const call_types_1 = require("../lib/telemetry/call-types");
+const browser_click_expr_1 = require("../scraper/browser-click-expr");
 const deep_locator_actuate_1 = require("../scraper/deep-locator-actuate");
 const deep_locator_candidates_1 = require("../scraper/deep-locator-candidates");
 const deep_locator_click_1 = require("../scraper/deep-locator-click");
@@ -481,6 +485,35 @@ const INVALID_MARKER_EL_EXPR = `((el) => {
  * final Continue/Submit click.
  */
 exports.TRAILING_GRACE_WINDOW = 2;
+/** Cap on a single attribute value before a failure-bundle DOM capture keeps it. */
+const FAILURE_DUMP_MAX_ATTR_LENGTH = 2_000;
+/** Byte budget for a failure-bundle `bodyOuterHtml` capture after attribute pruning. */
+const FAILURE_DUMP_MAX_BODY_LENGTH = 100_000;
+const FAILURE_DUMP_ATTR_RX = new RegExp(`="([^"]{${FAILURE_DUMP_MAX_ATTR_LENGTH},})"|='([^']{${FAILURE_DUMP_MAX_ATTR_LENGTH},})'`, "g");
+/**
+ * Prepares a `document.body.outerHTML` string for a step-failure bundle so it
+ * shows RENDERED controls, not a cut-off shell. A single data-carrying attribute
+ * (a SPA mount point's `data="{…}"` state blob, a long `value=`) can exceed the
+ * whole body budget on its own, pushing the actual `<button>`/`<input>` markup
+ * past the truncation point — which reads in the bundle as "empty DOM / 0
+ * buttons" when the page is fully hydrated. Collapse any attribute value longer
+ * than {@link FAILURE_DUMP_MAX_ATTR_LENGTH} to an elided marker BEFORE the length
+ * cap, then slice to {@link FAILURE_DUMP_MAX_BODY_LENGTH}. The double- and
+ * single-quoted alternatives are kept separate (rather than a `\1` backreference)
+ * so a double-quoted value may contain apostrophes — and vice versa — without
+ * ending the match early, which a shared `[^"']` class would wrongly do. Returns
+ * null passthrough so callers keep their "evaluate failed → null" contract.
+ */
+function prepareFailureDumpBody(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const pruned = raw.replace(FAILURE_DUMP_ATTR_RX, (_m, dq, sq) => {
+        const value = dq ?? sq ?? "";
+        const quote = dq !== undefined ? '"' : "'";
+        return `=${quote}[elided ${value.length} chars]${quote}`;
+    });
+    return pruned.slice(0, FAILURE_DUMP_MAX_BODY_LENGTH);
+}
 /**
  * Trust boundary: static string literal, fixed at compile time. No interpolation
  * means no injection surface. Runs in browser context and returns a typed-narrow
@@ -1008,6 +1041,48 @@ function isClickStateToggleVerified(params) {
         return false;
     return selectionStateChanged;
 }
+/**
+ * Reads the "N settings/items selected" running count that multi-select wizard
+ * steps render as a live heading above the option grid. Returns the integer, or
+ * `null` when the snapshot has no such counter. Operates on a
+ * {@link StepSnapshot.visibleTextSignature}, which is
+ * `"<len>:<first-200-chars-of-innerText>"` — the counter idiom sits at the top
+ * of these steps, so it is always inside the 200-char window.
+ *
+ * Exists because some SPA multi-selects (obfuscated hashed classes, no
+ * `aria-pressed`/`data-state`) expose no selection-state attribute at all, so
+ * {@link isClickStateToggleVerified}'s fingerprint is structurally blind and a
+ * phantom option click rides the generic DOM-delta gate to a FALSE credit — the
+ * running counter is the only trustworthy "did the selection register" signal.
+ */
+function selectionCountFromSignature(visibleTextSignature) {
+    const colon = visibleTextSignature.indexOf(":");
+    const text = colon === -1 ? visibleTextSignature : visibleTextSignature.slice(colon + 1);
+    const match = text.match(/(\d+)\s+(?:(?:settings?|items?|options?)\s+)?selected\b/i);
+    const digits = match?.[1];
+    return digits === undefined ? null : Number.parseInt(digits, 10);
+}
+/**
+ * Veto for a SELECTION-intent step whose weak DOM signals (view-swap byte delta,
+ * a non-advance `domVerified` reflow) would otherwise credit a click that did
+ * NOT register the selection. When the step's snapshot exposes a running
+ * "N selected" counter (see {@link selectionCountFromSignature}) and that count
+ * did not increase across the click, the option was not actually selected — a
+ * phantom the fingerprint can't catch — so the caller must NOT treat the weak
+ * signals as verification and should keep healing. Returns `true` only when a
+ * counter is present on BOTH snapshots and did not rise; absent a counter it
+ * returns `false` (no veto), so counter-less selection widgets are untouched.
+ */
+function isSelectionCounterStalled(params) {
+    const { isSelectionStep, preVisibleTextSignature, postVisibleTextSignature } = params;
+    if (!isSelectionStep)
+        return false;
+    const pre = selectionCountFromSignature(preVisibleTextSignature);
+    const post = selectionCountFromSignature(postVisibleTextSignature);
+    if (pre === null || post === null)
+        return false;
+    return post <= pre;
+}
 /**
  * Whether an act-success step warrants a committed-value read-back before the
  * weak view-swap/form-value signals are allowed to accept it. A controlled
@@ -5383,7 +5458,7 @@ async function executeStepWithHealing(params) {
         const bodyOuterHtmlRaw = await (frameTarget ?? page)
             .evaluate("document.body ? document.body.outerHTML : null")
             .catch(() => null);
-        const bodyOuterHtml = typeof bodyOuterHtmlRaw === "string" ? bodyOuterHtmlRaw.slice(0, 100_000) : null;
+        const bodyOuterHtml = prepareFailureDumpBody(bodyOuterHtmlRaw);
         const probeAbsentObservedUnfocused = await (0, stagehand_guard_1.guardedObserve)(stagehand, undefined, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
         // observe() is blind to a cross-origin OOPIF, so a frame-scoped empty
         // result degrades to the deep-locator resolver for dump evidence — this
@@ -5841,7 +5916,7 @@ async function executeStepWithHealing(params) {
                     if (selectStep && !selectStep.questionLabel) {
                         const selectCandidates = await (0, deep_locator_candidates_1.resolveDeepLocatorCandidates)(page, frameTarget?.frameSelector, "select", null, { frameTarget });
                         const optionPhrases = (0, deep_locator_candidates_1.extractTaggedPhrases)(step);
-                        const optionScores = selectCandidates.map((candidate) => (0, deep_locator_candidates_1.scoreCandidate)(candidate.accessibleText, optionPhrases));
+                        const optionScores = selectCandidates.map((candidate) => (0, deep_locator_candidates_1.scoreCandidate)(candidate.accessibleText, optionPhrases, candidate.isNav));
                         const topScore = optionScores.length > 0 ? Math.max(...optionScores) : 0;
                         const tiedForTop = optionScores.filter((score) => score === topScore).length;
                         if (tiedForTop > 1) {
@@ -5878,6 +5953,32 @@ async function executeStepWithHealing(params) {
                     // 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") {
@@ -5900,7 +6001,7 @@ async function executeStepWithHealing(params) {
                         else {
                             await (0, deep_locator_candidates_1.clickDeepLocatorCandidate)(page, frameTarget?.frameSelector, deepLocatorInnerSelector, candidate.index, { frameTarget });
                         }
-                    }, { denyCandidate })
+                    }, { denyCandidate, readSelectionCount, baselineSelectionCount })
                         .then((outcome) => ({ outcome, error: null }))
                         .catch((error) => ({ outcome: null, error }));
                     triedSelectors.push(...attemptTriedSelectors);
@@ -5935,11 +6036,14 @@ async function executeStepWithHealing(params) {
                                 };
                     }
                     else {
+                        const counterStalledCount = cascadeResult.outcome?.counterStalledSelectors.length ?? 0;
                         const failureMessage = cascadeResult.error
                             ? `deepLocator: ${actuation.kind} threw ${(0, errors_1.toErrorMessage)(cascadeResult.error)}`
-                            : attemptTriedSelectors.length > 0
-                                ? `deepLocator: no actionable candidate (${attemptTriedSelectors.length} not-actionable)`
-                                : "deepLocator: no actionable candidate (every candidate refused by the wizard-exit deny-list)";
+                            : 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);
@@ -6512,12 +6616,33 @@ async function executeStepWithHealing(params) {
                 }
             }
         }
+        // Selection-counter veto. A multi-select option click whose widget exposes
+        // no aria/data-state marker (obfuscated hashed classes) leaves
+        // `clickStateToggleVerified` blind, so a phantom that merely reflowed the
+        // DOM would ride the weak `domVerifiedForStep`/`clickViewSwapVerified`
+        // signals to a FALSE credit — the flow then advances to a "Next" that
+        // no-ops because nothing was actually selected. When the step's running
+        // "N selected" counter did not rise, suppress those weak DOM-delta signals
+        // so the cascade keeps trying a real selection. Strong signals (real
+        // network/URL transition) and the counter-independent state-toggle /
+        // form-value signals — each of which IS the selection registering — are
+        // never vetoed; counter-less widgets are untouched (the helper no-ops).
+        const selectionCounterStalled = isSelectionCounterStalled({
+            isSelectionStep: parseSelectStep(step) !== null,
+            preVisibleTextSignature: pre.visibleTextSignature,
+            postVisibleTextSignature: post.visibleTextSignature,
+        });
+        if (selectionCounterStalled && (domVerifiedForStep || clickViewSwapVerified)) {
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} selection step credited only via DOM reflow but the "N selected" counter did not rise — the option did not register; not treating the weak DOM signal as verified`);
+        }
+        const domVerifiedAfterCounter = selectionCounterStalled ? false : domVerifiedForStep;
+        const clickViewSwapAfterCounter = selectionCounterStalled ? false : clickViewSwapVerified;
         let verified = networkIsRealAdvance ||
             urlChanged ||
-            domVerifiedForStep ||
+            domVerifiedAfterCounter ||
             datepickerCommitted ||
             (!datepickerRejected &&
-                (clickViewSwapVerified || formValueVerified || clickStateToggleVerified));
+                (clickViewSwapAfterCounter || formValueVerified || clickStateToggleVerified));
         // Final-step submit-verification gate. Replaces the deterministic
         // submitEndpointPattern regex with a Haiku 4.5 LLM judgment over
         // multi-signal evidence (network captures, page URL/title, DOM
@@ -6695,7 +6820,7 @@ async function executeStepWithHealing(params) {
                     // default action, but isolated-world page.evaluate() click()s don't
                     // reliably trigger that default action — same gap N+42 documented
                     // for direct checkbox/radio clicks.
-                    const clickExpr = `(() => { const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null); let el = r.singleNodeValue; if (!el || typeof el.click !== "function") return { fired: false }; if (el.tagName === "LABEL") { const wrapped = el.querySelector("input[type=checkbox], input[type=radio]"); if (wrapped) el = wrapped; } if (el.type === "checkbox" || el.type === "radio") { el.checked = true; el.dispatchEvent(new Event("click", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); return { fired: true, kind: "checkbox", checked: el.checked }; } el.click(); return { fired: true, kind: "click" }; })()`;
+                    const clickExpr = `(() => { const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null); let el = r.singleNodeValue; if (!el || typeof el.click !== "function") return { fired: false }; if (el.tagName === "LABEL") { const wrapped = el.querySelector("input[type=checkbox], input[type=radio]"); if (wrapped) el = wrapped; } if (el.type === "checkbox" || el.type === "radio") { el.checked = true; el.dispatchEvent(new Event("click", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); return { fired: true, kind: "checkbox", checked: el.checked }; } ${(0, browser_click_expr_1.clickActivationExpr)("el")} return { fired: true, kind: "click" }; })()`;
                     const n16FallbackTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
                     const probeResult = (await n16FallbackTarget.evaluate(clickExpr));
                     const fired = probeResult.fired;
@@ -6802,12 +6927,26 @@ async function executeStepWithHealing(params) {
                     // only a strong signal (network/url) or a verified checkbox state may
                     // pass. Non-final/submit steps are unaffected.
                     const weakDomSignalsAllowed = (!isFinalStep && !submitStep) || requireSubmitEndpoint;
+                    // Selection-counter veto for the n+16 fallback — the same gate the
+                    // primary verifier applies, recomputed against `retryPost`. Without
+                    // it this path would re-credit a stalled selection the primary veto
+                    // already suppressed: the fallback `el.click()` can reflow the DOM
+                    // (html/text/selection-state delta) without registering the option,
+                    // and those weak deltas are exactly what the OR below admits for a
+                    // non-final selection step. Only the weak-delta disjunct is vetoed;
+                    // strong signals (network/url) and a verified checkbox state pass.
+                    const retrySelectionCounterStalled = isSelectionCounterStalled({
+                        isSelectionStep: parseSelectStep(step) !== null,
+                        preVisibleTextSignature: pre.visibleTextSignature,
+                        postVisibleTextSignature: retryPost.visibleTextSignature,
+                    });
                     let retryVerified = !clickBlockedByInvalid &&
                         !fallbackDomOnlyAdvance &&
                         (retryNetworkFired ||
                             retryUrlChanged ||
                             checkboxStateVerified ||
                             (weakDomSignalsAllowed &&
+                                !retrySelectionCounterStalled &&
                                 (retryHtmlDelta !== 0 ||
                                     retryTextChanged ||
                                     retryFormValueChanged ||
@@ -7070,7 +7209,7 @@ async function executeStepWithHealing(params) {
     const bodyOuterHtmlRaw = await (frameTarget ?? (0, frame_target_1.mainFrameTarget)(page))
         .evaluate("document.body ? document.body.outerHTML : null")
         .catch(() => null);
-    const bodyOuterHtml = typeof bodyOuterHtmlRaw === "string" ? bodyOuterHtmlRaw.slice(0, 100_000) : null;
+    const bodyOuterHtml = prepareFailureDumpBody(bodyOuterHtmlRaw);
     const cascadeExhaustObservedUnfocused = await (0, stagehand_guard_1.guardedObserve)(stagehand, undefined, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
     const unfocusedObserve = cascadeExhaustObservedUnfocused.length === 0 && frameTarget?.frame
         ? await deepLocatorCandidatesAsActions(page, frameTarget)