@enricai/barnacle 1.12.80 → 1.12.82

package/dist/scraper/flow-runner.js

@@ -21,6 +21,7 @@ exports.shouldRetryCaptchaRegistry = shouldRetryCaptchaRegistry;
 exports.buildDeepMarkerCentreExpr = buildDeepMarkerCentreExpr;
 exports.prepareFailureDumpBody = prepareFailureDumpBody;
 exports.fieldValuesAtFailureExpr = fieldValuesAtFailureExpr;
+exports.settleWithPageQuiescence = settleWithPageQuiescence;
 exports.snapshotPage = snapshotPage;
 exports.resolveDumpPageIdentity = resolveDumpPageIdentity;
 exports.findRecentBackendError = findRecentBackendError;
@@ -77,6 +78,7 @@ exports.verifyFillReadback = verifyFillReadback;
 exports.verifyPromptSelectorCommitted = verifyPromptSelectorCommitted;
 exports.tailRetargetPhrasesForStep = tailRetargetPhrasesForStep;
 exports.stepQuotesValueNotControlName = stepQuotesValueNotControlName;
+exports.waitForUploadNetworkSignal = waitForUploadNetworkSignal;
 exports.isUploadAffordanceLabel = isUploadAffordanceLabel;
 exports.writeFixtureToTempFile = writeFixtureToTempFile;
 exports.attachToSurfacedInput = attachToSurfacedInput;
@@ -88,6 +90,7 @@ exports.parseFillStep = parseFillStep;
 exports.parseFillValueIntent = parseFillValueIntent;
 exports.parseSegmentedDateValue = parseSegmentedDateValue;
 exports.resolveSegmentedDateGroup = resolveSegmentedDateGroup;
+exports.parseSegmentedPartStep = parseSegmentedPartStep;
 exports.trySegmentedDateSpinbuttonPrimitive = trySegmentedDateSpinbuttonPrimitive;
 exports.parseRadioStep = parseRadioStep;
 exports.parseWidgetOptionClickStep = parseWidgetOptionClickStep;
