@enricai/barnacle 1.12.71 → 1.12.73

package/dist/scraper/flow-runner.js

@@ -19,6 +19,7 @@ exports.mergeResponseHeaders = mergeResponseHeaders;
 exports.wireSignalCapture = wireSignalCapture;
 exports.shouldRetryCaptchaRegistry = shouldRetryCaptchaRegistry;
 exports.prepareFailureDumpBody = prepareFailureDumpBody;
+exports.fieldValuesAtFailureExpr = fieldValuesAtFailureExpr;
 exports.snapshotPage = snapshotPage;
 exports.resolveDumpPageIdentity = resolveDumpPageIdentity;
 exports.findRecentBackendError = findRecentBackendError;
@@ -88,6 +89,7 @@ exports.hasUnfilledRequiredControlForStep = hasUnfilledRequiredControlForStep;
 exports.simulateDragDropUpload = simulateDragDropUpload;
 exports.dispatchJqueryChangeEvent = dispatchJqueryChangeEvent;
 exports.verifyDomEffect = verifyDomEffect;
+exports.formValidityProbeExpr = formValidityProbeExpr;
 exports.narrowInvalidFormControl = narrowInvalidFormControl;
 exports.formatStepPrefix = formatStepPrefix;
 exports.tryDeterministicFieldLabelActuation = tryDeterministicFieldLabelActuation;
