extension.js · part 1

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/extensions/cursor-browser-automation/dist/extension.js, part 1. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

use strict

Cursor IDE Browser Automation

${t}: ${e.message}

${e}: ${n.message}

[${r}] [${t}] [${e}] ${n}

function getParentElementAcrossShadow(element) {
    if (!element) return null;
    if (element.parentElement) return element.parentElement;
    const root = element.getRootNode ? element.getRootNode() : null;
    if (root && root.host && root.host.nodeType === Node.ELEMENT_NODE) {
        return root.host;
    }
    return null;
}

function walkComposedElements(root, visitor) {
    function visitContainer(container) {
        const children = container && container.children ? Array.from(container.children) : [];
        for (const child of children) {
            if (visitElement(child)) {
                return true;
            }
        }
        return false;
    }

    function visitElement(element) {
        if (visitor(element)) {
            return true;
        }
        if (element.shadowRoot && element.shadowRoot.mode === 'open') {
            if (visitContainer(element.shadowRoot)) {
                return true;
            }
        }
        return visitContainer(element);
    }

    return visitContainer(root);
}

function querySelectorAllIncludingOpenShadowRoots(selector) {
    const matches = [];
    walkComposedElements(document, (element) => {
        try {
            if (element.matches && element.matches(selector)) {
                matches.push(element);
            }
        } catch (_) { }
        return false;
    });
    return matches;
}

function findElementByIdAcrossRoots(id, preferredRoot) {
    if (!id) return null;

    function findElementByIdWithinRoot(root) {
        let match = null;
        walkComposedElements(root, (element) => {
            if (element.id === id) {
                match = element;
                return true;
            }
            return false;
        });
        return match;
    }

    const rootsToSearch = [];
    if (preferredRoot) {
        rootsToSearch.push(preferredRoot);
    }
    if (preferredRoot !== document) {
        rootsToSearch.push(document);
    }
    for (const root of rootsToSearch) {
        try {
            if (root && typeof root.getElementById === 'function') {
                const element = root.getElementById(id);
                if (element) {
                    return element;
                }
            }
            if (root && typeof root.querySelector === 'function') {
                const element = root.querySelector('#' + CSS.escape(String(id)));
                if (element) {
                    return element;
                }
            }
            const nestedElement = findElementByIdWithinRoot(root);
            if (nestedElement) {
                return nestedElement;
            }
        } catch (_) { }
    }
    return null;
}

function isElementHiddenForAria(element) {
    if (!element) return true;
    const tag = element.tagName?.toUpperCase();
    if (['STYLE', 'SCRIPT', 'NOSCRIPT', 'TEMPLATE'].includes(tag)) return true;
    if (element.getAttribute('aria-hidden') === 'true') return true;

    const style = window.getComputedStyle(element);
    if (!style) return false;

    if (style.visibility === 'hidden' || style.visibility === 'collapse') return true;
    if (style.display === 'none') return true;

    let parent = getParentElementAcrossShadow(element);
    while (parent && parent !== document.body) {
        if (parent.getAttribute('aria-hidden') === 'true') return true;
        const parentStyle = window.getComputedStyle(parent);
        if (parentStyle?.display === 'none') return true;
        parent = getParentElementAcrossShadow(parent);
    }

    return false;
}

function getTextFromIds(ids, preferredRoot) {
    try {
        if (!ids) return '';
        const parts = [];
        ids.split(/\s+/).forEach(id => {
            const el = findElementByIdAcrossRoots(id, preferredRoot);
            if (el) {
                const t = (el.innerText || el.textContent || '').trim();
                if (t) parts.push(t);
            }
        });
        return parts.join(' ').trim();
    } catch (_) { return ''; }
}

function getVisibleText(el) {
    try {
        const parts = [];
        const state = { length: 0, maxLength: 240 };

        function collectVisibleTextParts(node) {
            if (!node || state.length > state.maxLength) {
                return;
            }

            if (node.nodeType === Node.TEXT_NODE) {
                const parent = node.parentElement;
                if (parent && isElementHiddenForAria(parent)) {
                    return;
                }
                const text = node.textContent || '';
                const clean = text.replace(/\s+/g, ' ').trim();
                if (clean) {
                    parts.push(clean);
                    state.length += clean.length + 1;
                }
                return;
            }

            if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {
                return;
            }

            if (node.nodeType === Node.ELEMENT_NODE) {
                const element = node;
                const tag = element.tagName?.toUpperCase();
                if (['STYLE', 'SCRIPT', 'NOSCRIPT', 'TEMPLATE'].includes(tag)) {
                    return;
                }
                if (isElementHiddenForAria(element)) {
                    return;
                }
                if (tag === 'SLOT') {
                    const assignedNodes = typeof element.assignedNodes === 'function'
                        ? element.assignedNodes({ flatten: true })
                        : [];
                    const slotChildren = assignedNodes.length > 0 ? assignedNodes : Array.from(element.childNodes || []);
                    for (const child of slotChildren) {
                        collectVisibleTextParts(child);
                        if (state.length > state.maxLength) {
                            break;
                        }
                    }
                    return;
                }
                if (element.shadowRoot && element.shadowRoot.mode === 'open') {
                    collectVisibleTextParts(element.shadowRoot);
                    return;
                }
            }

            const children = Array.from(node.childNodes || []);
            for (const child of children) {
                collectVisibleTextParts(child);
                if (state.length > state.maxLength) {
                    break;
                }
            }
        }

        collectVisibleTextParts(el);
        if (parts.length) {
            return parts.join(' ').trim().substring(0, 200);
        }
        const fallback = (el.innerText || el.textContent || '').replace(/\s+/g, ' ').trim();
        return fallback.substring(0, 200);
    } catch (_) {
        try {
            const text = (el.innerText || '').replace(/\s+/g, ' ').trim();
            return text.substring(0, 200);
        } catch (_) {
            return '';
        }
    }
}

