@enricai/barnacle 1.12.37 → 1.12.39

package/dist/scraper/flow-runner.js

@@ -14,7 +14,7 @@
  * the terminal failure dump.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRAILING_GRACE_WINDOW = exports.STEP_WATCHDOG_MS = exports.GOTO_TIMEOUT_MS = void 0;
+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.prepareFailureDumpBody = prepareFailureDumpBody;
@@ -75,7 +75,9 @@ exports.pollEnumerate = pollEnumerate;
 exports.waitForTransitionBody = waitForTransitionBody;
 exports.injectCaptchaTokenAndSubmit = injectCaptchaTokenAndSubmit;
 exports.submitCaptchaGatedForm = submitCaptchaGatedForm;
+exports.trySelectPrimitive = trySelectPrimitive;
 exports.chooseRequiredSelectOption = chooseRequiredSelectOption;
+exports.tryFillRequiredSelectsPrimitive = tryFillRequiredSelectsPrimitive;
 exports.buildRadioIdXPath = buildRadioIdXPath;
 exports.selectRadioGroupOption = selectRadioGroupOption;
 exports.hasUnfilledRequiredControlForStep = hasUnfilledRequiredControlForStep;
@@ -125,6 +127,8 @@ const submit_control_1 = require("../scraper/submit-control");
 const watchdog_1 = require("../scraper/watchdog");
 const recon_shared_1 = require("../scripts/recon-shared");
 const client_1 = require("../testmail/client");
+var spa_readiness_2 = require("../scraper/spa-readiness");
+Object.defineProperty(exports, "waitForSpaReady", { enumerable: true, get: function () { return spa_readiness_2.waitForSpaReady; } });
 const logger = (0, logging_1.getLogger)({ name: "scraper/flow-runner" });
 /** Cap on the rolling capture-filename window held in memory for failure dumps. */
 const RECENT_CAPTURES_WINDOW = 20;
@@ -459,6 +463,36 @@ const PROMPT_TRIGGER_SELECTORS = [
     "[data-automation-id='multiSelectContainer']",
     "[data-automation-id='promptSelectionLabel']",
 ].join(",");
