@geometra/proxy 1.19.15 → 1.19.17

package/dist/dom-actions.js

@@ -5,9 +5,65 @@ function delay(ms) {
 }
 const LABELED_CONTROL_SELECTOR = 'input, select, textarea, button, [role="combobox"], [role="textbox"], [aria-haspopup="listbox"], [contenteditable="true"]';
 const OPTION_PICKER_SELECTOR = '[role="option"], [role="menuitem"], [role="treeitem"], button, li, [data-value], [aria-selected], [aria-checked]';
+export function createFillLookupCache() {
+    return {
+        control: new Map(),
+        editable: new Map(),
+        fileInput: new Map(),
+    };
+}
+export function clearFillLookupCache(cache) {
+    cache.control.clear();
+    cache.editable.clear();
+    cache.fileInput.clear();
+}
+function lookupCacheKey(kind, label, exact) {
+    return `${kind}:${exact ? 'exact' : 'fuzzy'}:${normalizedOptionLabel(label)}`;
+}
+function lookupCacheKeys(kind, label, exact, fieldId) {
+    const keys = [lookupCacheKey(kind, label, exact)];
+    if (fieldId)
+        keys.unshift(`${kind}:id:${fieldId}`);
+    return keys;
+}
+function cacheMapForKind(cache, kind) {
+    if (kind === 'control')
+        return cache.control;
+    if (kind === 'editable')
+        return cache.editable;
+    return cache.fileInput;
+}
+function readCachedLocator(cache, kind, label, exact, fieldId) {
+    if (!cache)
+        return undefined;
+    const map = cacheMapForKind(cache, kind);
+    for (const key of lookupCacheKeys(kind, label, exact, fieldId)) {
+        if (map.has(key))
+            return map.get(key) ?? null;
+    }
+    return undefined;
+}
+function writeCachedLocator(cache, kind, label, exact, fieldId, locator) {
+    if (!cache)
+        return;
+    const map = cacheMapForKind(cache, kind);
+    for (const key of lookupCacheKeys(kind, label, exact, fieldId)) {
+        map.set(key, locator);
+    }
+}
 function normalizedOptionLabel(value) {
     return value.replace(/\s+/g, ' ').trim().toLowerCase();
 }
+function prefersGroupedChoiceValue(value) {
+    const normalized = normalizedOptionLabel(value);
+    return normalized === 'yes' ||
+        normalized === 'no' ||
+        normalized === 'true' ||
+        normalized === 'false' ||
+        normalized === 'decline' ||
+        normalized === 'prefer not' ||
+        normalized === 'opt out';
+}
 function semanticSelectionAliases(value) {
     const normalized = normalizedOptionLabel(value);
     const aliases = new Set([normalized]);
@@ -367,6 +423,24 @@ async function findLabeledControl(frame, fieldLabel, exact, opts) {
     });
     return bestIndex >= 0 ? fallbackCandidates.nth(bestIndex) : null;
 }
+async function findLabeledControlInPage(page, fieldLabel, exact, opts) {
+    const cacheable = !opts?.preferredAnchor;
+    const cached = cacheable ? readCachedLocator(opts?.cache, 'control', fieldLabel, exact, opts?.fieldId) : undefined;
+    if (cached !== undefined) {
+        return cached;
+    }
+    for (const frame of page.frames()) {
+        const locator = await findLabeledControl(frame, fieldLabel, exact, { preferredAnchor: opts?.preferredAnchor });
+        if (!locator)
+            continue;
+        if (cacheable)
+            writeCachedLocator(opts?.cache, 'control', fieldLabel, exact, opts?.fieldId, locator);
+        return locator;
+    }
+    if (cacheable)
+        writeCachedLocator(opts?.cache, 'control', fieldLabel, exact, opts?.fieldId, null);
+    return null;
+}
 function textMatches(candidate, expected, exact) {
     return selectionMatchScore(candidate, expected, exact) !== null;
 }
@@ -381,11 +455,9 @@ function displayedValueMatchesSelection(candidate, expected, exact, selectedOpti
         return false;
     return (normalizedSelectedOption.includes(normalizedCandidate) || normalizedCandidate.includes(normalizedSelectedOption));
 }