@@ -391,6 +394,8 @@ function wireSignalCapture(page, params) {
                 method: capture.method,
                 status: capture.status,
                 url: capture.url,
+                hasBody: (req.requestPostData ?? "").length > 0,
+                multipart: /^multipart\//i.test(requestContentType(req.requestHeaders)),
             });
             if (recentCaptureMeta.length > RECENT_CAPTURES_WINDOW) {
                 recentCaptureMeta.splice(0, recentCaptureMeta.length - RECENT_CAPTURES_WINDOW);
@@ -733,6 +738,18 @@ const PROMPT_CURRENT_TEXT_EXPR = `((w, valueSel, emptyRx) => {
   if (raw.trim() && !emptyRx.test(raw.trim())) return norm(raw);
   return "";
 })`;
+/**
+ * Browser-side predicate: does a widget's committed text name the requested
+ * option as a whole phrase? A bare substring test credits "Astrophysics" for
+ * "Physics"; comparing on word boundaries (punctuation folded to spaces) keeps
+ * chip lists and "N items selected, X" announcements matching while a longer,
+ * different option no longer does.
+ */
+const PROMPT_NAMES_OPTION_EXPR = `((committed, wanted) => {
+  const words = (s) => " " + (s || "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() + " ";
+  const want = words(wanted);
+  return want.trim() === "" || words(committed).includes(want);
+})`;
 /**
  * Browser-side expression reading what a prompt-selector widget ANNOUNCES it
  * committed, lowercased and whitespace-collapsed, or `""` when nothing is
@@ -764,6 +781,8 @@ const PROMPT_ANNOUNCED_VALUE_EXPR = `((w) => {
   let anode = w;
   for (let d = 0; d < ${browser_click_expr_1.MAX_SELECTION_ANCESTOR_DEPTH} && anode; d++) {
     const list = anode.querySelector ? anode.querySelector('[data-automation-id="selectedItemList"]') : null;
+    const entries = list ? Array.from(list.querySelectorAll("*")).filter((e) => e.children.length === 0).map((e) => norm(e.textContent)).filter(Boolean) : [];
+    if (entries.length > 0) return entries.join(" , ");
     if (list && norm(list.textContent)) return norm(list.textContent);
     anode = anode.parentElement;
   }
@@ -933,26 +952,15 @@ const N16_TRUSTED_CLICK_TIMEOUT_MS = 3_000;
 /**
  * Shared pre-click centre + hit-test for a Stagehand-resolved selector, so
  * observe-act and the natural-language act attempts share one routine.
- * Returns a failure message when the control stays covered, null otherwise.
+ * Returns a failure message when the control cannot be centred and hit-tested
+ * (covered, unresolved, or the page cannot answer the probe), null otherwise.
  */
-async function centreObservedClickTarget(target, selector, onUnavailable, deferWhenMissing = false) {
+async function centreObservedClickTarget(target, selector) {
     try {
         await (0, trusted_click_1.centreSelectorForClick)(target, selector);
         return null;
     }
     catch (err) {
-        // A TypeError means the page cannot answer the hit-test probe (no
-        // evaluate seam), not that the control is covered; defer to the act.
-        if (err instanceof TypeError) {
-            onUnavailable(`centre hit-test unavailable: ${(0, errors_1.toErrorMessage)(err)}`);
-            return null;
-        }
-        // Stagehand's own resolution of a natural-language act can differ from the
-        // observe result, so an unresolvable element there is the act's to judge.
-        if (deferWhenMissing && (0, errors_1.toErrorMessage)(err).includes("is not in the document")) {
-            onUnavailable(`centre target unresolved: ${(0, errors_1.toErrorMessage)(err)}`);
-            return null;
-        }
         return `observed click target not clickable: ${(0, errors_1.toErrorMessage)(err)}`;
     }
 }
@@ -1151,6 +1159,61 @@ function fieldValuesAtFailureExpr() {
     return out;
   })()`;
 }
+/**
+ * Reads the in-page quiescence probe as a typed, non-null value. A detached
+ * frame or malformed probe result reads as idle so settle consumes the reader
+ * directly and needs no guard of its own.
+ */
+async function readPageQuiescence(target) {
+    const idle = { pending: 0, mutations: 0 };
+    const result = await Promise.resolve(target.evaluate(click_settle_1.QUIESCENCE_PROBE_EXPR)).catch(() => idle);
+    if (result === null || typeof result !== "object")
+        return idle;
+    const { pending, mutations } = result;
+    return typeof pending === "number" && typeof mutations === "number"
+        ? { pending, mutations }
+        : idle;
+}
+/**
+ * Reads only the visible-text signature settle polls on. Going through
+ * {@link snapshotPage} also read the frame URL, which rejects once a submit
+ * detaches the OOPIF and would abort the settle mid-poll; a failed read here
+ * degrades to the empty signature like the snapshot's own text read does.
+ */
+async function readSettleTextSignature(target) {
+    const result = await Promise.resolve(target.evaluate(DOM_SNAPSHOT_EXPR)).catch(() => null);
+    if (result === null || typeof result !== "object")
+        return "";
+    const { text } = result;
+    return typeof text === "string" ? text : "";
+}
+/**
+ * Settles after a click using the target's own text signature and in-page
+ * quiescence reader, so every post-click site decides from the same settle
+ * signal instead of hand-building the readers.
+ */
+async function settleWithPageQuiescence(page, target, signalCounter, preNetworkCount, submitShaped, preVisibleTextSignature, advanced) {
+    await (0, click_settle_1.settleAfterClick)(page, signalCounter, preNetworkCount, submitShaped, () => readSettleTextSignature(target), preVisibleTextSignature, () => readPageQuiescence(target), advanced);
+}
+/**
+ * Builds the "has the page finished advancing" test a mid-flow submit settles
+ * against. It is the body-swap half of the {@link hasPageAdvanced} the phantom
+ * classifier credits with, so a header that flipped before its body re-rendered
+ * keeps settle polling while the classifier still credits whatever is left once
+ * the wait is spent.
+ * Undefined for any other step, which keeps the plain quiet-window settle.
+ */
+function pageAdvancedSince(preVisibleTextSignature, midFlowSubmit) {
+    if (!midFlowSubmit)
+        return undefined;
+    const pre = {
+        networkCount: 0,
+        url: "",
+        bodyHtmlLength: 0,
+        visibleTextSignature: preVisibleTextSignature,
+    };
+    return (visibleTextSignature) => (0, phantom_click_1.hasPageBodySwapped)(pre, { ...pre, visibleTextSignature });
+}
 /**
  * Captures the pre/post signal triple the submit-verify cascade diffs.
  * Accepts the optional `page` so a resolved child `FrameTarget` whose
@@ -2902,10 +2965,18 @@ async function judgeStepOutcome(params) {
             captureFn,
         });
     }
-    await (0, click_settle_1.settleAfterClick)(params.page, params.signalCounter, params.preNetworkCount, isStepSettleWaitShaped({ step, submitStep: false, isFinalStep, flowHasSubmitSemantics: false }), async () => {
-        const text = await probeRawVisibleText(target);
-        return `${text.length}:${text.slice(0, 200)}`;
-    }, params.preVisibleTextSignature);
+    await settleWithPageQuiescence(params.page, target, params.signalCounter, params.preNetworkCount, isStepSettleWaitShaped({
+        step,
+        submitStep: params.submitStep,
+        isFinalStep,
+        flowHasSubmitSemantics: params.flowHasSubmitSemantics,
+    }) || params.elementSubmitShaped === true, params.preVisibleTextSignature, pageAdvancedSince(params.preVisibleTextSignature, isMidFlowSubmitShapedStep({
+        step,
+        submitStep: params.submitStep,
+        isFinalStep,
+        flowHasSubmitSemantics: params.flowHasSubmitSemantics,
+        elementSubmitShaped: params.elementSubmitShaped,
+    })));
     const colon = params.preVisibleTextSignature.indexOf(":");
     const beforeText = (colon === -1 ? params.preVisibleTextSignature : params.preVisibleTextSignature.slice(colon + 1))
         .replace(/\s+/g, " ")
@@ -3557,8 +3628,8 @@ async function verifyFillReadback(target, selector, expectedValue) {
     if (!el) return null;
     const tag = el.tagName ? el.tagName.toLowerCase() : "";
     let actual = "";
-    const siblings = el.parentElement ? el.parentElement.querySelectorAll("[role='spinbutton']").length : 0;
-    if (el.getAttribute && el.getAttribute("role") === "spinbutton" && siblings > 1) {
+    ${SEGMENT_OWNER_JS}
+    if (isDateSegment(el)) {
       return { outcome: "segment", postValue: el.value || el.getAttribute("aria-valuenow") || "", tag };
     }
     if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
@@ -3624,8 +3695,8 @@ async function verifyPromptSelectorCommitted(target, selector, requestedOption)
     const emptyRx = new RegExp(${JSON.stringify(PROMPT_EMPTY_VALUE_RX_SRC)}, ${JSON.stringify(PROMPT_EMPTY_VALUE_RX_FLAGS)});
     const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
     const announcedValue = ${PROMPT_ANNOUNCED_VALUE_EXPR};
-    const squash = (s) => (s || "").toLowerCase().replace(/[^a-z0-9]+/g, "");
-    const want = squash(${JSON.stringify(requestedOption ?? "")});
+    const namesOption = ${PROMPT_NAMES_OPTION_EXPR};
+    const want = ${JSON.stringify(requestedOption ?? "")};
     const xpath = ${JSON.stringify(xpath)};
     const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
     const el = result.singleNodeValue;
@@ -3633,7 +3704,7 @@ async function verifyPromptSelectorCommitted(target, selector, requestedOption)
     const widget = el.matches && el.matches(triggerSel) ? el : el.closest(triggerSel);
     if (!widget) return { isPromptWidget: false, committed: false };
     const value = announcedValue(widget) || currentText(widget, valueSel, emptyRx);
-    return { isPromptWidget: true, committed: value !== "" && (!want || squash(value).includes(want)) };
+    return { isPromptWidget: true, committed: value !== "" && (!want || namesOption(value, want)) };
   })()`;
     try {
         const raw = await target.evaluate(expr);
@@ -4510,12 +4581,17 @@ const UPLOAD_URL_PATTERNS = [
     "/media",
     "/import",
 ];
+/** Case-insensitive Content-Type lookup; CDP preserves the page's header casing. */
+function requestContentType(headers) {
+    const key = Object.keys(headers).find((k) => k.toLowerCase() === "content-type");
+    return key ? (headers[key] ?? "") : "";
+}
 /**
  * Poll the recent-capture window for an upload-related POST after a file has
  * been attached. Extracted from `tryUploadPrimitive` so the raw-input path,
  * the click-to-surface path, and the CDP native-chooser path all verify the
- * same way. Returns true as soon as a non-GET capture whose URL matches
- * {@link UPLOAD_URL_PATTERNS} lands; false if the timeout elapses first.
+ * same way. Returns true as soon as a non-GET capture that is multipart, or is not
+ * known to be body-less and has a URL matching {@link UPLOAD_URL_PATTERNS}, lands; false if the timeout elapses first.
  */
 async function waitForUploadNetworkSignal(params) {
     const { page, fixture, logger, signalCounter, recentCaptureMeta, stopWhen } = params;
@@ -4528,6 +4604,10 @@ async function waitForUploadNetworkSignal(params) {
             const uploadCapture = newCaptures.find((cap) => {
                 if (cap.method === "GET")
                     return false;
+                if (cap.multipart)
+                    return true;
+                if (cap.hasBody === false)
+                    return false;
                 const lowerUrl = cap.url.toLowerCase();
                 return UPLOAD_URL_PATTERNS.some((p) => lowerUrl.includes(p));
             });
@@ -4659,8 +4739,9 @@ async function tryUploadPrimitive(params) {
  * Attach the fixture to an already-surfaced `<input type=file>` (raw or freshly
  * mounted after a click) and verify. Extracted verbatim from the original
  * `tryUploadPrimitive` body so the raw-input path and the click-to-surface
- * path share one setInputFiles + framework-change-dispatch + network/DOM verify
- * + drag-drop-fallback implementation.
+ * path share one setInputFiles + framework-change-dispatch + network/DOM verify implementation.
+ * Returns true only on a verified signal
+ * (upload POST or populated `.files`).
  */
 async function attachToSurfacedInput(params) {
     const { page, target, fixture, logger, signalCounter, recentCaptureMeta } = params;
@@ -4727,18 +4808,10 @@ async function attachToSurfacedInput(params) {
         .evaluate("(() => { const els = document.querySelectorAll('input[type=file]'); for (const el of els) { if (el.files && el.files.length > 0) return el.files.length; } return 0; })()")
         .catch(() => 0);
     if (typeof attachedLength !== "number" || attachedLength === 0) {
-        logger.warn("upload primitive: no network activity within timeout and no file attached in DOM; attempting drag-drop fallback");
-        // K'4: fall back to simulated drag-drop on the most-likely drop zone.
-        // Some custom upload widgets (Material Dropzone, react-dropzone, custom
-        // <uapp-upload> wrappers) only register files when a `drop` event with
-        // a DataTransfer fires on the visible drop area — they don't observe
-        // the hidden input's `files[]` mutations even with synthetic `change`
-        // dispatches. This is the documented Playwright community workaround.
-        const dragDropOk = await simulateDragDropUpload(target, fixture, logger);
-        if (dragDropOk) {
-            logger.info(`upload primitive: drag-drop fallback succeeded (name=${fixture.name}, size=${fixture.buffer.length}b)`);
-            return true;
-        }
+        // A dispatched drop is unverified (no network signal, no .files), so it is
+        // not success here: return false and let surfaceAndUpload run the verified
+        // drop and the trusted-click/chooser routes.
+        logger.warn("upload primitive: no network activity within timeout and no file attached in DOM; deferring to surface-and-upload");
         return false;
     }
     logger.info(`upload primitive: file attached in DOM after setInputFiles (deferred-upload widget; name=${fixture.name}, filesLength=${attachedLength})`);
@@ -5269,30 +5342,108 @@ function segmentedDateStepTokens(text) {
         return named ? [token] : [];
     });
 }
+const SEGMENTED_DATE_STEP_NOISE = new Set([
+    "barnaclevalue",
+    "click",
+    "type",
+    "enter",
+    "fill",
+    "set",
+    "select",
+    "input",
+    "write",
+    "put",
+    "choose",
+    "use",
+    "press",
+    "focus",
+    "spinbutton",
+    "part",
+    "segment",
+    "digits",
+    "box",
+    "first",
+    "second",
+    "into",
+    "as",
+    "by",
+    "from",
+    "to",
+    "is",
+    "be",
+    "it",
+    "its",
+    "this",
+    "that",
+    "my",
+    "your",
+    ...SEGMENTED_DATE_STOPWORDS,
+    ...SEGMENTED_DATE_FIELD_WORDS,
+    ...SEGMENTED_DATE_PART_LABELS,
+    ...SEGMENTED_DATE_FIELD_NOUNS,
+]);
 /**
  * Pick which spinbutton group a segmented-date step targets. Groups whose
  * segment widths (digit count of `aria-valuemax`) don't sum to the value's
  * digit count are dropped. A group is only eligible when a field the step names
  * (quoted, e.g. 'From', or unquoted in field position, e.g. "the To date")
  * matches its OWN label as whole words — a group with no `label` is judged by
- * its whole `context`. The section the step names ("Work Experience 1") is
+ * its whole `context` — and every other quoted phrase is found in the group's
+ * label or section. The section the step names ("Work Experience 1") is
  * then resolved: when a width-fitting group elsewhere matches the step's
- * section words better than any eligible group does, the named section renders
- * no such field and the step resolves to nothing rather than to another
- * section's. Returns the index into `groups`, or `null` when nothing matches
- * or the best match is tied — writing a date into a group that merely fits the
- * width would corrupt another field.
+ * section words better than any eligible group does, or the group's own
+ * section shares none of the step's remaining words (or numbering), the named
+ * section renders no such field and the step resolves to nothing rather than to
+ * another section's. Returns the index into `groups`, or `null` when nothing
+ * matches or the best match is tied — writing a date into a group that merely
+ * fits the width would corrupt another field. Groups that hold the same
+ * segments under different names never tie.
  */
 function resolveSegmentedDateGroup(instruction, groups) {
     const value = parseSegmentedDateValue(instruction);
     if (!value)
         return null;
+    const compatible = (group) => group.segmentMaxes.map((max) => String(max).length).reduce((a, b) => a + b, 0) ===
+        value.digits.length;
+    return pickSegmentedDateGroup(instruction, groups, value, compatible);
+}
+const SEGMENTED_DATE_PART_BY_LABEL = {
+    month: "month",
+    mm: "month",
+    day: "day",
+    dd: "day",
+    year: "year",
+    yyyy: "year",
+    yy: "year",
+};
+/**
+ * Parse a per-segment step such as "type '01' into Month". Requires a quoted
+ * 1-4 digit value AND exactly one part label (Month/MM, Day/DD, Year/YYYY), so
+ * a bare short numeric (ZIP fragment, age) is never claimed.
+ */
+function parseSegmentedPartStep(instruction) {
+    const raw = parseFillValueIntent(instruction)?.value;
+    if (!raw || !/^\d{1,4}$/.test(raw))
+        return null;
+    const parts = new Set(segmentedDateTokens(instruction.replace(raw, " ")).flatMap((t) => {
+        const part = SEGMENTED_DATE_PART_BY_LABEL[t];
+        return part ? [part] : [];
+    }));
+    const [part] = [...parts];
+    return parts.size === 1 && part ? { digits: raw, valueSpan: raw, part } : null;
+}
+/** Index of the single segment in `group` whose own label names `part`, or null when none/ambiguous. */
+function segmentIndexForPart(group, part) {
+    const hits = (group.segmentLabels ?? []).flatMap((label, si) => segmentedDateTokens(label).some((t) => SEGMENTED_DATE_PART_BY_LABEL[t] === part) ? [si] : []);
+    return hits.length === 1 ? (hits[0] ?? null) : null;
+}
+function pickSegmentedDateGroup(instruction, groups, value, compatible) {
     const valueTokens = segmentedDateTokens(value.valueSpan).join(" ");
     const quoted = (0, quoted_spans_1.findQuotedSpans)(instruction)
         .map((s) => segmentedDateTokens(s.text.trim()))
         .filter((t) => t.length > 0 &&
         t.join(" ") !== valueTokens &&
-        !(t.length === 1 && SEGMENTED_DATE_PART_LABELS.has(t[0] ?? "")));
+        !t.every((token) => SEGMENTED_DATE_PART_LABELS.has(token)));
     const stepTokens = segmentedDateStepTokens(instruction.replace(value.valueSpan, " barnaclevalue "));
     const targets = quoted.length > 0 ? quoted : [stepTokens];
     const contains = (hay, needle) => {
@@ -5302,8 +5453,6 @@ function resolveSegmentedDateGroup(instruction, groups) {
         }
         return false;
     };
-    const compatible = (group) => group.segmentMaxes.map((max) => String(max).length).reduce((a, b) => a + b, 0) ===
-        value.digits.length;
     const stepSet = new Set(stepTokens);
     const sectionScore = (group) => {
         const own = new Set(segmentedDateTokens(group.label ?? ""));
@@ -5313,10 +5462,33 @@ function resolveSegmentedDateGroup(instruction, groups) {
             !SEGMENTED_DATE_STOPWORDS.has(t) &&
             !SEGMENTED_DATE_FIELD_WORDS.has(t)).length;
     };
+    const quotedTokens = new Set(quoted.flat());
+    const leftover = stepTokens.filter((t) => !SEGMENTED_DATE_STEP_NOISE.has(t) && !quotedTokens.has(t));
+    const isNumber = (t) => /^\d+$/.test(t);
+    // A group under another heading is not the field the step names, however
+    // well its label matches: the step's own words must find the section.
+    // A section that only repeats the group's own label is no heading at all
+    // (Workday enumerates "From*" as both), so it cannot name another section.
+    const namesOtherSection = (group) => {
+        const section = segmentedDateTokens(group.section ?? "");
+        const label = segmentedDateTokens(group.label ?? "");
+        if (section.length === 0 || contains(label, section))
+            return false;
+        const known = new Set([...section, ...label]);
+        const words = leftover.filter((t) => !isNumber(t));
+        const numbers = leftover.filter(isNumber);
+        const sectionNumbers = section.filter(isNumber);
+        if (numbers.length > 0 && sectionNumbers.length > 0) {
+            if (!numbers.some((n) => sectionNumbers.includes(n)))
+                return true;
+        }
+        if (words.some((t) => section.includes(t)))
+            return false;
+        return words.some((t) => !known.has(t));
+    };
     const bestSection = Math.max(0, ...groups.filter(compatible).map((group) => sectionScore(group)));
-    let best = -1;
     let bestScore = -1;
-    let tied = false;
+    let leaders = [];
     groups.forEach((group, index) => {
         if (!compatible(group))
             return;
@@ -5326,24 +5498,43 @@ function resolveSegmentedDateGroup(instruction, groups) {
         const namesOwnField = group.label === undefined &&
             quoted.length === 0 &&
             own.some((t) => SEGMENTED_DATE_FIELD_WORDS.has(t) && stepSet.has(t));
-        if (!namesOwnField &&
-            !targets.some((t) => contains(t, own) || (quoted.length > 0 && contains(own, t)))) {
+        const namesOwnLabel = (t) => contains(t, own) || (quoted.length > 0 && contains(own, t));
+        if (!namesOwnField && !targets.some(namesOwnLabel))
+            return;
+        const named = segmentedDateTokens(`${group.section ?? ""} ${group.context}`);
+        if (quoted.some((t) => !namesOwnLabel(t) && !contains(named, t)))
+            return;
+        if (namesOtherSection(group))
             return;
-        }
         const score = sectionScore(group);
         if (score < bestSection)
             return;
         if (score > bestScore) {
-            best = index;
             bestScore = score;
-            tied = false;
+            leaders = [index];
         }
         else if (score === bestScore) {
-            tied = true;
+            const alias = (a, b) => (groups[a]?.sameAs ?? a) === (groups[b]?.sameAs ?? b) ||
+                groups[a]?.sameAs === b ||
+                groups[b]?.sameAs === a;
+            const twin = leaders.findIndex((leader) => alias(leader, index));
+            if (twin < 0)
+                leaders.push(index);
+            else
+                leaders[twin] = Math.min(leaders[twin] ?? index, index);
         }
     });
-    if (best >= 0)
-        return tied ? null : best;
+    if (leaders.length === 1)
+        return leaders[0] ?? null;
+    if (leaders.length > 1) {
+        // A nested group is one wrapper's slice of a larger date widget (e.g. the
+        // Year half of "From MM/YYYY"), so it only ties with a standalone group of
+        // the same label when no section text separates them — Workday renders
+        // "Work Experience 1 From" and "Education 1 From" with no heading the
+        // enumerator can see. The standalone group is the field the step names.
+        const standalone = leaders.filter((i) => !groups[i]?.nested);
+        return standalone.length === 1 ? (standalone[0] ?? null) : null;
+    }
     // A step that names no field at all can only mean the one date widget on the
     // page; a named field that matched no label must never fall back to it.
     if (quoted.length > 0 || stepTokens.some((t) => SEGMENTED_DATE_FIELD_WORDS.has(t)))
@@ -5351,12 +5542,12 @@ function resolveSegmentedDateGroup(instruction, groups) {
     const only = groups.flatMap((g, i) => (compatible(g) && !g.nested ? [i] : []));
     return only.length === 1 ? (only[0] ?? null) : null;
 }
-const SEGMENTED_DATE_MARKER_ATTR = "data-barnacle-segdate";
-/** Exported so tests can run the real DOM enumeration against markup. */
-exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
-  const attr = ${JSON.stringify(SEGMENTED_DATE_MARKER_ATTR)};
-  const stale = document.querySelectorAll("[" + attr + "]");
-  stale.forEach((el) => el.removeAttribute(attr));
+/**
+ * In-page helpers shared by the date-segment enumeration and the fill
+ * readback so "is this spinbutton one segment of a multi-segment widget" has a
+ * single definition; defines `spins`, `ownerOf` and `isDateSegment`.
+ */
+const SEGMENT_OWNER_JS = `
   const hiddenAttr = (node) => node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true";
   const styleOf = (node) => {
     try { return typeof getComputedStyle === "function" ? getComputedStyle(node) : window.getComputedStyle(node); } catch { return null; }
@@ -5370,18 +5561,53 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     return false;
   };
   const spins = Array.from(document.querySelectorAll("input[role='spinbutton']")).filter((el) => !isHidden(el));
-  if (spins.length === 0) return { groups: [] };
   const norm = (s) => (s || "").replace(/\\s+/g, " ").trim();
-  const byContainer = new Map();
-  for (const el of spins) {
-    const box = el.closest("fieldset,[role='group']") || el.parentElement;
-    if (!byContainer.has(box)) byContainer.set(box, []);
-    byContainer.get(box).push(el);
-  }
   const idText = (ids) => (ids || "").split(/\\s+/).map((id) => {
     const ref = id ? document.getElementById(id) : null;
     return ref ? norm(ref.textContent) : "";
   }).join(" ");
+  const legendOf = (node) => {
+    const legend = node.tagName === "FIELDSET" ? node.querySelector(":scope > legend") : null;
+    return legend ? norm(legend.textContent) : "";
+  };
+  const namedBy = (node) => [legendOf(node), norm(node.getAttribute("aria-label")), idText(node.getAttribute("aria-labelledby"))].filter(Boolean).join(" ");
+  const tiedToSpin = (l) => l.querySelector("input,[role='spinbutton']") || (l.getAttribute("for") && spins.some((sp) => sp.id === l.getAttribute("for")));
+  const hasCaption = (node) => namedBy(node) !== "" || Array.from(node.querySelectorAll("label,legend")).some((l) => !tiedToSpin(l));
+  const captionOwnerOf = (el) => {
+    const explicit = el.closest("fieldset,[role='group']");
+    if (explicit) return explicit;
+    for (let node = el.parentElement; node && node !== document.body; node = node.parentElement) {
+      if (hasCaption(node)) return node;
+    }
+    return null;
+  };
+  const bareSpins = spins.filter((sp) => !captionOwnerOf(sp));
+  const hasOtherControl = (node) => Array.from(node.querySelectorAll("input,select,textarea")).some((c) => !spins.includes(c) && c.type !== "hidden");
+  // Segments that each sit in their own uncaptioned wrapper share no
+  // fieldset/caption, so the nearest ancestor holding several bare spinbuttons
+  // (and no other form control) is the widget they belong to.
+  const bareOwnerOf = (el) => {
+    for (let node = el.parentElement; node && node !== document.body; node = node.parentElement) {
+      if (hasOtherControl(node)) break;
+      if (bareSpins.filter((sp) => node.contains(sp)).length > 1) return node;
+    }
+    return el.parentElement;
+  };
+  const ownerOf = (el) => captionOwnerOf(el) || bareOwnerOf(el);
+  const isDateSegment = (el) => {
+    if (!el.getAttribute || el.getAttribute("role") !== "spinbutton" || !spins.includes(el)) return false;
+    const box = ownerOf(el);
+    return spins.filter((sp) => ownerOf(sp) === box).length > 1;
+  };
+`;
+const SEGMENTED_DATE_MARKER_ATTR = "data-barnacle-segdate";
+/** Exported so tests can run the real DOM enumeration against markup. */
+exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
+  const attr = ${JSON.stringify(SEGMENTED_DATE_MARKER_ATTR)};
+  const stale = document.querySelectorAll("[" + attr + "]");
+  stale.forEach((el) => el.removeAttribute(attr));
+  ${SEGMENT_OWNER_JS}
+  if (spins.length === 0) return { groups: [] };
   const headingSibling = (node) => {
     let prevSib = node.previousElementSibling;
     for (let hop = 0; hop < 3 && prevSib; hop++, prevSib = prevSib.previousElementSibling) {
@@ -5389,11 +5615,6 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     }
     return "";
   };
-  const legendOf = (node) => {
-    const legend = node.tagName === "FIELDSET" ? node.querySelector(":scope > legend") : null;
-    return legend ? norm(legend.textContent) : "";
-  };
-  const namedBy = (node) => [legendOf(node), norm(node.getAttribute("aria-label")), idText(node.getAttribute("aria-labelledby"))].filter(Boolean).join(" ");
   const sectionOf = (box, includeSelf) => {
     const parts = [includeSelf ? namedBy(box) : "", headingSibling(box)];
     let node = box.parentElement;
@@ -5408,11 +5629,12 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     const prev = box.previousElementSibling;
     return prev && prev.matches("label,legend") && !prev.querySelector("input,[role='spinbutton']") ? norm(prev.textContent) : "";
   };
-  const formFieldOf = (box) => box.closest("[data-automation-id^='formField-']");
-  const formFieldLabel = (field) => {
-    const label = field.querySelector("label,legend");
-    return label ? norm(label.textContent) : "";
-  };
+  const byContainer = new Map();
+  for (const el of spins) {
+    const box = ownerOf(el);
+    if (!byContainer.has(box)) byContainer.set(box, []);
+    byContainer.get(box).push(el);
+  }
   const labelText = (seg) => {
     const parts = [idText(seg.getAttribute("aria-labelledby")), norm(seg.getAttribute("aria-label")), norm(seg.getAttribute("placeholder"))];
     if (seg.id) {
@@ -5441,21 +5663,65 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
   const addGroup = (segs, box, nested) => {
     const gi = groups.length;
     segs.forEach((seg, si) => mark(seg, gi + ":" + si));
-    const field = formFieldOf(box) || segs[0].closest("[data-automation-id^='formField-']");
-    const innerField = field && field !== box && box.contains(field) && segs.every((seg) => field.contains(seg)) ? formFieldLabel(field) : "";
-    const own = innerField || namedBy(box) || (field ? formFieldLabel(field) : "") || ownCaption(box) || segs.map((seg) => idText(seg.getAttribute("aria-labelledby"))).filter(Boolean).join(" ");
-    const section = sectionOf(box, Boolean(innerField));
+    let inner = null;
+    for (let node = segs[0].parentElement; node && node !== box && box.contains(node) && !inner; node = node.parentElement) {
+      if (segs.every((seg) => node.contains(seg)) && hasCaption(node)) inner = node;
+    }
+    const labelBox = inner || box;
+    const own = namedBy(labelBox) || ownCaption(labelBox) || segs.map((seg) => idText(seg.getAttribute("aria-labelledby"))).filter(Boolean).join(" ");
+    const section = sectionOf(labelBox, Boolean(inner));
     groups.push({
       segmentMaxes: segs.map((seg, si) => maxOf(seg, si, segs.length)),
       context: [section, own].filter(Boolean).join(" "),
       label: own,
       section,
       nested,
+      segmentLabels: segs.map((seg) => labelText(seg)),
     });
   };
+  const PART_WORD = /^(mm|dd|yyyy|yy|month|day|year)$/i;
+  const keyOf = (text) => norm(text).split(" ").filter((word) => {
+    const parts = word.split(/[^A-Za-z0-9]+/).filter(Boolean);
+    return parts.length > 0 && !parts.every((part) => PART_WORD.test(part));
+  }).join(" ");
+  const ownKey = (seg) => {
+    const parts = [idText(seg.getAttribute("aria-labelledby")), norm(seg.getAttribute("aria-label"))];
+    if (seg.id) {
+      document.querySelectorAll("label").forEach((l) => { if (l.getAttribute("for") === seg.id) parts.push(norm(l.textContent)); });
+    }
+    const wrap = seg.closest("label");
+    if (wrap) parts.push(norm(wrap.textContent));
+    return keyOf(parts.filter(Boolean).join(" "));
+  };
+  // A container's legend names the whole section; the field a segment belongs
+  // to is the caption naming it, or the caption nearest before it with no other
+  // control in between.
+  const fieldKeys = (segs, box) => {
+    const own = new Set(segs);
+    const boxLegend = box.tagName === "FIELDSET" ? box.querySelector(":scope > legend") : null;
+    const keys = new Map();
+    let current = "";
+    box.querySelectorAll("label,legend,input,select,textarea,button").forEach((el) => {
+      if (el === boxLegend) return;
+      if (el.matches("label,legend")) {
+        const target = el.getAttribute("for");
+        if (isHidden(el) || el.querySelector("input,select,textarea,[role='spinbutton']") || (target && box.querySelector("[id='" + target + "']"))) return;
+        current = keyOf(el.textContent);
+        return;
+      }
+      if (!own.has(el)) {
+        if (!isHidden(el)) current = "";
+        return;
+      }
+      keys.set(el, ownKey(el) || current);
+    });
+    return segs.map((seg) => keys.get(seg) || "");
+  };
+  const captionRuns = [];
   const nestedCandidates = [];
   byContainer.forEach((segs, box) => {
     addGroup(segs, box, false);
+    const outerIndex = groups.length - 1;
     const byParent = new Map();
     for (const seg of segs) {
       if (!byParent.has(seg.parentElement)) byParent.set(seg.parentElement, []);
@@ -5463,9 +5729,36 @@ exports.SEGMENTED_DATE_ENUMERATE_EXPR = `(() => {
     }
     // A shared fieldset can hold several independent dates (From and To year
     // spinbuttons side by side); each wrapper is then its own candidate group.
-    if (byParent.size > 1) byParent.forEach((inner, parent) => nestedCandidates.push([inner, parent]));
+    if (byParent.size > 1) {
+      byParent.forEach((inner, parent) => nestedCandidates.push([inner, parent]));
+      return;
+    }
+    const keys = fieldKeys(segs, box);
+    const runs = [];
+    segs.forEach((seg, si) => {
+      const last = runs[runs.length - 1];
+      if (last && last.key === keys[si]) last.segs.push(seg);
+      else runs.push({ key: keys[si], segs: [seg] });
+    });
+    runs.filter((run) => run.key).forEach((run) => captionRuns.push({ run, box, outerIndex, whole: run.segs.length === segs.length }));
   });
   nestedCandidates.forEach(([inner, parent]) => addGroup(inner, parent, true));
+  captionRuns.forEach(({ run, box, outerIndex, whole }) => {
+    const outer = groups[outerIndex];
+    const same = (a, b) => a.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() === b.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+    if (whole && same(outer.label || "", run.key)) return;
+    const gi = groups.length;
+    run.segs.forEach((seg, si) => mark(seg, gi + ":" + si));
+    const section = sectionOf(box, true);
+    groups.push({
+      segmentMaxes: run.segs.map((seg, si) => maxOf(seg, si, run.segs.length)),
+      context: [section, run.key].filter(Boolean).join(" "),
+      label: run.key,
+      section,
+      nested: true,
+      sameAs: whole ? outerIndex : undefined,
+    });
+  });
   return { groups };
 })()`;
 const SEGMENTED_DATE_CLEAR_EXPR = `(() => {
@@ -5484,15 +5777,29 @@ const SEGMENTED_DATE_CLEAR_EXPR = `(() => {
  */
 async function trySegmentedDateSpinbuttonPrimitive(params) {
     const { page, target, instruction, logger } = params;
-    const value = parseSegmentedDateValue(instruction);
-    if (!value)
+    const whole = parseSegmentedDateValue(instruction);
+    const part = parseSegmentedPartStep(instruction);
+    if (!whole && !part)
         return null;
-    const sendCDP = (method, args) => target.frame?.session ? target.frame.session.send(method, args) : page.sendCDP(method, args);
+    const sendCDP = frameCdpSender(page, target);
     try {
         const enumerated = (await target.evaluate(exports.SEGMENTED_DATE_ENUMERATE_EXPR));
         if (!enumerated?.groups?.length)
             return null;
-        const gi = resolveSegmentedDateGroup(instruction, enumerated.groups);
+        const wholeGi = whole ? resolveSegmentedDateGroup(instruction, enumerated.groups) : null;
+        const partStep = wholeGi === null ? part : null;
+        const value = (wholeGi !== null ? whole : part);
+        const partOf = (group) => partStep ? segmentIndexForPart(group, partStep.part) : null;
+        const partFits = (group) => {
+            const si = partOf(group);
+            return (!group.nested &&
+                si !== null &&
+                value.digits.length <= String(group.segmentMaxes[si] ?? 0).length);
+        };
+        const gi = wholeGi ??
+            (partStep
+                ? pickSegmentedDateGroup(instruction, enumerated.groups, partStep, partFits)
+                : null);
         if (gi === null) {
             logger.info("segmented date primitive: no unambiguous group; falling through");
             await target.evaluate(SEGMENTED_DATE_CLEAR_EXPR);
@@ -5500,10 +5807,15 @@ async function trySegmentedDateSpinbuttonPrimitive(params) {
         }
         const maxes = enumerated.groups[gi]?.segmentMaxes ?? [];
         const widths = maxes.map((max) => String(max).length);
-        const expected = widths.map((w, i) => {
-            const start = widths.slice(0, i).reduce((a, b) => a + b, 0);
-            return Number(value.digits.slice(start, start + w));
-        });
+        const onlySegment = partStep ? partOf(enumerated.groups[gi]) : null;
+        const active = widths.flatMap((_, si) => onlySegment === null || si === onlySegment ? [si] : []);
+        const sliceFor = (si) => {
+            if (onlySegment !== null)
+                return value.digits;
+            const start = widths.slice(0, si).reduce((a, b) => a + b, 0);
+            return value.digits.slice(start, start + (widths[si] ?? 0));
+        };
+        const expected = active.map((si) => Number(sliceFor(si)));
         const segmentSelector = (si) => `[${SEGMENTED_DATE_MARKER_ATTR}~="${gi}:${si}"]`;
         const focusSegment = async (si) => {
             const selector = segmentSelector(si);
@@ -5516,7 +5828,9 @@ async function trySegmentedDateSpinbuttonPrimitive(params) {
                 // scrolling is best-effort; the key events only need the segment focused
             }
             try {
-                if (await (0, trusted_click_1.isClickPointUnobscured)(target, selector)) {
+                // An open option popup can cover the field; clear it so the trusted
+                // click lands on the segment instead of falling back to a bare focus().
+                if (await clearObscuringPopup(page, target, selector)) {
                     await (0, trusted_click_1.clickCentredTrusted)(target, selector, { label: "date segment" });
                 }
             }
@@ -5536,12 +5850,9 @@ async function trySegmentedDateSpinbuttonPrimitive(params) {
                 await sendCDP("Input.dispatchKeyEvent", { type: "keyUp", ...keyArgs });
             }
         };
-        const segmentDigits = widths.map((w, i) => {
-            const from = widths.slice(0, i).reduce((acc, n) => acc + n, 0);
-            return value.digits.slice(from, from + w);
-        });
+        const segmentDigits = active.map((si) => sliceFor(si));
         const readSegments = async () => (await target.evaluate(`(() => {
-      const sels = ${JSON.stringify(widths.map((_, si) => segmentSelector(si)))};
+      const sels = ${JSON.stringify(active.map((si) => segmentSelector(si)))};
       return sels.map((sel) => {
         const s = document.querySelector(sel);
         if (!s) return NaN;
@@ -5558,15 +5869,18 @@ async function trySegmentedDateSpinbuttonPrimitive(params) {
         // locator.type (per-character key events, never Input.insertText) covers a
         // page whose CDP channel does not reach the widget.
         const typeViaLocator = async () => {
-            for (const [si, digits] of segmentDigits.entries()) {
-                await target.locator(segmentSelector(si)).first().type(digits, {
+            for (const [k, digits] of segmentDigits.entries()) {
+                await target
+                    .locator(segmentSelector(active[k] ?? 0))
+                    .first()
+                    .type(digits, {
                     delay: SEGMENTED_DATE_KEY_DELAY_MS,
                 });
             }
         };
         const typeViaKeyEvents = async () => {
-            for (const [si, digits] of segmentDigits.entries()) {
-                await focusSegment(si);
+            for (const [k, digits] of segmentDigits.entries()) {
+                await focusSegment(active[k] ?? 0);
                 await typeViaCdp(digits);
             }
         };
@@ -5961,6 +6275,16 @@ function isNavigatingEvaluateRejection(error) {
         message.includes("no frame for given id found") ||
         GENERIC_CONTENT_FREE_EVAL_REJECTION_MESSAGES.has(message.trim()));
 }
+/**
+ * Settles after a click and returns the post-click snapshot, so the settle
+ * wait and the phantom classifier decide from the same reader and baseline.
+ * Without a page there is nothing to wait on and the snapshot is taken as-is.
+ */
+async function settleAndSnapshotPostClick(target, signalCounter, page, pre, midFlowSubmit = false) {
+    if (page)
+        await settleWithPageQuiescence(page, target, signalCounter, pre.networkCount, true, pre.visibleTextSignature, pageAdvancedSince(pre.visibleTextSignature, midFlowSubmit));
+    return snapshotPage(target, signalCounter, page);
+}
 /**
  * Shared in-page discovery of the widget's callback, used identically by
  * `injectCaptchaTokenAndSubmit`'s precheck (to decide the branch) and its
@@ -6268,9 +6592,7 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
         if (clickResult.clicked) {
             if (!pre || !verification)
                 return true;
-            if (verification.page)
-                await (0, click_settle_1.settleAfterClick)(verification.page, verification.signalCounter, pre.networkCount, true, async () => (await snapshotPage(target, verification.signalCounter)).visibleTextSignature, pre.visibleTextSignature);
-            const post = await snapshotPage(target, verification.signalCounter, verification.page);
+            const post = await settleAndSnapshotPostClick(target, verification.signalCounter, verification.page, pre, verification.isMidFlowSubmitStep);
             const verdict = (0, phantom_click_1.classifyPhantomClick)({
                 actResultSuccess: true,
                 pre,
@@ -6291,9 +6613,7 @@ async function submitCaptchaGatedForm(target, responseField = "h-captcha-respons
                     throw err;
                 });
                 if (runnerUpClickResult.clicked) {
-                    if (verification.page)
-                        await (0, click_settle_1.settleAfterClick)(verification.page, verification.signalCounter, post.networkCount, true, async () => (await snapshotPage(target, verification.signalCounter)).visibleTextSignature, post.visibleTextSignature);
-                    const runnerUpPost = await snapshotPage(target, verification.signalCounter, verification.page);
+                    const runnerUpPost = await settleAndSnapshotPostClick(target, verification.signalCounter, verification.page, post, verification.isMidFlowSubmitStep);
                     const runnerUpVerdict = (0, phantom_click_1.classifyPhantomClick)({
                         actResultSuccess: true,
                         pre: post,
@@ -6839,7 +7159,10 @@ async function tryCheckboxStatePrimitive(params) {
         let overlaid = false;
         let trustedDelivered = false;
         for (const sel of clickSels) {
-            const probe = await (0, trusted_click_1.probeClickPoint)(target, sel);
+            const firstProbe = await (0, trusted_click_1.probeClickPoint)(target, sel);
+            const probe = firstProbe?.state === "occluded" && firstProbe.occluder !== "none"
+                ? await dismissLeftoverPromptPopups(page, target).then(() => (0, trusted_click_1.probeClickPoint)(target, sel), () => firstProbe)
+                : firstProbe;
             if (probe?.state === "occluded" && probe.occluder !== "none") {
                 overlaid = true;
                 continue;
@@ -7897,7 +8220,7 @@ async function tryPromptSelectorPrimitive(params) {
             logger.info(`prompt-selector primitive: filtered list for ${optLabel} names no matching option; submitting with Enter`);
             try {
                 await target.evaluate(`(() => { const el = document.querySelector('[${PROMPT_OPTION_MARK_ATTR}-search="1"]'); if (el) el.focus(); })()`);
-                await sendTrustedEnter(page);
+                await sendTrustedEnter(page, target);
             }
             catch (err) {
                 logger.info(`prompt-selector primitive: enter submit failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}`);
@@ -7940,7 +8263,7 @@ const PROMPT_SELECTOR_MAX_STABLE_READS = 5;
  * committer is never handed an unsettled list.
  */
 async function readStablePromptOptions(page, target, enumerateOptionsExpr, initial) {
-    const key = (r) => JSON.stringify((r?.options ?? []).map((o) => [o.text, o.nodeId ?? null]));
+    const key = (r) => JSON.stringify((r?.options ?? []).map((o) => [o.text, o.domText ?? null]));
     let current = initial;
     for (let read = 0; read < PROMPT_SELECTOR_MAX_STABLE_READS; read++) {
         await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
@@ -7979,33 +8302,78 @@ function promptOptionsNameOption(result, option) {
     const want = normPromptOptionText(option);
     if (want === "")
         return true;
-    return (result?.options ?? []).some((o) => {
+    return realPromptOptions(result?.options ?? [], option).some((o) => {
+        const text = normPromptOptionText(o.text);
+        return text === want || text.includes(want);
+    });
+}
+/**
+ * Single classification of which rendered entries are real options, shared by
+ * the submit decision and the committer so they cannot disagree. Placeholders
+ * ("No Items.", "No results for x") are dropped, except an entry that is
+ * exactly the requested text, which is the user's own option.
+ */
+function realPromptOptions(options, option) {
+    const want = normPromptOptionText(option);
+    return options.filter((o) => {
         const text = normPromptOptionText(o.text);
         if (text === "")
             return false;
-        if (text === want)
-            return true;
-        if (PROMPT_PLACEHOLDER_RE.test(text))
-            return false;
-        return text.includes(want);
+        return text === want || !PROMPT_PLACEHOLDER_RE.test(text);
     });
 }
-/** Dispatches a trusted Enter to the focused element (the filter input) via CDP. */
-async function sendTrustedEnter(page) {
-    const key = { key: "Enter", code: "Enter", windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 };
-    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyDown", text: "\r", ...key });
-    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyUp", ...key });
+/**
+ * Single owner of CDP delivery for trusted input: a child-frame target's own
+ * session when it has one, otherwise the page's, so keys reach the frame that
+ * holds the focused element.
+ */
+function frameCdpSender(page, target) {
+    return (method, args) => target.frame?.session ? target.frame.session.send(method, args) : page.sendCDP(method, args);
 }
-/** Dispatches a trusted Escape to the focused element via CDP, closing a popup left open. */
-async function sendTrustedEscape(page) {
-    const key = {
+/**
+ * Clicks at a frame-local viewport point through the same CDP route as keys, so
+ * the press lands where the hit test just ran instead of re-resolving a locator.
+ * A same-process child frame has no session of its own, so its offset in the
+ * page is added to reach page coordinates.
+ */
+async function dispatchTrustedClick(page, target, x, y) {
+    if (target.frame === null) {
+        await page.click(x, y);
+        return;
+    }
+    const send = frameCdpSender(page, target);
+    const offset = target.frame.session
+        ? { x: 0, y: 0 }
+        : ((await target
+            .evaluate(`(() => {
+            const f = window.frameElement;
+            if (!f) return null;
+            const r = f.getBoundingClientRect();
+            return { x: r.left, y: r.top };
+          })()`)
+            .catch(() => null)) ?? { x: 0, y: 0 });
+    const point = { x: x + offset.x, y: y + offset.y, button: "left", clickCount: 1 };
+    await send("Input.dispatchMouseEvent", { type: "mouseMoved", x: point.x, y: point.y });
+    await send("Input.dispatchMouseEvent", { type: "mousePressed", ...point });
+    await send("Input.dispatchMouseEvent", { type: "mouseReleased", ...point });
+}
+async function sendTrustedKey(page, target, key, text) {
+    const send = frameCdpSender(page, target);
+    await send("Input.dispatchKeyEvent", { type: "keyDown", ...(text ? { text } : {}), ...key });
+    await send("Input.dispatchKeyEvent", { type: "keyUp", ...key });
+}
+/** Dispatches a trusted Enter to the focused element (the filter input) via the target frame's CDP session. */
+async function sendTrustedEnter(page, target) {
+    await sendTrustedKey(page, target, { key: "Enter", code: "Enter", windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 }, "\r");
+}
+/** Dispatches a trusted Escape to the focused element via the target frame's CDP session, closing a popup left open. */
+async function sendTrustedEscape(page, target) {
+    await sendTrustedKey(page, target, {
         key: "Escape",
         code: "Escape",
         windowsVirtualKeyCode: 27,
         nativeVirtualKeyCode: 27,
-    };
-    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyDown", ...key });
-    await page.sendCDP("Input.dispatchKeyEvent", { type: "keyUp", ...key });
+    });
 }
 /**
  * Counts rendered listbox / activeListContainer popups other than the chip
@@ -8049,18 +8417,52 @@ async function dismissLeftoverPromptPopups(page, target) {
             .catch(() => 0));
         if (!count)
             return;
-        logger.info(`prompt-selector primitive: dismissing ${count} leftover popup(s) via Escape`);
-        const trusted = await sendTrustedEscape(page)
+        logger.info(`popup dismissal: dismissing ${count} leftover popup(s) via Escape`);
+        const trusted = await sendTrustedEscape(page, target)
             .then(() => true)
             .catch((err) => {
-            logger.info(`prompt-selector primitive: Escape dispatch failed: ${(0, errors_1.toErrorMessage)(err)}`);
+            logger.info(`popup dismissal: Escape dispatch failed: ${(0, errors_1.toErrorMessage)(err)}`);
             return false;
         });
         if (!trusted || attempt > 0)
             await target.evaluate(IN_PAGE_ESCAPE_EXPR).catch(() => undefined);
-        await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS).catch(() => undefined);
+        await settleAfterEscape(page);
     }
 }
+/** Waits for a dismissed popup to unpaint; a page without a timer seam just proceeds. */
+async function settleAfterEscape(page) {
+    await Promise.resolve()
+        .then(() => page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS))
+        .catch(() => undefined);
+}
+/**
+ * Clears whatever popup paints over `selector`'s click point so the caller's
+ * trusted click lands on the field. The hit test, not the popup's markup, is
+ * the evidence: a named occluder gets the listbox-aware dismissal first and
+ * then a plain Escape for popups that dismissal does not recognise. Resolves
+ * true only when a fresh hit test reaches the field; an indeterminate probe
+ * (no layout, nothing at the point) only ever gets the listbox-aware
+ * dismissal, never a blind Escape.
+ */
+async function clearObscuringPopup(page, target, selector) {
+    const covered = (probe) => probe?.state === "occluded" && probe.occluder !== undefined && probe.occluder !== "none";
+    const first = await (0, trusted_click_1.probeClickPoint)(target, selector);
+    if (first?.state === "hit")
+        return true;
+    await dismissLeftoverPromptPopups(page, target).catch(() => undefined);
+    const afterListbox = await (0, trusted_click_1.probeClickPoint)(target, selector);
+    if (afterListbox?.state === "hit")
+        return true;
+    if (!covered(afterListbox))
+        return false;
+    const trusted = await sendTrustedEscape(page, target)
+        .then(() => true)
+        .catch(() => false);
+    if (!trusted)
+        await target.evaluate(IN_PAGE_ESCAPE_EXPR).catch(() => undefined);
+    await settleAfterEscape(page);
+    return (await (0, trusted_click_1.probeClickPoint)(target, selector))?.state === "hit";
+}
 /**
  * Phase 3 of {@link tryPromptSelectorPrimitive}: given the popup's rendered
  * (possibly filtered) option list, match the requested option — deterministic
@@ -8091,7 +8493,7 @@ async function commitPromptOption(params) {
         .join("
");
     let optionsResult = params.optionsResult;
     for (let depth = 0; depth <= PROMPT_SELECTOR_MAX_DRILL_DEPTH; depth++) {
-        const options = optionsResult.options ?? [];
+        const options = realPromptOptions(optionsResult.options ?? [], option);
         const detMatch = options.find((o) => norm(o.text) === wantOpt) ?? null;
         if (detMatch === null && (anthropic === null || options.length === 0)) {
             logger.info(`prompt-selector primitive: no option match for ${optLabel}${anthropic === null ? " (no LLM client)" : ""}; falling through to cascade`);
@@ -8129,7 +8531,7 @@ async function commitPromptOption(params) {
         let clicked = false;
         for (let attempt = 0; attempt < PROMPT_SELECTOR_MAX_CLICK_RESOLVES && !clicked; attempt++) {
             const fresh = (await target.evaluate(enumerateOptionsExpr).catch(() => null));
-            const freshMatches = (fresh?.options ?? []).filter((o) => norm(o.text) === wantChosenText);
+            const freshMatches = realPromptOptions(fresh?.options ?? [], option).filter((o) => norm(o.text) === wantChosenText);
             const freshOption = freshMatches.find((o) => o.nodeId !== undefined && o.nodeId === chosenOption.nodeId) ??
                 freshMatches[0];
             if (!freshOption) {
@@ -8152,6 +8554,19 @@ async function commitPromptOption(params) {
                 await (0, trusted_click_1.clickCentredTrusted)(target, optionSel, {
                     label: "prompt-selector option",
                     expectText: expectedDomText,
+                    clickAtPoint: async (x, y) => {
+                        const stillThere = await target
+                            .evaluate(`((x, y, want) => {
+                  const hit = document.elementFromPoint(x, y);
+                  const el = hit && hit.closest(${JSON.stringify(optionSel)});
+                  return !!el && (el.textContent || "").replace(/\\s+/g, " ").trim() === want;
+                })(${x}, ${y}, ${JSON.stringify(expectedDomText)})`)
+                            .catch(() => false);
+                        if (!stillThere) {
+                            throw new trusted_click_1.CentredClickError("centred click: prompt-selector option identity mismatch at click point, click withheld", "mismatch");
+                        }
+                        await dispatchTrustedClick(page, target, x, y);
+                    },
                     verifyBeforeClick: async () => (await target
                         .evaluate(`((sel, want) => {
                   const el = document.querySelector(sel);
@@ -8180,6 +8595,7 @@ async function commitPromptOption(params) {
       const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
       const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
       const announcedValue = ${PROMPT_ANNOUNCED_VALUE_EXPR};
+      const namesOption = ${PROMPT_NAMES_OPTION_EXPR};
       const w = document.querySelector("[" + markAttr + '="' + wIdx + '"]');
       if (!w) return { ok: false, id: "", stillInvalid: false };
       const text = currentText(w, valueSel, emptyRx);
@@ -8238,7 +8654,7 @@ async function commitPromptOption(params) {
       // The widget's own announcement of what it committed is ground truth when readable.
       const committed = announcedValue(w);
       if (committed) {
-        return { ok: !!wantText && committed.includes(wantText), id: w.id || "", stillInvalid, committed };
+        return { ok: !!wantText && namesOption(committed, wantText), id: w.id || "", stillInvalid, committed };
       }
       // A wrong option leaves the widget valid, so !stillInvalid proves nothing
       // once the widget's own value is readable: a readable value naming another
@@ -8410,6 +8826,9 @@ async function hasUnfilledRequiredControlForStep(target, instruction) {
  * upload/dropzone/file-related class or tag names. Tries multiple
  * candidates in order. Returns true on first success.
  *
+ * Dispatch-only: a true return means the drop events fired, not that the
+ * widget accepted the file; callers must verify.
+ *
  * Site-agnostic — DataTransfer + DragEvent dispatch is universal HTML5
  * drag-and-drop API. Works on react-dropzone, Material Dropzone, custom
  * <uapp-upload>/<app-upload>, and any other drop-zone-based upload UI.
@@ -9517,11 +9936,7 @@ async function probeChildFrameSubmitFallback(params) {
         const clickResult = (await Promise.resolve(target.evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(top.deepIndex))).catch(() => ({ clicked: false })));
         if (!clickResult.clicked)
             continue;
-        await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, true, async () => {
-            const snap = await snapshotPage(target, signalCounter);
-            return snap.visibleTextSignature;
-        }, pre.visibleTextSignature);
-        const post = await snapshotPage(target, signalCounter, page);
+        const post = await settleAndSnapshotPostClick(target, signalCounter, page, pre, isMidFlowSubmitStep);
         const verdict = (0, phantom_click_1.classifyPhantomClick)({
             actResultSuccess: true,
             pre,
@@ -9538,11 +9953,7 @@ async function probeChildFrameSubmitFallback(params) {
         const runnerUpClickResult = (await Promise.resolve(target.evaluate((0, submit_control_1.buildClickByDeepIndexExpr)(runnerUp.deepIndex))).catch(() => ({ clicked: false })));
         if (!runnerUpClickResult.clicked)
             continue;
-        await (0, click_settle_1.settleAfterClick)(page, signalCounter, post.networkCount, true, async () => {
-            const snap = await snapshotPage(target, signalCounter);
-            return snap.visibleTextSignature;
-        }, post.visibleTextSignature);
-        const runnerUpPost = await snapshotPage(target, signalCounter, page);
+        const runnerUpPost = await settleAndSnapshotPostClick(target, signalCounter, page, post, isMidFlowSubmitStep);
         const runnerUpVerdict = (0, phantom_click_1.classifyPhantomClick)({
             actResultSuccess: true,
             pre,
@@ -10299,7 +10710,7 @@ async function executeStepWithHealing(params) {
         });
         if (backendErrorUrl !== null) {
             logger.error(`${formatStepPrefix(stepIndex, totalSteps)} backend error detected (submit endpoint returned 5xx: ${backendErrorUrl}); aborting cascade`);
-            throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactSecrets)(step).slice(0, 60)}) backend 5xx at ${backendErrorUrl} — unrecoverable`, "backend-error-unrecoverable");
+            throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactPii)(step).slice(0, 60)}) backend 5xx at ${backendErrorUrl} — unrecoverable`, "backend-error-unrecoverable");
         }
         // Bounded same-origin child-iframe fallback: the probe above only ever
         // looked at the resolved (declared-or-main) frame's own light+shadow DOM,
@@ -10384,7 +10795,7 @@ async function executeStepWithHealing(params) {
             targetResolutionDiagnostic,
             fieldValuesAtFailure,
         }) ?? null;
-        throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactSecrets)(step).slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
+        throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactPii)(step).slice(0, 60)}) probe found no candidates on page${dumpPath ? `; see ${dumpPath}` : ""}`, "probe-absent");
     }
     // Pre-submit form-validity probe. Fires on the canonical submit step
     // (either the final flow step OR a step explicitly flagged `submitStep:
@@ -10766,13 +11177,13 @@ async function executeStepWithHealing(params) {
         // control stays covered so the attempt fails instead of clicking an overlay.
         // Resolves true once the observe ran, so guardedAct skips its own pass.
         const preCentreNaturalLanguageClick = async (instruction) => {
-            if (!stagehand_guard_1.CLICK_INTENT_RE.test(instruction))
+            if (!(0, stagehand_guard_1.hasClickIntent)(instruction))
                 return false;
-            const observed = await (0, stagehand_guard_1.guardedObserve)(stagehand, instruction, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget).catch(() => []);
+            const observed = await (0, stagehand_guard_1.guardedObserve)(stagehand, instruction, { timeout: exports.STEP_WATCHDOG_MS }, captureFn, frameTarget);
             const first = observed[0];
-            if (first?.method !== "click" || !first.selector)
+            if (!(0, stagehand_guard_1.isTrustedClickMethod)(first?.method) || !first?.selector)
                 return true;
-            const failure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), first.selector, (msg) => logger.debug(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${msg}`), true);
+            const failure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), first.selector);
             if (failure)
                 throw new Error(failure);
             return true;
@@ -10951,11 +11362,15 @@ async function executeStepWithHealing(params) {
                         // burn the step budget probing all of them.
                         const runnerUp = ranked[1];
                         if (runnerUp) {
-                            await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, true, async () => {
-                                const snap = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter);
-                                return snap.visibleTextSignature;
-                            }, pre.visibleTextSignature);
-                            const midPost = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
+                            const midTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+                            const deepMidFlowSubmit = isMidFlowSubmitShapedStep({
+                                step,
+                                submitStep,
+                                isFinalStep,
+                                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                                elementSubmitShaped: !stepDeclaredNonSubmit,
+                            });
+                            const midPost = await settleAndSnapshotPostClick(midTarget, signalCounter, page, pre, deepMidFlowSubmit);
                             const topVerdict = (0, phantom_click_1.classifyPhantomClick)({
                                 actResultSuccess: true,
                                 pre,
@@ -10964,20 +11379,8 @@ async function executeStepWithHealing(params) {
                                 // stray selection flip must not mask a top-pick phantom and skip
                                 // the runner-up retry.
                                 isSubmitShapedStep: true,
-                                isMidFlowSubmitStep: isMidFlowSubmitShapedStep({
-                                    step,
-                                    submitStep,
-                                    isFinalStep,
-                                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                                }),
-                                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, midPost.url, isMidFlowSubmitShapedStep({
-                                    step,
-                                    submitStep,
-                                    isFinalStep,
-                                    flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-                                })
-                                    ? pre.url
-                                    : undefined),
+                                isMidFlowSubmitStep: deepMidFlowSubmit,
+                                destinationPlausible: (0, phantom_click_1.isPlausibleStepDestination)(step, midPost.url, deepMidFlowSubmit ? pre.url : undefined),
                             });
                             if (topVerdict === "phantom") {
                                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} deep-submit-locator top pick (${top.tag} "${top.accessibleName}") phantom-clicked; retrying runner-up ${runnerUp.tag} "${runnerUp.accessibleName}" (tier ${runnerUp.tier})`);
@@ -11370,8 +11773,8 @@ async function executeStepWithHealing(params) {
                     // bars, so centre + hit-test the observed control first; an
                     // unrecoverable occlusion fails the attempt instead of clicking an
                     // overlay.
-                    if (overriddenTarget.method === "click") {
-                        const centreFailure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), overriddenTarget.selector, (msg) => logger.debug(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt}: ${msg}`));
+                    if ((0, stagehand_guard_1.isTrustedClickMethod)(overriddenTarget.method)) {
+                        const centreFailure = await centreObservedClickTarget(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), overriddenTarget.selector);
                         if (centreFailure) {
                             record.errorMessage = centreFailure;
                             attempts.push(record);
@@ -11708,6 +12111,24 @@ async function executeStepWithHealing(params) {
         }
         // A fill/select/type action cannot open a tab, so skip the discovery wait for it.
         await adoptOpenedPage(resolvedAction && STATE_CLASS_METHODS.has(resolvedAction.method ?? "") ? 0 : undefined);
+        const isClick = resolvedAction !== null && resolvedAction.method === "click";
+        // Attribute-based submit-shape read of the resolved click target itself —
+        // independent of the flow-authored `submitStep` flag. Read before the
+        // settle: a view swap removes the clicked control, so a post-swap read
+        // would blind the mid-flow exemption on exactly the case it exists for.
+        // See resolvedClickTargetIsSubmitShaped's doc comment.
+        const resolvedElementIsSubmitShaped = isClick && !stepDeclaredNonSubmit && resolvedAction?.selector
+            ? await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector)
+            : false;
+        // Computed once: gates every credit signal that takes no post-click URL
+        // (network, DOM read-back) and classifyPhantomClick's destinationPlausible.
+        const stepIsMidFlowSubmit = isMidFlowSubmitShapedStep({
+            step,
+            submitStep,
+            isFinalStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+            elementSubmitShaped: resolvedElementIsSubmitShaped,
+        });
         await page.waitForTimeout(STEP_PAUSE_MS);
         // A successful act that reported no actions still ran a click-class action;
         // judging it before its round-trip lands would cascade onto the advanced page.
@@ -11716,10 +12137,7 @@ async function executeStepWithHealing(params) {
             : !STATE_CLASS_METHODS.has(resolvedAction.method ?? "");
         if (mayTriggerRoundTrip) {
             const settleTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
-            await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, isSettleWaitStep, async () => {
-                const snap = await snapshotPage(settleTarget, signalCounter);
-                return snap.visibleTextSignature;
-            }, pre.visibleTextSignature);
+            await settleWithPageQuiescence(page, settleTarget, signalCounter, pre.networkCount, isSettleWaitStep || resolvedElementIsSubmitShaped, pre.visibleTextSignature, pageAdvancedSince(pre.visibleTextSignature, stepIsMidFlowSubmit));
         }
         const post = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
         record.post = post;
@@ -11728,18 +12146,9 @@ async function executeStepWithHealing(params) {
             record.resolvedArguments = (resolvedAction.arguments ?? []).map(String);
         }
         const networkFired = post.networkCount > pre.networkCount;
-        // Computed once: gates every credit signal that takes no post-click URL
-        // (network, DOM read-back) and classifyPhantomClick's destinationPlausible.
-        const stepIsMidFlowSubmit = isMidFlowSubmitShapedStep({
-            step,
-            submitStep,
-            isFinalStep,
-            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
-        });
         const destinationPlausible = (0, phantom_click_1.isPlausibleStepDestination)(step, post.url, stepIsMidFlowSubmit ? pre.url : undefined);
         const urlChanged = (0, phantom_click_1.hasOriginOrPathChanged)(pre.url, post.url) && destinationPlausible;
         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,
         // so the legacy heuristic false-negatived every form fill. Re-read DOM state
         // for those; keep the navigation signal authoritative for clicks/links —
@@ -11836,12 +12245,6 @@ async function executeStepWithHealing(params) {
         const clickedElementStillPresent = isClick && resolvedAction?.selector
             ? await resolvedClickTargetStillPresent(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector)
             : true;
-        // Attribute-based submit-shape read of the resolved click target itself —
-        // independent of the flow-authored `submitStep` flag. See
-        // resolvedClickTargetIsSubmitShaped's doc comment.
-        const resolvedElementIsSubmitShaped = isClick && !stepDeclaredNonSubmit && resolvedAction?.selector
-            ? await resolvedClickTargetIsSubmitShaped(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), resolvedAction.selector)
-            : false;
         // Client-side view-swap gate: credit a click that produces substantial
         // DOM growth (≥5KB) with zero network when it's NOT a submit/final step
         // and NOT an advance-pattern step. Fixes the top-window site "Manual Application"
@@ -12142,6 +12545,9 @@ async function executeStepWithHealing(params) {
                 captureFn,
                 step,
                 isFinalStep,
+                submitStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                elementSubmitShaped: resolvedElementIsSubmitShaped,
                 page,
                 target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
                 signalCounter,
@@ -12383,10 +12789,13 @@ async function executeStepWithHealing(params) {
                         probeResult.checked === true &&
                         (probeResult.ariaManaged === true || !ancestorStillInvalid);
                     await page.waitForTimeout(STEP_PAUSE_MS);
-                    await (0, click_settle_1.settleAfterClick)(page, signalCounter, pre.networkCount, isSettleWaitStep, async () => {
-                        const snap = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter);
-                        return snap.visibleTextSignature;
-                    }, pre.visibleTextSignature);
+                    await settleWithPageQuiescence(page, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, pre.networkCount, isSettleWaitStep || retryResolvedElementIsSubmitShaped, pre.visibleTextSignature, pageAdvancedSince(pre.visibleTextSignature, isMidFlowSubmitShapedStep({
+                        step,
+                        submitStep,
+                        isFinalStep,
+                        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                        elementSubmitShaped: retryResolvedElementIsSubmitShaped,
+                    })));
                     const retryPost = await snapshotPage(frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), signalCounter, page);
                     const retryNetworkFired = retryPost.networkCount > pre.networkCount;
                     const retryMidFlowSubmit = isMidFlowSubmitShapedStep({
@@ -12738,6 +13147,9 @@ async function executeStepWithHealing(params) {
                             captureFn,
                             step,
                             isFinalStep,
+                            submitStep,
+                            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+                            elementSubmitShaped: resolvedElementIsSubmitShaped,
                             page,
                             target: frameTarget ?? (0, frame_target_1.mainFrameTarget)(page),
                             signalCounter,
@@ -13093,7 +13505,7 @@ async function executeStepWithHealing(params) {
     if (dumpPath !== null) {
         logger.error(`${formatStepPrefix(stepIndex, totalSteps)} failed after ${MAX_STEP_ATTEMPTS} attempts; diagnostic bundle: ${dumpPath}`);
     }
-    throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactSecrets)(step).slice(0, 60)}) failed verification after ${MAX_STEP_ATTEMPTS} attempts${dumpPath ? `; see ${dumpPath}` : ""}`, phantomClickAfterAttempt1 ? "phantom-click-exhausted" : "cascade-exhausted");
+    throw new errors_2.StepVerificationError(`${formatStepPrefix(stepIndex, totalSteps)} (${(0, pii_redaction_1.redactPii)(step).slice(0, 60)}) failed verification after ${MAX_STEP_ATTEMPTS} attempts${dumpPath ? `; see ${dumpPath}` : ""}`, phantomClickAfterAttempt1 ? "phantom-click-exhausted" : "cascade-exhausted");
 }
 /**
  * Navigates `page` directly to `url` and waits for the SPA to hydrate,