@xzzpig/pi-starline 0.5.1 → 0.7.1

package/extensions/starline/mouse/index.ts

@@ -88,11 +88,13 @@ import {
 import { activeEditor, pointerOverEditor } from "./editor-mouse";
 import { scrollEditorBy } from "./editor-scroll";
 import { editorVisualRowCount } from "./editor-text-cursor";
+import { nativeCopyHandler } from "./fork-native-clipboard";
+import { cleanForkTranscriptRows } from "./fork-transcript-copy";
+import { type SharedWheelHandler, sharedWheelRegistrar } from "./fork-wheel-compat";
 import { type BoxLike, scrollContentLinesFor } from "./hit-test";
 import { keyTextFor } from "./key-text";
 import { externalEditorName, selectionHintText } from "./selection-state";
 import { type ExpandTarget, expandKeyText, expandTargetAt } from "./tool-box";
-import { cleanTranscriptRows } from "./transcript-copy";
 
 /** Pi's interrupt chord — refused by the range-delete branch, never consumed. */
 const CTRL_C = "\x03";
@@ -275,7 +277,7 @@ export function activeSelectionHintText(): string | null {
 		);
 	} catch {
 		// The renderer is best effort; a receiver that has moved on offers no
-		// hint rather than breaking the metadata row.
+		// hint rather than breaking the editor's top rule.
 		return null;
 	}
 }
