extension.js · part 3

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

File contents and all parts · All files

${n}  children:

snapshot-${(new Date).toISOString().replace(/[:.]/g,"-")}-${Math.random().toString(36).slice(2,8)}.log

Large snapshot redirected to: ${n} (${o} lines, ${s.length} preview lines)

Failed to execute JavaScript in browser:

Browser execution returned null or undefined

Browser execution returned non-object: 

Browser result missing required "success" field

Browser result missing required field: ${String(t)}

### Action: ${e}

- Browser View ID: ${o}

### Page state

- Page URL: ${c}

- Page Title: ${d}

- Page Snapshot: Large snapshot (${w} bytes, ${i} lines) written to file

- Snapshot File: [${r}](file://${r})

- Preview (first ${s.length} lines):

... (${i-s.length} more lines in file)

### Snapshot diff (previous vs current)

### Snapshot diff (previous vs current)

- Diff too large to include inline (${h} bytes).

Failed to write snapshot to file, returning inline:

### Action: ${e}

- Browser View ID: ${o}

### Page state

- Page URL: ${c}

- Page Title: ${d}

- Page Snapshot:

### Snapshot diff (previous vs current)

### Snapshot diff (previous vs current)

- Diff too large to include inline (${h} bytes).

Auto-snapshotting view ${t} (stale or missing)

browserUtils must be provided for ensureFreshSnapshot

${n} buildPageSnapshot();

Failed to update screenshot service: ${t}

	(() => ({
		viewportCssWidth: window.innerWidth,
		viewportCssHeight: window.innerHeight,
		url: window.location.href,
	}))();

Viewport screenshot metrics were incomplete

Viewport screenshot could not be normalized

Failed to normalize viewport screenshot: ${t}

[getScreenshot] viewId=${t}, taking screenshot

Failed to take screenshot: ${n.error}

Error taking screenshot: ${t}

function setNativeValue(el, val) {
	const elTagName = el.tagName.toUpperCase();
	let valueSetter = null;

	if (elTagName === 'INPUT') {
		valueSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set;
	} else if (elTagName === 'TEXTAREA') {
		valueSetter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
	}

	if (valueSetter) {
		valueSetter.call(el, val);
	} else {
		el.value = val;
	}
}

async function dispatchMouseClickSequenceInBrowser(element, options) {
	const globals = globalThis;
	const browserDocument = globals.document;
	const button = options.button ?? 'left';
	const modifiers = options.modifiers ?? [];

	let buttonValue = 0;
	let buttonsValue = 1;
	let clickEventType = 'click';
	if (button === 'right') {
		buttonValue = 2;
		buttonsValue = 2;
		clickEventType = 'contextmenu';
	} else if (button === 'middle') {
		buttonValue = 1;
		buttonsValue = 4;
		clickEventType = 'auxclick';
	}

	const pointerEventOptions = {
		bubbles: true,
		cancelable: true,
		view: globals.window,
		button: buttonValue,
		buttons: buttonsValue,
		ctrlKey: modifiers.includes('Control') || modifiers.includes('ControlOrMeta'),
		shiftKey: modifiers.includes('Shift'),
		altKey: modifiers.includes('Alt'),
		metaKey: modifiers.includes('Meta') || modifiers.includes('ControlOrMeta'),
		clientX: options.x,
		clientY: options.y,
		pointerId: 1,
		pointerType: 'mouse',
		isPrimary: true,
	};

	const mouseEventOptions = {
		bubbles: true,
		cancelable: true,
		view: globals.window,
		button: buttonValue,
		buttons: buttonsValue,
		ctrlKey: modifiers.includes('Control') || modifiers.includes('ControlOrMeta'),
		shiftKey: modifiers.includes('Shift'),
		altKey: modifiers.includes('Alt'),
		metaKey: modifiers.includes('Meta') || modifiers.includes('ControlOrMeta'),
		clientX: options.x,
		clientY: options.y,
	};

	const previousActiveElement = browserDocument?.activeElement;
	if (previousActiveElement && previousActiveElement !== element && previousActiveElement !== browserDocument?.body) {
		if (typeof previousActiveElement.blur === 'function') {
			previousActiveElement.blur();
		}
	}

	if (typeof element.focus === 'function') {
		element.focus();
	}

	await new Promise((resolve) => {
		globals.setTimeout(resolve, 0);
	});

	element.dispatchEvent(new globals.PointerEvent('pointerover', pointerEventOptions));
	element.dispatchEvent(new globals.PointerEvent('pointerenter', { ...pointerEventOptions, bubbles: false }));
	element.dispatchEvent(new globals.MouseEvent('mouseover', mouseEventOptions));
	element.dispatchEvent(new globals.MouseEvent('mouseenter', { ...mouseEventOptions, bubbles: false }));
	element.dispatchEvent(new globals.PointerEvent('pointermove', pointerEventOptions));
	element.dispatchEvent(new globals.MouseEvent('mousemove', mouseEventOptions));
	element.dispatchEvent(new globals.PointerEvent('pointerdown', pointerEventOptions));
	element.dispatchEvent(new globals.MouseEvent('mousedown', mouseEventOptions));

	if (typeof element.focus === 'function') {
		element.focus();
	}

	if ((options.holdDurationMs ?? 0) > 0) {
		await new Promise((resolve) => {
			globals.setTimeout(resolve, options.holdDurationMs);
		});
	}

	element.dispatchEvent(new globals.PointerEvent('pointerup', pointerEventOptions));
	element.dispatchEvent(new globals.MouseEvent('mouseup', mouseEventOptions));
	element.dispatchEvent(new globals.MouseEvent(clickEventType, mouseEventOptions));

	if (options.doubleClick) {
		element.dispatchEvent(new globals.PointerEvent('pointerdown', pointerEventOptions));
		element.dispatchEvent(new globals.MouseEvent('mousedown', mouseEventOptions));
		element.dispatchEvent(new globals.PointerEvent('pointerup', pointerEventOptions));
		element.dispatchEvent(new globals.MouseEvent('mouseup', mouseEventOptions));
		element.dispatchEvent(new globals.MouseEvent(clickEventType, mouseEventOptions));
		if (clickEventType === 'click') {
			element.dispatchEvent(new globals.MouseEvent('dblclick', mouseEventOptions));
		}
	}

	await new Promise((resolve) => {
		globals.setTimeout(resolve, 0);
	});
}

function getScrollableAncestors(el) {
	const ancestors = [];
	let current = el.parentElement;
	while (current && current !== document.body && current !== document.documentElement) {
		const style = window.getComputedStyle(current);
		const overflowY = style.overflowY;
		const overflowX = style.overflowX;
		const isScrollable = (
			(overflowY === 'auto' || overflowY === 'scroll' || overflowX === 'auto' || overflowX === 'scroll') &&
			(current.scrollHeight > current.clientHeight || current.scrollWidth > current.clientWidth)
		);
		if (isScrollable) {
			ancestors.push(current);
		}
		current = current.parentElement;
	}
	if (document.scrollingElement && (document.scrollingElement.scrollHeight > window.innerHeight || document.scrollingElement.scrollWidth > window.innerWidth)) {
		ancestors.push(document.scrollingElement);
	}
	return ancestors;
}

function safeRound(val) {
	if (typeof val !== 'number' || !Number.isFinite(val)) return 0;
	return Math.round(val);
}

function getScrollContainerInfo(container) {
	const rect = container.getBoundingClientRect();
	const ref = container.getAttribute ? (container.getAttribute('data-cursor-ref') || null) : null;
	const tag = container.tagName?.toLowerCase() || '';
	const id = container.id || null;
	const classes = container.className && typeof container.className === 'string'
		? container.className.trim().split(/\s+/).slice(0, 2).join(' ')
		: '';
	return {
		ref,
		tag,
		id,
		classes,
		scrollTop: safeRound(container.scrollTop),
		scrollLeft: safeRound(container.scrollLeft),
		scrollHeight: safeRound(container.scrollHeight),
		scrollWidth: safeRound(container.scrollWidth),
		clientHeight: safeRound(container.clientHeight),
		clientWidth: safeRound(container.clientWidth),
		canScrollDown: container.scrollTop + container.clientHeight < container.scrollHeight - 5,
		canScrollUp: container.scrollTop > 5,
		canScrollRight: container.scrollLeft + container.clientWidth < container.scrollWidth - 5,
		canScrollLeft: container.scrollLeft > 5,
		boundingBox: {
			top: safeRound(rect.top),
			left: safeRound(rect.left),
			width: safeRound(rect.width),
			height: safeRound(rect.height)
		}
	};
}

function isElementVisibleInContainer(el, container) {
	const elRect = el.getBoundingClientRect();
	const containerRect = container === document.scrollingElement
		? { top: 0, left: 0, bottom: window.innerHeight, right: window.innerWidth }
		: container.getBoundingClientRect();
	const padding = 10;
	return (
		elRect.top >= containerRect.top - padding &&
		elRect.bottom <= containerRect.bottom + padding &&
		elRect.left >= containerRect.left - padding &&
		elRect.right <= containerRect.right + padding
	);
}

function scrollElementIntoContainer(el, container) {
	const elRect = el.getBoundingClientRect();
	const containerRect = container === document.scrollingElement
		? { top: 0, left: 0, bottom: window.innerHeight, right: window.innerWidth, width: window.innerWidth, height: window.innerHeight }
		: container.getBoundingClientRect();

	let scrollTopDelta = 0;
	let scrollLeftDelta = 0;

	if (elRect.bottom > containerRect.bottom) {
		scrollTopDelta = elRect.bottom - containerRect.bottom + 20;
	} else if (elRect.top < containerRect.top) {
		scrollTopDelta = elRect.top - containerRect.top - 20;
	}

	if (elRect.right > containerRect.right) {
		scrollLeftDelta = elRect.right - containerRect.right + 20;
	} else if (elRect.left < containerRect.left) {
		scrollLeftDelta = elRect.left - containerRect.left - 20;
	}

	if (Math.abs(scrollTopDelta) > 5 || Math.abs(scrollLeftDelta) > 5) {
		container.scrollBy({ top: scrollTopDelta, left: scrollLeftDelta, behavior: 'instant' });
		return { scrolled: true, deltaY: safeRound(scrollTopDelta), deltaX: safeRound(scrollLeftDelta) };
	}
	return { scrolled: false, deltaY: 0, deltaX: 0 };
}

function isInViewport(rect) {
	if (!rect || !Number.isFinite(rect.top) || !Number.isFinite(rect.bottom)) return false;
	const padding = 10;
	return (
		rect.top >= -padding &&
		rect.left >= -padding &&
		rect.bottom <= window.innerHeight + padding &&
		rect.right <= window.innerWidth + padding
	);
}

function getSafeRect(element) {
	const rect = element.getBoundingClientRect();
	return {
		top: safeRound(rect.top),
		left: safeRound(rect.left),
		bottom: safeRound(rect.bottom),
		right: safeRound(rect.right),
		width: safeRound(rect.width),
		height: safeRound(rect.height)
	};
}

async function ensureElementInView(element, maxAttempts) {
	const attempts = maxAttempts || 5;
	const scrollableAncestors = getScrollableAncestors(element);
	let totalScrolledContainers = 0;

	for (let attempt = 0; attempt < attempts; attempt++) {
		const rect = getSafeRect(element);

		if (isInViewport(rect)) {
			return {
				success: true,
				attempts: attempt + 1,
				scrolledContainers: totalScrolledContainers,
				containerCount: scrollableAncestors.length
			};
		}

		let didScroll = false;

		for (let i = 0; i < scrollableAncestors.length; i++) {
			const container = scrollableAncestors[i];
			if (!isElementVisibleInContainer(element, container)) {
				const scrollResult = scrollElementIntoContainer(element, container);
				if (scrollResult.scrolled) {
					totalScrolledContainers++;
					didScroll = true;
					await new Promise(r => setTimeout(r, 100));
				}
			}
		}

		if (didScroll) {
			await new Promise(r => setTimeout(r, 50));
			continue;
		}

		const newRect = getSafeRect(element);
		if (!isInViewport(newRect)) {
			try {
				element.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
				await new Promise(r => setTimeout(r, 100));
			} catch (e) {
				element.scrollIntoView(true);
				await new Promise(r => setTimeout(r, 100));
			}
		}

		const finalRect = getSafeRect(element);
		if (isInViewport(finalRect)) {
			return {
				success: true,
				attempts: attempt + 1,
				scrolledContainers: totalScrolledContainers,
				containerCount: scrollableAncestors.length
			};
		}

		for (let i = scrollableAncestors.length - 1; i >= 0; i--) {
			const container = scrollableAncestors[i];
			const scrollResult = scrollElementIntoContainer(element, container);
			if (scrollResult.scrolled) {
				totalScrolledContainers++;
				await new Promise(r => setTimeout(r, 100));
			}
		}
	}

	const finalRect = getSafeRect(element);
	const finalContainerInfos = scrollableAncestors.map(c => getScrollContainerInfo(c));

	return {
		success: false,
		attempts: attempts,
		rect: finalRect,
		viewportSize: { width: window.innerWidth, height: window.innerHeight },
		scrollContainers: finalContainerInfos,
		scrolledContainers: totalScrolledContainers,
		containerCount: scrollableAncestors.length
	};
}

 (attempt ${t.attempts})

${e} ${t.actionType}: ${t.targetDescription}${n}

 - ${t.error}

No browser tab available

No browser tab available. Please navigate to a page first.

			${q}
			${c}
			${pt}
			
function isDropdownElement(el) {
	if (!el) return false;
	const tag = el.tagName?.toLowerCase() || '';
	const role = el.getAttribute?.('role') || '';

	const dropdownRoles = ['listbox', 'menu', 'combobox', 'tree', 'grid'];
	const dropdownClasses = ['dropdown', 'select-options', 'autocomplete', 'suggestions', 'popover', 'menu-list', 'option-list'];

	if (dropdownRoles.includes(role)) return true;
	if (tag === 'select' || tag === 'datalist') return true;

	const ariaHaspopup = el.getAttribute?.('aria-haspopup');
	const ariaExpanded = el.getAttribute?.('aria-expanded');
	if (ariaHaspopup && ariaHaspopup !== 'false') return true;
	if (ariaExpanded === 'true') return true;

	const classList = el.className && typeof el.className === 'string' ? el.className.toLowerCase() : '';
	if (dropdownClasses.some(cls => classList.includes(cls))) return true;

	const style = window.getComputedStyle(el);
	const isAbsoluteOrFixed = style.position === 'absolute' || style.position === 'fixed';
	const hasHighZIndex = parseInt(style.zIndex, 10) > 10;
	const hasOptions = el.querySelectorAll('[role="option"], [role="menuitem"], option, li').length > 0;

	if (isAbsoluteOrFixed && hasHighZIndex && hasOptions) return true;

	return false;
}

function findDropdownAncestor(el) {
	let current = el;
	while (current && current !== document.body) {
		if (isDropdownElement(current)) {
			return current;
		}
		current = current.parentElement;
	}
	return null;
}

async function attemptDropdownClose(dropdownEl) {
	const result = {
		attempted: true,
		method: null,
		success: false
	};

	document.body.dispatchEvent(new MouseEvent('click', {
		bubbles: true,
		cancelable: true,
		view: window,
		clientX: 0,
		clientY: 0
	}));
	result.method = 'click-body';

	await new Promise(r => setTimeout(r, 100));

	const style = window.getComputedStyle(dropdownEl);
	if (style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity) === 0) {
		result.success = true;
		return result;
	}

	document.dispatchEvent(new KeyboardEvent('keydown', {
		key: 'Escape',
		code: 'Escape',
		keyCode: 27,
		bubbles: true,
		cancelable: true
	}));
	result.method = 'press-escape';

	await new Promise(r => setTimeout(r, 100));

	const styleAfterEsc = window.getComputedStyle(dropdownEl);
	if (styleAfterEsc.display === 'none' || styleAfterEsc.visibility === 'hidden' || parseFloat(styleAfterEsc.opacity) === 0) {
		result.success = true;
	}

	return result;
}

			
function getBlockingElementInfo(hitElement, targetElement) {
	if (!hitElement) {
		return null;
	}

	const tag = hitElement.tagName?.toLowerCase() || '';
	const id = hitElement.id || null;
	const classes = hitElement.className && typeof hitElement.className === 'string'
		? hitElement.className.trim().split(/\s+/).filter(Boolean)
		: [];
	const role = hitElement.getAttribute?.('role') || null;
	const rect = hitElement.getBoundingClientRect();
	const ref = hitElement.getAttribute?.('data-cursor-ref') || null;

	const nonInteractiveTags = ['p', 'span', 'div', 'label', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'td', 'th', 'caption', 'figcaption', 'legend', 'small', 'strong', 'em', 'b', 'i', 'u', 'mark', 'del', 'ins', 'sub', 'sup', 'code', 'pre', 'blockquote', 'cite', 'q', 'abbr', 'address', 'time'];
	const interactiveRoles = ['button', 'link', 'checkbox', 'radio', 'textbox', 'combobox', 'listbox', 'menuitem', 'tab', 'switch', 'slider', 'spinbutton', 'option'];
	const dropdownRoles = ['listbox', 'menu', 'combobox', 'tree', 'grid'];

	const isNonInteractive = (
		nonInteractiveTags.includes(tag) &&
		!role &&
		!hitElement.onclick &&
		!hitElement.hasAttribute('tabindex') &&
		hitElement.getAttribute('contenteditable') !== 'true'
	);

	const isInteractiveByRole = role && interactiveRoles.includes(role);
	const isInteractiveByTag = ['a', 'button', 'input', 'select', 'textarea', 'summary'].includes(tag);

	const dropdownAncestor = findDropdownAncestor ? findDropdownAncestor(hitElement) : null;
	const isDropdownOption = role === 'option' || role === 'menuitem' || tag === 'option' ||
		(dropdownAncestor && dropdownAncestor !== hitElement);

	const info = {
		tag,
		id,
		classes,
		role,
		ref,
		isNonInteractiveText: isNonInteractive && !isInteractiveByRole && !isInteractiveByTag,
		isDropdownOption: isDropdownOption,
		dropdownAncestorRef: dropdownAncestor ? (dropdownAncestor.getAttribute?.('data-cursor-ref') || null) : null,
		boundingBox: {
			top: Math.round(rect.top),
			left: Math.round(rect.left),
			width: Math.round(rect.width),
			height: Math.round(rect.height),
			bottom: Math.round(rect.bottom),
			right: Math.round(rect.right)
		}
	};

	if (tag === 'iframe') {
		info.iframe = getIframeInfo(hitElement);
	}

	if (isNonInteractive && targetElement) {
		const targetRect = targetElement.getBoundingClientRect();
		const hitRect = rect;

		info.clickOffsetSuggestion = null;

		if (hitRect.bottom <= targetRect.bottom && hitRect.top >= targetRect.top) {
			if (hitRect.right < targetRect.right - 10) {
				info.clickOffsetSuggestion = { offsetX: Math.round(targetRect.width - 5), description: 'right edge' };
			} else if (hitRect.left > targetRect.left + 10) {
				info.clickOffsetSuggestion = { offsetX: 5, description: 'left edge' };
			}
		}
		if (!info.clickOffsetSuggestion) {
			if (hitRect.bottom < targetRect.bottom - 10) {
				info.clickOffsetSuggestion = { offsetY: Math.round(targetRect.height - 5), description: 'bottom edge' };
			} else if (hitRect.top > targetRect.top + 10) {
				info.clickOffsetSuggestion = { offsetY: 5, description: 'top edge' };
			}
		}
	}

	return info;
}

