pi-libtui 0.3.2

package/src/host/mouse-bridge.ts

@@ -0,0 +1,212 @@
+import { type TUI, TuiAltScreen } from "@earendil-works/pi-tui";
+import { getMouseRegistryState } from "../mouse/registry.ts";
+import type { MouseRegistry, ScreenDecorationContext } from "../mouse.ts";
+import { installMouseDispatch } from "./mouse-dispatch.ts";
+import { isRecord, rendererHasOverlay, rendererHasSelection, terminalSize } from "./pi-layout-adapter.ts";
+import { nativeSelectionGeometry, rendererFullscreenLayout } from "./pi-native-selection.ts";
+
+const ALL_MOTION_INSTALLATION_KEY = Symbol.for("pi-libtui/mouse/all-motion-installation/v1");
+const SCREEN_DECORATION_INSTALLATION_KEY = Symbol.for("pi-libtui/mouse/screen-decoration-installation/v1");
+const ENABLE_ALL_MOTION = "\x1b[?1003h";
+const DISABLE_ALL_MOTION = "\x1b[?1003l";
+
+// type-boundary: Pi 0.84.2's private renderer patch points are narrowed by the installation validators below.
+type PiPrivateValue = unknown;
+
+type ApplySelectionHandler = (this: object, screen: string[], layout?: PiPrivateValue) => PiPrivateValue;
+
+interface AllMotionInstallation {
+	protocol: "pi-libtui/mouse/all-motion-installation/v1";
+	refs: number;
+	patched: (this: object) => void;
+	dispose(): void;
+}
+
+interface ScreenDecorationInstallation {
+	protocol: "pi-libtui/mouse/screen-decoration-installation/v1";
+	refs: number;
+	patched: ApplySelectionHandler;
+	dispose(): void;
+}
+
+function isAllMotionInstallation(value: PiPrivateValue): value is AllMotionInstallation {
+	if (!isRecord(value)) return false;
+	return (
+		value.protocol === "pi-libtui/mouse/all-motion-installation/v1" &&
+		typeof value.refs === "number" &&
+		typeof value.patched === "function" &&
+		typeof value.dispose === "function"
+	);
+}
+
+function isScreenDecorationInstallation(value: PiPrivateValue): value is ScreenDecorationInstallation {
+	if (!isRecord(value)) return false;
+	return (
+		value.protocol === "pi-libtui/mouse/screen-decoration-installation/v1" &&
+		typeof value.refs === "number" &&
+		typeof value.patched === "function" &&
+		typeof value.dispose === "function"
+	);
+}
+
+export function isPiMultiplexedEnvironment(env: NodeJS.ProcessEnv): boolean {
+	const term = env.TERM?.toLowerCase() ?? "";
+	return (
+		env.TMUX !== undefined ||
+		env.ZELLIJ !== undefined ||
+		env.STY !== undefined ||
+		term.startsWith("tmux") ||
+		term.startsWith("screen")
+	);
+}
+
+function writeTerminal(renderer: object, data: string): void {
+	try {
+		const terminal = Reflect.get(renderer, "terminal") as PiPrivateValue;
+		if (!isRecord(terminal)) return;
+		const write = terminal.write;
+		if (typeof write === "function") Reflect.apply(write, terminal, [data]);
+	} catch {
+		// Mouse motion negotiation is best-effort.
+	}
+}
+
+export function installAllMotionTracking(
+	tui: TUI,
+	prototype: object,
+	env: NodeJS.ProcessEnv = process.env,
+): () => void {
+	if (!isPiMultiplexedEnvironment(env)) return () => {};
+	const existing = Reflect.get(prototype, ALL_MOTION_INSTALLATION_KEY) as PiPrivateValue;
+	if (isAllMotionInstallation(existing)) {
+		const wasInactive = existing.refs === 0;
+		existing.refs += 1;
+		if (wasInactive && tui.mode === "fullscreen" && Reflect.get(tui as object, "mouseEnabled") !== false) {
+			writeTerminal(tui as object, ENABLE_ALL_MOTION);
+		}
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			existing.refs -= 1;
+			if (existing.refs === 0) existing.dispose();
+		};
+	}
+	const originalValue = Reflect.get(prototype, "beforeTerminalStart") as PiPrivateValue;
+	if (typeof originalValue !== "function") return () => {};
+	const original = originalValue as (this: object) => void;
+	let installation: AllMotionInstallation;
+	const patched = function (this: object): void {
+		Reflect.apply(original, this, []);
+		if (installation.refs > 0 && Reflect.get(this, "mouseEnabled") !== false) writeTerminal(this, ENABLE_ALL_MOTION);
+	};
+	let restored = false;
+	installation = {
+		protocol: "pi-libtui/mouse/all-motion-installation/v1",
+		refs: 1,
+		patched,
+		dispose() {
+			if (restored) return;
+			if (Reflect.get(prototype, ALL_MOTION_INSTALLATION_KEY) !== installation) return;
+			writeTerminal(tui as object, DISABLE_ALL_MOTION);
+			if (Reflect.get(prototype, "beforeTerminalStart") !== patched) return;
+			restored = true;
+			Reflect.set(prototype, "beforeTerminalStart", original);
+			Reflect.set(prototype, ALL_MOTION_INSTALLATION_KEY, undefined);
+		},
+	};
+	Reflect.set(prototype, "beforeTerminalStart", patched);
+	Reflect.set(prototype, ALL_MOTION_INSTALLATION_KEY, installation);
+	if (tui.mode === "fullscreen" && Reflect.get(tui as object, "mouseEnabled") !== false) {
+		writeTerminal(tui as object, ENABLE_ALL_MOTION);
+	}
+
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		installation.refs -= 1;
+		if (installation.refs === 0) installation.dispose();
+	};
+}
+
+function isScreen(value: PiPrivateValue): value is string[] {
+	return Array.isArray(value) && value.every((line) => typeof line === "string");
+}
+
+export function installScreenDecoration(prototype: object, registry: MouseRegistry): () => void {
+	const existing = Reflect.get(prototype, SCREEN_DECORATION_INSTALLATION_KEY) as PiPrivateValue;
+	if (isScreenDecorationInstallation(existing)) {
+		existing.refs += 1;
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			existing.refs -= 1;
+			if (existing.refs === 0) existing.dispose();
+		};
+	}
+	const originalValue = Reflect.get(prototype, "applySelection") as PiPrivateValue;
+	if (typeof originalValue !== "function") return () => {};
+	const original = originalValue as ApplySelectionHandler;
+	let installation: ScreenDecorationInstallation;
+	const patched: ApplySelectionHandler = function (screen, layout) {
+		const native = Reflect.apply(original, this, [screen, layout]) as PiPrivateValue;
+		if (installation.refs === 0 || !isScreen(native) || getMouseRegistryState(registry).screenDecorators.length === 0)
+			return native;
+		const size = terminalSize(this);
+		if (!size) return native;
+		const fullscreenLayout = rendererFullscreenLayout(this);
+		const context: ScreenDecorationContext = {
+			width: size.columns,
+			height: size.rows,
+			hasOverlay: rendererHasOverlay(this),
+			selectionActive: rendererHasSelection(this),
+			selection: nativeSelectionGeometry(this),
+			...(fullscreenLayout ? { viewport: fullscreenLayout.viewport, transcriptLines: fullscreenLayout.lines } : {}),
+		};
+		return registry.dispatchScreenDecorators(native, context);
+	};
+	let restored = false;
+	installation = {
+		protocol: "pi-libtui/mouse/screen-decoration-installation/v1",
+		refs: 1,
+		patched,
+		dispose() {
+			if (restored) return;
+			if (Reflect.get(prototype, SCREEN_DECORATION_INSTALLATION_KEY) !== installation) return;
+			if (Reflect.get(prototype, "applySelection") !== patched) return;
+			restored = true;
+			Reflect.set(prototype, "applySelection", original);
+			Reflect.set(prototype, SCREEN_DECORATION_INSTALLATION_KEY, undefined);
+		},
+	};
+	Reflect.set(prototype, "applySelection", patched);
+	Reflect.set(prototype, SCREEN_DECORATION_INSTALLATION_KEY, installation);
+
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		installation.refs -= 1;
+		if (installation.refs === 0) installation.dispose();
+	};
+}
+
+/** Install the generic fullscreen pointer, layout, selection, and decoration compatibility leases. */
+export function installMouseBridge(tui: TUI, registry: MouseRegistry): () => void {
+	const prototype = tui.mode === "fullscreen" ? Reflect.getPrototypeOf(tui as object) : TuiAltScreen.prototype;
+	if (!prototype) return () => {};
+
+	const removeAllMotion = installAllMotionTracking(tui, prototype);
+	const removeScreenDecoration = installScreenDecoration(prototype, registry);
+	const removeMouseDispatch = installMouseDispatch(tui, prototype, registry);
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		removeMouseDispatch();
+		removeAllMotion();
+		removeScreenDecoration();
+	};
+}