function getLabelsText(el) {
    try {
        const labels = (el.labels && Array.from(el.labels)) || [];
        if (!labels.length) return '';
        const labelText = labels
            .map(label => getVisibleText(label) || (label.textContent || '').trim())
            .filter(Boolean)
            .join(' ')
            .trim();
        return labelText.substring(0, 200);
    } catch (_) {
        return '';
    }
}

function getImplicitRole(el) {
    try {
        const tag = el.tagName ? el.tagName.toLowerCase() : '';
        switch (tag) {
            case 'a':
                return el.hasAttribute('href') ? 'link' : null;
            case 'area':
                return el.hasAttribute('href') ? 'link' : null;
            case 'article':
                return 'article';
            case 'aside':
                return 'complementary';
            case 'button':
                return 'button';
            case 'datalist':
                return 'listbox';
            case 'details':
                return 'group';
            case 'dialog':
                return 'dialog';
            case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
                return 'heading';
            case 'hr':
                return 'separator';
            case 'img':
                return (el.getAttribute('alt') === '' && !el.getAttribute('title')) ? null : 'img';
            case 'input': {
                const type = (el.type || el.getAttribute('type') || 'text').toLowerCase();
                if (type === 'button' || type === 'submit' || type === 'reset' || type === 'image') return 'button';
                if (type === 'checkbox') return 'checkbox';
                if (type === 'radio') return 'radio';
                if (type === 'range') return 'slider';
                if (type === 'number') return 'spinbutton';
                if (type === 'search') return el.hasAttribute('list') ? 'combobox' : 'searchbox';
                if (type === 'hidden') return null;
                if (['email', 'tel', 'text', 'url', 'password', ''].includes(type)) {
                    const list = el.getAttribute('list');
                    if (list) {
                        const datalist = findElementByIdAcrossRoots(list, el.getRootNode ? el.getRootNode() : document);
                        if (datalist && datalist.tagName === 'DATALIST') return 'combobox';
                    }
                    return 'textbox';
                }
                return 'textbox';
            }
            case 'li':
                return 'listitem';
            case 'main':
                return 'main';
            case 'math':
                return 'math';
            case 'menu':
                return 'list';
            case 'meter':
                return 'meter';
            case 'nav':
                return 'navigation';
            case 'ol': case 'ul':
                return 'list';
            case 'optgroup':
                return 'group';
            case 'option':
                return 'option';
            case 'output':
                return 'status';
            case 'progress':
                return 'progressbar';
            case 'search':
                return 'search';
            case 'select':
                return el.hasAttribute('multiple') || (el.size > 1) ? 'listbox' : 'combobox';
            case 'summary':
                return 'button';
            case 'table':
                return 'table';
            case 'tbody': case 'tfoot': case 'thead':
                return 'rowgroup';
            case 'td':
                return 'cell';
            case 'textarea':
                return 'textbox';
            case 'th':
                return 'columnheader';
            case 'tr':
                return 'row';
            case 'section':
                return (el.hasAttribute('aria-label') || el.hasAttribute('aria-labelledby')) ? 'region' : null;
            case 'form':
                return (el.hasAttribute('aria-label') || el.hasAttribute('aria-labelledby')) ? 'form' : null;
            case 'header':
                return 'banner';
            case 'footer':
                return 'contentinfo';
            case 'svg':
                return 'img';
            default:
                return null;
        }
    } catch (_) {
        return null;
    }
}

function getAriaRole(el) {
    const explicitRole = el.getAttribute('role');
    if (explicitRole) {
        const roles = explicitRole.split(' ').map(r => r.trim()).filter(Boolean);
        if (roles.length > 0) return roles[0];
    }
    return getImplicitRole(el);
}

