@enricai/barnacle 1.12.72 → 1.12.74

package/dist/scraper/flow-runner.js

@@ -14,11 +14,12 @@
  * the terminal failure dump.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRAILING_GRACE_WINDOW = exports.STEP_WATCHDOG_MS = exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR = exports.GOTO_TIMEOUT_MS = exports.waitForSpaReady = void 0;
+exports.hasOriginOrPathChanged = exports.TRAILING_GRACE_WINDOW = exports.STEP_WATCHDOG_MS = exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR = exports.GOTO_TIMEOUT_MS = exports.waitForSpaReady = void 0;
 exports.mergeResponseHeaders = mergeResponseHeaders;
 exports.wireSignalCapture = wireSignalCapture;
 exports.shouldRetryCaptchaRegistry = shouldRetryCaptchaRegistry;
 exports.prepareFailureDumpBody = prepareFailureDumpBody;
+exports.fieldValuesAtFailureExpr = fieldValuesAtFailureExpr;
 exports.snapshotPage = snapshotPage;
 exports.resolveDumpPageIdentity = resolveDumpPageIdentity;
 exports.findRecentBackendError = findRecentBackendError;
@@ -76,7 +77,6 @@ exports.parseWidgetOptionClickStep = parseWidgetOptionClickStep;
 exports.parseCheckStep = parseCheckStep;
 exports.pollEnumerate = pollEnumerate;
 exports.waitForTransitionBody = waitForTransitionBody;
-exports.hasOriginOrPathChanged = hasOriginOrPathChanged;
 exports.injectCaptchaTokenAndSubmit = injectCaptchaTokenAndSubmit;
 exports.submitCaptchaGatedForm = submitCaptchaGatedForm;
 exports.trySelectPrimitive = trySelectPrimitive;
@@ -88,6 +88,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 +953,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
@@ -3375,17 +3425,39 @@ function elementSelectionFingerprintExpr(xpath) {
  * In-page source for `(el) => Element | null`: the nearest ancestor of `el`,
  * within {@link MAX_SELECTION_ANCESTOR_DEPTH} levels, whose subtree contains a
  * selection-marker element (`role="combobox"`/`role="listbox"`, or a
- * {@link WIDGET_KIT_SELECTION_MARKER_SELECTORS} match) — climbing ancestor
- * levels rather than a single `closest()` call, because a design-system
- * combobox's marker (the `role="combobox"` trigger) and its committed-value
- * control (a hidden `<input>`) are commonly SIBLINGS under a shared wrapper
- * that itself carries no role/class marker: `closest()` only searches
- * self-and-ancestors of `el`, so it can never see a marker that lives on a
- * cousin subtree. At each level, `querySelectorAll` searches the WHOLE
- * subtree (not just direct children), so the marker may be nested arbitrarily
- * deep under that ancestor. Returns the FIRST (nearest) qualifying ancestor,
- * so a same-shaped input/select outside that common ancestor is never
- * mistaken for the same control's committed-value sibling. Shared by
+ * {@link WIDGET_KIT_SELECTION_MARKER_SELECTORS} match) AND at most one
+ * independent WIDGET ROOT (each `role="combobox"`/marker trigger is its own
+ * root; a `role="listbox"` is a root TOO unless some trigger in the subtree
+ * actually declares ownership of it via `aria-owns`/`aria-controls` — a
+ * trigger merely co-existing in the same subtree does NOT make every listbox
+ * its panel, since a real trigger plus an unrelated, un-owned bare listbox
+ * (its own standalone multi-select, no opener) are still two independent
+ * widgets, not one; with NO trigger anywhere in the subtree, each bare
+ * `role="listbox"` is likewise its own standalone widget root, so two such
+ * triggerless listboxes sharing an ancestor are still counted as two
+ * independent roots rather than silently collapsing to zero — EXCEPT when
+ * the scope holds exactly one trigger and exactly one listbox and neither
+ * declares ownership of the other: that pairing is unambiguous regardless of
+ * missing ARIA wiring, so it still counts as a single root) — climbing
+ * ancestor levels rather than a single `closest()` call, because a design-system combobox's
+ * marker (the `role="combobox"` trigger) and its committed-value control (a
+ * hidden `<input>`) are commonly SIBLINGS under a shared wrapper that itself
+ * carries no role/class marker: `closest()` only searches self-and-ancestors
+ * of `el`, so it can never see a marker that lives on a cousin subtree. At
+ * each level, `querySelectorAll` searches the WHOLE subtree (not just direct
+ * children), so the marker may be nested arbitrarily deep under that
+ * ancestor. The widget-root cap is deliberate: a candidate ancestor whose
+ * subtree contains TWO OR MORE independent widget roots (e.g. two unrelated
+ * toggle-shaped rows sharing a parent) is ambiguous about which widget —
+ * and therefore which committed-value control — actually belongs to `el`, so
+ * it is skipped rather than returned; climbing continues to look for an
+ * unambiguous (single-widget) ancestor instead of exposing the whole
+ * multi-widget subtree to the caller's input/select scan, which would let an
+ * UNRELATED sibling widget's own state change masquerade as `el`'s. A single
+ * trigger + its own owned listbox panel (one widget root) still passes.
+ * Returns the FIRST (nearest) unambiguous qualifying ancestor, so a
+ * same-shaped input/select outside that common ancestor is never mistaken for
+ * the same control's committed-value sibling. Shared by
  * {@link SELECTION_STATE_MAP_EXPR}'s `isCommittedValueControl` and
  * {@link selectionSiblingCommittedValueChanged}'s container resolution so the
  * baseline capture and the read-back agree on exactly what counts as