package/src/host/mouse-dispatch.ts

@@ -0,0 +1,400 @@
+import { type Component, matchesKey, type TUI, type TuiInputListenerResult } from "@earendil-works/pi-tui";
+import { getMouseRegistryState } from "../mouse/registry.ts";
+import type { MouseRegistry, TextInteractionTarget, TuiMouseEventType } from "../mouse.ts";
+import { publishFullscreenLayoutCapability } from "../mouse.ts";
+import { ensureSelectionRegistry } from "../selection.ts";
+import { createEvent, isPrimarySelectionRelease, type ParsedMouseEvent, parseMouse } from "./mouse-input.ts";
+import { type MouseTarget, targetsAt as resolveTargetsAt } from "./mouse-targets.ts";
+import {
+	contains,
+	isRecord,
+	isVisibleComponent,
+	rendererHasOverlay,
+	rendererLayoutFrame,
+} from "./pi-layout-adapter.ts";
+import { fullscreenLayoutCapability, nativeSelectionCompleted } from "./pi-native-selection.ts";
+
+const INSTALLATION_KEY = Symbol.for("pi-libtui/mouse/bridge-installation/v1");
+const FOCUS_IN = "\x1b[I";
+const FOCUS_OUT = "\x1b[O";
+
+// type-boundary: Pi 0.84.2's private input and overlay members are narrowed by the validators below.
+type PiPrivateValue = unknown;
+
+type ViewportInputHandler = (this: object, data: string) => TuiInputListenerResult;
+
+interface BridgeInstallation {
+	protocol: "pi-libtui/mouse/bridge-installation/v1";
+	refs: number;
+	patched: ViewportInputHandler;
+	dispose(): void;
+}
+
+interface PointerState {
+	capture?: MouseTarget;
+	hover?: MouseTarget;
+	lastPointer?: ParsedMouseEvent;
+	textClick?: { target: MouseTarget; x: number; y: number; moved: boolean };
+	nativePrimaryPress?: boolean;
+	keyboardTarget?: Component & TextInteractionTarget;
+}
+
+function setKeyboardTarget(state: PointerState, target: (Component & TextInteractionTarget) | undefined): void {
+	if (state.keyboardTarget === target) return;
+	try {
+		state.keyboardTarget?.setViewportFocus(false);
+	} catch {
+		// Optional transcript interaction must not break the renderer input path.
+	}
+	state.keyboardTarget = target;
+	try {
+		target?.setViewportFocus(true);
+	} catch {
+		state.keyboardTarget = undefined;
+	}
+}
+
+function isInstallation(value: PiPrivateValue): value is BridgeInstallation {
+	if (!isRecord(value)) return false;
+	return (
+		value.protocol === "pi-libtui/mouse/bridge-installation/v1" &&
+		typeof value.refs === "number" &&
+		typeof value.patched === "function" &&
+		typeof value.dispose === "function"
+	);
+}
+
+function withNativeCopyDeferred(renderer: object, invoke: () => TuiInputListenerResult): TuiInputListenerResult {
+	const property = "copySelectionToClipboard";
+	const ownDescriptor = Reflect.getOwnPropertyDescriptor(renderer, property);
+	const suppress = (): Promise<void> => Promise.resolve();
+	if (!Reflect.set(renderer, property, suppress) || Reflect.get(renderer, property) !== suppress) return invoke();
+	try {
+		return invoke();
+	} finally {
+		if (Reflect.get(renderer, property) === suppress) {
+			if (ownDescriptor) Reflect.defineProperty(renderer, property, ownDescriptor);
+			else Reflect.deleteProperty(renderer, property);
+		}
+	}
+}
+
+function requestRender(renderer: object): void {
+	try {
+		const method = Reflect.get(renderer, "requestRender") as PiPrivateValue;
+		if (typeof method === "function") Reflect.apply(method, renderer, []);
+	} catch {
+		// A component callback must not break Pi's input path during renderer replacement.
+	}
+}
+
+function nativePointerOwnsInput(renderer: object): boolean {
+	return Reflect.get(renderer, "selectionPressActive") === true || Boolean(Reflect.get(renderer, "scrollbarDrag"));
+}
+
+function defersInputToOverlay(renderer: object): boolean {
+	const method = Reflect.get(renderer, "shouldDeferViewportInputToOverlay") as PiPrivateValue;
+	if (typeof method !== "function") return false;
+	try {
+		return Reflect.apply(method, renderer, []) === true;
+	} catch {
+		return false;
+	}
+}
+
+/** Patch Pi's fullscreen input path until the official API also covers overlays, capture, and hover. */
+export function installMouseDispatch(tui: TUI, prototype: object, registry: MouseRegistry): () => void {
+	const finish = (removeBridge: () => void): (() => void) => {
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			removeBridge();
+		};
+	};
+	const existing = Reflect.get(prototype, INSTALLATION_KEY) as PiPrivateValue;
+	if (isInstallation(existing)) {
+		existing.refs += 1;
+		let disposed = false;
+		return finish(() => {
+			if (disposed) return;
+			disposed = true;
+			existing.refs -= 1;
+			if (existing.refs === 0) existing.dispose();
+		});
+	}
+
+	const originalValue = Reflect.get(prototype, "handleViewportInput") as PiPrivateValue;
+	if (typeof originalValue !== "function") return finish(() => {});
+	const original = originalValue as ViewportInputHandler;
+	const removeFullscreenLayoutCapability = publishFullscreenLayoutCapability(fullscreenLayoutCapability);
+	const registryState = getMouseRegistryState(registry);
+	const rendererForViewport = tui as object;
+	const preserveViewport = (): void => {
+		const frame = rendererLayoutFrame(rendererForViewport);
+		const scrollView = frame?.primaryScrollView;
+		if (!scrollView) return;
+		try {
+			scrollView.scrollTo(scrollView.scrollTop, { disableFollow: true });
+		} catch {
+			// The native viewport is optional across Pi versions.
+		}
+	};
+	registryState.viewportPreserver = preserveViewport;
+	const states = new Map<object, PointerState>();
+	const targetsAt = (renderer: object, x: number, y: number, includeLayout: boolean): MouseTarget[] =>
+		resolveTargetsAt(registry, renderer, x, y, includeLayout, defersInputToOverlay);
+
+	const send = (target: MouseTarget, type: TuiMouseEventType, parsed: ParsedMouseEvent): boolean => {
+		const rect = target.getRect();
+		if (!rect) return false;
+		return target.dispatch(createEvent(type, parsed, rect));
+	};
+	const containsTarget = (target: MouseTarget, parsed: ParsedMouseEvent): boolean => {
+		if (target.isCurrent && !target.isCurrent()) return false;
+		if (target.containsPoint) return target.containsPoint(parsed.x, parsed.y);
+		const rect = target.getRect();
+		return Boolean(rect && contains(rect, parsed.x, parsed.y));
+	};
+	const finishTextClick = (
+		renderer: object,
+		state: PointerState,
+		parsed: ParsedMouseEvent,
+		dispatchRelease: boolean,
+	): void => {
+		const textClick = state.textClick;
+		if (!textClick) return;
+		const isClick = !textClick.moved && parsed.x === textClick.x && parsed.y === textClick.y;
+		// Resolve the release against the current frame. A press can invalidate and
+		// rerender a disclosure before its release arrives; dispatching through the
+		// captured box would let that stale geometry collapse a different surface.
+		const currentTarget = targetsAt(renderer, parsed.x, parsed.y, true).find(
+			(target) => target.key === textClick.target.key && containsTarget(target, parsed),
+		);
+		const handled = dispatchRelease
+			? Boolean(currentTarget && send(currentTarget, "release", parsed))
+			: Boolean(isClick && currentTarget);
+		if (isClick && handled && currentTarget?.textInteraction) {
+			setKeyboardTarget(state, currentTarget.textInteraction);
+		}
+		state.textClick = undefined;
+	};
+	const cancelTextClick = (state: PointerState, parsed: ParsedMouseEvent | undefined): void => {
+		if (!state.textClick) return;
+		if (parsed) send(state.textClick.target, "release", { ...parsed, rawButton: 3 });
+		state.textClick = undefined;
+	};
+
+	const patched: ViewportInputHandler = function (data) {
+		let state = states.get(this);
+		if (!state) {
+			state = {};
+			states.set(this, state);
+		}
+		const mouseInput = parseMouse(data);
+		if (mouseInput.kind !== "event") {
+			if (data === FOCUS_OUT) {
+				const lastPointer = state.lastPointer;
+				const hadPointerState = Boolean(state.capture || state.hover || state.textClick);
+				if (lastPointer) {
+					if (state.capture) send(state.capture, "release", { ...lastPointer, rawButton: 3 });
+					if (state.hover) send(state.hover, "leave", lastPointer);
+				}
+				cancelTextClick(state, lastPointer);
+				state.capture = undefined;
+				state.hover = undefined;
+				state.lastPointer = undefined;
+				state.nativePrimaryPress = undefined;
+				setKeyboardTarget(state, undefined);
+				if (hadPointerState) requestRender(this);
+			}
+			if (data === FOCUS_IN || data === FOCUS_OUT || mouseInput.kind === "unsupported") {
+				return Reflect.apply(original, this, [data]);
+			}
+			const viewportInput = registry.dispatchViewportInput(data);
+			if (viewportInput.consumed) return { consume: true, data: viewportInput.data };
+			if (rendererHasOverlay(this) || defersInputToOverlay(this)) {
+				setKeyboardTarget(state, undefined);
+				return Reflect.apply(original, this, [viewportInput.data]);
+			}
+			if (matchesKey(viewportInput.data, "escape")) {
+				setKeyboardTarget(state, undefined);
+				requestRender(this);
+				return Reflect.apply(original, this, [viewportInput.data]);
+			}
+			const keyboardTarget = state.keyboardTarget;
+			if (keyboardTarget) {
+				const frame = rendererLayoutFrame(this);
+				if (!frame || !isVisibleComponent(frame, keyboardTarget)) {
+					setKeyboardTarget(state, undefined);
+				} else {
+					try {
+						if (keyboardTarget.handleViewportInput(viewportInput.data)) {
+							requestRender(this);
+							return { consume: true, data: viewportInput.data };
+						}
+						// Once input returns to the editor, Enter must submit there rather than toggle the old target.
+						setKeyboardTarget(state, undefined);
+					} catch {
+						setKeyboardTarget(state, undefined);
+					}
+				}
+			}
+			return Reflect.apply(original, this, [viewportInput.data]);
+		}
+		const parsed = mouseInput.event;
+		state.lastPointer = parsed;
+		if (parsed.type === "press" && defersInputToOverlay(this)) setKeyboardTarget(state, undefined);
+		if (!state.capture && nativePointerOwnsInput(this)) {
+			const textClick = state.textClick;
+			if (textClick && parsed.type === "drag") {
+				textClick.moved ||= parsed.x !== textClick.x || parsed.y !== textClick.y;
+				if (textClick.moved) send(textClick.target, "drag", parsed);
+			}
+			const selectionWasActive = parsed.type === "release" && Reflect.get(this, "selectionPressActive") === true;
+			const deferCopy = selectionWasActive && isPrimarySelectionRelease(parsed) && registry.shouldDeferNativeCopy();
+			const invokeOriginal = (): TuiInputListenerResult => Reflect.apply(original, this, [data]);
+			const result = deferCopy ? withNativeCopyDeferred(this, invokeOriginal) : invokeOriginal();
+			const selectionEnded = selectionWasActive && Reflect.get(this, "selectionPressActive") === false;
+			if (selectionEnded) {
+				const selection = nativeSelectionCompleted(this);
+				if (selection) ensureSelectionRegistry().publishSelectionCompleted(selection);
+			}
+			if (textClick && parsed.type === "release") {
+				finishTextClick(this, state, parsed, true);
+				requestRender(this);
+			}
+			if (parsed.type === "release") state.nativePrimaryPress = undefined;
+			return result;
+		}
+
+		if (state.textClick && parsed.type === "drag") {
+			state.textClick.moved ||= parsed.x !== state.textClick.x || parsed.y !== state.textClick.y;
+			if (state.textClick.moved) send(state.textClick.target, "drag", parsed);
+			return Reflect.apply(original, this, [data]);
+		}
+		if (state.textClick && parsed.type === "release") {
+			const result = Reflect.apply(original, this, [data]);
+			finishTextClick(this, state, parsed, true);
+			state.nativePrimaryPress = undefined;
+			requestRender(this);
+			return result;
+		}
+
+		// A component only owns a release after it handled the matching press. Keep
+		// native selection gestures out of the general release dispatch path when a
+		// stale layout makes an expanded fold report a release hit.
+		if (state.nativePrimaryPress && (parsed.type === "drag" || parsed.type === "release")) {
+			if (parsed.type === "release") state.nativePrimaryPress = undefined;
+			return Reflect.apply(original, this, [data]);
+		}
+
+		if ((parsed.type === "drag" || parsed.type === "release") && state.capture) {
+			const captured = state.capture;
+			send(captured, parsed.type, parsed);
+			if (parsed.type === "release") state.capture = undefined;
+			requestRender(this);
+			return { consume: true };
+		}
+
+		if (parsed.type === "move") {
+			const previousHover = state.hover;
+			if (previousHover && previousHover.frame === rendererLayoutFrame(this)) {
+				if (containsTarget(previousHover, parsed) && send(previousHover, "move", parsed)) {
+					return { consume: true };
+				}
+			}
+			let next: MouseTarget | undefined;
+			let handled = false;
+			for (const target of targetsAt(this, parsed.x, parsed.y, true)) {
+				const type = state.hover?.key === target.key ? "move" : "enter";
+				if (!send(target, type, parsed)) continue;
+				next = target;
+				handled = true;
+				break;
+			}
+			if (previousHover && previousHover.key !== next?.key) send(previousHover, "leave", parsed);
+			state.hover = next;
+			// Components request their own redraw when a move changes local state. The
+			// bridge only redraws for target transitions, keeping raw motion storms O(1)
+			// when the pointer remains over the same affordance.
+			if (previousHover?.key !== next?.key) requestRender(this);
+			return handled ? { consume: true } : Reflect.apply(original, this, [data]);
+		}
+
+		let prepassedOverlayKeys: ReadonlySet<object> | undefined;
+		if (parsed.type === "press" && (parsed.rawButton & 3) === 0 && !defersInputToOverlay(this)) {
+			let textTarget: MouseTarget | undefined;
+			const dispatchedOverlayKeys = new Set<object>();
+			prepassedOverlayKeys = dispatchedOverlayKeys;
+			for (const target of targetsAt(this, parsed.x, parsed.y, true)) {
+				if (target.overlayRegion) {
+					dispatchedOverlayKeys.add(target.key);
+					if (!send(target, "press", parsed)) continue;
+					state.capture = target;
+					setKeyboardTarget(state, undefined);
+					requestRender(this);
+					return { consume: true };
+				}
+				if (!target.textInteraction || !send(target, "press", parsed)) continue;
+				textTarget = target;
+				break;
+			}
+			if (textTarget) {
+				state.textClick = { target: textTarget, x: parsed.x, y: parsed.y, moved: false };
+				requestRender(this);
+				return Reflect.apply(original, this, [data]);
+			}
+			setKeyboardTarget(state, undefined);
+		}
+
+		for (const target of targetsAt(this, parsed.x, parsed.y, true)) {
+			if (prepassedOverlayKeys?.has(target.key)) continue;
+			if (!send(target, parsed.type, parsed)) continue;
+			if (parsed.type === "press") state.capture = target;
+			requestRender(this);
+			return { consume: true };
+		}
+		if (parsed.type === "press" && (parsed.rawButton & 3) === 0) state.nativePrimaryPress = true;
+		return Reflect.apply(original, this, [data]);
+	};
+
+	let restored = false;
+	const installation: BridgeInstallation = {
+		protocol: "pi-libtui/mouse/bridge-installation/v1",
+		refs: 1,
+		patched,
+		dispose() {
+			if (restored) return;
+			const current = Reflect.get(prototype, INSTALLATION_KEY) as PiPrivateValue;
+			if (current !== installation) return;
+			if (Reflect.get(prototype, "handleViewportInput") !== patched) return;
+			restored = true;
+			if (registryState.viewportPreserver === preserveViewport) registryState.viewportPreserver = undefined;
+			for (const [renderer, state] of states) {
+				if (state.lastPointer) {
+					if (state.capture) send(state.capture, "release", { ...state.lastPointer, rawButton: 3 });
+					if (state.hover) send(state.hover, "leave", state.lastPointer);
+				}
+				cancelTextClick(state, state.lastPointer);
+				state.nativePrimaryPress = undefined;
+				setKeyboardTarget(state, undefined);
+				requestRender(renderer);
+			}
+			states.clear();
+			removeFullscreenLayoutCapability();
+			Reflect.set(prototype, "handleViewportInput", original);
+			Reflect.set(prototype, INSTALLATION_KEY, undefined);
+		},
+	};
+	Reflect.set(prototype, "handleViewportInput", patched);
+	Reflect.set(prototype, INSTALLATION_KEY, installation);
+
+	let disposed = false;
+	return finish(() => {
+		if (disposed) return;
+		disposed = true;
+		installation.refs -= 1;
+		if (installation.refs === 0) installation.dispose();
+	});
+}

