silvery 0.19.2 → 0.21.0

package/dist/mouse-events-Dki3ISIp.mjs

@@ -0,0 +1,1044 @@
+import { O as displayWidthAnsi, rt as wrapText } from "./ansi-yC4RyBNY.mjs";
+import { createLogger } from "loggily";
+//#region packages/ag/src/focus-queries.ts
+/** Check if a node has the focusable prop set to true (or truthy). */
+function isFocusable(node) {
+	if (node.hidden) return false;
+	const props = node.props;
+	return Boolean(props.focusable) && props.display !== "none";
+}
+/** Check if a node creates a focus scope (isolated Tab cycle). */
+function isFocusScope(node) {
+	const props = node.props;
+	return Boolean(props.focusScope);
+}
+/**
+* Walk up from node to nearest ancestor (or self) with focusable prop.
+* Useful for mouse clicks — find the focusable target from a deep text node.
+*/
+function findFocusableAncestor(node) {
+	let current = node;
+	while (current) {
+		if (isFocusable(current)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* DFS traversal of focusable nodes in tab order, optionally scoped.
+*
+* When scope is provided, only nodes within that scope subtree are included.
+* If a focusScope node is encountered during traversal, its children are
+* skipped (they belong to a different scope), unless that scope IS the
+* provided scope node.
+*/
+function getTabOrder(root, scope) {
+	const result = [];
+	const walkRoot = scope ?? root;
+	function walk(node) {
+		if (node.hidden) return;
+		if (node.props.display === "none") return;
+		if (node !== walkRoot && isFocusScope(node)) {
+			if (isFocusable(node)) result.push(node);
+			return;
+		}
+		if (isFocusable(node)) result.push(node);
+		for (const child of node.children) walk(child);
+	}
+	walk(walkRoot);
+	return result;
+}
+/**
+* Walk up from a node to find the nearest ancestor (or self) with focusScope prop.
+* Returns the testID of the enclosing scope, or null if none found.
+*/
+function findEnclosingScope(node) {
+	let current = node;
+	while (current) {
+		if (isFocusScope(current)) {
+			const props = current.props;
+			return typeof props.testID === "string" ? props.testID : null;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Find a node by testID in the subtree rooted at root.
+* DFS, returns the first match.
+*/
+function findByTestID(root, testID) {
+	if (root.props.testID === testID) return root;
+	for (const child of root.children) {
+		const found = findByTestID(child, testID);
+		if (found) return found;
+	}
+	return null;
+}
+/**
+* Compute center point of a Rect.
+*/
+function rectCenter(rect) {
+	return {
+		cx: rect.x + rect.width / 2,
+		cy: rect.y + rect.height / 2
+	};
+}
+/**
+* Check if a candidate point falls within a 45-degree cone from source
+* in the given direction (tvOS-style spatial navigation).
+*
+* The cone extends from the center of the source rect in the specified
+* direction with a 45-degree half-angle (90-degree total aperture).
+*/
+function isInCone(source, candidate, direction) {
+	const dx = candidate.cx - source.cx;
+	const dy = candidate.cy - source.cy;
+	switch (direction) {
+		case "up":
+			if (dy >= 0) return false;
+			return Math.abs(dx) <= Math.abs(dy);
+		case "down":
+			if (dy <= 0) return false;
+			return Math.abs(dx) <= Math.abs(dy);
+		case "left":
+			if (dx >= 0) return false;
+			return Math.abs(dy) <= Math.abs(dx);
+		case "right":
+			if (dx <= 0) return false;
+			return Math.abs(dy) <= Math.abs(dx);
+	}
+}
+/**
+* Euclidean distance between two points.
+*/
+function distance(a, b) {
+	const dx = a.cx - b.cx;
+	const dy = a.cy - b.cy;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+/**
+* Find the nearest focusable candidate in a given direction using
+* 45-degree cone heuristic (tvOS-style spatial navigation).
+*
+* From the center of the source rect, draw a cone in the target direction.
+* Filter candidates whose center falls within the cone. Pick the closest
+* by Euclidean distance.
+*
+* @param from - The currently focused node
+* @param direction - Direction to search
+* @param candidates - All focusable nodes to consider
+* @param layoutFn - Function to get screen rect for a node (null if not laid out)
+*/
+function findSpatialTarget(from, direction, candidates, layoutFn) {
+	const sourceRect = layoutFn(from);
+	if (!sourceRect) return null;
+	const source = rectCenter(sourceRect);
+	let best = null;
+	let bestDist = Infinity;
+	for (const candidate of candidates) {
+		if (candidate === from) continue;
+		const candidateRect = layoutFn(candidate);
+		if (!candidateRect) continue;
+		const target = rectCenter(candidateRect);
+		if (!isInCone(source, target, direction)) continue;
+		const dist = distance(source, target);
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = candidate;
+		}
+	}
+	return best;
+}
+/**
+* Check if a node has an explicit nextFocus{Direction} override prop.
+*
+* These props allow components to declare explicit focus targets for
+* spatial navigation, overriding the cone heuristic.
+*
+* @param node - The node to check
+* @param direction - Direction string: "up", "down", "left", "right"
+* @returns The testID of the explicit target, or null
+*/
+function getExplicitFocusLink(node, direction) {
+	const value = node.props[`nextFocus${direction.charAt(0).toUpperCase()}${direction.slice(1)}`];
+	return typeof value === "string" ? value : null;
+}
+//#endregion
+//#region packages/ag/src/interactive-signals.ts
+/**
+* Ensure a node has an InteractiveState object, creating one if needed.
+* Returns the (possibly newly created) state.
+*/
+function ensureInteractiveState(node) {
+	if (!node.interactiveState) node.interactiveState = {
+		hovered: false,
+		armed: false,
+		selected: false,
+		focused: false,
+		dropTarget: false
+	};
+	return node.interactiveState;
+}
+/**
+* Set the hovered state. Returns true if the value changed.
+*/
+function setHovered(node, value) {
+	const state = ensureInteractiveState(node);
+	if (state.hovered === value) return false;
+	state.hovered = value;
+	return true;
+}
+/**
+* Set the armed state (pointer-down, awaiting click). Returns true if the value changed.
+*/
+function setArmed(node, value) {
+	const state = ensureInteractiveState(node);
+	if (state.armed === value) return false;
+	state.armed = value;
+	return true;
+}
+/**
+* Set the focused state. Returns true if the value changed.
+*/
+function setFocused(node, value) {
+	const state = ensureInteractiveState(node);
+	if (state.focused === value) return false;
+	state.focused = value;
+	return true;
+}
+//#endregion
+//#region packages/ag/src/tree-utils.ts
+/**
+* Collect the ancestor path from target to root (inclusive).
+*/
+function getAncestorPath(node) {
+	const path = [];
+	let current = node;
+	while (current) {
+		path.push(current);
+		current = current.parent;
+	}
+	return path;
+}
+/**
+* Check if a point is inside a rect.
+*/
+function pointInRect(x, y, rect) {
+	return x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+}
+//#endregion
+//#region packages/ag-term/src/mouse-events.ts
+/**
+* DOM-level Mouse Events for silvery
+*
+* Provides React DOM-compatible mouse event infrastructure:
+* - SilveryMouseEvent / SilveryWheelEvent synthetic event objects
+* - Tree-based hit testing using scrollRect (replaces manual HitRegistry)
+* - Event dispatch with bubbling (target → root, stopPropagation support)
+* - Double-click detection (300ms / 2-cell threshold)
+* - mouseenter/mouseleave tracking (no bubble, like DOM spec)
+*/
+const mouseLog = createLogger("silvery:mouse");
+/**
+* Create a synthetic mouse event.
+*
+* Modifier keys are merged from two sources:
+* - SGR mouse protocol: reports Ctrl, Alt/Meta, Shift (reliable)
+* - Keyboard tracking: reports Super/Cmd, Hyper, CapsLock, NumLock (via Kitty protocol)
+*
+* `metaKey` = keyboard-tracked Super (Cmd on macOS). SGR "meta" maps to `altKey`.
+*/
+function createMouseEvent(type, x, y, target, parsed, keyboardMods) {
+	let propagationStopped = false;
+	let defaultPrevented = false;
+	const metaKey = keyboardMods?.super ?? false;
+	if (type === "click" || type === "mousedown") mouseLog.debug?.(`createMouseEvent(${type}) metaKey=${metaKey} keyboardMods.super=${keyboardMods?.super}`);
+	else if (type === "wheel") {
+		const targetId = target.props.id ?? "";
+		mouseLog.debug?.(`createMouseEvent(wheel) x=${x} y=${y} delta=${parsed.delta ?? 0} target=${target.type}#${targetId}`);
+	} else if (type === "mouseup") mouseLog.debug?.(`createMouseEvent(mouseup) x=${x} y=${y} button=${parsed.button}`);
+	return {
+		type,
+		x,
+		y,
+		clientX: parsed.clientX,
+		clientY: parsed.clientY,
+		button: parsed.button,
+		altKey: parsed.meta,
+		ctrlKey: parsed.ctrl,
+		metaKey,
+		shiftKey: parsed.shift,
+		timeStamp: parsed.receivedAt ?? performance.now(),
+		inputBatchId: parsed.inputBatchId,
+		target,
+		currentTarget: target,
+		nativeEvent: parsed,
+		get propagationStopped() {
+			return propagationStopped;
+		},
+		get defaultPrevented() {
+			return defaultPrevented;
+		},
+		stopPropagation() {
+			propagationStopped = true;
+		},
+		preventDefault() {
+			defaultPrevented = true;
+		}
+	};
+}
+/**
+* Create a synthetic wheel event.
+*/
+function createWheelEvent(x, y, target, parsed, keyboardMods) {
+	const base = createMouseEvent("wheel", x, y, target, parsed, keyboardMods);
+	base.deltaY = parsed.delta ?? 0;
+	base.deltaX = 0;
+	return base;
+}
+/** Position property on a Box that takes the node out of normal flow. */
+function isAbsolutePositioned(node) {
+	return node.props.position === "absolute";
+}
+/**
+* Geometry-based hit test for absolute-positioned descendants.
+*
+* Walks the whole subtree rooted at `node` in tree order. For each
+* absolute-positioned descendant whose scrollRect contains (x, y), recurse
+* into it as a standalone hit-test (which finds the deepest in-flow child
+* under that absolute) and track the latest-in-tree hit — that one paints
+* on top (third pass in render order uses natural child order, so later =
+* higher z).
+*
+* Respects pointerEvents="none" on the absolute root and its ancestors,
+* and overflow:hidden/scroll clipping on ancestors up to `node`.
+*
+* Returns null if no absolute descendant covers (x, y).
+*/
+function hitTestAbsoluteDescendants(node, x, y, ancestorClipRect) {
+	let result = null;
+	for (const child of node.children) {
+		const cp = child.props;
+		if (cp.pointerEvents === "none") continue;
+		let childClip = ancestorClipRect;
+		if (cp.overflow === "hidden" || cp.overflow === "scroll") {
+			const cr = child.scrollRect;
+			if (cr) childClip = childClip ? intersectRect(childClip, cr) : cr;
+		}
+		if (isAbsolutePositioned(child) && child.scrollRect) {
+			if (!(ancestorClipRect && !pointInRect(x, y, ancestorClipRect)) && pointInRect(x, y, child.scrollRect)) {
+				const hit = hitTestAbsoluteDescendants(child, x, y, null) ?? hitTestInFlow(child, x, y);
+				if (hit) result = hit;
+			}
+		}
+		const deeper = hitTestAbsoluteDescendants(child, x, y, childClip);
+		if (deeper) result = deeper;
+	}
+	return result;
+}
+/** Compute the intersection of two rects; returns a zero-size rect if disjoint. */
+function intersectRect(a, b) {
+	const x1 = Math.max(a.x, b.x);
+	const y1 = Math.max(a.y, b.y);
+	const x2 = Math.min(a.x + a.width, b.x + b.width);
+	const y2 = Math.min(a.y + a.height, b.y + b.height);
+	return {
+		x: x1,
+		y: y1,
+		width: Math.max(0, x2 - x1),
+		height: Math.max(0, y2 - y1)
+	};
+}
+/**
+* In-flow (non-absolute) DFS hit test. Used by both `hitTest` after the
+* absolute pass, and by `hitTestAbsoluteDescendants` when recursing into a
+* matched absolute to find the deepest in-flow descendant under it.
+*
+* Skips absolute children — they're handled by the absolute pass at the
+* entry point (`hitTest`).
+*/
+function hitTestInFlow(node, x, y) {
+	const rect = node.scrollRect;
+	if (!rect) return null;
+	if (!pointInRect(x, y, rect)) return null;
+	const props = node.props;
+	if (props.pointerEvents === "none") return null;
+	const clips = props.overflow === "hidden" || props.overflow === "scroll";
+	for (let i = node.children.length - 1; i >= 0; i--) {
+		const child = node.children[i];
+		if (isAbsolutePositioned(child)) continue;
+		if (clips) {
+			if (child.scrollRect && !pointInRect(x, y, rect)) continue;
+		}
+		const hit = hitTestInFlow(child, x, y);
+		if (hit) return hit;
+	}
+	if (node.type === "silvery-text") for (let i = node.children.length - 1; i >= 0; i--) {
+		const child = node.children[i];
+		if (child.inlineRects) {
+			for (const inlineRect of child.inlineRects) if (pointInRect(x, y, inlineRect)) return child;
+		}
+	}
+	return node;
+}
+/**
+* Tree-based hit test: find the deepest node whose scrollRect contains (x, y).
+*
+* Uses reverse child order (last sibling wins = highest z-order, like DOM).
+* Respects overflow:hidden clipping and pointerEvents="none".
+*
+* ### Absolute-positioned nodes escape parent bounds
+*
+* Absolute descendants participate in hit-testing by GEOMETRY, not by
+* tree order / parent rect containment. An absolute child can be placed
+* outside its parent's bounding rect (e.g., a popover anchored near a
+* viewport edge); it still occupies screen cells at its own geometry and
+* must be hittable.
+*
+* The hit test runs an "absolute pass" first that walks the whole subtree
+* for absolute descendants and returns the latest-in-tree hit (matching
+* the three-pass render order where absolute children paint on top of
+* normal + sticky content). If no absolute descendant covers the point,
+* it falls through to standard in-flow DFS.
+*
+* A recursive sub-call (via `hitTest(absolute, ...)`) would re-run the
+* absolute pass on that absolute's subtree — which is correct: nested
+* absolutes also need geometry-based hit testing.
+*/
+function hitTest(node, x, y) {
+	const absHit = hitTestAbsoluteDescendants(node, x, y, null);
+	if (absHit) return absHit;
+	return hitTestInFlow(node, x, y);
+}
+/**
+* Resolve the effective userSelect value for a node.
+* "auto" inherits from parent; root defaults to "text".
+*/
+function resolveUserSelect(node) {
+	let current = node;
+	while (current) {
+		const value = current.props.userSelect;
+		if (value === "none" || value === "text" || value === "contain") return value;
+		current = current.parent;
+	}
+	return "text";
+}
+/**
+* Selection hit test: find the deepest node whose text is selectable at (x, y).
+*
+* Unlike pointer hitTest, this:
+* - Ignores pointerEvents (a node with pointerEvents="none" can still be selectable)
+* - Respects userSelect (a node with userSelect="none" is not a selection target)
+*/
+function selectionHitTest(node, x, y) {
+	return selectionHitTestInner(node, x, y, true);
+}
+function selectionCellFromPoint(x, y) {
+	return {
+		col: Math.max(0, Math.floor(x)),
+		row: Math.max(0, Math.floor(y))
+	};
+}
+/**
+* Find the nearest selectable rendered-text cell inside a container rect.
+*
+* This is the terminal-target equivalent of the browser's
+* caretPositionFromPoint behavior for text-containing boxes: a mousedown in
+* padding or interior whitespace can still start text selection by snapping to
+* nearby rendered text, while genuinely text-free containers return null.
+*/
+function nearestSelectableCellFromPoint(buffer, rect, x, y) {
+	if (rect.width <= 0 || rect.height <= 0) return null;
+	const left = Math.max(0, Math.floor(rect.x));
+	const right = Math.min(buffer.width - 1, Math.ceil(rect.x + rect.width) - 1);
+	const top = Math.max(0, Math.floor(rect.y));
+	const bottom = Math.min(buffer.height - 1, Math.ceil(rect.y + rect.height) - 1);
+	if (left > right || top > bottom) return null;
+	const pointerCol = Math.max(0, Math.floor(x));
+	const pointerRow = Math.max(0, Math.floor(y));
+	const rows = [];
+	for (let row = top; row <= bottom; row++) {
+		let first = -1;
+		let last = -1;
+		let nearest = -1;
+		let nearestDistance = Number.POSITIVE_INFINITY;
+		for (let col = left; col <= right; col++) {
+			if (!buffer.isCellSelectable(col, row)) continue;
+			if (first === -1) first = col;
+			last = col;
+			const distance = Math.abs(col - pointerCol);
+			if (distance < nearestDistance) {
+				nearest = col;
+				nearestDistance = distance;
+			}
+		}
+		if (first !== -1) rows.push({
+			row,
+			first,
+			last,
+			nearest
+		});
+	}
+	if (rows.length === 0) return null;
+	const firstRow = rows[0];
+	const lastRow = rows[rows.length - 1];
+	const sameRow = rows.find((candidate) => candidate.row === pointerRow);
+	if (sameRow) {
+		if (pointerCol < sameRow.first) return {
+			col: sameRow.first,
+			row: sameRow.row
+		};
+		if (pointerCol > sameRow.last) return {
+			col: Math.min(right, sameRow.last + 1),
+			row: sameRow.row
+		};
+		return {
+			col: sameRow.nearest,
+			row: sameRow.row
+		};
+	}
+	if (pointerRow < firstRow.row) return {
+		col: firstRow.first,
+		row: firstRow.row
+	};
+	if (pointerRow > lastRow.row) return {
+		col: lastRow.last,
+		row: lastRow.row
+	};
+	for (let i = 0; i < rows.length; i++) {
+		const candidate = rows[i];
+		if (candidate.row > pointerRow) return {
+			col: candidate.first,
+			row: candidate.row
+		};
+	}
+	return {
+		col: lastRow.last,
+		row: lastRow.row
+	};
+}
+/**
+* Resolve the semantic selection anchor for a terminal pointer position.
+*
+* This is the single owner for mousedown selection semantics:
+* - exact selectable glyph / empty rendered line hits
+* - `userSelect="none"` pointer targets that block document selection
+* - nearest rendered text-cell fallback from blank padding inside text containers
+* - `userSelect="contain"` / document boundary discovery
+* - Shift/raw buffer selection that bypasses document scopes
+*/
+function resolveSelectionAnchorFromPoint(options) {
+	const { root, buffer, x, y } = options;
+	const forceBufferSelection = options.forceBufferSelection === true;
+	const downCell = selectionCellFromPoint(x, y);
+	let anchorCell = downCell;
+	if (!root) return forceBufferSelection ? {
+		node: null,
+		cell: anchorCell,
+		downCell,
+		boundaries: [],
+		forceBufferSelection
+	} : null;
+	const pointerTarget = hitTest(root, x, y);
+	const pointerBlocksSelection = pointerTarget !== null && resolveUserSelect(pointerTarget) === "none";
+	let selectedNode = !pointerBlocksSelection ? selectionHitTest(root, x, y) : null;
+	if (selectedNode === null && !forceBufferSelection && !pointerBlocksSelection && pointerTarget !== null && buffer) {
+		let current = pointerTarget;
+		while (current && selectedNode === null) {
+			const rect = current.scrollRect;
+			const nearest = rect ? nearestSelectableCellFromPoint(buffer, rect, x, y) : null;
+			if (!nearest) {
+				current = current.parent;
+				continue;
+			}
+			const nearestHit = selectionHitTest(root, nearest.col, nearest.row);
+			if (nearestHit) {
+				anchorCell = nearest;
+				selectedNode = nearestHit;
+			}
+			current = current.parent;
+		}
+	}
+	if (selectedNode === null && !forceBufferSelection) return null;
+	return {
+		node: selectedNode,
+		cell: anchorCell,
+		downCell,
+		boundaries: selectedNode ? findSelectionBoundaries(selectedNode) : [],
+		forceBufferSelection
+	};
+}
+function selectionHitTestInner(node, x, y, allowRowFallback) {
+	const rect = node.scrollRect;
+	if (!rect) return null;
+	if (!pointInRect(x, y, rect)) return null;
+	const props = node.props;
+	if (resolveUserSelect(node) === "none") return null;
+	const clips = props.overflow === "hidden" || props.overflow === "scroll";
+	for (let i = node.children.length - 1; i >= 0; i--) {
+		const child = node.children[i];
+		const childRect = child.scrollRect;
+		if (clips) {
+			if (childRect && !pointInRect(x, y, rect)) continue;
+		}
+		if (childRect && pointInRect(x, y, childRect)) {
+			if (resolveUserSelect(child) === "none") return null;
+			const hit = selectionHitTestInner(child, x, y, false);
+			if (hit) return hit;
+			continue;
+		}
+		const hit = selectionHitTestInner(child, x, y, false);
+		if (hit) return hit;
+	}
+	if (node.type === "silvery-text") for (let i = node.children.length - 1; i >= 0; i--) {
+		const child = node.children[i];
+		if (child.inlineRects) {
+			for (const inlineRect of child.inlineRects) if (pointInRect(x, y, inlineRect)) return child;
+		}
+	}
+	if (node.type === "silvery-text") return pointHitsRenderedTextRow(node, y) ? node : null;
+	return allowRowFallback ? findTextNodeOnRow(node, y) : null;
+}
+function nodeSelectionScope(node) {
+	const rect = node.scrollRect;
+	if (!rect) return null;
+	if (rect.width <= 0 || rect.height <= 0) return null;
+	if (node.type === "silvery-text") {
+		const textBounds = renderedTextBounds(node);
+		if (textBounds === null) return null;
+		return {
+			top: rect.y,
+			bottom: rect.y + textBounds.height - 1,
+			left: rect.x,
+			right: rect.x + textBounds.width - 1
+		};
+	}
+	return {
+		top: rect.y,
+		bottom: rect.y + rect.height - 1,
+		left: rect.x,
+		right: rect.x + rect.width - 1
+	};
+}
+function collectText(node) {
+	if (node.type === "silvery-text" && node.textContent !== void 0) return node.textContent;
+	let out = "";
+	for (const child of node.children) out += collectText(child);
+	return out;
+}
+function renderedTextLines(node) {
+	const rect = node.scrollRect;
+	if (!rect || rect.width <= 0) return [];
+	const text = collectText(node);
+	if (text.length === 0) return [];
+	const wrap = node.props.wrap;
+	return wrap !== false && wrap !== "truncate" && wrap !== "truncate-end" && wrap !== "clip" ? wrapText(text, rect.width, true, false) : text.split("\n");
+}
+function renderedTextBounds(node) {
+	const rect = node.scrollRect;
+	if (!rect || rect.width <= 0 || rect.height <= 0) return null;
+	const lines = renderedTextLines(node);
+	if (lines.length === 0) return null;
+	let maxWidth = 0;
+	for (const line of lines) maxWidth = Math.max(maxWidth, Math.min(rect.width, displayWidthAnsi(line)));
+	if (maxWidth <= 0) return null;
+	return {
+		width: maxWidth,
+		height: Math.min(rect.height, lines.length)
+	};
+}
+function pointHitsRenderedTextRow(node, y) {
+	const rect = node.scrollRect;
+	if (!rect) return false;
+	const row = y - rect.y;
+	if (row < 0 || row >= rect.height) return false;
+	return renderedTextLines(node)[row] !== void 0;
+}
+function findTextNodeOnRow(node, y) {
+	for (let i = node.children.length - 1; i >= 0; i--) {
+		const child = node.children[i];
+		const hit = findTextNodeOnRow(child, y);
+		if (hit) return hit;
+	}
+	return node.type === "silvery-text" && pointHitsRenderedTextRow(node, y) ? node : null;
+}
+/**
+* Return the selectable document-ancestor chain for a node, nearest first.
+*
+* This is the DOM-like selection path: ordinary selectable nodes create
+* semantic selection regions, while `userSelect="contain"` marks a CSS-style
+* hard containment boundary that selection must not escape.
+*/
+function findSelectionBoundaries(node) {
+	const boundaries = [];
+	let current = node;
+	while (current) {
+		if (resolveUserSelect(current) !== "none") {
+			const scope = nodeSelectionScope(current);
+			if (scope) {
+				const props = current.props;
+				boundaries.push({
+					node: current,
+					scope,
+					hardContain: props.userSelect === "contain"
+				});
+			}
+		}
+		current = current.parent;
+	}
+	return boundaries;
+}
+/** Map event type to the handler prop name */
+const EVENT_HANDLER_MAP = {
+	click: "onClick",
+	dblclick: "onDoubleClick",
+	tripleclick: "onTripleClick",
+	mousedown: "onMouseDown",
+	mouseup: "onMouseUp",
+	mousemove: "onMouseMove",
+	mouseenter: "onMouseEnter",
+	mouseleave: "onMouseLeave",
+	wheel: "onWheel"
+};
+/**
+* Dispatch a mouse event through the render tree with DOM-style bubbling.
+*
+* Bubbles from target → root, calling the appropriate handler on each node.
+* stopPropagation() halts bubbling. mouseenter/mouseleave do NOT bubble (DOM spec).
+*/
+function dispatchMouseEvent(event) {
+	const handlerProp = EVENT_HANDLER_MAP[event.type];
+	if (!handlerProp) return;
+	if (event.type === "mouseenter" || event.type === "mouseleave") {
+		const handler = event.target.props[handlerProp];
+		if (handler) {
+			const mutableEvent = event;
+			mutableEvent.currentTarget = event.target;
+			handler(event);
+		}
+		return;
+	}
+	const path = getAncestorPath(event.target);
+	for (const node of path) {
+		if (event.propagationStopped) break;
+		const handler = node.props[handlerProp];
+		if (handler) {
+			const mutableEvent = event;
+			mutableEvent.currentTarget = node;
+			handler(event);
+		}
+	}
+}
+function createClickCountState() {
+	return {
+		lastClickTime: 0,
+		lastClickX: -999,
+		lastClickY: -999,
+		lastClickButton: -1,
+		count: 0
+	};
+}
+/** @deprecated Use `createClickCountState()` instead. */
+const createDoubleClickState = createClickCountState;
+const MULTI_CLICK_TIME_MS = 300;
+const MULTI_CLICK_DISTANCE = 2;
+/**
+* Determine the consecutive-click count for the current click.
+*
+* Returns 1 for a fresh click, 2 for a double-click, 3 for a triple-click.
+* Subsequent clicks restart the chain at 1.
+*
+* Updates `state` so the next call sees the right history.
+*/
+function checkClickCount(state, x, y, button, now = Date.now()) {
+	const timeDelta = now - state.lastClickTime;
+	const dx = Math.abs(x - state.lastClickX);
+	const dy = Math.abs(y - state.lastClickY);
+	const inChain = button === state.lastClickButton && timeDelta <= MULTI_CLICK_TIME_MS && dx <= MULTI_CLICK_DISTANCE && dy <= MULTI_CLICK_DISTANCE;
+	let count;
+	if (!inChain || state.count >= 3) count = 1;
+	else if (state.count === 1) count = 2;
+	else count = 3;
+	state.lastClickTime = now;
+	state.lastClickX = x;
+	state.lastClickY = y;
+	state.lastClickButton = button;
+	state.count = count;
+	return count;
+}
+/**
+* Check if a click qualifies as a double-click. Backwards-compatible
+* wrapper around `checkClickCount`.
+*
+* @deprecated Use `checkClickCount` and inspect the returned count
+*   (`=== 2` for dblclick, `=== 3` for tripleclick).
+*/
+function checkDoubleClick(state, x, y, button, now = Date.now()) {
+	return checkClickCount(state, x, y, button, now) === 2;
+}
+/**
+* Compute mouseenter/mouseleave transitions between two ancestor paths.
+*
+* Returns { entered, left } — arrays of nodes that were entered or left.
+* Mirrors the DOM spec: fire mouseleave on nodes in prevPath not in nextPath,
+* and mouseenter on nodes in nextPath not in prevPath.
+*/
+function computeEnterLeave(prevPath, nextPath) {
+	const prevSet = new Set(prevPath);
+	const nextSet = new Set(nextPath);
+	return {
+		entered: nextPath.filter((n) => !prevSet.has(n)),
+		left: prevPath.filter((n) => !nextSet.has(n))
+	};
+}
+function createMouseEventProcessor(options) {
+	return {
+		doubleClick: createDoubleClickState(),
+		hoverPath: [],
+		mouseDownTarget: null,
+		mouseCaptureTarget: null,
+		outsideCaptureReleaseTimer: null,
+		outsideCaptureReleaseMouse: null,
+		focusManager: options?.focusManager,
+		keyboardModifiers: {
+			super: false,
+			hyper: false,
+			capsLock: false,
+			numLock: false
+		},
+		lastClickPrevented: false,
+		lastPointer: null
+	};
+}
+function findMouseCaptureTarget(node) {
+	let current = node;
+	while (current) {
+		if (current.props.mouseCapture === true) return current;
+		current = current.parent;
+	}
+	return null;
+}
+const MOUSE_CAPTURE_OUTSIDE_GRACE_MS = 2e3;
+function mouseUpParsed(parsed) {
+	return parsed.action === "up" ? parsed : {
+		...parsed,
+		action: "up"
+	};
+}
+/**
+* Update keyboard modifier state from a parsed key event.
+* Call this for every keyboard event so mouse events can include accurate modifiers.
+*/
+function updateKeyboardModifiers(state, key) {
+	const isRelease = key.eventType === "release";
+	const prevSuper = state.keyboardModifiers.super;
+	if (key.super !== void 0) state.keyboardModifiers.super = isRelease ? false : key.super;
+	if (key.hyper !== void 0) state.keyboardModifiers.hyper = isRelease ? false : key.hyper;
+	if (key.capsLock !== void 0) state.keyboardModifiers.capsLock = key.capsLock;
+	if (key.numLock !== void 0) state.keyboardModifiers.numLock = key.numLock;
+	if (state.keyboardModifiers.super !== prevSuper) mouseLog.debug?.(`keyboardModifiers.super: ${prevSuper} → ${state.keyboardModifiers.super} (key.super=${key.super}, eventType=${key.eventType})`);
+}
+function releaseMousePress(state, parsed) {
+	let defaultPrevented = false;
+	const dispatchTarget = state.mouseCaptureTarget;
+	const releaseParsed = mouseUpParsed(parsed);
+	cancelOutsideCaptureRelease(state);
+	if (state.mouseDownTarget) setArmed(state.mouseDownTarget, false);
+	if (dispatchTarget) {
+		const event = createMouseEvent("mouseup", releaseParsed.x, releaseParsed.y, dispatchTarget, releaseParsed, state.keyboardModifiers);
+		dispatchMouseEvent(event);
+		defaultPrevented = event.defaultPrevented;
+	}
+	state.lastClickPrevented = false;
+	state.mouseDownTarget = null;
+	state.mouseCaptureTarget = null;
+	return defaultPrevented;
+}
+function cancelOutsideCaptureRelease(state) {
+	if (state.outsideCaptureReleaseTimer !== null) clearTimeout(state.outsideCaptureReleaseTimer);
+	state.outsideCaptureReleaseTimer = null;
+	state.outsideCaptureReleaseMouse = null;
+}
+function scheduleOutsideCaptureRelease(state, parsed) {
+	state.outsideCaptureReleaseMouse = parsed;
+	if (state.outsideCaptureReleaseTimer !== null) return;
+	state.outsideCaptureReleaseTimer = setTimeout(() => {
+		const outsideMouse = state.outsideCaptureReleaseMouse ?? parsed;
+		releaseMousePress(state, outsideMouse);
+		clearHoverPath(state, outsideMouse);
+	}, MOUSE_CAPTURE_OUTSIDE_GRACE_MS);
+}
+function clearHoverPath(state, parsed) {
+	for (const node of state.hoverPath.slice().reverse()) {
+		setHovered(node, false);
+		dispatchMouseEvent(createMouseEvent("mouseleave", parsed.x, parsed.y, node, parsed, state.keyboardModifiers));
+	}
+	state.hoverPath = [];
+	state.lastPointer = null;
+}
+/**
+* Re-resolve the hover path at the last known pointer coordinates and
+* dispatch enter/leave for any nodes that changed. Use after a layout
+* change that didn't come from a mouse event — most importantly:
+*
+*   - Wheel scrolls (content shifts under a stationary cursor)
+*   - Async content arrival (transcript leaf appended, list re-flowed)
+*   - Programmatic re-layout (resize, theme switch)
+*
+* Without this, hover bg / hover-armed popovers stick to whatever AgNode
+* was under the cursor when the last mouse event fired, even after the
+* tree under that coordinate changed. Symptoms: persistent hover bg on
+* rows that have scrolled out from under the pointer; popover targets
+* arming on rows the cursor isn't over anymore.
+*
+* Idempotent — when nothing changed, no events fire and `state.hoverPath`
+* stays identity-equal. Safe to call every render commit.
+*
+* Bead: @km/code/sticky-hover-residue.
+*/
+function refreshHoverPath(state, root) {
+	if (state.lastPointer === null) return;
+	if (state.mouseCaptureTarget) return;
+	const { x, y } = state.lastPointer;
+	const target = hitTest(root, x, y);
+	const newPath = target ? getAncestorPath(target) : [];
+	const { entered, left } = computeEnterLeave(state.hoverPath, newPath);
+	if (entered.length === 0 && left.length === 0) return;
+	const synthetic = {
+		x,
+		y,
+		button: 0,
+		action: "move",
+		coordinateMode: "cell",
+		shift: false,
+		meta: false,
+		ctrl: false
+	};
+	for (const node of left) {
+		setHovered(node, false);
+		dispatchMouseEvent(createMouseEvent("mouseleave", x, y, node, synthetic, state.keyboardModifiers));
+	}
+	for (const node of entered.reverse()) {
+		setHovered(node, true);
+		dispatchMouseEvent(createMouseEvent("mouseenter", x, y, node, synthetic, state.keyboardModifiers));
+	}
+	state.hoverPath = newPath;
+}
+/**
+* Process a raw ParsedMouse event and dispatch DOM-level events on the render tree.
+*
+* Call this for every SGR mouse event received. It handles:
+* - mousedown / mouseup
+* - click (on mouseup if same target as mousedown)
+* - dblclick (based on timing)
+* - mousemove + mouseenter/mouseleave
+* - wheel
+*/
+function processMouseEvent(state, parsed, root) {
+	const { x, y, action } = parsed;
+	state.lastPointer = {
+		x,
+		y
+	};
+	const target = hitTest(root, x, y);
+	if (action === "move") {
+		const nodeType = target?.type ?? "null";
+		const nodeId = target ? target.props.id ?? "" : "";
+		let enterAncestor = "";
+		if (target) {
+			let n = target;
+			while (n) {
+				if ("onMouseEnter" in n.props) {
+					enterAncestor = `${n.type}#${n.props.id ?? ""}`;
+					break;
+				}
+				n = n.parent;
+			}
+		}
+		const newPath = target ? getAncestorPath(target) : [];
+		const { entered } = computeEnterLeave(state.hoverPath, newPath);
+		mouseLog.debug?.(`move x=${x} y=${y} target=${nodeType}#${nodeId} enterAncestor=${enterAncestor || "none"} entered=${entered.length} prevPath=${state.hoverPath.length}`);
+	}
+	let defaultPrevented = false;
+	if (target) cancelOutsideCaptureRelease(state);
+	if (!target) {
+		if (action === "move") {
+			if (state.mouseCaptureTarget) scheduleOutsideCaptureRelease(state, parsed);
+			else defaultPrevented = releaseMousePress(state, parsed);
+			clearHoverPath(state, parsed);
+			return defaultPrevented;
+		}
+		if (action === "up") defaultPrevented = releaseMousePress(state, parsed);
+		return defaultPrevented;
+	}
+	if (action === "down") {
+		state.mouseDownTarget = target;
+		state.mouseCaptureTarget = findMouseCaptureTarget(target);
+		setArmed(target, true);
+		if (state.focusManager) {
+			const focusable = findFocusableAncestor(target);
+			if (focusable) state.focusManager.focus(focusable, "mouse");
+		}
+		const event = createMouseEvent("mousedown", x, y, target, parsed, state.keyboardModifiers);
+		dispatchMouseEvent(event);
+		if (event.defaultPrevented) defaultPrevented = true;
+	} else if (action === "up") {
+		const dispatchTarget = state.mouseCaptureTarget ?? target;
+		if (state.mouseDownTarget) setArmed(state.mouseDownTarget, false);
+		state.lastClickPrevented = false;
+		dispatchMouseEvent(createMouseEvent("mouseup", x, y, dispatchTarget, parsed, state.keyboardModifiers));
+		if (state.mouseDownTarget) {
+			const count = checkClickCount(state.doubleClick, x, y, parsed.button);
+			const clickEvent = createMouseEvent("click", x, y, dispatchTarget, parsed, state.keyboardModifiers);
+			clickEvent.detail = count;
+			dispatchMouseEvent(clickEvent);
+			if (clickEvent.defaultPrevented) {
+				defaultPrevented = true;
+				state.lastClickPrevented = true;
+			}
+			if (count >= 2) {
+				const dblEvent = createMouseEvent("dblclick", x, y, dispatchTarget, parsed, state.keyboardModifiers);
+				dblEvent.detail = 2;
+				dispatchMouseEvent(dblEvent);
+				if (dblEvent.defaultPrevented) {
+					defaultPrevented = true;
+					state.lastClickPrevented = true;
+				}
+			}
+			if (count === 3) {
+				const tripleEvent = createMouseEvent("tripleclick", x, y, dispatchTarget, parsed, state.keyboardModifiers);
+				tripleEvent.detail = 3;
+				dispatchMouseEvent(tripleEvent);
+				if (tripleEvent.defaultPrevented) {
+					defaultPrevented = true;
+					state.lastClickPrevented = true;
+				}
+			}
+		}
+		state.mouseDownTarget = null;
+		state.mouseCaptureTarget = null;
+	} else if (action === "move") {
+		dispatchMouseEvent(createMouseEvent("mousemove", x, y, state.mouseCaptureTarget ?? target, parsed, state.keyboardModifiers));
+		const newPath = getAncestorPath(target);
+		const { entered, left } = computeEnterLeave(state.hoverPath, newPath);
+		for (const node of left) {
+			setHovered(node, false);
+			dispatchMouseEvent(createMouseEvent("mouseleave", x, y, node, parsed, state.keyboardModifiers));
+		}
+		for (const node of entered.reverse()) {
+			setHovered(node, true);
+			dispatchMouseEvent(createMouseEvent("mouseenter", x, y, node, parsed, state.keyboardModifiers));
+		}
+		state.hoverPath = newPath;
+	} else if (action === "wheel") {
+		const event = createWheelEvent(x, y, target, parsed, state.keyboardModifiers);
+		dispatchMouseEvent(event);
+		if (event.defaultPrevented) defaultPrevented = true;
+	}
+	return defaultPrevented;
+}
+//#endregion
+export { findSpatialTarget as C, findFocusableAncestor as S, getTabOrder as T, getAncestorPath as _, createDoubleClickState as a, findByTestID as b, createWheelEvent as c, hitTest as d, processMouseEvent as f, updateKeyboardModifiers as g, selectionHitTest as h, createClickCountState as i, dispatchMouseEvent as l, resolveSelectionAnchorFromPoint as m, checkDoubleClick as n, createMouseEvent as o, refreshHoverPath as p, computeEnterLeave as r, createMouseEventProcessor as s, checkClickCount as t, findSelectionBoundaries as u, setArmed as v, getExplicitFocusLink as w, findEnclosingScope as x, setFocused as y };
+
+//# sourceMappingURL=mouse-events-Dki3ISIp.mjs.map