@@ -442,11 +444,12 @@ function transcriptSelectionText(
 	if (receiver.hasOverlay?.()) return undefined;
 	const sourceLines = scrollContentLinesFor(receiver.currentLayout?.root, scrollView);
 	if (!sourceLines) return undefined;
-	const cleaned = cleanTranscriptRows(
+	const cleaned = cleanForkTranscriptRows(
 		sourceLines,
 		bounds.start.row,
 		bounds.end.row,
 		config.icons.rail,
+		config.features?.editor ?? true,
 	);
 	if (!cleaned.changed) return undefined;
 	const adjusted: SelectionBounds = {
@@ -729,8 +732,8 @@ function moveCaretForPress(
  * which is what `scrollEditorBy` does.
  *
  * The window it scrolls within is Pi's own `max(5, rows * 0.3)`, taken from the
- * terminal rather than from the box's rect: the rect includes Starline's border
- * and metadata rows, and guessing how many of those there are would put the
+ * terminal rather than from the box's rect: the rect includes Starline's border,
+ * padding and filler rows, and guessing how many of those there are would put the
  * boundary in the wrong place. Without a row count there is nothing to compute
  * it from, so the notch falls through.
  */
@@ -738,6 +741,7 @@ function scrollEditorForWheel(
 	receiver: MouseCapableReceiver,
 	event: { direction: number; x: number; y: number },
 	deps: InstallMouseDeps,
+	wheelDelta?: number,
 ): boolean {
 	try {
 		if (!deps.getConfig().mouse.wheelRouting) return false;
@@ -749,7 +753,10 @@ function scrollEditorForWheel(
 		const rows = receiver.terminal?.rows;
 		if (typeof rows !== "number") return false;
 		if (!pointerOverEditorBox(receiver, editor.component, event.x, event.y)) return false;
-		const lines = event.direction * Math.max(1, receiver.wheelScrollLines ?? 1);
+		const lines =
+			typeof wheelDelta === "number" && Number.isFinite(wheelDelta) && wheelDelta !== 0
+				? wheelDelta
+				: event.direction * Math.max(1, receiver.wheelScrollLines ?? 1);
 		return scrollEditorBy(editor.scrollable, lines, rows);
 	} catch {
 		// Routing is a best-effort read of Pi's internals and of an editor this
@@ -855,24 +862,22 @@ export function installMouseFeaturesOn(
 		),
 	);
 
+	const registerWheel = sharedWheelRegistrar(api);
+	const wheelHandler: SharedWheelHandler = ({ event, tui, wheelDelta }) => {
+		if (event.wheel === undefined) return undefined;
+		const receiver = bindReceiver(tui);
+		if (!receiver || !featureOn("editorWheelScroll")) return undefined;
+		const notch = { direction: event.wheel, x: event.x, y: event.y };
+		if (!scrollEditorForWheel(receiver, notch, deps, wheelDelta)) return undefined;
+		// The shared wheel slot repaints handled events; the older pre-dispatch
+		// slot needs the consumer to request the repaint itself.
+		if (!registerWheel) receiver.requestRender?.();
+		return { handled: true };
+	};
 	cleanups.push(
-		api.addMouseHandler(
-			({ event, tui }) => {
-				if (event.wheel === undefined) return undefined;
-				const receiver = bindReceiver(tui);
-				if (!receiver || !featureOn("editorWheelScroll")) return undefined;
-				const notch = { direction: event.wheel, x: event.x, y: event.y };
-				if (!scrollEditorForWheel(receiver, notch, deps)) {
-					return undefined;
-				}
-				// Pi's own wheel routing repaints at the end of every notch;
-				// consuming the event means reaching that repaint is now this
-				// handler's job.
-				receiver.requestRender?.();
-				return { handled: true };
-			},
-			{ priority: 10 },
-		),
+		registerWheel
+			? registerWheel(wheelHandler, { priority: 10 })
+			: api.addMouseHandler(wheelHandler, { priority: 10 }),
 	);
 
 	cleanups.push(
@@ -887,7 +892,32 @@ export function installMouseFeaturesOn(
 		),
 	);
 
-	if (api.copySlotAvailable) {
+	if (api.copySlotAvailable && api.addAsyncCopyHandler) {
+		cleanups.push(
+			api.addAsyncCopyHandler(
+				nativeCopyHandler(({ tui }) => {
+					const receiver = bindReceiver(tui);
+					const bounds = receiver?.getSelectionBounds?.();
+					if (!receiver || !bounds) return undefined;
+					const config = deps.getConfig();
+					return {
+						receiver,
+						showNotice: config.mouse.copyNotice,
+						texts: [
+							() =>
+								featureOn("editorBufferCopy")
+									? editorTextForSelection(receiver, config, bounds)
+									: undefined,
+							() =>
+								featureOn("transcriptCleanCopy") && config.mouse.transcriptCleanCopy
+									? transcriptSelectionText(receiver, config, bounds)
+									: undefined,
+						],
+					};
+				}),
+			),
+		);
+	} else if (api.copySlotAvailable) {
 		cleanups.push(
 			api.addCopyHandler(({ tui }) => {
 				const receiver = bindReceiver(tui);

package/extensions/starline/mouse/pointer-events.ts

@@ -0,0 +1,73 @@
+/**
+ * A second reader for pointer events, so more than one part of Starline can see
+ * where a click landed without taking a second patch on the same method.
+ *
+ * The renderer's `handleMouseEvent` is the one method every pointer report goes
+ * through before Pi dispatches it to a component or an overlay, and the patch
+ * registry holds exactly one behaviour per adapter key (`mouse-pointer-shape`,
+ * installed by `pointer-shape.ts`). Rather than register a second adapter on the
+ * same method — which would silently replace the first — the patch publishes
+ * every event here and whoever needs one subscribes.
+ *
+ * Observers run before the event is dispatched, so one can close a popover
+ * before the click it belongs to reaches the thing underneath, and they never
+ * consume anything: whatever the renderer does with the event afterwards is
+ * unchanged.
+ */
+
+export type PointerEventRaw = {
+	/** SGR button code: `button & 3` is the button, bit 32 motion, bit 64 wheel. */
+	button: number;
+	/** Column, 0-based, in screen cells. */
+	x: number;
+	/** Row, 0-based, from the top of the viewport. */
+	y: number;
+	/** The `m`/`M` terminator: true ends a gesture. */
+	release?: boolean;
+};
+
+/** The renderer instance the event is being dispatched on. */
+export type PointerReceiver = {
+	terminal?: { rows?: number };
+};
+
+export type PointerObserver = (
+	event: PointerEventRaw,
+	receiver: PointerReceiver | undefined,
+) => void;
+
+const observers = new Set<PointerObserver>();
+
+/** Watch every pointer report. Returns the disposer. */
+export function observePointerEvents(observer: PointerObserver): () => void {
+	observers.add(observer);
+	return () => {
+		observers.delete(observer);
+	};
+}
+
+/**
+ * Publish one event to the observers. Called by the `handleMouseEvent` patch
+ * before it dispatches; one observer throwing must not swallow the event for
+ * the others or for Pi.
+ */
+export function publishPointerEvent(
+	event: PointerEventRaw,
+	receiver: PointerReceiver | undefined,
+): void {
+	for (const observer of [...observers]) {
+		try {
+			observer(event, receiver);
+		} catch {
+			// Observers only observe; a broken one is not the event's problem.
+		}
+	}
+}
+
+/** True for a left-or-any-button press: not a release, not a drag, not a notch. */
+export function isPointerPress(event: PointerEventRaw): boolean {
+	if (event.release === true) return false;
+	if (!Number.isFinite(event.button)) return false;
+	// Bit 32 is motion (a drag when a button is held), bit 64 a wheel notch.
+	return (event.button & 32) === 0 && (event.button & 64) === 0;
+}

package/extensions/starline/mouse/pointer-shape.ts

@@ -0,0 +1,138 @@
+/**
+ * Changes the mouse pointer while it is over something clickable.
+ *
+ * The terminal draws the pointer, and OSC 22 (`ESC ] 22 ; <shape> ST`, shape names
+ * from CSS `cursor`) asks it for a different one; Ghostty and kitty support it, and
+ * other terminals ignore it. Pi already forwards every pointer movement to the
+ * component under it as a `move` event (any-motion tracking, off under tmux and
+ * friends), so the footer knows when the pointer is on a pill.
+ *
+ * What it cannot know is when the pointer *leaves*: the next `move` goes to
+ * whatever is under it now, and Pi has no leave event. So the shape is owned here,
+ * around the renderer's own dispatch, not by any component. During each `move` a
+ * component may call `requestPointerShape`; after the dispatch, a move that nobody
+ * claimed puts the pointer back to `default`. Only a change is written, so moving
+ * across a pill costs one escape sequence, not one per cell.
+ *
+ * This is a stand-in for an upstream API: a `pointer` field on the result a
+ * component's `handleMouse` returns, with the renderer writing OSC 22 itself.
+ * When Pi ships that, the callers return `{ pointer: "pointer" }` instead and this
+ * file goes away.
+ *
+ * The same patch is the process's only view of every pointer report, so it also
+ * publishes each one to `pointer-events` before dispatching. The pill bubble's
+ * outside-click dismissal is the second reader; see that module for why it does
+ * not get a patch of its own.
+ */
+
+import { installPrototypePatch } from "../prototype-patch-registry";
+import { requestSharedPointer } from "./fork-pointer-coordination";
+import { type PointerEventRaw, type PointerReceiver, publishPointerEvent } from "./pointer-events";
+
+/** CSS cursor names; `default` is the terminal's own arrow. */
+export type PointerShape = "default" | "pointer" | "text";
+
+type MouseEventRaw = { button?: unknown; release?: unknown };
+type TerminalHost = { terminal?: { write?: (data: string) => void } };
+type PointerShapeHost = { handleMouseEvent?: unknown };
+
+/** SGR bit for "this report is motion", and the button code for "no button held". */
+const MOTION_BIT = 32;
+const NO_BUTTON = 3;
+
+let dispatching = false;
+let requested: PointerShape | undefined;
+let current: PointerShape = "default";
+let lastHost: TerminalHost | undefined;
+
+/**
+ * Ask for `shape` while the pointer stays where it is. Only meaningful while a
+ * `move` is being dispatched; outside one it is ignored, so a click handler that
+ * calls it by accident cannot leave the pointer stuck.
+ */
+export function requestPointerShape(shape: PointerShape): void {
+	if (requestSharedPointer(shape)) return;
+	if (dispatching) requested = shape;
+}
+
+/** A pointer movement with no button held: what Pi turns into a `move` event. */
+function isHover(raw: MouseEventRaw | undefined): boolean {
+	if (!raw || raw.release === true || typeof raw.button !== "number") return false;
+	return (raw.button & MOTION_BIT) !== 0 && (raw.button & 0b11) === NO_BUTTON;
+}
+
+function writeShape(host: TerminalHost | undefined, shape: PointerShape): void {
+	try {
+		host?.terminal?.write?.(`\x1b]22;${shape}\x1b\\`);
+	} catch {
+		// A terminal that cannot be written to keeps its pointer; nothing to undo.
+	}
+}
+
+/** Put the pointer back if this module changed it. */
+function resetPointer(): void {
+	if (current !== "default") writeShape(lastHost, "default");
+	current = "default";
+	requested = undefined;
+	lastHost = undefined;
+}
+
+/**
+ * Wrap `TuiAltScreen.handleMouseEvent`, the one method every pointer report passes
+ * through before Pi dispatches it. Returns undefined on a build without it — that
+ * is a Pi without component mouse events, so there is nothing clickable to point
+ * at either.
+ *
+ * Every report is published to `pointer-events` first, before the shape logic and
+ * before Pi dispatches: the pill bubble's outside-click dismissal is a second
+ * reader of the same method, and one patch per method is the registry's rule.
+ * Nothing about the pointer shape depends on that.
+ */
+export function installPointerShape(prototype: PointerShapeHost): (() => void) | undefined {
+	const target = prototype as Record<string, unknown>;
+	if (typeof target.handleMouseEvent !== "function") return undefined;
+
+	const onExit = () => resetPointer();
+	let uninstall: () => void;
+	try {
+		uninstall = installPrototypePatch(
+			prototype,
+			"handleMouseEvent",
+			"mouse-pointer-shape",
+			({ predecessor, receiver, args }) => {
+				const raw = args[0] as PointerEventRaw | undefined;
+				if (raw && Number.isFinite(raw.x) && Number.isFinite(raw.y)) {
+					publishPointerEvent(raw, receiver as PointerReceiver);
+				}
+				if (!isHover(args[0] as MouseEventRaw | undefined)) {
+					return Function.prototype.apply.call(predecessor, receiver, args);
+				}
+				dispatching = true;
+				requested = undefined;
+				try {
+					return Function.prototype.apply.call(predecessor, receiver, args);
+				} finally {
+					dispatching = false;
+					const next = requested ?? "default";
+					requested = undefined;
+					lastHost = receiver as TerminalHost;
+					if (next !== current) {
+						current = next;
+						writeShape(lastHost, next);
+					}
+				}
+			},
+		);
+	} catch {
+		return undefined;
+	}
+
+	// Pi restores the terminal on exit but has never heard of this shape; without
+	// the reset a hand left over a pill outlives the process.
+	process.once("exit", onExit);
+	return () => {
+		process.removeListener("exit", onExit);
+		resetPointer();
+		uninstall();
+	};
+}

package/extensions/starline/mouse/transcript-copy.ts

@@ -5,19 +5,20 @@
  * Pi's `copyActiveSelectionToClipboard` copies *rendered* rows. In the transcript
  * those rows carry chrome that two components paint around their content:
  *
- * - Starline's own user messages (`user-message.ts`): a full-width `─` rule
- *   above and below, and every content row prefixed with the configured rail
- *   glyph plus a space (`│ hello`).
- * - `pi-toolbox`'s tool box frames (`frame.ts`): rounded corners
- *   (`╭──╮` / `╰──╯`) and every content row wrapped in verticals
- *   (`│ hello │`).
+ * - pi-tidy's "rail" user messages (`user-message.ts` there; Starline drew
+ *   them itself before 0.9): a full-width `─` rule above and below, every
+ *   content row prefixed with `│ ` (`│ hello`), and padding rows that are the
+ *   bare `│`. With tidy's icons on, the first text row also carries the user
+ *   icon (`│  hello`) and the rows after it hang two cells further in; both
+ *   come off too.
+ * - pi-tidy's tool box frames (`frame.ts`; `pi-toolbox` before the rename):
+ *   rounded corners (`╭──╮` / `╰──╯`, the top one possibly labelled, as a
+ *   "frame" user message's `╭─  ─╮` is) and every content row wrapped in
+ *   verticals (`│ hello │`).
  * - pi-coding-agent's `DynamicBorder` (bash boxes) paints the same full-width
  *   `─` rule — but bash content rows start with a space, not the rail
- *   (`bash-execution.js` renders them with paddingX=1), so under the default
- *   rail the pair below never forms and a bash box copies verbatim. Only in
- *   `copyFriendly` mode (empty rail prefix), where the rule pair alone
- *   decides, do its borders come off. Its content is never touched either
- *   way.
+ *   (`bash-execution.js` renders them with paddingX=1), so the pair below never
+ *   forms and a bash box copies verbatim.
  *
  * The clipboard should hold the content, not the chrome. The frame-free
  * selection task that was cut from 0.3.0 tried to do this by *inferring* where
@@ -25,7 +26,7 @@
  * produced a new edge case — a frame is not a structural concept in Pi. This
  * module therefore recognises only the exact markers above: a rounded-corner
  * pair of equal width, and a full-width rule pair whose every inner row
- * carries the configured rail prefix. Anything else — a markdown table with
+ * carries the rail. Anything else — a markdown table with
  * its square `┌┬┐` corners, a blockquote's `│ ` gutter, a horizontal rule the
  * assistant actually wrote — is content and passes through byte-identical.
  *
@@ -53,10 +54,28 @@ export type CleanedRows = {
 	changed: boolean;
 };
 
-/** A full-width rule: Starline's user message border, `DynamicBorder`. */
+/**
+ * pi-tidy's user message rail. Fixed there (its `USER_RAIL_GLYPH`) so this
+ * side can recognise it without reading tidy's settings.
+ */
+const USER_RAIL_GLYPH = "│";
+const USER_RAIL_PREFIX = `${USER_RAIL_GLYPH} `;
+/** pi-tidy's user icon (its `MESSAGE_ICONS.user`), and the indent that hangs under it. */
+const USER_ICON_PREFIX = `${USER_RAIL_PREFIX}\u{f007} `;
+const USER_HANG_PREFIX = `${USER_RAIL_PREFIX}  `;
+
+/** A content row or a bare padding row of a rail message. */
+function isRailRow(text: string): boolean {
+	return text.startsWith(USER_RAIL_PREFIX) || text.trimEnd() === USER_RAIL_GLYPH;
+}
+
+/** A full-width rule: a rail message's border, `DynamicBorder`. */
 const RULE_ROW_RE = /^─+$/;
-/** pi-toolbox's rounded frame edges. Square corners are content (tables). */
-const FRAME_OPEN_RE = /^╭─*╮$/;
+/**
+ * pi-tidy's rounded frame edges; the top one may carry a label (`╭─  ─╮`,
+ * a "frame" user message). Square corners are content (tables).
+ */
+const FRAME_OPEN_RE = /^╭(?:─ [^─]+ )?─*╮$/;
 const FRAME_CLOSE_RE = /^╰─*╯$/;
 
 function strippedRow(lines: readonly string[], cache: string[], row: number): string {
@@ -68,6 +87,37 @@ function strippedRow(lines: readonly string[], cache: string[], row: number): st
 	return text;
 }
 
+/**
+ * Decide what each row of one rail message sheds. Padding rows lose the bare
+ * rail. When the first text row leads with the user icon, it loses the icon
+ * too, and the rows hanging under it lose the indent that lines them up.
+ */
+function claimRailMessage(
+	lines: readonly string[],
+	cache: string[],
+	first: number,
+	end: number,
+	claimed: Map<number, string>,
+): void {
+	let iconed: boolean | undefined;
+	for (let row = first; row < end; row++) {
+		const text = strippedRow(lines, cache, row);
+		if (!text.startsWith(USER_RAIL_PREFIX) || text.trim() === USER_RAIL_GLYPH) {
+			claimed.set(row, USER_RAIL_GLYPH);
+			continue;
+		}
+		if (iconed === undefined) {
+			iconed = text.startsWith(USER_ICON_PREFIX);
+			claimed.set(row, iconed ? USER_ICON_PREFIX : USER_RAIL_PREFIX);
+			continue;
+		}
+		claimed.set(
+			row,
+			iconed && text.startsWith(USER_HANG_PREFIX) ? USER_HANG_PREFIX : USER_RAIL_PREFIX,
+		);
+	}
+}
+
 /**
  * Classifies every row of `lines`, then cleans the rows in
  * `[startRow, endRow]`. The scan covers the whole buffer rather than the
@@ -79,15 +129,14 @@ export function cleanTranscriptRows(
 	lines: readonly string[],
 	startRow: number,
 	endRow: number,
-	railGlyph: string,
 ): CleanedRows {
 	const cache: string[] = new Array(lines.length);
 	/** Rows to drop: paired frame edges and paired border rules. */
 	const dropped = new Set<number>();
 	/** pi-toolbox frame content rows: strip one `│` from each side. */
 	const frameContent = new Set<number>();
-	/** Starline user message rows: strip the rail prefix. */
-	const railContent = new Set<number>();
+	/** Rail user message rows, and the prefix each one sheds. */
+	const railContent = new Map<number, string>();
 
 	// Pass 1 — rounded frames. Edges pair strictly by equal width, inner rows
 	// are content. A rounded box drawn inside bash output can mis-pair, but the
@@ -113,17 +162,10 @@ export function cleanTranscriptRows(
 	}
 
 	// Pass 2 — full-width rule pairs. Two rules of equal width with at least
-	// one row between them are a Starline user message's borders, and the rows
-	// between carry the rail. Any inner row *without* the rail prefix breaks
-	// the candidate: it is what keeps an assistant's own `---` rules, and the
-	// text between two of them, from being eaten — those rows are content.
-	//
-	// With an empty rail prefix (the `copyFriendly` render drops the rail)
-	// nothing can break a candidate, so any two equal-width rules pair. That
-	// also matches a markdown `---` pair, which then loses its rules from the
-	// copy — accepted: a horizontal rule is closer to chrome than to content,
-	// and the alternative is leaving real borders in every copyFriendly copy.
-	const railPrefix = railGlyph.length > 0 ? `${railGlyph} ` : "";
+	// one row between them are a rail user message's borders, and the rows
+	// between carry the rail. Any inner row *without* the rail breaks the
+	// candidate: it is what keeps an assistant's own `---` rules, and the text
+	// between two of them, from being eaten — those rows are content.
 	let lastRule: { row: number; width: number } | undefined;
 	for (let row = 0; row < lines.length; row++) {
 		if (dropped.has(row)) continue;
@@ -133,10 +175,10 @@ export function cleanTranscriptRows(
 			if (lastRule && lastRule.width === width && row - lastRule.row >= 2) {
 				dropped.add(lastRule.row);
 				dropped.add(row);
-				for (let inner = lastRule.row + 1; inner < row; inner++) railContent.add(inner);
+				claimRailMessage(lines, cache, lastRule.row + 1, row, railContent);
 			}
 			lastRule = { row, width };
-		} else if (railPrefix.length > 0 && !text.startsWith(railPrefix)) {
+		} else if (!isRailRow(text)) {
 			lastRule = undefined;
 		}
 	}
@@ -155,8 +197,9 @@ export function cleanTranscriptRows(
 			changed = true;
 			continue;
 		}
-		if (railContent.has(row) && railPrefix.length > 0 && text.startsWith(railPrefix)) {
-			rows.push({ text: text.slice(railPrefix.length), leftTrim: visibleWidth(railPrefix) });
+		const prefix = railContent.get(row);
+		if (prefix !== undefined && text.startsWith(prefix)) {
+			rows.push({ text: text.slice(prefix.length), leftTrim: visibleWidth(prefix) });
 			changed = true;
 			continue;
 		}

package/extensions/starline/paste-collapse.ts

@@ -63,6 +63,39 @@ export function supportsPasteCollapse(value: unknown): boolean {
 	return asPasteInternals(value) !== null;
 }
 
+/**
+ * Find an editor method through [[GetOwnProperty]] instead of [[Get]].
+ *
+ * What we are handed is not always the editor. Another extension may pass us its
+ * own Proxy over it — `pi-better-background-tasks` answers `handleInput` with a
+ * wrapper its get trap builds on the spot, and forwards writes to the editor
+ * behind. Capturing through [[Get]] then captures *that* wrapper, and the
+ * `defineProperty` below shadows the very property the wrapper dispatches
+ * through, so the two call each other with nothing underneath: one keystroke and
+ * the stack is gone. Descriptor reads go to the target, so this finds the real
+ * handler whoever's Proxy is standing in front of it.
+ */
+function resolveHandler<Signature extends (...args: never[]) => unknown>(
+	editor: object,
+	prop: string,
+): Signature | undefined {
+	// An instance handler first: whoever put it there is upstream of us, and Pi
+	// itself keeps its handlers on the prototype, where the walk below finds them.
+	const own = Object.getOwnPropertyDescriptor(editor, prop);
+	if (own && "value" in own && typeof own.value === "function") return own.value as Signature;
+	for (
+		let proto: object | null = Object.getPrototypeOf(editor);
+		proto !== null;
+		proto = Object.getPrototypeOf(proto)
+	) {
+		const desc = Object.getOwnPropertyDescriptor(proto, prop);
+		if (desc && "value" in desc && typeof desc.value === "function") {
+			return desc.value as Signature;
+		}
+	}
+	return undefined;
+}
+
 /**
  * Reproduce Pi's pre-collapse cleaning: decode the CSI-u control re-encoding
  * some terminals apply inside a bracketed paste, normalise line endings and
@@ -174,7 +207,7 @@ export function installPasteCollapse(
 	const editor = asPasteInternals(value);
 	if (!editor) return undefined;
 
-	const base = editor.handlePaste;
+	const base = resolveHandler<(text: string) => void>(editor, "handlePaste");
 	if (typeof base !== "function") return undefined;
 
 	// Pi keeps handlePaste on the prototype, where deleting our shadow reveals it
@@ -260,17 +293,16 @@ export function installPasteCollapse(
 
 	// Anything that is not a paste puts the offer away. Pi feeds a bracketed paste
 	// in over several calls with isInPaste set, so only the tail of one counts.
-	const baseInput = editor.handleInput;
+	const baseInput = resolveHandler<(data: string) => unknown>(editor, "handleInput");
 	const previousOwnInput = Object.getOwnPropertyDescriptor(editor, "handleInput");
-	const inputShadow =
-		typeof baseInput === "function"
-			? function (this: unknown, data: string): unknown {
-					sawPaste = false;
-					const result = baseInput.call(editor, data);
-					if (!sawPaste && editor.isInPaste !== true) armed = null;
-					return result;
-				}
-			: null;
+	const inputShadow = baseInput
+		? function (this: unknown, data: string): unknown {
+				sawPaste = false;
+				const result = baseInput.call(editor, data);
+				if (!sawPaste && editor.isInPaste !== true) armed = null;
+				return result;
+			}
+		: null;
 	if (inputShadow) {
 		Object.defineProperty(editor, "handleInput", {
 			configurable: true,
@@ -292,17 +324,24 @@ export function installPasteCollapse(
 	};
 	const ownHint = activeHint;
 
+	/** Read back where the shadows were put. `[[Get]]` is the wrong question to ask
+	 *  an editor that came wrapped in another extension's Proxy: its get trap
+	 *  answers `handleInput` with a wrapper of its own, so the comparison below
+	 *  never recognises our shadow and the disposer leaves it installed. */
+	const ownValue = (prop: "handleInput" | "handlePaste"): unknown =>
+		Object.getOwnPropertyDescriptor(editor, prop)?.value;
+
 	return () => {
 		armed = null;
 		if (activeHint === ownHint) activeHint = null;
-		if (inputShadow && (editor as { handleInput?: unknown }).handleInput === inputShadow) {
+		if (inputShadow && ownValue("handleInput") === inputShadow) {
 			if (previousOwnInput) {
 				Object.defineProperty(editor, "handleInput", previousOwnInput);
 			} else {
 				delete (editor as { handleInput?: unknown }).handleInput;
 			}
 		}
-		if ((editor as { handlePaste?: unknown }).handlePaste !== shadow) return;
+		if (ownValue("handlePaste") !== shadow) return;
 		if (previousOwn) {
 			Object.defineProperty(editor, "handlePaste", previousOwn);
 			return;