package/src/host/mouse-input.ts

@@ -0,0 +1,85 @@
+import type { MouseRect, TuiMouseEvent, TuiMouseEventType } from "../mouse.ts";
+
+export interface ParsedMouseEvent {
+	type: "press" | "release" | "drag" | "wheel" | "move";
+	x: number;
+	y: number;
+	rawButton: number;
+	wheel: -1 | 1 | undefined;
+}
+
+export type ParsedMouseInput =
+	| { kind: "event"; event: ParsedMouseEvent }
+	| { kind: "unsupported" }
+	| { kind: "not-mouse" };
+
+function modifiers(rawButton: number): Pick<TuiMouseEvent, "shift" | "alt" | "ctrl"> {
+	return {
+		shift: (rawButton & 4) !== 0,
+		alt: (rawButton & 8) !== 0,
+		ctrl: (rawButton & 16) !== 0,
+	};
+}
+
+export function createEvent(type: TuiMouseEventType, parsed: ParsedMouseEvent, rect: MouseRect): TuiMouseEvent {
+	const buttonBits = parsed.rawButton & 3;
+	return {
+		type,
+		row: parsed.y - rect.y,
+		col: parsed.x - rect.x,
+		screenRow: parsed.y,
+		screenCol: parsed.x,
+		button: parsed.wheel === undefined && buttonBits !== 3 ? (buttonBits as 0 | 1 | 2) : undefined,
+		wheel: parsed.wheel,
+		...modifiers(parsed.rawButton),
+	};
+}
+
+export function parseMouse(data: string): ParsedMouseInput {
+	const sgr = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(data);
+	if (sgr) {
+		const rawButton = Number.parseInt(sgr[1]!, 10);
+		const x = Number.parseInt(sgr[2]!, 10) - 1;
+		const y = Number.parseInt(sgr[3]!, 10) - 1;
+		if ((rawButton & 64) !== 0) {
+			const direction = rawButton & 3;
+			if (direction !== 0 && direction !== 1) return { kind: "unsupported" };
+			return { kind: "event", event: { type: "wheel", x, y, rawButton, wheel: direction === 0 ? -1 : 1 } };
+		}
+		const motion = (rawButton & 32) !== 0;
+		const noButton = (rawButton & 3) === 3;
+		return {
+			kind: "event",
+			event: {
+				type: sgr[4] === "m" ? "release" : motion ? (noButton ? "move" : "drag") : "press",
+				x,
+				y,
+				rawButton,
+				wheel: undefined,
+			},
+		};
+	}
+
+	if (data.length === 6 && data.startsWith("\x1b[M")) {
+		const rawButton = data.charCodeAt(3) - 32;
+		if ((rawButton & 64) === 0) return { kind: "unsupported" };
+		const direction = rawButton & 3;
+		if (direction !== 0 && direction !== 1) return { kind: "unsupported" };
+		return {
+			kind: "event",
+			event: {
+				type: "wheel",
+				x: data.charCodeAt(4) - 33,
+				y: data.charCodeAt(5) - 33,
+				rawButton,
+				wheel: direction === 0 ? -1 : 1,
+			},
+		};
+	}
+	return { kind: "not-mouse" };
+}
+
+export function isPrimarySelectionRelease(event: ParsedMouseEvent): boolean {
+	const button = event.rawButton & 3;
+	return event.type === "release" && (button === 0 || button === 3);
+}