@enricai/barnacle 1.12.2 → 1.12.4

package/dist/scraper/flow-runner.js

@@ -24,6 +24,7 @@ exports.findRecentPageTransition = findRecentPageTransition;
 exports.isWizardExitAction = isWizardExitAction;
 exports.isAdvanceStep = isAdvanceStep;
 exports.shouldCaptureSelectionState = shouldCaptureSelectionState;
+exports.flowHasSubmitSemantics = flowHasSubmitSemantics;
 exports.shouldWarnMissingAdvancePattern = shouldWarnMissingAdvancePattern;
 exports.parseCaptureIndex = parseCaptureIndex;
 exports.latestCaptureIndex = latestCaptureIndex;
@@ -58,6 +59,7 @@ exports.normalizeDateValue = normalizeDateValue;
 exports.fillHtml5DateTimeInput = fillHtml5DateTimeInput;
 exports.fillTextDatepickerInput = fillTextDatepickerInput;
 exports.verifyFillReadback = verifyFillReadback;
+exports.verifyPromptSelectorCommitted = verifyPromptSelectorCommitted;
 exports.isUploadAffordanceLabel = isUploadAffordanceLabel;
 exports.writeFixtureToTempFile = writeFixtureToTempFile;
 exports.attachToSurfacedInput = attachToSurfacedInput;
@@ -386,6 +388,13 @@ const SELECT_SETTLE_MS = 400;
  * triggered it.
  */
 const PROMPT_SELECTOR_SETTLE_MS = 400;
+/**
+ * Cap on the category->leaf drill loop in {@link commitPromptOption}: a
+ * two-level cascading multiselect (category click re-renders the popup to
+ * leaves) only ever drills one level deep in the wild, so 3 gives headroom
+ * for a rarer 2-level cascade without letting a genuinely broken widget spin.
+ */
+const PROMPT_SELECTOR_MAX_DRILL_DEPTH = 3;
 /**
  * Temporary attribute {@link tryPromptSelectorPrimitive} stamps onto each
  * candidate widget during its read-only enumerate pass, so the Node-side click
@@ -396,6 +405,18 @@ const PROMPT_SELECTOR_SETTLE_MS = 400;
 const PROMPT_WIDGET_MARK_ATTR = "data-bcl-prompt-idx";
 /** Same role as {@link PROMPT_WIDGET_MARK_ATTR}, but for the popup's rendered option entries. */
 const PROMPT_OPTION_MARK_ATTR = "data-bcl-prompt-opt-idx";
+/**
+ * Cross-vendor selector for a genuine focusable form control — the only kind
+ * of element a native click event reliably opens. Phase 1's container walk
+ * marks the OUTERMOST widget-kit container so one widget resolves to one
+ * candidate, but that container is often a layout wrapper with no click
+ * handler of its own (e.g. a typeahead/chip widget's real open+filter control
+ * is an `<input>` nested a level deeper, inside its own `*InputContainer`
+ * wrapper). Phase 2 prefers clicking this interactive descendant over the
+ * marked container itself, falling back to the container only when it has
+ * none — no vendor branch, just "click the real control if one exists".
+ */
+const PROMPT_INTERACTIVE_CONTROL_SELECTORS = "button,[role='combobox'],[role='button'],input";
 /**
  * Cross-vendor selector union that identifies the TRIGGER of a native-control-less
  * popup-dropdown widget (a combobox that opens a listbox popup and renders no
@@ -486,6 +507,30 @@ const PROMPT_EMPTY_VALUE_RX_FLAGS = PROMPT_EMPTY_VALUE_RX.flags;
  * the remaining `textContent`.
  */
 const BUTTON_VALUE_EXPR = "((el) => { const c = el.cloneNode(true); for (const n of c.querySelectorAll(\"[role='option'],[role='listbox'],[aria-hidden='true'],abbr,svg\")) n.remove(); return c.textContent || \"\"; })";
