@north-light/crouter 0.3.177 → 0.3.179

package/dist/clients/attach/__tests__/frame-selection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/frame-selection.test.js

@@ -0,0 +1,84 @@
+// Mouse drag-select copies out of the PHYSICAL frame rows, which carry SGR
+// color, OSC-8 link boundaries, pi-tui's APC cursor marker, and wide glyphs. A
+// column is a terminal cell, never a string index — get that wrong and the copy
+// silently slices mid-escape or off-by-N, with the highlight still looking right
+// on screen.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { highlightCells, rowCells, sliceCells } from '../ansi-cells.js';
+import { createFrameSelection } from '../session/selection.js';
+const CURSOR_MARKER = '\x1b_pi-cursor\x1b\\';
+const LINK = (uri, text) => `\x1b]8;;${uri}\x07${text}\x1b]8;;\x07`;
+test('cells are counted as the terminal counts them', () => {
+    assert.equal(rowCells('plain'), 5);
+    assert.equal(rowCells('\x1b[31mred\x1b[0m'), 3);
+    assert.equal(rowCells(LINK('file:///tmp/a.ts', 'a.ts')), 4);
+    assert.equal(rowCells(`ab${CURSOR_MARKER}cd`), 4);
+    assert.equal(rowCells('日本'), 4);
+});
+test('a slice returns the plain text under those cells', () => {
+    assert.equal(sliceCells('\x1b[31mhello\x1b[0m world', 0, 5), 'hello');
+    assert.equal(sliceCells('\x1b[31mhello\x1b[0m world', 6, 11), 'world');
+    assert.equal(sliceCells(`src/${LINK('file:///tmp/a.ts', 'a.ts')}:12`, 0, 8), 'src/a.ts');
+    assert.equal(sliceCells(`ab${CURSOR_MARKER}cd`, 0, 4), 'abcd');
+    // A wide glyph belongs to the cell it starts at and is never split in half.
+    assert.equal(sliceCells('日本語', 2, 4), '本');
+});
+test('highlighting restyles without changing what the row says', () => {
+    const row = '\x1b[31mhello\x1b[0m world';
+    const painted = highlightCells(row, 0, 5, 80);
+    assert.equal(sliceCells(painted, 0, rowCells(row)), 'hello world');
+    assert.equal(rowCells(painted), rowCells(row));
+    assert.ok(painted.includes('\x1b[7m'));
+    // A reset inside the span would drop the highlight, so inverse is re-asserted.
+    assert.equal(highlightCells(row, 0, 11, 80).split('\x1b[7m').length - 1, 2);
+});
+test('the cursor marker survives a highlight that starts on its cell', () => {
+    const painted = highlightCells(`ab${CURSOR_MARKER}cd`, 2, 4, 80);
+    assert.ok(painted.includes(CURSOR_MARKER));
+    assert.equal(sliceCells(painted, 0, 4), 'abcd');
+});
+test('a short row pads so a multi-row selection reads as one block, never past the pane', () => {
+    assert.equal(rowCells(highlightCells('ab', 0, 6, 80)), 6);
+    // Padding past the pane width would wrap the row and break the frame's row count.
+    assert.equal(rowCells(highlightCells('ab', 0, 6, 4)), 4);
+});
+test('a press that never moves stays a click, so file links still open', () => {
+    const selection = createFrameSelection({ frame: () => ['src/a.ts'], width: () => 40 });
+    selection.begin(3, 1);
+    assert.deepEqual(selection.release(), { kind: 'click', column: 3, row: 1 });
+    assert.equal(selection.active(), false);
+});
+test('a drag across rows selects terminal-style: to the edge, then whole rows', () => {
+    const frame = ['first row', '\x1b[32msecond row\x1b[0m', 'third row'];
+    const selection = createFrameSelection({ frame: () => frame, width: () => 40 });
+    selection.begin(7, 1);
+    assert.equal(selection.extend(5, 3), true);
+    // Same cell twice is not a change — no wasted render.
+    assert.equal(selection.extend(5, 3), false);
+    const painted = selection.apply(frame);
+    assert.equal(painted.length, 3);
+    assert.ok(painted[0].includes('\x1b[7m'));
+    assert.equal(sliceCells(painted[1], 0, rowCells(frame[1])), 'second row');
+    assert.equal(selection.active(), true);
+    assert.equal(selection.clear(), true);
+    assert.equal(selection.active(), false);
+});
+test('a backwards drag selects the same span as a forwards one', () => {
+    const frame = ['abcdef', 'ghijkl'];
+    const forwards = createFrameSelection({ frame: () => frame, width: () => 6 });
+    forwards.begin(3, 1);
+    forwards.extend(4, 2);
+    const backwards = createFrameSelection({ frame: () => frame, width: () => 6 });
+    backwards.begin(4, 2);
+    backwards.extend(3, 1);
+    assert.deepEqual(backwards.apply(frame), forwards.apply(frame));
+});
+test('an empty drag over blank rows reports nothing to copy', () => {
+    // Releasing over content would shell out to the clipboard; blank rows settle
+    // the geometry without leaving the process.
+    const selection = createFrameSelection({ frame: () => ['', '', ''], width: () => 40 });
+    selection.begin(2, 1);
+    selection.extend(5, 3);
+    assert.deepEqual(selection.release(), { kind: 'selection', notice: 'Nothing to copy — selection is empty' });
+});