@@ -3395,9 +3467,42 @@ function elementSelectionFingerprintExpr(xpath) {
  */
 const NEARBY_SELECTION_CONTAINER_FN_SRC = `(el) => {
     const MARKER_SEL = '[role="combobox"],[role="listbox"],' + ${JSON.stringify(browser_click_expr_1.WIDGET_KIT_SELECTION_MARKER_SELECTORS)};
+    const WIDGET_ROOT_SEL = '[role="combobox"],' + ${JSON.stringify(browser_click_expr_1.WIDGET_KIT_SELECTION_MARKER_SELECTORS)};
+    const isOwnedListbox = (listbox, triggers) => {
+      if (!listbox.id) return false;
+      return triggers.some((trigger) => {
+        const ownsId = trigger.getAttribute("aria-owns") || trigger.getAttribute("aria-controls");
+        return ownsId === listbox.id;
+      });
+    };
+    const countWidgetRoots = (scope) => {
+      // Each combobox-like trigger is its own widget root. A role=listbox is
+      // that widget's owned PANEL only when SOME trigger in scope actually
+      // declares ownership of it via aria-owns/aria-controls — a trigger
+      // merely co-existing in the same scope does not make every listbox its
+      // panel, since a trigger plus an unrelated, un-owned bare listbox (its
+      // own standalone multi-select, no opener) are still two independent
+      // widgets. Any listbox left un-owned by every trigger — including when
+      // there is no trigger in scope at all — counts as its own widget root.
+      const triggers = Array.from(scope.querySelectorAll(WIDGET_ROOT_SEL));
+      const listboxes = Array.from(scope.querySelectorAll('[role="listbox"]'));
+      const unownedListboxes = listboxes.filter((lb) => !isOwnedListbox(lb, triggers));
+      // A lone trigger next to a lone listbox, neither declaring aria-owns/
+      // aria-controls, is still an unambiguous single widget (a real-world
+      // combobox that never bothered to wire up ARIA ownership) — only
+      // count it as two independent roots once there is more than one
+      // trigger or more than one listbox in scope to actually be ambiguous
+      // about pairing.
+      if (triggers.length === 1 && listboxes.length === 1 && unownedListboxes.length === 1) {
+        return 1;
+      }
+      return triggers.length + unownedListboxes.length;
+    };
     let node = el.parentElement;
     for (let depth = 0; depth < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && node; depth++) {
-      if (node.querySelectorAll && node.querySelectorAll(MARKER_SEL).length > 0) return node;
+      if (node.querySelectorAll && node.querySelectorAll(MARKER_SEL).length > 0) {
+        if (countWidgetRoots(node) <= 1) return node;
+      }
       node = node.parentElement;
     }
     return null;
@@ -4662,9 +4767,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);
@@ -4676,8 +4784,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;
@@ -4748,29 +4863,8 @@ async function waitForTransitionBody(params) {
     }
     return false;
 }
-/**
- * Reduces a URL to origin+pathname (query/hash ignored) so a captcha
- * target's post-submit `url()` can be compared to its pre-submit baseline
- * without a same-page query-string change (e.g. a step counter) registering
- * as a false advance. Unparseable URLs compare equal only to themselves.
- */
-function originAndPathOf(url) {
-    try {
-        const parsed = new URL(url);
-        return `${parsed.origin}${parsed.pathname}`;
-    }
-    catch {
-        return url;
-    }
-}
-/**
- * Credits a captchaGated advance from an observed navigation: true only
- * when origin or pathname actually changed, so a same-page query-string
- * mutation (e.g. a step counter) never counts as an advance.
- */
-function hasOriginOrPathChanged(preUrl, postUrl) {
-    return originAndPathOf(preUrl) !== originAndPathOf(postUrl);
-}
+var phantom_click_2 = require("./phantom-click");
+Object.defineProperty(exports, "hasOriginOrPathChanged", { enumerable: true, get: function () { return phantom_click_2.hasOriginOrPathChanged; } });
 /**
  * Polls the captcha target's URL for an origin/path change after a
  * multipart form submit, which navigates the page without producing any
@@ -4782,7 +4876,7 @@ async function waitForCaptchaNavigation(params) {
     const { page, captchaTarget, baselineUrl, timeoutMs, intervalMs } = params;
     const check = async () => {
         const currentUrl = await (0, frame_target_1.readCurrentFrameUrl)(page, captchaTarget);
-        return hasOriginOrPathChanged(baselineUrl, currentUrl);
+        return (0, phantom_click_1.hasOriginOrPathChanged)(baselineUrl, currentUrl);
     };
     if (await check())
         return true;
@@ -7269,11 +7363,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) {
@@ -7431,9 +7535,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)
@@ -7502,7 +7632,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 = [];
@@ -8624,6 +8754,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
@@ -8649,6 +8782,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");
     }
@@ -9262,8 +9396,42 @@ async function executeStepWithHealing(params) {
                         continue;
                     }
                     const topWindowTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+                    let clickedShadowDescendant = false;
                     try {
-                        await topWindowTarget.locator(topWindowSelector).first().click();
+                        // `document.evaluate` (what the xpath-resolved locator below is
+                        // built on) cannot cross a shadow boundary, so on a custom-
+                        // element host whose real activation lives on an interior
+                        // shadow-DOM descendant, the xpath resolves to the host itself —
+                        // the phantomed target from attempt 1. Resolve into the host's
+                        // own (open) shadow root for the real interactive descendant and
+                        // stamp it with a throwaway marker attribute; a CSS attribute
+                        // selector (unlike xpath) pierces an open shadow root, so
+                        // re-locating via that marker and clicking delivers a genuinely
+                        // trusted click at the real target instead of the host's own
+                        // bounding box. No shadow root, or no qualifying descendant,
+                        // falls back unchanged to clicking the host via its xpath.
+                        const xpathBody = xpathBodyForEvaluate(topWindowSelector);
+                        const markerAttr = "data-barnacle-shadow-click-target";
+                        const markerValue = `t${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+                        const markResult = xpathBody
+                            ? await topWindowTarget
+                                .evaluate((0, browser_click_expr_1.buildMarkShadowInteractiveDescendantExpr)(xpathBody, markerAttr, markerValue))
+                                .catch(() => ({ found: false }))
+                            : { found: false };
+                        if (markResult.found) {
+                            try {
+                                await topWindowTarget.locator(`[${markerAttr}="${markerValue}"]`).first().click();
+                                clickedShadowDescendant = true;
+                            }
+                            finally {
+                                await topWindowTarget
+                                    .evaluate((0, browser_click_expr_1.buildUnmarkShadowDescendantExpr)(xpathBody, markerAttr, markerValue))
+                                    .catch(() => undefined);
+                            }
+                        }
+                        else {
+                            await topWindowTarget.locator(topWindowSelector).first().click();
+                        }
                     }
                     catch (err) {
                         const failureMessage = `trusted-click-retry: top-window trusted click threw ${(0, errors_1.toErrorMessage)(err)}`;
@@ -9275,11 +9443,13 @@ async function executeStepWithHealing(params) {
                         logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${failureMessage}`);
                         continue;
                     }
-                    record.instruction = `trusted-click-retry (top-window): ${topWindowSelector}`;
+                    record.instruction = `trusted-click-retry (top-window): ${topWindowSelector}${clickedShadowDescendant ? " (shadow descendant)" : ""}`;
                     record.actResultSuccess = true;
-                    record.actResultDescription = `trusted-click-retry clicked "${topWindowSelector}" via top-window locator`;
+                    record.actResultDescription = clickedShadowDescendant
+                        ? `trusted-click-retry clicked the shadow-DOM descendant of "${topWindowSelector}" via top-window locator`
+                        : `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`);
+                    logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: trusted-click-retry: top-window trusted locator click on the resolved target${clickedShadowDescendant ? " (shadow descendant)" : ""}`);
                     resolvedAction = {
                         selector: topWindowSelector,
                         description: record.actResultDescription,
@@ -9827,7 +9997,7 @@ async function executeStepWithHealing(params) {
             record.resolvedArguments = (resolvedAction.arguments ?? []).map(String);
         }
         const networkFired = post.networkCount > pre.networkCount;
-        const urlChanged = post.url !== pre.url;
+        const urlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, post.url);
         const isStateClass = resolvedAction !== null && STATE_CLASS_METHODS.has(resolvedAction.method ?? "");
         const isClick = resolvedAction !== null && resolvedAction.method === "click";
         // State-class actions (fill/check/etc.) never move the network counter or URL,
@@ -10395,7 +10565,7 @@ async function executeStepWithHealing(params) {
                     await page.waitForTimeout(STEP_PAUSE_MS);
                     const retryPost = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
                     const retryNetworkFired = retryPost.networkCount > pre.networkCount;
-                    const retryUrlChanged = retryPost.url !== pre.url;
+                    const retryUrlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, retryPost.url);
                     const retryHtmlDelta = retryPost.bodyHtmlLength - pre.bodyHtmlLength;
                     const retryTextChanged = retryPost.visibleTextSignature !== pre.visibleTextSignature;
                     const retryFormValueChanged = retryPost.formValueSignature !== pre.formValueSignature;
@@ -10930,6 +11100,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)
@@ -10949,6 +11122,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}`);