workbench.glass.main.js · part 506

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/out/vs/workbench/workbench.glass.main.js, part 506. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

(function() {
	'use strict';

	if (window.__cursorElementPickerInjected) return;
	window.__cursorElementPickerInjected = true;

	if (window !== window.top) return;

	// Element identity is tracked off-DOM via WeakMap to avoid leaking
	// 'data-cursor-element-id' attributes onto the host page. The attribute
	// previously broke Next.js fast-refresh / HMR on customer apps because
	// React reconciliation saw foreign attributes on tracked nodes.
	const elementIdPrefix = 'cursor-el-' + Math.random().toString(36).slice(2, 7) + '-';
	let elementIdCounter = 0;
	const cursorElementIdMap = new WeakMap();
	let selectionMode = false;
	// The element under a region still being noted, so the host can follow it
	// when a resize reflows the page. Held weakly: nothing clears it when the
	// draft ends.
	let trackedRegionAnchor = null;
	let frozen = false;
	// Default true so the first hover shows the hint even if the overlay's
	// initial 'set-show-hint' arrives before this script is injected.
	let hintMode = true;
	let hoverIdentity = true;
	let cursorStyleOverride = null;
	let highlightBox = null;
	let identityPill = null;
	let hoverPreviewBox = null;
	// Identity-pill content cache, keyed on (element, hintMode). The pill
	// also renders mutable state (innerText suffix, id/class), so this
	// deliberately accepts a stale label while the cursor stays within one
	// element: re-reading innerText is a forced layout on every hover RAF
	// tick, which is the cost this cache exists to remove.
	let pillContentElement = null;
	let pillContentHintMode = null;
	let lastHoveredElement = null;
	let lastSentHoveredUid = null;
	let rafPending = false;
	let listeners = null;
	let lastMouseX = 0;
	let lastMouseY = 0;
	let altHeld = false;
	let hoverSuppressed = false;
	// True between hide-picker-highlight and restore-picker-highlight. All
	// deferred visual updates (hover RAFs, geometry-refresh RAFs) must
	// no-op while set, or a callback armed before the hide re-shows picker
	// chrome and it gets captured into the submitted screenshot.
	let hiddenForScreenshot = false;
	let frozenSelectionHueIndex = 0;

	const multiSelectBoxes = new Map();
	const multiSelectElements = new Map();
	const multiSelectHueIndices = new Map();
	// Fingerprint (tag/id/class/innerText) captured at pick time, keyed by
	// element. After an in-place DOM swap (hot-module replacement) it
	// re-attaches the pick to the equivalent fresh element. WeakMap keys let
	// replaced elements be collected.
	const selectionFingerprints = new WeakMap();
	// Tracked elements whose subtree mutated in place; their fingerprints
	// re-capture on the next reconcile while still rendered.
	const dirtyFingerprintElements = new Set();
	// uid -> deadline (ms epoch) for a disconnected pick waiting to
	// re-resolve before it is pruned.
	const pendingReconnects = new Map();
	const RECONNECT_GRACE_MS = ${t.reconnectGraceMs??400};
	let reconcileRetryTimer = 0;
	// True when a mutation batch added nodes since the last resolution
	// attempt: only then can a pending disconnect resolve differently.
	let reconcileHasNewCandidates = false;
	// A rebind or prune happened but the settle notification is still owed
	// (deferred while other disconnects are mid-grace).
	let selectionSettleDirty = false;
	let domMutationObserver = null;
	let domMutationObserverActive = false;

	function sendToHost(channel, data) {
		const bridge = ${e};
		if (bridge) bridge.send(channel, data);
	}

	// Build-time seam: extension builds substitute a predicate that recognizes
	// their own isolated-world UI host. See BrowserElementPickerScriptOptions.
	const isInjectedUiEvent = ${n};

	const HUE_COLORS = ${Pqf};
	function getHueColor(idx) {
		return HUE_COLORS[((idx % HUE_COLORS.length) + HUE_COLORS.length) % HUE_COLORS.length];
	}

	const scrollByAt = ${w6w.toString()};

	const APPEND_HUE_INDICES = ${Mqf};
	function currentPickedCount() {
		if (multiSelectElements.size > 0) {
			return multiSelectElements.size;
		}
		if (frozen && lastHoveredElement) {
			return 1;
		}
		return 0;
	}
	function nextPickHueIndex() {
		const count = currentPickedCount();
		if (count <= 0) return 0;
		return APPEND_HUE_INDICES[(count - 1) % APPEND_HUE_INDICES.length];
	}

	function hueIndexForElement(el) {
		const uid = getOrAssignElementId(el);
		if (uid && multiSelectHueIndices.has(uid)) {
			return multiSelectHueIndices.get(uid);
		}
		return frozenSelectionHueIndex;
	}

	function getHoverHueIndex() {
		return altHeld ? nextPickHueIndex() : 0;
	}

	function refreshHoverHues() {
		if (hoverPreviewBox && hoverPreviewBox.style.display !== 'none') {
			const c = getHueColor(getHoverHueIndex());
			hoverPreviewBox.style.border = '2px solid ' + c.hoverBorder;
			hoverPreviewBox.style.background = c.hoverBg;
		}
		if (!frozen && highlightBox && highlightBox.style.display !== 'none') {
			const c = getHueColor(getHoverHueIndex());
			highlightBox.style.border = '2px solid ' + c.hoverBorder;
			highlightBox.style.background = c.hoverBg;
		}
	}

	const SVG_SKIP = new Set([
		'svg', 'path', 'circle', 'rect', 'line', 'polyline',
		'polygon', 'g', 'use', 'defs', 'clippath', 'mask',
	]);

	const INLINE_SKIP = new Set([
		'span', 'em', 'strong', 'b', 'i', 'u', 'small',
		'sub', 'sup', 'br', 'wbr',
	]);

	const STRUCTURAL_SKIP = new Set([
		'html', 'head', 'script', 'style', 'link', 'meta',
		'title', 'base', 'noscript', 'template',
	]);

	const INTERACTIVE_TAGS = new Set([
		'button', 'a', 'input', 'select', 'textarea', 'label',
	]);

	const INTERACTIVE_ROLES = new Set([
		'button', 'link', 'tab', 'menuitem',
		'checkbox', 'radio', 'switch',
	]);

	const IDENTITY_INTERACTIVE_TAGS = new Set([
		'button', 'a', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'label', 'th', 'td',
	]);

	${kVf}

	function getOrAssignElementId(element) {
		if (!element || element.nodeType !== Node.ELEMENT_NODE) return null;
		let id = cursorElementIdMap.get(element);
		if (!id) {
			id = elementIdPrefix + (++elementIdCounter);
			cursorElementIdMap.set(element, id);
		}
		return id;
	}

	const getElementPathBase = ${y6w.toString()};
	function getElementPath(element) {
		return getElementPathBase(element, isPickerOverlayNode);
	}

	const resolveRestoreItemsBase = ${S6w.toString()};
	function resolveRestoreItems(items, isReserved) {
		return resolveRestoreItemsBase(
			document,
			items,
			isReserved
				? (el) => isPickerOverlayNode(el) || isReserved(el)
				: isPickerOverlayNode
		);
	}

	function isInteractiveOverride(el, tag) {
		if (INTERACTIVE_TAGS.has(tag)) return true;
		const role = el.getAttribute && el.getAttribute('role');
		if (role && INTERACTIVE_ROLES.has(role)) return true;
		if (el.hasAttribute && el.hasAttribute('onclick')) return true;
		if (el.id) return true;
		if (hasComponentBoundary(el)) return true;
		return false;
	}

	function bubbleToMeaningfulElement(raw) {
		let el = raw;
		let depth = 0;
		while (el && depth < 5) {
			const tag = el.tagName.toLowerCase();
			if (isInteractiveOverride(el, tag)) return el;
			if (!SVG_SKIP.has(tag) && !INLINE_SKIP.has(tag)) return el;
			el = el.parentElement;
			depth++;
		}
		return raw;
	}

	function isPickerOverlayNode(node) {
		if (node === highlightBox || node === identityPill || node === hoverPreviewBox) return true;
		if (node && node.getAttribute && node.getAttribute('data-cursor-picker-multiselect') === 'true') return true;
		if (node && node.getAttribute && node.getAttribute('data-cursor-picker-shimmer') === 'true') return true;
		if (node && node.getAttribute && node.getAttribute('data-cursor-picker-shimmer-sweep') === 'true') return true;
		if (node && node.getAttribute && node.getAttribute('data-cursor-picker-shimmer-styles') === 'true') return true;
		return false;
	}

	function isMeaningfulCandidate(el) {
		if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
		if (isPickerOverlayNode(el)) return false;
		const tag = el.tagName.toLowerCase();
		if (STRUCTURAL_SKIP.has(tag)) return false;
		if (isInteractiveOverride(el, tag)) return true;
		if (SVG_SKIP.has(tag)) return false;
		if (INLINE_SKIP.has(tag)) return false;
		return true;
	}

	function findMeaningfulAncestor(el) {
		if (!el || el === document.body) return null;
		let parent = el.parentElement;
		let depth = 0;
		while (parent && parent !== document.body && depth < 32) {
			if (isPickerOverlayNode(parent)) {
				parent = parent.parentElement;
				depth++;
				continue;
			}
			const tag = parent.tagName.toLowerCase();
			if (STRUCTURAL_SKIP.has(tag)) {
				parent = parent.parentElement;
				depth++;
				continue;
			}
			if (isInteractiveOverride(parent, tag)) return parent;
			if (!SVG_SKIP.has(tag) && !INLINE_SKIP.has(tag)) return parent;
			parent = parent.parentElement;
			depth++;
		}
		if (parent === document.body) return parent;
		return null;
	}

	function findFirstMeaningfulChild(el) {
		if (!el || !el.children || el.children.length === 0) return null;
		for (let i = 0; i < el.children.length; i++) {
			const child = el.children[i];
			if (isPickerOverlayNode(child)) continue;
			if (isMeaningfulCandidate(child)) return child;
			const deeper = findFirstMeaningfulChild(child);
			if (deeper) return deeper;
		}
		return null;
	}

	function findMeaningfulSibling(el, direction) {
		if (!el || !el.parentElement) return null;
		const siblings = [];
		let currentIndex = -1;
		const children = el.parentElement.children;
		for (let i = 0; i < children.length; i++) {
			const child = children[i];
			if (isPickerOverlayNode(child)) continue;
			if (!isMeaningfulCandidate(child)) continue;
			if (child === el) {
				currentIndex = siblings.length;
			}
			siblings.push(child);
		}
		if (siblings.length === 0 || currentIndex === -1) return null;
		if (siblings.length === 1) return null;
		const offset = direction === 'next' ? 1 : -1;
		const nextIndex =
			(currentIndex + offset + siblings.length) % siblings.length;
		return siblings[nextIndex];
	}

	function buildIdentityParts(element) {
		const tag = element.tagName.toLowerCase();
		const fwInfo = detectFrameworkInfoCached(element);
		let boldPart = '';
		let lightPart = '';
		if (fwInfo && fwInfo.name) {
			boldPart = fwInfo.name + ' \u00B7 ';
			lightPart = tag;
		} else if (element.id) {
			lightPart = tag;
			boldPart = '#' + element.id;
		} else if (element.className && typeof element.className === 'string') {
			const first = element.className.trim().split(/\s+/)[0];
			if (first) {
				lightPart = tag;
				boldPart = '.' + first;
			} else {
				lightPart = tag;
			}
		} else {
			lightPart = tag;
		}

		let suffix = '';
		if (IDENTITY_INTERACTIVE_TAGS.has(tag) || (element.getAttribute && element.getAttribute('role') === 'button')) {
			const innerText = (element.innerText || '').trim();
			if (innerText.length > 0 && innerText.length <= 30) {
				suffix = ' "' + innerText + '"';
			} else if (innerText.length > 30) {
				suffix = ' "' + innerText.substring(0, 27) + '..."';
			}
		}
		return { boldPart, lightPart, suffix };
	}

	// Write-only: callers pass precomputed identity parts so the layout
	// reads in buildIdentityParts stay ahead of any style writes.
	function renderPillContent(parts, showHint) {
		while (identityPill.firstChild) identityPill.firstChild.remove();

		const line = document.createElement('div');
		line.style.cssText = 'white-space:nowrap;overflow:hidden;text-overflow:ellipsis;';
		if (parts.boldPart) {
			const b = document.createElement('span');
			b.style.fontWeight = '500';
			b.textContent = parts.boldPart;
			line.appendChild(b);
		}
		if (parts.lightPart) {
			const l = document.createElement('span');
			l.style.fontWeight = '400';
			l.textContent = parts.lightPart;
			line.appendChild(l);
		}
		if (parts.suffix) {
			const s = document.createElement('span');
			s.style.fontWeight = '400';
			s.textContent = parts.suffix;
			line.appendChild(s);
		}
		identityPill.appendChild(line);

		if (showHint) {
			const hint = document.createElement('div');
			hint.style.cssText = 'font-weight:400;margin-top:4px;opacity:0.85;white-space:nowrap;';
			hint.textContent = 'Click to select, drag to draw';
			identityPill.appendChild(hint);
		}
	}

	function buildPayload(element, hueIndex) {
		const rect = element.getBoundingClientRect();
		const cs = window.getComputedStyle(element);
		const className = typeof element.className === 'string'
			? element.className
			: (element.className && element.className.baseVal) || '';
		const fwInfo = detectFrameworkInfoCached(element);
		const payload = {
			tagName: String(element.tagName).substring(0, ${Lhs}),
			id: String(element.id || '').substring(0, ${Ohs}),
			uniqueId: String(getOrAssignElementId(element) || '').substring(0, ${RAi}),
			className: String(className).substring(0, ${Fhs}),
			innerText: element.innerText ? element.innerText.substring(0, 200) : '',
			path: getElementPath(element).substring(0, ${ISl}),
			// Keep page payloads within the host validator's ceilings.
			attributes: Array.from(element.attributes || [])
				.slice(0, ${ESl})
				.map(a => ({
					name: String(a.name).substring(0, ${CSl}),
					value: String(a.value).substring(0, ${TSl}),
				})),
			rect: {
				top: rect.top, left: rect.left,
				width: rect.width, height: rect.height
			},
			styles: {
				color: String(cs.color).substring(0, ${P9e}),
				backgroundColor: String(cs.backgroundColor).substring(0, ${P9e}),
				fontSize: String(cs.fontSize).substring(0, ${P9e}),
				fontFamily: String(cs.fontFamily).substring(0, ${xSl}),
				display: String(cs.display).substring(0, ${P9e}),
				position: String(cs.position).substring(0, ${P9e})
			},
			component: fwInfo ? String(fwInfo.name).substring(0, ${PAi}) : undefined,
			componentStack: fwInfo && fwInfo.stack.length > 0
				? fwInfo.stack.map(name => String(name).substring(0, ${PAi}))
				: undefined,
			framework: fwInfo ? fwInfo.framework : undefined,
			componentPropsJson: undefined,
		};
		if (typeof hueIndex === 'number') {
			payload.hueIndex = hueIndex;
		}
		if (element.isConnected) {
			selectionFingerprints.set(element, {
				tagName: payload.tagName,
				id: payload.id,
				className: payload.className,
				innerText: payload.innerText,
			});
		}
		return payload;
	}

	// Lighter-weight capture than buildPayload for fingerprint refreshes:
	// only the identity fields the matcher compares.
	function captureSelectionFingerprint(element) {
		if (!element.isConnected) return;
		const className = typeof element.className === 'string'
			? element.className
			: (element.className && element.className.baseVal) || '';
		selectionFingerprints.set(element, {
			tagName: String(element.tagName).substring(0, ${Lhs}),
			id: String(element.id || '').substring(0, ${Ohs}),
			className: String(className).substring(0, ${Fhs}),
			innerText: element.innerText ? element.innerText.substring(0, 200) : '',
		});
	}

	const PILL_MAX_WIDTH = 320;
	const PILL_HEIGHT = 28;
	const PILL_PADDING_X = 24;
	const HOVER_BORDER_DEFAULT = '2px solid rgba(58,150,221,0.5)';
	const HOVER_BG_DEFAULT = 'transparent';
	const SELECTED_BORDER_DEFAULT = '2px solid #3a96dd';
	const SELECTED_BG_DEFAULT = 'rgba(58,150,221,0.08)';
	const HIGHLIGHT_GEOMETRY_TRANSITION = 'left 0.08s ease,top 0.08s ease,width 0.08s ease,height 0.08s ease';

	function createHighlightElements() {
		if (highlightBox) return;
		highlightBox = document.createElement('div');
		highlightBox.setAttribute('data-cursor-picker-highlight', 'true');
		highlightBox.style.cssText =
			'position:fixed;border:' + HOVER_BORDER_DEFAULT + ';background:' + HOVER_BG_DEFAULT + ';' +
			'border-radius:${F2n}px;pointer-events:none;z-index:2147483647;transition:' + HIGHLIGHT_GEOMETRY_TRANSITION + ';display:none;';
		document.body.appendChild(highlightBox);

		identityPill = document.createElement('div');
		identityPill.setAttribute('data-cursor-picker-pill', 'true');
		identityPill.style.cssText =
			'position:fixed;background:rgba(58,150,221,0.9);color:#fff;' +
			'padding:6px 12px;border-radius:8px;font:500 13px system-ui,-apple-system,sans-serif;' +
			'pointer-events:none;white-space:nowrap;z-index:2147483647;' +
			'max-width:' + PILL_MAX_WIDTH + 'px;overflow:hidden;text-overflow:ellipsis;display:none;' +
			'box-shadow:0 4px 12px rgba(0,0,0,0.15);';
		document.body.appendChild(identityPill);

		hoverPreviewBox = document.createElement('div');
		hoverPreviewBox.setAttribute('data-cursor-picker-hover-preview', 'true');
		hoverPreviewBox.style.cssText =
			'position:fixed;border:' + HOVER_BORDER_DEFAULT + ';background:' + HOVER_BG_DEFAULT + ';' +
			'border-radius:${F2n}px;pointer-events:none;z-index:2147483645;transition:' + HIGHLIGHT_GEOMETRY_TRANSITION + ';display:none;';
		document.body.appendChild(hoverPreviewBox);
	}

	function removeHighlightElements() {
		if (highlightBox) { highlightBox.remove(); highlightBox = null; }
		if (identityPill) { identityPill.remove(); identityPill = null; }
		if (hoverPreviewBox) { hoverPreviewBox.remove(); hoverPreviewBox = null; }
		pillContentElement = null;
	}

	function createMultiSelectBox(hueIndex) {
		const color = getHueColor(hueIndex || 0);
		const box = document.createElement('div');
		box.setAttribute('data-cursor-picker-multiselect', 'true');
		box.style.cssText =
			'position:fixed;border:2px solid ' + color.border + ';background:' + color.bg + ';' +
			'border-radius:${F2n}px;pointer-events:none;z-index:2147483646;display:none;';
		document.body.appendChild(box);
		return box;
	}

	function applyBoxRect(box, rect) {
		box.style.display = '';
		box.style.left = rect.left + 'px';
		box.style.top = rect.top + 'px';
		box.style.width = rect.width + 'px';
		box.style.height = rect.height + 'px';
	}

	function updateMultiSelectBox(box, element) {
		applyBoxRect(box, element.getBoundingClientRect());
	}

	function refreshAllMultiSelectBoxes() {
		// Read every rect before writing any box style: the boxes live in the
		// same layout tree, so interleaved read/write would force one reflow
		// per selected element. Disconnected elements are skipped: their rect
		// is all zeros and their box is hidden while reconciliation waits for
		// the element to come back.
		const updates = [];
		for (const [uid, box] of multiSelectBoxes) {
			const el = multiSelectElements.get(uid);
			if (el && el.isConnected) updates.push([box, el.getBoundingClientRect()]);
		}
		for (const [box, rect] of updates) {
			applyBoxRect(box, rect);
		}
	}

	function currentSelectionEntries() {
		const entries = [];
		const seenUids = new Set();
		if (frozen && lastHoveredElement) {
			const uid = getOrAssignElementId(lastHoveredElement);
			if (uid) {
				seenUids.add(uid);
				entries.push({ uid, el: lastHoveredElement });
			}
		}
		for (const [uid, el] of multiSelectElements.entries()) {
			if (!seenUids.has(uid)) entries.push({ uid, el });
		}
		return entries;
	}

	// Reconciliation is keyed by logical uid, not by visual owner. A selection
	// box and a launch shimmer may intentionally own the same uid at once; HMR
	// must rebind both to the same replacement rather than making them compete
	// for it as independent restore items.
	function trackedSelectionEntries() {
		const byUid = new Map(
			currentSelectionEntries().map(entry => [entry.uid, entry.el])
		);
		for (const [uid, membership] of launchMemberships) {
			const existing = byUid.get(uid);
			if (!existing || (!existing.isConnected && membership.element.isConnected)) {
				byUid.set(uid, membership.element);
			}
		}
		mergeAnchorTrackedEntries(byUid);
		return Array.from(byUid, ([uid, el]) => ({ uid, el }));
	}

	function ownsSelectionUid(uid) {
		return multiSelectElements.has(uid) || !!(
			frozen &&
			lastHoveredElement &&
			cursorElementIdMap.get(lastHoveredElement) === uid
		);
	}

	function rebindTrackedUid(uid, replacement, fingerprint) {
		cursorElementIdMap.set(replacement, uid);
		if (fingerprint) selectionFingerprints.set(replacement, fingerprint);
		if (multiSelectElements.has(uid)) {
			multiSelectElements.set(uid, replacement);
		}
		if (
			frozen &&
			lastHoveredElement &&
			cursorElementIdMap.get(lastHoveredElement) === uid
		) {
			lastHoveredElement = replacement;
		}
		const membership = launchMemberships.get(uid);
		if (membership) membership.element = replacement;
		const displaced = launchDisplacedStacks.get(uid);
		if (displaced) {
			for (const snapshot of displaced) snapshot.element = replacement;
		}
		rebindAnchorMembers(uid, replacement, fingerprint);
	}

${SVf}

	function removeSelectionForUid(uid) {
		const box = multiSelectBoxes.get(uid);
		if (box) box.remove();
		multiSelectBoxes.delete(uid);
		multiSelectElements.delete(uid);
		multiSelectHueIndices.delete(uid);
		if (
			frozen &&
			lastHoveredElement &&
			cursorElementIdMap.get(lastHoveredElement) === uid
		) {
			frozen = false;
			lastHoveredElement = null;
			updateHighlight(null);
		}
	}

	function scheduleReconcileRetry() {
		clearTimeout(reconcileRetryTimer);
		reconcileRetryTimer = 0;
		if (pendingReconnects.size === 0) return;
		const delay = Math.max(
			0,
			Math.min(...pendingReconnects.values()) - Date.now()
		);
		reconcileRetryTimer = setTimeout(function () {
			reconcileRetryTimer = 0;
			// A capture in progress defers visual work; restore-picker-highlight
			// re-runs refreshSelectionGeometry and picks the pending work up.
			if (!selectionMode || hiddenForScreenshot) return;
			refreshSelectionGeometry();
			refreshLaunchGroupBoxes();
		}, delay);
	}

	// A settle replaces the host's payloads wholesale through the same
	// element-picked/isNavigation shape the resize resend already uses, so
	// path/attributes/rects stay truthful for whichever elements the picks
	// are now bound to. Only a fully emptied selection goes out as a bare
	// resync: retaining nothing is what moves the open draft to the composer.
	function notifySelectionSettled() {
		const connected = currentSelectionEntries().filter(entry => entry.el.isConnected);
		if (connected.length === 0) {
			sendToHost('selection-resynced', { multiSelectPayloads: [] });
			return;
		}
		const payloads = connected.map(entry =>
			buildPayload(entry.el, hueIndexForElement(entry.el))
		);
		if (payloads.length === 1) {
			sendToHost('element-picked', {
				element: payloads[0],
				altKey: false,
				isNavigation: true,
			});
			return;
		}
		sendToHost('element-picked', {
			element: payloads[payloads.length - 1],
			altKey: false,
			isNavigation: true,
			shiftKey: true,
			multiSelectPayloads: payloads,
		});
	}

	// HMR frameworks (Vite, Next.js fast refresh) replace DOM subtrees in
	// place without a navigation, so the tracked element objects disconnect
	// while their logical elements re-render. Re-attach each disconnected
	// pick to the unique element matching its fingerprint captured at pick
	// time, keeping the host-visible uid stable so chips, mentions, and the
	// open draft survive. Unresolved picks get a short grace window (a React
	// remount settles within a frame or two); only after it do they prune.
	// The host hears one settle notification once every disconnect has
	// settled — notifying earlier would evict a pick about to re-resolve.
	function reconcileDisconnectedSelections() {
		retryMissingAnchors();
		const entries = trackedSelectionEntries();
		if (dirtyFingerprintElements.size > 0) {
			// In-place text/class edits mutate identity fields without a
			// disconnect; refresh those fingerprints while the elements are
			// still rendered so a later swap can still match.
			for (const entry of entries) {
				if (entry.el.isConnected && dirtyFingerprintElements.has(entry.el)) {
					captureSelectionFingerprint(entry.el);
				}
			}
			dirtyFingerprintElements.clear();
		}
		const disconnected = entries.filter(entry => !entry.el.isConnected);
		const disconnectedUids = new Set(disconnected.map(entry => entry.uid));
		for (const uid of Array.from(pendingReconnects.keys())) {
			if (!disconnectedUids.has(uid)) pendingReconnects.delete(uid);
		}
		if (disconnected.length === 0) {
			if (pendingReconnects.size === 0 && selectionSettleDirty) {
				selectionSettleDirty = false;
				notifySelectionSettled();
			}
			return;
		}
		const now = Date.now();
		const hasNewDisconnects = disconnected.some(
			entry => !pendingReconnects.has(entry.uid)
		);
		const deadlineReached = disconnected.some(entry => {
			const deadline = pendingReconnects.get(entry.uid);
			return deadline !== undefined && now >= deadline;
		});
		// Resolution scans same-tag elements and reads innerText on prefix
		// matches, so run it only when its answer can have changed: a fresh
		// disconnect, new nodes since the last attempt, or a due deadline.
		const attemptResolve =
			hasNewDisconnects || reconcileHasNewCandidates || deadlineReached;
		reconcileHasNewCandidates = false;
		// One element can sit under several tracked uids (a pin re-attached by
		// fingerprint keeps its own uid on an element the draft owns), so
		// resolve each element once and give its replacement to every uid on
		// it; the replacement keeps the uid the element itself carried.
		let replacementFor = null;
		if (attemptResolve) {
			const disconnectedEls = Array.from(new Set(disconnected.map(entry => entry.el)));
			const items = disconnectedEls.map(el => selectionFingerprints.get(el) || null);
			// An element already backing a connected tracked pick or shimmer
			// is spoken for: it neither counts toward ambiguity nor can be
			// stolen by a disconnected pick with the same fingerprint.
			const reserved = new Set();
			for (const entry of entries) {
				if (entry.el.isConnected) reserved.add(entry.el);
			}
			const resolvedEls = resolveRestoreItems(items, el => reserved.has(el));
			replacementFor = new Map(disconnectedEls.map((el, i) => [el, resolvedEls[i]]));
		}
		for (const entry of disconnected) {
			const replacement = replacementFor ? replacementFor.get(entry.el) : null;
			if (replacement) {
				pendingReconnects.delete(entry.uid);
				const fingerprint = selectionFingerprints.get(entry.el);
				rebindTrackedUid(entry.uid, replacement, fingerprint);
				const ownerUid = cursorElementIdMap.get(entry.el);
				if (ownerUid && ownerUid !== entry.uid && disconnectedUids.has(ownerUid)) {
					cursorElementIdMap.set(replacement, ownerUid);
				}
				if (ownsSelectionUid(entry.uid)) selectionSettleDirty = true;
				continue;
			}
			const deadline = pendingReconnects.get(entry.uid);
			if (deadline === undefined) {
				pendingReconnects.set(entry.uid, now + RECONNECT_GRACE_MS);
				// Hide the stale box while the pick waits: a box floating at
				// the pre-swap rect points at nothing either way. (The frozen
				// highlight hides through updateHighlight's disconnect guard.)
				const selectionBox = multiSelectBoxes.get(entry.uid);
				if (selectionBox) selectionBox.style.display = 'none';
				const membership = launchMemberships.get(entry.uid);
				if (membership) membership.box.style.display = 'none';
				continue;
			}
			if (now < deadline) continue;
			// Grace expired: the element is really gone.
			pendingReconnects.delete(entry.uid);
			if (ownsSelectionUid(entry.uid)) {
				removeSelectionForUid(entry.uid);
				selectionSettleDirty = true;
			}
			if (launchMemberships.has(entry.uid)) {
				removeLaunchMembership(entry.uid);
			}
			detachAnnotationAnchorUid(entry.uid);
		}
		if (pendingReconnects.size > 0) {
			scheduleReconcileRetry();
			return;
		}
		refreshDomMutationObserver();
		if (selectionSettleDirty) {
			selectionSettleDirty = false;
			notifySelectionSettled();
		}
	}

	// Geometry refresh plus DOM-disconnect reconciliation. Rebinds and
	// evictions are reported to the host once settled, as fresh payloads or
	// an empty resync.
	// Pin rects go out only from the once-per-frame refresh, so a timer, a
	// resize or a host set never adds a second annotation-anchors in a frame.
	function refreshSelectionGeometry(isFrame) {
		reconcileDisconnectedSelections();
		const anchorRects = isFrame ? measureAnnotationAnchors() : null;
		refreshAllMultiSelectBoxes();
		if (frozen && lastHoveredElement) {
			updateHighlight(lastHoveredElement);
		}
		if (isFrame) {
			sendAnnotationAnchors(anchorRects);
		} else if (hasAnnotationAnchors()) {
			scheduleGeometryRefresh();
		}
	}

	function toggleMultiSelect(element, hueIndex) {
		const uid = getOrAssignElementId(element);
		if (!uid) return false;
		if (multiSelectElements.has(uid)) {
			multiSelectElements.delete(uid);
			const box = multiSelectBoxes.get(uid);
			if (box) box.remove();
			multiSelectBoxes.delete(uid);
			multiSelectHueIndices.delete(uid);
			refreshHoverHues();
			return false;
		}
		multiSelectElements.set(uid, element);
		const idx = typeof hueIndex === 'number'
			? hueIndex
			: multiSelectElements.size - 1;
		multiSelectHueIndices.set(uid, idx);
		const box = createMultiSelectBox(idx);
		updateMultiSelectBox(box, element);
		multiSelectBoxes.set(uid, box);
		refreshHoverHues();
		return true;
	}

	function clearAllMultiSelect() {
		for (const box of multiSelectBoxes.values()) box.remove();
		multiSelectBoxes.clear();
		multiSelectElements.clear();
		multiSelectHueIndices.clear();
		refreshHoverHues();
	}

	function getMultiSelectPayloads() {
		const payloads = [];
		for (const [uid, el] of multiSelectElements.entries()) {
			payloads.push(buildPayload(el, multiSelectHueIndices.get(uid)));
		}
		return payloads;
	}

${wVf}

	function sendHoveredRect(meaningful) {
		if (!meaningful) {
			if (lastSentHoveredUid === null) return;
			lastSentHoveredUid = null;
			sendToHost('element-hovered', { rect: null });
			return;
		}
		const uid = getOrAssignElementId(meaningful);
		if (uid === lastSentHoveredUid) return;
		lastSentHoveredUid = uid;
		const rect = meaningful.getBoundingClientRect();
		sendToHost('element-hovered', {
			rect: {
				top: rect.top,
				left: rect.left,
				width: rect.width,
				height: rect.height,
			},
		});
	}

	function updateHighlight(element) {
		if (!highlightBox || !identityPill) return;
		// A disconnected element has an all-zero rect; hide rather than paint
		// a collapsed box at the origin while reconciliation waits for its
		// replacement.
		if (!element || !element.isConnected) {
			highlightBox.style.display = 'none';
			identityPill.style.display = 'none';
			pillContentElement = null;
			return;
		}
		// Layout reads (rect, identity text, viewport) happen before any style
		// write below so the browser resolves layout at most once per update.
		const rect = element.getBoundingClientRect();
		// Quiet mode (hoverIdentity false) anchors the identity pill to the
		// frozen selection instead of the cursor.
		const pillAnchor = frozen
			? (hoverIdentity ? null : 'selection')
			: (hoverIdentity ? 'cursor' : null);
		const pillHint = hintMode && !frozen;
		const needsPillContent =
			pillAnchor !== null &&
			(pillContentElement !== element || pillContentHintMode !== pillHint);
		const pillParts = needsPillContent ? buildIdentityParts(element) : null;
		// The selection pill clears classic scrollbars. The scrolling element
		// reports the visible area: the root in standards mode, body in quirks
		// mode. Without one, the root may report only its own box, so fall back
		// to the inner size.
		const visibleBox = document.scrollingElement;
		const viewportWidth = pillAnchor === 'selection'
			? Math.min(window.innerWidth, (visibleBox ? visibleBox.clientWidth : 0) || window.innerWidth)
			: window.innerWidth;
		const viewportHeight = pillAnchor === 'selection'
			? Math.min(window.innerHeight, (visibleBox ? visibleBox.clientHeight : 0) || window.innerHeight)
			: window.innerHeight;

		highlightBox.style.display = '';
		highlightBox.style.left = rect.left + 'px';
		highlightBox.style.top = rect.top + 'px';
		highlightBox.style.width = rect.width + 'px';
		highlightBox.style.height = rect.height + 'px';
		if (frozen) {
			const selColor = getHueColor(frozenSelectionHueIndex);
			highlightBox.style.border = '2px solid ' + selColor.border;
			highlightBox.style.background = selColor.bg;
		} else {
			const hoverColor = getHueColor(getHoverHueIndex());
			highlightBox.style.border = '2px solid ' + hoverColor.hoverBorder;
			highlightBox.style.background = hoverColor.hoverBg;
		}

		if (pillAnchor === null) {
			identityPill.style.display = 'none';
			pillContentElement = null;
			return;
		}
		identityPill.style.display = '';
		if (pillParts) {
			renderPillContent(pillParts, pillHint);
			pillContentElement = element;
			pillContentHintMode = pillHint;
		}

		if (pillAnchor === 'selection') {
			if (rect.bottom <= 0 || rect.top >= viewportHeight) {
				identityPill.style.display = 'none';
				return;
			}
			// Outer width: max-width sizes the content box inside the padding.
			const pillMaxWidth = Math.max(PILL_PADDING_X, Math.min(PILL_MAX_WIDTH, viewportWidth - 8));
			identityPill.style.maxWidth = pillMaxWidth - PILL_PADDING_X + 'px';
			// Right-align to the selection unless a full-width pill would cross the
			// viewport's left edge; then left-align, clamped to the right edge.
			if (rect.right >= pillMaxWidth + 4) {
				identityPill.style.left = '';
				identityPill.style.right = Math.max(4, viewportWidth - rect.right) + 'px';
			} else {
				identityPill.style.right = '';
				identityPill.style.left =
					Math.max(4, Math.min(rect.left, viewportWidth - pillMaxWidth - 4)) + 'px';
			}
			const anchorTop = Math.max(0, rect.top);
			if (anchorTop >= 36) {
				identityPill.style.top = anchorTop - 6 + 'px';
				identityPill.style.transform = 'translateY(-100%)';
			} else {
				identityPill.style.top =
					Math.max(0, Math.min(anchorTop + 6, viewportHeight - PILL_HEIGHT)) + 'px';
				identityPill.style.transform = '';
			}
			return;
		}

		identityPill.style.maxWidth = PILL_MAX_WIDTH + 'px';
		identityPill.style.transform = '';
		const pillLeft = lastMouseX + 12;
		const pillTop = lastMouseY + 20;
		identityPill.style.right = '';
		if (pillLeft + PILL_MAX_WIDTH > viewportWidth) {
			identityPill.style.left = '';
			identityPill.style.right = '4px';
		} else {
			identityPill.style.left = pillLeft + 'px';
		}
		identityPill.style.top = Math.min(pillTop, viewportHeight - PILL_HEIGHT) + 'px';
	}

	function updateHoverPreview(element) {
		if (!hoverPreviewBox) return;
		if (!element) {
			hoverPreviewBox.style.display = 'none';
			return;
		}
		const uid = cursorElementIdMap.get(element);
		if (uid && multiSelectElements.has(uid)) {
			hoverPreviewBox.style.display = 'none';
			return;
		}
		if (!frozen && multiSelectElements.size === 0) {
			hoverPreviewBox.style.display = 'none';
			return;
		}
		const rect = element.getBoundingClientRect();
		const color = getHueColor(getHoverHueIndex());
		hoverPreviewBox.style.display = '';
		hoverPreviewBox.style.left = rect.left + 'px';
		hoverPreviewBox.style.top = rect.top + 'px';
		hoverPreviewBox.style.width = rect.width + 'px';
		hoverPreviewBox.style.height = rect.height + 'px';
		hoverPreviewBox.style.border = '2px solid ' + color.hoverBorder;
		hoverPreviewBox.style.background = color.hoverBg;
	}

	function hideHighlightForScreenshot() {
		hiddenForScreenshot = true;
		if (identityPill) identityPill.style.display = 'none';
		if (hoverPreviewBox) hoverPreviewBox.style.display = 'none';
		for (const box of multiSelectBoxes.values()) box.style.display = 'none';
		for (const membership of launchMemberships.values()) membership.box.style.display = 'none';
	}

	function restoreHighlight() {
		hiddenForScreenshot = false;
		refreshSelectionGeometry();
		refreshLaunchGroupBoxes();
	}

	function updateHoverAt(x, y) {
		if (!selectionMode || hoverSuppressed || hiddenForScreenshot) return;
		const el = document.elementFromPoint(x, y);
		if (el && !isPickerOverlayNode(el)) {
			const meaningful = bubbleToMeaningfulElement(el);
			sendHoveredRect(meaningful);
			if (!frozen && multiSelectElements.size === 0) {
				lastHoveredElement = meaningful;
				updateHighlight(meaningful);
				updateHoverPreview(null);
			} else {
				updateHoverPreview(meaningful);
			}
		}
	}

	function onMouseMove(e) {
		if (!selectionMode || hoverSuppressed || isInjectedUiEvent(e)) return;
		scheduleHoverUpdateAt(e.clientX, e.clientY);
	}

	function scheduleHoverUpdateAt(x, y) {
		lastMouseX = x;
		lastMouseY = y;
		if (rafPending) return;
		rafPending = true;
		requestAnimationFrame(() => {
			rafPending = false;
			updateHoverAt(lastMouseX, lastMouseY);
		});
	}

	function seedMultiSelectFromFrozen() {
		if (frozen && lastHoveredElement && multiSelectElements.size === 0) {
			toggleMultiSelect(lastHoveredElement);
			frozen = false;
		}
	}

	function onClick(e) {
		if (!selectionMode || isInjectedUiEvent(e)) return;
		if (!e.isTrusted) {
			blockEvent(e);
			return;
		}
		if (e.shiftKey !== true) {
			const groupId = hitTestReadyLaunchGroup(e.clientX, e.clientY);
			if (groupId) {
				e.preventDefault();
				e.stopPropagation();
				e.stopImmediatePropagation();
				sendToHost('group-activated', {
					groupId,
					clientX: e.clientX,
					clientY: e.clientY,
				});
				return;
			}
		}
		e.preventDefault();
		e.stopPropagation();
		e.stopImmediatePropagation();

		const el = document.elementFromPoint(e.clientX, e.clientY);
		if (!el || isPickerOverlayNode(el)) return;
		const meaningful = bubbleToMeaningfulElement(el);

		if (e.shiftKey === true) {
			seedMultiSelectFromFrozen();
			toggleMultiSelect(meaningful);
			if (multiSelectElements.size === 0) {
				frozen = true;
				frozenSelectionHueIndex = 0;
				lastHoveredElement = meaningful;
				updateHighlight(meaningful);
				updateHoverPreview(null);
				refreshDomMutationObserver();
				return;
			}
			lastHoveredElement = meaningful;
			updateHighlight(null);
			updateHoverPreview(null);
			refreshDomMutationObserver();
			sendToHost('element-picked', {
				element: buildPayload(meaningful, hueIndexForElement(meaningful)),
				altKey: e.altKey === true,
				shiftKey: true,
				multiSelectPayloads: getMultiSelectPayloads(),
			});
			return;
		}

		clearAllMultiSelect();
		lastHoveredElement = meaningful;
		frozen = true;
		frozenSelectionHueIndex = 0;
		updateHighlight(meaningful);
		updateHoverPreview(null);
		refreshDomMutationObserver();

		sendToHost('element-picked', {
			element: buildPayload(meaningful, hueIndexForElement(meaningful)),
			altKey: e.altKey === true,
		});
	}

	function blockEvent(e) {
		if (!selectionMode || isInjectedUiEvent(e)) return;
		e.preventDefault();
		e.stopPropagation();
		e.stopImmediatePropagation();
	}

	let resizeTimer = 0;
	// Scroll fires per scrolled element (capture listener) and mutations can
	// arrive several times per frame. One geometry refresh per frame is
	// enough, and it still lands before that frame's paint because scroll
	// handlers and mutation callbacks run ahead of rAF callbacks.
	let geometryRefreshRafPending = false;
	function scheduleGeometryRefresh() {
		if (geometryRefreshRafPending) return;
		geometryRefreshRafPending = true;
		requestAnimationFrame(() => {
			geometryRefreshRafPending = false;
			// Applying box rects sets display:'' and would undo an
			// intervening hide-picker-highlight mid-capture.
			if (!selectionMode || hiddenForScreenshot) return;
			refreshSelectionGeometry(true);
			refreshLaunchGroupBoxes();
		});
	}
	function onScrollGeometryChanged() {
		if (!selectionMode) return;
		scheduleGeometryRefresh();
	}

	const PICKER_CHROME_SELECTOR =
		'[data-cursor-picker-highlight],[data-cursor-picker-pill],' +
		'[data-cursor-picker-hover-preview],[data-cursor-picker-multiselect],' +
		'[data-cursor-picker-shimmer],[data-cursor-picker-shimmer-sweep],' +
		'[data-cursor-picker-shimmer-styles]';
	function isPickerChromeNode(node) {
		return !!node
			&& node.nodeType === Node.ELEMENT_NODE
			&& typeof node.matches === 'function'
			&& node.matches(PICKER_CHROME_SELECTOR);
	}
	// The observer must ignore the picker's own DOM writes (box styles, pill
	// content, box mount/unmount) or every geometry refresh would schedule
	// the next one forever.
	function isPickerChromeMutation(record) {
		const target = record.target;
		const scope = target.nodeType === Node.ELEMENT_NODE
			? target
			: target.parentElement;
		if (scope && typeof scope.closest === 'function' && scope.closest(PICKER_CHROME_SELECTOR)) {
			return true;
		}
		if (record.type !== 'childList') return false;
		const added = record.addedNodes;
		const removed = record.removedNodes;
		if (added.length === 0 && removed.length === 0) return false;
		for (let i = 0; i < added.length; i++) {
			if (!isPickerChromeNode(added[i])) return false;
		}
		for (let i = 0; i < removed.length; i++) {
			if (!isPickerChromeNode(removed[i])) return false;
		}
		return true;
	}
	// Page DOM churn (hot-module replacement swaps, streaming agent edits,
	// text updates) moves or replaces selected elements without any scroll
	// or resize. Watch for it so selection boxes track layout and
	// reconciliation notices disconnected picks promptly.
	function onDomMutations(records) {
		if (!selectionMode) return;
		const tracked = trackedSelectionEntries();
		if (tracked.length === 0 && !hasAnnotationAnchors()) return;
		const connectedTrackedElements = new Set(
			tracked.filter(entry => entry.el.isConnected).map(entry => entry.el)
		);
		let sawPageMutation = false;
		const addedNodeLists = [];
		for (let i = 0; i < records.length; i++) {
			const record = records[i];
			if (isPickerChromeMutation(record)) continue;
			sawPageMutation = true;
			if (record.type === 'childList' && record.addedNodes.length > 0) {
				reconcileHasNewCandidates = true;
				addedNodeLists.push(record.addedNodes);
			}
			// An in-place edit inside a tracked element changes the identity
			// fields its fingerprint records.
			const target = record.target.nodeType === Node.ELEMENT_NODE
				? record.target
				: record.target.parentElement;
			let ancestor = target;
			while (ancestor) {
				if (connectedTrackedElements.has(ancestor)) {
					dirtyFingerprintElements.add(ancestor);
				}
				ancestor = ancestor.parentElement;
			}
		}
		noteAddedAnchorCandidates(addedNodeLists);
		if (sawPageMutation) scheduleGeometryRefresh();
	}

	function refreshDomMutationObserver() {
		const shouldObserve =
			selectionMode && (
				multiSelectElements.size > 0 ||
				launchMemberships.size > 0 ||
				hasAnnotationAnchors() ||
				(frozen && !!lastHoveredElement)
			);
		if (shouldObserve === domMutationObserverActive) return;
		if (shouldObserve) {
			domMutationObserver ||= new MutationObserver(onDomMutations);
			domMutationObserver.observe(document.documentElement, {
				childList: true,
				subtree: true,
				attributes: true,
				characterData: true,
			});
		} else {
			domMutationObserver.disconnect();
		}
		domMutationObserverActive = shouldObserve;
	}

	function onViewportGeometryChanged() {
		if (!selectionMode || hiddenForScreenshot) return;
		var isMulti = multiSelectElements.size > 0;
		var hasSelection = (frozen && lastHoveredElement) || isMulti;
		refreshSelectionGeometry();
		refreshLaunchGroupBoxes();
		if (!hasSelection) return;
		clearTimeout(resizeTimer);
		resizeTimer = setTimeout(function() {
			if (!selectionMode || hiddenForScreenshot) return;
			refreshSelectionGeometry();
			refreshLaunchGroupBoxes();
			if (lastHoveredElement) {
				var isM = multiSelectElements.size > 0;
				sendToHost('element-picked', {
					element: buildPayload(lastHoveredElement, hueIndexForElement(lastHoveredElement)),
					altKey: false,
					isNavigation: true,
					shiftKey: isM,
					multiSelectPayloads: isM ? getMultiSelectPayloads() : undefined,
				});
			}
		}, 150);
	}

	function enableSelection() {
		if (selectionMode) return;
		selectionMode = true;
		frozen = false;
		createHighlightElements();

		if (!cursorStyleOverride) {
			cursorStyleOverride = document.createElement('style');
			cursorStyleOverride.textContent = ${JSON.stringify(i)};
			document.head.appendChild(cursorStyleOverride);
		}

		const moveHandler = onMouseMove;
		const clickHandler = onClick;
		const keyDownHandler = (ev) => {
			if (ev.key === 'Alt' && !altHeld) {
				altHeld = true;
				refreshHoverHues();
			}
		};
		const keyUpHandler = (ev) => {
			if (ev.key === 'Alt' && altHeld) {
				altHeld = false;
				refreshHoverHues();
			}
		};
		const blurHandler = () => {
			if (altHeld) {
				altHeld = false;
				refreshHoverHues();
			}
		};

		document.addEventListener('mousemove', moveHandler);
		document.addEventListener('click', clickHandler, true);
		document.addEventListener('mousedown', blockEvent, true);
		document.addEventListener('mouseup', blockEvent, true);
		document.addEventListener('pointerdown', blockEvent, true);
		document.addEventListener('pointerup', blockEvent, true);
		document.addEventListener('keydown', keyDownHandler, true);
		document.addEventListener('keyup', keyUpHandler, true);
		window.addEventListener('blur', blurHandler);
		window.addEventListener('resize', onViewportGeometryChanged);
		document.addEventListener('scroll', onScrollGeometryChanged, true);
		listeners = { moveHandler, clickHandler, keyDownHandler, keyUpHandler, blurHandler };
		if (hasAnnotationAnchors()) {
			// A set that arrived while selection was off has not been
			// measured against the live page yet.
			markAnchorsForRetry();
			refreshDomMutationObserver();
			scheduleGeometryRefresh();
		}
	}

	function disableSelection() {
		clearTimeout(resizeTimer);
		clearTimeout(reconcileRetryTimer);
		reconcileRetryTimer = 0;
		pendingReconnects.clear();
		dirtyFingerprintElements.clear();
		reconcileHasNewCandidates = false;
		selectionSettleDirty = false;
		clearAnnotationAnchors();
		trackedRegionAnchor = null;
		if (domMutationObserver) domMutationObserver.disconnect();
		domMutationObserverActive = false;
		selectionMode = false;
		frozen = false;
		frozenSelectionHueIndex = 0;
		altHeld = false;
		hoverSuppressed = false;
		hoverIdentity = true;
		hiddenForScreenshot = false;
		lastHoveredElement = null;
		sendHoveredRect(null);
		clearAllMultiSelect();
		clearLaunchGroups();

		if (cursorStyleOverride) {
			cursorStyleOverride.remove();
			cursorStyleOverride = null;
		}

		removeHighlightElements();

		if (listeners) {
			document.removeEventListener('mousemove', listeners.moveHandler);
			document.removeEventListener('click', listeners.clickHandler, true);
			document.removeEventListener('mousedown', blockEvent, true);
			document.removeEventListener('mouseup', blockEvent, true);
			document.removeEventListener('pointerdown', blockEvent, true);
			document.removeEventListener('pointerup', blockEvent, true);
			document.removeEventListener('keydown', listeners.keyDownHandler, true);
			document.removeEventListener('keyup', listeners.keyUpHandler, true);
			window.removeEventListener('blur', listeners.blurHandler);
			listeners = null;
		}
		window.removeEventListener('resize', onViewportGeometryChanged);
		document.removeEventListener('scroll', onScrollGeometryChanged, true);
	}

	function unfreezeSelection() {
		frozen = false;
		refreshSelectionGeometry();
		refreshDomMutationObserver();
	}

	// Null when the point hits nothing more specific than the document.
	function regionAnchorElementAt(x, y) {
		const hit = document.elementFromPoint(x, y);
		const el = hit && !isPickerOverlayNode(hit) ? bubbleToMeaningfulElement(hit) : null;
		return !el || el === document.body || el === document.documentElement ? null : el;
	}

	function regionAnchorAt(x, y) {
		return buildPayload(regionAnchorElementAt(x, y) || document.documentElement, 0);
	}

	function trackRegionAnchorAt(x, y) {
		const anchor = regionAnchorElementAt(x, y);
		trackedRegionAnchor = anchor ? new WeakRef(anchor) : null;
		return trackedRegionAnchorRect();
	}

	function trackedRegionAnchorRect() {
		const anchor = trackedRegionAnchor?.deref();
		if (!anchor || !anchor.isConnected) return null;
		const rect = anchor.getBoundingClientRect();
		return { top: rect.top, left: rect.left, width: rect.width, height: rect.height };
	}

	window.__cursorPicker = {
		bubbleToMeaningfulElement,
		getElementPath,
		buildPayload,
		regionAnchorAt,
		trackRegionAnchorAt,
		trackedRegionAnchorRect,
	};

	function repaintHoverHighlight() {
		pillContentElement = null;
		// A multi-select leaves lastHoveredElement set with no hover box;
		// repainting it would strand a hover box over that pick. A frozen pick
		// keeps its box even after alt-appended picks.
		if (!hiddenForScreenshot && lastHoveredElement && (frozen || multiSelectElements.size === 0)) {
			updateHighlight(lastHoveredElement);
		}
	}

	function onPickerCommand(data) {
		if (!data || typeof data !== 'object') return;
		if (data.type === 'enable-element-selection') {
			enableSelection();
		} else if (data.type === 'disable-element-selection') {
			disableSelection();
		} else if (data.type === 'unfreeze-element-selection') {
			unfreezeSelection();
		} else if (data.type === 'hide-picker-highlight') {
			hideHighlightForScreenshot();
		} else if (data.type === 'restore-picker-highlight') {
			restoreHighlight();
		} else if (data.type === 'set-show-hint') {
			hintMode = !!data.value;
			repaintHoverHighlight();
		} else if (data.type === 'set-hover-identity') {
			hoverIdentity = !!data.value;
			repaintHoverHighlight();
		} else if (data.type === 'clear-hover') {
			lastHoveredElement = null;
			updateHighlight(null);
			updateHoverPreview(null);
			sendHoveredRect(null);
			refreshDomMutationObserver();
		} else if (data.type === 'set-picker-hover-suppressed') {
			hoverSuppressed = !!data.value;
			if (hoverSuppressed) {
				updateHoverPreview(null);
				sendHoveredRect(null);
				if (!frozen && multiSelectElements.size === 0) {
					lastHoveredElement = null;
					updateHighlight(null);
				}
			} else if (!hiddenForScreenshot) {
				// Only restore-picker-highlight may clear the screenshot
				// hide; an unsuppress mid-capture (pointer leaving the
				// comment input during submit) must not redraw the boxes
				// into the capture.
				restoreHighlight();
			}
		} else if (data.type === 'clear-multi-select') {
			clearAllMultiSelect();
			updateHoverPreview(null);
			refreshDomMutationObserver();
		} else if (data.type === 'promote-selection-to-group') {
			promoteSelectionToGroup(data.groupId, data.uids);
		} else if (data.type === 'mark-group-ready') {
			markLaunchGroupReady(data.groupId);
		} else if (data.type === 'demote-group-to-selection') {
			demoteGroupToSelection(
				data.groupId,
				data.restoreSelection === true
			);
		} else if (data.type === 'remove-picked-element') {
			const uid = typeof data.uid === 'string' ? data.uid : null;
			if (!uid) return;
			removeSelectionForUid(uid);
			updateHoverPreview(null);
			refreshDomMutationObserver();
		} else if (data.type === 'hover-at') {
			if (!selectionMode || hoverSuppressed) return;
			lastMouseX = data.x;
			lastMouseY = data.y;
			// The host already sends at most one hover per frame. Apply it
			// immediately instead of waiting for a second renderer's RAF.
			if (!rafPending) updateHoverAt(data.x, data.y);
		} else if (data.type === 'scroll-by-at') {
			// Scrolling mid-capture would shift the content out from under
			// the element crop computed at pick time.
			if (!selectionMode || hiddenForScreenshot) return;
			scrollByAt(document, data.x, data.y, data.deltaX, data.deltaY);
			if (!hoverSuppressed) {
				// The content under the cursor moved. Clearing the dedupe uid
				// forces a rect resend to the host even when the same element
				// stays under the cursor (its viewport rect changed).
				lastSentHoveredUid = null;
				scheduleHoverUpdateAt(data.x, data.y);
			}
		} else if (data.type === 'cancel-design-overlay') {
			clearAllMultiSelect();
			frozen = false;
			frozenSelectionHueIndex = 0;
			hoverSuppressed = false;
			hiddenForScreenshot = false;
			lastHoveredElement = null;
			updateHighlight(null);
			updateHoverPreview(null);
			sendHoveredRect(null);
			// Cancel ends the current selection protocol. Keep reconnects that
			// belong to persistent launch shimmers and annotation anchors, but
			// discard every deferred selection settle so it cannot publish
			// into the next draft.
			for (const uid of Array.from(pendingReconnects.keys())) {
				if (!outlivesDraft(uid)) {
					pendingReconnects.delete(uid);
				}
			}
			for (const element of Array.from(dirtyFingerprintElements)) {
				const uid = cursorElementIdMap.get(element);
				if (!uid || !outlivesDraft(uid)) {
					dirtyFingerprintElements.delete(element);
				}
			}
			selectionSettleDirty = false;
			reconcileHasNewCandidates =
				reconcileHasNewCandidates && pendingReconnects.size > 0;
			scheduleReconcileRetry();
			refreshDomMutationObserver();
		} else if (data.type === 'restore-selection') {
			if (!selectionMode) {
				sendToHost('selection-restored', {
					requestId: data.requestId,
					multiSelectPayloads: [],
				});
				return;
			}
			const items = Array.isArray(data.elements)
				? data.elements.slice(0, ${slt})
				: [];
			const resolvedEls = resolveRestoreItems(items);
			clearAllMultiSelect();
			frozen = false;
			frozenSelectionHueIndex = 0;
			lastHoveredElement = null;
			updateHighlight(null);
			updateHoverPreview(null);
			const resolved = [];
			for (let i = 0; i < items.length; i++) {
				const el = resolvedEls[i];
				if (!el) continue;
				const item = items[i];
				const hueIdx = typeof item.hueIndex === 'number'
					? item.hueIndex
					: resolved.length;
				resolved.push({ el, hueIdx });
			}
			const payloads = resolved.map(({ el, hueIdx }) => buildPayload(el, hueIdx));
			if (resolved.length === 1) {
				const { el, hueIdx } = resolved[0];
				frozen = true;
				frozenSelectionHueIndex = hueIdx;
				lastHoveredElement = el;
				updateHighlight(el);
			} else if (resolved.length > 1) {
				for (const { el, hueIdx } of resolved) {
					const uid = getOrAssignElementId(el);
					if (!uid) continue;
					multiSelectElements.set(uid, el);
					multiSelectHueIndices.set(uid, hueIdx);
					const box = createMultiSelectBox(hueIdx);
					updateMultiSelectBox(box, el);
					multiSelectBoxes.set(uid, box);
				}
				lastHoveredElement = resolved[resolved.length - 1].el;
				frozen = false;
				updateHighlight(null);
			}
			refreshDomMutationObserver();
			sendToHost('selection-restored', {
				requestId: data.requestId,
				multiSelectPayloads: payloads,
			});
		} else if (data.type === 'set-annotation-anchors') {
			setAnnotationAnchors(Array.isArray(data.anchors) ? data.anchors : []);
		} else if (data.type === 'scroll-annotation-into-view') {
			if (typeof data.id === 'string') scrollAnnotationIntoView(data.id, data.behavior, data.regionOffset);
		} else if (data.type === 'pick-element-at') {
			if (!selectionMode) return;
			const el = document.elementFromPoint(data.x, data.y);
			if (!el || isPickerOverlayNode(el)) return;
			const meaningful = bubbleToMeaningfulElement(el);

			if (data.appendToOverlay === true) {
				const uid = getOrAssignElementId(meaningful);
				const hueIdx = typeof data.hueIndex === 'number'
					? data.hueIndex
					: multiSelectElements.size;
				if (uid && !multiSelectElements.has(uid)) {
					multiSelectElements.set(uid, meaningful);
					multiSelectHueIndices.set(uid, hueIdx);
					const box = createMultiSelectBox(hueIdx);
					updateMultiSelectBox(box, meaningful);
					multiSelectBoxes.set(uid, box);
				}
				refreshDomMutationObserver();
				updateHoverPreview(null);
				sendToHost('element-picked', {
					element: buildPayload(meaningful, hueIdx),
					altKey: true,
					appendToOverlay: true,
					requestId: data.requestId,
				});
				return;
			}

			if (data.shiftKey === true) {
				seedMultiSelectFromFrozen();
				const startHueIdx = typeof data.hueIndex === 'number'
					? data.hueIndex
					: 0;
				toggleMultiSelect(meaningful, startHueIdx + Math.max(0, multiSelectElements.size));
				if (multiSelectElements.size === 0) {
					// Shift-deselected the last element. Reply as a plain
					// single-pick so the host's pending request gate clears;
					// otherwise submit stays disabled.
					frozen = true;
					frozenSelectionHueIndex = startHueIdx;
					lastHoveredElement = meaningful;
					updateHighlight(meaningful);
					refreshDomMutationObserver();
					sendToHost('element-picked', {
						element: buildPayload(meaningful),
						altKey: data.altKey === true,
						requestId: data.requestId,
					});
					return;
				}
				lastHoveredElement = meaningful;
				updateHighlight(null);
				refreshDomMutationObserver();
				sendToHost('element-picked', {
					element: buildPayload(meaningful, hueIndexForElement(meaningful)),
					altKey: data.altKey === true,
					requestId: data.requestId,
					shiftKey: true,
					multiSelectPayloads: getMultiSelectPayloads(),
				});
				return;
			}

			clearAllMultiSelect();
			lastHoveredElement = meaningful;
			frozen = true;
			frozenSelectionHueIndex = typeof data.hueIndex === 'number'
				? data.hueIndex
				: 0;
			updateHighlight(meaningful);
			updateHoverPreview(null);
			refreshDomMutationObserver();
			sendToHost('element-picked', {
				element: buildPayload(meaningful, hueIndexForElement(meaningful)),
				altKey: data.altKey === true,
				requestId: data.requestId,
			});
		} else if (
			data.type === 'cursor-design-select-parent' ||
			data.type === 'cursor-design-select-first-child' ||
			data.type === 'cursor-design-select-next-sibling' ||
			data.type === 'cursor-design-select-previous-sibling'
		) {
			if (!selectionMode || !lastHoveredElement) return;
			clearAllMultiSelect();
			let target = null;
			if (data.type === 'cursor-design-select-parent') {
				target = findMeaningfulAncestor(lastHoveredElement);
			} else if (data.type === 'cursor-design-select-first-child') {
				target = findFirstMeaningfulChild(lastHoveredElement);
			} else if (data.type === 'cursor-design-select-next-sibling') {
				target = findMeaningfulSibling(lastHoveredElement, 'next');
			} else {
				target = findMeaningfulSibling(lastHoveredElement, 'previous');
			}
			if (!target) return;
			lastHoveredElement = target;
			frozen = true;
			updateHighlight(target);
			refreshDomMutationObserver();
			sendToHost('element-picked', {
				element: buildPayload(target, frozenSelectionHueIndex),
				altKey: false,
				isNavigation: true,
			});
		}
	}

	${r}
})();