function computeAccessibleName(el, role) {
    try {
        if (!el || el.getAttribute('aria-hidden') === 'true') {
            return '';
        }

        const labelledBy = el.getAttribute('aria-labelledby');
        const fromLabelledBy = getTextFromIds(labelledBy, el.getRootNode ? el.getRootNode() : document);
        if (fromLabelledBy) return fromLabelledBy.substring(0, 200);

        const ariaLabel = (el.getAttribute('aria-label') || '').trim();
        if (ariaLabel) return ariaLabel.substring(0, 200);

        const ariaPlaceholder = (el.getAttribute('aria-placeholder') || '').trim();
        if (ariaPlaceholder) return ariaPlaceholder.substring(0, 200);

        const labelsText = getLabelsText(el);
        if (labelsText) return labelsText.substring(0, 200);

        const tag = el.tagName ? el.tagName.toLowerCase() : '';

        if (tag === 'img') {
            const alt = (el.getAttribute('alt') || '').trim();
            if (alt) return alt.substring(0, 200);
        }

        if (tag === 'input') {
            const type = (el.getAttribute('type') || 'text').toLowerCase();
            const value = el.value || el.getAttribute('value') || '';
            const placeholder = (el.getAttribute('placeholder') || '').trim();
            if (type === 'button' || type === 'submit' || type === 'reset') {
                if (value) return String(value).substring(0, 200);
            }
            if (placeholder) return placeholder.substring(0, 200);
            if (value && type !== 'password') return String(value).substring(0, 200);
        }

        if (tag === 'textarea') {
            const placeholder = (el.getAttribute('placeholder') || '').trim();
            if (placeholder) return placeholder.substring(0, 200);
            if (el.value) return String(el.value).substring(0, 200);
        }

        if (tag === 'select') {
            const selected = Array.from(el.selectedOptions || [])
                .map(option => getVisibleText(option) || (option.textContent || '').trim())
                .filter(Boolean)
                .join(', ')
                .trim();
            if (selected) return selected.substring(0, 200);
        }

        const roleLower = (role || '').toLowerCase();
        const interactiveRoles = new Set(['button', 'link', 'menuitem', 'option', 'tab', 'checkbox', 'radio', 'switch', 'combobox', 'textbox', 'listbox', 'slider', 'spinbutton', 'cell', 'gridcell', 'row', 'columnheader', 'rowheader']);
        const interactiveTags = new Set(['button', 'a', 'summary', 'label', 'option', 'textarea', 'select', 'time']);
        const headingTags = new Set(['h1','h2','h3','h4','h5','h6']);
        if (interactiveRoles.has(roleLower) || interactiveTags.has(tag) || headingTags.has(tag)) {
            const visible = getVisibleText(el);
            if (visible) return visible.substring(0, 200);
        }

        if (tag === 'p' || tag === 'li' || roleLower === 'heading') {
            const visible = getVisibleText(el);
            if (visible) return visible.substring(0, 200);
        }

        const title = (el.getAttribute('title') || '').trim();
        if (title) return title.substring(0, 200);

        return '';
    } catch (_) {
        return '';
    }
}

