@geometra/proxy 1.45.0 → 1.47.0

package/dist/dom-actions.d.ts

@@ -1,5 +1,6 @@
 import type { Locator, Page } from 'playwright';
 import type { ClientChoiceType, ClientFillField } from './types.js';
+export declare function delay(ms: number): Promise<void>;
 export type FileAttachStrategy = 'auto' | 'chooser' | 'hidden' | 'drop';
 export interface FillLookupCache {
     control: Map<string, Locator | null>;

package/dist/dom-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dom-actions.d.ts","sourceRoot":"","sources":["../src/dom-actions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dom-actions.d.ts","sourceRoot":"","sources":["../src/dom-actions.ts"],"names":[],"mappings":"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"}

package/dist/dom-actions.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-function delay(ms) {
+export function delay(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
 const LABELED_CONTROL_SELECTOR = 'input, select, textarea, button, [role="combobox"], [role="textbox"], [aria-haspopup="listbox"], [contenteditable="true"]';
@@ -1873,11 +1873,22 @@ async function pressEnterToCommitListbox(page, handle) {
  * no form ancestor, etc.) — "unknown" is NOT a veto, same convention as
  * `readAriaInvalid`.
  */
-async function readFormLevelInvalidState(handle) {
+async function readFormLevelInvalidState(handle, opts) {
     if (!handle)
         return false;
+    // Default behavior preserves the existing veto logic: a blank required
+    // hidden input only counts as invalid when SOMETHING else in the wrapper
+    // also flags an error (role=alert / data-invalid / data-error). That's
+    // safe for read-only checks where we don't know whether a commit was
+    // recently attempted. When `requireWrapperFlag: false`, the function
+    // becomes stricter and treats a blank required hidden input as
+    // definitively-not-committed even without a visible error flag — the
+    // caller (postCommitVerify) is asserting that a commit was just attempted,
+    // so the hidden input's emptiness IS authoritative. Bug surfaced by
+    // JobForge round-2 marathon — Airtable PM AI #94 phone-country combobox.
+    const requireWrapperFlag = opts?.requireWrapperFlag ?? true;
     try {
-        return await handle.evaluate((el) => {
+        return await handle.evaluate((el, requireWrapperFlagFn) => {
             if (!(el instanceof Element))
                 return false;
             // Find the closest <form>. No form = can't verify, not a veto.
@@ -1923,9 +1934,15 @@ async function readFormLevelInvalidState(handle) {
                 // hidden input is blank. react-select writes an empty string to
                 // its hidden input when uncommitted.
                 if (input.required && (input.value === '' || input.value == null)) {
-                    // Only veto if SOMETHING in the wrapper also flags the field as
-                    // in-error. A blank hidden input on a page that hasn't attempted
-                    // submit yet is common and non-authoritative.
+                    if (!requireWrapperFlagFn) {
+                        // Caller (postCommitVerify) just attempted a commit; a blank
+                        // required hidden input is authoritative even without a
+                        // visible error flag.
+                        return true;
+                    }
+                    // Read-only mode: only veto if SOMETHING in the wrapper also
+                    // flags the field as in-error. A blank hidden input on a page
+                    // that hasn't attempted submit yet is common and non-authoritative.
                     const flaggedInWrapper = wrapper.querySelector('[role="alert"]') ||
                         wrapper.querySelector('[data-invalid]') ||
                         wrapper.querySelector('[data-error]');
@@ -1955,7 +1972,7 @@ async function readFormLevelInvalidState(handle) {
                 return true;
             }
             return false;
-        });
+        }, requireWrapperFlag);
     }
     catch {
         return false;
@@ -2532,22 +2549,130 @@ async function attachViaChooser(page, paths, clickX, clickY) {
     ]);
     await chooser.setFiles(paths);
 }
-/** Synthetic drop at (x,y) using file bytes from the proxy host (targets elementFromPoint). */
+/**
+ * Map common file extensions to MIME types so react-dropzone's `accept` filter
+ * does not silently drop our synthetic files. Defaults to application/octet-stream
+ * for unknowns, which is rejected by most dropzones configured with accept.
+ */
+function mimeTypeForPath(path) {
+    const ext = path.toLowerCase().split('.').pop() ?? '';
+    switch (ext) {
+        case 'pdf': return 'application/pdf';
+        case 'doc': return 'application/msword';
+        case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        case 'txt': return 'text/plain';
+        case 'rtf': return 'application/rtf';
+        case 'png': return 'image/png';
+        case 'jpg':
+        case 'jpeg': return 'image/jpeg';
+        case 'gif': return 'image/gif';
+        case 'webp': return 'image/webp';
+        case 'svg': return 'image/svg+xml';
+        default: return 'application/octet-stream';
+    }
+}
+/**
+ * Synthetic drop at (x,y) using file bytes from the proxy host.
+ *
+ * react-dropzone (widely used by Greenhouse, Ashby, and others) does NOT listen
+ * for a bare `drop` event — its `getRootProps` wires up a full
+ * `dragenter` → `dragover` → `drop` sequence, and react-dropzone's internal
+ * state machine silently ignores a `drop` that never saw `dragenter`/`dragover`.
+ * It also requires a proper `dataTransfer.types` containing "Files" AND correct
+ * MIME types for any configured `accept` filter, otherwise the file is
+ * rejected.
+ *
+ * We dispatch the full sequence on the deepest visible element at (x,y) and
+ * bubble up — plus a fallback walk-up that targets any ancestor whose class
+ * names, data-attributes, or role look dropzone-ish, so we hit both the inner
+ * button layer and the wrapper that actually has the listeners.
+ */
 async function attachViaDropPlaywright(page, paths, dropX, dropY) {
     const fs = await import('node:fs/promises');
     const buffers = await Promise.all(paths.map(p => fs.readFile(p)));
     const names = paths.map(p => p.split(/[/\\\\]/).pop() ?? 'file');
+    const mimes = paths.map(mimeTypeForPath);
     await page.mouse.move(dropX, dropY);
-    await page.mainFrame().evaluate(({ bufs, ns, x, y }) => {
-        const dt = new DataTransfer();
-        for (let i = 0; i < bufs.length; i++) {
-            const u8 = new Uint8Array(bufs[i]);
-            const blob = new Blob([u8]);
-            dt.items.add(new File([blob], ns[i], { type: 'application/octet-stream' }));
+    await page.mainFrame().evaluate(({ bufs, ns, ms, x, y }) => {
+        const makeDataTransfer = () => {
+            const dt = new DataTransfer();
+            for (let i = 0; i < bufs.length; i++) {
+                const u8 = new Uint8Array(bufs[i]);
+                const blob = new Blob([u8], { type: ms[i] });
+                dt.items.add(new File([blob], ns[i], { type: ms[i] }));
+            }
+            return dt;
+        };
+        const dispatchSequence = (target) => {
+            // Each event needs its own DataTransfer because some frameworks
+            // consume the items list during dragenter/dragover inspection.
+            for (const type of ['dragenter', 'dragover', 'drop']) {
+                const dt = makeDataTransfer();
+                const ev = new DragEvent(type, {
+                    bubbles: true,
+                    cancelable: true,
+                    composed: true,
+                    clientX: x,
+                    clientY: y,
+                    dataTransfer: dt,
+                });
+                // Some browsers/frameworks freeze the dataTransfer getter; re-define
+                // it defensively so listeners read the files.
+                try {
+                    Object.defineProperty(ev, 'dataTransfer', { value: dt, configurable: true });
+                }
+                catch { /* ignore */ }
+                target.dispatchEvent(ev);
+            }
+        };
+        const deepest = document.elementFromPoint(x, y);
+        const targets = [];
+        if (deepest)
+            targets.push(deepest);
+        // Walk up a few ancestors looking for anything that looks like a dropzone
+        // root (react-dropzone emits `data-rfd-*`; Greenhouse uses div.drop-zone;
+        // Ashby uses role="button" wrappers). We dispatch on the first dropzone-ish
+        // ancestor AND the deepest element, because we cannot tell statically
+        // which one has the real listener.
+        let p = deepest?.parentElement ?? null;
+        for (let depth = 0; depth < 12 && p; depth++) {
+            const tag = p.tagName.toLowerCase();
+            const attrs = p.getAttributeNames();
+            const looksLikeDropzone = attrs.some(a => a.startsWith('data-rfd') || a === 'data-dropzone' || a === 'data-testid') ||
+                (p.className && typeof p.className === 'string' && /drop[-_]?zone|file[-_]?upload|attach|upload/i.test(p.className)) ||
+                tag === 'label' ||
+                p.getAttribute('role') === 'button';
+            if (looksLikeDropzone && !targets.includes(p))
+                targets.push(p);
+            p = p.parentElement;
         }
-        const target = document.elementFromPoint(x, y) ?? document.body;
-        target.dispatchEvent(new DragEvent('drop', { bubbles: true, cancelable: true, clientX: x, clientY: y, dataTransfer: dt }));
-    }, { bufs: buffers.map(b => Array.from(b)), ns: names, x: dropX, y: dropY });
+        if (targets.length === 0)
+            targets.push(document.body);
+        for (const t of targets)
+            dispatchSequence(t);
+        // As a final fallback, if there is a hidden input[type=file] scoped to
+        // the nearest form/section, set its `files` via DataTransfer and dispatch
+        // the React-friendly native input value setter so react-hook-form notices.
+        const host = deepest?.closest('form, [role="form"], fieldset, section, div') ?? document.body;
+        const fileInput = host.querySelector('input[type="file"]');
+        if (fileInput) {
+            const dt = makeDataTransfer();
+            try {
+                Object.defineProperty(fileInput, 'files', { value: dt.files, configurable: true });
+            }
+            catch { /* ignore */ }
+            try {
+                // React overrides the input value setter; we need the native prototype
+                // setter so React sees the change.
+                const proto = Object.getPrototypeOf(fileInput);
+                const descriptor = Object.getOwnPropertyDescriptor(proto, 'value');
+                descriptor?.set?.call(fileInput, '');
+            }
+            catch { /* ignore */ }
+            fileInput.dispatchEvent(new Event('input', { bubbles: true }));
+            fileInput.dispatchEvent(new Event('change', { bubbles: true }));
+        }
+    }, { bufs: buffers.map(b => Array.from(b)), ns: names, ms: mimes, x: dropX, y: dropY });
 }
 /**
  * `strategy`:
@@ -3103,6 +3228,23 @@ async function attemptNativeBatchFill(page, fields) {
                     return explicit;
                 return el.textContent?.trim() || undefined;
             }
+            // Snapshot every state attribute that React-style stateful buttons
+            // typically toggle on selection. Used to verify that a click on a
+            // button-shaped group radio actually committed (not a structural
+            // no-op). Mirrors `selectionSignature` in `chooseValueFromLabeledGroup`
+            // — kept in sync because they live in different page.evaluate scopes.
+            function selectionSignature(opts) {
+                return opts.map(el => {
+                    const ariaPressed = el.getAttribute('aria-pressed') ?? '';
+                    const ariaChecked = el.getAttribute('aria-checked') ?? '';
+                    const ariaSelected = el.getAttribute('aria-selected') ?? '';
+                    const dataState = el.getAttribute('data-state') ?? '';
+                    const dataSelected = el.getAttribute('data-selected') ?? '';
+                    const className = (el instanceof HTMLElement ? el.className : '') ?? '';
+                    const checked = el instanceof HTMLInputElement ? String(el.checked) : '';
+                    return `${ariaPressed}|${ariaChecked}|${ariaSelected}|${dataState}|${dataSelected}|${className}|${checked}`;
+                }).join('||');
+            }
             function setGroupedChoice(fieldLabel, value, exact) {
                 const groups = Array.from(document.querySelectorAll('fieldset, [role="radiogroup"], [role="group"]'))
                     .filter((el) => visible(el) && matches(groupPrompt(el), fieldLabel, exact));
@@ -3129,7 +3271,30 @@ async function attemptNativeBatchFill(page, fields) {
                                 return control.checked;
                             return true;
                         }
+                        // role=radio / role=checkbox: click and verify aria-checked
+                        // / aria-selected. The native batch fill used to silently return
+                        // true here, which masked Pinecone's commit-on-rerender bug.
+                        if (option.getAttribute('role') === 'radio' || option.getAttribute('role') === 'checkbox') {
+                            option.click();
+                            return (option.getAttribute('aria-checked') === 'true' ||
+                                option.getAttribute('aria-selected') === 'true');
+                        }
+                        // Plain <button> path. This is where Pinecone / LangChain Ashby
+                        // Yes/No groups land. The native batch fill previously returned
+                        // true unconditionally, masking the silent-fail mode where the
+                        // form re-renders mid-flow with a shifted field-id prefix that
+                        // wipes the radio's commit state. Snapshot the group's selection
+                        // signature, click, then re-snapshot — if nothing changed, the
+                        // click was a structural no-op and we return false so the higher-
+                        // level setFieldChoice fallback (chooseValueFromLabeledGroup,
+                        // which has its own retry logic) can take over. Bug surfaced by
+                        // JobForge round-2 marathon — Pinecone Sr SWE Database Team
+                        // #320 and LangChain SE Manager #325.
+                        const beforeSig = selectionSignature(options);
                         option.click();
+                        const afterSig = selectionSignature(options);
+                        if (beforeSig === afterSig)
+                            return false;
                         return true;
                     }
                 }
@@ -3384,9 +3549,25 @@ async function findOtpBoxGroup(page, fieldLabel, expectedLength) {
             // address them unambiguously via a single selector. Using a
             // content-hash-ish random id avoids collisions with existing
             // data attributes and re-renders across re-entry.
+            //
+            // Before stamping the new marker, strip any STALE markers from
+            // ALL prior calls anywhere in the document. Without this, a re-rendered
+            // OTP form (e.g. after a stale-OTP submit failure) can leave detached
+            // nodes carrying old data-geometra-otp-* attributes that selectors
+            // could otherwise hit before resolving the live cells. (Bug surfaced
+            // by JobForge round-2 marathon — Glean ML Engineer #174.)
+            const stale = document.querySelectorAll('[data-geometra-otp-stamp]');
+            for (const node of Array.from(stale)) {
+                for (const attr of Array.from(node.attributes)) {
+                    if (attr.name.startsWith('data-geometra-otp-')) {
+                        node.removeAttribute(attr.name);
+                    }
+                }
+            }
             const marker = `data-geometra-otp-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
             best.inputs.forEach((input, index) => {
                 input.setAttribute(marker, String(index));
+                input.setAttribute('data-geometra-otp-stamp', '1');
             });
             return { cssSelector: `[${marker}]`, count: best.inputs.length };
         }, { scopeHint: scope, wantLength: expectedLength });
@@ -3428,6 +3609,17 @@ export async function fillOtp(page, value, opts) {
     if (!group) {
         throw new Error(`fillOtp: no OTP box group found${opts?.fieldLabel ? ` near label "${opts.fieldLabel}"` : ''}. Expected ≥2 sibling <input maxlength="1"> elements on the same row.`);
     }
+    // Sanity check: the locator we just stamped must resolve to exactly the
+    // expected number of cells, all connected to the live document. If the
+    // form re-rendered between findOtpBoxGroup's marker stamp and now, the
+    // marker may have been wiped from the DOM and the count drops to 0.
+    // Throw a clear stale-cell error rather than proceeding to type into
+    // nothing. (Bug surfaced by JobForge round-2 marathon — Glean ML
+    // Engineer #174 second-attempt failure.)
+    const liveCount = await group.boxes.count();
+    if (liveCount !== group.cellCount) {
+        throw new Error(`fillOtp: OTP cell group went stale before fill (expected ${group.cellCount} cells, found ${liveCount}). The form likely re-rendered between detection and fill — retry the call.`);
+    }
     // Click the leftmost box via its center point. We use a low-level
     // bounding-box click because a semantic "click the first input" path
     // resolves to whichever input paints topmost in the stacking order,
@@ -3441,6 +3633,22 @@ export async function fillOtp(page, value, opts) {
         throw new Error('fillOtp: first OTP cell has no bounding box (detached or invisible?)');
     }
     await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    // Verify focus actually landed on a cell of THIS group (not a stacked
+    // overlay or a sibling element that happened to share the click point).
+    // If the click missed, typing would feed characters to whatever element
+    // happens to hold focus — usually nothing useful — and the readback
+    // would mysteriously show all-empty cells.
+    const focusedOnGroup = await firstBox.evaluate((el) => {
+        const active = document.activeElement;
+        if (!active)
+            return false;
+        // Either the click landed on cell 0 itself, or focus auto-advanced to
+        // a sibling cell with the same data-geometra-otp-stamp.
+        return active === el || (active instanceof HTMLElement && active.hasAttribute('data-geometra-otp-stamp'));
+    });
+    if (!focusedOnGroup) {
+        throw new Error('fillOtp: bounding-box click on cell 0 did not land focus inside the OTP group. The cell may be covered by an overlay or the group is stale — retry after re-detecting.');
+    }
     // Clear any pre-existing values in all cells so we write a clean slate.
     // Some widgets pre-populate cells with zero-width spaces or previous
     // values after a re-render; typing over them would offset the
@@ -3471,35 +3679,131 @@ export async function fillOtp(page, value, opts) {
     await page.keyboard.type(value, { delay: perCharDelay });
     // Small settle window for the last cell's onChange propagation.
     await delay(80);
-    // Verify: read every cell's value and confirm per-char match.
-    const readback = [];
-    for (let i = 0; i < perCellCount; i++) {
-        const cellValue = await group.boxes.nth(i).evaluate((el) => {
-            if (el instanceof HTMLInputElement)
-                return el.value;
-            if (el instanceof HTMLElement)
-                return el.textContent ?? '';
-            return '';
-        });
-        readback.push(cellValue ?? '');
-    }
-    // For each typed char, the corresponding cell must contain exactly that
-    // char. Cells beyond the typed length are allowed to be empty.
     const expected = Array.from(value);
-    const mismatches = [];
-    for (let i = 0; i < expected.length; i++) {
-        if (readback[i] !== expected[i]) {
-            mismatches.push({ index: i, expected: expected[i], got: readback[i] ?? '' });
+    const liveGroup = group;
+    // Readback helper — reads every cell's current value / text content so
+    // we can compare against the expected char at the same index.
+    async function readCurrentCells() {
+        const out = [];
+        for (let i = 0; i < perCellCount; i++) {
+            const cellValue = await liveGroup.boxes.nth(i).evaluate((el) => {
+                if (el instanceof HTMLInputElement)
+                    return el.value;
+                if (el instanceof HTMLElement)
+                    return el.textContent ?? '';
+                return '';
+            });
+            out.push(cellValue ?? '');
         }
-    }
+        return out;
+    }
+    let readback = await readCurrentCells();
+    let mismatches = computeOtpMismatches(readback, expected);
+    // Recovery path: some Greenhouse / React builds let cell 0 accept the
+    // entire string because the onKeyDown auto-advance handler fires after
+    // the input event, so the first char lands in cell 0 but the second
+    // char also lands there (no maxlength enforcement on a controlled input)
+    // — cells 1..N-1 end up empty and cell 0 holds the full value. Also
+    // observed: partial fills where cells 0..K hold multiple chars and
+    // cells K+1.. hold the rest. Rather than throwing and asking the caller
+    // to retry fresh (which often hits the same race), we do a deterministic
+    // per-cell recovery: clear every cell again, then for EACH cell
+    // individually click its center and type exactly one char. This is
+    // slower (~N clicks) but guarantees a 1:1 mapping regardless of whether
+    // the widget's focus-advance handler is working. Surfaced by the
+    // JobForge Hex AI Engineering Lead #310 apply flow on 2026-04-11, where
+    // the initial `page.keyboard.type` dumped "ctUwV3" into cell 0 and
+    // "c"/"t"/"U" into cells 5/6/7 (focus advanced erratically late in the
+    // typing sequence), and the post-verify readback momentarily showed a
+    // stale-but-matching state so the tool returned success.
+    if (mismatches.length > 0) {
+        // Capture per-cell bounding boxes BEFORE any clearing / re-typing so
+        // we have stable screen coordinates to click even if the widget
+        // re-renders mid-recovery.
+        const cellBoxes = [];
+        for (let i = 0; i < perCellCount; i++) {
+            try {
+                cellBoxes.push(await group.boxes.nth(i).boundingBox());
+            }
+            catch {
+                cellBoxes.push(null);
+            }
+        }
+        // Clear every cell again. React-controlled cells sometimes reject a
+        // direct `.value = ''` the first time; pairing the DOM reset with a
+        // keyboard Select-All + Delete cycle per cell during the type loop
+        // below is more reliable.
+        for (let i = 0; i < perCellCount; i++) {
+            try {
+                await group.boxes.nth(i).evaluate((el) => {
+                    if (el instanceof HTMLInputElement) {
+                        el.value = '';
+                        el.dispatchEvent(new Event('input', { bubbles: true }));
+                        el.dispatchEvent(new Event('change', { bubbles: true }));
+                    }
+                });
+            }
+            catch {
+                /* tolerate */
+            }
+        }
+        // Per-cell typing: click each cell at its center, then type the single
+        // expected char. We do NOT rely on the widget's auto-advance — we
+        // always explicitly click the next cell for the next char. Before
+        // typing, reset the target cell's value directly in the DOM so the
+        // new char overwrites instead of appending. This is faster and more
+        // deterministic than going through the keyboard Select-All + Delete
+        // path on every cell.
+        for (let i = 0; i < expected.length; i++) {
+            const cellBox = cellBoxes[i];
+            if (!cellBox)
+                continue;
+            try {
+                await liveGroup.boxes.nth(i).evaluate((el) => {
+                    if (el instanceof HTMLInputElement) {
+                        el.value = '';
+                        el.dispatchEvent(new Event('input', { bubbles: true }));
+                        el.dispatchEvent(new Event('change', { bubbles: true }));
+                    }
+                });
+            }
+            catch {
+                /* tolerate */
+            }
+            const cx = cellBox.x + cellBox.width / 2;
+            const cy = cellBox.y + cellBox.height / 2;
+            await page.mouse.click(cx, cy);
+            await page.keyboard.type(expected[i], { delay: perCharDelay });
+        }
+        // Settle, re-read, re-compare.
+        await delay(60);
+        readback = await readCurrentCells();
+        mismatches = computeOtpMismatches(readback, expected);
+    }
+    // Final verification. If recovery did not resolve the mismatch, throw
+    // with the full diagnostic so callers get an honest failure instead of
+    // a silent "success" that leaves cells holding the wrong chars.
     if (mismatches.length > 0) {
+        const allEmpty = readback.slice(0, expected.length).every((v) => v === '');
+        if (allEmpty) {
+            throw new Error(`fillOtp: typed ${expected.length} chars but ALL ${expected.length} target cells are still empty after per-cell recovery. Focus was lost mid-flow or the cell group was re-rendered after detection. Retry the call to re-detect the live cells.`);
+        }
         const summary = mismatches
             .map((m) => `cell ${m.index}: expected "${m.expected}", got "${m.got}"`)
             .join('; ');
-        throw new Error(`fillOtp: typed ${expected.length} chars into ${perCellCount}-cell group but readback mismatch — ${summary}. Readback: [${readback.map((v) => JSON.stringify(v)).join(', ')}]`);
+        throw new Error(`fillOtp: typed ${expected.length} chars into ${perCellCount}-cell group but readback mismatch even after per-cell recovery — ${summary}. Readback: [${readback.map((v) => JSON.stringify(v)).join(', ')}]`);
     }
     return { cellCount: perCellCount, filledCount: expected.length };
 }
+function computeOtpMismatches(readback, expected) {
+    const mismatches = [];
+    for (let i = 0; i < expected.length; i++) {
+        if (readback[i] !== expected[i]) {
+            mismatches.push({ index: i, expected: expected[i], got: readback[i] ?? '' });
+        }
+    }
+    return mismatches;
+}
 export async function setFieldText(page, fieldLabel, value, opts) {
     // Bug #2 (v1.43) auto-routing: if the caller's label looks like a
     // verification-code / security-code / OTP prompt, try the dedicated OTP
@@ -4184,7 +4488,16 @@ export async function pickListboxOption(page, label, opts) {
         // [data-invalid] flag inside the field wrapper (react-hook-form,
         // Formik, Ashby forms, etc.). If the form disagrees with the trigger,
         // the commit did not land and the caller should retry.
-        if (await readFormLevelInvalidState(openedHandle))
+        //
+        // We use the STRICT variant here (`requireWrapperFlag: false`) because
+        // we just attempted a commit — a required hidden input that is still
+        // empty IS authoritative even before the user submits the form. Without
+        // this, Greenhouse's phone-country-code combobox (Airtable PM AI #94)
+        // false-passes verification: the trigger shows "+1" but the hidden
+        // input stays blank because react-select's keyboard-Enter commit
+        // didn't bind to the country sub-control. Bug surfaced by JobForge
+        // round-2 marathon.
+        if (await readFormLevelInvalidState(openedHandle, { requireWrapperFlag: false }))
             return false;
         return true;
     };