package/dist/clients/attach/ansi-cells.d.ts

@@ -0,0 +1,31 @@
+/** Read one terminal control sequence so non-printing ANSI never takes a cell.
+ *  `undefined` means the sequence runs off the end of the row. */
+export declare function readEscape(line: string, start: number): {
+    text: string;
+    end: number;
+} | undefined;
+/** One printable grapheme, with the escape sequences that preceded it. */
+export type RowGlyph = {
+    /** The grapheme itself, with no ANSI attached. */
+    text: string;
+    /** 0-indexed terminal cell this grapheme starts at. */
+    cell: number;
+    /** Cells occupied — 2 for a wide grapheme, 0 for a zero-width one. */
+    width: number;
+};
+/** Walk `line` as the terminal does, calling `onGlyph` per printable grapheme
+ *  and `onEscape` per control sequence, in row order. Returns the cell count. */
+export declare function walkRow(line: string, visit: {
+    onGlyph?: (glyph: RowGlyph) => void;
+    onEscape?: (escape: string) => void;
+}): number;
+/** Cells the row occupies on screen. */
+export declare function rowCells(line: string): number;
+/** Plain text of cells `[from, to)` — every escape, link boundary, and cursor
+ *  marker dropped, exactly what a terminal copies out of that span. */
+export declare function sliceCells(line: string, from: number, to: number): string;
+/** Reverse-video cells `[from, to)`, re-asserting inverse after any SGR inside
+ *  the span (a reset there would otherwise drop the highlight mid-selection).
+ *  A short row is padded with spaces so a multi-row selection reads as one
+ *  block, never past `maxCells`. */
+export declare function highlightCells(line: string, from: number, to: number, maxCells: number): string;

package/dist/clients/attach/ansi-cells.js