-async function openDropdownControl(page, fieldLabel, exact) {
-    for (const frame of page.frames()) {
-        const locator = await findLabeledControl(frame, fieldLabel, exact);
-        if (!locator)
-            continue;
+async function openDropdownControl(page, fieldLabel, exact, cache, fieldId) {
+    const locator = await findLabeledControlInPage(page, fieldLabel, exact, { cache, fieldId });
+    if (locator) {
         await locator.scrollIntoViewIfNeeded();
         const handle = await locator.elementHandle();
         const clickTarget = await resolveMeaningfulClickTarget(locator);
@@ -788,7 +860,33 @@ async function findLabeledFileInput(frame, fieldLabel, exact) {
     }, { fieldLabel, exact });
     return bestIndex >= 0 ? loc.nth(bestIndex) : null;
 }
+async function findLabeledFileInputInPage(page, fieldLabel, exact, cache, fieldId) {
+    const cached = readCachedLocator(cache, 'file', fieldLabel, exact, fieldId);
+    if (cached !== undefined)
+        return cached;
+    for (const frame of page.frames()) {
+        const locator = await findLabeledFileInput(frame, fieldLabel, exact);
+        if (!locator)
+            continue;
+        writeCachedLocator(cache, 'file', fieldLabel, exact, fieldId, locator);
+        return locator;
+    }
+    writeCachedLocator(cache, 'file', fieldLabel, exact, fieldId, null);
+    return null;
+}
 async function attachHiddenInAllFrames(page, paths, opts) {
+    if (opts?.fieldLabel) {
+        const labeled = await findLabeledFileInputInPage(page, opts.fieldLabel, opts.exact ?? false, opts.cache, opts.fieldId);
+        if (labeled) {
+            try {
+                await labeled.setInputFiles(paths);
+                return true;
+            }
+            catch {
+                /* fall through to uncached scan */
+            }
+        }
+    }
     for (const frame of page.frames()) {
         if (opts?.fieldLabel) {
             const labeled = await findLabeledFileInput(frame, opts.fieldLabel, opts.exact ?? false);
@@ -864,7 +962,7 @@ export async function attachFiles(page, paths, opts) {
         return;
     }
     if (strategy === 'hidden' || strategy === 'auto') {
-        if (await attachHiddenInAllFrames(page, paths, { fieldLabel, exact }))
+        if (await attachHiddenInAllFrames(page, paths, { fieldId: opts?.fieldId, fieldLabel, exact, cache: opts?.cache }))
             return;
         if (strategy === 'hidden') {
             if (fieldLabel) {
@@ -893,7 +991,10 @@ export async function attachFiles(page, paths, opts) {
     }
     throw new Error('file: no input[type=file] in any frame; pass x,y (chooser), dropX/dropY (drop), or strategy hidden');
 }
-async function findLabeledEditableField(page, fieldLabel, exact) {
+async function findLabeledEditableField(page, fieldLabel, exact, cache, fieldId) {
+    const cached = readCachedLocator(cache, 'editable', fieldLabel, exact, fieldId);
+    if (cached !== undefined)
+        return cached;
     for (const frame of page.frames()) {
         const candidates = [
             frame.getByLabel(fieldLabel, { exact }),
@@ -904,13 +1005,18 @@ async function findLabeledEditableField(page, fieldLabel, exact) {
             const visible = await firstVisible(candidate, { minWidth: 1, minHeight: 1 });
             if (!visible)
                 continue;
-            if (await locatorIsEditable(visible))
+            if (await locatorIsEditable(visible)) {
+                writeCachedLocator(cache, 'editable', fieldLabel, exact, fieldId, visible);
                 return visible;
+            }
         }
         const fallback = await findLabeledControl(frame, fieldLabel, exact);
-        if (fallback && await locatorIsEditable(fallback))
+        if (fallback && await locatorIsEditable(fallback)) {
+            writeCachedLocator(cache, 'editable', fieldLabel, exact, fieldId, fallback);
             return fallback;
+        }
     }
+    writeCachedLocator(cache, 'editable', fieldLabel, exact, fieldId, null);
     return null;
 }
 async function locatorCurrentValue(locator) {
@@ -995,9 +1101,329 @@ async function setLocatorTextValue(locator, value) {
         return false;
     }
 }
+async function attemptNativeBatchFill(page, fields) {
+    const results = fields.map(() => false);
+    for (const frame of page.frames()) {
+        const pending = [];
+        for (let index = 0; index < fields.length; index++) {
+            if (results[index])
+                continue;
+            const field = fields[index];
+            if (field.kind === 'file')
+                continue;
+            if (field.kind === 'auto') {
+                pending.push({
+                    index,
+                    kind: 'auto',
+                    fieldLabel: field.fieldLabel,
+                    value: field.value,
+                    exact: field.exact ?? false,
+                });
+                continue;
+            }
+            if (field.kind === 'text') {
+                pending.push({
+                    index,
+                    kind: 'text',
+                    fieldLabel: field.fieldLabel,
+                    value: field.value,
+                    exact: field.exact ?? false,
+                });
+                continue;
+            }
+            if (field.kind === 'choice') {
+                pending.push({
+                    index,
+                    kind: 'choice',
+                    fieldLabel: field.fieldLabel,
+                    value: field.value,
+                    exact: field.exact ?? false,
+                    choiceType: field.choiceType ?? null,
+                });
+                continue;
+            }
+            pending.push({
+                index,
+                kind: 'toggle',
+                label: field.label,
+                checked: field.checked ?? true,
+                exact: field.exact ?? false,
+                controlType: field.controlType ?? null,
+            });
+        }
+        if (pending.length === 0)
+            break;
+        const frameResults = await frame.evaluate((items) => {
+            function normalize(value) {
+                return (value ?? '').replace(/\s+/g, ' ').trim().toLowerCase();
+            }
+            function matches(candidate, expected, exact) {
+                const normalizedCandidate = normalize(candidate);
+                const normalizedExpected = normalize(expected);
+                if (!normalizedCandidate || !normalizedExpected)
+                    return false;
+                return exact ? normalizedCandidate === normalizedExpected : normalizedCandidate.includes(normalizedExpected);
+            }
+            function visible(el) {
+                if (!(el instanceof HTMLElement))
+                    return false;
+                const rect = el.getBoundingClientRect();
+                if (rect.width <= 0 || rect.height <= 0)
+                    return false;
+                const style = getComputedStyle(el);
+                return style.display !== 'none' && style.visibility !== 'hidden';
+            }
+            function referencedText(ids) {
+                if (!ids)
+                    return undefined;
+                const text = ids
+                    .split(/\s+/)
+                    .map(id => document.getElementById(id)?.textContent?.trim() ?? '')
+                    .filter(Boolean)
+                    .join(' ')
+                    .trim();
+                return text || undefined;
+            }
+            function explicitLabelText(el) {
+                const aria = el.getAttribute('aria-label')?.trim();
+                if (aria)
+                    return aria;
+                const labelledBy = referencedText(el.getAttribute('aria-labelledby'));
+                if (labelledBy)
+                    return labelledBy;
+                if ((el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) &&
+                    el.labels &&
+                    el.labels.length > 0) {
+                    return el.labels[0]?.textContent?.trim() || undefined;
+                }
+                if (el instanceof HTMLElement && el.id) {
+                    const label = document.querySelector(`label[for="${CSS.escape(el.id)}"]`);
+                    const text = label?.textContent?.trim();
+                    if (text)
+                        return text;
+                }
+                if (el.parentElement?.tagName.toLowerCase() === 'label') {
+                    return el.parentElement.textContent?.trim() || undefined;
+                }
+                return undefined;
+            }
+            function dispatch(target) {
+                target.dispatchEvent(new Event('input', { bubbles: true }));
+                target.dispatchEvent(new Event('change', { bubbles: true }));
+            }
+            function setInputLikeValue(target, next) {
+                const proto = target instanceof HTMLInputElement ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype;
+                const descriptor = Object.getOwnPropertyDescriptor(proto, 'value');
+                if (descriptor?.set)
+                    descriptor.set.call(target, next);
+                else
+                    target.value = next;
+            }
+            function currentValue(el) {
+                if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)
+                    return el.value;
+                if (el instanceof HTMLSelectElement)
+                    return el.selectedOptions[0]?.textContent?.trim() || el.value;
+                if (el instanceof HTMLElement && el.isContentEditable)
+                    return el.innerText || el.textContent || '';
+                return '';
+            }
+            function prefersGroupedChoice(input) {
+                const normalized = normalize(input);
+                return normalized === 'yes' ||
+                    normalized === 'no' ||
+                    normalized === 'true' ||
+                    normalized === 'false' ||
+                    normalized === 'decline' ||
+                    normalized === 'prefer not' ||
+                    normalized === 'opt out';
+            }
+            function setTextField(fieldLabel, value, exact) {
+                const controls = Array.from(document.querySelectorAll('input, textarea, [contenteditable="true"]'));
+                for (const control of controls) {
+                    if (!(control instanceof Element) || !visible(control))
+                        continue;
+                    if (control instanceof HTMLInputElement && ['checkbox', 'radio', 'file', 'button', 'submit', 'reset', 'hidden'].includes(control.type)) {
+                        continue;
+                    }
+                    if (!matches(explicitLabelText(control), fieldLabel, exact))
+                        continue;
+                    if (control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement) {
+                        control.focus();
+                        setInputLikeValue(control, value);
+                        dispatch(control);
+                        return matches(currentValue(control), value, false);
+                    }
+                    if (control instanceof HTMLElement && control.isContentEditable) {
+                        control.focus();
+                        control.textContent = value;
+                        dispatch(control);
+                        return matches(currentValue(control), value, false);
+                    }
+                }
+                return false;
+            }
+            function setSelectField(fieldLabel, value, exact) {
+                const controls = Array.from(document.querySelectorAll('select'));
+                for (const control of controls) {
+                    if (!(control instanceof HTMLSelectElement) || !visible(control))
+                        continue;
+                    if (!matches(explicitLabelText(control), fieldLabel, exact))
+                        continue;
+                    const expected = normalize(value);
+                    const option = Array.from(control.options).find((candidate) => {
+                        const label = normalize(candidate.textContent);
+                        const rawValue = normalize(candidate.value);
+                        return exact ? label === expected || rawValue === expected : label.includes(expected) || rawValue.includes(expected);
+                    });
+                    if (!option)
+                        return false;
+                    control.value = option.value;
+                    dispatch(control);
+                    return matches(currentValue(control), value, false) || normalize(control.value) === expected;
+                }
+                return false;
+            }
+            function groupPrompt(container) {
+                const legend = container.querySelector('legend')?.textContent?.trim();
+                if (legend)
+                    return legend;
+                const explicit = explicitLabelText(container);
+                if (explicit)
+                    return explicit;
+                const textLike = container.querySelector('h1, h2, h3, h4, h5, h6, p, span, div');
+                const text = textLike?.textContent?.trim();
+                return text || undefined;
+            }
+            function choiceLabel(el) {
+                if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+                    return explicitLabelText(el);
+                }
+                if (el instanceof HTMLLabelElement)
+                    return el.textContent?.trim() || undefined;
+                const explicit = explicitLabelText(el);
+                if (explicit)
+                    return explicit;
+                return el.textContent?.trim() || undefined;
+            }
+            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));
+                for (const group of groups) {
+                    const options = Array.from(group.querySelectorAll('input[type="radio"], input[type="checkbox"], [role="radio"], [role="checkbox"], label, button'));
+                    for (const option of options) {
+                        if (!(option instanceof Element) || !visible(option))
+                            continue;
+                        if (!matches(choiceLabel(option), value, exact))
+                            continue;
+                        if (option instanceof HTMLInputElement) {
+                            if (!option.checked)
+                                option.click();
+                            if (!option.checked) {
+                                option.checked = true;
+                                dispatch(option);
+                            }
+                            return option.checked;
+                        }
+                        if (option instanceof HTMLLabelElement) {
+                            option.click();
+                            const control = option.control;
+                            if (control instanceof HTMLInputElement)
+                                return control.checked;
+                            return true;
+                        }
+                        option.click();
+                        return true;
+                    }
+                }
+                return false;
+            }
+            function setToggle(label, checked, exact, controlType) {
+                const inputs = Array.from(document.querySelectorAll('input[type="checkbox"], input[type="radio"]'));
+                for (const input of inputs) {
+                    if (!(input instanceof HTMLInputElement) || !visible(input))
+                        continue;
+                    if (controlType && input.type !== controlType)
+                        continue;
+                    if (!matches(explicitLabelText(input), label, exact))
+                        continue;
+                    if (input.checked !== checked) {
+                        input.click();
+                        if (input.checked !== checked) {
+                            input.checked = checked;
+                            dispatch(input);
+                        }
+                    }
+                    return input.checked === checked;
+                }
+                const labels = Array.from(document.querySelectorAll('label'));
+                for (const labelEl of labels) {
+                    if (!(labelEl instanceof HTMLLabelElement) || !visible(labelEl))
+                        continue;
+                    if (!matches(labelEl.textContent, label, exact))
+                        continue;
+                    const control = labelEl.control;
+                    if (!(control instanceof HTMLInputElement))
+                        continue;
+                    if (controlType && control.type !== controlType)
+                        continue;
+                    if (control.checked !== checked)
+                        labelEl.click();
+                    if (control.checked !== checked) {
+                        control.checked = checked;
+                        dispatch(control);
+                    }
+                    return control.checked === checked;
+                }
+                return false;
+            }
+            function setAutoField(fieldLabel, value, exact) {
+                if (typeof value === 'boolean') {
+                    if (setGroupedChoice(fieldLabel, value ? 'Yes' : 'No', exact))
+                        return true;
+                    if (setToggle(fieldLabel, value, exact, null))
+                        return true;
+                    return setSelectField(fieldLabel, value ? 'Yes' : 'No', exact);
+                }
+                if (prefersGroupedChoice(value) && setGroupedChoice(fieldLabel, value, exact))
+                    return true;
+                if (setSelectField(fieldLabel, value, exact))
+                    return true;
+                if (setTextField(fieldLabel, value, exact))
+                    return true;
+                return setGroupedChoice(fieldLabel, value, exact);
+            }
+            return items.map((field) => {
+                if (field.kind === 'auto') {
+                    return { index: field.index, ok: setAutoField(field.fieldLabel, field.value, field.exact) };
+                }
+                if (field.kind === 'text')
+                    return { index: field.index, ok: setTextField(field.fieldLabel, field.value, field.exact) };
+                if (field.kind === 'choice') {
+                    if (field.choiceType === 'group') {
+                        return { index: field.index, ok: setGroupedChoice(field.fieldLabel, field.value, field.exact) };
+                    }
+                    if (field.choiceType === 'listbox') {
+                        return { index: field.index, ok: false };
+                    }
+                    const selected = setSelectField(field.fieldLabel, field.value, field.exact);
+                    if (selected)
+                        return { index: field.index, ok: true };
+                    return { index: field.index, ok: setGroupedChoice(field.fieldLabel, field.value, field.exact) };
+                }
+                return { index: field.index, ok: setToggle(field.label, field.checked, field.exact, field.controlType) };
+            });
+        }, pending).catch(() => []);
+        for (const entry of frameResults) {
+            if (entry?.ok === true)
+                results[entry.index] = true;
+        }
+    }
+    return results;
+}
 export async function setFieldText(page, fieldLabel, value, opts) {
     const exact = opts?.exact ?? false;
-    const locator = await findLabeledEditableField(page, fieldLabel, exact);
+    const locator = await findLabeledEditableField(page, fieldLabel, exact, opts?.cache, opts?.fieldId);
     if (!locator) {
         throw new Error(`setFieldText: no visible editable field matching "${fieldLabel}"`);
     }
@@ -1175,12 +1601,91 @@ async function chooseValueFromLabeledGroup(page, fieldLabel, value, exact) {
     }
     return false;
 }
+async function autoFieldLocatorKind(locator) {
+    try {
+        return await locator.evaluate((el) => {
+            if (el instanceof HTMLSelectElement)
+                return 'select';
+            if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)
+                return 'text';
+            if (el instanceof HTMLElement && el.isContentEditable)
+                return 'text';
+            const role = el.getAttribute('role');
+            if (role === 'combobox' || role === 'listbox')
+                return 'choice';
+            if (el instanceof HTMLButtonElement)
+                return 'choice';
+            if (el.getAttribute('aria-haspopup') === 'listbox')
+                return 'choice';
+            return 'unknown';
+        });
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export async function setAutoFieldValue(page, fieldLabel, value, opts) {
+    const exact = opts?.exact ?? false;
+    if (typeof value === 'boolean') {
+        if (await chooseValueFromLabeledGroup(page, fieldLabel, value ? 'Yes' : 'No', exact))
+            return;
+        await setCheckedControl(page, fieldLabel, { checked: value, exact });
+        return;
+    }
+    if (prefersGroupedChoiceValue(value) && await chooseValueFromLabeledGroup(page, fieldLabel, value, exact)) {
+        return;
+    }
+    const locator = await findLabeledControlInPage(page, fieldLabel, exact, { cache: opts?.cache, fieldId: opts?.fieldId });
+    if (locator) {
+        const kind = await autoFieldLocatorKind(locator);
+        if (kind === 'select') {
+            await setFieldChoice(page, fieldLabel, value, {
+                fieldId: opts?.fieldId,
+                exact,
+                choiceType: 'select',
+                cache: opts?.cache,
+            });
+            return;
+        }
+        if (kind === 'text') {
+            await setFieldText(page, fieldLabel, value, {
+                fieldId: opts?.fieldId,
+                exact,
+                cache: opts?.cache,
+            });
+            return;
+        }
+        if (kind === 'choice') {
+            await setFieldChoice(page, fieldLabel, value, {
+                fieldId: opts?.fieldId,
+                exact,
+                cache: opts?.cache,
+            });
+            return;
+        }
+    }
+    if (await chooseValueFromLabeledGroup(page, fieldLabel, value, exact))
+        return;
+    try {
+        await setFieldText(page, fieldLabel, value, {
+            fieldId: opts?.fieldId,
+            exact,
+            cache: opts?.cache,
+        });
+        return;
+    }
+    catch {
+        await setFieldChoice(page, fieldLabel, value, {
+            fieldId: opts?.fieldId,
+            exact,
+            cache: opts?.cache,
+        });
+    }
+}
 export async function setFieldChoice(page, fieldLabel, value, opts) {
     const exact = opts?.exact ?? false;
-    for (const frame of page.frames()) {
-        const locator = await findLabeledControl(frame, fieldLabel, exact);
-        if (!locator)
-            continue;
+    const locator = await findLabeledControlInPage(page, fieldLabel, exact, { cache: opts?.cache, fieldId: opts?.fieldId });
+    if (locator) {
         await locator.scrollIntoViewIfNeeded();
         if (await setNativeSelectByLabel(locator, value, exact)) {
             const displayed = await locatorDisplayedValues(locator);
@@ -1188,13 +1693,19 @@ export async function setFieldChoice(page, fieldLabel, value, opts) {
                 return;
             throw new Error(`setFieldChoice: selected "${value}" for field "${fieldLabel}" but could not confirm it`);
         }
-        break;
+    }
+    if (opts?.choiceType === 'group') {
+        if (await chooseValueFromLabeledGroup(page, fieldLabel, value, exact))
+            return;
+        throw new Error(`setFieldChoice: no grouped choice matching "${value}" for field "${fieldLabel}"`);
     }
     try {
         await pickListboxOption(page, value, {
+            fieldId: opts?.fieldId,
             fieldLabel,
             exact,
             query: opts?.query,
+            cache: opts?.cache,
         });
         return;
     }
@@ -1204,14 +1715,32 @@ export async function setFieldChoice(page, fieldLabel, value, opts) {
         throw listboxError;
     }
 }
-export async function fillFields(page, fields) {
-    for (const field of fields) {
+export async function fillFields(page, fields, cache = createFillLookupCache()) {
+    const nativeResults = await attemptNativeBatchFill(page, fields);
+    for (let index = 0; index < fields.length; index++) {
+        const field = fields[index];
+        if (nativeResults[index])
+            continue;
+        if (field.kind === 'auto') {
+            await setAutoFieldValue(page, field.fieldLabel, field.value, {
+                fieldId: field.fieldId,
+                exact: field.exact,
+                cache,
+            });
+            continue;
+        }
         if (field.kind === 'text') {
-            await setFieldText(page, field.fieldLabel, field.value, { exact: field.exact });
+            await setFieldText(page, field.fieldLabel, field.value, { fieldId: field.fieldId, exact: field.exact, cache });
             continue;
         }
         if (field.kind === 'choice') {
-            await setFieldChoice(page, field.fieldLabel, field.value, { exact: field.exact, query: field.query });
+            await setFieldChoice(page, field.fieldLabel, field.value, {
+                fieldId: field.fieldId,
+                exact: field.exact,
+                query: field.query,
+                choiceType: field.choiceType,
+                cache,
+            });
             continue;
         }
         if (field.kind === 'toggle') {
@@ -1222,7 +1751,7 @@ export async function fillFields(page, fields) {
             });
             continue;
         }
-        await attachFiles(page, field.paths, { fieldLabel: field.fieldLabel, exact: field.exact });
+        await attachFiles(page, field.paths, { fieldId: field.fieldId, fieldLabel: field.fieldLabel, exact: field.exact, cache });
     }
 }
 export async function selectNativeOption(page, x, y, opt) {
@@ -1278,7 +1807,7 @@ export async function pickListboxOption(page, label, opts) {
     let selectedOptionText;
     let openedHandle;
     if (opts?.fieldLabel) {
-        const opened = await openDropdownControl(page, opts.fieldLabel, exact);
+        const opened = await openDropdownControl(page, opts.fieldLabel, exact, opts.cache, opts.fieldId);
         anchor = { x: opened.anchorX, y: opened.anchorY };
         openedHandle = opened.handle;
         const query = opts.query ?? label;