@nuanu-ai/agentbrowse 0.2.7 → 0.2.8

package/dist/commands/action-acceptance.js

@@ -0,0 +1,1411 @@
+import { getSurface, getTarget } from '../runtime-state.js';
+import { inferComparableValueTypeFromFacts, } from '../control-semantics.js';
+import { buildLocator, resolveLocatorRoot } from './action-fallbacks.js';
+import { resolveSurfaceScopeRoot } from './target-resolution.js';
+import { isLocatorUserActionable } from './user-actionable.js';
+const ACTION_CANDIDATE_PRIORITY = {
+    click: {
+        role: 0,
+        testId: 1,
+        label: 2,
+        text: 3,
+        title: 4,
+        css: 5,
+        xpath: 6,
+    },
+    fill: {
+        css: 0,
+        xpath: 1,
+        testId: 2,
+        label: 3,
+        placeholder: 4,
+        role: 5,
+        text: 6,
+        title: 7,
+    },
+    type: {
+        css: 0,
+        xpath: 1,
+        testId: 2,
+        label: 3,
+        placeholder: 4,
+        role: 5,
+        text: 6,
+        title: 7,
+    },
+    select: {
+        css: 0,
+        xpath: 1,
+        testId: 2,
+        label: 3,
+        role: 4,
+        text: 5,
+        title: 6,
+        placeholder: 7,
+    },
+    press: {
+        css: 0,
+        xpath: 1,
+        testId: 2,
+        label: 3,
+        placeholder: 4,
+        role: 5,
+        text: 6,
+        title: 7,
+    },
+};
+const ACCEPTANCE_POLL_INTERVAL_MS = 100;
+const ACCEPTANCE_POLL_TIMEOUT_MS = 2_500;
+const PAGE_OBSERVATION_SCRIPT = String.raw `(() => {
+  const normalizeText = (value) => (value ?? '').replace(/\s+/g, ' ').trim();
+  const sampleText = (value, limit) => {
+    if (value.length <= limit) {
+      return value;
+    }
+
+    const edge = Math.floor(limit / 3);
+    const middle = Math.max(1, limit - edge * 2);
+    const middleStart = Math.max(0, Math.floor((value.length - middle) / 2));
+    return [
+      value.slice(0, edge),
+      value.slice(middleStart, middleStart + middle),
+      value.slice(-edge),
+    ].join('\n');
+  };
+  const isVisible = (element) => {
+    if (!(element instanceof HTMLElement)) {
+      return false;
+    }
+
+    const style = element.ownerDocument?.defaultView?.getComputedStyle(element);
+    if (!style || style.display === 'none' || style.visibility === 'hidden') {
+      return false;
+    }
+
+    const rect = element.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+  };
+  const interactiveSummary = () => {
+    const selectors = [
+      'button',
+      'a',
+      'input',
+      'textarea',
+      'select',
+      '[role="button"]',
+      '[role="link"]',
+      '[role="option"]',
+      '[role="combobox"]',
+    ];
+    const items = [];
+
+    for (const element of Array.from(document.querySelectorAll(selectors.join(', ')))) {
+      if (!isVisible(element)) {
+        continue;
+      }
+
+      const role = element.getAttribute('role') || element.tagName.toLowerCase();
+      const label =
+        normalizeText(element.getAttribute('aria-label')) ||
+        normalizeText(
+          element instanceof HTMLInputElement ||
+            element instanceof HTMLTextAreaElement ||
+            element instanceof HTMLSelectElement
+            ? element.value
+            : element.textContent
+        ) ||
+        normalizeText(element.getAttribute('title')) ||
+        normalizeText(element.getAttribute('placeholder'));
+      if (!label) {
+        continue;
+      }
+
+      items.push(
+        [
+          role,
+          label.slice(0, 80),
+          element.getAttribute('aria-expanded') || '',
+          element.getAttribute('aria-selected') || '',
+          element.getAttribute('aria-pressed') || '',
+        ].join(':')
+      );
+      if (items.length >= 60) {
+        break;
+      }
+    }
+
+    return items.join('|');
+  };
+  const stableControlSummary = () => {
+    const selectors = [
+      'button',
+      'a[href]',
+      'input',
+      'textarea',
+      'select',
+      '[role="button"]',
+      '[role="link"]',
+      '[role="option"]',
+      '[role="combobox"]',
+      '[role="textbox"]',
+    ];
+    const items = [];
+
+    for (const element of Array.from(document.querySelectorAll(selectors.join(', ')))) {
+      if (!isVisible(element)) {
+        continue;
+      }
+
+      const role = element.getAttribute('role') || element.tagName.toLowerCase();
+      const descriptor =
+        normalizeText(element.getAttribute('aria-label')) ||
+        normalizeText(element.getAttribute('name')) ||
+        normalizeText(element.getAttribute('placeholder')) ||
+        normalizeText(element.getAttribute('title')) ||
+        normalizeText(element.id) ||
+        normalizeText(element.getAttribute('data-testid')) ||
+        normalizeText(element.getAttribute('data-test-id')) ||
+        '';
+      const inputType =
+        element instanceof HTMLInputElement
+          ? normalizeText(element.type || 'text')
+          : element instanceof HTMLSelectElement
+            ? 'select'
+            : element instanceof HTMLTextAreaElement
+              ? 'textarea'
+              : '';
+      const disabled =
+        element instanceof HTMLButtonElement ||
+        element instanceof HTMLInputElement ||
+        element instanceof HTMLSelectElement ||
+        element instanceof HTMLTextAreaElement
+          ? element.disabled
+          : element.getAttribute('aria-disabled') === 'true';
+      const valueState =
+        element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement
+          ? normalizeText(element.value)
+            ? 'value'
+            : 'empty'
+          : '';
+
+      items.push(
+        [
+          role,
+          inputType,
+          descriptor || 'unlabeled',
+          disabled ? 'disabled' : '',
+          valueState,
+          element.getAttribute('aria-expanded') || '',
+          element.getAttribute('aria-selected') || '',
+          element.getAttribute('aria-pressed') || '',
+        ].join(':')
+      );
+      if (items.length >= 80) {
+        break;
+      }
+    }
+
+    return items.join('|');
+  };
+  const dialogSummary = () => {
+    const items = [];
+
+    for (const element of Array.from(
+      document.querySelectorAll('dialog, [role="dialog"], [aria-modal="true"]')
+    )) {
+      if (!isVisible(element)) {
+        continue;
+      }
+
+      const label =
+        normalizeText(element.getAttribute('aria-label')) ||
+        normalizeText(element.getAttribute('data-testid')) ||
+        normalizeText(element.id) ||
+        sampleText(normalizeText(element.textContent || ''), 120);
+      items.push('dialog:' + (label || 'visible'));
+      if (items.length >= 20) {
+        break;
+      }
+    }
+
+    return items.join('|');
+  };
+  const frameSummary = () => {
+    const items = [];
+
+    for (const element of Array.from(document.querySelectorAll('iframe, frame'))) {
+      if (!isVisible(element)) {
+        continue;
+      }
+
+      const title =
+        normalizeText(element.getAttribute('title')) ||
+        normalizeText(element.getAttribute('name'));
+      const rawSrc = element.getAttribute('src') || '';
+      let normalizedSrc = normalizeText(rawSrc);
+      if (rawSrc) {
+        try {
+          const url = new URL(rawSrc, document.baseURI);
+          normalizedSrc = (url.origin + url.pathname).toLowerCase();
+        } catch {
+          normalizedSrc = normalizeText(rawSrc);
+        }
+      }
+
+      items.push(
+        [
+          'frame',
+          title || 'untitled',
+          normalizedSrc.slice(0, 160),
+          element.getAttribute('aria-hidden') || '',
+        ].join(':')
+      );
+      if (items.length >= 20) {
+        break;
+      }
+    }
+
+    return items.join('|');
+  };
+  const headingSummary = () => {
+    const items = [];
+
+    for (const element of Array.from(
+      document.querySelectorAll('h1, h2, h3, legend, [role="heading"]')
+    )) {
+      if (!isVisible(element)) {
+        continue;
+      }
+
+      const label = sampleText(normalizeText(element.textContent || ''), 120);
+      if (!label) {
+        continue;
+      }
+
+      items.push(label);
+      if (items.length >= 20) {
+        break;
+      }
+    }
+
+    return items.join('|');
+  };
+  const processingSummary = () => {
+    const selectors = [
+      '[aria-busy="true"]',
+      '[role="progressbar"]',
+      '[role="status"]',
+      '[data-loading]',
+      '[data-busy]',
+      'button[disabled]',
+      'input[disabled]',
+      'select[disabled]',
+      'textarea[disabled]',
+    ];
+    const items = [];
+
+    for (const element of Array.from(document.querySelectorAll(selectors.join(', ')))) {
+      if (!isVisible(element)) {
+        continue;
+      }
+
+      const role = element.getAttribute('role') || element.tagName.toLowerCase();
+      const label =
+        normalizeText(element.getAttribute('aria-label')) ||
+        normalizeText(element.getAttribute('name')) ||
+        normalizeText(element.getAttribute('title')) ||
+        normalizeText(element.id) ||
+        sampleText(normalizeText(element.textContent || ''), 80);
+      items.push(
+        [
+          role,
+          label || 'processing',
+          element.getAttribute('aria-busy') || '',
+          element.getAttribute('data-loading') || '',
+          element.getAttribute('data-busy') || '',
+        ].join(':')
+      );
+      if (items.length >= 20) {
+        break;
+      }
+    }
+
+    return items.join('|');
+  };
+
+  const body = document.body;
+  if (!body) {
+    return {
+      content: '',
+      structure: '',
+      submitSignals: '',
+    };
+  }
+
+  const attrs = body
+    .getAttributeNames()
+    .sort()
+    .map((name) => name + '=' + (body.getAttribute(name) ?? ''))
+    .join('|');
+  const text = sampleText(normalizeText(body.innerText || ''), 6000);
+  const controls = interactiveSummary();
+  const stableControls = stableControlSummary();
+  const dialogs = dialogSummary();
+  const frames = frameSummary();
+  const headings = headingSummary();
+  const processing = processingSummary();
+  return {
+    content: [attrs, text, controls, dialogs, frames].join('\n'),
+    structure: [attrs, stableControls, dialogs, frames, headings].join('\n'),
+    submitSignals: [processing, dialogs, frames, headings, stableControls].join('\n'),
+  };
+})()`;
+const NO_PROGRESS_PAGE_SIGNALS_SCRIPT = String.raw `(() => {
+  const normalizeText = (value) => (value ?? '').replace(/\s+/g, ' ').trim();
+  const isVisible = (element) => {
+    if (!(element instanceof HTMLElement)) {
+      return false;
+    }
+
+    const style = element.ownerDocument?.defaultView?.getComputedStyle(element);
+    if (!style || style.display === 'none' || style.visibility === 'hidden') {
+      return false;
+    }
+
+    const rect = element.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+  };
+  const uniqueTexts = (elements, limit) => {
+    const values = [];
+    for (const element of elements) {
+      if (!isVisible(element)) {
+        continue;
+      }
+      const text = normalizeText(element.textContent);
+      if (!text || values.includes(text)) {
+        continue;
+      }
+      values.push(text.slice(0, 240));
+      if (values.length >= limit) {
+        break;
+      }
+    }
+    return values;
+  };
+  const labelForField = (element) => {
+    if (!(element instanceof HTMLElement)) {
+      return null;
+    }
+
+    const ariaLabel = normalizeText(element.getAttribute('aria-label'));
+    if (ariaLabel) {
+      return ariaLabel;
+    }
+
+    if (
+      element instanceof HTMLInputElement ||
+      element instanceof HTMLTextAreaElement ||
+      element instanceof HTMLSelectElement
+    ) {
+      if (element.labels?.length) {
+        const labels = Array.from(element.labels)
+          .map((label) => normalizeText(label.textContent))
+          .filter(Boolean);
+        if (labels.length > 0) {
+          return labels.join(' / ');
+        }
+      }
+    }
+
+    const placeholder = normalizeText(element.getAttribute('placeholder'));
+    if (placeholder) {
+      return placeholder;
+    }
+
+    const name = normalizeText(element.getAttribute('name'));
+    if (name) {
+      return name;
+    }
+
+    const id = normalizeText(element.id);
+    if (id) {
+      return id;
+    }
+
+    return normalizeText(element.textContent) || null;
+  };
+  const pushUniqueText = (values, nextValue, limit) => {
+    const text = normalizeText(nextValue);
+    if (!text || values.includes(text)) {
+      return;
+    }
+
+    values.push(text.slice(0, 240));
+    if (values.length > limit) {
+      values.length = limit;
+    }
+  };
+  const VALIDATION_TEXT_RE =
+    /(?:required|invalid|incorrect|too\s+(?:short|long)|must|error|format|please\s+(?:enter|select|choose|fill)|невер|ошиб|обязател|заполн|введите|укажите|выберите|долж|нужно|формат|цифр|символ)/i;
+
+  const fieldSelectors =
+    'input, textarea, select, [role="textbox"], [contenteditable="true"], [aria-invalid="true"]';
+  const relatedHelperTexts = (element) => {
+    if (!(element instanceof HTMLElement)) {
+      return [];
+    }
+
+    const values = [];
+    const describedBy = normalizeText(element.getAttribute('aria-describedby'));
+    if (describedBy) {
+      for (const id of describedBy.split(/\s+/)) {
+        const helper = document.getElementById(id);
+        if (helper && isVisible(helper)) {
+          const helperText = normalizeText(helper.textContent);
+          if (VALIDATION_TEXT_RE.test(helperText)) {
+            pushUniqueText(values, helperText, 4);
+          }
+        }
+      }
+    }
+
+    let anchor = element.parentElement;
+    for (let depth = 0; anchor && depth < 4 && values.length < 4; depth += 1, anchor = anchor.parentElement) {
+      const anchorFieldCount = anchor.querySelectorAll(fieldSelectors).length;
+      if (anchorFieldCount === 0 || anchorFieldCount > 3) {
+        continue;
+      }
+
+      for (const candidate of Array.from(anchor.children)) {
+        if (!(candidate instanceof HTMLElement)) {
+          continue;
+        }
+        if (candidate === element || candidate.contains(element) || element.contains(candidate)) {
+          continue;
+        }
+        if (!isVisible(candidate) || candidate.matches('label, legend')) {
+          continue;
+        }
+        if (candidate.querySelector(fieldSelectors)) {
+          continue;
+        }
+
+        const helperText = normalizeText(candidate.textContent);
+        if (!VALIDATION_TEXT_RE.test(helperText)) {
+          continue;
+        }
+        pushUniqueText(values, helperText, 4);
+      }
+    }
+
+    return values;
+  };
+
+  const invalidFields = [];
+  const messages = [];
+  for (const element of Array.from(document.querySelectorAll(fieldSelectors))) {
+    if (!isVisible(element)) {
+      continue;
+    }
+
+    const ariaInvalid = element.getAttribute('aria-invalid') === 'true';
+    const htmlInvalid =
+      element instanceof HTMLInputElement ||
+      element instanceof HTMLTextAreaElement ||
+      element instanceof HTMLSelectElement
+        ? !element.checkValidity()
+        : false;
+    const helperMessages = relatedHelperTexts(element);
+
+    if (!ariaInvalid && !htmlInvalid && helperMessages.length === 0) {
+      continue;
+    }
+
+    const label = labelForField(element);
+    if (!label || invalidFields.includes(label)) {
+      continue;
+    }
+    invalidFields.push(label.slice(0, 140));
+    for (const helperMessage of helperMessages) {
+      pushUniqueText(messages, helperMessage, 6);
+    }
+    if (invalidFields.length >= 6) {
+      break;
+    }
+  }
+
+  const messageSelectors = [
+    '[role="alert"]',
+    '[aria-live="assertive"]',
+    '[aria-live="polite"]',
+    '.error',
+    '.errors',
+    '.invalid-feedback',
+    '.form-error',
+    '.warning',
+    '[data-testid*="error"]',
+    '[data-testid*="warning"]',
+  ];
+  for (const message of uniqueTexts(Array.from(document.querySelectorAll(messageSelectors.join(', '))), 6)) {
+    pushUniqueText(messages, message, 6);
+  }
+
+  const overlaySelectors = [
+    '[role="alertdialog"]',
+    '[role="dialog"][aria-modal="true"]',
+    '[role="dialog"][data-state="open"]',
+    '[data-state="open"][role="dialog"]',
+  ];
+  const blockingOverlays = uniqueTexts(
+    Array.from(document.querySelectorAll(overlaySelectors.join(', '))),
+    4
+  );
+
+  return {
+    messages,
+    invalidFields,
+    blockingOverlays,
+  };
+})()`;
+function hashText(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
+    }
+    return String(hash);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function rankLocatorCandidates(candidates, action) {
+    const priority = ACTION_CANDIDATE_PRIORITY[action];
+    if (!priority) {
+        return [...candidates];
+    }
+    return [...candidates].sort((left, right) => {
+        const leftPriority = priority[left.strategy] ?? 99;
+        const rightPriority = priority[right.strategy] ?? 99;
+        return leftPriority - rightPriority;
+    });
+}
+export function shouldVerifyObservableProgress(target, action) {
+    if (action === 'fill' || action === 'type') {
+        return false;
+    }
+    return action === 'click' || action === 'press' || action === 'select';
+}
+function isEditableLikeTarget(target) {
+    if (target.controlFamily === 'text-input' ||
+        target.controlFamily === 'select' ||
+        target.controlFamily === 'datepicker') {
+        return true;
+    }
+    const kind = (target.kind ?? '').toLowerCase();
+    const role = (target.semantics?.role ?? '').toLowerCase();
+    return (['input', 'textarea', 'select', 'combobox'].includes(kind) ||
+        ['textbox', 'combobox'].includes(role) ||
+        target.allowedActions.includes('fill') ||
+        target.allowedActions.includes('type') ||
+        target.allowedActions.includes('select'));
+}
+function isSelectableChoiceTarget(target) {
+    const kind = (target.kind ?? '').toLowerCase();
+    const role = (target.semantics?.role ?? '').toLowerCase();
+    return (kind === 'option' ||
+        role === 'option' ||
+        role === 'menuitem' ||
+        role === 'gridcell' ||
+        target.structure?.family === 'structured-grid');
+}
+function acceptancePolicyForAction(target, action) {
+    if (action === 'select') {
+        if (target.controlFamily === 'datepicker') {
+            return 'date-selection';
+        }
+        if (target.controlFamily === 'select') {
+            return 'selection';
+        }
+    }
+    if (action === 'click' || action === 'press') {
+        if (target.controlFamily === 'datepicker') {
+            return isSelectableChoiceTarget(target) ? 'date-selection' : 'disclosure';
+        }
+        if (target.controlFamily === 'select') {
+            return isSelectableChoiceTarget(target) ? 'selection' : 'disclosure';
+        }
+    }
+    const policy = target.acceptancePolicy;
+    if (!policy) {
+        return undefined;
+    }
+    if ((action === 'click' || action === 'press') &&
+        policy === 'value-change' &&
+        isEditableLikeTarget(target)) {
+        return 'generic-click';
+    }
+    return policy;
+}
+function trackedStateKeys(target, action, policy) {
+    const states = target.semantics?.states;
+    const keys = new Set();
+    if (states) {
+        for (const key of ['selected', 'checked', 'expanded', 'pressed', 'current']) {
+            if (Object.prototype.hasOwnProperty.call(states, key)) {
+                keys.add(key);
+            }
+        }
+    }
+    if (policy === 'disclosure' &&
+        (action === 'click' || action === 'press') &&
+        (target.controlFamily === 'select' || target.controlFamily === 'datepicker')) {
+        keys.add('expanded');
+    }
+    return [...keys];
+}
+export async function capturePageObservation(page) {
+    const snapshot = typeof page.evaluate === 'function'
+        ? await page
+            .evaluate(PAGE_OBSERVATION_SCRIPT)
+            .catch(() => '')
+        : '';
+    const contentSnapshot = typeof snapshot === 'string' ? snapshot : (snapshot?.content ?? '');
+    const structureSnapshot = typeof snapshot === 'string' ? '' : (snapshot?.structure ?? '');
+    const submitSignalSnapshot = typeof snapshot === 'string' ? '' : (snapshot?.submitSignals ?? '');
+    return {
+        url: page.url(),
+        title: await page.title().catch(() => ''),
+        contentHash: contentSnapshot ? hashText(contentSnapshot) : null,
+        structureHash: structureSnapshot ? hashText(structureSnapshot) : null,
+        submitSignalHash: submitSignalSnapshot ? hashText(submitSignalSnapshot) : null,
+    };
+}
+async function readLocatorText(locator) {
+    const count = await locator.count().catch(() => 0);
+    if (count === 0) {
+        return null;
+    }
+    const normalizedInnerText = typeof locator.innerText === 'function'
+        ? await locator
+            .innerText()
+            .then((value) => value.replace(/\s+/g, ' ').trim())
+            .catch(() => '')
+        : '';
+    if (normalizedInnerText) {
+        return normalizedInnerText;
+    }
+    const normalizedTextContent = typeof locator.textContent === 'function'
+        ? await locator
+            .textContent()
+            .then((value) => (value ?? '').replace(/\s+/g, ' ').trim())
+            .catch(() => '')
+        : '';
+    return normalizedTextContent || null;
+}
+export async function captureLocatorContextHash(locator) {
+    const candidates = [];
+    if (typeof locator.locator === 'function') {
+        const ancestorContext = locator.locator('xpath=ancestor-or-self::*[' +
+            '@role="option" or @role="row" or @role="gridcell" or @role="listitem" or ' +
+            '@role="tabpanel" or @role="dialog" or @role="listbox" or @role="menu" or @role="grid" or ' +
+            'self::article or self::li or self::tr or self::td or self::section or self::form' +
+            '][1]');
+        candidates.push(typeof ancestorContext.first === 'function' ? ancestorContext.first() : ancestorContext);
+    }
+    candidates.push(typeof locator.first === 'function' ? locator.first() : locator);
+    for (const candidate of candidates) {
+        const text = await readLocatorText(candidate);
+        if (text) {
+            return hashText(text);
+        }
+    }
+    return null;
+}
+async function captureLocatorValue(locator) {
+    const count = await locator.count().catch(() => 0);
+    if (count === 0) {
+        return null;
+    }
+    const inputValue = typeof locator.inputValue === 'function'
+        ? await locator.inputValue().catch(() => '')
+        : '';
+    if (inputValue) {
+        return inputValue;
+    }
+    return readLocatorText(locator);
+}
+async function captureLocatorValueFromCandidates(locators) {
+    let fallbackValue = null;
+    for (const locator of locators) {
+        const value = await captureLocatorValue(locator).catch(() => null);
+        if (value) {
+            return value;
+        }
+        if (value !== null && fallbackValue === null) {
+            fallbackValue = value;
+        }
+    }
+    return fallbackValue;
+}
+async function captureSelectedOptionText(locator) {
+    return locator
+        .evaluate((element) => {
+        if (!(element instanceof HTMLSelectElement)) {
+            return null;
+        }
+        const selected = element.options[element.selectedIndex] ?? null;
+        const text = (selected?.textContent ?? '').replace(/\s+/g, ' ').trim();
+        return text || null;
+    })
+        .catch(() => null);
+}
+function pushComparableValue(values, nextValue) {
+    const raw = (nextValue ?? '').replace(/\s+/g, ' ').trim();
+    const normalized = normalizeComparableValue(raw);
+    if (!normalized) {
+        return;
+    }
+    if (values.some((existing) => normalizeComparableValue(existing) === normalized)) {
+        return;
+    }
+    values.push(raw);
+}
+async function captureLocatorComparableValues(locator) {
+    const count = await locator.count().catch(() => 0);
+    if (count === 0) {
+        return [];
+    }
+    const values = [];
+    pushComparableValue(values, await captureLocatorValue(locator));
+    pushComparableValue(values, await captureSelectedOptionText(locator));
+    return values;
+}
+async function captureLocatorComparableValuesFromCandidates(locators) {
+    const values = [];
+    for (const locator of locators) {
+        const nextValues = await captureLocatorComparableValues(locator).catch(() => []);
+        for (const nextValue of nextValues) {
+            pushComparableValue(values, nextValue);
+        }
+    }
+    return values;
+}
+async function captureLocatorStateFromCandidates(locators, keys) {
+    for (const locator of locators) {
+        const state = await captureLocatorState(locator, keys).catch(() => null);
+        if (state && Object.keys(state).length > 0) {
+            return state;
+        }
+    }
+    return null;
+}
+async function captureLocatorContextHashFromCandidates(locators) {
+    for (const locator of locators) {
+        const hash = await captureLocatorContextHash(locator).catch(() => null);
+        if (hash) {
+            return hash;
+        }
+    }
+    return null;
+}
+function comparableValueTypeForTarget(target) {
+    return inferComparableValueTypeFromFacts({
+        kind: target.kind,
+        role: target.semantics?.role,
+        label: target.label,
+        displayLabel: target.displayLabel,
+        placeholder: target.placeholder,
+        inputName: target.inputName,
+        inputType: target.inputType,
+        autocomplete: target.autocomplete,
+        states: target.semantics?.states,
+        structure: target.structure,
+    });
+}
+function normalizeComparableValue(value, comparableValueType) {
+    const raw = (value ?? '').replace(/\s+/g, ' ').trim();
+    if (!raw) {
+        return '';
+    }
+    if (comparableValueType === 'card-number' ||
+        comparableValueType === 'expiry' ||
+        comparableValueType === 'cvc') {
+        return raw.replace(/\D/g, '');
+    }
+    if (comparableValueType === 'date') {
+        const isoMatch = raw.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+        if (isoMatch) {
+            return `${isoMatch[1]}${isoMatch[2]}${isoMatch[3]}`;
+        }
+        const localizedMatch = raw.match(/^(\d{1,2})[./-](\d{1,2})[./-](\d{2,4})$/);
+        if (localizedMatch) {
+            const [, day = '', month = '', year = ''] = localizedMatch;
+            if (!day || !month || !year) {
+                return raw.replace(/\D/g, '');
+            }
+            const normalizedYear = year.length === 2 ? `20${year}` : year.padStart(4, '0');
+            return `${normalizedYear}${month.padStart(2, '0')}${day.padStart(2, '0')}`;
+        }
+        return raw.replace(/\D/g, '');
+    }
+    if (comparableValueType === 'phone' ||
+        (!comparableValueType && /^\+?[\d\s().-]{5,}$/.test(raw))) {
+        const normalized = raw.replace(/[^\d+]/g, '');
+        return normalized.startsWith('+') ? `+${normalized.slice(1).replace(/\+/g, '')}` : normalized;
+    }
+    return raw.toLowerCase();
+}
+function valuesMatchExpected(expected, actual, comparableValueType) {
+    const normalizedExpected = normalizeComparableValue(expected, comparableValueType);
+    const normalizedActual = normalizeComparableValue(actual, comparableValueType);
+    if (!normalizedExpected || !normalizedActual) {
+        return false;
+    }
+    return normalizedActual === normalizedExpected || normalizedActual.includes(normalizedExpected);
+}
+function valuesMatchAnyExpected(expected, actualValues, comparableValueType) {
+    return actualValues.some((actualValue) => valuesMatchExpected(expected, actualValue, comparableValueType));
+}
+function expectedValueForAcceptance(action, actionValue) {
+    if (action === 'fill' || action === 'type' || action === 'select') {
+        return actionValue ?? null;
+    }
+    return null;
+}
+function recoveryDescendantSelector(target, action) {
+    if (action === 'fill' || action === 'type') {
+        return 'input:not([type="hidden"]), textarea, select, [contenteditable="true"]';
+    }
+    if ((action === 'click' || action === 'press') &&
+        (target.controlFamily === 'text-input' ||
+            target.controlFamily === 'select' ||
+            target.controlFamily === 'datepicker')) {
+        return 'input:not([type="hidden"]), textarea, select, [contenteditable="true"], [role="textbox"], [role="combobox"]';
+    }
+    return null;
+}
+async function prepareReadLocator(locator, target, action) {
+    const visible = await isLocatorUserActionable(locator);
+    if (!visible) {
+        return null;
+    }
+    const descendantSelector = recoveryDescendantSelector(target, action);
+    if (!descendantSelector) {
+        return locator;
+    }
+    const requiresEditableDescendant = action === 'fill' || action === 'type';
+    if (requiresEditableDescendant) {
+        const editable = await locator.isEditable().catch(() => false);
+        if (editable) {
+            return locator;
+        }
+    }
+    const descendants = locator.locator(descendantSelector);
+    const count = await descendants.count().catch(() => 0);
+    const visibleDescendants = [];
+    for (let index = 0; index < count; index += 1) {
+        const descendant = descendants.nth(index);
+        const descendantVisible = await isLocatorUserActionable(descendant);
+        if (!descendantVisible) {
+            continue;
+        }
+        if (requiresEditableDescendant) {
+            const editable = await descendant.isEditable().catch(() => false);
+            if (!editable) {
+                continue;
+            }
+        }
+        visibleDescendants.push(descendant);
+    }
+    if (visibleDescendants.length === 1) {
+        return visibleDescendants[0] ?? null;
+    }
+    return requiresEditableDescendant ? null : locator;
+}
+function valueMeaningfullyChanged(before, after) {
+    const normalizedBefore = normalizeComparableValue(before);
+    const normalizedAfter = normalizeComparableValue(after);
+    if (!normalizedAfter) {
+        return false;
+    }
+    return normalizedBefore !== normalizedAfter;
+}
+export const __testComparableValues = {
+    comparableValueTypeForTarget,
+    normalizeComparableValue,
+    valuesMatchExpected,
+};
+export async function captureLocatorState(locator, keys) {
+    if (keys.length === 0) {
+        return null;
+    }
+    const count = await locator.count().catch(() => 0);
+    if (count === 0) {
+        return { current: 'missing' };
+    }
+    const state = {};
+    const heuristicFlags = await locator
+        .evaluate((element) => {
+        if (!(element instanceof HTMLElement)) {
+            return { selected: null, current: null, pressed: null };
+        }
+        const blob = (element.getAttribute('class') || '').toLowerCase() +
+            ' ' +
+            (element.getAttribute('data-state') || '').toLowerCase() +
+            ' ' +
+            (element.getAttribute('data-status') || '').toLowerCase() +
+            ' ' +
+            Object.values(element.dataset || {})
+                .join(' ')
+                .toLowerCase();
+        const active = /(?:selected|active|current)\b/.test(blob);
+        const pressed = /(?:pressed|active)\b/.test(blob);
+        return {
+            selected: active,
+            current: active,
+            pressed,
+        };
+    })
+        .catch(() => ({ selected: null, current: null, pressed: null }));
+    for (const key of keys) {
+        switch (key) {
+            case 'checked': {
+                if (typeof locator.isChecked === 'function') {
+                    const checked = await locator.isChecked().catch(() => undefined);
+                    if (typeof checked === 'boolean') {
+                        state.checked = checked;
+                        break;
+                    }
+                }
+                const ariaChecked = await locator.getAttribute?.('aria-checked').catch(() => null);
+                if (ariaChecked === 'true')
+                    state.checked = true;
+                else if (ariaChecked === 'false')
+                    state.checked = false;
+                else if (ariaChecked === 'mixed')
+                    state.checked = 'mixed';
+                break;
+            }
+            case 'selected': {
+                const value = await locator.getAttribute?.('aria-selected').catch(() => null);
+                if (value === 'true')
+                    state.selected = true;
+                else if (value === 'false')
+                    state.selected = false;
+                else if (typeof heuristicFlags.selected === 'boolean')
+                    state.selected = heuristicFlags.selected;
+                break;
+            }
+            case 'expanded': {
+                const value = await locator.getAttribute?.('aria-expanded').catch(() => null);
+                if (value === 'true')
+                    state.expanded = true;
+                else if (value === 'false')
+                    state.expanded = false;
+                break;
+            }
+            case 'pressed': {
+                const value = await locator.getAttribute?.('aria-pressed').catch(() => null);
+                if (value === 'true')
+                    state.pressed = true;
+                else if (value === 'false')
+                    state.pressed = false;
+                else if (typeof heuristicFlags.pressed === 'boolean')
+                    state.pressed = heuristicFlags.pressed;
+                break;
+            }
+            case 'current': {
+                const value = await locator.getAttribute?.('aria-current').catch(() => null);
+                if (value === 'true')
+                    state.current = true;
+                else if (typeof value === 'string' && value.length > 0)
+                    state.current = value;
+                else if (typeof heuristicFlags.current === 'boolean')
+                    state.current = heuristicFlags.current;
+                break;
+            }
+            case 'focused': {
+                const focused = await locator
+                    .evaluate((element) => {
+                    if (!(element instanceof HTMLElement)) {
+                        return false;
+                    }
+                    return (element.matches?.(':focus') === true ||
+                        element.ownerDocument?.activeElement === element);
+                })
+                    .catch(() => false);
+                state.focused = focused;
+                break;
+            }
+        }
+    }
+    return Object.keys(state).length > 0 ? state : null;
+}
+export function locatorStateChanged(before, after) {
+    if (!before && !after) {
+        return false;
+    }
+    if (!before) {
+        return Boolean(after && Object.keys(after).length > 0);
+    }
+    if (!after) {
+        return Object.keys(before).length > 0;
+    }
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+    for (const key of keys) {
+        if (before[key] !== after[key]) {
+            return true;
+        }
+    }
+    return false;
+}
+export function pageObservationChanged(before, after) {
+    if (!before || !after) {
+        return false;
+    }
+    if (before.url !== after.url || before.title !== after.title) {
+        return true;
+    }
+    if (before.contentHash && after.contentHash && before.contentHash !== after.contentHash) {
+        return true;
+    }
+    return false;
+}
+export function submitObservationChanged(before, after) {
+    if (!before || !after) {
+        return false;
+    }
+    if (before.url !== after.url || before.title !== after.title) {
+        return true;
+    }
+    if (before.structureHash &&
+        after.structureHash &&
+        before.structureHash !== after.structureHash) {
+        return true;
+    }
+    return false;
+}
+export async function diagnoseNoObservableProgress(page, locator) {
+    const targetState = await locator
+        .evaluate((element) => {
+        if (!(element instanceof HTMLElement)) {
+            return {};
+        }
+        const readonly = element.hasAttribute('readonly') ||
+            element.getAttribute('aria-readonly') === 'true' ||
+            ('readOnly' in element &&
+                typeof element.readOnly === 'boolean' &&
+                element.readOnly);
+        return {
+            disabled: Boolean(element.disabled),
+            ariaDisabled: element.getAttribute('aria-disabled') === 'true',
+            readonly,
+            centerHitSelf: (() => {
+                const rect = element.getBoundingClientRect();
+                if (rect.width <= 0 || rect.height <= 0) {
+                    return false;
+                }
+                const centerX = rect.left + rect.width / 2;
+                const centerY = rect.top + rect.height / 2;
+                const hit = element.ownerDocument?.elementFromPoint(centerX, centerY);
+                return Boolean(hit &&
+                    (hit === element ||
+                        element.contains(hit) ||
+                        (hit instanceof HTMLElement && hit.shadowRoot?.contains(element))));
+            })(),
+        };
+    })
+        .catch(() => ({}));
+    const pageSignals = await page
+        .evaluate(NO_PROGRESS_PAGE_SIGNALS_SCRIPT)
+        .catch(() => null);
+    if (!pageSignals || typeof pageSignals !== 'object' || Array.isArray(pageSignals)) {
+        return null;
+    }
+    const messages = Array.isArray(pageSignals.messages)
+        ? pageSignals.messages.filter((value) => typeof value === 'string')
+        : [];
+    const invalidFields = Array.isArray(pageSignals.invalidFields)
+        ? pageSignals.invalidFields.filter((value) => typeof value === 'string')
+        : [];
+    const blockingOverlays = Array.isArray(pageSignals.blockingOverlays)
+        ? pageSignals.blockingOverlays.filter((value) => typeof value === 'string')
+        : [];
+    const rawTargetState = targetState &&
+        typeof targetState === 'object' &&
+        !Array.isArray(targetState)
+        ? targetState
+        : undefined;
+    const normalizedTargetState = rawTargetState
+        ? {
+            disabled: Boolean(rawTargetState.disabled),
+            ariaDisabled: Boolean(rawTargetState.ariaDisabled),
+            readonly: Boolean(rawTargetState.readonly),
+            centerHitSelf: Boolean(rawTargetState.centerHitSelf),
+        }
+        : undefined;
+    const effectiveBlockingOverlays = normalizedTargetState?.centerHitSelf ? [] : blockingOverlays;
+    let kind = 'site-noop';
+    if (messages.length > 0 || invalidFields.length > 0) {
+        kind = 'validation-blocked';
+    }
+    else if (normalizedTargetState?.disabled ||
+        normalizedTargetState?.ariaDisabled ||
+        normalizedTargetState?.readonly) {
+        kind = 'target-blocked';
+    }
+    else if (effectiveBlockingOverlays.length > 0) {
+        kind = 'overlay-blocked';
+    }
+    return {
+        kind,
+        messages,
+        invalidFields,
+        blockingOverlays: effectiveBlockingOverlays,
+        targetState: normalizedTargetState,
+    };
+}
+async function resolveTargetLocatorForRead(page, target, surface, action = 'click') {
+    const surfaceRoot = await resolveSurfaceScopeRoot(page, surface);
+    const baseRoot = resolveLocatorRoot(page, target.framePath ?? surface?.framePath);
+    const defaultRoot = surfaceRoot ?? baseRoot;
+    for (const candidate of rankLocatorCandidates(target.locatorCandidates, action)) {
+        const locatorRoot = candidate.scope === 'root'
+            ? baseRoot
+            : candidate.scope === 'surface'
+                ? surfaceRoot
+                : defaultRoot;
+        if (!locatorRoot) {
+            continue;
+        }
+        const locator = buildLocator(locatorRoot, candidate);
+        if (!locator)
+            continue;
+        const count = await locator.count().catch(() => 0);
+        if (count === 0)
+            continue;
+        const first = locator.first();
+        const prepared = await prepareReadLocator(first, target, action);
+        if (!prepared)
+            continue;
+        return prepared;
+    }
+    const descendantSelector = recoveryDescendantSelector(target, action);
+    if (!surfaceRoot || !descendantSelector) {
+        return null;
+    }
+    const descendants = surfaceRoot.locator(descendantSelector);
+    const descendantCount = await descendants.count().catch(() => 0);
+    const visibleDescendants = [];
+    for (let index = 0; index < descendantCount; index += 1) {
+        const descendant = descendants.nth(index);
+        const visible = await isLocatorUserActionable(descendant);
+        if (!visible) {
+            continue;
+        }
+        if (action === 'fill' || action === 'type') {
+            const editable = await descendant.isEditable().catch(() => false);
+            if (!editable) {
+                continue;
+            }
+        }
+        visibleDescendants.push(descendant);
+    }
+    return visibleDescendants.length === 1 ? (visibleDescendants[0] ?? null) : null;
+}
+export async function createAcceptanceProbe(args) {
+    const { session, page, target, action, actionValue, locator, beforePageObservation } = args;
+    const policy = acceptancePolicyForAction(target, action);
+    if (!policy) {
+        return null;
+    }
+    const trackedStates = shouldVerifyObservableProgress(target, action)
+        ? trackedStateKeys(target, action, policy)
+        : [];
+    if ((action === 'click' || action === 'press') &&
+        policy === 'generic-click' &&
+        isEditableLikeTarget(target) &&
+        !trackedStates.includes('focused')) {
+        trackedStates.push('focused');
+    }
+    const beforeLocatorObservation = trackedStates.length > 0 ? await captureLocatorState(locator, trackedStates) : null;
+    const beforeContextHash = policy === 'value-change' || policy === 'submit' ? null : await captureLocatorContextHash(locator);
+    const surface = target.surfaceRef ? getSurface(session, target.surfaceRef) : null;
+    const surfaceLocator = surface ? await resolveSurfaceScopeRoot(page, surface) : null;
+    const pageReadLocator = await resolveTargetLocatorForRead(page, target, surface, action);
+    const readLocator = pageReadLocator ?? locator;
+    const readLocators = pageReadLocator && pageReadLocator !== locator ? [locator, pageReadLocator] : [locator];
+    const beforeReadLocatorObservation = trackedStates.length > 0
+        ? await captureLocatorStateFromCandidates([readLocator], trackedStates)
+        : null;
+    const beforeReadContextHash = policy === 'value-change' || policy === 'submit'
+        ? null
+        : await captureLocatorContextHashFromCandidates([readLocator]);
+    const beforeValue = await captureLocatorValueFromCandidates(readLocators);
+    const ownerTarget = target.ownerRef ? getTarget(session, target.ownerRef) : null;
+    const ownerSurface = ownerTarget?.surfaceRef ? getSurface(session, ownerTarget.surfaceRef) : null;
+    const ownerLocator = ownerTarget
+        ? await resolveTargetLocatorForRead(page, ownerTarget, ownerSurface, action)
+        : null;
+    const beforeOwnerValue = ownerLocator && (policy === 'selection' || policy === 'date-selection')
+        ? await captureLocatorValue(ownerLocator)
+        : null;
+    const beforeSurfaceContextHash = surfaceLocator &&
+        target.structure?.family === 'structured-grid' &&
+        (policy === 'selection' || policy === 'date-selection')
+        ? await captureLocatorContextHash(surfaceLocator)
+        : null;
+    const comparableValueType = comparableValueTypeForTarget(target);
+    return {
+        policy,
+        page,
+        target,
+        action,
+        surface,
+        ownerTarget,
+        ownerSurface,
+        beforePage: beforePageObservation,
+        beforeLocator: beforeLocatorObservation,
+        beforeContextHash,
+        beforeReadLocator: beforeReadLocatorObservation,
+        beforeReadContextHash,
+        trackedStateKeys: trackedStates,
+        locator,
+        readLocator,
+        readLocators,
+        surfaceLocator,
+        expectedValue: expectedValueForAcceptance(action, actionValue),
+        beforeValue,
+        comparableValueType,
+        ownerLocator,
+        beforeOwnerValue,
+        beforeSurfaceContextHash,
+    };
+}
+export async function evaluateAcceptanceProbe(probe, afterPageObservation) {
+    const liveReadLocator = (await resolveTargetLocatorForRead(probe.page, probe.target, probe.surface, probe.action).catch(() => null)) ?? probe.readLocator;
+    const liveReadLocators = liveReadLocator && liveReadLocator !== probe.locator
+        ? [probe.locator, liveReadLocator]
+        : [probe.locator];
+    const liveOwnerLocator = probe.ownerTarget
+        ? (await resolveTargetLocatorForRead(probe.page, probe.ownerTarget, probe.ownerSurface, probe.action).catch(() => null)) ?? probe.ownerLocator
+        : null;
+    const liveSurfaceLocator = probe.target.structure?.family === 'structured-grid' && probe.surface
+        ? (await resolveSurfaceScopeRoot(probe.page, probe.surface).catch(() => null)) ??
+            probe.surfaceLocator
+        : probe.surfaceLocator;
+    const afterLocatorObservation = probe.trackedStateKeys.length > 0
+        ? await captureLocatorState(probe.locator, probe.trackedStateKeys)
+        : null;
+    const afterContextHash = probe.policy === 'value-change' || probe.policy === 'submit'
+        ? probe.beforeContextHash
+        : await captureLocatorContextHash(probe.locator);
+    const afterReadLocatorObservation = probe.trackedStateKeys.length > 0
+        ? await captureLocatorStateFromCandidates([liveReadLocator], probe.trackedStateKeys)
+        : null;
+    const afterReadContextHash = probe.policy === 'value-change' || probe.policy === 'submit'
+        ? probe.beforeReadContextHash
+        : await captureLocatorContextHashFromCandidates([liveReadLocator]);
+    const afterValue = await captureLocatorValueFromCandidates(liveReadLocators);
+    const afterOwnerValue = liveOwnerLocator ? await captureLocatorValue(liveOwnerLocator) : null;
+    const afterSurfaceContextHash = liveSurfaceLocator &&
+        probe.target.structure?.family === 'structured-grid' &&
+        (probe.policy === 'selection' || probe.policy === 'date-selection')
+        ? await captureLocatorContextHash(liveSurfaceLocator)
+        : probe.beforeSurfaceContextHash;
+    const targetValueChanged = probe.expectedValue === null && valueMeaningfullyChanged(probe.beforeValue, afterValue);
+    const ownerValueChanged = probe.expectedValue === null && valueMeaningfullyChanged(probe.beforeOwnerValue, afterOwnerValue);
+    const surfaceContextChanged = probe.expectedValue === null &&
+        probe.beforeSurfaceContextHash !== null &&
+        afterSurfaceContextHash !== null &&
+        probe.beforeSurfaceContextHash !== afterSurfaceContextHash;
+    switch (probe.policy) {
+        case 'value-change':
+            return valuesMatchExpected(probe.expectedValue, afterValue, probe.comparableValueType);
+        case 'selection':
+            const afterComparableValues = await captureLocatorComparableValuesFromCandidates(liveReadLocators);
+            const afterOwnerComparableValues = liveOwnerLocator
+                ? await captureLocatorComparableValuesFromCandidates([liveOwnerLocator])
+                : [];
+            if (probe.expectedValue !== null) {
+                return (valuesMatchAnyExpected(probe.expectedValue, afterComparableValues, probe.comparableValueType) ||
+                    valuesMatchAnyExpected(probe.expectedValue, afterOwnerComparableValues, probe.comparableValueType));
+            }
+            return (targetValueChanged ||
+                ownerValueChanged ||
+                surfaceContextChanged ||
+                locatorStateChanged(probe.beforeLocator, afterLocatorObservation) ||
+                locatorStateChanged(probe.beforeReadLocator, afterReadLocatorObservation) ||
+                probe.beforeContextHash !== afterContextHash ||
+                probe.beforeReadContextHash !== afterReadContextHash);
+        case 'toggle':
+            return (locatorStateChanged(probe.beforeLocator, afterLocatorObservation) ||
+                locatorStateChanged(probe.beforeReadLocator, afterReadLocatorObservation));
+        case 'disclosure':
+            return (targetValueChanged ||
+                locatorStateChanged(probe.beforeLocator, afterLocatorObservation) ||
+                locatorStateChanged(probe.beforeReadLocator, afterReadLocatorObservation) ||
+                probe.beforeContextHash !== afterContextHash ||
+                probe.beforeReadContextHash !== afterReadContextHash);
+        case 'date-selection':
+            const afterDateComparableValues = await captureLocatorComparableValuesFromCandidates(liveReadLocators);
+            const afterDateOwnerComparableValues = liveOwnerLocator
+                ? await captureLocatorComparableValuesFromCandidates([liveOwnerLocator])
+                : [];
+            const explicitDateMatched = probe.expectedValue !== null &&
+                (valuesMatchAnyExpected(probe.expectedValue, afterDateComparableValues, probe.comparableValueType) ||
+                    valuesMatchAnyExpected(probe.expectedValue, afterDateOwnerComparableValues, probe.comparableValueType));
+            return (explicitDateMatched ||
+                locatorStateChanged(probe.beforeLocator, afterLocatorObservation) ||
+                locatorStateChanged(probe.beforeReadLocator, afterReadLocatorObservation) ||
+                targetValueChanged ||
+                ownerValueChanged ||
+                surfaceContextChanged ||
+                (probe.expectedValue === null &&
+                    (probe.beforeContextHash !== afterContextHash ||
+                        probe.beforeReadContextHash !== afterReadContextHash)));
+        case 'submit':
+            return submitObservationChanged(probe.beforePage, afterPageObservation);
+        case 'navigation':
+            return (targetValueChanged ||
+                pageObservationChanged(probe.beforePage, afterPageObservation) ||
+                probe.beforeContextHash !== afterContextHash ||
+                probe.beforeReadContextHash !== afterReadContextHash);
+        case 'generic-click':
+            return (targetValueChanged ||
+                locatorStateChanged(probe.beforeLocator, afterLocatorObservation) ||
+                locatorStateChanged(probe.beforeReadLocator, afterReadLocatorObservation) ||
+                probe.beforeContextHash !== afterContextHash ||
+                probe.beforeReadContextHash !== afterReadContextHash ||
+                pageObservationChanged(probe.beforePage, afterPageObservation));
+    }
+    return false;
+}
+export async function waitForAcceptanceProbe(probe, options) {
+    const timeoutMs = options?.timeoutMs ?? ACCEPTANCE_POLL_TIMEOUT_MS;
+    const intervalMs = options?.intervalMs ?? ACCEPTANCE_POLL_INTERVAL_MS;
+    const startedAt = Date.now();
+    let polls = 0;
+    let afterPageObservation = probe.beforePage ? await capturePageObservation(probe.page) : null;
+    while (true) {
+        polls += 1;
+        const accepted = await evaluateAcceptanceProbe(probe, afterPageObservation);
+        if (accepted) {
+            return {
+                accepted: true,
+                afterPageObservation,
+                polls,
+            };
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            return {
+                accepted: false,
+                afterPageObservation,
+                polls,
+            };
+        }
+        await sleep(intervalMs);
+        afterPageObservation = probe.beforePage ? await capturePageObservation(probe.page) : null;
+    }
+}