@@ -952,6 +954,55 @@ function prepareFailureDumpBody(raw) {
  * agree on exactly what counts as a class-token selection marker.
  */
 const DOM_SNAPSHOT_EXPR = `(() => { const b = document.body; if (!b) return { html: 0, text: "", values: "", state: "" }; const t = b.innerText || ""; const controls = Array.from(b.querySelectorAll("input, textarea, select")).filter((el) => el.offsetParent !== null); const values = controls.map((el) => { if (el.type === "checkbox" || el.type === "radio") return el.checked ? "1" : "0"; return el.value || ""; }).join("|").slice(0, 2000); const ariaSel = "[aria-pressed],[aria-checked],[aria-selected],[data-state],[data-selected],[data-checked],[role=option],[role=switch],[role=checkbox],[role=menuitemcheckbox]"; const classSel = ${JSON.stringify(browser_click_expr_1.SELECTION_MARKER_CLASS_SELECTOR_SRC)}; const classRx = ${browser_click_expr_1.SELECTION_MARKER_CLASS_TOKEN_REGEX_SRC}; const skip = (el) => el.closest("[role=dialog],[role=tooltip],[aria-live]") !== null; const seen = new Set(); for (const el of b.querySelectorAll(ariaSel + "," + classSel)) { if (el.offsetParent !== null && !skip(el)) seen.add(el); } let idx = 0; const parts = []; for (const el of seen) { const ap = el.getAttribute("aria-pressed") || ""; const ac = el.getAttribute("aria-checked") || ""; const as = el.getAttribute("aria-selected") || ""; const dsRaw = el.getAttribute("data-state") || ""; const ds = (dsRaw === "open" || dsRaw === "closed") ? "" : dsRaw; const dsel = el.hasAttribute("data-selected") ? "1" : ""; const dchk = el.hasAttribute("data-checked") ? "1" : ""; const clsHit = classRx.test(el.getAttribute("class") || "") ? "1" : "0"; const i = idx++; if (!ap && !ac && !as && !ds && !dsel && !dchk && clsHit === "0") continue; parts.push(i + ":" + ap + "," + ac + "," + as + "," + ds + "," + dsel + "," + dchk + "," + clsHit); } const joined = parts.join("|"); let h = 2166136261; for (let k = 0; k < joined.length; k++) { h ^= joined.charCodeAt(k); h = Math.imul(h, 16777619); } const state = (h >>> 0).toString(36) + ":" + parts.length; return { html: (b.outerHTML || "").length, text: t.length + ":" + t.slice(0, 200), values, state }; })()`;
+/** Caps mirroring {@link DOM_SNAPSHOT_EXPR}'s truncation so a pathological page can't bloat the failure bundle. */
+const FIELD_VALUES_AT_FAILURE_MAX_CONTROLS = 200;
+const FIELD_VALUES_AT_FAILURE_MAX_VALUE_LENGTH = 500;
+/**
+ * Browser-side expression source returning `{label, value}[]` for every
+ * visible input/textarea/select, read via the live `.value`/`.checked`
+ * property rather than the serialized attribute. Exists because every
+ * DOM-direct fill path sets a control's value with `el.value = value` (the
+ * JS property), which is never reflected back into the `value=` content
+ * attribute `document.body.outerHTML` serializes — so a reparsed HTML
+ * snapshot can structurally never prove what a text field currently holds.
+ * The accessible-name resolution (`aria-labelledby`, then `aria-label`, then
+ * `label[for]`/wrapping `label`, then `name`/`id`/`placeholder`) mirrors
+ * `recon-browser.ts`'s `accessibleNameForControl` so the label a step
+ * targets and the label this capture keys on agree.
+ */
+function fieldValuesAtFailureExpr() {
+    return `(() => {
+    const b = document.body;
+    if (!b) return [];
+    const accessibleName = (el) => {
+      const labelledBy = el.getAttribute("aria-labelledby");
+      if (labelledBy) {
+        const text = labelledBy.split(/\\s+/).map((id) => document.getElementById(id)?.textContent ?? "").join(" ").trim();
+        if (text) return text;
+      }
+      const ariaLabel = el.getAttribute("aria-label");
+      if (ariaLabel && ariaLabel.trim()) return ariaLabel;
+      const id = el.getAttribute("id");
+      if (id) {
+        const label = document.querySelector("label[for=\\"" + CSS.escape(id) + "\\"]");
+        if (label && label.textContent && label.textContent.trim()) return label.textContent;
+      }
+      const wrappingLabel = el.closest("label");
+      if (wrappingLabel && wrappingLabel.textContent && wrappingLabel.textContent.trim()) return wrappingLabel.textContent;
+      return el.getAttribute("name") || id || el.getAttribute("placeholder") || "";
+    };
+    const controls = Array.from(b.querySelectorAll("input, textarea, select")).filter((el) => el.offsetParent !== null);
+    const out = [];
+    for (const el of controls) {
+      if (out.length >= ${FIELD_VALUES_AT_FAILURE_MAX_CONTROLS}) break;
+      const label = accessibleName(el).trim();
+      if (!label) continue;
+      const value = (el.type === "checkbox" || el.type === "radio") ? (el.checked ? "1" : "0") : (el.value || "");
+      out.push({ label: label.slice(0, 200), value: String(value).slice(0, ${FIELD_VALUES_AT_FAILURE_MAX_VALUE_LENGTH}) });
+    }
+    return out;
+  })()`;
+}
 /**
  * Captures the pre/post signal triple the submit-verify cascade diffs.
  * Accepts the optional `page` so a resolved child `FrameTarget` whose
@@ -1588,9 +1639,10 @@ function isClickViewSwapVerified(params) {
     // a real network/URL transition, leaving it structurally unverifiable.
     // `resolvedElementIsSubmitShaped` closes the same gap from the OTHER
     // direction: a step the flow never flagged `submitStep` can still resolve
-    // onto an objectively submit-shaped control (an HTML `type="submit"`
-    // affordance, or an unmarked `<button>` owned by a `<form>`, whose default
-    // type IS submit) — that control needs the same real-transition proof
+    // onto an objectively submit-shaped control per submit-control.ts's
+    // SUBMIT_SHAPE_EXPR (an explicit `type="submit"` affordance, or a
+    // non-native control that clears the same name/negative-text
+    // corroboration bar) — that control needs the same real-transition proof
     // regardless of flow authoring, so a byte-positive form reset can't be
     // mistaken for a byte-positive real submit.
     if (submitStep || resolvedElementIsSubmitShaped)
@@ -3281,12 +3333,11 @@ function xpathTailForRetarget(xpath) {
  * resolve) `FIRST_ORDERED_NODE_TYPE` silently accepts whichever one happens
  * to come first in document order — not necessarily the element the primary
  * xpath was tracking. Snapshotting every match and preferring one that is
- * objectively submit-shaped — native `type="submit"`/`type="image"`/
- * form-owned button, or (reusing submit-control.ts's exported
- * {@link SUBMIT_SHAPE_FALLBACK_EXPR}) a tag/role-agnostic generic-action
- * control — and not negative-text (reuses submit-control.ts's own
- * {@link NEGATIVE_TEXT_EXPR} vocabulary rather than a second copy) recovers
- * the plausible candidate instead of an arbitrary one.
+ * objectively submit-shaped — reusing submit-control.ts's exported
+ * {@link SUBMIT_SHAPE_EXPR}, the single site-agnostic predicate every submit-
+ * shape consumer now shares — and not negative-text (reuses submit-
+ * control.ts's own {@link NEGATIVE_TEXT_EXPR} vocabulary rather than a
+ * second copy) recovers the plausible candidate instead of an arbitrary one.
  * Falls back to the first document-order match when no candidate clears that
  * bar, preserving the previous behavior for every single-match (the common)
  * case.
@@ -3295,15 +3346,7 @@ const XPATH_TAIL_RETARGET_RESOLVE_FN_SRC = `((tail) => {
     const isNegative = ${submit_control_1.NEGATIVE_TEXT_EXPR};
     const accessibleName = (el) =>
       (el.getAttribute("aria-label") || el.textContent || "").replace(/\\s+/g, " ").trim().toLowerCase();
-    const isFallbackShaped = ${submit_control_1.SUBMIT_SHAPE_FALLBACK_EXPR};
-    const isSubmitShaped = (el) => {
-      if (!el || !el.tagName) return false;
-      const tag = el.tagName.toUpperCase();
-      const type = (el.getAttribute("type") || "").toLowerCase();
-      if (tag === "INPUT" && (type === "submit" || type === "image")) return true;
-      if (tag === "BUTTON" && (type === "submit" || type === "") && el.closest("form")) return true;
-      return isFallbackShaped(el, accessibleName(el), isNegative);
-    };
+    const isSubmitShaped = ${submit_control_1.SUBMIT_SHAPE_EXPR};
     const r = document.evaluate("//" + tail, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
     const nodes = [];
     for (let i = 0; i < r.snapshotLength; i++) nodes.push(r.snapshotItem(i));
@@ -3564,15 +3607,20 @@ async function resolvedClickTargetStillPresent(target, selector) {
  * Site-agnostic submit-shape signal read directly from the resolved click
  * target — the counterpart to the flow-authored `submitStep` flag. A step
  * the flow never flagged can still resolve onto an objectively submit-shaped
- * control: `<input type="submit">` / `<input type="image">`, a `<button>`
- * with no `type` (or `type="submit"`) owned by a `<form>` — per the HTML
- * spec a button's default type IS submit, so an unmarked in-form button
- * commits the form exactly like an explicit `type="submit"` one — or, via
- * {@link SUBMIT_SHAPE_FALLBACK_EXPR}, a tag/role-agnostic control (e.g. a
- * `<div>`/`<a>`) whose accessible name reads a generic action verb, or is the
- * sole actionable control in its form. Reuses submit-control.ts's own
- * widened predicate instead of a narrower, hand-duplicated tag/type-only
- * check, so a legitimately-clicked non-native submit control is not
+ * control, per submit-control.ts's exported {@link SUBMIT_SHAPE_EXPR}: an
+ * `<input type="submit">` / `<input type="image">`, a `<button>`/`<input>`
+ * carrying an EXPLICIT `type="submit"` attribute, or — the same
+ * corroboration-requiring path a non-native control must clear — a
+ * tag/role-agnostic control (e.g. a `<div>`/`<a>`) whose accessible name
+ * reads a generic action verb, or is the sole actionable control in its
+ * form. A default-type `<button>` merely owned by a `<form>` no longer
+ * earns unconditional credit from that structural fact alone: the HTML
+ * spec makes a button's default type submit, but structure alone is not
+ * proof of submit intent (e.g. a "Show contact form" reveal toggle a page
+ * happens to nest inside a `<form>`), so it must clear the same
+ * corroboration bar as a non-native control. Reuses submit-control.ts's
+ * own single predicate instead of a hand-duplicated tag/type-only check,
+ * so a legitimately-clicked non-native submit control is not
  * mis-classified as "not submit-shaped" here. Returns `false` — never
  * manufactures a submit-shape veto — on a non-xpath selector, a miss, or an
  * evaluate failure.
@@ -3596,18 +3644,8 @@ async function resolvedClickTargetIsSubmitShaped(target, selector, xpathTail = n
     if (!el && ${JSON.stringify(xpathTail)}) {
       el = ${XPATH_TAIL_RETARGET_RESOLVE_FN_SRC}(${JSON.stringify(xpathTail)});
     }
-    if (!el || !el.tagName) return false;
-    const tag = el.tagName.toUpperCase();
-    const type = (el.getAttribute("type") || "").toLowerCase();
-    if (tag === "INPUT" && (type === "submit" || type === "image")) return true;
-    if (tag === "BUTTON" && (type === "submit" || type === "") && el.closest("form")) return true;
-    const isNegative = ${submit_control_1.NEGATIVE_TEXT_EXPR};
-    const accessibleName = (node) =>
-      (node.getAttribute("aria-label") || node.textContent || "").replace(/\\s+/g, " ").trim().toLowerCase();
-    const isFallbackShaped = ${submit_control_1.SUBMIT_SHAPE_FALLBACK_EXPR};
-    const name = accessibleName(el);
-    if (isNegative(name)) return false;
-    return isFallbackShaped(el, name, isNegative);
+    const isSubmitShaped = ${submit_control_1.SUBMIT_SHAPE_EXPR};
+    return isSubmitShaped(el);
   })()`;
     try {
         return (await target.evaluate(expr)) === true;
@@ -4675,9 +4713,12 @@ function parseFieldLabelTarget(step) {
  * Name"); otherwise a substring match either direction (a `fieldLabel` of
  * "Acme Non-Employee ID" against an accessible name of "Non-Employee ID", or
  * the reverse) so minor phrasing drift between the flow's field noun and the
- * control's own label still resolves. Returns `null` — never a guess — when
- * no candidate's accessible name relates to `fieldLabel` at all, so the
- * caller can refuse to act rather than fill/click the wrong control.
+ * control's own label still resolves; when multiple candidates qualify via
+ * substring, the one whose length is closest to `fieldLabel`'s (the most
+ * specific match) wins, not whichever happened to come first. Returns
+ * `null` — never a guess — when no candidate's accessible name relates to
+ * `fieldLabel` at all, so the caller can refuse to act rather than
+ * fill/click the wrong control.
  */
 function findDeepLocatorCandidateByFieldLabel(candidates, fieldLabel) {
     const normalizedLabel = normalizeFieldLabel(fieldLabel);
@@ -4689,8 +4730,15 @@ function findDeepLocatorCandidateByFieldLabel(candidates, fieldLabel) {
     const exact = named.find((entry) => entry.text === normalizedLabel);
     if (exact)
         return exact.candidate;
-    const partial = named.find((entry) => entry.text.includes(normalizedLabel) || normalizedLabel.includes(entry.text));
-    return partial?.candidate ?? null;
+    const partials = named.filter((entry) => entry.text.includes(normalizedLabel) || normalizedLabel.includes(entry.text));
+    const mostSpecific = partials.reduce((closest, entry) => {
+        if (!closest)
+            return entry;
+        const entryDistance = Math.abs(entry.text.length - normalizedLabel.length);
+        const closestDistance = Math.abs(closest.text.length - normalizedLabel.length);
+        return entryDistance < closestDistance ? entry : closest;
+    }, null);
+    return mostSpecific?.candidate ?? null;
 }
 /** Max settle-retry attempts for a primitive's DOM enumerate (see `pollEnumerate`). */
 const PRIMITIVE_ENUMERATE_ATTEMPTS = 5;
@@ -7282,11 +7330,21 @@ async function verifyDomEffect(target, action, preSelectionState = {}) {
  *        - select: pick the first non-empty option.
  *      Each auto-pick is recorded so the cascade can surface a self-heal
  *      warning ("you auto-picked X; consider adding an explicit step").
+ *   3. NATIVE-VALIDITY FALLBACK — independent of the class-marker scan:
+ *      any `required` control whose native `validity.valueMissing` (or,
+ *      absent a `validity` object, an empty `.value`) is true gets flagged
+ *      even when no framework has applied an invalid-marker class yet
+ *      (e.g. a pristine, untouched required field).
  *
  * Label resolution checks (in order) the nearest `<label>`, `aria-label`,
  * `data-id`, and `name`.
+ *
+ * Exported (mirroring {@link fieldValuesAtFailureExpr}) so the real
+ * native-validity-fallback logic can be exercised against a genuine DOM in
+ * unit tests, rather than only through a mocked `evaluate`.
  */
-const FORM_VALIDITY_PROBE_EXPR = `(() => {
+function formValidityProbeExpr() {
+    return `(() => {
   const INVALID_CLASS_RX = /(${INVALID_MARKER_CLASS_SOURCE})/;
   const MARKERS = ["ng-invalid", "mat-form-field-invalid", "is-invalid", "field-invalid", "input-invalid", "Mui-error", "ng-touched", "ng-dirty"];
   function fire(el, ev) {
@@ -7444,9 +7502,35 @@ const FORM_VALIDITY_PROBE_EXPR = `(() => {
     }
     out.push({ label, classSignature, emptyOrUnchecked, autoFilled, _el: el });
   }
+  // Native-validity fallback: the class-marker scan above is blind to a
+  // required field that is genuinely empty but PRISTINE -- a framework
+  // that never applies ng-invalid/Mui-error/etc. until after user
+  // interaction, or one that doesn't use any of the listed conventions
+  // at all. This pass is independent of INVALID_CLASS_RX and relies
+  // solely on the native HTML5 constraint-validation API, so it catches
+  // required-and-empty controls no CSS framework has marked invalid yet.
+  const requiredEls = Array.from(document.querySelectorAll("input,select,textarea"));
+  for (const ctrl of requiredEls) {
+    if (!ctrl.required) continue;
+    if (out.some((e) => e._el === ctrl || (e._el && e._el.contains(ctrl)))) continue;
+    const valueMissing = ctrl.validity ? ctrl.validity.valueMissing : !ctrl.value;
+    if (!valueMissing) continue;
+    const byFor = ctrl.id && document.querySelector ? document.querySelector("label[for=\\"" + ctrl.id + "\\"]") : null;
+    let label = byFor && byFor.textContent ? byFor.textContent.trim() : "";
+    let scan = ctrl;
+    for (let i = 0; i < 4 && scan && !label; i++) {
+      const ownLabel = scan.closest ? scan.closest("label") : null;
+      if (ownLabel && ownLabel.textContent) label = ownLabel.textContent.trim();
+      scan = scan.parentElement;
+    }
+    if (!label) label = ctrl.getAttribute("aria-label") || ctrl.getAttribute("data-id") || ctrl.getAttribute("name") || ctrl.getAttribute("id") || "(unlabeled)";
+    label = label.replace(/\\s+/g, " ").slice(0, 80);
+    out.push({ label, classSignature: "", emptyOrUnchecked: true, autoFilled: null, _el: ctrl });
+  }
   // Strip the DOM reference before serialization.
   return out.slice(0, 12).map((e) => ({ label: e.label, classSignature: e.classSignature, emptyOrUnchecked: e.emptyOrUnchecked, autoFilled: e.autoFilled }));
 })()`;
+}
 /**
  * Runs ONLY on the cascade's final step when a submitEndpointPattern is
  * declared. Surfaces ng-invalid form controls (and whether each is empty)
@@ -7515,7 +7599,7 @@ function formatStepPrefix(stepIndex, totalSteps) {
 async function probeFormValidityBeforeSubmit(params) {
     const { target, stepIndex, totalSteps, logger } = params;
     try {
-        const raw = await target.evaluate(FORM_VALIDITY_PROBE_EXPR);
+        const raw = await target.evaluate(formValidityProbeExpr());
         if (!Array.isArray(raw))
             return [];
         const out = [];
@@ -8637,6 +8721,9 @@ async function executeStepWithHealing(params) {
             .evaluate("document.body ? document.body.outerHTML : null")
             .catch(() => null);
         const bodyOuterHtml = prepareFailureDumpBody(bodyOuterHtmlRaw);
+        const fieldValuesAtFailure = await (frameTarget ?? page)
+            .evaluate(fieldValuesAtFailureExpr())
+            .catch(() => null);
         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
@@ -8662,6 +8749,7 @@ async function executeStepWithHealing(params) {
             bodyOuterHtml,
             unfocusedObserve,
             targetResolutionDiagnostic,
+            fieldValuesAtFailure,
         }) ?? null;
         throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${step.slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
     }
@@ -10943,6 +11031,9 @@ async function executeStepWithHealing(params) {
         .evaluate("document.body ? document.body.outerHTML : null")
         .catch(() => null);
     const bodyOuterHtml = prepareFailureDumpBody(bodyOuterHtmlRaw);
+    const fieldValuesAtFailure = await (frameTarget ?? (0, frame_target_1.mainFrameTarget)(page))
+        .evaluate(fieldValuesAtFailureExpr())
+        .catch(() => null);
     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)
@@ -10962,6 +11053,7 @@ async function executeStepWithHealing(params) {
         bodyOuterHtml,
         unfocusedObserve,
         targetResolutionDiagnostic,
+        fieldValuesAtFailure,
     }) ?? null;
     if (dumpPath !== null) {
         logger.error(`${formatStepPrefix(stepIndex, totalSteps)} failed after ${MAX_STEP_ATTEMPTS} attempts; diagnostic bundle: ${dumpPath}`);