use strict

window.addEventListener('message', (e) => {
		if (e.source !== window) return;
		onPickerCommand(e.data);
	});

window.__cursorPickerCommand = onPickerCommand;

[${f}] Failed to disable element picker:

[${f}] Failed to enable element picker:

use strict

use strict

Can't connect to server

[BrowserTabContent] Failed to accept certificate:

[BrowserTabContent] Failed to reject certificate:

HTTP ERROR

Copied error details to clipboard

Copied URL to clipboard

Failed to capture screenshot${jr?.error?`: ${jr.error}`:""}

: ${jr.error}

Failed to capture screenshot: 

Hide Favorites & History

Show Favorites & History

Hide favorites and history

Show favorites and history

glass-78zum5 glass-dt5ytf glass-euugli glass-2lah0s glass-1n2onr6 glass-jbqb8w glass-e0pwq glass-19ypqd9 glass-1arpupx glass-6ikm8r glass-10wlt62

Resize browser sidebar

glass-1n2onr6 glass-78zum5 glass-dt5ytf glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-euugli glass-5yr21d

glass-78zum5 glass-1iyjqo2 glass-euugli glass-kh2ocl glass-6s0dn4

glass-78zum5 glass-6s0dn4 glass-5cdhqx glass-2lah0s

glass--default-marker glass-3nfvp2 glass-6s0dn4 glass-l56j7k glass-2lah0s