function getIframeInfo(iframe) {
	if (!iframe || iframe.tagName?.toLowerCase() !== 'iframe') {
		return null;
	}

	const src = iframe.getAttribute('src') || null;
	const sandbox = iframe.getAttribute('sandbox') || null;
	const title = iframe.getAttribute('title') || null;
	const name = iframe.getAttribute('name') || null;
	const allow = iframe.getAttribute('allow') || null;

	let isSameOrigin = false;
	try {
		if (src) {
			const iframeUrl = new URL(src, window.location.href);
			isSameOrigin = iframeUrl.origin === window.location.origin;
		}
	} catch (e) {
		isSameOrigin = false;
	}

	return {
		src,
		sandbox,
		title,
		name,
		allow,
		isSameOrigin
	};
}

			
function attemptRefRecovery(ref, expectedRole, expectedName) {
	const allElements = querySelectorAllIncludingOpenShadowRoots('[data-cursor-ref]');
	let bestMatch = null;
	let bestScore = 0;

	for (const el of allElements) {
		const elRole = el.getAttribute('role') || getImplicitRole(el);
		const elName = computeAccessibleName(el, elRole);

		let score = 0;

		if (expectedRole && elRole === expectedRole) {
			score += 50;
		}

		if (expectedName && elName) {
			const expectedLower = expectedName.toLowerCase();
			const actualLower = elName.toLowerCase();

			if (actualLower === expectedLower) {
				score += 50;
			} else if (actualLower.includes(expectedLower) || expectedLower.includes(actualLower)) {
				score += 25;
			}
		}

		if (score > bestScore) {
			bestScore = score;
			bestMatch = el;
		}
	}

	if (bestMatch && bestScore >= 50) {
		return {
			success: true,
			element: bestMatch,
			newRef: bestMatch.getAttribute('data-cursor-ref'),
			matchScore: bestScore
		};
	}

	return { success: false };
}

