@nuanu-ai/agentbrowse 0.2.7 → 0.2.8

package/dist/commands/observe-inventory.js

@@ -0,0 +1,2837 @@
+import { inferAcceptancePolicyFromFacts, inferAllowedActionsFromFacts, inferAvailabilityFromFacts, inferControlFamilyFromFacts, } from '../control-semantics.js';
+import { LOCATOR_DOM_SIGNATURE_SCRIPT, normalizePageSignature, readLocatorDomSignature, } from './descriptor-validation.js';
+import { TRANSPARENT_ACTIONABLE_CONTROL_HELPER_SCRIPT } from './user-actionable.js';
+const DOM_TARGET_COLLECTION_LIMIT = 320;
+const DOM_SIGNAL_COLLECTION_LIMIT = 24;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeInheritedFramePath(framePath) {
+    return Array.isArray(framePath) && framePath.length > 0 ? [...framePath] : undefined;
+}
+function normalizeInheritedFrameUrl(frameUrl) {
+    return typeof frameUrl === 'string' && frameUrl.trim().length > 0 ? frameUrl : undefined;
+}
+function normalizeInheritedPageSignature(pageSignature) {
+    return typeof pageSignature === 'string' && pageSignature.trim().length > 0
+        ? pageSignature
+        : undefined;
+}
+function applyInheritedDomTargetMetadata(target, options) {
+    const normalizedFramePath = normalizeInheritedFramePath(options?.framePath) ?? normalizeInheritedFramePath(target.framePath);
+    const normalizedFrameUrl = normalizeInheritedFrameUrl(options?.frameUrl) ?? target.frameUrl;
+    const normalizedPageSignature = normalizeInheritedPageSignature(options?.pageSignature) ?? target.pageSignature;
+    return {
+        ...target,
+        framePath: normalizedFramePath,
+        frameUrl: normalizedFrameUrl,
+        pageSignature: normalizedPageSignature,
+    };
+}
+function enrichObservedTargetSemantics(target) {
+    const facts = {
+        kind: target.kind,
+        role: target.role,
+        label: target.label,
+        interactionHint: target.interactionHint,
+        placeholder: target.placeholder,
+        inputName: target.inputName,
+        inputType: target.inputType,
+        autocomplete: target.autocomplete,
+        states: target.states,
+    };
+    const allowedActions = inferAllowedActionsFromFacts(facts);
+    const acceptancePolicy = inferAcceptancePolicyFromFacts(facts, allowedActions);
+    const controlFamily = inferControlFamilyFromFacts(facts, allowedActions);
+    const availability = inferAvailabilityFromFacts(facts.states, undefined, {
+        readonlyInteractive: controlFamily === 'select' ||
+            controlFamily === 'datepicker' ||
+            acceptancePolicy === 'selection' ||
+            acceptancePolicy === 'date-selection',
+    });
+    const capability = allowedActions.length > 0 ? 'actionable' : 'informational';
+    return {
+        ...target,
+        capability,
+        availability,
+        allowedActions,
+        acceptancePolicy,
+    };
+}
+function applyInheritedSignalMetadata(signal, options) {
+    const normalizedFramePath = normalizeInheritedFramePath(options?.framePath) ?? normalizeInheritedFramePath(signal.framePath);
+    const normalizedFrameUrl = normalizeInheritedFrameUrl(options?.frameUrl) ?? signal.frameUrl;
+    return {
+        ...signal,
+        framePath: normalizedFramePath,
+        frameUrl: normalizedFrameUrl,
+    };
+}
+function hasStagehandDomFacts(domFacts) {
+    return Boolean(domFacts &&
+        (domFacts.kind ||
+            domFacts.role ||
+            domFacts.placeholder ||
+            domFacts.value ||
+            domFacts.text ||
+            domFacts.currentValue ||
+            (domFacts.states && Object.keys(domFacts.states).length > 0)));
+}
+function scoreStagehandLocatorSnapshot(snapshot) {
+    let score = 0;
+    if (snapshot.domSignature) {
+        score += 1;
+    }
+    if (snapshot.domFacts?.kind) {
+        score += 1;
+    }
+    if (snapshot.domFacts?.placeholder) {
+        score += 1;
+    }
+    if (snapshot.domFacts?.value) {
+        score += 1;
+    }
+    if (snapshot.domFacts?.text) {
+        score += 1;
+    }
+    if (snapshot.domFacts?.currentValue) {
+        score += 2;
+    }
+    if (snapshot.domFacts?.role) {
+        score += 3;
+    }
+    if (snapshot.domFacts?.states && Object.keys(snapshot.domFacts.states).length > 0) {
+        score += 3;
+    }
+    return score;
+}
+async function readStagehandLocatorSnapshotOnce(locator) {
+    return {
+        domSignature: await readLocatorDomSignature(locator).catch(() => null),
+        domFacts: await readStagehandDomFacts(locator).catch(() => null),
+    };
+}
+export async function readStagehandLocatorSnapshot(locator) {
+    const target = locator.first();
+    let best = await readStagehandLocatorSnapshotOnce(target);
+    if (hasStagehandDomFacts(best.domFacts)) {
+        return best;
+    }
+    await target.waitFor({ state: 'attached', timeout: 1200 }).catch(() => undefined);
+    for (const delayMs of [0, 100, 250]) {
+        if (delayMs > 0) {
+            await sleep(delayMs);
+        }
+        const snapshot = await readStagehandLocatorSnapshotOnce(target);
+        if (scoreStagehandLocatorSnapshot(snapshot) > scoreStagehandLocatorSnapshot(best)) {
+            best = snapshot;
+        }
+        if (hasStagehandDomFacts(snapshot.domFacts)) {
+            return snapshot;
+        }
+    }
+    return best;
+}
+const STAGEHAND_DOM_FACTS_SCRIPT = String.raw `
+  if (!(element instanceof HTMLElement)) {
+    return null;
+  }
+
+  const normalizeText = (value) => (value ?? '').replace(/\s+/g, ' ').trim();
+  const isVisible = (candidate) => {
+    if (!(candidate instanceof HTMLElement)) {
+      return false;
+    }
+    const style = candidate.ownerDocument?.defaultView?.getComputedStyle(candidate);
+    if (!style || style.display === 'none' || style.visibility === 'hidden') {
+      return false;
+    }
+    const rect = candidate.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+  };
+
+  const inputLike = element;
+  const disabledProperty =
+    typeof inputLike.disabled === 'boolean' ? inputLike.disabled : false;
+  const readonlyProperty =
+    'readOnly' in inputLike && typeof inputLike.readOnly === 'boolean' ? inputLike.readOnly : false;
+  const disabled =
+    element.getAttribute('aria-disabled') === 'true' || Boolean(disabledProperty);
+  const readonly =
+    element.hasAttribute('readonly') ||
+    element.getAttribute('aria-readonly') === 'true' ||
+    Boolean(readonlyProperty);
+  const expandedValue = element.getAttribute('aria-expanded');
+  const selectedValue = element.getAttribute('aria-selected');
+  const checkedValue = element.getAttribute('aria-checked');
+  const pressedValue = element.getAttribute('aria-pressed');
+  const expanded =
+    expandedValue === 'true' ? true : expandedValue === 'false' ? false : undefined;
+  const selected =
+    selectedValue === 'true' ? true : selectedValue === 'false' ? false : undefined;
+  const checked =
+    checkedValue === 'true' ? true : checkedValue === 'false' ? false : undefined;
+  const pressed =
+    pressedValue === 'true' ? true : pressedValue === 'false' ? false : undefined;
+  const current =
+    element.getAttribute('aria-current') ??
+    (document.activeElement === element ? true : undefined);
+  const states = {};
+  const directValue =
+    'value' in inputLike && typeof inputLike.value === 'string'
+      ? normalizeText(inputLike.value)
+      : undefined;
+  const directText = normalizeText(element.innerText || element.textContent || '');
+  let currentValue =
+    directValue ||
+    (element.tagName.toLowerCase() === 'input' || element.tagName.toLowerCase() === 'textarea'
+      ? undefined
+      : directText || undefined);
+
+  const popupBacked =
+    element.getAttribute('role') === 'combobox' ||
+    element.hasAttribute('aria-haspopup') ||
+    element.hasAttribute('aria-controls') ||
+    readonly;
+  if (!currentValue && popupBacked && element.parentElement) {
+    const siblingValues = Array.from(element.parentElement.children)
+      .filter((candidate) => candidate !== element)
+      .filter((candidate) => isVisible(candidate))
+      .filter((candidate) => {
+        const tag = candidate.tagName.toLowerCase();
+        if (tag === 'label' || tag === 'legend') {
+          return false;
+        }
+        const role = candidate.getAttribute('role') || '';
+        return (
+          role === 'listbox' ||
+          role === 'button' ||
+          role === 'option' ||
+          candidate.hasAttribute('aria-selected') ||
+          candidate.hasAttribute('aria-current')
+        );
+      })
+      .map((candidate) => normalizeText(candidate.innerText || candidate.textContent || ''))
+      .filter(
+        (value, index, all) =>
+          Boolean(value) && value.length <= 40 && all.indexOf(value) === index
+      );
+    if (siblingValues.length === 1) {
+      currentValue = siblingValues[0];
+    }
+  }
+
+  if (expanded !== undefined) states.expanded = expanded;
+  if (selected !== undefined) states.selected = selected;
+  if (checked !== undefined) states.checked = checked;
+  if (pressed !== undefined) states.pressed = pressed;
+  if (current !== undefined) states.current = current;
+  if (readonly) states.readonly = true;
+  if (disabled) states.disabled = true;
+  if (element.getAttribute('aria-disabled') === 'true') states.ariaDisabled = true;
+
+  return {
+    kind: element.tagName.toLowerCase(),
+    role: element.getAttribute('role') || undefined,
+    placeholder: element.getAttribute('placeholder') || undefined,
+    inputName: element.getAttribute('name') || undefined,
+    inputType: element.getAttribute('type') || undefined,
+    autocomplete: element.getAttribute('autocomplete') || undefined,
+    value: directValue || undefined,
+    text: directText || undefined,
+    currentValue: currentValue || undefined,
+    states: Object.keys(states).length > 0 ? states : undefined,
+  };
+`;
+function readStagehandDomFactsInBrowser(element) {
+    return Function('element', STAGEHAND_DOM_FACTS_SCRIPT)(element);
+}
+async function readStagehandDomFacts(locator) {
+    return locator
+        .evaluate((element, source) => Function('element', source)(element), STAGEHAND_DOM_FACTS_SCRIPT)
+        .catch(() => null);
+}
+export function normalizeStagehandSelector(selector) {
+    if (!selector.startsWith('xpath=')) {
+        return { selector };
+    }
+    let remaining = selector.slice('xpath='.length).trim();
+    const framePath = [];
+    const frameBoundaryPattern = /^(.*?\/iframe\[\d+\])\/html\[1\]\/body\[1\](\/.*)$/;
+    while (true) {
+        const boundary = remaining.match(frameBoundaryPattern);
+        if (!boundary) {
+            break;
+        }
+        framePath.push(`xpath=${boundary[1]}`);
+        remaining = `/html[1]/body[1]${boundary[2]}`;
+    }
+    return framePath.length > 0
+        ? {
+            selector: `xpath=${remaining}`,
+            framePath,
+        }
+        : { selector };
+}
+async function collectDomTargetsFromDocument(context, options) {
+    const includeActivationAffordances = options?.includeActivationAffordances === true;
+    const inheritedFramePath = JSON.stringify(options?.framePath ?? []);
+    const inheritedFrameUrl = JSON.stringify(options?.frameUrl ?? '');
+    const inheritedPageSignature = JSON.stringify(options?.pageSignature ?? '');
+    const observedTargets = await context.evaluate(String.raw `(() => {
+    const includeActivationAffordances = ${includeActivationAffordances ? 'true' : 'false'};
+    const inheritedFramePath = ${inheritedFramePath};
+    const inheritedFrameUrl = ${inheritedFrameUrl};
+    const inheritedPageSignature = ${inheritedPageSignature};
+    const domSignatureOf = (element) => {
+      ${LOCATOR_DOM_SIGNATURE_SCRIPT}
+    };
+    const selector =
+      'button, a[href], input:not([type="hidden"]), textarea, select, [role="button"], [role="link"], [role="textbox"], [role="combobox"], [role="option"], [role="gridcell"], [contenteditable="true"], [tabindex]:not([tabindex="-1"])';
+    const contextSelector =
+      'main, aside, section, form, article, nav, [role="dialog"], [role="listbox"], [role="menu"], [role="grid"], [role="region"], [role="tabpanel"]';
+    const collectionSelector =
+      'ul, ol, table, tbody, [role="list"], [role="listbox"], [role="menu"], [role="grid"], [role="tablist"], [role="radiogroup"]';
+    const itemSelector =
+      'li, tr, td, article, [role="option"], [role="listitem"], [role="row"], [role="gridcell"], [role="tab"], [role="menuitem"], [role="radio"]';
+    const headingSelector = 'h1, h2, h3, h4, h5, h6, [role="heading"], legend';
+    const collectorElementLimit = ${DOM_TARGET_COLLECTION_LIMIT};
+    const collectorOutputLimit = 180;
+
+    const cssEscape = (value) =>
+      typeof CSS !== 'undefined' && typeof CSS.escape === 'function'
+        ? CSS.escape(value)
+        : value.replace(/["\\]/g, '\\$&');
+
+    const ownerWindowOf = (node) => node?.ownerDocument?.defaultView || window;
+    const isHTMLElementNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.HTMLElement);
+    };
+    const isHTMLInputNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.HTMLInputElement);
+    };
+    const isHTMLLabelNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.HTMLLabelElement);
+    };
+    const isHTMLTextAreaNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.HTMLTextAreaElement);
+    };
+    const isHTMLSelectNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.HTMLSelectElement);
+    };
+    const isHTMLIFrameNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.HTMLIFrameElement);
+    };
+    const isShadowRootNode = (value) => {
+      const view = ownerWindowOf(value);
+      return Boolean(view && value instanceof view.ShadowRoot);
+    };
+    const composedParentElement = (element) => {
+      if (!isHTMLElementNode(element)) return undefined;
+      if (element.parentElement) return element.parentElement;
+      const root = element.getRootNode?.();
+      if (isShadowRootNode(root) && isHTMLElementNode(root.host)) {
+        return root.host;
+      }
+      return undefined;
+    };
+    const composedClosest = (element, selectorValue) => {
+      let current = element;
+
+      while (isHTMLElementNode(current)) {
+        const direct = current.closest?.(selectorValue);
+        if (isHTMLElementNode(direct)) {
+          return direct;
+        }
+        current = composedParentElement(current);
+      }
+
+      return undefined;
+    };
+    const associatedLabelControlOf = (element) => {
+      if (!isHTMLLabelNode(element)) return undefined;
+
+      const directControl = element.control;
+      if (isHTMLElementNode(directControl)) {
+        return directControl;
+      }
+
+      const nestedControl = element.querySelector?.('input, select, textarea');
+      return isHTMLElementNode(nestedControl) ? nestedControl : undefined;
+    };
+    const labelBackedChoiceControlOf = (element) => {
+      const control = associatedLabelControlOf(element);
+      if (!isHTMLInputNode(control)) return undefined;
+
+      const type = (control.type || '').toLowerCase();
+      if (type === 'radio' || type === 'checkbox') {
+        return control;
+      }
+
+      return undefined;
+    };
+    const collectInteractiveElements = (
+      root,
+      limit = collectorElementLimit,
+      acc = [],
+      seen = new Set()
+    ) => {
+      if (!root?.querySelectorAll || acc.length >= limit) {
+        return acc;
+      }
+
+      const matches = Array.from(root.querySelectorAll(selector)).concat(
+        Array.from(root.querySelectorAll('label')).filter((candidate) =>
+          isHTMLElementNode(candidate) && Boolean(labelBackedChoiceControlOf(candidate))
+        )
+      );
+      for (const candidate of matches) {
+        if (acc.length >= limit) break;
+        if (!isHTMLElementNode(candidate) || seen.has(candidate)) continue;
+        seen.add(candidate);
+        acc.push(candidate);
+      }
+
+      const descendants = Array.from(root.querySelectorAll('*'));
+      for (const candidate of descendants) {
+        if (acc.length >= limit) break;
+        if (!isHTMLElementNode(candidate) || !candidate.shadowRoot) continue;
+        collectInteractiveElements(candidate.shadowRoot, limit, acc, seen);
+      }
+
+      return acc;
+    };
+
+    const isVisible = (element) => {
+      ${TRANSPARENT_ACTIONABLE_CONTROL_HELPER_SCRIPT}
+      const style = window.getComputedStyle(element);
+      if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        style.visibility === 'collapse'
+      ) {
+        return false;
+      }
+      const rect = element.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) {
+        return false;
+      }
+      if (style.opacity === '0') {
+        return isTransparentActionableControl(element);
+      }
+      return true;
+    };
+
+    const normalizeDescriptorText = (value) => (value || '').replace(/\s+/g, ' ').trim();
+
+    const imageAltTextOf = (element) => {
+      if (!isHTMLElementNode(element)) return undefined;
+
+      const seen = new Set();
+      const values = [];
+      const push = (value) => {
+        const normalized = normalizeDescriptorText(value);
+        if (!normalized || normalized.length < 2 || normalized.length > 80) {
+          return;
+        }
+        const key = normalized.toLowerCase();
+        if (seen.has(key)) return;
+        seen.add(key);
+        values.push(normalized);
+      };
+
+      if (element.tagName.toLowerCase() === 'img') {
+        push(element.getAttribute('alt'));
+      }
+
+      for (const candidate of Array.from(element.querySelectorAll('img[alt]')).slice(0, 6)) {
+        if (!isHTMLElementNode(candidate)) continue;
+        push(candidate.getAttribute('alt'));
+      }
+
+      return values.length > 0 ? values.join(' ') : undefined;
+    };
+
+    const textOf = (element) => {
+      const tag = element?.tagName?.toLowerCase?.();
+      if (tag && ['script', 'style', 'noscript', 'template'].includes(tag)) {
+        return undefined;
+      }
+      const buttonLikeText =
+        isHTMLInputNode(element) &&
+        ['button', 'submit', 'reset'].includes((element.getAttribute('type') || 'text').trim().toLowerCase())
+          ? normalizeDescriptorText(element.value || element.getAttribute('value') || '')
+          : undefined;
+      if (buttonLikeText) {
+        return buttonLikeText;
+      }
+      const textValue = normalizeDescriptorText(element?.innerText || element?.textContent || '');
+      const altValue = imageAltTextOf(element);
+      if (!textValue && !altValue) {
+        return undefined;
+      }
+      if (!textValue) {
+        return altValue;
+      }
+      if (!altValue || textValue.toLowerCase().includes(altValue.toLowerCase())) {
+        return textValue;
+      }
+      return (altValue + ' ' + textValue).trim();
+    };
+
+    const isMeaningfulLabel = (value) => {
+      const normalized = (value || '').replace(/\s+/g, ' ').trim();
+      return Boolean(normalized) && normalized !== '[object Object]';
+    };
+
+    const inputTypeOf = (element) => {
+      if (!isHTMLInputNode(element)) {
+        return '';
+      }
+      return (element.getAttribute('type') || 'text').trim().toLowerCase();
+    };
+
+    const isButtonLikeInput = (element) => {
+      return isHTMLInputNode(element) && ['button', 'submit', 'reset'].includes(inputTypeOf(element));
+    };
+
+    const LOOSE_ACTION_TEXT_RE =
+      /^(?:pay|buy|continue|submit|search|book|reserve|checkout|next|done|оплат|куп|продолж|дальше|поиск|заброни)/i;
+
+    const tokenizeSemanticText = (value) => {
+      const normalized = (value || '')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[^a-zA-Z0-9\u0400-\u04FF]+/g, ' ')
+        .toLowerCase()
+        .trim();
+      if (!normalized) return [];
+      return normalized
+        .split(/\s+/)
+        .filter((token) => token.length >= 2 && token !== 'input' && token !== 'field');
+    };
+
+    const fieldSemanticTokensOf = (element) => {
+      const tokens = new Set();
+      const pushValue = (value) => {
+        for (const token of tokenizeSemanticText(value)) {
+          tokens.add(token);
+        }
+      };
+
+      const inputType = inputTypeOf(element);
+      const autocomplete = (element.getAttribute('autocomplete') || '').trim().toLowerCase();
+
+      if (isButtonLikeInput(element)) {
+        return tokens;
+      }
+
+      pushValue(element.getAttribute('placeholder'));
+      pushValue(element.getAttribute('name'));
+      pushValue(element.getAttribute('id'));
+      pushValue(autocomplete);
+      pushValue(inputType);
+
+      if (inputType === 'email' || autocomplete.includes('email')) {
+        pushValue('email mail e-mail');
+      }
+      if (
+        inputType === 'tel' ||
+        autocomplete.startsWith('tel') ||
+        autocomplete.includes('phone')
+      ) {
+        pushValue('phone telephone mobile tel номер телефон');
+      }
+      if (inputType === 'password' || autocomplete.includes('password')) {
+        pushValue('password pass пароль');
+      }
+      if (inputType === 'search' || autocomplete.includes('search')) {
+        pushValue('search find поиск найти');
+      }
+      if (
+        inputType === 'date' ||
+        autocomplete.includes('bday') ||
+        autocomplete.includes('birth') ||
+        autocomplete.includes('dob')
+      ) {
+        pushValue('date birth birthday dob дата рождения');
+      }
+
+      return tokens;
+    };
+
+    const isLooseFieldLabelCompatible = (element, candidateText) => {
+      const normalizedCandidate = normalizeDescriptorText(candidateText || '');
+      if (!normalizedCandidate) return false;
+      if (LOOSE_ACTION_TEXT_RE.test(normalizedCandidate)) {
+        return false;
+      }
+
+      const semanticTokens = fieldSemanticTokensOf(element);
+      if (semanticTokens.size === 0) {
+        return true;
+      }
+
+      const candidateTokens = tokenizeSemanticText(normalizedCandidate);
+      if (candidateTokens.length === 0) {
+        return false;
+      }
+
+      return candidateTokens.some((token) => semanticTokens.has(token));
+    };
+
+    const isFieldLikeControl = (element) => {
+      const tag = element.tagName.toLowerCase();
+      const explicitRole = (element.getAttribute('role') || '').trim().toLowerCase();
+      if (tag === 'input') {
+        return !isButtonLikeInput(element);
+      }
+      return (
+        tag === 'textarea' ||
+        tag === 'select' ||
+        explicitRole === 'textbox' ||
+        explicitRole === 'combobox' ||
+        explicitRole === 'searchbox' ||
+        explicitRole === 'spinbutton'
+      );
+    };
+
+    const precedesElementInDocument = (candidate, element) => {
+      return Boolean(candidate.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING);
+    };
+
+    const ariaLabelledbyTextOf = (element) => {
+      const labelledBy = element.getAttribute('aria-labelledby')?.trim();
+      if (!labelledBy) return undefined;
+
+      const text = labelledBy
+        .split(/\s+/)
+        .map((id) => textOf(document.getElementById(id)))
+        .filter(Boolean)
+        .join(' ')
+        .trim();
+
+      return isMeaningfulLabel(text) ? text : undefined;
+    };
+
+    const describedByTextOf = (element) => {
+      const describedBy = element.getAttribute('aria-describedby')?.trim();
+      if (!describedBy) return undefined;
+
+      const text = describedBy
+        .split(/\s+/)
+        .map((id) => textOf(document.getElementById(id)))
+        .filter(Boolean)
+        .join(' ')
+        .trim();
+
+      return isMeaningfulLabel(text) ? text : undefined;
+    };
+
+    const nearestFieldLabelOf = (element) => {
+      const restrictLooseCandidatesToPreceding = isFieldLikeControl(element);
+      const anchors = [
+        composedParentElement(element),
+        composedParentElement(composedParentElement(element)),
+        composedParentElement(composedParentElement(composedParentElement(element))),
+      ].filter(Boolean);
+
+      for (const anchor of anchors) {
+        if (!isHTMLElementNode(anchor)) continue;
+
+        const explicitLabels = Array.from(
+          anchor.querySelectorAll('label, legend, [class*="label"], [data-testid*="label"]')
+        ).filter((candidate) => {
+          return (
+            isHTMLElementNode(candidate) &&
+            candidate !== element &&
+            !candidate.contains(element) &&
+            !element.contains(candidate)
+          );
+        });
+
+        for (const candidate of explicitLabels) {
+          if (
+            restrictLooseCandidatesToPreceding &&
+            !candidate.matches('label, legend') &&
+            !precedesElementInDocument(candidate, element)
+          ) {
+            continue;
+          }
+          const candidateText = textOf(candidate);
+          if (isMeaningfulLabel(candidateText)) {
+            return candidateText;
+          }
+        }
+
+        for (const child of Array.from(anchor.children).slice(0, 8)) {
+          if (!isHTMLElementNode(child)) continue;
+          if (child === element || child.contains(element) || element.contains(child)) continue;
+          if (restrictLooseCandidatesToPreceding && !precedesElementInDocument(child, element)) {
+            continue;
+          }
+
+          const candidateText = textOf(child);
+          if (isMeaningfulLabel(candidateText)) {
+            return candidateText;
+          }
+        }
+      }
+
+      return undefined;
+    };
+
+    const labelOf = (element) => {
+      const ariaLabel = element.getAttribute('aria-label')?.trim();
+      if (isMeaningfulLabel(ariaLabel)) return ariaLabel;
+
+      const customLabel = element.getAttribute('label')?.trim();
+      if (isMeaningfulLabel(customLabel)) return customLabel;
+
+      const ariaLabelledbyText = ariaLabelledbyTextOf(element);
+      if (isMeaningfulLabel(ariaLabelledbyText)) return ariaLabelledbyText;
+
+      const labels = element.labels;
+      if (labels && labels.length > 0) {
+        const labelText = textOf(labels[0]);
+        if (isMeaningfulLabel(labelText)) return labelText;
+      }
+
+      const title = element.getAttribute('title')?.trim();
+      if (isMeaningfulLabel(title)) return title;
+
+      const skipNearestFieldLabel = isButtonLikeInput(element);
+      const preferFieldLabelBeforeVisibleText = isFieldLikeControl(element);
+      const text = textOf(element);
+      if (!preferFieldLabelBeforeVisibleText && isMeaningfulLabel(text)) return text;
+
+      const placeholder = element.getAttribute('placeholder')?.trim();
+      const nearestFieldLabel = nearestFieldLabelOf(element);
+      if (
+        !skipNearestFieldLabel &&
+        isMeaningfulLabel(nearestFieldLabel) &&
+        (!preferFieldLabelBeforeVisibleText ||
+          isLooseFieldLabelCompatible(element, nearestFieldLabel))
+      ) {
+        return nearestFieldLabel;
+      }
+
+      if (isMeaningfulLabel(placeholder)) return placeholder;
+
+      if (!skipNearestFieldLabel && isMeaningfulLabel(nearestFieldLabel)) return nearestFieldLabel;
+
+      if (isMeaningfulLabel(text)) return text;
+
+      const syntheticLabel = stableLabelOf(element);
+      if (isMeaningfulLabel(syntheticLabel)) return syntheticLabel;
+
+      return undefined;
+    };
+
+    const VALIDATION_TEXT_RE =
+      /(?:required|invalid|incorrect|too\s+(?:short|long)|must|error|format|please\s+(?:enter|select|choose|fill)|невер|ошиб|обязател|заполн|введите|укажите|выберите|долж|нужно|формат|цифр|символ)/i;
+
+    const syntheticLabelOf = (element) => {
+      const tag = element.tagName.toLowerCase();
+      const explicitRole = element.getAttribute('role')?.trim();
+      const hasStructuredAffordance =
+        element.hasAttribute('aria-haspopup') ||
+        element.hasAttribute('aria-controls') ||
+        element.hasAttribute('aria-expanded') ||
+        element.hasAttribute('aria-pressed') ||
+        element.hasAttribute('aria-selected') ||
+        element.hasAttribute('aria-describedby');
+      if (tag === 'input') {
+        const inputType = inputTypeOf(element);
+        if (isButtonLikeInput(element)) return 'Button';
+        if (inputType === 'tel') return 'Phone input';
+        if (inputType === 'email') return 'Email input';
+        if (inputType === 'password') return 'Password input';
+        if (inputType === 'search') return 'Search input';
+        if (inputType === 'date') return 'Date input';
+        return 'Text input';
+      }
+      if (tag === 'textarea') return 'Text area';
+      if (tag === 'select' || explicitRole === 'combobox') return 'Combobox';
+      if (explicitRole === 'textbox') return 'Text input';
+      if ((tag === 'button' || explicitRole === 'button') && hasStructuredAffordance) {
+        return 'Button';
+      }
+      if ((tag === 'a' || explicitRole === 'link') && hasStructuredAffordance) {
+        return 'Link';
+      }
+      if (explicitRole === 'option') return 'Option';
+      if (explicitRole === 'menuitem') return 'Menu item';
+      if (explicitRole === 'gridcell') return 'Grid cell';
+      return undefined;
+    };
+
+    const stableLabelOf = (element) => {
+      const ariaLabel = element.getAttribute('aria-label')?.trim();
+      if (isMeaningfulLabel(ariaLabel)) return ariaLabel;
+
+      const customLabel = element.getAttribute('label')?.trim();
+      if (isMeaningfulLabel(customLabel)) return customLabel;
+
+      const title = element.getAttribute('title')?.trim();
+      if (isMeaningfulLabel(title)) return title;
+
+      const ariaLabelledbyText = ariaLabelledbyTextOf(element);
+      if (isMeaningfulLabel(ariaLabelledbyText)) return ariaLabelledbyText;
+
+      const labels = element.labels;
+      if (labels && labels.length > 0) {
+        const labelText = textOf(labels[0]);
+        if (isMeaningfulLabel(labelText)) return labelText;
+      }
+
+      const text = textOf(element);
+      if (isMeaningfulLabel(text)) return text;
+
+      const skipNearestFieldLabel = isButtonLikeInput(element);
+      const nearestFieldLabel = nearestFieldLabelOf(element);
+      if (!skipNearestFieldLabel && isMeaningfulLabel(nearestFieldLabel)) return nearestFieldLabel;
+
+      return syntheticLabelOf(element);
+    };
+
+    const inferRole = (element) => {
+      const explicitRole = element.getAttribute('role')?.trim();
+      if (explicitRole) return explicitRole;
+
+      const labelBackedChoice = labelBackedChoiceControlOf(element);
+      if (isHTMLInputNode(labelBackedChoice)) {
+        const inputType = (labelBackedChoice.type || '').toLowerCase();
+        if (inputType === 'radio') return 'radio';
+        if (inputType === 'checkbox') return 'checkbox';
+      }
+
+      const tag = element.tagName.toLowerCase();
+      if (tag === 'button') return 'button';
+      if (tag === 'a' && element.getAttribute('href')) return 'link';
+      if (tag === 'select') return 'combobox';
+      if (tag === 'textarea') return 'textbox';
+      if (tag === 'input') {
+        const inputType = (element.getAttribute('type') || 'text').toLowerCase();
+        if (['button', 'submit', 'reset'].includes(inputType)) return 'button';
+        return 'textbox';
+      }
+      return undefined;
+    };
+
+    const kindOf = (element) => {
+      const tag = element.tagName.toLowerCase();
+      if (tag === 'input') return 'input';
+      if (tag === 'textarea') return 'textarea';
+      if (tag === 'select') return 'select';
+      if (tag === 'a') return 'link';
+      return inferRole(element) || tag;
+    };
+
+    const buildSelector = (element) => {
+      const testIdAttributeOf = (candidate) => {
+        if (candidate.hasAttribute('data-testid')) return 'data-testid';
+        if (candidate.hasAttribute('data-test-id')) return 'data-test-id';
+        return undefined;
+      };
+      const testIdSelectorOf = (candidate, value) => {
+        const attribute = testIdAttributeOf(candidate);
+        if (!attribute || !value) return undefined;
+        return '[' + attribute + '="' + cssEscape(value) + '"]';
+      };
+      const queryRootOf = (candidate) => {
+        const root = candidate.getRootNode?.();
+        return root && typeof root.querySelectorAll === 'function' ? root : document;
+      };
+
+      const isSelectorUniqueFor = (candidate, selectorValue) => {
+        const queryRoot = queryRootOf(candidate);
+        try {
+          const matches = Array.from(queryRoot.querySelectorAll(selectorValue));
+          return matches.length === 1 && matches[0] === candidate;
+        } catch {
+          return false;
+        }
+      };
+
+      if (element.id && isSelectorUniqueFor(element, '#' + cssEscape(element.id))) {
+        return '#' + cssEscape(element.id);
+      }
+
+      const testId =
+        element.getAttribute('data-testid')?.trim() || element.getAttribute('data-test-id')?.trim();
+      if (testId) {
+        const selectorValue = testIdSelectorOf(element, testId);
+        if (isSelectorUniqueFor(element, selectorValue)) {
+          return selectorValue;
+        }
+      }
+
+      const name = element.getAttribute('name')?.trim();
+      const tag = element.tagName.toLowerCase();
+      if (name) {
+        const selectorValue = tag + '[name="' + cssEscape(name) + '"]';
+        if (isSelectorUniqueFor(element, selectorValue)) {
+          return selectorValue;
+        }
+      }
+
+      const segmentOf = (current) => {
+        if (current.id && isSelectorUniqueFor(current, '#' + cssEscape(current.id))) {
+          return '#' + cssEscape(current.id);
+        }
+
+        const currentTestId =
+          current.getAttribute('data-testid')?.trim() ||
+          current.getAttribute('data-test-id')?.trim();
+        if (currentTestId) {
+          const selectorValue = testIdSelectorOf(current, currentTestId);
+          if (isSelectorUniqueFor(current, selectorValue)) {
+            return selectorValue;
+          }
+        }
+
+        const currentName = current.getAttribute('name')?.trim();
+        const currentTag = current.tagName.toLowerCase();
+        if (currentName) {
+          const selectorValue = currentTag + '[name="' + cssEscape(currentName) + '"]';
+          if (isSelectorUniqueFor(current, selectorValue)) {
+            return selectorValue;
+          }
+        }
+
+        const parent = current.parentElement;
+        const root = current.getRootNode?.();
+        const siblingPool = parent
+          ? Array.from(parent.children)
+          : isShadowRootNode(root)
+            ? Array.from(root.children)
+            : [];
+        const siblings = siblingPool.filter((child) => child.tagName.toLowerCase() === currentTag);
+        const index = siblings.indexOf(current) + 1;
+        return currentTag + ':nth-of-type(' + Math.max(index, 1) + ')';
+      };
+
+      const path = [];
+      let current = element;
+      while (current && current.nodeType === Node.ELEMENT_NODE && path.length < 8) {
+        path.unshift(segmentOf(current));
+        if (current.id) {
+          break;
+        }
+        current = current.parentElement;
+      }
+      if (path.length === 0) return undefined;
+
+      const structuralSelector = path.join(' > ');
+      return isSelectorUniqueFor(element, structuralSelector) ? structuralSelector : undefined;
+    };
+
+    const selectorFromRelation = (element, attribute) => {
+      const relation = element.getAttribute(attribute)?.trim();
+      if (!relation) return undefined;
+
+      for (const id of relation.split(/\s+/)) {
+        const related = document.getElementById(id);
+        if (!isHTMLElementNode(related)) continue;
+        const selector = buildSelector(related);
+        if (selector) return selector;
+      }
+
+      return undefined;
+    };
+
+    const laneOf = (rect) => {
+      const width = Math.max(window.innerWidth || 0, 1);
+      const center = rect.left + rect.width / 2;
+      if (center < width / 3) return 'left';
+      if (center < (width * 2) / 3) return 'center';
+      return 'right';
+    };
+
+    const bandOf = (rect) => {
+      const height = Math.max(window.innerHeight || 0, 1);
+      const center = rect.top + rect.height / 2;
+      if (center < height / 3) return 'top';
+      if (center < (height * 2) / 3) return 'middle';
+      return 'bottom';
+    };
+
+    const readBooleanState = (element, attribute) => {
+      const raw = element.getAttribute(attribute)?.trim();
+      if (raw === 'true') return true;
+      if (raw === 'false') return false;
+      return undefined;
+    };
+
+    const parseColor = (value) => {
+      if (!value || value === 'transparent') return null;
+
+      const rgbaMatch = value.match(/rgba?\(([^)]+)\)/i);
+      if (rgbaMatch) {
+        const [r = '0', g = '0', b = '0', a = '1'] = rgbaMatch[1].split(',').map((part) => part.trim());
+        return {
+          r: Number(r),
+          g: Number(g),
+          b: Number(b),
+          a: Number(a),
+        };
+      }
+
+      const hexMatch = value.match(/^#([0-9a-f]{3,8})$/i);
+      if (hexMatch) {
+        const hex = hexMatch[1];
+        if (hex.length === 3 || hex.length === 4) {
+          const [r, g, b, a = 'f'] = hex.split('');
+          return {
+            r: Number.parseInt(r + r, 16),
+            g: Number.parseInt(g + g, 16),
+            b: Number.parseInt(b + b, 16),
+            a: Number.parseInt(a + a, 16) / 255,
+          };
+        }
+        if (hex.length === 6 || hex.length === 8) {
+          return {
+            r: Number.parseInt(hex.slice(0, 2), 16),
+            g: Number.parseInt(hex.slice(2, 4), 16),
+            b: Number.parseInt(hex.slice(4, 6), 16),
+            a: hex.length === 8 ? Number.parseInt(hex.slice(6, 8), 16) / 255 : 1,
+          };
+        }
+      }
+
+      return null;
+    };
+
+    const luminanceOf = (color) => {
+      if (!color || color.a <= 0) return null;
+      return (0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b) / 255;
+    };
+
+    const visualOf = (element) => {
+      const style = window.getComputedStyle(element);
+      const background = parseColor(style.backgroundColor);
+      const border = parseColor(style.borderColor);
+      const backgroundLuminance = luminanceOf(background);
+      const borderVisible = Boolean(border && border.a > 0.2 && style.borderStyle !== 'none' && Number.parseFloat(style.borderWidth || '0') > 0);
+
+      let emphasis = 'normal';
+      const opacity = Number.parseFloat(style.opacity || '1');
+      const fontWeight = Number.parseInt(style.fontWeight || '400', 10);
+      if (opacity < 0.7) {
+        emphasis = 'muted';
+      } else if (fontWeight >= 600) {
+        emphasis = 'strong';
+      }
+
+      let fill = 'none';
+      if (background && background.a > 0.05 && backgroundLuminance !== null) {
+        if (backgroundLuminance <= 0.35) {
+          fill = 'dark';
+        } else if (backgroundLuminance <= 0.75) {
+          fill = 'mid';
+        } else {
+          fill = 'light';
+        }
+      }
+
+      return {
+        emphasis,
+        fill,
+        outlined: borderVisible,
+      };
+    };
+
+    const landmarkLabelOf = (container) => {
+      if (!container) return undefined;
+
+      const ariaLabel = container.getAttribute?.('aria-label')?.trim();
+      if (ariaLabel) return ariaLabel;
+
+      const heading = container.querySelector?.(headingSelector);
+      const headingText = textOf(heading);
+      if (headingText) return headingText;
+
+      const text = textOf(container);
+      if (text && text.length <= 140) return text;
+      if (text) return text.slice(0, 140);
+      return undefined;
+    };
+
+    const isStructuredContainer = (element) => {
+      if (!isHTMLElementNode(element)) return false;
+
+      const tag = element.tagName.toLowerCase();
+      const role = element.getAttribute('role')?.trim() || '';
+      if (
+        ['label', 'li', 'article', 'tr', 'fieldset', 'section', 'aside', 'form'].includes(tag) ||
+        ['option', 'listitem', 'row', 'group', 'dialog', 'region', 'tabpanel', 'listbox', 'menu', 'grid'].includes(role)
+      ) {
+        return true;
+      }
+
+      const text = textOf(element);
+      if (!text) return false;
+
+      const interactiveCount = element.querySelectorAll(selector).length;
+      const hasHeading = Boolean(element.querySelector(headingSelector));
+      return interactiveCount >= 2 && (hasHeading || text.length >= 40);
+    };
+
+    const hasSemanticInteractiveAncestor = (element) => {
+      let current = composedParentElement(element);
+      while (current) {
+        if (current.matches?.(selector)) {
+          return true;
+        }
+        current = composedParentElement(current);
+      }
+      return false;
+    };
+
+    const visibleInteractiveDescendantCountOf = (element) => {
+      return Array.from(element.querySelectorAll(selector)).filter((candidate) => {
+        return isHTMLElementNode(candidate) && isVisible(candidate);
+      }).length;
+    };
+
+    const clickableSemanticBlobOf = (element) => {
+      return [
+        element.getAttribute('class') || '',
+        Object.values(element.dataset || {}).join(' '),
+        element.getAttribute('data-testid') || '',
+        element.getAttribute('data-test-id') || '',
+      ]
+        .join(' ')
+        .toLowerCase();
+    };
+
+    const viewportArea = () => {
+      return Math.max(window.innerWidth || 0, 1) * Math.max(window.innerHeight || 0, 1);
+    };
+
+    const isGenericClickableElement = (element) => {
+      if (!isHTMLElementNode(element)) return false;
+      if (element.matches?.(selector)) return false;
+      if (hasSemanticInteractiveAncestor(element)) return false;
+
+      const tag = element.tagName.toLowerCase();
+      const labelBackedChoice = labelBackedChoiceControlOf(element);
+      if (['body', 'main', 'form'].includes(tag)) return false;
+      if (tag === 'label' && !labelBackedChoice) return false;
+
+      const style = window.getComputedStyle(element);
+      if (style.pointerEvents === 'none') return false;
+
+      const rect = element.getBoundingClientRect();
+      const area = rect.width * rect.height;
+      if (rect.width < 40 || rect.height < 20 || area < 1200) return false;
+
+      const explicitClick =
+        element.hasAttribute('onclick') || typeof element.onclick === 'function';
+      const cursorClick = style.cursor === 'pointer';
+      if (!explicitClick && !cursorClick) return false;
+
+      const descriptorText = stableLabelOf(element) || textOf(element);
+      if (!descriptorText) return false;
+
+      const interactiveDescendants = visibleInteractiveDescendantCountOf(element);
+      if (interactiveDescendants > 8) return false;
+      if (!explicitClick && area >= viewportArea() * 0.75 && interactiveDescendants >= 2) {
+        return false;
+      }
+
+      const structuredLike =
+        isStructuredContainer(element) ||
+        ['article', 'li'].includes(tag) ||
+        /\b(card|item|result|fare|flight|ticket|offer|row)\b/.test(
+          clickableSemanticBlobOf(element)
+        );
+
+      if (!structuredLike && !explicitClick && !labelBackedChoice && descriptorText.length < 12) {
+        return false;
+      }
+
+      return true;
+    };
+
+    const hasAcceptedGenericClickableAncestor = (element, accepted) => {
+      return accepted.some((ancestor) => ancestor !== element && ancestor.contains(element));
+    };
+
+    const collectGenericClickableElements = (
+      root,
+      limit = collectorElementLimit,
+      acc = [],
+      seen = new Set()
+    ) => {
+      if (!root?.querySelectorAll || acc.length >= limit) {
+        return acc;
+      }
+
+      const descendants = Array.from(root.querySelectorAll('*'));
+      for (const candidate of descendants) {
+        if (acc.length >= limit) break;
+        if (!isHTMLElementNode(candidate) || seen.has(candidate)) continue;
+        if (!isGenericClickableElement(candidate)) continue;
+        if (hasAcceptedGenericClickableAncestor(candidate, acc)) continue;
+        seen.add(candidate);
+        acc.push(candidate);
+      }
+
+      for (const candidate of descendants) {
+        if (acc.length >= limit) break;
+        if (!isHTMLElementNode(candidate) || !candidate.shadowRoot) continue;
+        collectGenericClickableElements(candidate.shadowRoot, limit, acc, seen);
+      }
+
+      return acc;
+    };
+
+    const containerOf = (element) => {
+      let current = element.parentElement;
+      let depth = 0;
+      while (current && depth < 6) {
+        if (isStructuredContainer(current)) {
+          return current;
+        }
+        current = current.parentElement;
+        depth += 1;
+      }
+      return undefined;
+    };
+
+    const containerTextOf = (container) => {
+      const text = textOf(container);
+      if (!text) return undefined;
+      return text.length <= 240 ? text : text.slice(0, 240);
+    };
+
+    const groupOf = (element) => {
+      if (element.matches?.(collectionSelector)) {
+        return element;
+      }
+
+      return composedClosest(element, collectionSelector) || undefined;
+    };
+
+    const descriptiveItemOf = (element) => {
+      const selfText = textOf(element);
+      let current = composedParentElement(element);
+      let depth = 0;
+
+      while (current && depth < 5) {
+        const currentText = textOf(current);
+        if (currentText && currentText !== selfText) {
+          const interactiveCount = current.querySelectorAll(selector).length;
+          const hasSiblingText = Array.from(current.children).some((child) => {
+            if (!isHTMLElementNode(child)) return false;
+            if (child === element || child.contains(element) || element.contains(child)) return false;
+            return Boolean(textOf(child));
+          });
+
+          if (
+            interactiveCount > 0 &&
+            interactiveCount <= 4 &&
+            currentText.length <= 180 &&
+            (hasSiblingText || current.matches?.(itemSelector) || isStructuredContainer(current))
+          ) {
+            return current;
+          }
+        }
+
+        current = composedParentElement(current);
+        depth += 1;
+      }
+
+      return undefined;
+    };
+
+    const itemOf = (element) => {
+      const descriptiveItem = descriptiveItemOf(element);
+      if (descriptiveItem) {
+        return descriptiveItem;
+      }
+
+      if (element.matches?.(itemSelector)) {
+        const ancestorItem = composedClosest(composedParentElement(element), itemSelector);
+        if (ancestorItem) {
+          const selfText = textOf(element);
+          const ancestorText = textOf(ancestorItem);
+          if (
+            ancestorText &&
+            ancestorText !== selfText &&
+            ancestorText.length > (selfText?.length || 0)
+          ) {
+            return ancestorItem;
+          }
+        }
+
+        return element;
+      }
+
+      return composedClosest(element, itemSelector) || undefined;
+    };
+
+    const normalizeText = (value) => (value || '').replace(/\s+/g, ' ').trim().toLowerCase();
+
+    const contextualHintOf = (element) => {
+      const excluded = new Set(
+        [labelOf(element), textOf(element)]
+          .map((value) => normalizeText(value))
+          .filter(Boolean)
+      );
+
+      const seen = new Set();
+      const pushCandidate = (candidates, value) => {
+        const text = (value || '').replace(/\s+/g, ' ').trim();
+        const normalized = normalizeText(text);
+        if (!normalized || excluded.has(normalized) || seen.has(normalized)) {
+          return;
+        }
+        if (text.length < 4 || text.length > 120) {
+          return;
+        }
+        seen.add(normalized);
+        candidates.push(text);
+      };
+
+      const describeNode = (node, candidates) => {
+        if (!isHTMLElementNode(node)) return;
+
+        const heading = node.querySelector?.(headingSelector);
+        if (isHTMLElementNode(heading) && heading !== element && !heading.contains(element)) {
+          pushCandidate(candidates, textOf(heading));
+        }
+
+        for (const child of Array.from(node.children).slice(0, 8)) {
+          if (!isHTMLElementNode(child)) continue;
+          if (child === element || child.contains(element) || element.contains(child)) continue;
+          pushCandidate(candidates, textOf(child));
+        }
+
+        pushCandidate(candidates, landmarkLabelOf(node));
+        pushCandidate(candidates, textOf(node));
+      };
+
+      const anchors = [
+        itemOf(element),
+        groupOf(element),
+        containerOf(element),
+        composedParentElement(element),
+        composedParentElement(composedParentElement(element)),
+      ].filter(Boolean);
+
+      for (const anchor of anchors) {
+        const candidates = [];
+        pushCandidate(candidates, describedByTextOf(element));
+        describeNode(anchor, candidates);
+        if (candidates.length > 0) {
+          return candidates[0];
+        }
+      }
+
+      const describedBy = describedByTextOf(element);
+      if (describedBy) {
+        return describedBy;
+      }
+
+      return undefined;
+    };
+
+    const VALIDATION_CLASS_RE = /\b(?:error|invalid|warning|danger|alert|failed)\b/i;
+    const validationFieldSelectors =
+      'input, textarea, select, [role="textbox"], [contenteditable="true"], [aria-invalid="true"]';
+
+    const relatedValidationMessagesOf = (element) => {
+      if (!isHTMLElementNode(element)) {
+        return [];
+      }
+
+      const values = [];
+      const pushMessage = (value) => {
+        const text = normalizeDescriptorText(value || '');
+        if (!text || !VALIDATION_TEXT_RE.test(text)) {
+          return;
+        }
+        if (values.includes(text)) {
+          return;
+        }
+        values.push(text.slice(0, 240));
+        if (values.length > 4) {
+          values.length = 4;
+        }
+      };
+
+      const describedBy = describedByTextOf(element);
+      if (describedBy) {
+        pushMessage(describedBy);
+      }
+
+      let anchor = element.parentElement;
+      for (let depth = 0; anchor && depth < 4 && values.length < 4; depth += 1, anchor = anchor.parentElement) {
+        const anchorFieldCount = anchor.querySelectorAll(validationFieldSelectors).length;
+        if (anchorFieldCount === 0 || anchorFieldCount > 3) {
+          continue;
+        }
+
+        for (const candidate of Array.from(anchor.children)) {
+          if (!isHTMLElementNode(candidate)) {
+            continue;
+          }
+          if (candidate === element || candidate.contains(element) || element.contains(candidate)) {
+            continue;
+          }
+          if (!isVisible(candidate) || candidate.matches('label, legend')) {
+            continue;
+          }
+          if (candidate.querySelector(validationFieldSelectors)) {
+            continue;
+          }
+          pushMessage(candidate.textContent);
+        }
+      }
+
+      return values;
+    };
+
+    const hasValidationStyling = (element) => {
+      if (!isHTMLElementNode(element)) {
+        return false;
+      }
+
+      let node = element;
+      for (let depth = 0; node && depth < 4; depth += 1, node = node.parentElement) {
+        const classBlob =
+          (node.getAttribute('class') || '') +
+          ' ' +
+          Object.values(node.dataset || {}).join(' ') +
+          ' ' +
+          (node.getAttribute('data-state') || '') +
+          ' ' +
+          (node.getAttribute('data-status') || '');
+        if (VALIDATION_CLASS_RE.test(classBlob.toLowerCase())) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    const validationEvidenceOf = (element) => {
+      if (!isHTMLElementNode(element)) {
+        return undefined;
+      }
+
+      const required =
+        element.getAttribute('aria-required') === 'true' ||
+        (isHTMLInputNode(element) || isHTMLTextAreaNode(element) || isHTMLSelectNode(element)
+          ? element.required
+          : false);
+      const invalid =
+        element.getAttribute('aria-invalid') === 'true' ||
+        ((isHTMLInputNode(element) || isHTMLTextAreaNode(element) || isHTMLSelectNode(element)) &&
+          !element.checkValidity());
+      const messages = relatedValidationMessagesOf(element);
+      const errorStyling = hasValidationStyling(element);
+      const message = messages[0];
+
+      if (!required && !invalid && !errorStyling && !message) {
+        return undefined;
+      }
+
+      return {
+        invalid: invalid || undefined,
+        required: required || undefined,
+        message,
+        errorStyling: errorStyling || undefined,
+      };
+    };
+
+    const stateOf = (element) => {
+      const states = {};
+      const labelBackedChoice = labelBackedChoiceControlOf(element);
+
+      const ariaDisabled = readBooleanState(element, 'aria-disabled');
+      if (ariaDisabled !== undefined) states.disabled = ariaDisabled;
+
+      if (element.matches?.(':disabled')) {
+        states.disabled = true;
+      }
+
+      const style = window.getComputedStyle(element);
+      if (style.pointerEvents === 'none') {
+        states.disabled = true;
+      }
+
+      const ariaSelected = readBooleanState(element, 'aria-selected');
+      if (ariaSelected !== undefined) states.selected = ariaSelected;
+
+      const ariaExpanded = readBooleanState(element, 'aria-expanded');
+      if (ariaExpanded !== undefined) states.expanded = ariaExpanded;
+
+      const ariaPressed = readBooleanState(element, 'aria-pressed');
+      if (ariaPressed !== undefined) states.pressed = ariaPressed;
+
+      const ariaBusy = readBooleanState(element, 'aria-busy');
+      if (ariaBusy !== undefined) states.busy = ariaBusy;
+
+      const ariaReadonly = readBooleanState(element, 'aria-readonly');
+      if (ariaReadonly !== undefined) states.readonly = ariaReadonly;
+
+      const ariaChecked = element.getAttribute('aria-checked')?.trim();
+      if (ariaChecked === 'true') states.checked = true;
+      else if (ariaChecked === 'false') states.checked = false;
+      else if (ariaChecked === 'mixed') states.checked = 'mixed';
+
+      const ariaCurrent = element.getAttribute('aria-current')?.trim();
+      if (ariaCurrent) {
+        states.current = ariaCurrent === 'true' ? true : ariaCurrent;
+      }
+
+      if (isHTMLSelectNode(element) && typeof element.selectedIndex === 'number' && element.selectedIndex > 0) {
+        states.hasSelection = true;
+      }
+
+      const className = (element.getAttribute('class') || '').toLowerCase();
+      const dataset = Object.values(element.dataset || {})
+        .join(' ')
+        .toLowerCase();
+      const semanticBlob =
+        className +
+        ' ' +
+        dataset +
+        ' ' +
+        (element.getAttribute('data-state') || '').toLowerCase() +
+        ' ' +
+        (element.getAttribute('data-status') || '').toLowerCase() +
+        ' ' +
+        (element.getAttribute('aria-label') || '').toLowerCase();
+
+      if (/(?:selected|active|current)\b/.test(semanticBlob)) {
+        if (states.selected === undefined) states.selected = true;
+        if (states.current === undefined) states.current = true;
+      }
+      if (/(?:occupied|unavailable|sold|taken|reserved|booked)\b/.test(semanticBlob)) {
+        states.occupied = true;
+        states.selectable = false;
+        states.disabled = true;
+      }
+      if (/(?:premium|extra-legroom|comfort|preferred)\b/.test(semanticBlob)) {
+        states.premium = true;
+      }
+      if (states.selectable === undefined && states.disabled !== true && states.occupied !== true) {
+        const role = inferRole(element);
+        const tag = element.tagName.toLowerCase();
+        if (role === 'gridcell' || tag === 'button') {
+          states.selectable = true;
+        }
+      }
+
+      if (isHTMLInputNode(element)) {
+        const type = (element.type || 'text').toLowerCase();
+        if (type === 'checkbox' || type === 'radio') {
+          states.checked = element.indeterminate ? 'mixed' : element.checked;
+        }
+        if (element.readOnly) {
+          states.readonly = true;
+        }
+      }
+
+      if (isHTMLInputNode(labelBackedChoice)) {
+        const type = (labelBackedChoice.type || 'text').toLowerCase();
+        if (type === 'checkbox' || type === 'radio') {
+          states.checked = labelBackedChoice.indeterminate ? 'mixed' : labelBackedChoice.checked;
+        }
+        if (labelBackedChoice.disabled) {
+          states.disabled = true;
+        }
+        if (labelBackedChoice.readOnly) {
+          states.readonly = true;
+        }
+      }
+
+      if (isHTMLTextAreaNode(element) && element.readOnly) {
+        states.readonly = true;
+      }
+
+      if (isHTMLSelectNode(element) && element.disabled) {
+        states.disabled = true;
+      }
+
+      return Object.keys(states).length > 0 ? states : undefined;
+    };
+
+    const inferStructuredCell = (element, surface) => {
+      if (!isHTMLElementNode(element)) return undefined;
+
+      const role = inferRole(element) || '';
+      const className = (element.getAttribute('class') || '').toLowerCase();
+      const surfaceKind = inferSurfaceKind(surface);
+      const label = labelOf(element) || textOf(element) || '';
+      const normalizedLabel = label.replace(/\s+/g, ' ').trim();
+      const seatIdentityLike =
+        /(?:\bseat\s*\d{1,3}[a-z]?\b|место\s*\d{1,3}[a-z]?\b|\b\d{1,3}[a-z]\b|\b[a-z]\d{1,3}\b)/i.test(
+          label
+        );
+      const seatLike =
+        seatIdentityLike ||
+        /seat|cabin|fare|row/.test(className) ||
+        element.hasAttribute('data-row') ||
+        element.hasAttribute('data-column') ||
+        element.hasAttribute('data-seat');
+      const structuredSurface = surfaceKind === 'grid' || surfaceKind === 'datepicker';
+      const explicitDateCellMetadata =
+        element.hasAttribute('data-day') ||
+        element.hasAttribute('data-date') ||
+        element.hasAttribute('aria-rowindex') ||
+        element.hasAttribute('aria-colindex') ||
+        Boolean(
+          composedClosest(
+            element,
+            '[data-day], [data-date], [aria-rowindex], [aria-colindex]'
+          )
+        );
+      const compactDateCellLabel =
+        /^(?:\d{1,2}|january|february|march|april|may|june|july|august|september|october|november|december|январ|феврал|март|апрел|ма[йя]|июн|июл|август|сентябр|октябр|ноябр|декабр)$/i.test(
+          normalizedLabel
+        ) ||
+        /^(?:\d{1,2}[./-]\d{1,2}(?:[./-]\d{2,4})?)$/.test(normalizedLabel);
+      const dateLike =
+        surfaceKind === 'datepicker' ||
+        ((role === 'gridcell' || structuredSurface || explicitDateCellMetadata) &&
+          compactDateCellLabel);
+      const structuredCellRole = role === 'gridcell' || role === 'button';
+
+      if (!structuredCellRole || (!structuredSurface && !seatLike && !dateLike)) {
+        return undefined;
+      }
+
+      const row =
+        element.getAttribute('aria-rowindex')?.trim() ||
+        element.getAttribute('data-row')?.trim() ||
+        composedClosest(element, '[aria-rowindex]')?.getAttribute?.('aria-rowindex')?.trim() ||
+        label.match(/\b(\d{1,3})[a-z]\b/i)?.[1] ||
+        undefined;
+      const column =
+        element.getAttribute('aria-colindex')?.trim() ||
+        element.getAttribute('data-column')?.trim() ||
+        label.match(/\b\d{1,3}([a-z])\b/i)?.[1]?.toUpperCase() ||
+        undefined;
+      const zone =
+        element.getAttribute('data-zone')?.trim() ||
+        composedClosest(element, '[data-zone]')?.getAttribute?.('data-zone')?.trim() ||
+        contextNodeOf(groupOf(element))?.label ||
+        contextNodeOf(containerOf(element))?.label ||
+        undefined;
+
+      return {
+        family: 'structured-grid',
+        variant: dateLike ? 'date-cell' : seatLike ? 'seat-cell' : 'grid-cell',
+        row,
+        column,
+        zone,
+        cellLabel: label || undefined,
+      };
+    };
+
+    const inferSurfaceKind = (surface) => {
+      if (!isHTMLElementNode(surface)) return undefined;
+      const role = surface.getAttribute('role')?.trim();
+      if (role === 'dialog') return 'dialog';
+      if (role === 'listbox') return 'listbox';
+      if (role === 'menu') return 'menu';
+      if (role === 'grid') return 'grid';
+      if (role === 'tabpanel') return 'tabpanel';
+      if (isGenericClickableElement(surface) && isStructuredContainer(surface)) return 'card';
+      const className = (surface.getAttribute('class') || '').toLowerCase();
+      if (className.includes('calendar') || className.includes('datepicker')) return 'datepicker';
+      if (className.includes('popover')) return 'popover';
+      if (className.includes('dropdown')) return 'dropdown';
+      const tag = surface.tagName.toLowerCase();
+      if (tag === 'article') return 'card';
+      if (tag === 'fieldset') return 'group';
+      if (tag === 'li') return 'listitem';
+      if (tag === 'section' || tag === 'form' || tag === 'aside') return tag;
+      return role || surface.tagName.toLowerCase();
+    };
+
+    const contextNodeOf = (element) => {
+      if (!element) return undefined;
+
+      const kind = element.getAttribute?.('role')?.trim() || element.tagName?.toLowerCase?.();
+      const label = landmarkLabelOf(element);
+      const text = containerTextOf(element);
+
+      if (!kind && !label && !text) return undefined;
+      return { kind: kind || undefined, label, text };
+    };
+
+    const pageSignature =
+      inheritedPageSignature ||
+      (() => {
+        try {
+          const url = new URL(window.location.href);
+          return url.origin + url.pathname;
+        } catch {
+          return window.location.href;
+        }
+      })();
+
+    const collectTargets = (doc) => {
+      const seenElements = new Set();
+      const overlaySurfaceSelector =
+        '[role="dialog"], [aria-modal="true"], [role="listbox"], [role="menu"], [role="grid"], [role="tabpanel"], [class*="popover"], [class*="dropdown"], [class*="listbox"], [class*="calendar"], [class*="datepicker"]';
+
+      const compactText = (value) => (value || '').replace(/\s+/g, ' ').trim();
+
+      const surfacePriorityOf = (surface) => {
+        if (!isHTMLElementNode(surface)) return 0;
+        const role = surface.getAttribute('role')?.trim() || '';
+        const className = (surface.getAttribute('class') || '').toLowerCase();
+        if (role === 'dialog' || surface.getAttribute('aria-modal') === 'true') return 100;
+        if (role === 'listbox' || role === 'menu') return 95;
+        if (className.includes('calendar') || className.includes('datepicker')) return 90;
+        if (className.includes('popover') || className.includes('dropdown')) return 85;
+        if (role === 'grid' || role === 'tabpanel') return 80;
+        if (isGenericClickableElement(surface) && isStructuredContainer(surface)) {
+          const interactiveCount = visibleInteractiveDescendantCountOf(surface);
+          return interactiveCount >= 1 && interactiveCount <= 6 ? 58 : 54;
+        }
+        const tag = surface.tagName.toLowerCase();
+        const interactiveCount = surface.querySelectorAll(selector).length;
+        if (tag === 'article' || tag === 'fieldset') return interactiveCount >= 2 ? 65 : 55;
+        if (role === 'group' || role === 'region') return interactiveCount >= 2 ? 60 : 50;
+        if (tag === 'li' || role === 'listitem' || role === 'row') return interactiveCount >= 2 ? 58 : 48;
+        if (tag === 'section' || tag === 'form' || tag === 'aside') {
+          return interactiveCount >= 2 && interactiveCount <= 8 ? 52 : 0;
+        }
+        return 0;
+      };
+
+      const surfaceKindOf = inferSurfaceKind;
+
+      const visualSeatGridMeta = new WeakMap();
+
+      const isPotentialVisualGridSurface = (element) => {
+        if (!isHTMLElementNode(element) || !isVisible(element)) {
+          return false;
+        }
+
+        const rect = element.getBoundingClientRect();
+        if (rect.width < 220 || rect.height < 220) {
+          return false;
+        }
+
+        const role = element.getAttribute('role')?.trim() || '';
+        const tag = element.tagName.toLowerCase();
+        return (
+          role === 'grid' ||
+          ['article', 'section', 'main', 'form', 'aside', 'div'].includes(tag)
+        );
+      };
+
+      const isVisualGridSquareElement = (element) => {
+        if (!isHTMLElementNode(element) || !isVisible(element)) {
+          return false;
+        }
+        if (element.matches?.(selector)) {
+          return false;
+        }
+
+        const rect = element.getBoundingClientRect();
+        if (rect.width < 24 || rect.width > 52 || rect.height < 24 || rect.height > 52) {
+          return false;
+        }
+        if (Math.abs(rect.width - rect.height) > Math.max(8, Math.min(rect.width, rect.height) * 0.35)) {
+          return false;
+        }
+        if (rect.width * rect.height < 576) {
+          return false;
+        }
+
+        return true;
+      };
+
+      const visualSeatGridTokenKindOf = (element) => {
+        const text = compactText(textOf(element));
+        if (!text) {
+          return undefined;
+        }
+        if (/^\d{1,3}$/.test(text)) {
+          return 'row';
+        }
+        if (/^[a-z]$/i.test(text)) {
+          return 'column';
+        }
+        return undefined;
+      };
+
+      const visualSeatCellStateOf = (element) => {
+        const style = window.getComputedStyle(element);
+        const background = parseColor(style.backgroundColor);
+        const hasFilledBackground = Boolean(background && background.a > 0.15);
+        const glyphCount = element.querySelectorAll(
+          'svg, path, use, circle, line, polyline, polygon'
+        ).length;
+        const states = {};
+
+        if (glyphCount > 0 && !hasFilledBackground) {
+          states.occupied = true;
+          states.selectable = false;
+          states.disabled = true;
+          return states;
+        }
+
+        states.selectable = true;
+        if (glyphCount > 0 && hasFilledBackground) {
+          states.selected = true;
+        }
+
+        if (background && background.a > 0.15) {
+          const warm = background.r > background.b + 40 && background.g > 60;
+          if (warm) {
+            states.premium = true;
+          }
+        }
+
+        return states;
+      };
+
+      const isVisualSeatCellElement = (element) => {
+        if (!isVisualGridSquareElement(element)) {
+          return false;
+        }
+        if (hasSemanticInteractiveAncestor(element)) {
+          return false;
+        }
+
+        const text = compactText(textOf(element));
+        if (text) {
+          return false;
+        }
+
+        const style = window.getComputedStyle(element);
+        if (style.pointerEvents === 'none') {
+          return false;
+        }
+
+        const background = parseColor(style.backgroundColor);
+        const border = parseColor(style.borderColor);
+        const glyphCount = element.querySelectorAll(
+          'svg, path, use, circle, line, polyline, polygon'
+        ).length;
+        const borderVisible =
+          Boolean(border && border.a > 0.2) &&
+          style.borderStyle !== 'none' &&
+          Number.parseFloat(style.borderWidth || '0') > 0;
+        const backgroundVisible = Boolean(background && background.a > 0.15);
+
+        if (!backgroundVisible && !borderVisible && glyphCount === 0) {
+          return false;
+        }
+        if (element.children.length > 3) {
+          return false;
+        }
+
+        return true;
+      };
+
+      const visualSeatGridOwnerSurfaceOf = (surface) => {
+        let preferredArticle = undefined;
+        let preferredSection = undefined;
+        let preferredFallback = undefined;
+        let current = surface;
+        let depth = 0;
+        while (current && depth < 8) {
+          if (!isHTMLElementNode(current) || !isVisible(current)) {
+            current = current?.parentElement ?? null;
+            depth += 1;
+            continue;
+          }
+
+          const tag = current.tagName.toLowerCase();
+          if (tag === 'article' && !preferredArticle) {
+            preferredArticle = current;
+          } else if (tag === 'section' && !preferredSection) {
+            preferredSection = current;
+          } else if (!preferredFallback && ['main', 'form', 'aside'].includes(tag)) {
+            preferredFallback = current;
+          }
+
+          current = current.parentElement;
+          depth += 1;
+        }
+
+        return preferredArticle || preferredSection || preferredFallback || surface;
+      };
+
+      const chooseNearestHeader = (headers, rect, axis) => {
+        if (headers.length === 0) {
+          return undefined;
+        }
+
+        const centerX = rect.left + rect.width / 2;
+        const centerY = rect.top + rect.height / 2;
+        const ranked = headers
+          .map((header) => {
+            const headerCenterX = header.rect.left + header.rect.width / 2;
+            const headerCenterY = header.rect.top + header.rect.height / 2;
+            const primaryDistance =
+              axis === 'column'
+                ? Math.abs(headerCenterX - centerX)
+                : Math.abs(headerCenterY - centerY);
+            const secondaryDistance =
+              axis === 'column'
+                ? Math.max(0, rect.top - header.rect.bottom)
+                : header.rect.left <= rect.left
+                  ? Math.max(0, rect.left - header.rect.right)
+                  : Math.max(0, header.rect.left - rect.right);
+            return {
+              header,
+              primaryDistance,
+              secondaryDistance,
+            };
+          })
+          .sort((left, right) => {
+            if (left.primaryDistance !== right.primaryDistance) {
+              return left.primaryDistance - right.primaryDistance;
+            }
+            return left.secondaryDistance - right.secondaryDistance;
+          });
+
+        return ranked[0]?.header;
+      };
+
+      const analyzeVisualSeatGridSurface = (surface) => {
+        if (!isPotentialVisualGridSurface(surface)) {
+          return null;
+        }
+
+        const squareNodes = Array.from(surface.querySelectorAll('*')).filter((candidate) =>
+          isVisualGridSquareElement(candidate)
+        );
+        if (squareNodes.length < 16) {
+          return null;
+        }
+
+        const rowHeaders = [];
+        const columnHeaders = [];
+        const seatCells = [];
+
+        for (const candidate of squareNodes) {
+          const rect = candidate.getBoundingClientRect();
+          const tokenKind = visualSeatGridTokenKindOf(candidate);
+          if (tokenKind === 'row') {
+            rowHeaders.push({
+              element: candidate,
+              text: compactText(textOf(candidate)),
+              rect,
+            });
+            continue;
+          }
+          if (tokenKind === 'column') {
+            columnHeaders.push({
+              element: candidate,
+              text: compactText(textOf(candidate)).toUpperCase(),
+              rect,
+            });
+            continue;
+          }
+          if (isVisualSeatCellElement(candidate)) {
+            seatCells.push({
+              element: candidate,
+              rect,
+            });
+          }
+        }
+
+        if (seatCells.length < 8 || rowHeaders.length < 4 || columnHeaders.length < 4) {
+          return null;
+        }
+
+        const topMostColumn = Math.min(...columnHeaders.map((header) => header.rect.top));
+        const topColumnHeaders = columnHeaders
+          .filter((header) => Math.abs(header.rect.top - topMostColumn) <= Math.max(14, header.rect.height))
+          .sort((left, right) => left.rect.left - right.rect.left);
+        if (topColumnHeaders.length < 4) {
+          return null;
+        }
+
+        const ownerSurface = visualSeatGridOwnerSurfaceOf(surface);
+        const descriptors = [];
+
+        for (const seatCell of seatCells) {
+          const rowHeaderCandidates = rowHeaders.filter((header) => {
+            const headerCenterY = header.rect.top + header.rect.height / 2;
+            const seatCenterY = seatCell.rect.top + seatCell.rect.height / 2;
+            return Math.abs(headerCenterY - seatCenterY) <= Math.max(12, seatCell.rect.height);
+          });
+          const preferredRowHeaders = rowHeaderCandidates.filter(
+            (header) => header.rect.right <= seatCell.rect.left + 4
+          );
+          const rowHeader =
+            chooseNearestHeader(
+              preferredRowHeaders.length > 0 ? preferredRowHeaders : rowHeaderCandidates,
+              seatCell.rect,
+              'row'
+            ) || undefined;
+          const columnHeader = chooseNearestHeader(
+            topColumnHeaders.filter((header) => header.rect.bottom <= seatCell.rect.top + 12),
+            seatCell.rect,
+            'column'
+          );
+
+          const row = rowHeader?.text;
+          const column = columnHeader?.text;
+          if (!row || !column) {
+            continue;
+          }
+
+          const label = row + column;
+          const states = visualSeatCellStateOf(seatCell.element);
+          descriptors.push({
+            element: seatCell.element,
+            meta: {
+              kind: 'div',
+              label,
+              interactionHint: 'click',
+              states,
+              structure: {
+                family: 'structured-grid',
+                variant: 'seat-cell',
+                row,
+                column,
+                zone: landmarkLabelOf(ownerSurface) || landmarkLabelOf(surface) || undefined,
+                cellLabel: label,
+              },
+              surface: ownerSurface,
+              surfaceKind: 'grid',
+              hintText: 'Seat map',
+            },
+          });
+        }
+
+        return descriptors.length >= 6 ? descriptors : null;
+      };
+
+      const collectVisualSeatGridElements = (
+        root,
+        limit = collectorElementLimit,
+        acc = [],
+        seen = new Set()
+      ) => {
+        if (!root?.querySelectorAll || acc.length >= limit) {
+          return acc;
+        }
+
+        const squareNodes = Array.from(root.querySelectorAll('*')).filter((candidate) =>
+          isVisualGridSquareElement(candidate)
+        );
+        if (squareNodes.length < 16) {
+          return acc;
+        }
+
+        const candidateSurfaces = new Map();
+        for (const squareNode of squareNodes) {
+          let current = composedParentElement(squareNode);
+          let depth = 0;
+          while (current && depth < 8) {
+            if (isPotentialVisualGridSurface(current)) {
+              candidateSurfaces.set(
+                current,
+                (candidateSurfaces.get(current) || 0) + 1
+              );
+            }
+            current = composedParentElement(current);
+            depth += 1;
+          }
+        }
+
+        const rankedSurfaces = [...candidateSurfaces.entries()]
+          .filter(([, count]) => count >= 16)
+          .sort((left, right) => right[1] - left[1]);
+
+        for (const [surface] of rankedSurfaces) {
+          if (acc.length >= limit) {
+            break;
+          }
+
+          const descriptors = analyzeVisualSeatGridSurface(surface);
+          if (!descriptors) {
+            continue;
+          }
+
+          for (const descriptor of descriptors) {
+            if (acc.length >= limit) {
+              break;
+            }
+            if (seen.has(descriptor.element)) {
+              continue;
+            }
+            seen.add(descriptor.element);
+            visualSeatGridMeta.set(descriptor.element, descriptor.meta);
+            acc.push(descriptor.element);
+          }
+        }
+
+        return acc;
+      };
+
+      const elements = collectInteractiveElements(doc, collectorElementLimit, [], seenElements)
+        .concat(
+          includeActivationAffordances
+            ? collectGenericClickableElements(doc, collectorElementLimit, [], seenElements)
+            : []
+        )
+        .concat(collectVisualSeatGridElements(doc, collectorElementLimit, [], seenElements))
+        .filter((element) => isHTMLElementNode(element))
+        .filter((element) => isVisible(element));
+
+      const localSurfaceCandidateOf = (element) => {
+        const candidates = [itemOf(element), containerOf(element)].filter((candidate) => {
+          return (
+            isHTMLElementNode(candidate) &&
+            candidate !== element &&
+            !candidate.matches?.(overlaySurfaceSelector) &&
+            isVisible(candidate) &&
+            surfacePriorityOf(candidate) > 0
+          );
+        });
+
+        return candidates[0];
+      };
+
+      const surfaceSelectorsOf = (element, localSurface) => {
+        const selectors = [];
+        let current = element.parentElement;
+
+        while (current) {
+          if (current.matches?.(overlaySurfaceSelector)) {
+            const selector = buildSelector(current);
+            if (selector && !selectors.includes(selector)) {
+              selectors.push(selector);
+            }
+          }
+          current = current.parentElement;
+        }
+
+        if (localSurface) {
+          const selector = buildSelector(localSurface);
+          if (selector && !selectors.includes(selector)) {
+            selectors.push(selector);
+          }
+        }
+
+        return selectors.length > 0 ? selectors : undefined;
+      };
+
+      const targets = elements.map((element, ordinal) => {
+        const visualSeatGrid = visualSeatGridMeta.get(element);
+        const labelBackedChoice = labelBackedChoiceControlOf(element);
+        const genericClickable = isGenericClickableElement(element);
+        const effectiveElement = element;
+        const domSignature = domSignatureOf(effectiveElement);
+        const genericCardLike =
+          !labelBackedChoice &&
+          genericClickable &&
+          (isStructuredContainer(element) ||
+            /\b(card|item|result|fare|flight|ticket|offer|row)\b/.test(
+              clickableSemanticBlobOf(element)
+            ));
+        const inferredKind =
+          visualSeatGrid?.kind ||
+          (labelBackedChoice
+            ? (labelBackedChoice.type || '').toLowerCase() === 'checkbox'
+              ? 'checkbox'
+              : 'radio'
+            : genericCardLike
+              ? 'card'
+              : kindOf(element));
+        const rect = element.getBoundingClientRect();
+        const container = containerOf(element);
+        const landmark = composedClosest(element, contextSelector);
+        const group = groupOf(element);
+        const item = itemOf(element);
+        const overlaySurface = composedClosest(element, overlaySurfaceSelector);
+        const localSurface = localSurfaceCandidateOf(element);
+        const selfSurface =
+          genericClickable && !labelBackedChoice && isStructuredContainer(element) ? element : undefined;
+        const surface =
+          visualSeatGrid?.surface ||
+          (isHTMLElementNode(overlaySurface) ? overlaySurface : localSurface || selfSurface);
+        const surfaceSelectors = surfaceSelectorsOf(element, localSurface || selfSurface);
+        const structure = visualSeatGrid?.structure || inferStructuredCell(element, surface);
+        const stableLabel = visualSeatGrid?.label || stableLabelOf(element);
+        const role = inferRole(element);
+        const surfaceKind = visualSeatGrid?.surfaceKind || surfaceKindOf(surface);
+        const form = composedClosest(element, 'form');
+        const testIdAttribute = element.hasAttribute('data-testid')
+          ? 'data-testid'
+          : element.hasAttribute('data-test-id')
+            ? 'data-test-id'
+            : undefined;
+        return {
+          kind: inferredKind,
+          label: visualSeatGrid?.label || labelOf(element) || stableLabel,
+          interactionHint: visualSeatGrid?.interactionHint || (genericClickable ? 'click' : undefined),
+          role,
+          text: textOf(element),
+          placeholder: element.getAttribute('placeholder')?.trim() || undefined,
+          inputName: element.getAttribute('name')?.trim() || undefined,
+          inputType: element.getAttribute('type')?.trim() || undefined,
+          autocomplete: element.getAttribute('autocomplete')?.trim() || undefined,
+          validation: validationEvidenceOf(element),
+          title: element.getAttribute('title')?.trim() || undefined,
+          testId:
+            element.getAttribute('data-testid')?.trim() ||
+            element.getAttribute('data-test-id')?.trim() ||
+            undefined,
+          testIdAttribute,
+          selector: buildSelector(element),
+          framePath: inheritedFramePath.length > 0 ? inheritedFramePath : undefined,
+          frameUrl: inheritedFrameUrl || undefined,
+          pageSignature,
+          domSignature,
+          states:
+            Object.keys({ ...(stateOf(element) || {}), ...(visualSeatGrid?.states || {}) }).length > 0
+              ? { ...(stateOf(element) || {}), ...(visualSeatGrid?.states || {}) }
+              : undefined,
+          surfaceKind,
+          surfaceLabel: landmarkLabelOf(surface),
+          surfaceSelector: surface ? buildSelector(surface) : undefined,
+          surfaceSelectors,
+          surfacePriority: surfacePriorityOf(surface),
+          controlsSurfaceSelector:
+            selectorFromRelation(element, 'aria-controls') || selectorFromRelation(element, 'aria-owns'),
+          formSelector: form ? buildSelector(form) : undefined,
+          descendantInteractiveCount: element.querySelectorAll(selector).length,
+          descendantEditableCount: element.querySelectorAll(
+            'input:not([type="hidden"]), textarea, select, [contenteditable="true"]'
+          ).length,
+          structure,
+          ordinal,
+          context: {
+            item: contextNodeOf(item),
+            group: contextNodeOf(group),
+            container: contextNodeOf(container),
+            landmark: contextNodeOf(landmark),
+            layout: {
+              lane: laneOf(rect),
+              band: bandOf(rect),
+            },
+            hintText: visualSeatGrid?.hintText || contextualHintOf(element),
+            visual: visualOf(element),
+          },
+        };
+      });
+
+      return targets;
+    };
+
+    const enrichDisplayLabels = (targets) => {
+      const repeatedLabels = new Map();
+
+      for (const target of targets) {
+        const label = (target.label || '').trim().toLowerCase();
+        if (!label) continue;
+        repeatedLabels.set(label, (repeatedLabels.get(label) || 0) + 1);
+      }
+
+      const describeContext = (candidate) => {
+        const item = candidate.context?.item;
+        const group = candidate.context?.group;
+        const container = candidate.context?.container;
+        return (
+          candidate.context?.hintText ||
+          item?.label ||
+          item?.text ||
+          group?.label ||
+          group?.text ||
+          container?.label ||
+          candidate.context?.hintText
+        );
+      };
+
+      return targets.map((target) => {
+        const label = (target.label || '').trim();
+        if (!label) return target;
+
+        const repeated = (repeatedLabels.get(label.toLowerCase()) || 0) > 1;
+        if (!repeated) return target;
+
+        const detail = describeContext(target);
+        if (!detail || detail === label) return target;
+
+        const compactDetail = detail.length <= 80 ? detail : detail.slice(0, 80);
+        return {
+          ...target,
+          displayLabel: label + ' — ' + compactDetail,
+        };
+      });
+    };
+
+    const hasUsefulInventorySignal = (candidate) => {
+      if (candidate.label || candidate.text || candidate.placeholder || candidate.title) {
+        return true;
+      }
+
+      if (candidate.structure?.family) {
+        return true;
+      }
+
+      if (candidate.states && Object.keys(candidate.states).length > 0) {
+        return true;
+      }
+
+      const kind = (candidate.kind || '').toLowerCase();
+      const role = (candidate.role || '').toLowerCase();
+      if (['input', 'textarea', 'select'].includes(kind)) {
+        return true;
+      }
+      if (['textbox', 'combobox', 'option', 'menuitem', 'gridcell'].includes(role)) {
+        return true;
+      }
+      if (candidate.controlsSurfaceSelector) {
+        return true;
+      }
+
+      return false;
+    };
+
+    const seen = new Set();
+    return enrichDisplayLabels(collectTargets(document))
+      .filter((candidate) => {
+        const frameKey = candidate.framePath ? candidate.framePath.join(' -> ') : 'top';
+        const key = frameKey + '|' + (candidate.selector || candidate.domSignature || '');
+        if (!candidate.selector && !candidate.domSignature) return false;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return hasUsefulInventorySignal(candidate);
+      })
+      .slice(0, collectorOutputLimit);
+  })()`);
+    if (!Array.isArray(observedTargets)) {
+        return [];
+    }
+    return observedTargets
+        .filter((target) => Boolean(target && typeof target === 'object' && typeof target.kind === 'string'))
+        .map((target) => enrichObservedTargetSemantics(applyInheritedDomTargetMetadata(target, {
+        framePath: options?.framePath,
+        frameUrl: options?.frameUrl,
+        pageSignature: options?.pageSignature,
+    })));
+}
+async function collectPageSignalsFromDocument(context, options) {
+    const inheritedFramePath = JSON.stringify(options?.framePath ?? []);
+    const inheritedFrameUrl = JSON.stringify(options?.frameUrl ?? '');
+    const observedSignals = await context.evaluate(String.raw `(() => {
+    const inheritedFramePath = ${inheritedFramePath};
+    const inheritedFrameUrl = ${inheritedFrameUrl};
+    const limit = ${DOM_SIGNAL_COLLECTION_LIMIT};
+    const interactiveSelector =
+      'button, a[href], input:not([type="hidden"]), textarea, select, [role="button"], [role="link"], [role="textbox"], [role="combobox"], [role="option"], [role="gridcell"], [contenteditable="true"], [tabindex]:not([tabindex="-1"])';
+    const explicitSelector = [
+      '[role="alert"]',
+      '[role="status"]',
+      '[aria-live="assertive"]',
+      '[aria-live="polite"]',
+      '[role="dialog"]',
+      '[aria-modal="true"]',
+      '[class*="toast"]',
+      '[class*="snackbar"]',
+      '[class*="banner"]',
+      '[class*="notice"]',
+      '[class*="success"]',
+      '[class*="error"]',
+      '[class*="warning"]',
+      '[data-testid*="toast"]',
+      '[data-testid*="banner"]',
+      '[data-testid*="alert"]',
+      '[data-testid*="success"]',
+      '[data-testid*="error"]',
+      '[aria-busy="true"]',
+      '[role="progressbar"]',
+      'button[disabled]',
+    ].join(', ');
+    const candidateSelector = 'h1, h2, h3, p, section, article, div, [role="region"]';
+    const outcomeTextRe =
+      /(?:thanks|thank you|success(?:ful|fully)?|receipt|order|confirmed|complete(?:d)?|declin(?:e|ed)|fail(?:ed|ure)|error|unable|try again|verification|verify|challenge|captcha|processing|pending|approved|denied)/i;
+
+    const normalizeText = (value) => (value ?? '').replace(/\s+/g, ' ').trim();
+    const sampleText = (value, maxLength) => {
+      const normalized = normalizeText(value);
+      if (!normalized) {
+        return '';
+      }
+      if (normalized.length <= maxLength) {
+        return normalized;
+      }
+      return normalized.slice(0, maxLength - 1).trimEnd() + '…';
+    };
+    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 textOf = (element) => {
+      if (!(element instanceof HTMLElement)) {
+        return '';
+      }
+      return sampleText(element.innerText || element.textContent || '', 240);
+    };
+    const hasVisibleInteractiveDescendant = (element) => {
+      if (!(element instanceof HTMLElement)) {
+        return false;
+      }
+      return Array.from(element.querySelectorAll(interactiveSelector)).some(
+        (candidate) => candidate !== element && candidate instanceof HTMLElement && isVisible(candidate)
+      );
+    };
+    const hasNestedOutcomeCandidate = (element) => {
+      if (!(element instanceof HTMLElement)) {
+        return false;
+      }
+      return Array.from(
+        element.querySelectorAll(
+          'h1, h2, h3, p, [role="alert"], [role="status"], [aria-live="assertive"], [aria-live="polite"]'
+        )
+      ).some((candidate) => {
+        if (!(candidate instanceof HTMLElement) || candidate === element || !isVisible(candidate)) {
+          return false;
+        }
+        return outcomeTextRe.test(normalizeText(candidate.innerText || candidate.textContent || ''));
+      });
+    };
+    const signalKindOf = (element, text) => {
+      const role = element.getAttribute('role') || '';
+      const ariaLive = element.getAttribute('aria-live') || '';
+      const classBlob =
+        ((element.getAttribute('class') || '') + ' ' + Object.values(element.dataset || {}).join(' ')).toLowerCase();
+
+      if (role === 'dialog' || element.getAttribute('aria-modal') === 'true') {
+        return 'dialog';
+      }
+      if (role === 'alert' || ariaLive === 'assertive') {
+        return 'alert';
+      }
+      if (
+        role === 'status' ||
+        ariaLive === 'polite' ||
+        element.hasAttribute('aria-busy') ||
+        element.matches('button[disabled], [role="progressbar"]')
+      ) {
+        return 'status';
+      }
+      if (/toast|snackbar|banner|notice|warning|error|success/.test(classBlob)) {
+        return outcomeTextRe.test(text) ? 'outcome' : 'notice';
+      }
+      return outcomeTextRe.test(text) ? 'outcome' : 'notice';
+    };
+
+    const seen = new Set();
+    const signals = [];
+    const pushSignal = (kind, text) => {
+      const normalized = sampleText(text, 240);
+      if (!normalized) {
+        return;
+      }
+      const key = kind + '|' + normalized.toLowerCase();
+      if (seen.has(key)) {
+        return;
+      }
+      seen.add(key);
+      signals.push({
+        kind,
+        text: normalized,
+        framePath: inheritedFramePath.length > 0 ? inheritedFramePath : undefined,
+        frameUrl: inheritedFrameUrl || undefined,
+        source: 'dom',
+      });
+      if (signals.length > limit) {
+        signals.length = limit;
+      }
+    };
+
+    for (const element of Array.from(document.querySelectorAll(explicitSelector))) {
+      if (!(element instanceof HTMLElement) || !isVisible(element)) {
+        continue;
+      }
+      const text = textOf(element);
+      if (!text) {
+        continue;
+      }
+      pushSignal(signalKindOf(element, text), text);
+      if (signals.length >= limit) {
+        return signals;
+      }
+    }
+
+    for (const element of Array.from(document.querySelectorAll(candidateSelector))) {
+      if (!(element instanceof HTMLElement) || !isVisible(element)) {
+        continue;
+      }
+      const text = textOf(element);
+      if (text.length < 12 || text.length > 240 || !outcomeTextRe.test(text)) {
+        continue;
+      }
+      if (hasVisibleInteractiveDescendant(element) || hasNestedOutcomeCandidate(element)) {
+        continue;
+      }
+      pushSignal(signalKindOf(element, text), text);
+      if (signals.length >= limit) {
+        break;
+      }
+    }
+
+    return signals;
+  })()`);
+    if (!Array.isArray(observedSignals)) {
+        return [];
+    }
+    return observedSignals.filter((signal) => Boolean(signal &&
+        typeof signal === 'object' &&
+        typeof signal.kind === 'string' &&
+        typeof signal.text === 'string' &&
+        signal.text.length > 0)).map((signal) => applyInheritedSignalMetadata(signal, {
+        framePath: options?.framePath,
+        frameUrl: options?.frameUrl,
+    }));
+}
+const FRAME_HOST_DESCRIPTOR_SCRIPT = String.raw `
+  const ownerWindowOf = (node) => node?.ownerDocument?.defaultView || window;
+  const isHTMLElementNode = (value) => {
+    const view = ownerWindowOf(value);
+    return Boolean(view && value instanceof view.HTMLElement);
+  };
+  const isShadowRootNode = (value) => {
+    const view = ownerWindowOf(value);
+    return Boolean(view && value instanceof view.ShadowRoot);
+  };
+  const composedParentElement = (element) => {
+    if (!isHTMLElementNode(element)) return undefined;
+    if (element.parentElement) return element.parentElement;
+    const root = element.getRootNode?.();
+    if (isShadowRootNode(root) && isHTMLElementNode(root.host)) {
+      return root.host;
+    }
+    return undefined;
+  };
+  const cssEscape = (value) =>
+    typeof CSS !== 'undefined' && typeof CSS.escape === 'function'
+      ? CSS.escape(value)
+      : String(value || '').replace(/["\\]/g, '\\$&');
+  const queryRootOf = (candidate) => {
+    const root = candidate.getRootNode?.();
+    return root && typeof root.querySelectorAll === 'function' ? root : document;
+  };
+  const isUserVisible = (candidate) => {
+    if (!isHTMLElementNode(candidate)) return false;
+
+    const view = ownerWindowOf(candidate);
+    const style = view?.getComputedStyle?.(candidate);
+    if (!style) {
+      return false;
+    }
+    if (style.display === 'none' || style.visibility === 'hidden' || style.visibility === 'collapse') {
+      return false;
+    }
+
+    const opacity = Number(style.opacity || '1');
+    if (Number.isFinite(opacity) && opacity <= 0.01) {
+      return false;
+    }
+
+    if (candidate.getAttribute('aria-hidden') === 'true' || candidate.inert) {
+      return false;
+    }
+
+    const rect = candidate.getBoundingClientRect();
+    if (!rect || rect.width < 4 || rect.height < 4) {
+      return false;
+    }
+
+    const viewportWidth =
+      view?.innerWidth ||
+      candidate.ownerDocument?.documentElement?.clientWidth ||
+      0;
+    const viewportHeight =
+      view?.innerHeight ||
+      candidate.ownerDocument?.documentElement?.clientHeight ||
+      0;
+    if (viewportWidth > 0 && viewportHeight > 0) {
+      if (rect.bottom <= 0 || rect.right <= 0 || rect.top >= viewportHeight || rect.left >= viewportWidth) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+  const isSelectorUniqueFor = (candidate, selectorValue) => {
+    const queryRoot = queryRootOf(candidate);
+    try {
+      const matches = Array.from(queryRoot.querySelectorAll(selectorValue));
+      return matches.length === 1 && matches[0] === candidate;
+    } catch {
+      return false;
+    }
+  };
+
+  if (!(element instanceof HTMLIFrameElement || element instanceof HTMLFrameElement)) {
+    return null;
+  }
+
+  const descriptorOf = (selector) =>
+    selector
+      ? {
+          selector,
+          userVisible: isUserVisible(element),
+        }
+      : null;
+
+  const tag = element.tagName.toLowerCase();
+  const testId =
+    element.getAttribute('data-testid')?.trim() ||
+    element.getAttribute('data-test-id')?.trim();
+  const testIdAttribute = element.hasAttribute('data-testid')
+    ? 'data-testid'
+    : element.hasAttribute('data-test-id')
+      ? 'data-test-id'
+      : undefined;
+  const name = element.getAttribute('name')?.trim();
+  const title = element.getAttribute('title')?.trim();
+  const src = element.getAttribute('src')?.trim();
+
+  if (element.id && isSelectorUniqueFor(element, '#' + cssEscape(element.id))) {
+    return descriptorOf('#' + cssEscape(element.id));
+  }
+  if (testId) {
+    const selectorValue = testIdAttribute
+      ? '[' + testIdAttribute + '="' + cssEscape(testId) + '"]'
+      : undefined;
+    if (isSelectorUniqueFor(element, selectorValue)) {
+      return descriptorOf(selectorValue);
+    }
+  }
+  if (name) {
+    const selectorValue = tag + '[name="' + cssEscape(name) + '"]';
+    if (isSelectorUniqueFor(element, selectorValue)) {
+      return descriptorOf(selectorValue);
+    }
+  }
+  if (title) {
+    const selectorValue = tag + '[title="' + cssEscape(title) + '"]';
+    if (isSelectorUniqueFor(element, selectorValue)) {
+      return descriptorOf(selectorValue);
+    }
+  }
+  if (src) {
+    const selectorValue = tag + '[src="' + cssEscape(src) + '"]';
+    if (isSelectorUniqueFor(element, selectorValue)) {
+      return descriptorOf(selectorValue);
+    }
+  }
+
+  const segmentOf = (current) => {
+    if (current.id && isSelectorUniqueFor(current, '#' + cssEscape(current.id))) {
+      return '#' + cssEscape(current.id);
+    }
+
+    const currentTestId =
+      current.getAttribute('data-testid')?.trim() ||
+      current.getAttribute('data-test-id')?.trim();
+    const currentTestIdAttribute = current.hasAttribute('data-testid')
+      ? 'data-testid'
+      : current.hasAttribute('data-test-id')
+        ? 'data-test-id'
+        : undefined;
+    if (currentTestId) {
+      const selectorValue = currentTestIdAttribute
+        ? '[' + currentTestIdAttribute + '="' + cssEscape(currentTestId) + '"]'
+        : undefined;
+      if (isSelectorUniqueFor(current, selectorValue)) {
+        return selectorValue;
+      }
+    }
+
+    const currentName = current.getAttribute('name')?.trim();
+    const currentTitle = current.getAttribute('title')?.trim();
+    const currentTag = current.tagName.toLowerCase();
+
+    if (currentName) {
+      const selectorValue = currentTag + '[name="' + cssEscape(currentName) + '"]';
+      if (isSelectorUniqueFor(current, selectorValue)) {
+        return selectorValue;
+      }
+    }
+
+    if (currentTitle) {
+      const selectorValue = currentTag + '[title="' + cssEscape(currentTitle) + '"]';
+      if (isSelectorUniqueFor(current, selectorValue)) {
+        return selectorValue;
+      }
+    }
+
+    const parent = current.parentElement;
+    const root = current.getRootNode?.();
+    const siblingPool = parent
+      ? Array.from(parent.children)
+      : isShadowRootNode(root)
+        ? Array.from(root.children)
+        : [];
+    const siblings = siblingPool.filter((child) => child.tagName.toLowerCase() === currentTag);
+    const index = siblings.indexOf(current) + 1;
+    return currentTag + ':nth-of-type(' + Math.max(index, 1) + ')';
+  };
+
+  const path = [];
+  let current = element;
+  while (current && current.nodeType === Node.ELEMENT_NODE && path.length < 8) {
+    path.unshift(segmentOf(current));
+    if (current.id) {
+      break;
+    }
+    current = current.parentElement;
+  }
+
+  if (path.length === 0) return null;
+
+  const structuralSelector = path.join(' > ');
+  const selector = isSelectorUniqueFor(element, structuralSelector) ? structuralSelector : null;
+  return descriptorOf(selector);
+`;
+async function readFrameHostDescriptor(frame) {
+    const frameElement = await frame.frameElement().catch(() => null);
+    if (!frameElement) {
+        return null;
+    }
+    try {
+        const descriptor = await frameElement.evaluate((element, source) => Function('element', source)(element), FRAME_HOST_DESCRIPTOR_SCRIPT);
+        if (!descriptor ||
+            typeof descriptor !== 'object' ||
+            typeof descriptor.selector !== 'string' ||
+            descriptor.selector.length === 0 ||
+            typeof descriptor.userVisible !== 'boolean') {
+            return null;
+        }
+        return descriptor;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await frameElement.dispose().catch(() => undefined);
+    }
+}
+export async function collectDomTargets(page, options) {
+    const topLevelPageSignature = typeof page.url === 'function' ? normalizePageSignature(page.url()) : options?.pageSignature;
+    if (typeof page.mainFrame !== 'function') {
+        return collectDomTargetsFromDocument(page, {
+            ...options,
+            pageSignature: topLevelPageSignature,
+        });
+    }
+    const collected = [];
+    const includeActivationAffordances = options?.includeActivationAffordances === true;
+    const walk = async (frame, framePath) => {
+        if (collected.length >= DOM_TARGET_COLLECTION_LIMIT) {
+            return;
+        }
+        const frameUrl = frame.url().trim() || undefined;
+        const targets = await collectDomTargetsFromDocument(frame, {
+            includeActivationAffordances,
+            pageSignature: topLevelPageSignature,
+            framePath,
+            frameUrl,
+        }).catch(() => []);
+        for (const target of targets) {
+            if (collected.length >= DOM_TARGET_COLLECTION_LIMIT) {
+                break;
+            }
+            collected.push(target);
+        }
+        if (collected.length >= DOM_TARGET_COLLECTION_LIMIT) {
+            return;
+        }
+        for (const childFrame of frame.childFrames().slice(0, 20)) {
+            if (collected.length >= DOM_TARGET_COLLECTION_LIMIT) {
+                break;
+            }
+            const frameHost = await readFrameHostDescriptor(childFrame);
+            if (!frameHost?.selector || !frameHost.userVisible) {
+                continue;
+            }
+            await walk(childFrame, [...(framePath ?? []), frameHost.selector]);
+        }
+    };
+    await walk(page.mainFrame());
+    return collected;
+}
+export async function collectPageSignals(page) {
+    if (typeof page.mainFrame !== 'function') {
+        return collectPageSignalsFromDocument(page);
+    }
+    const collected = [];
+    const seen = new Set();
+    const pushSignals = (signals) => {
+        for (const signal of signals) {
+            const key = [signal.kind, signal.text.toLowerCase(), signal.framePath?.join('>') ?? 'top'].join('|');
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            collected.push(signal);
+            if (collected.length >= DOM_SIGNAL_COLLECTION_LIMIT) {
+                break;
+            }
+        }
+    };
+    const walk = async (frame, framePath) => {
+        if (collected.length >= DOM_SIGNAL_COLLECTION_LIMIT) {
+            return;
+        }
+        const frameUrl = frame.url().trim() || undefined;
+        const signals = await collectPageSignalsFromDocument(frame, {
+            framePath,
+            frameUrl,
+        }).catch(() => []);
+        pushSignals(signals);
+        if (collected.length >= DOM_SIGNAL_COLLECTION_LIMIT) {
+            return;
+        }
+        for (const childFrame of frame.childFrames().slice(0, 20)) {
+            if (collected.length >= DOM_SIGNAL_COLLECTION_LIMIT) {
+                break;
+            }
+            const frameHost = await readFrameHostDescriptor(childFrame);
+            if (!frameHost?.selector || !frameHost.userVisible) {
+                continue;
+            }
+            await walk(childFrame, [...(framePath ?? []), frameHost.selector]);
+        }
+    };
+    await walk(page.mainFrame());
+    return collected;
+}
+export const __testDomTargetCollection = {
+    collectDomTargetsFromDocument,
+    collectPageSignalsFromDocument,
+    locatorDomSignatureScript: LOCATOR_DOM_SIGNATURE_SCRIPT,
+};
+export const __testStagehandDescriptor = {
+    normalizeStagehandSelector,
+    readStagehandDomFacts,
+    readStagehandDomFactsInBrowser,
+    stagehandDomFactsScript: STAGEHAND_DOM_FACTS_SCRIPT,
+};