glass--default-marker glass-3nfvp2 glass-6s0dn4 glass-l56j7k glass-2lah0s glass-1n2onr6 glass-6anfts glass-1m1144u

glass-10l6tqk glass-13vifvy glass-3m8u43 glass-1ey2m1c glass-u96u03 glass-7ve9fu glass-78zum5 glass-6s0dn4 glass-l56j7k glass-67bb7w glass-6o6s4a glass-1lbmi28 glass-1hc1fzr glass-1vcc2rl glass-19991ni glass-12s1jxh glass-6ekqhr

Remove Bookmark

Bookmark This Page

Remove Bookmark

Bookmark This Page

glass-78zum5 glass-6s0dn4 glass-5cdhqx glass-2lah0s

Hide Console

Show Console

Hide Console

Show Console

glass-78zum5 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-euugli glass-2lwn1j

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-euugli glass-78zum5 glass-dt5ytf

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-euugli glass-78zum5 glass-dt5ytf glass-12peec7

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-6ikm8r glass-10wlt62

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-6ikm8r glass-10wlt62 glass-78zum5 glass-1q0g3np glass-1ys0zz1

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-6ikm8r glass-10wlt62 glass-1s85apg

glass-1n2onr6 glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-6ikm8r glass-10wlt62 glass-1q0g3np glass-1ys0zz1 glass-1s85apg