+/**
+ * In-page predicate source for `(el) => boolean`: true when `el` is a
+ * `<select>` that is a design-system combobox opener's paired-but-hidden
+ * shadow control (Base Web `bb-customSelect` and any other vendor matching
+ * {@link PROMPT_TRIGGER_SELECTORS}) — a `<select>` with no layout box
+ * (`offsetParent === null`, the same idiom `DOM_SNAPSHOT_EXPR` uses for
+ * `display:none`-driven hiding classes like `dropdown-hide`) whose nearby
+ * container also holds a {@link PROMPT_TRIGGER_SELECTORS} opener element
+ * other than itself. The bounded-ancestor-climb-then-subtree-search shape
+ * mirrors {@link NEARBY_SELECTION_CONTAINER_FN_SRC}, but searches for
+ * {@link PROMPT_TRIGGER_SELECTORS} instead of the selection-marker union —
+ * this ties "opener" to the exact same union `tryPromptSelectorPrimitive`
+ * recognizes, so a select is excluded precisely when the primitive that
+ * should own it would actually claim it. Wired into every `<select>` list
+ * `trySelectPrimitive` and `applySelectValue` build, so those primitives fall
+ * through and let `tryPromptSelectorPrimitive` claim the opener instead — and
+ * consumed by {@link commitPromptOption}'s hidden-select-value corroboration
+ * when the opener's own readback is inconclusive.
+ */
+exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR = `(el) => {
+    if (!el || el.tagName !== "SELECT" || el.offsetParent !== null) return false;
+    const triggerSel = ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)};
+    let node = el.parentElement;
+    for (let depth = 0; depth < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && node; depth++) {
+      const openers = node.querySelectorAll ? Array.from(node.querySelectorAll(triggerSel)) : [];
+      if (openers.some((opener) => opener !== el)) return true;
+      node = node.parentElement;
+    }
+    return false;
+  }`;
 /**
  * Cross-vendor selector union for an OPTION rendered inside the opened popup —
  * standards first (`role=option`), then the widget-kit option markers. Sibling
@@ -3058,7 +3092,7 @@ const XPATH_OF_FN_SRC = `(node) => {
  * popover isn't mistaken for a selection.
  */
 function selectionFingerprintObjSrc(elVar, dsVar) {
-    return `{ kind: ${elVar}.getAttribute("kind") || "", cls: ${elVar}.getAttribute("class") || "", ariaPressed: ${elVar}.getAttribute("aria-pressed") || "", ariaChecked: ${elVar}.getAttribute("aria-checked") || "", ariaSelected: ${elVar}.getAttribute("aria-selected") || "", dataState: (${dsVar} === "open" || ${dsVar} === "closed") ? "" : ${dsVar}, dataSelected: ${elVar}.hasAttribute("data-selected") ? "1" : "", dataChecked: ${elVar}.hasAttribute("data-checked") ? "1" : "", checked: (${elVar}.type === "checkbox" || ${elVar}.type === "radio") ? (${elVar}.checked ? "1" : "0") : "", value: typeof ${elVar}.value === "string" ? ${elVar}.value.slice(0, 200) : "" }`;
+    return `{ kind: ${elVar}.getAttribute("kind") || "", cls: ${elVar}.getAttribute("class") || "", ariaPressed: ${elVar}.getAttribute("aria-pressed") || "", ariaChecked: ${elVar}.getAttribute("aria-checked") || "", ariaSelected: ${elVar}.getAttribute("aria-selected") || "", dataState: (${dsVar} === "open" || ${dsVar} === "closed") ? "" : ${dsVar}, dataSelected: ${elVar}.hasAttribute("data-selected") ? "1" : "", dataChecked: ${elVar}.hasAttribute("data-checked") ? "1" : "", checked: (${elVar}.type === "checkbox" || ${elVar}.type === "radio") ? (${elVar}.checked ? "1" : "0") : "", value: typeof ${elVar}.value === "string" ? ${elVar}.value.slice(0, 200) : "", ariaExpanded: ${elVar}.getAttribute("aria-expanded") || "" }`;
 }
 /**
  * Browser-side expression body that resolves `xpath` and returns that one
@@ -3143,7 +3177,7 @@ const SELECTION_STATE_MAP_EXPR = `(() => {
     const style = getComputedStyle(el);
     return style.display !== "none" && style.visibility !== "hidden";
   };
-  const sel = "button,[role=button],a,li,[tabindex],input,select,textarea,[role=option],[role=tab],[role=switch],[role=checkbox],[role=menuitemcheckbox]," + ${JSON.stringify(browser_click_expr_1.SELECTION_MARKER_CLASS_SELECTOR_SRC)};
+  const sel = "button,[role=button],a,li,[tabindex],input,select,textarea,[role=option],[role=tab],[role=switch],[role=checkbox],[role=menuitemcheckbox],[role=combobox]," + ${JSON.stringify(browser_click_expr_1.SELECTION_MARKER_CLASS_SELECTOR_SRC)};
   const skip = (el) => el.closest("[role=dialog],[role=tooltip],[aria-live]") !== null;
   const isCommittedValueControl = (el) =>
     (el.tagName === "INPUT" || el.tagName === "SELECT") &&
@@ -3208,6 +3242,7 @@ function asSelectionFingerprint(raw) {
         dataChecked: typeof r.dataChecked === "string" ? r.dataChecked : "",
         checked: typeof r.checked === "string" ? r.checked : "",
         value: typeof r.value === "string" ? r.value : "",
+        ariaExpanded: typeof r.ariaExpanded === "string" ? r.ariaExpanded : "",
     };
 }
 /**
@@ -3404,6 +3439,76 @@ async function selectionSiblingCommittedValueChanged(target, leafXpath, preSelec
         return false;
     }
 }
+/**
+ * Dedicated pre/post check crediting exactly one case none of the fingerprint
+ * diffs above can see: a raw click resolved onto (or under) a
+ * {@link PROMPT_TRIGGER_SELECTORS}-shaped combobox opener that GENUINELY opened
+ * its owned option panel. Opening a widget only flips `aria-expanded`, which
+ * {@link selectionFingerprintObjSrc}'s shared fingerprint deliberately blanks out
+ * of `dataState` and which {@link selectionFingerprintChanged} /
+ * {@link selectionAncestorChanged}'s `changed()` never compare — by design, so a
+ * bare accordion/tooltip disclosure is never mistaken for a selection. That
+ * leaves a replanner-generated two-step "click to open the dropdown"
+ * instruction with no signal at all: the fingerprint tiers above never move,
+ * so the open-click is scored phantom even though it genuinely exposed the
+ * option panel.
+ *
+ * This function is independent of those tiers rather than folded into their
+ * `changed()`: it reads the new {@link ElementSelectionFingerprint.ariaExpanded}
+ * field, but ONLY on a node that itself matches {@link PROMPT_TRIGGER_SELECTORS},
+ * and ONLY credits it when the opener's `aria-owns`/`aria-controls` scope (the
+ * SAME {@link PROMPT_SCOPE_ROOT_EXPR} resolution `tryPromptSelectorPrimitive`
+ * uses) now actually contains {@link PROMPT_OPTION_SELECTORS} content — never a
+ * bare `aria-expanded` flip with nothing rendered underneath. That second
+ * condition is what keeps a bare accordion/tooltip trigger (which flips
+ * `aria-expanded` but owns no option panel) excluded, preserving the existing
+ * deliberate exclusion.
+ *
+ * Walks from the leaf up to {@link MAX_SELECTION_ANCESTOR_DEPTH} for the NEAREST
+ * trigger match (mirrors {@link selectionAncestorChanged}'s climb, since
+ * Stagehand may resolve the click onto a label/icon child of the opener rather
+ * than the opener itself). No baseline entry for that trigger, no trigger
+ * match, a trigger that was already expanded pre-click, or a trigger that's
+ * still collapsed post-click → `false` (defer to the network/URL signal).
+ * Returns `false` on any evaluate throw.
+ */
+async function comboboxOpenerPanelOpened(target, leafXpath, preSelectionState) {
+    const expr = `(() => {
+    const LEAF = ${JSON.stringify(leafXpath)};
+    const BASE = ${JSON.stringify(preSelectionState)};
+    const TRIGGER_SEL = ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)};
+    const OPTION_SEL = ${JSON.stringify(PROMPT_OPTION_SELECTORS)};
+    const xpathOf = ${XPATH_OF_FN_SRC};
+    const scopeRootOf = ${PROMPT_SCOPE_ROOT_EXPR};
+    const r = document.evaluate(LEAF, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    let node = r.singleNodeValue;
+    for (let depth = 0; depth < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && node; depth++) {
+      if (node.getAttribute && node.matches && node.matches(TRIGGER_SEL)) {
+        const pre = BASE[xpathOf(node)];
+        if (!pre) return false;
+        const wasCollapsed = pre.ariaExpanded !== "true";
+        const nowExpanded = (node.getAttribute("aria-expanded") || "") === "true";
+        if (!wasCollapsed || !nowExpanded) return false;
+        // scopeRootOf falls back to \`document\` when the trigger has no
+        // aria-controls/aria-owns ref AND no inline popup in its own subtree.
+        // That fallback is a page-wide search, not the opener's OWNED scope —
+        // crediting through it would let an unrelated widget's already-open
+        // options (elsewhere on the page) falsely credit THIS trigger's click.
+        const scope = scopeRootOf(node);
+        if (!scope || scope === document || !scope.querySelector) return false;
+        return !!scope.querySelector(OPTION_SEL);
+      }
+      node = node.parentElement;
+    }
+    return false;
+  })()`;
+    try {
+        return (await target.evaluate(expr)) === true;
+    }
+    catch {
+        return false;
+    }
+}
 /** How long the upload primitive waits for a post-setInputFiles network POST. */
 const UPLOAD_NETWORK_TIMEOUT_MS = 5_000;
 /** Polling interval while waiting for the upload's network signal. */