@@ -0,0 +1,120 @@
+// ansi-cells.ts — cell arithmetic over a rendered terminal row.
+//
+// A composed frame row mixes printable graphemes with SGR colors, OSC-8 link
+// boundaries, and pi-tui's APC cursor marker. Anything that addresses a row by
+// terminal column — link hit tests, mouse selection — has to walk it the way the
+// terminal does: escapes take no cell, wide graphemes take two. Both the attach
+// session and the renderers need that walk, so it lives at the client root
+// rather than inside either peer.
+import stringWidth from 'string-width';
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+const INVERSE_ON = '\x1b[7m';
+const INVERSE_OFF = '\x1b[27m';
+/** Read one terminal control sequence so non-printing ANSI never takes a cell.
+ *  `undefined` means the sequence runs off the end of the row. */
+export function readEscape(line, start) {
+    const kind = line[start + 1];
+    if (kind === undefined)
+        return undefined;
+    // OSC, APC, DCS, and PM are string controls terminated by BEL or ST. pi-tui's
+    // cursor marker uses APC, so it must consume no display cells here.
+    if (kind === ']' || kind === '_' || kind === 'P' || kind === '^') {
+        const bel = line.indexOf('\x07', start + 2);
+        const st = line.indexOf('\x1b\\', start + 2);
+        const end = bel === -1 ? st : st === -1 ? bel : Math.min(bel, st);
+        if (end === -1)
+            return undefined;
+        return { text: line.slice(start, end + (end === bel ? 1 : 2)), end: end + (end === bel ? 1 : 2) };
+    }
+    if (kind === '[') {
+        let end = start + 2;
+        while (end < line.length && (line.charCodeAt(end) < 0x40 || line.charCodeAt(end) > 0x7e))
+            end++;
+        if (end >= line.length)
+            return undefined;
+        return { text: line.slice(start, end + 1), end: end + 1 };
+    }
+    return { text: line.slice(start, start + 2), end: start + 2 };
+}
+/** Walk `line` as the terminal does, calling `onGlyph` per printable grapheme
+ *  and `onEscape` per control sequence, in row order. Returns the cell count. */
+export function walkRow(line, visit) {
+    let cell = 0;
+    let index = 0;
+    while (index < line.length) {
+        if (line[index] === '\x1b') {
+            const escape = readEscape(line, index);
+            if (escape === undefined)
+                break;
+            visit.onEscape?.(escape.text);
+            index = escape.end;
+            continue;
+        }
+        const nextEscape = line.indexOf('\x1b', index);
+        const text = line.slice(index, nextEscape === -1 ? undefined : nextEscape);
+        for (const segment of GRAPHEMES.segment(text)) {
+            const width = stringWidth(segment.segment);
+            visit.onGlyph?.({ text: segment.segment, cell, width });
+            cell += width;
+        }
+        index = nextEscape === -1 ? line.length : nextEscape;
+    }
+    return cell;
+}
+/** Cells the row occupies on screen. */
+export function rowCells(line) {
+    return walkRow(line, {});
+}
+/** Plain text of cells `[from, to)` — every escape, link boundary, and cursor
+ *  marker dropped, exactly what a terminal copies out of that span. */
+export function sliceCells(line, from, to) {
+    let text = '';
+    walkRow(line, {
+        onGlyph: (glyph) => {
+            if (glyph.cell >= from && glyph.cell < to)
+                text += glyph.text;
+        },
+    });
+    return text;
+}
+/** Reverse-video cells `[from, to)`, re-asserting inverse after any SGR inside
+ *  the span (a reset there would otherwise drop the highlight mid-selection).
+ *  A short row is padded with spaces so a multi-row selection reads as one
+ *  block, never past `maxCells`. */
+export function highlightCells(line, from, to, maxCells) {
+    const end = Math.min(to, maxCells);
+    if (end <= from || from < 0)
+        return line;
+    let out = '';
+    let inside = false;
+    const open = () => { if (!inside) {
+        out += INVERSE_ON;
+        inside = true;
+    } };
+    const close = () => { if (inside) {
+        out += INVERSE_OFF;
+        inside = false;
+    } };
+    const cells = walkRow(line, {
+        onEscape: (escape) => {
+            out += escape;
+            // An SGR inside the span may have reset every attribute, including ours.
+            if (inside && escape.endsWith('m'))
+                out += INVERSE_ON;
+        },
+        onGlyph: (glyph) => {
+            if (glyph.cell >= from && glyph.cell < end)
+                open();
+            else
+                close();
+            out += glyph.text;
+        },
+    });
+    close();
+    if (cells < end) {
+        const gap = Math.max(0, from - cells);
+        const highlighted = end - Math.max(from, cells);
+        out += ' '.repeat(gap) + INVERSE_ON + ' '.repeat(highlighted) + INVERSE_OFF;
+    }
+    return out;
+}

package/dist/clients/attach/overlays/help.js

