@enricai/barnacle 1.12.38 → 1.12.40

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 = exports.waitForSpaReady = 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;
@@ -471,6 +473,116 @@ const PROMPT_OPTION_SELECTORS = [
     "[data-automation-id='promptOption']",
     "[data-uxi-widget-type='selectinputlistitem']",
 ].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}). Two independent signals both have to
+ * hold, and each is deliberately technique-agnostic rather than an exact
+ * enumeration: (1) hiddenness — `offsetParent === null`, a zero-size rect,
+ * `display:none`/`visibility:hidden`/`opacity:0`, off-screen positioning, OR
+ * any of the layout-fingerprint checks that generalize across the remaining
+ * CSS hiding techniques (`hasTinyFootprint` for the sr-only clip idiom and
+ * `transform:scale(0)`'s collapsed rect, a parsed `clip:` rect of zero area,
+ * an active `clip-path`, a `scale(0)`/zero `matrix()` transform, or an
+ * ancestor whose own box is collapsed to near-zero while clipping overflow)
+ * — and (2) opener-pairing — described below — which is what makes the
+ * hiddenness check safe to broaden: a false-positive on hiddenness alone
+ * (e.g. some other reason a real, standalone select reports a tiny rect)
+ * still can't misfire unless that same select also sits paired with a
+ * rendered combobox opener, which an ordinary select never does. Signal (2)
+ * requires the select's nearby container to also hold a
+ * {@link PROMPT_TRIGGER_SELECTORS} opener element, other than itself, that is
+ * ARIA-wired to a listbox panel — via `aria-owns`/`aria-controls`/
+ * `aria-haspopup="listbox"` declared on the opener (accepted unresolved only
+ * when the opener sits in the select's own immediate container, since many
+ * widgets mount their popup lazily on first open and haven't rendered it
+ * yet), or, once the referenced id does resolve (at any climbed depth), only
+ * when the target actually is `role=listbox` or contains a
+ * {@link PROMPT_OPTION_SELECTORS} match, or, for an opener declaring no
+ * owns/controls/haspopup at all, a {@link PROMPT_OPTION_SELECTORS} match
+ * rendered in THAT OPENER's own immediate container (never the whole climbed
+ * ancestor — scanning the ancestor would credit an unrelated already-open
+ * widget elsewhere in a shared ancestor as this select's pairing). Requiring
+ * resolution past the immediate container keeps the broadened hidden test
+ * from misclassifying an unrelated widget elsewhere in a shared ancestor as
+ * a paired shadow select.
+ * 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") return false;
+    const rect = el.getBoundingClientRect();
+    const style = getComputedStyle(el);
+    const isOffscreen = rect.right <= 0 || rect.bottom <= 0 || rect.left >= window.innerWidth || rect.top >= window.innerHeight;
+    // A near-zero footprint (<=1px either dimension) is the layout-level fingerprint
+    // shared by the classic sr-only clip technique (explicit width:1px;height:1px) and
+    // a real browser's transform:scale(0) (which collapses the bounding rect itself) —
+    // technique-agnostic, unlike enumerating every CSS property that can shrink a box.
+    const hasTinyFootprint = rect.width <= 1 || rect.height <= 1;
+    const clipMatch = /rect\\(\\s*([\\d.]+)px[,\\s]+([\\d.]+)px[,\\s]+([\\d.]+)px[,\\s]+([\\d.]+)px\\s*\\)/.exec(style.clip || "");
+    const isClipZeroArea = !!clipMatch && (parseFloat(clipMatch[3]) - parseFloat(clipMatch[1]) <= 0 || parseFloat(clipMatch[2]) - parseFloat(clipMatch[4]) <= 0);
+    // Only treat clip-path as a hiding signal when it collapses the element to
+    // zero visible area (circle(0), inset(50%), a degenerate polygon whose
+    // points share a single coordinate) — a decorative clip-path (rounded
+    // corners, an avatar circle) leaves the element fully visible and must
+    // not be misread as hidden.
+    const cp = style.clipPath || "";
+    const hasClipPath = /circle\\(\\s*0(?:px|%)?\\s*(?:at\\s[^)]*)?\\)/i.test(cp) || /ellipse\\(\\s*0(?:px|%)?\\s+0(?:px|%)?\\s*(?:at\\s[^)]*)?\\)/i.test(cp) || /inset\\(\\s*50%\\s*\\)/i.test(cp) || /polygon\\(\\s*(?:0%?\\s+0%?\\s*,?\\s*)+\\)/i.test(cp);
+    const hasZeroScale = /scale\\(\\s*0(?:\\.0+)?\\s*(?:,\\s*0(?:\\.0+)?\\s*)?\\)/.test(style.transform || "") || /matrix\\(\\s*0\\s*,\\s*0\\s*,\\s*0\\s*,\\s*0\\s*,/.test(style.transform || "");
+    // Ancestor overflow-clipping: a wrapper with overflow:hidden collapsed to a
+    // near-zero box clips its whole subtree to invisibility even though the
+    // select's own box, style and offsetParent all look ordinary.
+    const isAncestorClipped = (() => {
+      let anc = el.parentElement;
+      for (let d = 0; d < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && anc; d++) {
+        const ancStyle = getComputedStyle(anc);
+        const overflowHides = ancStyle.overflow === "hidden" || ancStyle.overflow === "clip" || ancStyle.overflowX === "hidden" || ancStyle.overflowY === "hidden";
+        if (overflowHides) {
+          const ancRect = anc.getBoundingClientRect();
+          if (ancRect.width <= 1 || ancRect.height <= 1) return true;
+        }
+        anc = anc.parentElement;
+      }
+      return false;
+    })();
+    const isHidden = el.offsetParent === null || (rect.width === 0 && rect.height === 0) || style.display === "none" || style.visibility === "hidden" || parseFloat(style.opacity) === 0 || isOffscreen || hasTinyFootprint || isClipZeroArea || hasClipPath || hasZeroScale || isAncestorClipped;
+    if (!isHidden) return false;
+    const triggerSel = ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)};
+    const optionSel = ${JSON.stringify(PROMPT_OPTION_SELECTORS)};
+    const hasRenderedPanel = (opener, allowUnresolvedDeclaration) => {
+      const ownsId = opener.getAttribute("aria-owns") || opener.getAttribute("aria-controls");
+      const target = ownsId ? document.getElementById(ownsId) : null;
+      if (target) return target.getAttribute("role") === "listbox" || target.querySelector(optionSel) !== null;
+      if (!allowUnresolvedDeclaration) return false;
+      if (!!ownsId || opener.getAttribute("aria-haspopup") === "listbox") return true;
+      return !!(opener.parentElement && opener.parentElement.querySelector(optionSel));
+    };
+    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)) : [];
+      // Only the select's own immediate container may pair on a merely-declared
+      // (not-yet-rendered) aria-owns/aria-controls/aria-haspopup target — an
+      // opener found only by climbing further up must have its panel actually
+      // resolve, or an unrelated sibling widget elsewhere in a shared ancestor
+      // (e.g. a distant visible field's own opener) would false-positive. An
+      // opener with no ARIA pairing declaration at all is credited only when
+      // an option-shaped element sits in ITS OWN immediate container — never
+      // by scanning the whole climbed ancestor, which would credit an
+      // unrelated already-open widget elsewhere in a shared ancestor.
+      if (openers.some((opener) => opener !== el && hasRenderedPanel(opener, depth === 0))) return true;
+      node = node.parentElement;
+    }
+    return false;
+  }`;
 /**
  * Cross-vendor selector union for an in-popup filter/typeahead input — standards
  * first, then the widget-kit's bare filter `<input>` (which carries no
@@ -3060,7 +3172,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
@@ -3145,7 +3257,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") &&
@@ -3210,6 +3322,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 : "",
     };
 }
 /**
@@ -3406,6 +3519,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. */
@@ -4556,7 +4739,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; }
@@ -4571,7 +4755,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++) {
@@ -4609,8 +4794,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
@@ -4800,7 +4989,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 = [];
@@ -5936,6 +6126,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);
@@ -5958,10 +6149,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) {
@@ -6063,12 +6299,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]"));
@@ -6329,7 +6567,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;
@@ -6342,9 +6588,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);
@@ -6438,7 +6703,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)