@@ -4312,10 +4417,14 @@ function findCaptchaCallbackExprSrc() {
  * `hcaptcha.execute(widgetId)`, letting the callback fire as a natural
  * consequence of hCaptcha's own execute/verify cycle; only when no
  * widgetId/execute path is available does this fall back to invoking the
- * captured callback directly. Only when no callback is discoverable at all
- * does this fall back to setting the hidden response field directly and
- * dispatching the framework-visible `change` event so the field's own value
- * listener observes it.
+ * captured callback directly. When no callback is discoverable at precheck
+ * time, this re-installs the callback-capture script and retries the lookup
+ * once — catching a widget whose `hcaptcha.render` call happens on demand
+ * rather than on page load, after this frame missed both session.ts's
+ * page-init-script install and the per-frame attach install. Only when the
+ * late retry also finds nothing does this fall back to setting the hidden
+ * response field directly and dispatching the framework-visible `change`
+ * event so the field's own value listener observes it.
  *
  * Widgets of this shape anchor a `[data-sitekey]` element whose
  * `data-callback` attribute names a function on `window`; that callback (not
@@ -4396,6 +4505,48 @@ async function injectCaptchaTokenAndSubmit(target, token, responseField = "h-cap
         await target.evaluate(invokeCallbackExpr).catch(() => undefined);
         return { injected, hasForm, callbackDiscovered };
     }
+    // Belt-and-suspenders: this frame missed session.ts's page-init-script
+    // install and bugfix-001's per-frame attach install (it either attached
+    // before the listener was wired, or never fired an observed attach/
+    // navigate event this run). Installing the capture script now is still
+    // idempotent and still cheap, and it's the only remaining chance to catch
+    // a widget that calls `hcaptcha.render` on demand rather than on load.
+    // Re-run the precheck's callback lookup once more before giving up and
+    // falling through to the raw field-set path below.
+    await target.evaluate((0, captcha_callback_capture_1.buildHcaptchaCallbackCaptureScript)()).catch(() => undefined);
+    const latePrecheckExpr = `(() => {
+    ${findCaptchaCallbackExprSrc()}
+    const sitekeyEl = document.querySelector("[data-sitekey]");
+    return Boolean(__findCaptchaCallback(sitekeyEl));
+  })()`;
+    const lateCallbackDiscovered = await target
+        .evaluate(latePrecheckExpr)
+        .catch(() => false);
+    if (lateCallbackDiscovered) {
+        const invokeLateCallbackExpr = `(() => {
+      ${findCaptchaCallbackExprSrc()}
+      const sitekeyEl = document.querySelector("[data-sitekey]");
+      const found = __findCaptchaCallback(sitekeyEl);
+      if (!found) return;
+      const canExecute =
+        found.kind === "captured" &&
+        found.widgetId !== undefined &&
+        found.widgetId !== null &&
+        window.hcaptcha &&
+        typeof window.hcaptcha.execute === "function";
+      if (canExecute) {
+        window.hcaptcha.execute(found.widgetId);
+        return;
+      }
+      found.invoke(${JSON.stringify(token)});
+    })()`;
+        // Same navigate-mid-evaluate tolerance as the non-late invoke above:
+        // the callback (or execute's own verify cycle) is free to submit the
+        // form synchronously, tearing down the execution context before a
+        // return value marshals.
+        await target.evaluate(invokeLateCallbackExpr).catch(() => undefined);
+        return { injected, hasForm, callbackDiscovered: true };
+    }
     const setValueExpr = `(() => {
     const responseField = ${JSON.stringify(responseField)};
     const token = ${JSON.stringify(token)};
@@ -4508,7 +4659,8 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
  */
 async function applySelectValue(page, target, selIdx, value) {
     const setExpr = `((selIdx, value) => {
-    const sel = Array.from(document.querySelectorAll("select"))[selIdx];
+    const isOpenerPairedHidden = ${exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR};
+    const sel = Array.from(document.querySelectorAll("select")).filter((s) => !isOpenerPairedHidden(s))[selIdx];
     if (!sel) return { ok: false };
     const desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "value");
     if (desc && desc.set) { desc.set.call(sel, value); } else { sel.value = value; }
@@ -4523,7 +4675,8 @@ async function applySelectValue(page, target, selIdx, value) {
     await page.waitForTimeout(SELECT_SETTLE_MS);
     const invalidExpr = `((selIdx) => {
     const isInvalid = ${INVALID_MARKER_EL_EXPR};
-    const sel = Array.from(document.querySelectorAll("select"))[selIdx];
+    const isOpenerPairedHidden = ${exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR};
+    const sel = Array.from(document.querySelectorAll("select")).filter((s) => !isOpenerPairedHidden(s))[selIdx];
     if (!sel) return false;
     let node = sel;
     for (let depth = 0; depth < 6 && node; depth++) {
@@ -4561,8 +4714,12 @@ async function trySelectPrimitive(params) {
     const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
     const wantOpt = norm(option);
     // All native selects, INCLUDING tabindex=-1 (MuiNativeSelect) which the
-    // a11y tree — and therefore Stagehand observe — never surfaces.
-    const selects = Array.from(document.querySelectorAll("select"));
+    // a11y tree — and therefore Stagehand observe — never surfaces. Excludes
+    // a design-system combobox opener's paired-but-hidden shadow <select>
+    // (Base Web etc.) so tryPromptSelectorPrimitive gets first refusal on it
+    // instead of this primitive silently writing a value the opener never sees.
+    const isOpenerPairedHidden = ${exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR};
+    const selects = Array.from(document.querySelectorAll("select")).filter((s) => !isOpenerPairedHidden(s));
     if (selects.length === 0) return { selectPresent: false };
     // FAST PATH — deterministic option match: exactly one select has an option
     // matching the flow's answer text. Unambiguous (the option text itself
@@ -4752,7 +4909,8 @@ async function tryFillRequiredSelectsPrimitive(params) {
     // (MUI marks NativeSelect via any of these). Reuses the isUnfilled / selLabelText
     // shape from trySelectPrimitive.
     const enumerateExpr = `(() => {
-    const selects = Array.from(document.querySelectorAll("select"));
+    const isOpenerPairedHidden = ${exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR};
+    const selects = Array.from(document.querySelectorAll("select")).filter((s) => !isOpenerPairedHidden(s));
     if (selects.length === 0) return { candidates: [] };
     const selLabelText = (sel) => {
       const parts = [];
@@ -5888,6 +6046,7 @@ async function commitPromptOption(params) {
         const isRequestedLeaf = norm(chosenOption.text) === wantOpt;
         const readbackExpr = `((wIdx, markAttr, valueSel, emptyRxSrc, emptyRxFlags, wantText, isRequestedLeaf) => {
       const isInvalid = ${INVALID_MARKER_EL_EXPR};
+      const isPairedHiddenSelect = ${exports.OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR};
       const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
       const buttonValue = ${BUTTON_VALUE_EXPR};
       const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
@@ -5910,10 +6069,55 @@ async function commitPromptOption(params) {
         if (node.getAttribute && isInvalid(node)) { stillInvalid = true; break; }
         node = node.parentElement;
       }
+      // Corroborating signal when the opener's own text/activedescendant read is
+      // inconclusive: the paired native <select> Base Web (and similar vendors)
+      // keeps in sync BEHIND the real widget now holds a non-empty CURRENT value
+      // (read-only — never written here) that, when its selected option's own
+      // text is available, also matches the requested option.
+      let hiddenSelectMatches = false;
+      if (!textMatches) {
+        let cnode = w;
+        for (let d = 0; d < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && cnode && !hiddenSelectMatches; d++) {
+          const selects = cnode.querySelectorAll ? Array.from(cnode.querySelectorAll("select")) : [];
+          for (const sel of selects) {
+            if (!isPairedHiddenSelect(sel)) continue;
+            // isPairedHiddenSelect only proves SOME opener sits near this select —
+            // in a form with multiple prompt-selector fields sharing an outer
+            // ancestor within MAX_SELECTION_ANCESTOR_DEPTH, that opener can be a
+            // SIBLING widget's, not w's. Mirror OPENER_PAIRED_HIDDEN_SELECT_EL_EXPR's
+            // own climb-then-scan-openers shape, but require w itself to be among
+            // the openers found at the NEAREST level that has any — the same level
+            // isPairedHiddenSelect stopped at — so a neighboring field's
+            // already-committed hidden select never corroborates this widget's commit.
+            let snode = sel.parentElement;
+            let pairedWithW = false;
+            for (let sd = 0; sd < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && snode && !pairedWithW; sd++) {
+              const openersHere = snode.querySelectorAll
+                ? Array.from(snode.querySelectorAll(${JSON.stringify(PROMPT_TRIGGER_SELECTORS)})).filter((o) => o !== sel)
+                : [];
+              if (openersHere.length > 0) {
+                pairedWithW = openersHere.includes(w);
+                break;
+              }
+              snode = snode.parentElement;
+            }
+            if (!pairedWithW) continue;
+            const v = (sel.value || "").trim();
+            if (!v) continue;
+            const selOpt = sel.options && sel.selectedIndex >= 0 ? sel.options[sel.selectedIndex] : null;
+            const optText = selOpt ? norm(selOpt.textContent || selOpt.label || "") : "";
+            // A selected option with no visible text (icon-only, value-only markup)
+            // carries no corroborating signal — treating it as a match would credit
+            // ANY selection change, including a different option than requested.
+            if (wantText && optText && optText.includes(wantText)) { hiddenSelectMatches = true; break; }
+          }
+          cnode = cnode.parentElement;
+        }
+      }
       // A category click may leave the widget's aria-invalid unset until final
       // submit, so !stillInvalid alone only counts as success when this click
       // landed on the requested leaf option, not an intermediate category.
-      return { ok: textMatches || (isRequestedLeaf && !stillInvalid), id: w.id || "" };
+      return { ok: textMatches || (isRequestedLeaf && !stillInvalid) || hiddenSelectMatches, id: w.id || "" };
     })(${JSON.stringify(chosen.wIdx)}, ${JSON.stringify(PROMPT_WIDGET_MARK_ATTR)}, ${JSON.stringify(PROMPT_VALUE_SELECTORS)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_SRC)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_FLAGS)}, ${JSON.stringify(norm(chosenOption.text))}, ${JSON.stringify(isRequestedLeaf)})`;
         const readback = (await target.evaluate(readbackExpr).catch(() => ({ ok: false, id: "" })));
         if (readback?.ok) {
@@ -6015,12 +6219,14 @@ async function hasUnfilledRequiredControlForStep(target, instruction) {
     // (button/aria-haspopup shapes with no native input/select at all) to
     // the container-widget union already covered.
     const controls = Array.from(document.querySelectorAll(
-      "input,select,textarea,[role=combobox],[role=listbox],.bb-custom-select-container,[class*='MultiCheckboxInput']," + triggerSel
+      "input,select,textarea,[role=combobox],[role=listbox]," + triggerSel
     ));
     for (const el of controls) {
       if (!isRequired(el) && !(el.querySelector && el.querySelector("[required],[aria-required=true]"))) {
         // container widgets carry required on an inner element; allow those
-        if (!/bb-custom-select-container|MultiCheckboxInput/.test((el.getAttribute && el.getAttribute("class")) || "")) continue;
+        const isTriggerWidget =
+          (el.matches && el.matches(triggerSel)) || (el.querySelector && !!el.querySelector(triggerSel));
+        if (!isTriggerWidget) continue;
       }
       // is it empty/invalid?
       const emptyOrInvalid = isEmptyish(el) || (el.querySelector && !!el.querySelector("[aria-invalid=true]"));
@@ -6281,7 +6487,15 @@ async function verifyDomEffect(target, action, preSelectionState = {}) {
                     // ancestor, and — since some resolved xpaths land on a sibling label rather
                     // than the combobox itself — the nearest combobox within the same
                     // field-group container, for a nested input value, falling back to visible
-                    // text or an aria label/valuetext.
+                    // text or an aria label/valuetext. `combo.textContent`/`el.textContent`
+                    // is NEVER read directly: for a composite opener+hidden-`<select>`
+                    // widget (role="combobox" on the shared container, resolved xpath
+                    // landing on the sibling hidden select) that concatenates EVERY
+                    // option's text, so it "matches" whatever the requested option is
+                    // regardless of what actually got selected — read only the
+                    // COMMITTED signal (aria-activedescendant's referenced node, the
+                    // select's own selectedIndex option, or the opener's displayed text
+                    // with any nested select/listbox option list stripped out first).
                     const exprCustom = `(() => {
             const r = document.evaluate(${JSON.stringify(xpath)}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
             const el = r.singleNodeValue;
@@ -6294,9 +6508,28 @@ async function verifyDomEffect(target, action, preSelectionState = {}) {
             combo = combo || el;
             const nestedInput = combo.querySelector && combo.querySelector('input');
             const value = (nestedInput && nestedInput.value) || el.value || "";
-            const text = (combo.textContent || el.textContent || "").trim();
+            const adid = (combo.getAttribute && combo.getAttribute('aria-activedescendant')) ||
+              (el.getAttribute && el.getAttribute('aria-activedescendant'));
+            const adNode = adid && document.getElementById(adid);
+            const adText = adNode ? (adNode.textContent || "").trim() : "";
+            const selectEl = el.tagName === "SELECT" ? el : (combo.tagName === "SELECT" ? combo : null);
+            const selectedOptText = selectEl && selectEl.selectedIndex >= 0 && selectEl.options[selectEl.selectedIndex]
+              ? (selectEl.options[selectEl.selectedIndex].textContent || "").trim()
+              : "";
+            // If combo itself IS the <select> (role="combobox" placed directly
+            // on the native select rather than a wrapping container),
+            // querySelectorAll('select,...') below only prunes DESCENDANTS —
+            // combo's own concatenated option text survives untouched. Skip
+            // the whole-text fallback entirely for that shape; selectedOptText
+            // above already reads its single committed option.
+            const clone = combo.tagName !== "SELECT" && combo.cloneNode ? combo.cloneNode(true) : null;
+            if (clone && clone.querySelectorAll) {
+              clone.querySelectorAll('select,[role="listbox"]').forEach((n) => n.remove());
+            }
+            const ownText = clone ? (clone.textContent || "").trim() : "";
             const ariaText = (el.getAttribute && (el.getAttribute('aria-label') || el.getAttribute('aria-valuetext'))) || "";
-            return { value: String(value).trim(), text: String(text || ariaText).trim() };
+            const text = adText || selectedOptText || ownText || ariaText;
+            return { value: String(value).trim(), text: String(text || "").trim() };
           })()`;
                     try {
                         const customResult = await target.evaluate(exprCustom);
@@ -6390,7 +6623,17 @@ async function verifyDomEffect(target, action, preSelectionState = {}) {
                     // may live on a hidden sibling `<input>`/`<select>` the click never
                     // re-renders visibly. Diff that control against its own baseline
                     // entry instead.
-                    return await selectionSiblingCommittedValueChanged(target, xpath, preSelectionState);
+                    if (await selectionSiblingCommittedValueChanged(target, xpath, preSelectionState)) {
+                        return true;
+                    }
+                    // No selection fingerprint moved anywhere: the click may still have
+                    // genuinely opened a combobox's owned option panel (a two-step
+                    // "click to open the dropdown" instruction), which flips only
+                    // `aria-expanded` — deliberately excluded from every fingerprint
+                    // diff above so a bare accordion/tooltip disclosure is never
+                    // credited. This dedicated check additionally requires the opener's
+                    // owned panel to now render option content before crediting it.
+                    return await comboboxOpenerPanelOpened(target, xpath, preSelectionState);
                 }
                 const isCheckedNow = await locator.isChecked();
                 if (!isCheckedNow)
@@ -7321,7 +7564,12 @@ async function executeStepWithHealing(params) {
             });
             const preCaptchaCaptureIdx = latestCaptureIndex(recentCaptures);
             const injectResult = await injectCaptchaTokenAndSubmit(captchaTarget, solved.token);
-            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: token injected=${injectResult.injected} hasForm=${injectResult.hasForm} callbackDiscovered=${injectResult.callbackDiscovered}`);
+            const registryState = await captchaTarget.evaluate(`(() => {
+          const registry = window[${JSON.stringify(captcha_callback_capture_1.HCAPTCHA_CALLBACK_REGISTRY_GLOBAL)}];
+          if (!registry) return "absent";
+          return Object.keys(registry).length === 0 ? "empty" : "populated";
+        })()`);
+            logger.info(`${formatStepPrefix(stepIndex, totalSteps)} captchaGated step: token injected=${injectResult.injected} hasForm=${injectResult.hasForm} callbackDiscovered=${injectResult.callbackDiscovered} registryState=${registryState}`);
             // Reuse the EXISTING waitForTransitionBody poll (no new captcha-specific
             // poll loop), just with a widened budget so the solve+submit round trip
             // doesn't eat into the plain ADVANCE_TRANSITION_POLL_MS window. A