@letsrunit/playwright 0.18.2 → 0.19.0

package/src/field/composite-slider.ts

@@ -0,0 +1,87 @@
+import type { Locator } from '@playwright/test';
+import type { Loc, SetOptions, Value } from './types';
+
+async function getSliderHandle(el: Locator, options?: SetOptions): Promise<Locator | null> {
+  const byAria = el.locator('[aria-valuenow], [role="slider"]').first();
+  if ((await byAria.count()) > 0) return byAria;
+
+  const focusables = el.locator('[tabindex]');
+  if ((await focusables.count()) > 0) return focusables.first();
+
+  const buttons = el.locator('button');
+  if ((await buttons.count()) > 0) return buttons.first();
+
+  return null;
+}
+
+function toNumber(value: string | null): number | null {
+  if (!value) return null;
+  const n = Number.parseFloat(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+async function getValueFromHandle(handle: Locator, options?: SetOptions): Promise<number | null> {
+  const fromAria = await handle.getAttribute('aria-valuenow', options).catch(() => null);
+  const parsedAria = toNumber(fromAria);
+  if (parsedAria !== null) return parsedAria;
+
+  const fromText = await handle.textContent(options).catch(() => null);
+  return toNumber(fromText);
+}
+
+async function getValueFromContext(el: Locator, options?: SetOptions): Promise<number | null> {
+  const labelled = el.page().getByLabel('result').first();
+  if ((await labelled.count()) > 0) {
+    const text = await labelled.textContent(options).catch(() => null);
+    const parsed = toNumber(text);
+    if (parsed !== null) return parsed;
+  }
+
+  const siblingNumber = await el
+    .evaluate((node) => {
+      const parent = node.parentElement;
+      if (!parent) return null;
+      for (const child of Array.from(parent.children)) {
+        if (child === node) continue;
+        const text = (child.textContent ?? '').trim();
+        if (!text) continue;
+        const n = Number.parseFloat(text);
+        if (Number.isFinite(n)) return n;
+      }
+      return null;
+    }, options)
+    .catch(() => null);
+
+  return typeof siblingNumber === 'number' ? siblingNumber : null;
+}
+
+async function readValue(el: Locator, handle: Locator, options?: SetOptions): Promise<number | null> {
+  const fromHandle = await getValueFromHandle(handle, options);
+  if (fromHandle !== null) return fromHandle;
+  return getValueFromContext(el, options);
+}
+
+export async function setCompositeSlider({ el }: Loc, value: Value, options?: SetOptions): Promise<boolean> {
+  if (typeof value !== 'number') return false;
+
+  const handle = await getSliderHandle(el, options);
+  if (!handle) return false;
+
+  const initial = await readValue(el, handle, options);
+  if (initial === null) return false;
+  if (Math.abs(initial - value) < 0.001) return true;
+
+  await handle.focus(options);
+  const page = el.page();
+  const key = value > initial ? 'ArrowRight' : 'ArrowLeft';
+  const maxPresses = Math.max(1, Math.min(200, Math.abs(Math.round(value - initial)) * 2));
+
+  for (let i = 0; i < maxPresses; i++) {
+    await page.keyboard.press(key);
+    const current = await readValue(el, handle, options);
+    if (current !== null && Math.abs(current - value) < 0.001) return true;
+  }
+
+  const finalValue = await readValue(el, handle, options);
+  return finalValue !== null && Math.abs(finalValue - value) < 0.001;
+}

package/src/field/composite-toggle.ts

@@ -0,0 +1,49 @@
+import type { Locator } from '@playwright/test';
+import type { Loc, SetOptions, Value } from './types';
+
+async function getToggleTarget(el: Locator, options?: SetOptions): Promise<Locator | null> {
+  const candidates = el.locator('button, [role="button"], [role="switch"], [role="checkbox"], [aria-checked], [tabindex]');
+  if ((await candidates.count()) === 0) return null;
+
+  const visible = candidates.filter({ visible: true });
+  if ((await visible.count()) > 0) return visible.first();
+
+  return candidates.first();
+}
+
+async function readToggleState(target: Locator, options?: SetOptions): Promise<boolean | null> {
+  const ariaChecked = await target.getAttribute('aria-checked', options).catch(() => null);
+  if (ariaChecked === 'true') return true;
+  if (ariaChecked === 'false') return false;
+
+  const checked = await target.getAttribute('checked', options).catch(() => null);
+  if (checked !== null) return checked !== 'false';
+
+  const className = await target.getAttribute('class', options).catch(() => null);
+  if (className) {
+    const lower = className.toLowerCase();
+    if (/(^|\s|-)checked(\s|$|-)/.test(lower)) return true;
+    if (/(^|\s|-)unchecked(\s|$|-)/.test(lower)) return false;
+    if (/switch/.test(lower)) return /checked/.test(lower);
+  }
+
+  return null;
+}
+
+export async function setCompositeToggle({ el }: Loc, value: Value, options?: SetOptions): Promise<boolean> {
+  if (typeof value !== 'boolean' && value !== null) return false;
+
+  const target = await getToggleTarget(el, options);
+  if (!target) return false;
+
+  const initial = await readToggleState(target, options);
+  if (initial === null) return false;
+
+  const desired = Boolean(value);
+  if (initial !== desired) {
+    await target.click(options);
+  }
+
+  const next = await readToggleState(target, options);
+  return next === desired;
+}

package/src/field/date-group.ts

@@ -25,35 +25,40 @@ async function getCandidateLocs(el: Locator, options?: SetOptions): Promise<Cand
 
   return Promise.all(
     candidates.map(async (c) => {
-      const info = await c.evaluate(/* v8 ignore start */ (node) => {
-        const e = node as HTMLInputElement | HTMLSelectElement;
-        const attrs: Record<string, string> = {};
-        for (const attr of e.attributes) {
-          attrs[attr.name] = attr.value;
-        }
-
-        let options: { value: string; text: string }[] = [];
-        if (e.tagName.toLowerCase() === 'select') {
-          options = Array.from((e as HTMLSelectElement).options).map((o) => ({
-            value: o.value,
-            text: o.text,
-          }));
-        }
-
-        return {
-          tag: e.tagName.toLowerCase(),
-          type: e.getAttribute('type'),
-          name: e.getAttribute('name'),
-          id: e.getAttribute('id'),
-          ariaLabel: e.getAttribute('aria-label'),
-          placeholder: e.getAttribute('placeholder'),
-          min: e.getAttribute('min'),
-          max: e.getAttribute('max'),
-          inputMode: e.getAttribute('inputmode'),
-          attrs,
-          options,
-        }; /* v8 ignore stop */
-      }, options);
+      const info = await c.evaluate(
+        /* v8 ignore start — callback runs in browser context, not Node */
+        (node) => {
+          const e = node as HTMLInputElement | HTMLSelectElement;
+          const attrs: Record<string, string> = {};
+          for (const attr of e.attributes) {
+            attrs[attr.name] = attr.value;
+          }
+
+          let options: { value: string; text: string }[] = [];
+          if (e.tagName.toLowerCase() === 'select') {
+            options = Array.from((e as HTMLSelectElement).options).map((o) => ({
+              value: o.value,
+              text: o.text,
+            }));
+          }
+
+          return {
+            tag: e.tagName.toLowerCase(),
+            type: e.getAttribute('type'),
+            name: e.getAttribute('name'),
+            id: e.getAttribute('id'),
+            ariaLabel: e.getAttribute('aria-label'),
+            placeholder: e.getAttribute('placeholder'),
+            min: e.getAttribute('min'),
+            max: e.getAttribute('max'),
+            inputMode: e.getAttribute('inputmode'),
+            attrs,
+            options,
+          };
+        },
+        /* v8 ignore stop */
+        options,
+      );
       return { el: c, ...info };
     }),
   );
@@ -100,54 +105,79 @@ async function behavioralProbe(candidateLocs: CandidateInfo[], scores: Score[],
     for (let i = 0; i < candidateLocs.length; i++) {
       const loc = candidateLocs[i];
       if (loc.tag === 'input') {
-        const can_be_day = await loc.el.evaluate(/* v8 ignore start */ (node) => {
-          const e = node as HTMLInputElement;
-          const old = e.value;
-          e.value = '31';
-          const valid = e.checkValidity();
-          e.value = old;
-          return valid; /* v8 ignore stop */
-        }, options);
+        const can_be_day = await loc.el.evaluate(
+          /* v8 ignore start — callback runs in browser context, not Node */
+          (node) => {
+            const e = node as HTMLInputElement;
+            const old = e.value;
+            e.value = '31';
+            const valid = e.checkValidity();
+            e.value = old;
+            return valid;
+          },
+          /* v8 ignore stop */
+          options,
+        );
         if (can_be_day) scores[i].day += 1;
 
-        const cannot_be_day = await loc.el.evaluate(/* v8 ignore start */ (node) => {
-          const e = node as HTMLInputElement;
-          const old = e.value;
-          e.value = '32';
-          const valid = !e.checkValidity();
-          e.value = old;
-          return valid; /* v8 ignore stop */
-        }, options);
+        const cannot_be_day = await loc.el.evaluate(
+          /* v8 ignore start — callback runs in browser context, not Node */
+          (node) => {
+            const e = node as HTMLInputElement;
+            const old = e.value;
+            e.value = '32';
+            const valid = !e.checkValidity();
+            e.value = old;
+            return valid;
+          },
+          /* v8 ignore stop */
+          options,
+        );
         if (cannot_be_day) scores[i].day += 1;
 
-        const can_be_month = await loc.el.evaluate(/* v8 ignore start */ (node) => {
-          const e = node as HTMLInputElement;
-          const old = e.value;
-          e.value = '12';
-          const valid = e.checkValidity();
-          e.value = old;
-          return valid; /* v8 ignore stop */
-        }, options);
+        const can_be_month = await loc.el.evaluate(
+          /* v8 ignore start — callback runs in browser context, not Node */
+          (node) => {
+            const e = node as HTMLInputElement;
+            const old = e.value;
+            e.value = '12';
+            const valid = e.checkValidity();
+            e.value = old;
+            return valid;
+          },
+          /* v8 ignore stop */
+          options,
+        );
         if (can_be_month) scores[i].month += 1;
 
-        const cannot_be_month = await loc.el.evaluate(/* v8 ignore start */ (node) => {
-          const e = node as HTMLInputElement;
-          const old = e.value;
-          e.value = '13';
-          const valid = !e.checkValidity();
-          e.value = old;
-          return valid; /* v8 ignore stop */
-        }, options);
+        const cannot_be_month = await loc.el.evaluate(
+          /* v8 ignore start — callback runs in browser context, not Node */
+          (node) => {
+            const e = node as HTMLInputElement;
+            const old = e.value;
+            e.value = '13';
+            const valid = !e.checkValidity();
+            e.value = old;
+            return valid;
+          },
+          /* v8 ignore stop */
+          options,
+        );
         if (cannot_be_month) scores[i].month += 1;
 
-        const can_be_year = await loc.el.evaluate(/* v8 ignore start */ (node) => {
-          const e = node as HTMLInputElement;
-          const old = e.value;
-          e.value = '2024';
-          const valid = e.checkValidity();
-          e.value = old;
-          return valid; /* v8 ignore stop */
-        }, options);
+        const can_be_year = await loc.el.evaluate(
+          /* v8 ignore start — callback runs in browser context, not Node */
+          (node) => {
+            const e = node as HTMLInputElement;
+            const old = e.value;
+            e.value = '2033';
+            const valid = e.checkValidity();
+            e.value = old;
+            return valid;
+          },
+          /* v8 ignore stop */
+          options,
+        );
         if (can_be_year) scores[i].year += 1;
       }
     }

package/src/field/date-text-input.ts

@@ -24,13 +24,13 @@ function buildDateString(date: Date, order: DateOrder, sep: string, pad: boolean
 
 function parseDateString(value: string, order: DateOrder, sep: string): Date | null {
   const raw = value.trim();
-  /* v8 ignore next */ if (!raw) return null;
+  if (!raw) return null;
 
   const tokens = raw.split(sep);
-  /* v8 ignore next */ if (tokens.length !== 3) return null;
+  if (tokens.length !== 3) return null;
 
   const nums = tokens.map((t) => Number(t));
-  /* v8 ignore next */ if (nums.some((n) => !Number.isFinite(n))) return null;
+  if (nums.some((n) => !Number.isFinite(n))) return null;
 
   const map: Record<'day' | 'month' | 'year', number> = { day: 0, month: 0, year: 0 };
   for (let i = 0; i < 3; i++) map[order[i]] = nums[i];
@@ -39,41 +39,57 @@ function parseDateString(value: string, order: DateOrder, sep: string): Date | n
   const month = map.month;
   const day = map.day;
 
-  /* v8 ignore next */ if (month < 1 || month > 12) return null;
-  /* v8 ignore next */ if (day < 1 || day > 31) return null;
+  if (month < 1 || month > 12) return null;
+  if (day < 1 || day > 31) return null;
 
   const dt = new Date(year, month - 1, day);
-  /* v8 ignore next */ if (dt.getFullYear() !== year || dt.getMonth() !== month - 1 || dt.getDate() !== day) return null;
+  if (dt.getFullYear() !== year || dt.getMonth() !== month - 1 || dt.getDate() !== day) return null;
 
   return dt;
 }
 
+function matchesDateLoosely(value: string, date: Date): boolean {
+  const digits = (value.match(/\d+/g) ?? []).map((d) => Number.parseInt(d, 10));
+  if (digits.length < 3) return false;
+
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+
+  return digits.includes(year) && digits.includes(month) && digits.includes(day);
+}
+
 async function inferLocaleAndPattern(el: Locator, options?: SetOptions): Promise<{
   locale: string;
   order: DateOrder;
   sep: string;
 }> {
-  return el.evaluate(/* v8 ignore start */ () => {
-    const lang = document.documentElement.getAttribute('lang') || navigator.language || 'en-US';
-    const dtf = new Intl.DateTimeFormat(lang, { year: 'numeric', month: '2-digit', day: '2-digit' });
-
-    const parts = dtf.formatToParts(new Date(2033, 10, 22)); // 22 Nov 2033, disambiguates day vs month
-    const order: Array<'day' | 'month' | 'year'> = [];
-    let sep = '/';
-
-    for (const p of parts) {
-      if (p.type === 'day' || p.type === 'month' || p.type === 'year') order.push(p.type);
-      if (p.type === 'literal') {
-        const lit = p.value.trim();
-        if (lit) sep = lit;
+  return el.evaluate(
+    /* v8 ignore start — callback runs in browser context, not Node */
+    () => {
+      const lang = document.documentElement.getAttribute('lang') || navigator.language || 'en-US';
+      const dtf = new Intl.DateTimeFormat(lang, { year: 'numeric', month: '2-digit', day: '2-digit' });
+
+      const parts = dtf.formatToParts(new Date(2033, 10, 22)); // 22 Nov 2033, disambiguates day vs month
+      const order: Array<'day' | 'month' | 'year'> = [];
+      let sep = '/';
+
+      for (const p of parts) {
+        if (p.type === 'day' || p.type === 'month' || p.type === 'year') order.push(p.type);
+        if (p.type === 'literal') {
+          const lit = p.value.trim();
+          if (lit) sep = lit;
+        }
       }
-    }
 
-    // Fallback if Intl returns something odd
-    const finalOrder = order.length === 3 ? order : (['day', 'month', 'year'] as const);
+      // Fallback if Intl returns something odd
+      const finalOrder = order.length === 3 ? order : (['day', 'month', 'year'] as const);
 
-    return { locale: lang, order: finalOrder as any, sep }; /* v8 ignore stop */
-  }, options);
+      return { locale: lang, order: finalOrder as any, sep };
+    },
+    /* v8 ignore stop */
+    options,
+  );
 }
 
 async function fillAndReadBack(el: Locator, s: string, options?: SetOptions, nextInput?: Locator): Promise<string> {
@@ -83,11 +99,11 @@ async function fillAndReadBack(el: Locator, s: string, options?: SetOptions, nex
   if (nextInput) {
     await nextInput.focus(options);
   } else {
-    await el.evaluate(/* v8 ignore next */ (el) => el.blur(), options);
+    await el.evaluate((el) => el.blur(), options);
   }
 
   // Some frameworks need a tiny tick.
-  await el.evaluate(/* v8 ignore next */ () => new Promise(requestAnimationFrame));
+  await el.evaluate(() => new Promise(requestAnimationFrame));
 
   return await el.inputValue(options);
 }
@@ -122,8 +138,12 @@ async function setDateValue(
     backParts.length !== dates.length ||
     dates.some((date, i) => {
       const part = backParts[i]?.trim();
+      if (!part) return true;
+
       const parsed = parseDateString(part, order, sep);
-      return !parsed || !sameYMD(parsed, date);
+      if (parsed && sameYMD(parsed, date)) return false;
+
+      return !matchesDateLoosely(part, date);
     });
 
   return !failed;
@@ -199,10 +219,8 @@ async function setInputValue(
   value2?: Date,
   options?: SetOptions,
 ): Promise<boolean> {
-  /* v8 ignore start */
   if (await el.evaluate((el) => (el as HTMLInputElement).readOnly, options)) return false;
   if (el2 && (await el2.evaluate((el) => (el as HTMLInputElement).readOnly, options))) return false;
-  /* v8 ignore stop */
 
   const { combinations, localeSep } = await formatCombinations(el, options);
   let fallbackMatch: [DateOrder, string, boolean] | null = null;
@@ -236,12 +254,12 @@ async function setInputValue(
   if (fallbackMatch) {
     const [order, sep, pad] = fallbackMatch;
     const success = await setDateValue(el, value, order, sep, pad, options, el2);
-    /* v8 ignore start */
+
     if (el2 && value2) {
       const success2 = await setDateValue(el2, value2, order, sep, pad, options);
       return success && success2;
     }
-    /* v8 ignore stop */
+
     return success;
   }
 

package/src/field/index.ts

@@ -1,13 +1,17 @@
 import { chain, isArray, isRange } from '@letsrunit/utils';
 import type { Locator } from '@playwright/test';
 import { pickFieldElement } from '../utils/pick-field-element';
+import { selectAria } from './aria-select';
 import { setCalendarDate } from './calendar';
+import { setCompositeDate } from './composite-date';
+import { setCompositeSelect } from './composite-select';
+import { setCompositeSlider } from './composite-slider';
+import { setCompositeToggle } from './composite-toggle';
 import { setDateGroup } from './date-group';
 import { setDateTextInput } from './date-text-input';
 import { setNativeCheckbox } from './native-checkbox';
 import { setNativeDate } from './native-date';
 import { setNativeInput } from './native-input';
-import { selectAria } from './aria-select';
 import { selectNative } from './native-select';
 import { setOtpValue } from './otp';
 import { setRadioGroup } from './radio-group';
@@ -42,22 +46,27 @@ export async function setFieldValue(el: Locator, value: Value, options?: SetOpti
     setCalendarDate,
     setOtpValue,
     setSliderValue,
+    // generic non-semantic composite controls
+    setCompositeToggle,
+    setCompositeSelect,
+    setCompositeSlider,
+    setCompositeDate,
     // fallback (eg contenteditable or will fail)
     setFallback,
   );
 
-  /* v8 ignore start */
   if ((await el.count()) > 1) {
     el = await pickFieldElement(el);
   }
-  /* v8 ignore stop */
 
   const tag = await el.evaluate((e) => e.tagName.toLowerCase(), options);
-  const type = await el
-    .getAttribute('type', options)
-    .then((s) => s && s.toLowerCase())
-    .catch(/* v8 ignore next */ () => null);
-  const loc = { el, tag, type };
+  const type = (
+    await el.getAttribute('type', options).catch(
+      /* v8 ignore next — attribute might be missing or element might have detached during the check */
+      () => null,
+    )
+  )?.toLowerCase();
+  const loc = { el, tag, type: type || null };
 
   await setValue(loc, value, options);
 }

package/src/field/native-date.ts

@@ -11,10 +11,13 @@ async function setSingleDate({ el, tag, type }: Loc, value: Date, options?: SetO
       'input[type=date], input[type=datetime-local], input[type=month], input[type=week], input[type=time]',
     );
     if ((await inputs.count()) === 1) {
-      const isVisible = await inputs.evaluate(/* v8 ignore next */ (e) => {
-        const style = window.getComputedStyle(e);
-        return style.display !== 'none' && style.visibility !== 'hidden' && e.getAttribute('type') !== 'hidden';
-      });
+      const isVisible = await inputs.evaluate(
+        /* v8 ignore next — callback runs in browser context, not Node */
+        (e) => {
+          const style = window.getComputedStyle(e);
+          return style.display !== 'none' && style.visibility !== 'hidden' && e.getAttribute('type') !== 'hidden';
+        },
+      );
       if (isVisible) {
         target = inputs;
         targetType = (await target.getAttribute('type', options)) || null;

package/src/field/radio-group.ts

@@ -1,5 +1,15 @@
 import type { Loc, SetOptions, Value } from './types';
 
+function caseInsensitiveExact(value: string): RegExp {
+  const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^${escaped}$`, 'i');
+}
+
+function caseInsensitiveLooseExact(value: string): RegExp {
+  const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^\\s*${escaped}\\s*$`, 'i');
+}
+
 export async function setRadioGroup(
   { el }: Loc,
   value: Value,
@@ -24,21 +34,73 @@ export async function setRadioGroup(
     return true;
   }
 
-  // 3. ARIA: exact value attribute
-  const ariaRadio = el.locator(`[role="radio"][value="${stringValue}"]`);
-  if ((await ariaRadio.count()) >= 1) {
-    const item = ariaRadio.first();
-    const ariaChecked = await item.getAttribute('aria-checked', options).catch(/* v8 ignore next */ () => null);
-    if (ariaChecked !== 'true') await item.click(options);
+  // 2b. Native wrappers: label text contains value
+  const wrappedRadio = el.locator('label').filter({ hasText: caseInsensitiveLooseExact(stringValue) }).locator('input[type=radio]');
+  if ((await wrappedRadio.count()) >= 1) {
+    const wrappedLabel = el.locator('label').filter({ hasText: caseInsensitiveLooseExact(stringValue) }).first();
+    await wrappedLabel.click({ ...options, force: true });
     return true;
   }
 
-  // 4. ARIA: by label text
-  const ariaRadioByLabel = el.getByLabel(stringValue, { exact: true }).locator('[role="radio"]');
-  if ((await ariaRadioByLabel.count()) >= 1) {
-    const item = ariaRadioByLabel.first();
-    const ariaChecked = await item.getAttribute('aria-checked', options).catch(/* v8 ignore next */ () => null);
-    if (ariaChecked !== 'true') await item.click(options);
+  const ariaRadios = el.getByRole('radio');
+  const hasAriaRadios = (await ariaRadios.count()) > 0;
+
+  // 3. ARIA: by accessible name
+  if (hasAriaRadios) {
+    const ariaRadioByName = el.getByRole('radio', { name: caseInsensitiveExact(stringValue) });
+    if ((await ariaRadioByName.count()) >= 1) {
+      const item = ariaRadioByName.first();
+      const ariaChecked = await item.getAttribute('aria-checked', options).catch(
+        /* v8 ignore next — attribute might be missing or element might have detached during the check */
+        () => null,
+      );
+      if (ariaChecked !== 'true') await item.click(options);
+
+      const nextAriaChecked = await item.getAttribute('aria-checked', options).catch(
+        /* v8 ignore next — attribute might be missing or element might have detached during the check */
+        () => null,
+      );
+      return nextAriaChecked === 'true';
+    }
+
+    // 4. ARIA: by value-like attributes
+    const ariaRadioByValue = el.locator(
+      `[role="radio"][value="${stringValue}"], ` +
+        `[role="radio"][data-value="${stringValue}"], ` +
+        `[role="radio"][aria-label="${stringValue}"]`,
+    );
+    if ((await ariaRadioByValue.count()) >= 1) {
+      const item = ariaRadioByValue.first();
+      const ariaChecked = await item.getAttribute('aria-checked', options).catch(
+        /* v8 ignore next — attribute might be missing or element might have detached during the check */
+        () => null,
+      );
+      if (ariaChecked !== 'true') await item.click(options);
+
+      const nextAriaChecked = await item.getAttribute('aria-checked', options).catch(
+        /* v8 ignore next — attribute might be missing or element might have detached during the check */
+        () => null,
+      );
+      return nextAriaChecked === 'true';
+    }
+  }
+
+  // 5. Native: click role radio by accessible name as last resort
+  const roleRadio = el.getByRole('radio', { name: caseInsensitiveLooseExact(stringValue) });
+  if ((await roleRadio.count()) >= 1) {
+    await roleRadio.first().click(options);
+    return await roleRadio.first().isChecked(options).catch(() => false);
+  }
+
+  // 6. Fallback: iterate label text manually
+  const labels = el.locator('label');
+  const labelCount = await labels.count();
+  for (let i = 0; i < labelCount; i++) {
+    const label = labels.nth(i);
+    const text = (await label.textContent(options).catch(() => ''))?.replace(/\s+/g, ' ').trim().toLowerCase();
+    if (text !== stringValue.trim().toLowerCase()) continue;
+
+    await label.click({ ...options, force: true });
     return true;
   }