@xzzpig/pi-starline 0.1.1 → 0.2.0

package/README.md

@@ -45,14 +45,14 @@ pieces of one product, not a theme:
 The second half of the product: the statusline tells you where you are, the
 mouse lets you act on what you see. Starline drives Pi 0.84's own renderer
 (`tuiMode: "fullscreen"`) by patching its methods directly — the extension API
-stops at high-level hooks, and pending-copy, click-to-expand and clean-copy all
+stops at high-level hooks, and the selection hint, click-to-expand and clean-copy all
 need to reach into the renderer itself. That is also why they live in Starline:
 they sit on the same prototype patches the footer and editor already use, and
 Pi keeps its core deliberately minimal — behaviours belong in extensions.
 
-- **Select and copy anywhere.** Drag to select in the transcript or the input box; double-click a word (paths and kebab-case stay whole), triple-click a line. Releasing copies — or hold the selection for `ctrl+c` with `mouse.copyOnSelect: false`, the behaviour [Pi #7720](https://github.com/earendil-works/pi/issues/7720) asks for upstream.
+- **Select and copy anywhere.** Drag to select in the transcript or the input box; double-click a word (paths and kebab-case stay whole), triple-click a line. Releasing copies — or set Pi's `fullscreenCopyOnSelect: false` and the selection stays highlighted, waiting for the copy key ([Pi #7720](https://github.com/earendil-works/pi/issues/7720), shipped in Pi 0.84.4).
 - **Clean copies.** Transcript selections drop Starline's rails, rule rows and pi-toolbox frame borders before they reach the clipboard; editor selections copy the draft's text, not the painted rows.
-- **Selection hint.** A pending selection shows exactly how many characters `ctrl+c` will copy, and a selection inside the editor names your editor — `ctrl+g to edit in nvim`.
+- **Selection hint.** A selection that is not auto-copying shows exactly how many characters the copy key (`ctrl+x` by default, whatever `app.message.copy` is bound to) will copy, and a selection inside the editor names your editor — `ctrl+g to edit in nvim`.
 - **Click to expand one tool box.** A click on a box's hint row expands just that box (MCP boxes included), and the `(ctrl+o to collapse)` anchor row closes it again.
 - **Click to move the caret** in the input box; **backspace/delete remove a selected range**; the **wheel scrolls the draft** over the input box, and a draft taller than the box keeps the `ctrl+g` external-editor hint on screen.
 
@@ -151,7 +151,7 @@ Detects Starship Nerd Font runtime/language modules, uses the Starship Nerd Font
 
 ## Install
 
-Starline drives Pi 0.84's alternate-screen renderer, so it needs **Pi ≥ 0.84.0**.
+Starline drives Pi 0.84's alternate-screen renderer, so it needs **Pi ≥ 0.84.4**.
 If you are on a distribution that bundles an older Pi, upgrade it or wait for it to catch up.
 
 ```bash
@@ -174,7 +174,7 @@ Settings live in `~/.pi/agent/starline.json`. The file is optional — anything
 {
 	"footerStyle": "pill",
 	"colors": { "gitBranch": "bold purple" },
-	"mouse": { "copyOnSelect": false }
+	"mouse": { "clickToExpandTools": false }
 }
 ```
 
@@ -184,7 +184,7 @@ Settings live in `~/.pi/agent/starline.json`. The file is optional — anything
 
 ## Requirements
 
-- [Pi](https://pi.dev) coding agent 0.80.3 or newer
+- [Pi](https://pi.dev) coding agent 0.84.4 or newer
 - A [Nerd Font](https://www.nerdfonts.com/) for icons (or set `icons.mode` to `"ascii"`)
 
 ## Development

package/extensions/starline/config.ts

@@ -109,12 +109,8 @@ export type MouseConfig = {
 	wheelRouting: boolean;
 	/** Show a "copied to clipboard" notice for a copy Starline itself performs. */
 	copyNotice: boolean;
-	/** Copy on mouse release. When false the highlight waits for ctrl+c. */
-	copyOnSelect: boolean;
 	/** Clicking a tool box's `ctrl+o to expand` hint expands that one box. */
 	clickToExpandTools: boolean;
-	/** Double/triple-click word selection stops at path separators. */
-	pathAwareWords: boolean;
 	/** Copy transcript selections without the painted rails, rules and frames. */
 	transcriptCleanCopy: boolean;
 };
@@ -123,7 +119,6 @@ const FIXED_EDITOR_KEY_MAP: Record<string, keyof MouseConfig> = {
 	enabled: "enabled",
 	mouseScroll: "wheelRouting",
 	copyNotice: "copyNotice",
-	copyOnSelect: "copyOnSelect",
 	clickToExpandTools: "clickToExpandTools",
 };
 
@@ -415,9 +410,7 @@ export const defaultConfig: PolishedTuiConfig = {
 		enabled: true,
 		wheelRouting: true,
 		copyNotice: true,
-		copyOnSelect: true,
 		clickToExpandTools: true,
-		pathAwareWords: true,
 		transcriptCleanCopy: true,
 	},
 };
@@ -831,18 +824,10 @@ function normalizeMouseConfig(record: Record<string, unknown>): MouseConfig {
 				: defaultConfig.mouse.wheelRouting,
 		copyNotice:
 			typeof record.copyNotice === "boolean" ? record.copyNotice : defaultConfig.mouse.copyNotice,
-		copyOnSelect:
-			typeof record.copyOnSelect === "boolean"
-				? record.copyOnSelect
-				: defaultConfig.mouse.copyOnSelect,
 		clickToExpandTools:
 			typeof record.clickToExpandTools === "boolean"
 				? record.clickToExpandTools
 				: defaultConfig.mouse.clickToExpandTools,
-		pathAwareWords:
-			typeof record.pathAwareWords === "boolean"
-				? record.pathAwareWords
-				: defaultConfig.mouse.pathAwareWords,
 		transcriptCleanCopy:
 			typeof record.transcriptCleanCopy === "boolean"
 				? record.transcriptCleanCopy
@@ -1304,11 +1289,9 @@ export function saveMousePatch(patch: Partial<MouseConfig>, path = configPath):
 			...(patch.enabled !== undefined ? { enabled: patch.enabled } : {}),
 			...(patch.wheelRouting !== undefined ? { wheelRouting: patch.wheelRouting } : {}),
 			...(patch.copyNotice !== undefined ? { copyNotice: patch.copyNotice } : {}),
-			...(patch.copyOnSelect !== undefined ? { copyOnSelect: patch.copyOnSelect } : {}),
 			...(patch.clickToExpandTools !== undefined
 				? { clickToExpandTools: patch.clickToExpandTools }
 				: {}),
-			...(patch.pathAwareWords !== undefined ? { pathAwareWords: patch.pathAwareWords } : {}),
 			...(patch.transcriptCleanCopy !== undefined
 				? { transcriptCleanCopy: patch.transcriptCleanCopy }
 				: {}),

package/extensions/starline/mouse/capabilities.ts

@@ -14,15 +14,20 @@
  * install this table exists to prevent. The check being stricter than a plain
  * call needs (it also demands writable and configurable) costs nothing, because
  * a class method declared the ordinary way is both.
+ *
+ * Since 0.84.4 the peer floor guarantees `copyActiveSelectionToClipboard`,
+ * `getCopyOnSelect` and `hasActiveSelection` exist; the probe still runs so a
+ * future Pi that moves them degrades feature-by-feature instead of breaking
+ * the whole install.
  */
 
 export type MouseCapability =
 	| "handleViewportInput"
 	| "routeWheel"
 	| "handleSelectionMouseEvent"
-	| "copySelectionToClipboard"
-	| "getWordSelection"
-	| "getSelectionSourceLine"
+	| "copyActiveSelectionToClipboard"
+	| "getCopyOnSelect"
+	| "hasActiveSelection"
 	| "getSelectionBounds"
 	| "getSelectionColumns"
 	| "flash"
@@ -30,8 +35,7 @@ export type MouseCapability =
 	| "requestRender";
 
 export type MouseFeature =
-	| "selectionPendingMode"
-	| "pathAwareWords"
+	| "selectionHint"
 	| "clickToExpandTools"
 	| "editorWheelScroll"
 	| "editorClickToCaret"
@@ -42,9 +46,9 @@ const CAPABILITIES: readonly MouseCapability[] = [
 	"handleViewportInput",
 	"routeWheel",
 	"handleSelectionMouseEvent",
-	"copySelectionToClipboard",
-	"getWordSelection",
-	"getSelectionSourceLine",
+	"copyActiveSelectionToClipboard",
+	"getCopyOnSelect",
+	"hasActiveSelection",
 	"getSelectionBounds",
 	"getSelectionColumns",
 	"flash",
@@ -61,25 +65,20 @@ const CAPABILITIES: readonly MouseCapability[] = [
  * is worse than no table.
  */
 const REQUIREMENTS: Record<MouseFeature, readonly MouseCapability[]> = {
-	// Without ctrl+c interception the pending mode strands a highlight the user
-	// cannot copy, which is worse than copy-on-release. It also reads the
-	// selection directly (`getSelectionBounds`, `getSelectionColumns`) to build
-	// an exact character count, and raises its own notice (`flash`), so all
-	// three must be reachable too. `requestRender` is what puts the pending hint
-	// on screen the moment the button comes up: arming without it would leave
-	// the user staring at a highlight with nothing telling them ctrl+c copies it.
-	selectionPendingMode: [
-		"copySelectionToClipboard",
-		"handleViewportInput",
+	// Derived from Pi 0.84.4's own select-without-copy state: the hint shows
+	// only while the renderer is NOT auto-copying (`getCopyOnSelect` false) and
+	// something is actually selected (`hasActiveSelection`). The character
+	// count is computed from the live selection through `getSelectionBounds`
+	// and `getSelectionColumns`, matching the columns the copy itself would
+	// slice — the hint promises what ctrl+x delivers. No release interception,
+	// no pending state: Pi's `copyOnSelect: false` already keeps the selection
+	// highlighted, and the hint rides Pi's own repaints.
+	selectionHint: [
+		"getCopyOnSelect",
+		"hasActiveSelection",
 		"getSelectionBounds",
 		"getSelectionColumns",
-		"flash",
-		"requestRender",
 	],
-	// Also reads the line under the pointer through the receiver's own
-	// `getSelectionSourceLine`, so the patch has a real line to hand
-	// `wordRangeAt` — without it there's nothing to compute a range over.
-	pathAwareWords: ["getWordSelection", "getSelectionSourceLine"],
 	// The press it acts on arrives through `handleSelectionMouseEvent`, and it
 	// asks `hasOverlay` the same question Pi's own press path asks before
 	// resolving a scroll view (`tui-alt-screen.js:684`) — without it, a click on
@@ -123,11 +122,12 @@ const REQUIREMENTS: Record<MouseFeature, readonly MouseCapability[]> = {
 		"hasOverlay",
 		"requestRender",
 	],
-	// It wraps `copySelectionToClipboard`, reads the selection through
-	// `getSelectionBounds` to find out whether it is the editor's, and raises
-	// Pi's own "Copied!" through `flash` when it answers the copy itself.
-	// `hasOverlay` again: a selection dropped on a dialog must not be read as
-	// text from the draft behind it.
+	// It wraps `copyActiveSelectionToClipboard` — the method Pi 0.84.4's
+	// Ctrl+X handler reaches (`handleCopyCommand` with `preferSelection`), so
+	// the clean copy answers exactly the copies that key performs — and reads
+	// the selection through `getSelectionBounds` to find out whether it is the
+	// editor's. `hasOverlay` again: a selection dropped on a dialog must not be
+	// read as text from the draft behind it.
 	//
 	// The clipboard write goes through `terminal.write`, which is not listed
 	// because it is not on this prototype — `terminal` is a plain instance field
@@ -135,18 +135,18 @@ const REQUIREMENTS: Record<MouseFeature, readonly MouseCapability[]> = {
 	// It is checked at the call site instead, and a terminal that cannot be
 	// written to makes the copy fall through to Pi rather than disabling the
 	// feature at install time.
-	editorBufferCopy: ["copySelectionToClipboard", "getSelectionBounds", "hasOverlay", "flash"],
-	// Shares the `copySelectionToClipboard` patch with the two features above
-	// it. It reads the selection through `getSelectionBounds` to find the rows,
-	// through `getSelectionColumns` to slice the cleaned text along the same
-	// grapheme-aligned columns Pi would have used, asks `hasOverlay` before
+	editorBufferCopy: ["copyActiveSelectionToClipboard", "getSelectionBounds", "hasOverlay", "flash"],
+	// Shares the `copyActiveSelectionToClipboard` patch with the two features
+	// above it. It reads the selection through `getSelectionBounds` to find the
+	// rows, through `getSelectionColumns` to slice the cleaned text along the
+	// same grapheme-aligned columns Pi would have used, asks `hasOverlay` before
 	// trusting those rows (an overlay is composited over a layout that still
-	// contains the transcript), and raises Pi's own "Copied!" through `flash`
+	// contains the transcript), and raises its own "Copied!" through `flash`
 	// when it answers the copy itself. The clipboard write goes through
 	// `terminal.write`, unlisted for the same reason as editorBufferCopy's — it
 	// is an instance field, checked at the call site instead.
 	transcriptCleanCopy: [
-		"copySelectionToClipboard",
+		"copyActiveSelectionToClipboard",
 		"getSelectionBounds",
 		"getSelectionColumns",
 		"hasOverlay",

package/extensions/starline/mouse/editor-caret.ts

@@ -397,9 +397,9 @@ type EditableEditor = {
  * range back a letter at a time. So one snapshot is pushed up front through the
  * editor's own `pushUndoSnapshot`, and the editor's own is shadowed for the
  * duration of the loop and put back in a `finally` — the same shadow-and-restore
- * shape `copyWithNotice` uses on `flash` and `installPasteCollapse` uses on
- * `handlePaste`. This is a plain assignment on Starline's own editor instance,
- * never on anything reached through Pi's renderer Proxy.
+ * shape `installPasteCollapse` uses on `handlePaste`. This is a plain
+ * assignment on Starline's own editor instance, never on anything reached
+ * through Pi's renderer Proxy.
  *
  * The loop is bounded twice over: by the character count of the range, and by a
  * no-progress check, so an editor that stops deleting cannot spin.

package/extensions/starline/mouse/index.ts

@@ -5,32 +5,22 @@
  * what it would do to it. `installMouse` probes what the running Pi build
  * exposes, logs once if something is missing, and installs each feature gated
  * on exactly its own declared requirement (`capabilities.ts`). Today that is
- * six features across five patches. Three of those methods carry two features
+ * six features across four patches. Two of those methods carry two features
  * each, and in every case the two share a single patch, because the patch
  * registry holds one behaviour per adapter key and a second registration would
  * silently replace the first:
  *
- * `selectionPendingMode`, across two patches:
- * - `copySelectionToClipboard` — the method Pi calls itself on mouse
- *   release. Wrapped to arm a pending state instead of copying immediately
- *   when `copyOnSelect` is off, calling through for every other caller
- *   (including its own ctrl+c path below).
- * - `handleViewportInput` — watched for a bare `ctrl+c` (`\x03`); with a
- *   selection pending it performs the real copy by calling back through
- *   `copySelectionToClipboard` (guarded so that call is recognised as the
- *   real thing and not re-armed), then clears the pending state. Anything
- *   else — including `ctrl+c` with nothing pending — calls through to Pi's
- *   own handler, which is what keeps `ctrl+c` interrupting.
- *
- * `pathAwareWords`, one patch:
- * - `getWordSelection` — Pi's own double-click word lookup, replaced with
- *   `wordRangeAt` (`word-select.ts`, ported from pi issue #7746) so a path or
- *   a kebab-case identifier selects whole instead of stopping at `/` or `-`.
- *   The installed 0.84.1 build predates #7746, so this substitutes Pi's
- *   entire word-selection rule rather than layering path handling on top of
- *   it — that is what #7746 itself proposes, not scope creep introduced
- *   here. Calls through when `wordRangeAt` declines (column past the end of
- *   the line) or when `mouse.pathAwareWords` is off.
+ * `selectionHint`, one patch plus a derived hint:
+ * - `copyActiveSelectionToClipboard` — the method Pi 0.84.4's Ctrl+X handler
+ *   reaches (`handleCopyCommand` with `preferSelection`). Wrapped so a
+ *   selection the clean-copy features recognise copies clean, calling
+ *   through for everything else.
+ * - The hint is derived, not owned: `activeSelectionHintText()` renders the
+ *   live renderer's state — an active selection that is not being
+ *   auto-copied (`getCopyOnSelect() === false`) — so select-without-copy is
+ *   Pi's own `fullscreenCopyOnSelect`, and this module only tells the user
+ *   what to press. The copy key is `app.message.copy` (default ctrl+x),
+ *   resolved from Pi's keybinding registry so a rebind shows up in the hint.
  *
  * `clickToExpandTools`, one patch:
  * - `handleSelectionMouseEvent` — watched for a left-button press that landed
@@ -63,7 +53,7 @@
  *   interrupt and exit chords cannot be swallowed by it from either direction.
  *   Every backspace it does not act on falls through and deletes one character.
  *
- * `editorBufferCopy`, sharing the `copySelectionToClipboard` patch:
+ * `editorBufferCopy`, sharing the `copyActiveSelectionToClipboard` patch:
  * - A selection lying inside the input box is copied from the *draft* rather
  *   than from the rendered rows. That is the one place this module builds
  *   clipboard bytes itself, and the reason is that the rendered rows are not
@@ -80,15 +70,10 @@
  *   was clean before changes.
  *
  * Everywhere else the clipboard gets exactly what Pi's own
- * `copySelectionToClipboard` puts there — see `installMouse` for why frame-free
+ * `copyActiveSelectionToClipboard` puts there — see `installMouse` for why frame-free
  * selection is not part of this.
  */
-import {
-	getKeybindings,
-	matchesKey,
-	sliceByColumn,
-	stripTerminalSequences,
-} from "@earendil-works/pi-tui";
+import { getKeybindings, sliceByColumn, stripTerminalSequences } from "@earendil-works/pi-tui";
 import type { PolishedTuiConfig } from "../config";
 import { installPrototypePatch } from "../prototype-patch-registry";
 import {
@@ -107,37 +92,17 @@ import { activeEditor, wheelTarget } from "./editor-mouse";
 import { scrollEditorBy } from "./editor-scroll";
 import { editorVisualRowCount } from "./editor-text-cursor";
 import { type BoxLike, scrollContentLinesFor } from "./hit-test";
-import { externalEditorName, SelectionPendingState, selectionHintText } from "./selection-state";
+import { externalEditorName, selectionHintText } from "./selection-state";
 import { type ExpandTarget, expandKeyText, expandTargetAt, keyTextFor } from "./tool-box";
 import { cleanTranscriptRows } from "./transcript-copy";
-import { wordRangeAt } from "./word-select";
 
+/** Pi's interrupt chord — refused by the range-delete branch, never consumed. */
 const CTRL_C = "\x03";
 /** Pi's exit chord, and `tui.editor.deleteCharForward`'s second default key. */
 const CTRL_D = "\x04";
 
-/**
- * Whether `data` is the ctrl+c chord, in whatever encoding the terminal sent
- * it. Pi 0.84 pushes the Kitty keyboard protocol (and falls back to xterm
- * modifyOtherKeys) on every capable terminal, and under either protocol the
- * chord arrives as an escape sequence — `\x1b[99;5u` or `\x1b[27;5;99~` —
- * never as the bare `\x03` a plain legacy terminal sends. The pending copy
- * must recognise all three, or ctrl+c falls through to Pi's own binding
- * (`app.clear`, clear the editor) exactly when it was about to copy. Pi's
- * own key matcher is the authority here: it parses every protocol this
- * build negotiates, and its `ctrl+c` arm accepts the raw control character
- * too, so a legacy terminal keeps working unchanged.
- */
-function isCtrlC(data: unknown): boolean {
-	if (typeof data !== "string" || data.length === 0) return false;
-	try {
-		return matchesKey(data, "ctrl+c");
-	} catch {
-		// A pi-tui build that has moved `matchesKey` must not break the copy:
-		// fall back to the raw byte, which is what this branch has always read.
-		return data === CTRL_C;
-	}
-}
+/** The binding Pi's selection copy lives on (`app.message.copy`, default ctrl+x). */
+const COPY_KEYBINDING = "app.message.copy";
 
 /** Opens the draft in `$EDITOR` — the hint an editor selection's hint carries. */
 const EXTERNAL_EDITOR_KEYBINDING = "app.editor.external";
@@ -171,11 +136,23 @@ type MouseCapablePrototype = {
 		row: number,
 		selection: SelectionBounds,
 	): SelectionColumns;
-	copySelectionToClipboard(this: unknown): Promise<void>;
+	/**
+	 * Pi 0.84.4's public selection-copy entry (`tui-alt-screen.ts`): true when
+	 * the active selection was copied, false when there was none. This is what
+	 * coding-agent's Ctrl+X handler reaches, so a clean copy answering this
+	 * method answers exactly the copies that key performs.
+	 */
+	copyActiveSelectionToClipboard(this: unknown): Promise<boolean>;
+	/**
+	 * Pi 0.84.4's select-without-copy state. The hint reads it to decide
+	 * whether a selection is waiting for the copy key or was already copied on
+	 * release.
+	 */
+	getCopyOnSelect(this: unknown): boolean;
+	/** Whether the fullscreen viewport has a non-empty active text selection. */
+	hasActiveSelection(this: unknown): boolean;
 	handleViewportInput(this: unknown, data: string): { consume: boolean } | undefined;
 	flash(this: unknown, message: string, durationMs?: number): void;
-	getWordSelection(this: unknown, point: SelectionPoint): SelectionBounds | undefined;
-	getSelectionSourceLine(this: unknown, point: SelectionPoint): string;
 	hasOverlay(this: unknown): boolean;
 	/**
 	 * `TuiAltScreen.routeWheel(event)` (`tui-alt-screen.js:375`). `event` is
@@ -203,7 +180,7 @@ type MouseCapablePrototype = {
 	selectionFocus?: unknown;
 	/**
 	 * `TuiBase.terminal` (`tui.js:101`); `rows` is a getter on it, and `write` is
-	 * how `copySelectionToClipboard` reaches the clipboard — it emits OSC 52
+	 * how `copyActiveSelectionToClipboard` reaches the clipboard — it emits OSC 52
 	 * through the terminal rather than through any renderer method.
 	 */
 	terminal?: { rows?: number; write?: (data: string) => void };
@@ -234,15 +211,72 @@ export type InstallMouseDeps = {
 let hasWarned = false;
 
 /**
- * Reader for the pending-selection state of whichever `installMouse` call is
+ * The live renderer the hint reads. `installMouse` receives only the
+ * prototype, so the instance is captured here from the first patched call
+ * that sees one — `handleViewportInput` sees every key and mouse event, and
+ * repaints ride Pi's own `requestRender`, so the hint is never more than one
+ * input away from the current renderer.
+ */
+let activeReceiver: MouseCapablePrototype | undefined;
+
+/**
+ * Reader for the derived selection hint of whichever `installMouse` call is
  * currently active, mirroring `pasteExpandHintText`'s pattern in
- * `../paste-collapse.ts`. `ui.ts` composes this with the paste hint
- * on every render; there is nothing to wire when no mouse install is active.
+ * `../paste-collapse.ts`. `ui.ts` composes this with the paste hint on every
+ * render; there is nothing to wire when no mouse install is active.
+ *
+ * The hint is computed on demand from the live renderer, never cached:
+ * "selected, ctrl+x to copy" is true exactly while Pi is not auto-copying
+ * and something is actually selected. The character count goes through the
+ * same two copy paths the copy key itself would answer, so the hint's
+ * promise and the clipboard's bytes stay in agreement.
  */
-let activeState: SelectionPendingState | undefined;
+let activeHint:
+	| { getConfig: () => PolishedTuiConfig; bufferCopy: boolean; cleanCopy: boolean }
+	| undefined;
 
 export function activeSelectionHintText(): string | null {
-	return activeState ? selectionHintText(activeState, externalEditorName()) : null;
+	if (!activeHint || !activeReceiver) return null;
+	const { getConfig, bufferCopy, cleanCopy } = activeHint;
+	try {
+		// Pi auto-copies on release; a selection that is already on the
+		// clipboard needs no hint. `getCopyOnSelect()` is the live value, so a
+		// setting flipped at runtime flips the hint with it.
+		if (activeReceiver.getCopyOnSelect()) return null;
+		if (!activeReceiver.hasActiveSelection()) return null;
+		const bounds = activeReceiver.getSelectionBounds();
+		if (!bounds) return null;
+		const pending = pendingSelectionText(
+			activeReceiver,
+			getConfig(),
+			bounds,
+			bufferCopy,
+			cleanCopy,
+		);
+		return selectionHintText(
+			pending.text.length,
+			copyKeyText(),
+			// An editor selection cannot grow past the visible window — there is
+			// no drag-scroll — so the hint for one points at the external editor,
+			// the way to act on the whole draft. "" (unbound) shows no suffix.
+			pending.inEditor ? keyTextFor(EXTERNAL_EDITOR_KEYBINDING) : undefined,
+			externalEditorName(),
+		);
+	} catch {
+		// The renderer is best effort; a receiver that has moved on offers no
+		// hint rather than breaking the metadata row.
+		return null;
+	}
+}
+
+/**
+ * The rendered name of the copy key, for the hint. `app.message.copy` is what
+ * Pi 0.84.4's Ctrl+X path is bound to (see `handleCopyCommand` in
+ * interactive-mode.ts), and the registry resolves a user rebind so the hint
+ * always quotes the key that really copies.
+ */
+function copyKeyText(): string {
+	return keyTextFor(COPY_KEYBINDING);
 }
 
 /**
@@ -283,10 +317,10 @@ function refreshExternalEditorHint(
 }
 
 /**
- * The exact text `copySelectionToClipboard` would produce, built the same way
- * it builds it: per row, through the receiver's own `getSelectionColumns`,
- * then `sliceByColumn` and `stripTerminalSequences` (both exported by
- * pi-tui), joined with "\n" — see `copySelectionToClipboard` in
+ * The exact text Pi's selection copy would produce, built the same way it
+ * builds it: per row, through the receiver's own `getSelectionColumns`, then
+ * `sliceByColumn` and `stripTerminalSequences` (both exported by pi-tui),
+ * joined with "\n" — see `copyActiveSelectionToClipboard` in
  * `node_modules/@earendil-works/pi-tui/dist/tui-alt-screen.js`. Reusing Pi's
  * own helpers instead of re-deriving the column math is what keeps this exact
  * rather than an estimate. The scroll-view case needs the box behind
@@ -321,42 +355,6 @@ function selectionText(receiver: MouseCapablePrototype, bounds: SelectionBounds)
 	return rows.join("\n");
 }
 
-/**
- * Runs `copySelectionToClipboard` (Pi's real one, reached through the
- * receiver so the `mouse-copy` patch's re-entrancy guard applies) with its
- * own "Copied!" flash suppressed when `copyNotice` is off.
- *
- * Pi's copy method flashes unconditionally — see
- * `node_modules/@earendil-works/pi-tui/dist/tui-alt-screen.js`. Respecting
- * `copyNotice: false` therefore means shadowing `flash` on the receiver for
- * the duration of this one call and restoring it immediately after, the same
- * shadow-and-restore shape `installPasteCollapse` already uses on `handlePaste`.
- * `receiver` here is Pi's own instance (the wrapper runs inside Pi's own
- * method call, not through the extension-facing Proxy), so a plain
- * assignment is safe.
- *
- * 0.84.2 (#8110) boundary: Pi's copy is now async, and when the host injects
- * a clipboard (`copySelection` — coding-agent does since 0.84.2), the flash
- * lands after `await`, outside this synchronous shadow. `copyNotice: false`
- * therefore still suppresses the toast on the OSC 52 fallback path (no host
- * clipboard) but not on the host-clipboard path. The ctrl+c caller must stay
- * synchronous — it returns `{ consume: true }` to Pi's `handleInput` — so
- * awaiting Pi's copy here is not an option.
- */
-function copyWithNotice(receiver: MouseCapablePrototype, showNotice: boolean): void {
-	if (showNotice) {
-		receiver.copySelectionToClipboard();
-		return;
-	}
-	const originalFlash = receiver.flash;
-	receiver.flash = () => {};
-	try {
-		receiver.copySelectionToClipboard();
-	} finally {
-		receiver.flash = originalFlash;
-	}
-}
-
 /**
  * Writes the draft's own text to the clipboard for a selection that lies inside
  * the input box, and reports whether it did — `false` means this selection was
@@ -368,14 +366,13 @@ function copyWithNotice(receiver: MouseCapablePrototype, showNotice: boolean): v
  * the frame fills each row out to, and a newline wherever the draft happened to
  * wrap. None of that is in the draft. The bytes go out the same way Pi's own
  * copy sends them — OSC 52 through `terminal.write`, see
- * `copySelectionToClipboard` in
+ * `copyActiveSelectionToClipboard` in
  * `node_modules/@earendil-works/pi-tui/dist/tui-alt-screen.js` — so nothing
  * downstream can tell the two copies apart.
  *
- * The flash is unconditional, exactly as Pi's is. `copyNotice: false` is
- * honoured by `copyWithNotice`, which shadows `flash` around the whole call;
- * checking the setting here as well would suppress the notice twice on one path
- * and not at all on the other.
+ * The flash is gated on `copyNotice` at the write itself, exactly once — Pi's
+ * own copy flashes unconditionally, so this check is the whole notice path for
+ * a clean copy.
  */
 function editorTextForSelection(
 	receiver: MouseCapablePrototype,
@@ -407,7 +404,7 @@ function copyEditorSelection(receiver: MouseCapablePrototype, config: PolishedTu
 		const write = receiver.terminal?.write;
 		if (typeof write !== "function") return false;
 		write.call(receiver.terminal, `\x1b]52;c;${Buffer.from(text).toString("base64")}\x07`);
-		receiver.flash("Copied!");
+		if (config.mouse.copyNotice) receiver.flash("Copied!");
 		return true;
 	} catch {
 		// Reading the editor and the layout is best effort. Anything this trips
@@ -508,7 +505,7 @@ function copyTranscriptSelection(
 		const write = receiver.terminal?.write;
 		if (typeof write !== "function") return false;
 		write.call(receiver.terminal, `\x1b]52;c;${Buffer.from(text).toString("base64")}\x07`);
-		receiver.flash("Copied!");
+		if (config.mouse.copyNotice) receiver.flash("Copied!");
 		return true;
 	} catch {
 		// Cleaning reads the layout and the selection, both best effort.
@@ -532,8 +529,6 @@ function copyTranscriptSelection(
  * all. `tui.editor.deleteCharForward` binds `ctrl+d` by default, and ctrl+c and
  * ctrl+d are Pi's interrupt and exit chords; consuming either because a
  * selection happens to be live would break a global key to save a keystroke.
- * The ctrl+c branch above already returns before this is reached, but stating
- * it here means the guarantee does not depend on branch order.
  */
 function isRangeDeleteKey(data: unknown): boolean {
 	if (typeof data !== "string" || data.length === 0) return false;
@@ -581,11 +576,11 @@ function deleteSelectedRange(receiver: MouseCapablePrototype, config: PolishedTu
 }
 
 /**
- * The text a copy of this selection would put on the clipboard, for the pending
- * hint's character count.
+ * The text a copy of this selection would put on the clipboard, for the hint's
+ * character count.
  *
  * It has to ask the same two paths the copy itself asks, in the same order, or
- * the hint promises a number ctrl+c does not deliver.
+ * the hint promises a number the copy does not deliver.
  */
 function pendingSelectionText(
 	receiver: MouseCapablePrototype,
@@ -596,8 +591,8 @@ function pendingSelectionText(
 ): { text: string; inEditor: boolean } {
 	const buffered = bufferCopy ? editorTextForSelection(receiver, config, bounds) : undefined;
 	if (buffered !== undefined) return { text: buffered, inEditor: true };
-	// The count the hint shows must be the number ctrl+c actually delivers, so
-	// a selection the copy would clean is counted after cleaning.
+	// The count the hint shows must be the number the copy key actually
+	// delivers, so a selection the copy would clean is counted after cleaning.
 	if (cleanCopy && config.mouse.transcriptCleanCopy) {
 		try {
 			const cleaned = transcriptSelectionText(receiver, config, bounds);
@@ -611,25 +606,24 @@ function pendingSelectionText(
 }
 
 /**
- * Installs the two features that live on `copySelectionToClipboard`.
- *
- * `selectionPendingMode` — arm on release, copy on ctrl+c — spans two patches:
- * the copy patch decides whether a release copies now or arms and waits, and
- * the `handleViewportInput` patch is what a waiting selection is eventually
- * released by.
- *
- * `editorBufferCopy` sits in front of the real copy on that same method. They
- * share one patch rather than taking a key each because
- * `installPrototypePatch` holds exactly one behaviour per adapter key: a second
- * registration under `mouse-copy` would silently replace the first, and two
- * different keys would leave the order they run in — and which of them gets to
- * consume the call — implicit. Here the precedence is written down: the buffer
- * copy answers first, and only when it declines does the pending mode or
- * predecessor see the call.
- *
- * Either feature can be off. With `selectionPendingMode` unavailable there is
- * no state and every call is a real copy; with `editorBufferCopy` unavailable
- * the clipboard is Pi's own bytes, exactly as before.
+ * Installs the clean-copy features on Pi 0.84.4's public copy entry, and the
+ * derived selection hint.
+ *
+ * `editorBufferCopy` and `transcriptCleanCopy` sit in front of
+ * `copyActiveSelectionToClipboard` — the method coding-agent's Ctrl+X handler
+ * reaches (`handleCopyCommand` with `preferSelection`) — so the clean copy
+ * answers exactly the copies that key performs. They share one patch rather
+ * than taking a key each because `installPrototypePatch` holds exactly one
+ * behaviour per adapter key: a second registration under `mouse-copy` would
+ * silently replace the first, and two different keys would leave the order
+ * they run in — and which of them gets to consume the call — implicit. Here
+ * the precedence is written down: the buffer copy answers first, and only
+ * when it declines does the clean copy or predecessor see the call.
+ *
+ * `selectionHint` owns no state at all: it records the config reader and the
+ * clean-copy flags so `activeSelectionHintText()` can derive the hint on
+ * demand from the live renderer. Either clean-copy feature can be off; with
+ * neither available the clipboard is Pi's own bytes, exactly as before.
  */
 function installCopying(
 	prototype: MouseCapablePrototype,
@@ -639,81 +633,40 @@ function installCopying(
 	const bufferCopy = features.has("editorBufferCopy");
 	const cleanCopy = features.has("transcriptCleanCopy");
 	const rangeDelete = features.has("editorClickToCaret");
-	const pendingMode = features.has("selectionPendingMode");
-	const state = pendingMode ? new SelectionPendingState() : undefined;
-	const previousState = activeState;
-	if (state) activeState = state;
-
-	// Set while this module is driving `copySelectionToClipboard` itself (the
-	// ctrl+c path below), so the `mouse-copy` patch performs the copy instead of
-	// re-arming the state it is itself in the middle of clearing.
-	let performingRealCopy = false;
+	const hint = features.has("selectionHint");
+	const previousHint = activeHint;
+	if (hint) activeHint = { getConfig: deps.getConfig, bufferCopy, cleanCopy };
 
 	const cleanups: Array<() => void> = [];
 
-	// Only installed when a feature that answers `copySelectionToClipboard` is
-	// on. With just `editorClickToCaret` the method is not ours to touch, and a
-	// Pi that has moved it must not make this install throw.
-	if (pendingMode || bufferCopy || cleanCopy) {
+	// Only installed when a feature that answers `copyActiveSelectionToClipboard`
+	// is on. With just `editorClickToCaret` or `selectionHint` the method is
+	// not ours to touch, and a Pi that has moved it must not make this install
+	// throw.
+	if (bufferCopy || cleanCopy) {
 		cleanups.push(
 			installPrototypePatch(
 				prototype,
-				"copySelectionToClipboard",
+				"copyActiveSelectionToClipboard",
 				"mouse-copy",
 				({ predecessor, receiver, args }) => {
 					const typedReceiver = receiver as MouseCapablePrototype;
 					const config = deps.getConfig();
-					if (!state || config.mouse.copyOnSelect || performingRealCopy) {
-						// The real copy, whether Pi triggered it directly on release
-						// (`copyOnSelect: true`), this module is driving it itself for
-						// ctrl+c below, or pending mode is not installed at all.
-						if (bufferCopy && copyEditorSelection(typedReceiver, config)) return undefined;
-						if (
-							cleanCopy &&
-							config.mouse.transcriptCleanCopy &&
-							copyTranscriptSelection(typedReceiver, config)
-						) {
-							return undefined;
-						}
-						return Reflect.apply(predecessor, receiver, args);
+					if (bufferCopy && copyEditorSelection(typedReceiver, config)) return true;
+					if (
+						cleanCopy &&
+						config.mouse.transcriptCleanCopy &&
+						copyTranscriptSelection(typedReceiver, config)
+					) {
+						return true;
 					}
-					const bounds = typedReceiver.getSelectionBounds();
-					if (!bounds) {
-						// A collapsed or empty selection (e.g. a plain click after a prior
-						// drag) still reaches this call — Pi runs it unconditionally on
-						// every release and relies on its own `if (!selection) return;`
-						// guard. Any stale arm from an earlier selection must not survive
-						// this: left in place, it would make a later ctrl+c consume the
-						// key for a no-op copy instead of falling through to interrupt.
-						if (state.pending) {
-							state.clear();
-							typedReceiver.requestRender();
-						}
-						return undefined;
-					}
-					const pendingText = pendingSelectionText(
-						typedReceiver,
-						config,
-						bounds,
-						bufferCopy,
-						cleanCopy,
-					);
-					state.arm(
-						pendingText.text.length,
-						// An editor selection cannot grow past the visible window —
-						// there is no drag-scroll — so the hint for one points at the
-						// external editor, the way to act on the whole draft. ""
-						// (unbound) simply shows no suffix.
-						pendingText.inEditor ? keyTextFor(EXTERNAL_EDITOR_KEYBINDING) : undefined,
-					);
-					typedReceiver.requestRender();
-					return undefined;
+					return Reflect.apply(predecessor, receiver, args);
 				},
 			),
 		);
 	}
 
-	if (!state && !rangeDelete) {
+	if (!hint && !rangeDelete) {
 		return () => {
 			for (const cleanup of cleanups) cleanup();
 		};
@@ -726,58 +679,27 @@ function installCopying(
 			"mouse-viewport-input",
 			({ predecessor, receiver, args }) => {
 				const data = args[0];
+				const typedReceiver = receiver as MouseCapablePrototype;
 				// Keystrokes and mouse events both land here, so this is the one
 				// place that sees every draft change; keep the outgrew-the-box
-				// hint current with it.
-				refreshExternalEditorHint(receiver as MouseCapablePrototype, deps.getConfig());
-				// ---- Branch 1: ctrl+c, `selectionPendingMode`'s. ----------------
+				// hint current with it, and keep the selection hint's renderer
+				// reference pointed at the live instance.
+				activeReceiver = typedReceiver;
+				refreshExternalEditorHint(typedReceiver, deps.getConfig());
+				// ---- Backspace and delete, `editorClickToCaret`'s. ------------
 				//
-				// This branch is FIRST, and deliberately so. The one outcome that
-				// must never regress is a bare ctrl+c with nothing pending reaching
-				// Pi and interrupting; evaluating its branch before any other means
-				// no feature added to this method later can intercept it by being
-				// installed in a different order. `isRangeDeleteKey` refuses ctrl+c
-				// and ctrl+d outright as well, so the guarantee holds structurally
-				// from both directions rather than by ordering alone.
-				if (state && isCtrlC(data) && state.pending) {
-					const typedReceiver = receiver as MouseCapablePrototype;
-					// `state.pending` can be stale: Pi clears its own selection
-					// through paths this module never sees (e.g. starting a new
-					// drag overwrites `selectionAnchor`/`selectionFocus` directly,
-					// with no call to `copySelectionToClipboard`). Re-read the real
-					// bounds before deciding: a copy that would be a no-op must not
-					// consume ctrl+c, or an in-flight interrupt gets swallowed for
-					// nothing.
-					if (!typedReceiver.getSelectionBounds()) {
-						state.clear();
-						typedReceiver.requestRender();
-						return Reflect.apply(predecessor, receiver, args);
-					}
-					performingRealCopy = true;
-					try {
-						copyWithNotice(typedReceiver, deps.getConfig().mouse.copyNotice);
-					} finally {
-						performingRealCopy = false;
-					}
-					state.clear();
-					typedReceiver.requestRender();
-					return { consume: true };
-				}
-				// ---- Branch 2: backspace and delete, `editorClickToCaret`'s. ----
-				//
-				// The two branches key off disjoint input — ctrl+c above, backspace
-				// and delete here — so they compose rather than compete. Range
-				// delete consumes the key only when it really removed something;
-				// every other backspace falls through and goes on deleting one
-				// character, which is the behaviour it must not break.
+				// Range delete consumes the key only when it really removed
+				// something; every other backspace falls through and goes on
+				// deleting one character, which is the behaviour it must not
+				// break. `isRangeDeleteKey` refuses ctrl+c and ctrl+d outright,
+				// so Pi's interrupt and exit chords can never be swallowed by
+				// this branch.
 				if (rangeDelete && isRangeDeleteKey(data)) {
-					const typedReceiver = receiver as MouseCapablePrototype;
 					if (deleteSelectedRange(typedReceiver, deps.getConfig())) {
 						// Pi's `handleInput` returns as soon as a listener consumes,
 						// so the focused editor never sees the key and Pi never
 						// reaches its own `requestImmediateRender` (`tui.js:620`).
 						// Redrawing the changed draft is this branch's job.
-						state?.clear();
 						typedReceiver.requestRender();
 						return { consume: true };
 					}
@@ -789,47 +711,9 @@ function installCopying(
 
 	return () => {
 		for (const cleanup of cleanups) cleanup();
-		if (activeState === state) activeState = previousState;
 	};
 }
 
-/**
- * Installs `pathAwareWords` on `getWordSelection`.
- *
- * The receiver's own `getSelectionSourceLine` gives the raw line under the
- * point; `stripTerminalSequences` is applied the same way predecessor itself
- * applies it (see `getWordSelection` in
- * `node_modules/@earendil-works/pi-tui/dist/tui-alt-screen.js`), so
- * `wordRangeAt` sees the same plain text Pi's own segmenter would. `col` is
- * the only thing the wrapper changes on the way out — `row`, `scrollView`
- * and any other point field ride through unmodified, which is what keeps a
- * scroll-view selection landing in the right place.
- */
-function installPathAwareWords(
-	prototype: MouseCapablePrototype,
-	deps: InstallMouseDeps,
-): () => void {
-	return installPrototypePatch(
-		prototype,
-		"getWordSelection",
-		"mouse-word-selection",
-		({ predecessor, receiver, args }) => {
-			if (!deps.getConfig().mouse.pathAwareWords) {
-				return Reflect.apply(predecessor, receiver, args);
-			}
-			const typedReceiver = receiver as MouseCapablePrototype;
-			const point = args[0] as SelectionPoint;
-			const line = stripTerminalSequences(typedReceiver.getSelectionSourceLine(point));
-			const range = wordRangeAt(line, point.col);
-			if (!range) return Reflect.apply(predecessor, receiver, args);
-			return {
-				start: { ...point, col: range.start },
-				end: { ...point, col: range.end, boundary: true },
-			};
-		},
-	);
-}
-
 /**
  * A left-button press: not a release, not a drag, not another button.
  *
@@ -1102,16 +986,13 @@ export function installMouse(prototype: object, deps: InstallMouseDeps): () => v
 	// below: `pi-toolbox` publishing which rows it drew a border on, at which
 	// columns, so Starline reads a fact instead of inferring one.
 	if (
-		enabled.has("selectionPendingMode") ||
+		enabled.has("selectionHint") ||
 		enabled.has("editorBufferCopy") ||
 		enabled.has("editorClickToCaret") ||
 		enabled.has("transcriptCleanCopy")
 	) {
 		cleanups.push(installCopying(typedPrototype, deps, enabled));
 	}
-	if (enabled.has("pathAwareWords")) {
-		cleanups.push(installPathAwareWords(typedPrototype, deps));
-	}
 	if (enabled.has("clickToExpandTools") || enabled.has("editorClickToCaret")) {
 		cleanups.push(installSelectionMouse(typedPrototype, deps, enabled));
 	}
@@ -1122,6 +1003,8 @@ export function installMouse(prototype: object, deps: InstallMouseDeps): () => v
 	if (cleanups.length === 0) return () => {};
 	return () => {
 		externalEditorHint = null;
+		activeReceiver = undefined;
+		activeHint = undefined;
 		for (const cleanup of cleanups) cleanup();
 	};
 }

package/extensions/starline/mouse/selection-state.ts

@@ -1,50 +1,28 @@
 import { basename } from "node:path";
 
 /**
- * The one piece of selection state Starline owns.
+ * The selection hint is derived state, not owned state.
  *
- * Pi holds the anchor, the focus and the granularity; this holds only whether a
- * released selection is still waiting to be copied. Keeping it this small is
- * what the 0.2.0 controller could not do, because back then Pi had no selection
- * at all.
+ * Pi 0.84.4 owns "select without copying" (`fullscreenCopyOnSelect`), so
+ * Starline no longer intercepts the release to arm a pending copy — the hint
+ * is computed on demand from the live renderer instead: an active selection
+ * that the renderer is not auto-copying. `selectionHintText` is the pure
+ * rendering of that state; `index.ts` gathers the pieces.
  */
-export class SelectionPendingState {
-	private characters = 0;
-	/**
-	 * `keyText("app.editor.external")`, resolved at arm time, when the pending
-	 * selection is the editor's. Editor selections cannot grow past the visible
-	 * window (there is no drag-scroll), so the hint points at the external
-	 * editor as the way to act on the whole draft.
-	 */
-	private externalEditorKey: string | undefined;
-
-	arm(characters: number, externalEditorKey?: string): void {
-		this.characters = characters > 0 ? characters : 0;
-		this.externalEditorKey = this.characters > 0 ? externalEditorKey : undefined;
-	}
-
-	clear(): void {
-		this.characters = 0;
-		this.externalEditorKey = undefined;
-	}
-
-	get pending(): { characters: number; externalEditorKey?: string } | undefined {
-		return this.characters > 0
-			? { characters: this.characters, externalEditorKey: this.externalEditorKey }
-			: undefined;
-	}
-}
-
 export function selectionHintText(
-	state: SelectionPendingState,
+	characters: number,
+	copyKey: string,
+	externalEditorKey: string | undefined,
 	editorName: string | null = null,
 ): string | null {
-	const pending = state.pending;
-	if (!pending) return null;
-	const noun = pending.characters === 1 ? "character" : "characters";
-	const base = `${pending.characters} ${noun} selected, ctrl+c to copy`;
-	return pending.externalEditorKey
-		? `${base} ⋅ ${pending.externalEditorKey} to edit in ${editorName ?? "$EDITOR"}`
+	if (characters <= 0) return null;
+	const noun = characters === 1 ? "character" : "characters";
+	const base =
+		copyKey.length > 0
+			? `${characters} ${noun} selected, ${copyKey} to copy`
+			: `${characters} ${noun} selected`;
+	return externalEditorKey
+		? `${base} ⋅ ${externalEditorKey} to edit in ${editorName ?? "$EDITOR"}`
 		: base;
 }
 

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

@@ -2,7 +2,7 @@
  * Strips decoration out of a transcript selection before it reaches the
  * clipboard.
  *
- * Pi's `copySelectionToClipboard` copies *rendered* rows. In the transcript
+ * 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

package/extensions/starline/prototype-patch-registry.ts

@@ -18,8 +18,7 @@ type PrototypePatchAdapter =
 	| "mouse-viewport-input"
 	| "mouse-wheel"
 	| "mouse-selection-event"
-	| "mouse-copy"
-	| "mouse-word-selection";
+	| "mouse-copy";
 
 type PrototypeMethodName = string;
 

package/extensions/starline/ui.ts

@@ -143,7 +143,7 @@ function getEditorChromeWidths(config: PolishedTuiConfig, uiTheme: Theme, reset:
  */
 function composeRightStatus(vimStatus: string | undefined, uiTheme: Theme): string | undefined {
 	// A live selection hint already spells the external editor out ("N
-	// characters selected, ctrl+c to copy ⋅ ctrl+g to edit in $EDITOR"), so it
+	// characters selected, ctrl+x to copy ⋅ ctrl+g to edit in $EDITOR"), so it
 	// takes precedence; the always-on hint only speaks when nothing else does.
 	const hint = composeHints(
 		pasteExpandHintText(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xzzpig/pi-starline",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A Starship-inspired statusline and Opencode-style TUI for Pi.",
   "type": "module",
   "license": "MIT",
@@ -23,9 +23,9 @@
     "extensions"
   ],
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.84.0",
-    "@earendil-works/pi-coding-agent": ">=0.84.0",
-    "@earendil-works/pi-tui": ">=0.84.0"
+    "@earendil-works/pi-ai": ">=0.84.4",
+    "@earendil-works/pi-coding-agent": ">=0.84.4",
+    "@earendil-works/pi-tui": ">=0.84.4"
   },
   "pi": {
     "extensions": [
@@ -38,9 +38,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.0",
-    "@earendil-works/pi-ai": "^0.84.2",
-    "@earendil-works/pi-coding-agent": "^0.84.2",
-    "@earendil-works/pi-tui": "^0.84.2",
+    "@earendil-works/pi-ai": "^0.84.4",
+    "@earendil-works/pi-coding-agent": "^0.84.4",
+    "@earendil-works/pi-tui": "^0.84.4",
     "@types/node": "^26.0.0",
     "typescript": "^7.0.2",
     "vitest": "^4.1.8"

package/extensions/starline/mouse/word-select.ts

@@ -1,145 +0,0 @@
-/**
- * Which columns a double click on one line should select.
- *
- * Ported from `getWordSelection` in pi commit `56419be51`
- * (`feat/word-selection-path-chars`, `packages/tui/src/tui-alt-screen.ts`),
- * filed upstream as issue #7746. The installed Pi build's own
- * `getWordSelection` predates that patch, so this substitutes Pi's whole
- * word-selection rule rather than layering path handling on top of it — see
- * `index.ts` for where that substitution happens and why it's the intended
- * scope, not creep.
- *
- * This is a pure function of one already-plain (no ANSI) line and a terminal
- * column; the caller in `index.ts` is what reads Pi's live source line and
- * strips escape sequences before calling in, matching the split
- * `getWordSelection`/`getSelectionSourceLine` already have upstream.
- */
-import { visibleWidth } from "@earendil-works/pi-tui";
-
-const wordSegmenter = new Intl.Segmenter(undefined, { granularity: "word" });
-
-/**
- * Characters that join two words into one for double-click selection.
- *
- * `Intl.Segmenter` already keeps `_` and `.` inside a word, so `foo_bar` and
- * `file.ts` survive on their own. It breaks on `/` and `-`, which is what
- * takes a path or a kebab-case identifier apart. Terminals keep these inside
- * a word so paths and URLs select whole; this set is what makes fullscreen's
- * own double-click agree with them.
- */
-const WORD_JOINERS = new Set(["/", "-"]);
-
-type WordSegment = {
-	start: number;
-	end: number;
-	isWordLike: boolean;
-	isJoiner: boolean;
-	isSpace: boolean;
-};
-
-/** `segments[index]`, guaranteed — every call site here only ever passes an index it just found in range. */
-function segmentAt(segments: readonly WordSegment[], index: number): WordSegment {
-	const segment = segments[index];
-	if (segment === undefined) {
-		throw new RangeError(`word-select: no segment at index ${index}`);
-	}
-	return segment;
-}
-
-function collectWordSegments(line: string): WordSegment[] {
-	const segments: WordSegment[] = [];
-	let start = 0;
-	for (const segment of wordSegmenter.segment(line)) {
-		const text = segment.segment;
-		const end = start + visibleWidth(text);
-		segments.push({
-			start,
-			end,
-			isWordLike: segment.isWordLike === true,
-			// Joiners arrive one per segment, so `//` in a URL is two of these.
-			isJoiner: text.length > 0 && [...text].every((char) => WORD_JOINERS.has(char)),
-			isSpace: text.length > 0 && text.trim().length === 0,
-		});
-		start = end;
-	}
-	return segments;
-}
-
-/**
- * Walk back over a run of joiners that opens a word, as in `/usr` or `--flag`.
- *
- * The run only counts as part of the word when nothing but whitespace
- * precedes it, which is what separates a leading separator from an infix one.
- * In `http://a.com` the `//` is preceded by `:`, so the scheme stays out.
- */
-function openingJoinerRun(segments: WordSegment[], first: number): number {
-	let index = first;
-	while (segments[index - 1]?.isJoiner) index--;
-	if (index === first) return first;
-	const before = segments[index - 1];
-	return before === undefined || before.isSpace ? index : first;
-}
-
-/**
- * Grow a word segment across joiners that have a word on both sides, plus any
- * separator run that opens it.
- *
- * Anchoring on word-like segments is what keeps this conservative: in
- * `http://a.com/b` the `:` is not a joiner, so the run stops there instead of
- * swallowing the scheme, and a dash used as prose punctuation in `a - b` has
- * whitespace around it rather than a word.
- */
-function expandOverWordJoiners(
-	segments: WordSegment[],
-	index: number,
-): { start: number; end: number } {
-	const anchor = segmentAt(segments, index);
-	if (anchor.isJoiner) {
-		// Clicking a separator should take the word it belongs to. Prefer the
-		// word on the left so an infix `/` grows the whole path; failing that,
-		// step over the run to the word it opens, so clicking the `/` of
-		// `/usr/bin` works.
-		if (segments[index - 1]?.isWordLike && segments[index + 1]?.isWordLike) {
-			return expandOverWordJoiners(segments, index - 1);
-		}
-		if (!segments[index - 1]?.isWordLike) {
-			let next = index;
-			while (segments[next]?.isJoiner) next++;
-			if (segments[next]?.isWordLike) return expandOverWordJoiners(segments, next);
-		}
-	}
-	if (!anchor.isWordLike) return { start: anchor.start, end: anchor.end };
-
-	let first = index;
-	while (first >= 2 && segments[first - 1]?.isJoiner && segments[first - 2]?.isWordLike) {
-		first -= 2;
-	}
-	first = openingJoinerRun(segments, first);
-	// A trailing run gets no such treatment: nothing follows it to make it
-	// part of the word, and `trailing- x` reading as `trailing-` would be
-	// wrong.
-	let last = index;
-	while (segments[last + 1]?.isJoiner && segments[last + 2]?.isWordLike) {
-		last += 2;
-	}
-	return { start: segmentAt(segments, first).start, end: segmentAt(segments, last).end };
-}
-
-/**
- * The column range a double click at `column` on `line` should select, in
- * the same column units as Pi's own `SelectionRange`. `undefined` when
- * `column` lands past the end of the line — the caller calls through to Pi's
- * own selection in that case rather than inventing a range.
- */
-export function wordRangeAt(
-	line: string,
-	column: number,
-): { start: number; end: number } | undefined {
-	const segments = collectWordSegments(line);
-	for (let index = 0; index < segments.length; index++) {
-		const segment = segmentAt(segments, index);
-		if (column < segment.start || column >= segment.end) continue;
-		return expandOverWordJoiners(segments, index);
-	}
-	return undefined;
-}