function buildPageSnapshot(options = {}) {
    const maxDepth = options.maxDepth || 30;
    const interactiveOnly = options.interactive || false;
    const compact = options.compact || false;
    const selector = options.selector || null;

    function collectElementStates(el, role) {
        const states = [];
        try {
            if (document.activeElement === el) {
                states.push('active');
                states.push('focused');
            }
            if (el.matches && el.matches(':checked')) states.push('checked');
            const ariaChecked = el.getAttribute('aria-checked');
            if (ariaChecked === 'true') states.push('checked');
            if (ariaChecked === 'mixed') states.push('indeterminate');
            if (el.matches && el.matches(':disabled')) states.push('disabled');
            if (el.disabled) states.push('disabled');
            let parent = getParentElementAcrossShadow(el);
            while (parent) {
                if (parent.tagName === 'FIELDSET' && parent.disabled) {
                    states.push('disabled');
                    break;
                }
                parent = getParentElementAcrossShadow(parent);
            }
            if (el.matches && el.matches(':required')) states.push('required');
            if (el.matches && el.matches(':read-only') && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA')) states.push('readonly');
            if (el.readOnly) states.push('readonly');
            if (el.selected) states.push('selected');
            const ariaSelected = el.getAttribute('aria-selected');
            if (ariaSelected === 'true') states.push('selected');
            const ariaExpanded = el.getAttribute('aria-expanded');
            if (ariaExpanded === 'true') states.push('expanded');
            if (ariaExpanded === 'false') states.push('collapsed');
            const ariaPressed = el.getAttribute('aria-pressed');
            if (ariaPressed === 'true') states.push('pressed');
            if (ariaPressed === 'false') states.push('released');
            if (el.getAttribute && el.getAttribute('aria-current')) states.push('current');
            if (el.getAttribute && el.getAttribute('aria-invalid') === 'true') states.push('invalid');
            if (el.getAttribute && el.getAttribute('aria-busy') === 'true') states.push('busy');
        } catch (_) { }
        return Array.from(new Set(states));
    }

    function collectElementDetails(el, role) {
        const details = {};
        try {
            const tag = el.tagName ? el.tagName.toLowerCase() : '';
            const ariaDescription = (el.getAttribute('aria-description') || '').trim();
            if (ariaDescription) {
                details.description = ariaDescription.substring(0, 200);
            }
            const describedBy = getTextFromIds(el.getAttribute('aria-describedby'), el.getRootNode ? el.getRootNode() : document);
            if (describedBy) {
                details.description = details.description
                    ? (details.description + ' ' + describedBy.substring(0, 200)).trim()
                    : describedBy.substring(0, 200);
            }
            if (tag === 'a' && el.hasAttribute('href')) {
                details.url = el.getAttribute('href');
            }
            if ((tag === 'img' || tag === 'svg') && el.hasAttribute('src')) {
                details.src = el.getAttribute('src');
            }
            if (tag === 'input' || tag === 'textarea') {
                const type = (el.getAttribute('type') || 'text').toLowerCase();
                const value = el.value || el.getAttribute('value') || '';
                if (value && (tag !== 'input' || type !== 'password')) {
                    details.value = String(value).substring(0, 200);
                }
                const placeholder = (el.getAttribute('placeholder') || '').trim();
                if (placeholder) {
                    details.placeholder = placeholder.substring(0, 200);
                }
            }
            if (tag === 'select') {
                const selected = Array.from(el.selectedOptions || [])
                    .map(option => getVisibleText(option) || (option.textContent || '').trim())
                    .filter(Boolean);
                if (selected.length) {
                    details.value = selected.join(', ').substring(0, 200);
                }
                const allOptions = Array.from(el.options || []);
                if (allOptions.length > 0 && allOptions.length <= 20) {
                    details.options = allOptions.map(opt => {
                        const label = (opt.textContent || '').trim();
                        const value = opt.value;
                        const disabled = opt.disabled;
                        let optStr = label;
                        if (value && value !== label) {
                            optStr += ' (value: ' + value + ')';
                        }
                        if (disabled) {
                            optStr += ' [disabled]';
                        }
                        return optStr;
                    }).join(', ');
                } else if (allOptions.length > 20) {
                    details.options = allOptions.slice(0, 10).map(opt => {
                        const label = (opt.textContent || '').trim();
                        return label;
                    }).join(', ') + '... (' + allOptions.length + ' total options)';
                }
            }
            if (role === 'combobox' && el.getAttribute('aria-activedescendant')) {
                details.activeDescendant = el.getAttribute('aria-activedescendant');
            }
        } catch (_) { }
        return details;
    }

    function shouldIncludeElement(el) {
        try {
            if (!el || el.getAttribute('aria-hidden') === 'true') {
                return false;
            }
            const tag = el.tagName ? el.tagName.toLowerCase() : '';
            const role = el.getAttribute('role') || getImplicitRole(el);
            const meaningfulTags = new Set(['a', 'button', 'input', 'select', 'textarea', 'img', 'svg', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'nav', 'main', 'header', 'footer', 'section', 'article', 'form', 'label', 'ul', 'ol', 'li', 'p', 'strong', 'em', 'small', 'time', 'option', 'summary', 'details']);
            if (meaningfulTags.has(tag)) {
                return true;
            }
            if (role && role !== 'generic') {
                return true;
            }
            if (el.getAttribute('aria-label') || el.getAttribute('aria-labelledby')) {
                return true;
            }
            if (el.matches && el.matches('[contenteditable="true"]')) {
                return true;
            }
            if (el.querySelector && el.querySelector('a, button, input, select, textarea, [role], [contenteditable="true"]')) {
                return true;
            }
        } catch (_) {
            return true;
        }
        return false;
    }

    const INTERACTIVE_ROLES = new Set([
        'button', 'link', 'textbox', 'checkbox', 'radio', 'combobox', 'listbox',
        'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'slider',
        'spinbutton', 'switch', 'tab', 'treeitem', 'searchbox'
    ]);

    function isValidRef(ref) {
        return typeof ref === 'string' && /^e\d+$/.test(ref);
    }

    function getMaxRefIndex() {
        let maxIndex = -1;
        const existing = querySelectorAllIncludingOpenShadowRoots('[data-cursor-ref]');
        for (const el of existing) {
            const ref = el.getAttribute('data-cursor-ref');
            if (isValidRef(ref)) {
                const num = parseInt(ref.substring(1), 10);
                if (!Number.isNaN(num)) {
                    maxIndex = Math.max(maxIndex, num);
                }
            }
        }
        return maxIndex;
    }

    let refCounter = 0;

    class RoleNameTracker {
        constructor() {
            this.counts = new Map();
            this.refsByKey = new Map();
        }
        getKey(role, name) {
            return role + '::' + (name || '');
        }
        getNextIndex(role, name) {
            const key = this.getKey(role, name);
            const current = this.counts.get(key) || 0;
            this.counts.set(key, current + 1);
            return current;
        }
        trackRef(role, name, ref) {
            const key = this.getKey(role, name);
            const refs = this.refsByKey.get(key) || [];
            refs.push(ref);
            this.refsByKey.set(key, refs);
        }
        getDuplicateKeys() {
            const duplicates = new Set();
            for (const [key, refs] of this.refsByKey) {
                if (refs.length > 1) {
                    duplicates.add(key);
                }
            }
            return duplicates;
        }
    }

    function buildInteractiveSnapshot() {
        const tracker = new RoleNameTracker();
        const elements = [];
        const usedRefs = new Set();
        const interactiveSet = new Set();

        const interactiveSelector = [
            'input', 'textarea', 'select', 'button', 'a[href]',
            '[role="button"]', '[role="link"]', '[role="textbox"]', '[role="checkbox"]',
            '[role="radio"]', '[role="combobox"]', '[role="listbox"]', '[role="menuitem"]',
            '[role="menuitemcheckbox"]', '[role="menuitemradio"]', '[role="option"]',
            '[role="slider"]', '[role="spinbutton"]', '[role="switch"]', '[role="tab"]',
            '[role="treeitem"]', '[role="searchbox"]', '[contenteditable="true"]',
            'summary', '[tabindex]:not([tabindex="-1"])'
        ].join(', ');

        const allInteractive = querySelectorAllIncludingOpenShadowRoots(interactiveSelector);

        for (const el of allInteractive) {
            if (el.getAttribute('aria-hidden') === 'true') continue;
            const style = window.getComputedStyle(el);
            if (style.display === 'none' || style.visibility === 'hidden') continue;
            const rect = el.getBoundingClientRect();
            if (rect.width === 0 && rect.height === 0) continue;

            const tag = el.tagName.toLowerCase();
            interactiveSet.add(el);
            const roleAttr = el.getAttribute('role') || '';
            const implicitRole = getImplicitRole(el);
            const role = roleAttr || implicitRole || 'generic';

            if (!INTERACTIVE_ROLES.has(role) && role !== 'generic') continue;

            const name = computeAccessibleName(el, role);
            const existingRef = el.getAttribute('data-cursor-ref');
            let ref = null;
            if (isValidRef(existingRef) && !usedRefs.has(existingRef)) {
                ref = existingRef;
            } else {
                ref = 'e' + refCounter++;
            }
            el.setAttribute('data-cursor-ref', ref);
            usedRefs.add(ref);

            const nth = tracker.getNextIndex(role, name);
            tracker.trackRef(role, name, ref);

            const node = { ref, role, name, tag };

            const states = collectElementStates(el, role);
            if (states.length) node.states = states;

            const details = collectElementDetails(el, role);
            for (const key in details) {
                if (details[key] !== undefined && details[key] !== '') {
                    node[key] = details[key];
                }
            }

            node._nth = nth;

            elements.push(node);
        }

        const duplicateKeys = tracker.getDuplicateKeys();
        for (const el of elements) {
            const key = tracker.getKey(el.role, el.name);
            if (duplicateKeys.has(key) && el._nth > 0) {
                el.nth = el._nth;
            }
            delete el._nth;
        }

        return { elements, tracker, usedRefs, interactiveSet };
    }

    function buildContentElements(interactiveSet, usedRefs) {
        const elements = [];
        const contentSelector = [
            'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
            'label', '[role="heading"]', 'p', 'li',
            'article', 'nav', 'main', 'header', 'footer', 'section',
            '[role="article"]', '[role="region"]', '[role="main"]', '[role="navigation"]',
            '[role="cell"]', '[role="gridcell"]', '[role="columnheader"]', '[role="rowheader"]',
            '[role="listitem"]'
        ].join(', ');
        const allContent = querySelectorAllIncludingOpenShadowRoots(contentSelector);

        for (const el of allContent) {
            if (el.getAttribute('aria-hidden') === 'true') continue;
            if (interactiveSet.has(el)) continue;

            const style = window.getComputedStyle(el);
            if (style.display === 'none' || style.visibility === 'hidden') continue;

            const tag = el.tagName.toLowerCase();
            const role = el.getAttribute('role') || getImplicitRole(el);
            const name = computeAccessibleName(el, role);

            if (!name) continue;

            const existingRef = el.getAttribute('data-cursor-ref');
            let ref = null;
            if (isValidRef(existingRef) && !usedRefs.has(existingRef)) {
                ref = existingRef;
            } else {
                ref = 'e' + refCounter++;
            }
            el.setAttribute('data-cursor-ref', ref);
            usedRefs.add(ref);

            const node = { ref, role, name, tag };

            if (role === 'heading') {
                const ariaLevel = parseInt(el.getAttribute('aria-level') || '', 10);
                const tagLevelMatch = tag.match(/^h([1-6])$/);
                const tagLevel = tagLevelMatch ? parseInt(tagLevelMatch[1], 10) : undefined;
                const level = !Number.isNaN(ariaLevel) ? ariaLevel : tagLevel;
                if (level) node.level = level;
            }

            elements.push(node);
        }

        return elements;
    }

    refCounter = getMaxRefIndex() + 1;

    const { elements: interactiveElements, tracker, usedRefs, interactiveSet } = buildInteractiveSnapshot();
    const contentElements = interactiveOnly ? [] : buildContentElements(interactiveSet, usedRefs);

    const allElements = [...interactiveElements, ...contentElements];

    querySelectorAllIncludingOpenShadowRoots('[data-cursor-ref]').forEach(el => {
        const ref = el.getAttribute('data-cursor-ref');
        if (!isValidRef(ref) || !usedRefs.has(ref)) {
            el.removeAttribute('data-cursor-ref');
        }
    });

    const tree = {
        role: 'document',
        ref: 'root',
        name: document.title || '',
        children: allElements
    };

    return {
        tree,
        stats: {
            totalRefs: allElements.length,
            interactiveRefs: interactiveElements.length,
            maxDepth: maxDepth
        }
    };
}

Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.

[object Array]

\ No newline at end of file

\ No newline at end of file

function getParentElementAcrossShadow(element) {
	if (!element) return null;
	if (element.parentElement) return element.parentElement;
	const root = element.getRootNode ? element.getRootNode() : null;
	if (root && root.host && root.host.nodeType === Node.ELEMENT_NODE) {
		return root.host;
	}
	return null;
}

function composedContains(ancestor, node) {
	let current = node;
	while (current) {
		if (current === ancestor) {
			return true;
		}
		current = getParentElementAcrossShadow(current);
	}
	return false;
}

function getDeepElementFromPoint(root, x, y) {
	if (!root || typeof root.elementFromPoint !== 'function') {
		return null;
	}
	let element = root.elementFromPoint(x, y);
	while (element && element.shadowRoot && element.shadowRoot.mode === 'open' && typeof element.shadowRoot.elementFromPoint === 'function') {
		const nested = element.shadowRoot.elementFromPoint(x, y);
		if (!nested || nested === element) {
			break;
		}
		element = nested;
	}
	return element;
}

function walkComposedElements(root, visitor) {
	function visitContainer(container) {
		const children = container && container.children ? Array.from(container.children) : [];
		for (const child of children) {
			if (visitElement(child)) {
				return true;
			}
		}
		return false;
	}

	function visitElement(element) {
		if (visitor(element)) {
			return true;
		}
		if (element.shadowRoot && element.shadowRoot.mode === 'open') {
			if (visitContainer(element.shadowRoot)) {
				return true;
			}
		}
		return visitContainer(element);
	}

	return visitContainer(root);
}

function querySelectorAllIncludingOpenShadowRoots(selector) {
	const matches = [];
	walkComposedElements(document, (element) => {
		try {
			if (element.matches && element.matches(selector)) {
				matches.push(element);
			}
		} catch (_) { }
		return false;
	});
	return matches;
}

function findElementByRef(ref) {
	let element = null;
	walkComposedElements(document, (candidate) => {
		if (candidate.getAttribute && candidate.getAttribute('data-cursor-ref') === ref) {
			element = candidate;
			return true;
		}
		return false;
	});
	if (element) {
		return { element, method: 'ref-attribute' };
	}
	return { element: null, method: 'not-found' };
}

function getElementDescription(element) {
	if (!element) return '';
	const tag = element.tagName?.toLowerCase() || '';
	const role = element.getAttribute('role') || '';
	const ariaLabel = element.getAttribute('aria-label') || '';
	const text = (element.textContent || '').trim().substring(0, 50);
	const parts = [];
	if (tag) parts.push(tag);
	if (role) parts.push('role=' + role);
	if (ariaLabel) parts.push('aria-label="' + ariaLabel + '"');
	else if (text) parts.push('text="' + text + '"');
	return parts.length > 0 ? ' (' + parts.join(', ') + ')' : '';
}

function assertDescriptionMatches(element, ref, expectedDescription) {
	const actualDescription = getElementDescription(element);
	if (expectedDescription) {
		const expectedLower = expectedDescription.toLowerCase();
		const actualLower = actualDescription.toLowerCase();

		const actualTextMatch = actualLower.match(/text="([^"]+)"/);
		const actualText = actualTextMatch ? actualTextMatch[1] : '';

		const actualTag = element.tagName?.toLowerCase() || '';
		const actualRole = element.getAttribute?.('role')?.toLowerCase() || '';

		const expectedMentionsButton = expectedLower.includes('button');
		const actualIsButton = actualTag === 'button' || actualRole === 'button' || actualLower.includes('button');

		if (expectedMentionsButton && !actualIsButton) {
			throw new Error('Stale element reference: ' + ref + ' expected a button but found ' + actualDescription + '. The page may have changed. Take a new snapshot.');
		}

		const expectedWords = expectedLower.replace(/button|link|input|checkbox|radio/g, '').trim().split(/\s+/).filter(w => w.length > 2);
		if (expectedWords.length > 0 && actualText) {
			const hasMatchingWord = expectedWords.some(word => actualText.includes(word));
			if (!hasMatchingWord) {
				throw new Error('Stale element reference: ' + ref + ' now points to' + actualDescription + ' but was expected to be "' + expectedDescription + '". The page may have changed. Take a new snapshot.');
			}
		}
	}
}