glass-10l6tqk glass-13vifvy glass-3m8u43 glass-1ey2m1c glass-u96u03 glass-52sccv glass-jbqb8w glass-hds75k glass-4wkmsb glass-gdialr glass-12w9bfk glass-6ekqhr

glass-10l6tqk glass-13vifvy glass-3m8u43 glass-1ey2m1c glass-u96u03 glass-52sccv glass-hds75k glass-4wkmsb glass-gdialr glass-12w9bfk glass-6ekqhr glass-9sb9an

glass-1iyjqo2 glass-s83m0k glass-1t1x2f9 glass-2lwn1j glass-78zum5 glass-6s0dn4 glass-l56j7k glass-1odjw0f glass-1krxdfg

glass-78zum5 glass-dt5ytf glass-1cy8zhl glass-dpxx8g glass-ehausa glass-1gfrnbc glass-m6i5cn

glass-1j61zf2 glass-1wd3ewq glass-dj266r glass-1yf7rl7 glass-at24cr glass-j3b58b

Certificate Error

glass-11wthnw glass-1dbl2gt glass-19aaqeu glass-1dt7z5j glass-dj266r glass-1yf7rl7 glass-at24cr glass-j3b58b glass-j0a0fe

The certificate for this site is not trusted

glass-78zum5 glass-dt5ytf glass-ehausa glass-h8yej3 glass-19snzy6 glass-1t8xvyj glass-1jkygx glass-usxwy5 glass-1o7kk3e glass-gxpns3 glass-161eota glass-1ot9j5z glass-1s4tksr glass-kphxji glass-178xt8z glass-s1s249 glass-so031l glass-e0pwq glass-13fuv20 glass-32b0ac glass-1q0q8m5 glass-19ypqd9 glass-1njmyyh glass-y7i79c glass-1talola glass-famn59 glass-9f619

glass-78zum5 glass-ehausa glass-1wm8ruf glass-37zpob

glass-1s688f glass-19aaqeu glass-18advcn glass-2lah0s

glass-19aaqeu glass-13faqbe glass-1iyjqo2 glass-s83m0k glass-1t1x2f9

glass-78zum5 glass-ehausa glass-1wm8ruf glass-37zpob

glass-1s688f glass-19aaqeu glass-18advcn glass-2lah0s

glass-19aaqeu glass-13faqbe glass-1iyjqo2 glass-s83m0k glass-1t1x2f9