+/**
+ * Browser-side expression reading a prompt-selector widget's OWN committed-value
+ * text — the single source of truth for "is this widget filled?", shared by the
+ * widget-enumeration phase ({@link tryPromptSelectorPrimitive}'s
+ * `enumerateWidgetsExpr`) and the act-success committed-value gate
+ * ({@link verifyPromptSelectorCommitted}) so the two never drift into separate
+ * ideas of "committed". Value via the union: `aria-activedescendant` → the
+ * referenced option's text, else the widget's own value (an `<input>`'s
+ * `value`, or a `<button>`-trigger's own label text via {@link BUTTON_VALUE_EXPR}),
+ * else a selection-label node ({@link PROMPT_VALUE_SELECTORS}) — treating the
+ * widget-kit empty-state phrase ({@link PROMPT_EMPTY_VALUE_RX}) as no value.
+ */
+const PROMPT_CURRENT_TEXT_EXPR = `((w, valueSel, emptyRx) => {
+  const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
+  const buttonValue = ${BUTTON_VALUE_EXPR};
+  const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
+  if (adid) { const opt = document.getElementById(adid); if (opt && opt.textContent.trim()) return norm(opt.textContent); }
+  if (w.tagName === "INPUT" && (w.value || "").trim()) return norm(w.value);
+  if (w.tagName === "BUTTON" && buttonValue(w).trim()) return norm(buttonValue(w));
+  const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
+  const raw = lbl ? (lbl.textContent || "") : "";
+  if (raw.trim() && !emptyRx.test(raw.trim())) return norm(raw);
+  return "";
+})`;
 /**
  * Browser-side expression resolving the DOM root within which a chosen widget's
  * popup options / filter input live. Popup placement is vendor-split: the ARIA
@@ -923,8 +968,20 @@ function isAdvanceStep(instruction) {
  * cascade depends on is unit-testable, not buried in `executeStepWithHealing`.
  */
 function shouldCaptureSelectionState(params) {
-    const { step, isFinalStep, submitStep } = params;
-    return !(isFinalStep || submitStep || isAdvanceStep(step));
+    const { step, isFinalStep, submitStep, flowHasSubmitSemantics } = params;
+    return !(submitStep || (isFinalStep && flowHasSubmitSemantics) || isAdvanceStep(step));
+}
+/**
+ * Whether a flow has ANY submit semantics at all — a step flagged
+ * `submitStep: true`, a `submitEndpointPattern`, or `requireSubmitEndpointMatch`.
+ * A read-only flow (none of the three) has no submit shape anywhere, so its
+ * final step is an ordinary read/click, not a submit. Pure + exported so
+ * callers can stop inferring submit-shape from `isFinalStep` alone on flows
+ * that never declared a submit.
+ */
+function flowHasSubmitSemantics(params) {
+    const { steps, submitEndpointPattern, requireSubmitEndpointMatch } = params;
+    return (steps.some((s) => s.submitStep) || submitEndpointPattern !== null || requireSubmitEndpointMatch);
 }
 /**
  * Whether a flow should be WARNed that its DOM-only advance guard is disarmed.
@@ -1200,10 +1257,10 @@ function isDomOnlyAdvanceVerified(params) {
 function isClickViewSwapVerified(params) {
     const VIEW_SWAP_MIN_BYTES = config_1.config.scraper.viewSwapMinBytesThreshold;
     const VIEW_SWAP_REVEAL_MIN_BYTES = config_1.config.scraper.viewSwapRevealMinBytesThreshold;
-    const { resolvedAction, isFinalStep, submitStep, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, } = params;
+    const { resolvedAction, isFinalStep, submitStep, flowHasSubmitSemantics, isAdvanceWithPattern, networkDelta, bytesDelta, textChanged, invalidMarkerDelta = 0, } = params;
     if (resolvedAction?.method !== "click")
         return false;
-    if (isFinalStep || submitStep)
+    if (submitStep || (isFinalStep && flowHasSubmitSemantics))
         return false;
     if (isAdvanceWithPattern)
         return false;
@@ -2715,6 +2772,50 @@ async function verifyFillReadback(target, selector, expectedValue) {
         return null;
     }
 }
+/**
+ * Committed-value guard for the prompt-selector widget family
+ * (`data-uxi-widget-type='multiselect'`/`selectinput`, `role=combobox`, …),
+ * mirroring {@link verifyFillReadback}'s role for plain inputs but reading the
+ * widget's OWN committed-value node ({@link PROMPT_CURRENT_TEXT_EXPR}) instead
+ * of a bare `<input>.value` — a chip multiselect's committed state lives on
+ * `aria-activedescendant`/a selection-label node, not the trigger's own value.
+ * Walks UP from the resolved element to the nearest {@link PROMPT_TRIGGER_SELECTORS}
+ * ancestor (the resolved element is often the inner filter input or icon, not
+ * the widget container itself — same resolution discipline as
+ * `tryPromptSelectorPrimitive`'s widget-container walk). Returns
+ * `isPromptWidget: false` for a resolved element that isn't part of this
+ * widget family at all, so a non-prompt click/fill is untouched.
+ */
+async function verifyPromptSelectorCommitted(target, selector) {
+    const xpath = xpathBodyForEvaluate(selector);
+    if (xpath === null)
+        return null;
+    const expr = `(() => {
+    const triggerSel = ${JSON.stringify(PROMPT_TRIGGER_SELECTORS)};
+    const valueSel = ${JSON.stringify(PROMPT_VALUE_SELECTORS)};
+    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 xpath = ${JSON.stringify(xpath)};
+    const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+    const el = result.singleNodeValue;
+    if (!el) return { isPromptWidget: false, committed: false };
+    const widget = el.matches && el.matches(triggerSel) ? el : el.closest(triggerSel);
+    if (!widget) return { isPromptWidget: false, committed: false };
+    return { isPromptWidget: true, committed: currentText(widget, valueSel, emptyRx) !== "" };
+  })()`;
+    try {
+        const raw = await target.evaluate(expr);
+        if (raw === null || typeof raw !== "object")
+            return null;
+        const r = raw;
+        if (typeof r.isPromptWidget !== "boolean" || typeof r.committed !== "boolean")
+            return null;
+        return { isPromptWidget: r.isPromptWidget, committed: r.committed };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Pull field-level errors out of an arbitrary JSON response body. Walks a
  * few of the conventional ATS shapes; falls through to `[]` so the caller
@@ -3521,11 +3622,54 @@ async function setFilesViaCdp(params) {
  * Recognizes the flow's conventional phrasings, all quoted:
  *   "select 'Yes'", "select or check 'BLS'",
  *   "for 'What is your highest level…?' select 'BSN completed'",
- *   "select 'Texas' in the State/Region dropdown".
+ *   "select 'Texas' in the State/Region dropdown",
+ *   "…then select the option 'Job Boards' from the popup list" (a compound
+ *   step that opens the widget in one clause and selects in another —
+ *   "select" is followed by a noun phrase like "the option"/"the value"
+ *   before the quoted option itself, rather than the quote directly).
  * Returns null when the step is not a single-dropdown select (e.g. generic
  * "for any remaining question…" catch-alls, or radio/checkbox-only steps) so
  * the caller falls through to the normal cascade.
  */
+// Nouns that name a form widget/question, used by `pickQuestionLabel` to tell
+// a genuine field label ("'How Did You Hear About Us?' prompt selector")
+// apart from an unrelated leading quoted phrase that just happens to precede
+// it in the instruction (e.g. a page/step-context quote like "'My
+// Information' step").
+const WIDGET_NOUN_RE = /\b(prompt\s+selector|multiselect|typeahead|dropdown|field|question|checkbox|radio\s+button|radio)\b/i;
+/**
+ * Pick the QUESTION LABEL out of an instruction's quoted phrases, given the
+ * already-extracted OPTION.
+ *
+ * Why this exists: an instruction can carry more than one quoted phrase that
+ * is not the option — e.g. a page/step-context phrase ("On the authenticated
+ * 'My Information' step, open the 'How Did You Hear About Us?' prompt
+ * selector…") — so naively taking the first non-option quote picks the
+ * context phrase instead of the actual widget label. This prefers a quote
+ * that sits immediately next to a widget noun (`multiselect`/`typeahead`/
+ * `dropdown`/`field`/`question`/`checkbox`/`radio button`/`prompt selector`)
+ * or is introduced
+ * by "for"/"for the"/"for the question"/"for the answer" (e.g. "click the
+ * 'Yes' answer for the question '…'"), before falling back to the first
+ * non-option quote so existing un-adorned phrasings keep working.
+ */
+function pickQuestionLabel(instruction, option) {
+    // biome-ignore lint/style/noNonNullAssertion: capture group 1 is required by the pattern, so it is present on every match
+    const candidates = [...instruction.matchAll(/'([^']+)'/g)].filter((m) => m[1].trim() !== option);
+    if (candidates.length === 0)
+        return null;
+    const adjacentToWidgetNoun = candidates.find((m) => {
+        const start = m.index ?? 0;
+        const end = start + m[0].length;
+        const before = instruction.slice(Math.max(0, start - 25), start);
+        const after = instruction.slice(end, end + 40);
+        return (/\bfor(?:\s+the)?(?:\s+(?:question|answer))?\s*$/i.test(before) || WIDGET_NOUN_RE.test(after));
+    });
+    // biome-ignore lint/style/noNonNullAssertion: candidates is guarded non-empty above, so the fallback element is always present
+    const picked = (adjacentToWidgetNoun ?? candidates[0]);
+    // biome-ignore lint/style/noNonNullAssertion: capture group 1 is required by the pattern, so it is present on every match
+    return picked[1].trim();
+}
 function parseSelectStep(instruction) {
     const lower = instruction.toLowerCase();
     // Must look like a dropdown selection, not a radio/checkbox click. "select
@@ -3541,16 +3685,20 @@ function parseSelectStep(instruction) {
     const quoted = [...instruction.matchAll(/'([^']+)'/g)].map((m) => m[1]);
     if (quoted.length === 0)
         return null;
-    // The OPTION is the quoted string immediately following the word "select".
-    const selMatch = instruction.match(/\bselect(?:\s+or\s+check)?\s+'([^']+)'/i);
+    // The OPTION is the quoted string following the word "select", allowing a
+    // short filler ("the option", "the answer") between the verb and the
+    // quote — real flow phrasing like "select the option 'Job Boards'" or
+    // "select the answer 'X'" otherwise fails to parse and the caller
+    // silently no-ops before touching the DOM.
+    const selMatch = instruction.match(/\bselect(?:\s+or\s+check)?\s+(?:the\s+\S+\s+)?'([^']+)'/i);
     if (!selMatch)
         return null;
     // biome-ignore lint/style/noNonNullAssertion: guarded by the !selMatch early-return; group 1 is required by the pattern
     const option = selMatch[1].trim();
     // The QUESTION LABEL, when present, is a DIFFERENT quoted string — the one
-    // introduced by "for '…'" or "in the '…' dropdown". Pick the first quoted
-    // string that is not the option.
-    const questionLabel = quoted.find((q) => q.trim() !== option)?.trim() ?? null;
+    // introduced by "for '…'" or adjacent to a widget noun like "'…' dropdown"
+    // or "'…' prompt selector". See `pickQuestionLabel`.
+    const questionLabel = pickQuestionLabel(instruction, option);
     return { option, questionLabel };
 }
 /**
@@ -3668,8 +3816,9 @@ function parseRadioStep(instruction) {
     // introduced by "for the question '…'" / "for the '…' question". Some steps
     // phrase the question un-quoted ("…about requiring visa sponsorship"); in
     // that case there is no second quoted string and questionLabel stays null,
-    // which the primitive handles via LLM group-matching.
-    const questionLabel = quoted.find((q) => q.trim() !== option)?.trim() ?? null;
+    // which the primitive handles via LLM group-matching. See
+    // `pickQuestionLabel`.
+    const questionLabel = pickQuestionLabel(instruction, option);
     return { option, questionLabel };
 }
 /**
@@ -4969,28 +5118,15 @@ async function tryPromptSelectorPrimitive(params) {
       }
       return "";
     };
-    const currentText = (w) => {
-      // Value via the union: aria-activedescendant → option text, the widget's
-      // own value (an <input>'s value, or a <button>-trigger's own label text —
-      // a button that IS the trigger carries the committed choice as its own
-      // text), else a selection-label node — treating the widget-kit empty-state
-      // phrase as no value.
-      const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
-      if (adid) { const opt = document.getElementById(adid); if (opt && opt.textContent.trim()) return norm(opt.textContent); }
-      if (w.tagName === "INPUT" && (w.value || "").trim()) return norm(w.value);
-      if (w.tagName === "BUTTON" && buttonValue(w).trim()) return norm(buttonValue(w));
-      const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
-      const raw = lbl ? (lbl.textContent || "") : "";
-      if (raw.trim() && !emptyRx.test(raw.trim())) return norm(raw);
-      return "";
-    };
+    const currentText = ${PROMPT_CURRENT_TEXT_EXPR};
+    const currentTextOf = (w) => currentText(w, valueSel, emptyRx);
     const isUnfilled = (w) => {
       let node = w;
       for (let d = 0; d < 6 && node; d++) {
         if (node.getAttribute && isInvalid(node)) return true;
         node = node.parentElement;
       }
-      return currentText(w) === "";
+      return currentTextOf(w) === "";
     };
     // Clear stale marks from a prior call on this same page (this primitive
     // runs once per "select 'X'" step, and an application wizard answers several
@@ -5038,17 +5174,6 @@ async function tryPromptSelectorPrimitive(params) {
             logger.info(`prompt-selector primitive: no unambiguous widget match for ${optLabel}; falling through to cascade`);
             return null;
         }
-        // Phase 2 (real gesture): open the popup. These widgets' trigger requires a
-        // genuine click — a synthetic dispatchEvent does not fire its handler.
-        const triggerSel = `[${PROMPT_WIDGET_MARK_ATTR}="${chosen.wIdx}"]`;
-        try {
-            await target.locator(triggerSel).first().click();
-        }
-        catch (err) {
-            logger.info(`prompt-selector primitive: trigger click failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
-            return null;
-        }
-        await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
         const enumerateOptionsExpr = `((widgetMarkAttr, wIdx, markAttr, optionSel, searchSel) => {
       const w = document.querySelector("[" + widgetMarkAttr + '="' + wIdx + '"]');
       if (!w) return { optionsPresent: false };
@@ -5087,9 +5212,65 @@ async function tryPromptSelectorPrimitive(params) {
         const label = opts[i].getAttribute("data-automation-label") || opts[i].getAttribute("aria-label") || opts[i].textContent || "";
         options.push({ oIdx: i, text: label.replace(/\\s+/g, " ").trim() });
       }
-      return { optionsPresent: true, searchable: !!searchInput, options };
+      // scopeIsDocument distinguishes a genuinely resolved (portal or inline)
+      // popup from the document-wide last-resort fallback in
+      // PROMPT_SCOPE_ROOT_EXPR — the pre-open pre-check below must NOT treat a
+      // still-unopened widget as "already open" on the strength of some OTHER
+      // widget's stale/leftover popup elsewhere in the document; only a scope
+      // that resolved to THIS widget's own inline subtree or its own
+      // aria-controls/aria-owns target counts.
+      return { optionsPresent: true, searchable: !!searchInput, options, scopeIsDocument: scope === document };
     })(${JSON.stringify(PROMPT_WIDGET_MARK_ATTR)}, ${JSON.stringify(chosen.wIdx)}, ${JSON.stringify(PROMPT_OPTION_MARK_ATTR)}, ${JSON.stringify(PROMPT_OPTION_SELECTORS)}, ${JSON.stringify(PROMPT_SEARCH_SELECTORS)})`;
-        const optionsInitial = await pollEnumerate(page, target, enumerateOptionsExpr, (r) => r?.optionsPresent === true);
+        // Pre-check (single evaluate, no polling): a PRIOR primitive call on this
+        // same unreloaded page may have already opened/drilled this exact widget's
+        // popup (a two-level cascading multiselect authored as two flow steps —
+        // category, then leaf — re-enters here for the leaf with the popup already
+        // open). Re-clicking the trigger in that case perturbs/closes the
+        // already-rendered popup instead of reading it. Skip the open-click
+        // entirely when options are already present AND resolved to THIS widget's
+        // OWN scope (not the document-wide fallback, which could otherwise credit
+        // an unrelated widget's stale/leftover popup elsewhere on the page as
+        // "already open"); a genuinely closed popup falls through to the normal
+        // open-click + poll path below unchanged.
+        const precheck = (await target.evaluate(enumerateOptionsExpr));
+        const alreadyOpen = precheck?.optionsPresent === true &&
+            (precheck.options?.length ?? 0) > 0 &&
+            precheck.scopeIsDocument !== true;
+        if (!alreadyOpen) {
+            // Phase 2 (real gesture): open the popup. These widgets' trigger requires a
+            // genuine click — a synthetic dispatchEvent does not fire its handler.
+            // Prefer the marked widget's own interactive descendant (a real form
+            // control) over the marked container itself, since the container is
+            // frequently a non-interactive layout wrapper for widget shapes whose
+            // actual trigger sits a level deeper (see PROMPT_INTERACTIVE_CONTROL_SELECTORS).
+            const containerTriggerSel = `[${PROMPT_WIDGET_MARK_ATTR}="${chosen.wIdx}"]`;
+            const innerTriggerSel = PROMPT_INTERACTIVE_CONTROL_SELECTORS.split(",")
+                .map((s) => `${containerTriggerSel} ${s}`)
+                .join(",");
+            let triggerSel = containerTriggerSel;
+            try {
+                const innerCount = await target.locator(innerTriggerSel).count();
+                if (innerCount > 0)
+                    triggerSel = innerTriggerSel;
+            }
+            catch {
+                // Fall back to the container selector.
+            }
+            try {
+                await target.locator(triggerSel).first().click();
+            }
+            catch (err) {
+                logger.info(`prompt-selector primitive: trigger click failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
+                return null;
+            }
+            await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
+        }
+        else {
+            logger.info(`prompt-selector primitive: popup for ${optLabel} already open with rendered options; skipping trigger click`);
+        }
+        const optionsInitial = alreadyOpen
+            ? precheck
+            : await pollEnumerate(page, target, enumerateOptionsExpr, (r) => r?.optionsPresent === true);
         if (!optionsInitial?.optionsPresent) {
             logger.info(`prompt-selector primitive: popup for ${optLabel} did not render options; falling through`);
             return null;
@@ -5112,6 +5293,7 @@ async function tryPromptSelectorPrimitive(params) {
                 questionLabel,
                 chosen,
                 optionsResult,
+                enumerateOptionsExpr,
             });
         }
         try {
@@ -5145,6 +5327,7 @@ async function tryPromptSelectorPrimitive(params) {
             questionLabel,
             chosen,
             optionsResult: optionsFiltered,
+            enumerateOptionsExpr,
         });
     }
     catch (err) {
@@ -5161,82 +5344,115 @@ async function tryPromptSelectorPrimitive(params) {
  * by the value union, or its invalid marker cleared). Split out from the main
  * function because both the static and searchable-then-filtered branches need
  * the identical match/click/verify sequence.
+ *
+ * Bounded (see {@link PROMPT_SELECTOR_MAX_DRILL_DEPTH}) category->leaf drill:
+ * when a click's readback fails, that is ambiguous between a genuine
+ * non-commit and a category click that swapped the popup to a deeper level
+ * (a two-level cascading multiselect authored as a SINGLE step naming only
+ * the leaf). Re-enumerating after a failed readback and comparing the
+ * option set disambiguates the two: an unchanged set is a real failure and
+ * must still fall through to the cascade; a changed set means the drill
+ * fired, so re-match/re-click continues at the new level instead of
+ * abandoning the primitive.
  */
 async function commitPromptOption(params) {
-    const { page, target, logger, anthropic, captureFn, optLabel, option, questionLabel, chosen, optionsResult, } = params;
+    const { page, target, logger, anthropic, captureFn, optLabel, option, questionLabel, chosen, enumerateOptionsExpr, } = params;
     const norm = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
     const wantOpt = norm(option);
-    const options = optionsResult.options ?? [];
-    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`);
-        return null;
-    }
-    const verdict = detMatch === null
-        ? await (0, select_option_1.judgeSelectOptionWithLLM)({
-            client: anthropic,
-            input: {
-                questionLabel,
-                desiredHint: option,
-                candidates: [{ label: chosen.label || null, options: options.map((o) => o.text) }],
-            },
-            captureFn,
-        })
-        : null;
-    if (detMatch === null &&
-        (!verdict || verdict.selectIndex === null || verdict.optionIndex === null)) {
-        logger.info(`prompt-selector primitive: LLM found no matching option for ${optLabel}${verdict ? ` (${verdict.reason})` : ""}; falling through to cascade`);
-        return null;
-    }
-    const chosenOption = detMatch ??
-        (verdict && verdict.optionIndex !== null ? (options[verdict.optionIndex] ?? null) : null);
-    if (!chosenOption) {
-        logger.info(`prompt-selector primitive: option match out of range for ${optLabel}; falling through`);
-        return null;
-    }
-    const matchReason = detMatch ? "deterministic" : `LLM: ${(verdict?.reason ?? "").slice(0, 60)}`;
-    const optionSel = `[${PROMPT_OPTION_MARK_ATTR}="${chosenOption.oIdx}"]`;
-    try {
-        await target.locator(optionSel).first().click();
-    }
-    catch (err) {
-        logger.info(`prompt-selector primitive: option click failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
-        return null;
-    }
-    await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
-    const readbackExpr = `((wIdx, markAttr, valueSel, emptyRxSrc, emptyRxFlags, wantText) => {
-    const isInvalid = ${INVALID_MARKER_EL_EXPR};
-    const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
-    const buttonValue = ${BUTTON_VALUE_EXPR};
-    const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
-    const w = document.querySelector("[" + markAttr + '="' + wIdx + '"]');
-    if (!w) return { ok: false, id: "" };
-    // Value via the union: aria-activedescendant, own input value, a <button>'s
-    // own value text (popup-pollution-safe, see BUTTON_VALUE_EXPR), or a
-    // selection-label node (empty-state phrase treated as no value).
-    const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
-    const adText = adid && document.getElementById(adid) ? norm(document.getElementById(adid).textContent) : "";
-    const own = w.tagName === "INPUT" ? norm(w.value || "") : w.tagName === "BUTTON" ? norm(buttonValue(w)) : "";
-    const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
-    const lblRaw = lbl ? (lbl.textContent || "") : "";
-    const lblText = lblRaw.trim() && !emptyRx.test(lblRaw.trim()) ? norm(lblRaw) : "";
-    const text = adText || own || lblText;
-    const textMatches = wantText ? text.includes(wantText) : text !== "";
-    let node = w;
-    let stillInvalid = false;
-    for (let d = 0; d < 6 && node; d++) {
-      if (node.getAttribute && isInvalid(node)) { stillInvalid = true; break; }
-      node = node.parentElement;
-    }
-    return { ok: textMatches || !stillInvalid, 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))})`;
-    const readback = (await target.evaluate(readbackExpr).catch(() => ({ ok: false, id: "" })));
-    if (!readback?.ok) {
-        logger.info(`prompt-selector primitive: selection for ${optLabel} did not commit; falling through to cascade`);
-        return null;
+    const optionSetKey = (opts) => opts
+        .map((o) => norm(o.text))
+        .sort()
+        .join("
");
+    let optionsResult = params.optionsResult;
+    for (let depth = 0; depth <= PROMPT_SELECTOR_MAX_DRILL_DEPTH; depth++) {
+        const options = optionsResult.options ?? [];
+        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`);
+            return null;
+        }
+        const verdict = detMatch === null
+            ? await (0, select_option_1.judgeSelectOptionWithLLM)({
+                client: anthropic,
+                input: {
+                    questionLabel,
+                    desiredHint: option,
+                    candidates: [{ label: chosen.label || null, options: options.map((o) => o.text) }],
+                },
+                captureFn,
+            })
+            : null;
+        if (detMatch === null &&
+            (!verdict || verdict.selectIndex === null || verdict.optionIndex === null)) {
+            logger.info(`prompt-selector primitive: LLM found no matching option for ${optLabel}${verdict ? ` (${verdict.reason})` : ""}; falling through to cascade`);
+            return null;
+        }
+        const chosenOption = detMatch ??
+            (verdict && verdict.optionIndex !== null ? (options[verdict.optionIndex] ?? null) : null);
+        if (!chosenOption) {
+            logger.info(`prompt-selector primitive: option match out of range for ${optLabel}; falling through`);
+            return null;
+        }
+        const matchReason = detMatch ? "deterministic" : `LLM: ${(verdict?.reason ?? "").slice(0, 60)}`;
+        const optionSel = `[${PROMPT_OPTION_MARK_ATTR}="${chosenOption.oIdx}"]`;
+        try {
+            await target.locator(optionSel).first().click();
+        }
+        catch (err) {
+            logger.info(`prompt-selector primitive: option click failed for ${optLabel}: ${(0, errors_1.toErrorMessage)(err)}; falling through`);
+            return null;
+        }
+        await page.waitForTimeout(PROMPT_SELECTOR_SETTLE_MS);
+        const readbackExpr = `((wIdx, markAttr, valueSel, emptyRxSrc, emptyRxFlags, wantText) => {
+      const isInvalid = ${INVALID_MARKER_EL_EXPR};
+      const norm = (s) => (s || "").replace(/\\s+/g, " ").trim().toLowerCase();
+      const buttonValue = ${BUTTON_VALUE_EXPR};
+      const emptyRx = new RegExp(emptyRxSrc, emptyRxFlags);
+      const w = document.querySelector("[" + markAttr + '="' + wIdx + '"]');
+      if (!w) return { ok: false, id: "" };
+      // Value via the union: aria-activedescendant, own input value, a <button>'s
+      // own value text (popup-pollution-safe, see BUTTON_VALUE_EXPR), or a
+      // selection-label node (empty-state phrase treated as no value).
+      const adid = w.getAttribute && w.getAttribute("aria-activedescendant");
+      const adText = adid && document.getElementById(adid) ? norm(document.getElementById(adid).textContent) : "";
+      const own = w.tagName === "INPUT" ? norm(w.value || "") : w.tagName === "BUTTON" ? norm(buttonValue(w)) : "";
+      const lbl = w.matches(valueSel) ? w : w.querySelector(valueSel);
+      const lblRaw = lbl ? (lbl.textContent || "") : "";
+      const lblText = lblRaw.trim() && !emptyRx.test(lblRaw.trim()) ? norm(lblRaw) : "";
+      const text = adText || own || lblText;
+      const textMatches = wantText ? text.includes(wantText) : text !== "";
+      let node = w;
+      let stillInvalid = false;
+      for (let d = 0; d < 6 && node; d++) {
+        if (node.getAttribute && isInvalid(node)) { stillInvalid = true; break; }
+        node = node.parentElement;
+      }
+      return { ok: textMatches || !stillInvalid, 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))})`;
+        const readback = (await target.evaluate(readbackExpr).catch(() => ({ ok: false, id: "" })));
+        if (readback?.ok) {
+            logger.info(`prompt-selector primitive: selected "${chosenOption.text.slice(0, 40)}" for ${optLabel} (${matchReason})`);
+            return readback.id;
+        }
+        if (depth === PROMPT_SELECTOR_MAX_DRILL_DEPTH) {
+            logger.info(`prompt-selector primitive: selection for ${optLabel} did not commit; falling through to cascade`);
+            return null;
+        }
+        // Readback failed — disambiguate a genuine non-commit from a
+        // category->leaf drill by re-enumerating and comparing the option set.
+        const reEnumerated = (await target
+            .evaluate(enumerateOptionsExpr)
+            .catch(() => ({ optionsPresent: false })));
+        const newOptions = reEnumerated?.optionsPresent ? (reEnumerated.options ?? []) : [];
+        const drilled = newOptions.length > 0 && optionSetKey(newOptions) !== optionSetKey(options);
+        if (!drilled) {
+            logger.info(`prompt-selector primitive: selection for ${optLabel} did not commit; falling through to cascade`);
+            return null;
+        }
+        logger.info(`prompt-selector primitive: click for ${optLabel} drilled the popup to a new option set; re-matching at the new level`);
+        optionsResult = { options: newOptions };
     }
-    logger.info(`prompt-selector primitive: selected "${chosenOption.text.slice(0, 40)}" for ${optLabel} (${matchReason})`);
-    return readback.id;
+    return null;
 }
 /**
  * Guard for the optional-step fast-skip: is there a REQUIRED, still-empty (or
@@ -6146,7 +6362,7 @@ async function probeStepBeforeAttempts(params) {
     }
 }
 async function executeStepWithHealing(params) {
-    const { stagehand, page, step, optional, upload, submitStep, stepIndex, totalSteps, phase, signalCounter, recentCaptures, recentCaptureMeta, anthropic, rephraseModel, logger, captureFn, uploadFixture, isFinalStep, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, getSuppressedAisdkElementIdErrorCount, trajectory, onStepFailure, } = params;
+    const { stagehand, page, step, optional, upload, submitStep, flowHasSubmitSemantics: flowHasSubmitSemanticsFlag, stepIndex, totalSteps, phase, signalCounter, recentCaptures, recentCaptureMeta, anthropic, rephraseModel, logger, captureFn, uploadFixture, isFinalStep, submitEndpointPattern, submittedStateSelectors, requireSubmitEndpointMatch, advanceTransitionBodyPattern, successUrlFragments, successPageTitleHints, ownBackendHostnames, knownErrorClassPrefixes, wizardExitButtonLabels, getSuppressedAisdkElementIdErrorCount, trajectory, onStepFailure, } = params;
     // Mutable (not the destructured const above) so a lost frame-attach race
     // can be upgraded in place once the OOPIF attaches later in the cascade —
     // see reresolveFrameTargetIfLost below. Every existing reference in this
@@ -6214,7 +6430,12 @@ async function executeStepWithHealing(params) {
     // false-credit the step, and whose advance/submit verdicts require a real
     // network/URL transition. Also keeps the extra full-DOM evaluate off the
     // submit/advance path. Step-level intent (available before the attempt loop).
-    const captureSelectionState = shouldCaptureSelectionState({ step, isFinalStep, submitStep });
+    const captureSelectionState = shouldCaptureSelectionState({
+        step,
+        isFinalStep,
+        submitStep,
+        flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
+    });
     const attempts = [];
     const triedSelectors = [];
     const failureReasons = [];
@@ -6648,7 +6869,7 @@ async function executeStepWithHealing(params) {
         // techniques faster.
         if (attempt > 1) {
             const wouldBeTechnique = attempt === 2
-                ? phantomClickAfterAttempt1 && (isFinalStep || submitStep)
+                ? phantomClickAfterAttempt1 && (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))
                     ? "deep-submit-locator"
                     : phantomClickAfterAttempt1
                         ? "trusted-click-retry"
@@ -6667,7 +6888,7 @@ async function executeStepWithHealing(params) {
                 })),
                 advanceUnmovedAfterAttempt1,
                 phantomClickAfterAttempt1,
-                submitShapedStep: isFinalStep || submitStep,
+                submitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
             });
             if (decision.skip) {
                 logger.info(`${formatStepPrefix(stepIndex, totalSteps)} attempt ${attempt} (${wouldBeTechnique}) skipped: ${decision.reason}`);
@@ -6795,7 +7016,9 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
-            else if (attempt === 2 && phantomClickAfterAttempt1 && (isFinalStep || submitStep)) {
+            else if (attempt === 2 &&
+                phantomClickAfterAttempt1 &&
+                (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))) {
                 // Deep submit-control locator: attempt 1 phantom-clicked (Stagehand
                 // reported success but pre/post showed zero effect), so the target is
                 // almost certainly unreachable via document.querySelectorAll — most
@@ -6917,7 +7140,9 @@ async function executeStepWithHealing(params) {
                     }
                 }
             }
-            else if (attempt === 2 && phantomClickAfterAttempt1 && !(isFinalStep || submitStep)) {
+            else if (attempt === 2 &&
+                phantomClickAfterAttempt1 &&
+                !(submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))) {
                 // Trusted-click retry: attempt 1 phantom-clicked a NON-submit control —
                 // Stagehand reported success but pre/post showed zero effect. On a
                 // design-system widget (React synthetic-event delegation, custom
@@ -7595,7 +7820,7 @@ async function executeStepWithHealing(params) {
         // `advanceTransitionBodyPattern` are unaffected.
         const domVerifiedForStep = isDomOnlyAdvanceVerified({
             hasPattern: advanceTransitionBodyPattern !== null,
-            isFinalOrSubmit: isFinalStep || submitStep,
+            isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
             isAdvance: isAdvanceStep(step),
             domVerified,
             networkIsRealAdvance,
@@ -7628,6 +7853,7 @@ async function executeStepWithHealing(params) {
             resolvedAction,
             isFinalStep,
             submitStep,
+            flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
             isAdvanceWithPattern: isAdvanceStep(step) && advanceTransitionBodyPattern !== null,
             networkDelta: post.networkCount - pre.networkCount,
             bytesDelta: post.bodyHtmlLength - pre.bodyHtmlLength,
@@ -7714,11 +7940,44 @@ async function executeStepWithHealing(params) {
                 }
             }
         }
+        // Committed-value guard for the prompt-selector widget family (popup
+        // multiselect/typeahead trigger widgets). The primitive's own picking
+        // gesture ({@link tryPromptSelectorPrimitive}) only runs on the observe-act
+        // fallback path; a resolved-as-click act against the SAME widget shape can
+        // open its popup, report success, and — since opening a popup mutates the
+        // DOM (bytes changed) — ride `clickViewSwapVerified` to a phantom success
+        // without ever committing an option. Gate it the same way as the datepicker
+        // guard above: readback the widget's own committed-value node
+        // ({@link verifyPromptSelectorCommitted}) and, when the resolved element IS
+        // this widget shape but nothing committed, suppress the weak signals.
+        // `isPromptWidget: false` for anything outside this widget family, so a
+        // plain click/fill is untouched.
+        let promptSelectorRejected = false;
+        // Exempt only on a genuine network-advance or URL-change signal, not the
+        // broader `hasStrongSignal` (which the sibling datepicker gate above
+        // legitimately relies on) — `domVerifiedForStep` is true here simply
+        // because opening the widget's popup mutates the DOM, so reusing it would
+        // let that popup-open alone skip the readback below.
+        const hasNetworkOrUrlSignal = networkIsRealAdvance || urlChanged;
+        if (record.actResultSuccess === true && !hasNetworkOrUrlSignal) {
+            const readbackSelector = resolvedAction?.selector ?? triedSelectors[triedSelectors.length - 1] ?? null;
+            if (readbackSelector) {
+                const readbackTarget = frameTarget ?? (0, frame_target_1.mainFrameTarget)(page);
+                const promptReadback = await verifyPromptSelectorCommitted(readbackTarget, readbackSelector);
+                if (promptReadback?.isPromptWidget === true && promptReadback.committed === false) {
+                    promptSelectorRejected = true;
+                    record.actResultSuccess = false;
+                    record.errorMessage = `prompt-selector-fill-rejected: resolved element <${readbackSelector}> is a prompt-selector-shaped widget but no committed value landed`;
+                }
+            }
+        }
         let verified = networkIsRealAdvance ||
             urlChanged ||
             domVerifiedForStep ||
             datepickerCommitted ||
-            (!datepickerRejected && (clickViewSwapVerified || formValueVerified));
+            (!datepickerRejected &&
+                !promptSelectorRejected &&
+                (clickViewSwapVerified || formValueVerified));
         // Final-step submit-verification gate. Replaces the deterministic
         // submitEndpointPattern regex with a Haiku 4.5 LLM judgment over
         // multi-signal evidence (network captures, page URL/title, DOM
@@ -8004,7 +8263,7 @@ async function executeStepWithHealing(params) {
                         }));
                     const fallbackDomOnlyAdvance = shouldVetoFallbackAdvance({
                         hasPattern: advanceTransitionBodyPattern !== null,
-                        isFinalOrSubmit: isFinalStep || submitStep,
+                        isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
                         isAdvance: isAdvanceStep(step),
                         retryUrlChanged,
                         retryNetworkIsRealAdvance,
@@ -8159,7 +8418,7 @@ async function executeStepWithHealing(params) {
             // checked) into `domVerified`. A registered selection toggle no longer
             // reads as a phantom just because it moved no network/URL/bytes.
             elementStateChanged: domVerified,
-            isSubmitShapedStep: isFinalStep || submitStep,
+            isSubmitShapedStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
         });
         const reason = record.errorMessage
             ? effectSignals
@@ -8178,7 +8437,8 @@ async function executeStepWithHealing(params) {
         // Empirically grounded: 22 of 22 JSON-envelope ATS Continue/Submit step-failure
         // dumps in a 2026-06-10 survey had the paired touched+dirty + visible
         // error text pattern with 3 distinct rejection messages.
-        if (record.resolvedMethod === "click" && (isFinalStep || submitStep)) {
+        if (record.resolvedMethod === "click" &&
+            (submitStep || (isFinalStep && flowHasSubmitSemanticsFlag))) {
             const live = await extractLivePageFormEvidence(page, frameTarget ?? (0, frame_target_1.mainFrameTarget)(page), {
                 client: anthropic,
                 knownErrorClassPrefixes,
@@ -8223,7 +8483,7 @@ async function executeStepWithHealing(params) {
             phantomClickAfterAttempt1 = record.phantomClickVerdict === "phantom";
             if (phantomClickAfterAttempt1) {
                 const suppressedCount = getSuppressedAisdkElementIdErrorCount?.();
-                const escalationTarget = isFinalStep || submitStep
+                const escalationTarget = submitStep || (isFinalStep && flowHasSubmitSemanticsFlag)
                     ? "escalating attempt 2 to deep-submit-locator"
                     : "non-submit step — escalating attempt 2 to trusted-click-retry (trusted CDP click on the resolved target)";
                 logger.warn(`${formatStepPrefix(stepIndex, totalSteps)} phantom click detected on attempt 1 (${record.technique}): reported success with no network/url/dom change${suppressedCount !== undefined ? `; ${suppressedCount} AISDK elementId errors suppressed this session (corroborating, not causal)` : ""} — ${escalationTarget}`);
@@ -8233,7 +8493,7 @@ async function executeStepWithHealing(params) {
                 // Treat the canonical submit click as "final" for this predicate
                 // even when it lives mid-flow. See requireSubmitEndpoint derivation
                 // above for the same gate-widening rationale.
-                isFinalStep: isFinalStep || submitStep,
+                isFinalStep: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
                 requireSubmitEndpoint,
                 resolvedMethod: record.resolvedMethod,
                 effectSignals,
@@ -8253,7 +8513,7 @@ async function executeStepWithHealing(params) {
             // can reorder a later step forward — instead of burning the cascade.
             const advanceStalled = isAdvanceStalled({
                 isAdvance: isAdvanceStep(step),
-                isFinalOrSubmit: isFinalStep || submitStep,
+                isFinalOrSubmit: submitStep || (isFinalStep && flowHasSubmitSemanticsFlag),
                 hasPattern: advanceTransitionBodyPattern !== null,
                 clickFired: record.resolvedMethod === "click" && record.actResultSuccess === true,
                 networkFired,
@@ -8399,6 +8659,11 @@ async function runHealingFlow(deps) {
             }
         },
     });
+    const flowHasSubmitSemanticsFlag = flowHasSubmitSemantics({
+        steps,
+        submitEndpointPattern: deps.submitEndpointPattern ?? null,
+        requireSubmitEndpointMatch: deps.requireSubmitEndpointMatch ?? false,
+    });
     if (shouldWarnMissingAdvancePattern(steps.map((s) => s.instruction), deps.advanceTransitionBodyPattern ?? null)) {
         logger.warn("flow has advance steps but no advanceTransitionBodyPattern — DOM-only advance guard is disarmed; pointer/page desync is possible on validation-re-render wizards");
     }
@@ -8407,6 +8672,24 @@ async function runHealingFlow(deps) {
             if (maxFlowMs !== undefined && Date.now() - start > maxFlowMs) {
                 throw new errors_2.StepVerificationError(`${formatStepPrefix(i, () => steps.length)} flow exceeded its maxFlowMs budget (${maxFlowMs}ms)`, "flow-timeout");
             }
+            // Liveness gate: a closed/crashed Stagehand session (e.g. the
+            // shutdown-supervisor force-releasing mid-flow) makes `page.url()`
+            // throw synchronously — the one call every Page implementation
+            // answers without touching the DOM. Everything downstream (observe/
+            // act probes) treats a thrown error as "page has no candidates right
+            // now" and, for an optional step, quietly skips it — so without this
+            // check the loop runs to completion and `runHealingFlow` resolves as
+            // if the flow finished, even though the session died partway through.
+            // Checking here, before any step-specific handling, means a dead
+            // session is reported as a `SessionTimeoutError` distinct from a
+            // legitimately-absent optional step, and the flow's own step count
+            // never quietly reaches `steps.length` past the point of death.
+            try {
+                page.url();
+            }
+            catch (err) {
+                throw new errors_2.SessionTimeoutError(`${formatStepPrefix(i, () => steps.length)} session appears closed/dead (page.url() threw: ${(0, errors_1.toErrorMessage)(err)}) — aborting after ${i} of ${steps.length} steps completed`);
+            }
             lastStepIndex = i;
             // Resolved fresh per step (not cached across the run) so a cross-origin
             // iframe that attaches mid-flow (e.g. after an "Apply" click reveals a
@@ -8423,6 +8706,7 @@ async function runHealingFlow(deps) {
                 optional: s.optional,
                 upload: s.upload,
                 submitStep: s.submitStep,
+                flowHasSubmitSemantics: flowHasSubmitSemanticsFlag,
                 stepIndex: i,
                 totalSteps: () => steps.length,
                 phase: "flow",