function validateElementForInteraction(element, ref, action, expectedDescription) {
	if (!element) {
		throw new Error('Element not found: ' + ref + '. Take a snapshot to get updated refs.');
	}

	assertDescriptionMatches(element, ref, expectedDescription);

	const actualDescription = getElementDescription(element);

	const rect = element.getBoundingClientRect();
	if (rect.width === 0 && rect.height === 0) {
		throw new Error('Element ' + ref + actualDescription + ' is not visible (zero dimensions). It may be hidden or collapsed.');
	}

	const style = window.getComputedStyle(element);
	if (style.display === 'none') {
		throw new Error('Element ' + ref + actualDescription + ' is hidden (display: none).');
	}
	if (style.visibility === 'hidden') {
		throw new Error('Element ' + ref + actualDescription + ' is hidden (visibility: hidden).');
	}
	if (parseFloat(style.opacity) === 0) {
		throw new Error('Element ' + ref + actualDescription + ' is not visible (opacity: 0). Wait for it to appear.');
	}
	if (style.pointerEvents === 'none' && action !== 'type' && action !== 'fill') {
		throw new Error('Element ' + ref + actualDescription + ' has pointer-events: none and cannot receive ' + action + ' interactions. Try clicking a parent element or waiting for a loading state to complete.');
	}

	if (element.disabled) {
		throw new Error('Element ' + ref + actualDescription + ' is disabled and cannot be interacted with. Enable the element first or interact with a different element.');
	}
	let parent = getParentElementAcrossShadow(element);
	while (parent) {
		if (parent.tagName === 'FIELDSET' && parent.disabled) {
			throw new Error('Element ' + ref + actualDescription + ' is inside a disabled fieldset and cannot be interacted with. Enable the fieldset first or interact with elements outside it.');
		}
		parent = getParentElementAcrossShadow(parent);
	}

	if (action === 'type' || action === 'fill') {
		const tag = element.tagName?.toLowerCase();
		const isContentEditable = element.isContentEditable || element.getAttribute('contenteditable') === 'true';
		const isReadonly = element.readOnly || element.getAttribute('readonly') !== null;
		const isTextInput = (tag === 'input' && !['button', 'submit', 'reset', 'checkbox', 'radio', 'file', 'image', 'hidden'].includes(element.type?.toLowerCase())) ||
			tag === 'textarea' ||
			isContentEditable;
		if (!isTextInput) {
			throw new Error('Element ' + ref + actualDescription + ' is not a text input, textarea, or contenteditable element. Use browser_cdp with DOM and Input commands if you want to interact with this element.');
		}
		if (isReadonly && !isContentEditable) {
			throw new Error('Element ' + ref + actualDescription + ' is readonly and cannot be modified. The value is set programmatically and cannot be changed by user input.');
		}
	}

	return true;
}