@@ -135,6 +135,7 @@ export class HelpOverlay {
             muted('mouse wheel (when reporting is on)'),
             blank,
             heading('Selection and copy'),
+            { text: 'Drag with the mouse to select; releasing copies the selection to the clipboard (and the tmux buffer). Any key clears the highlight.', style: 'plain' },
             { text: 'prefix + [  tmux copy-mode selects and copies the visible screenful; it works even while mouse reporting is on.', style: 'plain' },
             { text: 'Option-drag (iTerm2, Terminal.app) or Shift-drag (Ghostty, Alacritty, xterm) makes a true terminal selection that bypasses mouse reporting.', style: 'plain' },
             { text: 'Block-copy commands copy transcript content and are not capped at one screenful.', style: 'plain' },
@@ -146,7 +147,7 @@ export class HelpOverlay {
             { text: "/copy-transcript  every copyable block's text, oldest to newest, joined by blank lines.", style: 'plain' },
             blank,
             heading('Mouse'),
-            { text: `/mouse or ${this.binding('crtr.attach.mouse.toggle')}  toggle mouse wheel scrolling. Turning it off restores tmux drag-select and copy-mode mouse.`, style: 'plain' },
+            { text: `/mouse or ${this.binding('crtr.attach.mouse.toggle')}  toggle mouse reporting — wheel scrolling and viewer drag-select. Turning it off restores tmux drag-select and copy-mode mouse.`, style: 'plain' },
             blank,
             heading('Other attach keys'),
             ...otherKeys,

package/dist/clients/attach/session/file-links.js

@@ -5,9 +5,8 @@
 // and OSC-8 boundaries have all already been composed there.
 import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import stringWidth from 'string-width';
+import { walkRow } from '../ansi-cells.js';
 import { respawnPaneInBackground, shellQuote, viewerSplitEnv } from '../../../core/runtime/placement-tmux.js';
-const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 /** URI of the OSC-8 hyperlink occupying the given 1-indexed terminal cell. */
 export function osc8UriAt(frame, row, column) {
     if (!Number.isInteger(row) || !Number.isInteger(column) || row < 1 || column < 1)
@@ -24,56 +23,22 @@ export function osc8UriAt(frame, row, column) {
 }
 function scanOsc8Row(line, initialUri, hitColumn) {
     let activeUri = initialUri;
-    let cell = 1;
-    let index = 0;
-    while (index < line.length) {
-        if (line[index] === '\x1b') {
-            const escape = readEscape(line, index);
-            if (escape === undefined)
-                break;
-            const osc8 = parseOsc8(escape.text);
+    let uri;
+    walkRow(line, {
+        onEscape: (escape) => {
+            const osc8 = parseOsc8(escape);
             if (osc8 !== null)
                 activeUri = osc8 === '' ? undefined : osc8;
-            index = escape.end;
-            continue;
-        }
-        const nextEscape = line.indexOf('\x1b', index);
-        const text = line.slice(index, nextEscape === -1 ? undefined : nextEscape);
-        for (const segment of GRAPHEMES.segment(text)) {
-            const width = stringWidth(segment.segment);
-            if (hitColumn !== undefined && width > 0 && hitColumn >= cell && hitColumn < cell + width && activeUri !== undefined) {
-                return { activeUri, uri: activeUri };
-            }
-            cell += width;
-        }
-        index = nextEscape === -1 ? line.length : nextEscape;
-    }
-    return { activeUri, uri: undefined };
-}
-/** Read one terminal control sequence so non-printing ANSI never takes a cell. */
-function readEscape(line, start) {
-    const kind = line[start + 1];
-    if (kind === undefined)
-        return undefined;
-    // OSC, APC, DCS, and PM are string controls terminated by BEL or ST. pi-tui's
-    // cursor marker uses APC, so it must consume no display cells here.
-    if (kind === ']' || kind === '_' || kind === 'P' || kind === '^') {
-        const bel = line.indexOf('\x07', start + 2);
-        const st = line.indexOf('\x1b\\', start + 2);
-        const end = bel === -1 ? st : st === -1 ? bel : Math.min(bel, st);
-        if (end === -1)
-            return undefined;
-        return { text: line.slice(start, end + (end === bel ? 1 : 2)), end: end + (end === bel ? 1 : 2) };
-    }
-    if (kind === '[') {
-        let end = start + 2;
-        while (end < line.length && (line.charCodeAt(end) < 0x40 || line.charCodeAt(end) > 0x7e))
-            end++;
-        if (end >= line.length)
-            return undefined;
-        return { text: line.slice(start, end + 1), end: end + 1 };
-    }
-    return { text: line.slice(start, start + 2), end: start + 2 };
+        },
+        onGlyph: (glyph) => {
+            if (uri !== undefined || hitColumn === undefined || activeUri === undefined || glyph.width === 0)
+                return;
+            const cell = hitColumn - 1;
+            if (cell >= glyph.cell && cell < glyph.cell + glyph.width)
+                uri = activeUri;
+        },
+    });
+    return { activeUri, uri };
 }
 /** `null` means another escape sequence; an empty URI closes the active link. */
 function parseOsc8(sequence) {

package/dist/clients/attach/session/frame.d.ts

@@ -25,9 +25,13 @@ export declare class ViewerFrame implements Component {
     private readonly parts;
     private viewportRows;
     private lastFrame;
+    private overlay;
     constructor(terminal: Terminal, parts: ViewerFrameParts);
     render(width: number): string[];
-    /** The physical rows returned by the most recent render. */
+    /** Paint attributes over the composed frame — mouse selection highlight. The
+     *  overlay may restyle rows but must return the same number of them. */
+    setOverlay(overlay: (frame: readonly string[]) => string[]): void;
+    /** The physical rows returned by the most recent render, before any overlay. */
     lastRenderedFrame(): readonly string[];
     invalidate(): void;
     /** Rows the transcript viewport got in the last frame — the page size. */

package/dist/clients/attach/session/frame.js

@@ -56,6 +56,7 @@ export class ViewerFrame {
     parts;
     viewportRows = 0;
     lastFrame = [];
+    overlay;
     constructor(terminal, parts) {
         this.terminal = terminal;
         this.parts = parts;
@@ -117,12 +118,26 @@ export class ViewerFrame {
         if (frame.length !== rows)
             reportInvariant(`frame correction rendered ${frame.length} rows; expected ${rows}`);
         const finalFrame = this.ensureCursorMarker(frame, editorLines, editorSlice, editorBottomOffset, bottomLines.length, rows);
-        // This is the exact physical screen content used for OSC-8 mouse hit tests.
-        // Keep a copy because terminal rendering is allowed to retain the returned array.
+        // This is the exact physical screen content used for OSC-8 mouse hit tests
+        // and for the text a mouse selection copies, so it is kept BEFORE the
+        // overlay paints attributes over it. Keep a copy because terminal rendering
+        // is allowed to retain the returned array.
         this.lastFrame = finalFrame.slice();
-        return finalFrame;
+        if (this.overlay === undefined)
+            return finalFrame;
+        const painted = this.overlay(finalFrame);
+        if (painted.length !== finalFrame.length) {
+            reportInvariant(`frame overlay returned ${painted.length} rows; expected ${finalFrame.length}`);
+            return finalFrame;
+        }
+        return painted;
+    }
+    /** Paint attributes over the composed frame — mouse selection highlight. The
+     *  overlay may restyle rows but must return the same number of them. */
+    setOverlay(overlay) {
+        this.overlay = overlay;
     }
-    /** The physical rows returned by the most recent render. */
+    /** The physical rows returned by the most recent render, before any overlay. */
     lastRenderedFrame() {
         return this.lastFrame;
     }

package/dist/clients/attach/session/input-wiring.js

@@ -70,7 +70,7 @@ export function createInputController(ctx, km, capabilities, hooks) {
         onCopyTarget: hooks.copyTarget,
         onToggleMouse: () => {
             const on = hooks.toggleMouse();
-            setNotice(on ? 'Mouse: wheel scrolling on' : 'Mouse: off — tmux drag-select and copy-mode restored');
+            setNotice(on ? 'Mouse: wheel scrolling on, drag to select and copy' : 'Mouse: off — tmux drag-select and copy-mode restored');
         },
         onColor: hooks.setChipColor,
         onPromptSent: hooks.onPromptSent,

package/dist/clients/attach/session/mouse.d.ts

@@ -18,6 +18,10 @@ export interface MouseHandlers {
     onWheel(direction: 'up' | 'down', lines: number, column: number): void;
     /** A primary-button press with no Shift, Alt, or Control modifier. */
     onPrimaryPress(column: number, row: number): void;
+    /** Pointer motion with the primary button held. */
+    onPrimaryDrag(column: number, row: number): void;
+    /** The primary button came back up, wherever the pointer ended. */
+    onPrimaryRelease(column: number, row: number): void;
 }
 /** Create per-viewer mouse reporting from the user's saved starting mode. */
 export declare function createMouseReporting(write: (data: string) => void, defaultMode: MouseModeDefault): MouseReporting;

package/dist/clients/attach/session/mouse.js

@@ -3,7 +3,12 @@
 // Mouse reporting starts from the user's configured default. Follow-tmux mode
 // leaves native terminal selection alone when tmux mouse is off; inside a
 // reporting viewer, every mouse sequence is consumed so clicks and drags can
-// never become editor input.
+// never become editor input — which is why the viewer, not the terminal, owns
+// drag-select while reporting is on (session/selection.ts).
+//
+// Mode 1002 is button-event tracking: press, motion while a button is held, and
+// release. Those three are exactly the gesture parts a selection needs, so the
+// drag is reconstructed here and reported as press · drag · release.
 import { spawnSync } from 'node:child_process';
 import { inTmux } from '../../../core/runtime/placement-tmux.js';
 const MOUSE_REPORTING_ON = '\x1b[?1002h\x1b[?1006h';
@@ -46,12 +51,18 @@ export function createMouseReporting(write, defaultMode) {
             const withoutSgr = data.replace(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g, (_match, buttons, column, row, action) => {
                 consumed = true;
                 const code = Number(buttons);
+                // Bits 4/8/16 are Shift/Meta/Control; bit 32 is the motion flag, which
+                // must survive the mask so a drag is distinguishable from a press.
                 const button = code & ~(4 | 8 | 16);
                 if (button === 64)
                     handlers.onWheel('up', WHEEL_LINES, Number(column));
-                if (button === 65)
+                else if (button === 65)
                     handlers.onWheel('down', WHEEL_LINES, Number(column));
-                if (code === 0 && action === 'M')
+                else if (button === 32 && action === 'M')
+                    handlers.onPrimaryDrag(Number(column), Number(row));
+                else if (button === 0 && action === 'm')
+                    handlers.onPrimaryRelease(Number(column), Number(row));
+                else if (code === 0 && action === 'M')
                     handlers.onPrimaryPress(Number(column), Number(row));
                 return '';
             });

package/dist/clients/attach/session/selection.d.ts

@@ -0,0 +1,28 @@
+export type SelectionRelease = {
+    kind: 'click';
+    column: number;
+    row: number;
+} | {
+    kind: 'selection';
+    notice: string;
+};
+export interface FrameSelection {
+    /** Primary button pressed: anchor here and drop any previous highlight. */
+    begin(column: number, row: number): void;
+    /** Drag to a new cell. Returns true when the highlight changed. */
+    extend(column: number, row: number): boolean;
+    /** Primary button released. `click` means the press never moved, so the
+     *  caller's click handling (file links) still owns the gesture. */
+    release(): SelectionRelease | undefined;
+    /** Drop the highlight. Returns true when something was showing. */
+    clear(): boolean;
+    /** A highlight is on screen. */
+    active(): boolean;
+    /** Paint the highlight onto a composed frame; identity when nothing is selected. */
+    apply(frame: readonly string[]): string[];
+}
+export declare function createFrameSelection(deps: {
+    /** The physical rows of the last render, unhighlighted. */
+    frame: () => readonly string[];
+    width: () => number;
+}): FrameSelection;

package/dist/clients/attach/session/selection.js

@@ -0,0 +1,108 @@
+// session/selection.ts — mouse drag-select and copy over the rendered frame.
+//
+// While the viewer reports mouse events, the terminal hands presses and drags to
+// this process, so the terminal's own drag-select is unavailable: the viewer has
+// to do the selecting. It selects the way a terminal does — over the physical
+// rows last handed to the screen, not over transcript records — so wrapping,
+// folds, the pinned header, and the cockpit all select exactly as they look.
+// Releasing the button copies the selection to the clipboard (and, in tmux, the
+// paste buffer); the highlight stays up as confirmation until the next keypress,
+// wheel notch, or press.
+import { highlightCells, sliceCells } from '../ansi-cells.js';
+import { writeClipboardTextEverywhere } from '../../../core/clipboard-text.js';
+function before(a, b) {
+    return a.row < b.row || (a.row === b.row && a.column <= b.column);
+}
+/** The per-row cell ranges covered by a drag, in terminal selection geometry:
+ *  the first row runs to the pane edge, whole rows in between, the last row up
+ *  to and including the cell under the pointer. */
+function spans(anchor, head, width) {
+    const [start, end] = before(anchor, head) ? [anchor, head] : [head, anchor];
+    const rows = [];
+    for (let row = start.row; row <= end.row; row++) {
+        const from = row === start.row ? start.column - 1 : 0;
+        const to = row === end.row ? end.column : width;
+        if (to > from)
+            rows.push({ row, from, to });
+    }
+    return rows;
+}
+export function createFrameSelection(deps) {
+    let anchor;
+    let head;
+    const selected = () => anchor !== undefined && head !== undefined ? { anchor, head } : undefined;
+    const selectionText = () => {
+        const current = selected();
+        if (!current)
+            return '';
+        const frame = deps.frame();
+        const rows = spans(current.anchor, current.head, deps.width())
+            .map((span) => sliceCells(frame[span.row - 1] ?? '', span.from, span.to).trimEnd());
+        // A trailing blank row is an artifact of where the button came up; leading
+        // blanks inside the span are real content the user dragged across.
+        while (rows.length > 0 && rows[rows.length - 1] === '')
+            rows.pop();
+        return rows.join('\n');
+    };
+    return {
+        begin(column, row) {
+            anchor = { row, column };
+            head = undefined;
+        },
+        extend(column, row) {
+            if (anchor === undefined)
+                return false;
+            if (head !== undefined && head.row === row && head.column === column)
+                return false;
+            head = { row, column };
+            return true;
+        },
+        release() {
+            const press = anchor;
+            if (press === undefined)
+                return undefined;
+            if (head === undefined) {
+                anchor = undefined;
+                return { kind: 'click', column: press.column, row: press.row };
+            }
+            const text = selectionText();
+            if (text === '') {
+                anchor = undefined;
+                head = undefined;
+                return { kind: 'selection', notice: 'Nothing to copy — selection is empty' };
+            }
+            const { system, tmux } = writeClipboardTextEverywhere(text);
+            const destination = system && tmux ? 'clipboard + tmux buffer' : system ? 'clipboard' : tmux ? 'tmux buffer' : undefined;
+            const lines = text.split('\n').length;
+            return {
+                kind: 'selection',
+                notice: destination === undefined
+                    ? 'Copy failed — no clipboard tool found'
+                    : `Copied selection (${lines} ${lines === 1 ? 'line' : 'lines'}) — ${destination}`,
+            };
+        },
+        clear() {
+            const showing = head !== undefined;
+            anchor = undefined;
+            head = undefined;
+            return showing;
+        },
+        active() {
+            return head !== undefined;
+        },
+        apply(frame) {
+            const current = selected();
+            if (!current)
+                return frame.slice();
+            const width = deps.width();
+            const painted = frame.slice();
+            for (const span of spans(current.anchor, current.head, width)) {
+                const index = span.row - 1;
+                if (index < 0 || index >= painted.length)
+                    continue;
+                painted[index] = highlightCells(painted[index], span.from, span.to, width);
+            }
+            return painted;
+        },
+    };
+}

package/dist/clients/attach/slash/dispatch.js

@@ -44,7 +44,7 @@ export const CANVAS_SLASH_COMMANDS = [
     { name: 'mcp', description: 'MCP servers — status from the adapter’s config/cache; Enter (or /mcp <server>) connects, reconnects, or re-auths' },
     { name: 'rename', description: 'Rename this node everywhere — node row, viewer window, session chip, tmux pane: /rename <name>' },
     { name: 'color', description: 'Color this node — tmux pane outline + name chip: /color <color> (red, blue, #rrggbb, …) or /color none' },
-    { name: 'mouse', description: 'Toggle mouse wheel scrolling — off restores tmux drag-select and copy-mode mouse' },
+    { name: 'mouse', description: 'Toggle mouse wheel scrolling and drag-select — off restores tmux drag-select and copy-mode mouse' },
     { name: 'copy-message', description: 'Copy the newest message visible in the transcript viewport' },
     { name: 'copy-tool', description: 'Copy the newest tool call output' },
     { name: 'copy-transcript', description: 'Copy every copyable transcript block' },