function parseExpectedDescription(description) {
	if (!description) return { role: null, name: null };

	const desc = description.toLowerCase();
	let role = null;
	let name = null;

	const rolePatterns = [
		/role=["']?([^"',)]+)/,
		/^(button|link|textbox|checkbox|radio|combobox|listbox|menuitem|option|slider|switch|tab)/
	];

	for (const pattern of rolePatterns) {
		const match = desc.match(pattern);
		if (match) {
			role = match[1].trim();
			break;
		}
	}

	const namePatterns = [
		/(?:aria-label|text|name)=["']?([^"']+)["']?/,
		/["']([^"']+)["']/
	];

	for (const pattern of namePatterns) {
		const match = description.match(pattern);
		if (match) {
			name = match[1].trim();
			break;
		}
	}

	if (!name && description) {
		name = description.replace(/(.*)/, '').trim();
	}

	return { role, name };
}

			${ut}
			(async function() {
				const ref = ${JSON.stringify(s)};
				const expectedDescription = ${JSON.stringify(i)};
				const maxScrollAttempts = ${a};
				const retryOnStaleRef = ${l};
				const autoCloseDropdowns = ${d};
				const retryWithOffset = ${u};
				let offsetX = ${t.offsetX??"null"};
				let offsetY = ${t.offsetY??"null"};
				const holdDurationMs = ${t.holdDurationMs??0};

				let element = null;
				let usedRef = ref;
				let recoveryAttempted = false;
				let dropdownRecovery = null;
				let offsetRetry = null;

				const findResult = findElementByRef(ref);
				element = findResult.element;

				if (!element && retryOnStaleRef && expectedDescription) {
					const { role: expectedRole, name: expectedName } = parseExpectedDescription(expectedDescription);
					const recovery = attemptRefRecovery(ref, expectedRole, expectedName);

					if (recovery.success) {
						element = recovery.element;
						usedRef = recovery.newRef;
						recoveryAttempted = true;
					}
				}

				if (!element) {
					return {
						success: false,
						error: 'Element not found: ' + ref + '. Take a snapshot to get updated refs.',
						staleRef: true,
						recoveryAttempted: recoveryAttempted
					};
				}

				try {
					validateElementForInteraction(element, usedRef, 'click', expectedDescription);
				} catch (validationError) {
					return {
						success: false,
						error: validationError.message,
						validationFailed: true
					};
				}

				const scrollResult = await ensureElementInView(element, maxScrollAttempts);

				if (!scrollResult.success) {
					let errorMsg = 'Could not scroll element into view after ' + scrollResult.attempts + ' attempts.';
					if (scrollResult.containerCount > 0) {
						errorMsg += ' Found ' + scrollResult.containerCount + ' scroll container(s).';
					}
					if (scrollResult.rect) {
						const r = scrollResult.rect;
						const vp = scrollResult.viewportSize;
						const belowBy = r.bottom - vp.height;
						const aboveBy = -r.top;
						if (Number.isFinite(belowBy) && belowBy > 0) {
							errorMsg += ' Element is ' + Math.round(belowBy) + 'px below viewport.';
						} else if (Number.isFinite(aboveBy) && aboveBy > 0) {
							errorMsg += ' Element is ' + Math.round(aboveBy) + 'px above viewport.';
						}
					}

					return {
						success: false,
						error: errorMsg,
						scrollFailed: true,
						elementRect: scrollResult.rect,
						viewportSize: scrollResult.viewportSize,
						scrollContainers: scrollResult.scrollContainers,
						scrolledContainers: scrollResult.scrolledContainers,
						containerCount: scrollResult.containerCount
					};
				}

				const rect = element.getBoundingClientRect();
				let cx, cy;

				function computeClickCoords(oX, oY) {
					let x, y;
					if (oX !== null && oY !== null) {
						x = Math.round(rect.left + oX);
						y = Math.round(rect.top + oY);
					} else if (oX !== null) {
						x = Math.round(rect.left + oX);
						y = Math.round(rect.top + rect.height / 2);
					} else if (oY !== null) {
						x = Math.round(rect.left + rect.width / 2);
						y = Math.round(rect.top + oY);
					} else {
						x = Math.round(rect.left + rect.width / 2);
						y = Math.round(rect.top + rect.height / 2);
					}
					return { x, y };
				}

				const coords = computeClickCoords(offsetX, offsetY);
				cx = coords.x;
				cy = coords.y;

				let hitCheck = expectHitTarget({ x: cx, y: cy }, element, usedRef);

				if (!hitCheck.hit) {
					const doc = document;
					const hitElement = getDeepElementFromPoint(doc, cx, cy);
					const blockingInfo = getBlockingElementInfo(hitElement, element);

					if (autoCloseDropdowns && blockingInfo && (blockingInfo.isDropdownOption || blockingInfo.dropdownAncestorRef)) {
						const dropdownEl = blockingInfo.dropdownAncestorRef
							? findElementByRef(blockingInfo.dropdownAncestorRef).element
							: findDropdownAncestor(hitElement);

						if (dropdownEl) {
							dropdownRecovery = {
								detected: true,
								dropdownRef: dropdownEl.getAttribute('data-cursor-ref') || null,
								dropdownTag: dropdownEl.tagName?.toLowerCase() || '',
								dropdownRole: dropdownEl.getAttribute('role') || null,
								recoveryAttempted: true,
								recoverySucceeded: false
							};

							const closeResult = await attemptDropdownClose(dropdownEl);
							dropdownRecovery.recoveryAction = closeResult.method;
							dropdownRecovery.recoverySucceeded = closeResult.success;

							if (closeResult.success) {
								await new Promise(r => setTimeout(r, 50));
								hitCheck = expectHitTarget({ x: cx, y: cy }, element, usedRef);
							}
						}
					}

					if (!hitCheck.hit && retryWithOffset && blockingInfo && blockingInfo.isNonInteractiveText && blockingInfo.clickOffsetSuggestion) {
						const suggestion = blockingInfo.clickOffsetSuggestion;
						offsetRetry = {
							attempted: true,
							suggestedOffset: { x: suggestion.offsetX, y: suggestion.offsetY },
							retrySucceeded: false
						};

						const newOffsetX = suggestion.offsetX !== undefined ? suggestion.offsetX : offsetX;
						const newOffsetY = suggestion.offsetY !== undefined ? suggestion.offsetY : offsetY;
						const newCoords = computeClickCoords(newOffsetX, newOffsetY);

						const retryHitCheck = expectHitTarget({ x: newCoords.x, y: newCoords.y }, element, usedRef);
						if (retryHitCheck.hit) {
							cx = newCoords.x;
							cy = newCoords.y;
							offsetX = newOffsetX;
							offsetY = newOffsetY;
							hitCheck = retryHitCheck;
							offsetRetry.retrySucceeded = true;
						}
					}
				}

				if (!hitCheck.hit) {
					const doc = document;
					const hitElement = getDeepElementFromPoint(doc, cx, cy);
					const blockingInfo = getBlockingElementInfo(hitElement, element);

					let blockingType = hitCheck.blockingType;
					if (blockingInfo && (blockingInfo.isDropdownOption || blockingInfo.dropdownAncestorRef)) {
						blockingType = 'dropdown';
					}

					return {
						success: false,
						hitTargetFailed: true,
						error: hitCheck.error || 'Click would not reach the intended element.',
						interceptedBy: hitCheck.interceptedBy,
						interceptedRef: hitCheck.interceptedRef,
						blockingType: blockingType,
						blockingElementInfo: blockingInfo,
						suggestion: hitCheck.suggestion,
						targetRef: usedRef,
						targetPreview: previewNode(element),
						scrollAttempts: scrollResult.attempts,
						dropdownRecovery: dropdownRecovery,
						offsetRetry: offsetRetry,
						pageState: {
							url: window.location.href,
							title: document.title,
							snapshot: buildPageSnapshot().tree
						}
					};
				}

				await dispatchMouseClickSequenceInBrowser(element, {
					x: cx,
					y: cy,
					button: ${JSON.stringify(t.button??"left")},
					modifiers: ${JSON.stringify(t.modifiers||[])},
					doubleClick: ${JSON.stringify(t.doubleClick??!1)},
					holdDurationMs: holdDurationMs
				});

				const snapshotResult = buildPageSnapshot();
				return {
					success: true,
					usedRef: usedRef,
					refRecovered: recoveryAttempted,
					scrollAttempts: scrollResult.attempts,
					scrolledContainers: scrollResult.scrolledContainers || 0,
					doubleClick: ${JSON.stringify(t.doubleClick)} || false,
					button: ${JSON.stringify(t.button)} || 'left',
					offsetUsed: offsetX !== null || offsetY !== null,
					holdDuration: holdDurationMs,
					dropdownRecovery: dropdownRecovery,
					offsetRetry: offsetRetry,
					pageState: {
						url: window.location.href,
						title: document.title,
						snapshot: snapshotResult.tree
					}
				};
			})();
		

Error: Click target intercepted

Click intercepted by non-interactive text element: <${t.tag}>

Click intercepted by: <${t.tag}

 id="${t.id}"

 class="${t.classes.slice(0,3).join(" ")}"

 role="${t.role}"

Position: top=${t.boundingBox.top}, left=${t.boundingBox.left}, ${t.boundingBox.width}x${t.boundingBox.height}

Blocking element ref: ${t.ref}

Suggestion: Use offsetX=${n.offsetX} to click the ${n.description} of the target element.

Suggestion: Use offsetY=${n.offsetY} to click the ${n.description} of the target element.