function previewNode(element) {
	if (!element) return 'null';
	const tag = element.tagName?.toLowerCase() || 'unknown';
	const attrs = [];
	if (element.id) attrs.push('id="' + element.id + '"');
	if (element.className && typeof element.className === 'string') {
		const classes = element.className.trim().split(/\s+/).slice(0, 2).join(' ');
		if (classes) attrs.push('class="' + classes + '"');
	}
	if (element.getAttribute && element.getAttribute('role')) {
		attrs.push('role="' + element.getAttribute('role') + '"');
	}
	if (element.getAttribute && element.getAttribute('data-cursor-ref')) {
		attrs.push('ref="' + element.getAttribute('data-cursor-ref') + '"');
	}
	const text = (element.textContent || '').trim().substring(0, 30);
	const textPart = text ? '>' + text + '...' : '';
	return '<' + tag + (attrs.length ? ' ' + attrs.join(' ') : '') + textPart + '>';
}

function expectHitTarget(hitPoint, targetElement, targetRef) {
	const doc = hitPoint.ownerDocument || document;
	let hitElement = getDeepElementFromPoint(doc, hitPoint.x, hitPoint.y);

	if (!hitElement) {
		return {
			hit: false,
			interceptedBy: 'nothing (coordinates outside viewport)',
			error: 'Click coordinates (' + hitPoint.x + ', ' + hitPoint.y + ') are outside the visible viewport.',
			suggestion: 'The element may be scrolled out of view. Use browser_cdp with Runtime.evaluate or DOM commands to scroll it into view first.'
		};
	}

	if (hitElement === targetElement || composedContains(targetElement, hitElement)) {
		return { hit: true };
	}

	if (composedContains(targetElement, getParentElementAcrossShadow(hitElement))) {
		return { hit: true };
	}

	function isScrollContainer(el) {
		const style = window.getComputedStyle(el);
		const overflowY = style.overflowY;
		const overflowX = style.overflowX;
		return (overflowY === 'auto' || overflowY === 'scroll' || overflowX === 'auto' || overflowX === 'scroll') &&
			(el.scrollHeight > el.clientHeight || el.scrollWidth > el.clientWidth);
	}

	function isElementClippedByContainer(el, container) {
		const elRect = el.getBoundingClientRect();
		const containerRect = container.getBoundingClientRect();
		return elRect.top < containerRect.top || elRect.bottom > containerRect.bottom ||
			elRect.left < containerRect.left || elRect.right > containerRect.right;
	}

	let current = hitElement;
	while (current && current !== targetElement && current !== document.body) {
		const tagName = current.tagName?.toLowerCase() || '';
		const role = current.getAttribute?.('role') || '';
		const style = window.getComputedStyle(current);
		const position = style.position;
		const zIndex = parseInt(style.zIndex, 10);
		const hasHighZIndex = !isNaN(zIndex) && zIndex > 100;
		const isFixed = position === 'fixed' || position === 'absolute';

		const isDialog = tagName === 'dialog' || role === 'dialog' || role === 'alertdialog';
		const isModal = current.getAttribute?.('aria-modal') === 'true';
		const isIframe = tagName === 'iframe';
		const isNavOrHeader = tagName === 'nav' || tagName === 'header' || role === 'navigation' || role === 'banner';

		if (isIframe) {
			const hitRef = current.getAttribute('data-cursor-ref');
			const preview = previewNode(current);
			return {
				hit: false,
				interceptedBy: preview,
				interceptedRef: hitRef || undefined,
				blockingType: 'iframe',
				error: 'Click would hit an iframe instead of the target element.',
				suggestion: 'The target is behind an iframe. Iframe content cannot be interacted with directly. ' + (hitRef ? 'The iframe has ref ' + hitRef + '.' : 'Navigate to the iframe URL directly if you need to interact with its content.')
			};
		}

		if (isDialog || isModal) {
			const hitRef = current.getAttribute('data-cursor-ref');
			const preview = previewNode(current);
			return {
				hit: false,
				interceptedBy: preview,
				interceptedRef: hitRef || undefined,
				blockingType: 'modal',
				error: 'Click would hit a modal/dialog instead of the target element.',
				suggestion: 'A modal or dialog is blocking the target. Close it first with browser_cdp using Runtime.evaluate or by clicking its close button.'
			};
		}

		if (isScrollContainer(current)) {
			if (targetElement.closest && composedContains(current, targetElement)) {
				if (isElementClippedByContainer(targetElement, current)) {
					const hitRef = current.getAttribute('data-cursor-ref');
					const preview = previewNode(current);
					return {
						hit: false,
						interceptedBy: preview,
						interceptedRef: hitRef || undefined,
						blockingType: 'scroll-container',
						error: 'The target element is clipped by a scroll container (' + preview + '). The element exists but is not visible within its scrollable parent.',
						suggestion: 'Use browser_cdp with Runtime.evaluate to scroll the element into view within its container.' + (hitRef ? ' The scroll container has ref ' + hitRef + '.' : '')
					};
				}
			}
		}

		if (isNavOrHeader && isFixed) {
			const hitRef = current.getAttribute('data-cursor-ref');
			const preview = previewNode(current);
			return {
				hit: false,
				interceptedBy: preview,
				interceptedRef: hitRef || undefined,
				blockingType: 'fixed-header',
				error: 'Click would hit a fixed header/navigation bar instead of the target.',
				suggestion: 'A fixed header/navigation bar is blocking the target. Try scrolling the page so the target is not behind the fixed element, or click directly on the header element if that is the intent.'
			};
		}

		if (hasHighZIndex && isFixed && !isScrollContainer(current)) {
			const hitRef = current.getAttribute('data-cursor-ref');
			const preview = previewNode(current);
			return {
				hit: false,
				interceptedBy: preview,
				interceptedRef: hitRef || undefined,
				blockingType: 'overlay',
				error: 'Click would hit an overlay element (' + preview + ') instead of the target.',
				suggestion: hitRef
					? 'An overlay (ref: ' + hitRef + ') is blocking the target. Either click that element directly, or dismiss/close the overlay first.'
					: 'An overlay element is blocking the target. Close or dismiss this overlay before interacting with elements behind it. Try pressing Escape or looking for a close button.'
			};
		}

		current = getParentElementAcrossShadow(current);
	}

	if (current !== targetElement && !composedContains(targetElement, hitElement)) {
		const hitRef = hitElement.getAttribute('data-cursor-ref');
		const preview = previewNode(hitElement);
		const targetRect = targetElement.getBoundingClientRect();
		const isTargetOffscreen = targetRect.bottom < 0 || targetRect.top > window.innerHeight ||
			targetRect.right < 0 || targetRect.left > window.innerWidth;

		if (isTargetOffscreen) {
			return {
				hit: false,
				interceptedBy: preview,
				interceptedRef: hitRef || undefined,
				blockingType: 'offscreen',
				error: 'The target element is outside the visible viewport.',
				suggestion: 'Use browser_cdp with Runtime.evaluate to bring the target into view first.'
			};
		}

		const hitElementStyle = window.getComputedStyle(hitElement);
		const hitTagName = hitElement.tagName?.toLowerCase() || '';
		const isHitScrollContainer = isScrollContainer(hitElement);

		if (isHitScrollContainer && composedContains(hitElement, targetElement)) {
			return {
				hit: false,
				interceptedBy: preview,
				interceptedRef: hitRef || undefined,
				blockingType: 'scroll-container',
				error: 'The target is inside a scroll container but not in the visible scroll area. The click would hit the scroll container instead.',
				suggestion: 'Use browser_cdp with Runtime.evaluate to scroll the element into view within its container.'
			};
		}

		return {
			hit: false,
			interceptedBy: preview,
			interceptedRef: hitRef || undefined,
			blockingType: 'sibling',
			error: 'Click would hit a different element (' + preview + ') instead of the target.',
			suggestion: hitRef
				? 'The element at the click position has ref ' + hitRef + '. Click that ref if it is the intended target, or take a snapshot to see updated element positions.'
				: 'Another element is at the click position. Take a snapshot to see the current page layout and find the correct element ref.'
		};
	}

	return { hit: true };
}

element not found

cannot find

Element not found

: ${t.ref}

Take a snapshot first to see the current page state and available element refs. The refs might have changed since the last snapshot.

is not a text input

use click instead

Element is not a text input

: ${t.ref}

This element cannot accept text input. If you need to interact with it, use browser_cdp with DOM and Runtime.evaluate commands. If you need to type, find the actual input element.

browser_cdp or browser_snapshot to find correct input

timed out

Operation timed out

The page might be slow to respond. Try waiting a bit and then taking a snapshot to check the current state.

browser_cdp polling with Runtime.evaluate

not visible

zero dimensions

Element is not visible or interactable

: ${t.ref}

The element might be hidden, covered by another element, or outside the viewport. Try scrolling to bring it into view, or dismiss any overlays first.

browser_cdp with Runtime.evaluate

multiple elements

Multiple elements match the selector

: ${t.selector}

Use a more specific selector or take a snapshot to see the element refs, then use the ref directly.

browser_snapshot to get specific refs

pointer-events: none

Element has pointer-events: none CSS property

: ${t.ref}

This element cannot receive pointer events due to its CSS. The element may be decorative or the interaction should target a different element.

browser_snapshot to find an alternative clickable element

blocked by an overlay

blocked by a modal

Element is blocked by an overlay or modal

: ${t.ref}

Close the modal or overlay first before interacting with elements behind it. If no modal is visible, try taking a fresh snapshot as element refs may be stale.

browser_snapshot to refresh refs, or browser_cdp with Runtime.evaluate

failed to focus

Failed to focus element

: ${t.ref}

The element could not receive focus. Check if another element is covering it, if it has a negative tabindex, or if it is disabled. Take a snapshot to verify current element state.

browser_snapshot to check element state

Navigation occurred during the operation

Wait for navigation to complete and take a new snapshot to see the updated page state.

browser_snapshot after navigation completes

Element reference is stale (page has changed)

The page content has changed since the last snapshot. Take a new snapshot to get updated refs.

disabled fieldset

Element is inside a disabled fieldset