poly-weaver 0.12.2 → 0.12.4

package/dist/terminal/host.js

@@ -1,18 +1,24 @@
-import { ALT_SCREEN_OFF, ALT_SCREEN_ON, BEGIN_SYNC_UPDATE, CLEAR_SCREEN, CURSOR_HOME, END_SYNC_UPDATE, HIDE_CURSOR, MOUSE_OFF, QUERY_SYNC_UPDATE, RESET_SCROLL_REGION, SHOW_CURSOR, padOrClip, } from "../ansi.js";
+import { ALT_SCREEN_OFF, ALT_SCREEN_ON, BEGIN_SYNC_UPDATE, CLEAR_SCREEN, CURSOR_HOME, END_SYNC_UPDATE, HIDE_CURSOR, MOUSE_OFF, QUERY_SYNC_UPDATE, RESET_SCROLL_REGION, SHOW_CURSOR, applySelectionBackgroundRange, padOrClip, } from "../ansi.js";
 import { computeTerminalLayout } from "./layout.js";
 import { VirtualTerminal } from "./virtual-terminal.js";
-import { renderChildViewportRows, renderViewportLines, renderStatusRowBody, shouldShowVtCursor, } from "./render.js";
+import { composeAbsoluteRow, renderChildViewportRows, renderViewportLines, renderStatusRowBody, shouldShowVtCursor, } from "./render.js";
 import { BufferOrchestrationOutput, formatOrchestrationMessage, } from "./output.js";
-import { InputRouter, } from "./input-router.js";
+import { InputRouter, parseSgrMouseFrame, } from "./input-router.js";
 import { createKeyEventSource } from "./key-event-source.js";
 import { ChildKittyNegotiator } from "./kitty-negotiator.js";
 import { MouseModeReconciler, MouseModeTracker, } from "./mouse-mode-tracker.js";
 import { buildOsc52Forward } from "./osc52.js";
+import { copyToClipboard } from "./clipboard-write.js";
+import { Selection, } from "./selection.js";
 import { buildSplitSurface, buildVerticalStackSurface, computeSplitMetrics, SPLIT_COLLAPSE_AT_COLS, } from "../user/split-surface.js";
 const MAIN_CHILD_MOUSE_SOURCE = "main-child";
 const HOST_MOUSE_SOURCE = "host-owned";
 const AGENT_SPLIT_MOUSE_SOURCE = "agent-split";
-const HOST_MOUSE_CAPTURE_MODES = [1000, 1006];
+const HOST_MOUSE_CAPTURE_MODES = [1002, 1006];
+const MULTI_CLICK_MS = 500;
+const DRAG_SCROLL_INTERVAL_MS = 50;
+const DRAG_SCROLL_LINES = 1;
+const DRAG_EDGE_LOSS_MS = 80;
 /**
  * Parent-owned orchestration terminal host.
  *
@@ -38,6 +44,12 @@ export class TerminalHost {
     router;
     bufferOutput;
     onDump;
+    clipboardCopy;
+    now;
+    setIntervalFn;
+    clearIntervalFn;
+    setTimeoutFn;
+    clearTimeoutFn;
     interruptListeners = new Set();
     statusBar;
     childHandle;
@@ -80,6 +92,15 @@ export class TerminalHost {
     externalChildStatus;
     syncOutputSupported = false;
     lastFrameRows = null;
+    lastBaseRows = null;
+    selection = new Selection();
+    gestureOwner = "none";
+    lastClickTime = 0;
+    lastClickCell;
+    clickCount = 0;
+    dragScroll;
+    dragScrollTimer;
+    dragEdgeIntent;
     constructor(opts = {}) {
         this.stdin = opts.stdin ?? process.stdin;
         this.stdout = opts.stdout ?? process.stdout;
@@ -92,6 +113,16 @@ export class TerminalHost {
         this.bufferOutput.setOnChange(() => this.handleOutputChange());
         this.onDump = opts.onDump;
         this.injectedSource = opts.keyEventSource;
+        this.clipboardCopy = opts.copyToClipboard ?? copyToClipboard;
+        this.now = opts.now ?? Date.now;
+        this.setIntervalFn = opts.setIntervalFn ?? setInterval;
+        this.clearIntervalFn = opts.clearIntervalFn ?? clearInterval;
+        this.setTimeoutFn = opts.setTimeoutFn ?? setTimeout;
+        this.clearTimeoutFn = opts.clearTimeoutFn ?? clearTimeout;
+        const selectionCollaborator = {
+            hasSelection: () => this.hasSelection(),
+            handleEvent: (ev) => this.handleSelectionInput(ev),
+        };
         this.router = new InputRouter({
             onDump: opts.onDump,
             onInterrupt: () => this.fireInterrupt(),
@@ -102,8 +133,10 @@ export class TerminalHost {
             onScrollToBottom: () => this.handleScrollToBottom(),
             isChildAlternate: () => this.vt?.isAlternate === true,
             isChildMouseActive: () => this.childMouseTracker.hasActiveReportingMode(),
+            childWantsMotion: () => this.childMouseTracker.wantsMotion(),
             getChildKittyFlags: () => this.kittyNegotiator.activeFlags,
             getChildBracketedPaste: () => this.vt?.bracketedPaste === true,
+            selection: selectionCollaborator,
             onSyncOutputReport: (supported) => {
                 this.syncOutputSupported = supported;
             },
@@ -172,6 +205,7 @@ export class TerminalHost {
     openAgentSplit(pane) {
         if (!this.hasAttachedChild())
             return;
+        this.clearSelection({ schedule: false });
         const state = this.agentSplit ?? { pane: undefined, open: false, collaborator: undefined };
         state.pane = pane;
         state.open = true;
@@ -185,6 +219,7 @@ export class TerminalHost {
     closeAgentSplit() {
         if (this.agentSplit?.open !== true)
             return;
+        this.clearSelection({ schedule: false });
         this.agentSplit.open = false;
         this.clearMouseModeSource(AGENT_SPLIT_MOUSE_SOURCE);
         this.applyChildViewportSize();
@@ -254,6 +289,7 @@ export class TerminalHost {
         if (!this.started || this.stopped)
             return;
         this.stopped = true;
+        this.resetDragScrollState();
         this.stopSource();
         if (this.resizeListener) {
             this.stdout.removeListener("resize", this.resizeListener);
@@ -367,6 +403,7 @@ export class TerminalHost {
             return;
         if (!this.childHandle)
             return;
+        this.clearSelection({ schedule: false });
         const collaborator = this.agentSplit?.collaborator;
         if (this.agentSplit?.open === true) {
             this.closeAgentSplit();
@@ -408,6 +445,7 @@ export class TerminalHost {
         if (!this.layout) {
             this.layout = this.computeLayout();
         }
+        this.clearSelection({ schedule: false });
         this.vt?.dispose();
         const rect = this.childViewportRect();
         this.vt = new VirtualTerminal(rect.cols, rect.rows, {
@@ -463,6 +501,7 @@ export class TerminalHost {
     detachParentUi(mode) {
         if (mode && this.parentUi !== mode)
             return;
+        this.resetDragScrollState();
         this.router.detachParentUi(this.parentUi);
         this.parentUi = undefined;
         this.invalidateFrameCache();
@@ -533,6 +572,7 @@ export class TerminalHost {
     }
     invalidateFrameCache() {
         this.lastFrameRows = null;
+        this.lastBaseRows = null;
     }
     /** Force an immediate render (synchronously composes one frame). */
     renderNow() {
@@ -556,24 +596,31 @@ export class TerminalHost {
         const parentOnly = !fullRender
             && surface !== undefined
             && surface.lines.length >= this.layout.childRows;
-        const next = new Array(this.layout.rows).fill(null);
+        const baseRows = new Array(this.layout.rows).fill(null);
         if (!parentOnly) {
             const childRows = renderChildViewportRows(this.vt, this.layout);
             for (let i = 0; i < childRows.length; i++) {
-                next[i] = childRows[i];
+                baseRows[i] = childRows[i];
             }
         }
         if (surface) {
-            this.renderUiSurfaceRows(next, this.layout, surface);
+            this.renderUiSurfaceRows(baseRows, this.layout, surface);
         }
         // Warning strip is host-owned and lives in its own dedicated rows
         // (between the child viewport and the status bar), so it is rendered
         // independently of the parent UI surface and the child viewport.
-        this.renderMessageRows(next, this.layout);
+        this.renderMessageRows(baseRows, this.layout);
         if (this.statusBar && this.layout.statusRow !== undefined) {
             const text = this.statusBar.render(this.layout.columns);
-            next[this.layout.statusRow - 1] = renderStatusRowBody(this.layout, text);
+            baseRows[this.layout.statusRow - 1] = renderStatusRowBody(this.layout, text);
+        }
+        const prevBase = this.lastBaseRows;
+        for (let i = 0; i < baseRows.length; i++) {
+            if (baseRows[i] === null)
+                baseRows[i] = prevBase?.[i] ?? null;
         }
+        const displayRows = [...baseRows];
+        this.applySelectionHighlight(baseRows, displayRows);
         // Move the real cursor to the active owner of the frame. Host-owned
         // surfaces keep the historic hidden default unless they opt in; child-owned
         // frames mirror the child's own DECTCEM visibility.
@@ -604,25 +651,738 @@ export class TerminalHost {
         }
         const prev = this.lastFrameRows;
         let diffBody = HIDE_CURSOR;
-        for (let i = 0; i < next.length; i++) {
-            if (next[i] !== null) {
-                if (prev === null || prev[i] !== next[i]) {
-                    diffBody += `\x1b[${i + 1};1H${next[i]}`;
+        for (let i = 0; i < displayRows.length; i++) {
+            if (displayRows[i] !== null) {
+                if (prev === null || prev[i] !== displayRows[i]) {
+                    diffBody += `\x1b[${i + 1};1H${displayRows[i]}`;
                 }
             }
             else {
-                // Nothing painted this row this frame: carry the prior row forward
-                // so `next` doubles as the cache for the following frame.
-                next[i] = prev?.[i] ?? null;
+                displayRows[i] = prev?.[i] ?? null;
             }
         }
-        this.lastFrameRows = next;
+        this.lastFrameRows = displayRows;
+        this.lastBaseRows = baseRows;
         diffBody += cursorPlacement;
         const frame = this.syncOutputSupported
             ? BEGIN_SYNC_UPDATE + diffBody + END_SYNC_UPDATE
             : diffBody;
         this.stdout.write(frame);
     }
+    applySelectionHighlight(baseRows, displayRows) {
+        if (!this.selection.hasSelection())
+            return;
+        const state = this.selection.getState();
+        if (!state)
+            return;
+        if (state.kind === "surface") {
+            const snapshot = this.snapshotRegionFromRows(state.region, baseRows);
+            this.selection.refreshSurfaceSnapshot(snapshot);
+            for (const span of this.selection.perRowSpans()) {
+                const idx = span.row - 1;
+                const base = baseRows[idx];
+                if (base === null || base === undefined)
+                    continue;
+                displayRows[idx] = applySelectionBackgroundRange(base, span.startCol, span.endCol);
+            }
+            return;
+        }
+        if (state.kind === "agent-buffer") {
+            if (!this.vt || !this.selection.refreshAgentSnapshot((absRow) => composeAbsoluteRow(this.vt, absRow, state.composeCols))) {
+                this.selection.clear();
+                return;
+            }
+            const viewportY = this.vt.viewportY;
+            for (const span of this.selection.perRowSpans()) {
+                const screenRow = span.row - viewportY + 1;
+                if (screenRow < state.region.rowStart || screenRow > state.region.rowEnd)
+                    continue;
+                const base = baseRows[screenRow - 1];
+                if (base === null || base === undefined)
+                    continue;
+                displayRows[screenRow - 1] = applySelectionBackgroundRange(base, span.startCol, span.endCol);
+            }
+            return;
+        }
+        if (state.kind === "fork-buffer") {
+            const placement = this.parentUi && isHostParentUiMode(this.parentUi)
+                ? this.parentUi.forkSelectionPlacement?.()
+                : undefined;
+            if (!placement || !this.selection.refreshForkSnapshot((absRow) => composeAbsoluteRow(placement.vt, absRow, state.composeCols))) {
+                this.selection.clear();
+                return;
+            }
+            for (const span of this.selection.perRowSpans()) {
+                const screenRow = span.row - placement.vt.viewportY + placement.region.rowStart;
+                if (screenRow < placement.region.rowStart || screenRow > placement.region.rowEnd)
+                    continue;
+                const base = baseRows[screenRow - 1];
+                if (base === null || base === undefined)
+                    continue;
+                const startCol = Math.max(placement.region.colStart, span.startCol + placement.region.colStart - 1);
+                const endCol = Math.min(placement.region.colEnd, span.endCol + placement.region.colStart - 1);
+                if (startCol <= endCol) {
+                    displayRows[screenRow - 1] = applySelectionBackgroundRange(base, startCol, endCol);
+                }
+            }
+            return;
+        }
+        const placement = this.docSurfacePlacement(state.pane);
+        if (!placement) {
+            this.selection.clear();
+            return;
+        }
+        for (const span of this.selection.perRowSpans()) {
+            const paneRow = span.row - placement.pane.getScrollTop() + 1;
+            const screenRow = placement.region.rowStart + paneRow - 1;
+            if (screenRow < placement.region.rowStart || screenRow > placement.region.rowEnd)
+                continue;
+            const base = baseRows[screenRow - 1];
+            if (base === null || base === undefined)
+                continue;
+            const startCol = Math.max(placement.region.colStart, span.startCol + placement.region.colStart - 1);
+            const endCol = Math.min(placement.region.colEnd, span.endCol + placement.region.colStart - 1);
+            if (startCol <= endCol) {
+                displayRows[screenRow - 1] = applySelectionBackgroundRange(base, startCol, endCol);
+            }
+        }
+    }
+    hasSelection() {
+        return this.selection.hasSelection();
+    }
+    handleSelectionInput(ev) {
+        if (ev.kind === "wheel") {
+            return "pass";
+        }
+        if (ev.kind === "control" && ev.byte === 0x03) {
+            if (!this.hasSelection())
+                return "pass";
+            void this.copySelection();
+            return "consume";
+        }
+        if (ev.kind === "escape") {
+            if (!this.hasSelection())
+                return "pass";
+            this.clearSelection();
+            return "consume";
+        }
+        const mouse = parseSgrMouseFrame(ev);
+        if (!mouse)
+            return "pass";
+        const point = { row: mouse.row, col: mouse.column };
+        const isMotion = mouse.final === "M" && (mouse.button & 32) !== 0;
+        const isLeftPress = mouse.final === "M" && mouse.button === 0;
+        const isLeftRelease = mouse.final === "m" && (mouse.button === 0 || mouse.button === 3);
+        const isRightPress = mouse.final === "M" && mouse.button === 2;
+        if (isLeftPress) {
+            this.clearSelection({ schedule: true });
+            const hit = this.hitTestSelectable(mouse.column, mouse.row);
+            if (!hit) {
+                this.gestureOwner = "child";
+                return "pass";
+            }
+            this.gestureOwner = "host";
+            const clickCount = this.nextClickCount(point);
+            if (hit.scrollTarget === "main-vt" || hit.scrollTarget === "agent-vt") {
+                if (!this.beginAgentBufferSelection(hit.region, point, clickCount)) {
+                    this.gestureOwner = "child";
+                    return "pass";
+                }
+            }
+            else if (hit.scrollTarget === "offscreen-inquiry") {
+                if (!this.beginForkBufferSelection(hit.region, point, clickCount)) {
+                    this.gestureOwner = "child";
+                    return "pass";
+                }
+            }
+            else if (hit.scrollTarget === "agent-artifact"
+                || hit.scrollTarget === "offscreen-artifact"
+                || hit.scrollTarget === "parent-doc-surface") {
+                if (!this.beginDocSurfaceSelection(hit.scrollTarget, hit.region, point, clickCount)) {
+                    this.gestureOwner = "child";
+                    return "pass";
+                }
+            }
+            else if (clickCount >= 3) {
+                const snapshot = this.snapshotRegion(hit.region);
+                this.selection.selectLine(hit.region, point, snapshot);
+            }
+            else if (clickCount === 2) {
+                const snapshot = this.snapshotRegion(hit.region);
+                this.selection.selectWord(hit.region, point, snapshot);
+            }
+            else {
+                const snapshot = this.snapshotRegion(hit.region);
+                this.selection.beginDrag(hit.region, point, snapshot);
+            }
+            this.dragScroll = {
+                region: hit.region,
+                target: hit.scrollTarget,
+                col: mouse.column,
+                row: mouse.row,
+            };
+            this.scheduleParentUiRender();
+            return "consume";
+        }
+        if (isMotion) {
+            if (this.gestureOwner === "host") {
+                const localPoint = this.localSelectionPoint(point);
+                this.selection.extendTo(localPoint, this.bufferSelectionComposeRow());
+                if (this.dragScroll) {
+                    this.dragScroll.col = mouse.column;
+                    this.dragScroll.row = mouse.row;
+                    if (this.dragScroll.target !== "none"
+                        && this.dragScrollPastEdge(this.dragScroll)) {
+                        this.cancelDragEdgeIntent();
+                        this.startDragScroll();
+                    }
+                    else if (this.dragScroll.target !== "none"
+                        && this.updateDragEdgeIntent()) {
+                        if (this.dragScroll.edgeIntent)
+                            this.startDragScroll();
+                    }
+                    else {
+                        this.cancelDragEdgeIntent();
+                        this.stopDragScroll();
+                    }
+                }
+                this.scheduleParentUiRender();
+                return "consume";
+            }
+            return "pass";
+        }
+        if (isLeftRelease) {
+            if (this.gestureOwner === "host") {
+                this.resetDragScrollState();
+                if (this.selection.mode === "char" && this.selection.isEmpty()) {
+                    this.clearSelection({ schedule: true });
+                }
+                else {
+                    this.scheduleParentUiRender();
+                }
+                this.gestureOwner = "none";
+                return "consume";
+            }
+            if (this.gestureOwner === "child")
+                this.gestureOwner = "none";
+            return "pass";
+        }
+        if (isRightPress) {
+            if (this.hasSelection()) {
+                void this.copySelection();
+                return "consume";
+            }
+            return this.hitTestSelectable(mouse.column, mouse.row) ? "consume" : "pass";
+        }
+        return "pass";
+    }
+    nextClickCount(point) {
+        const now = this.now();
+        const sameCell = this.lastClickCell?.row === point.row
+            && this.lastClickCell?.col === point.col;
+        this.clickCount = sameCell && now - this.lastClickTime <= MULTI_CLICK_MS
+            ? this.clickCount + 1
+            : 1;
+        this.lastClickTime = now;
+        this.lastClickCell = point;
+        return this.clickCount;
+    }
+    beginAgentBufferSelection(region, point, clickCount) {
+        if (!this.vt)
+            return false;
+        const normalized = normalizeSelectionRegion(region);
+        const allPaneMarkers = [];
+        for (let row = normalized.rowStart; row <= normalized.rowEnd; row++) {
+            const marker = this.vt.registerMarker(this.vt.viewportY + (row - 1));
+            if (marker)
+                allPaneMarkers.push(marker);
+        }
+        if (allPaneMarkers.length !== normalized.rowEnd - normalized.rowStart + 1) {
+            for (const marker of allPaneMarkers)
+                marker.dispose();
+            return false;
+        }
+        const composeCols = this.vt.cols;
+        const composeRow = (absRow) => composeAbsoluteRow(this.vt, absRow, composeCols);
+        const anchorPaneIdx = Math.min(Math.max(point.row - normalized.rowStart, 0), allPaneMarkers.length - 1);
+        if (clickCount === 2) {
+            this.selection.selectMarkerBufferWord("agent-buffer", normalized, composeCols, allPaneMarkers, anchorPaneIdx, point.col, composeRow);
+        }
+        else if (clickCount >= 3) {
+            this.selection.selectMarkerBufferLine("agent-buffer", normalized, composeCols, allPaneMarkers, anchorPaneIdx, composeRow);
+        }
+        else {
+            this.selection.beginMarkerBufferDrag("agent-buffer", normalized, composeCols, allPaneMarkers, anchorPaneIdx, point.col, composeRow);
+        }
+        return true;
+    }
+    beginForkBufferSelection(region, point, clickCount) {
+        const placement = this.parentUi && isHostParentUiMode(this.parentUi)
+            ? this.parentUi.forkSelectionPlacement?.()
+            : undefined;
+        if (!placement || placement.vt.isAlternate === true)
+            return false;
+        const normalized = normalizeSelectionRegion(placement.region);
+        const allPaneMarkers = [];
+        for (let row = normalized.rowStart; row <= normalized.rowEnd; row++) {
+            const marker = placement.vt.registerMarker(placement.vt.viewportY + (row - normalized.rowStart));
+            if (marker)
+                allPaneMarkers.push(marker);
+        }
+        if (allPaneMarkers.length !== normalized.rowEnd - normalized.rowStart + 1) {
+            for (const marker of allPaneMarkers)
+                marker.dispose();
+            return false;
+        }
+        const composeCols = placement.vt.cols;
+        const composeRow = (absRow) => composeAbsoluteRow(placement.vt, absRow, composeCols);
+        const anchorPaneIdx = Math.min(Math.max(point.row - normalized.rowStart, 0), allPaneMarkers.length - 1);
+        const localCol = this.localColumnForRegion(region, point.col);
+        if (clickCount === 2) {
+            this.selection.selectMarkerBufferWord("fork-buffer", normalized, composeCols, allPaneMarkers, anchorPaneIdx, localCol, composeRow);
+        }
+        else if (clickCount >= 3) {
+            this.selection.selectMarkerBufferLine("fork-buffer", normalized, composeCols, allPaneMarkers, anchorPaneIdx, composeRow);
+        }
+        else {
+            this.selection.beginMarkerBufferDrag("fork-buffer", normalized, composeCols, allPaneMarkers, anchorPaneIdx, localCol, composeRow);
+        }
+        return true;
+    }
+    beginDocSurfaceSelection(target, region, point, clickCount) {
+        const placement = this.docSurfacePlacementForTarget(target, point);
+        if (!placement)
+            return false;
+        const normalized = normalizeSelectionRegion(placement.region);
+        const localRow = Math.min(Math.max(point.row - normalized.rowStart + 1, 1), Math.max(1, normalized.rowEnd - normalized.rowStart + 1));
+        const docLine = placement.pane.getScrollTop() + localRow - 1;
+        const localCol = this.localColumnForRegion(region, point.col);
+        if (clickCount === 2) {
+            this.selection.selectDocWord(normalized, placement.pane, docLine, localCol);
+        }
+        else if (clickCount >= 3) {
+            this.selection.selectDocLine(normalized, placement.pane, docLine);
+        }
+        else {
+            this.selection.beginDocDrag(normalized, placement.pane, docLine, localCol);
+        }
+        return true;
+    }
+    bufferSelectionComposeRow() {
+        const state = this.selection.getState();
+        if (!state)
+            return undefined;
+        if (state.kind === "agent-buffer") {
+            if (!this.vt)
+                return undefined;
+            return (absRow) => composeAbsoluteRow(this.vt, absRow, state.composeCols);
+        }
+        if (state.kind === "fork-buffer") {
+            const placement = this.parentUi && isHostParentUiMode(this.parentUi)
+                ? this.parentUi.forkSelectionPlacement?.()
+                : undefined;
+            if (!placement)
+                return undefined;
+            return (absRow) => composeAbsoluteRow(placement.vt, absRow, state.composeCols);
+        }
+        return undefined;
+    }
+    clearSelection(opts = {}) {
+        this.resetDragScrollState();
+        if (!this.selection.clear())
+            return;
+        this.gestureOwner = "none";
+        if (opts.schedule !== false)
+            this.scheduleParentUiRender();
+    }
+    async copySelection() {
+        this.refreshSelectionBeforeCopy();
+        const text = this.selection.extractText();
+        if (text.length === 0)
+            return;
+        const result = await this.clipboardCopy(text, { stdout: this.stdout });
+        if (result.osWritten) {
+            this.statusBar?.flash(`Copied ${text.split("\n").length} line(s)`, 1500, "copy-success");
+            this.clearSelection({ schedule: false });
+        }
+        else {
+            this.statusBar?.flash("Copy failed (clipboard unavailable)", 1500, "copy-failure");
+        }
+        this.scheduleRender();
+    }
+    refreshSelectionBeforeCopy() {
+        const state = this.selection.getState();
+        if (!state)
+            return;
+        if (state.kind === "surface") {
+            this.selection.refreshSurfaceSnapshot(this.snapshotRegion(state.region));
+            return;
+        }
+        if (state.kind === "agent-buffer") {
+            if (!this.vt || !this.selection.refreshAgentSnapshot((absRow) => composeAbsoluteRow(this.vt, absRow, state.composeCols))) {
+                this.selection.clear();
+            }
+            return;
+        }
+        if (state.kind === "fork-buffer") {
+            const placement = this.parentUi && isHostParentUiMode(this.parentUi)
+                ? this.parentUi.forkSelectionPlacement?.()
+                : undefined;
+            if (!placement || !this.selection.refreshForkSnapshot((absRow) => composeAbsoluteRow(placement.vt, absRow, state.composeCols))) {
+                this.selection.clear();
+            }
+            return;
+        }
+        if (state.kind === "doc-surface" && !this.docSurfacePlacement(state.pane)) {
+            this.selection.clear();
+        }
+    }
+    localSelectionPoint(point) {
+        const state = this.selection.getState();
+        if (state?.kind === "fork-buffer" || state?.kind === "doc-surface") {
+            return { row: point.row, col: this.localColumnForRegion(state.region, point.col) };
+        }
+        return point;
+    }
+    localColumnForRegion(region, column) {
+        const clamped = Math.min(Math.max(column, region.colStart), region.colEnd);
+        return clamped - region.colStart + 1;
+    }
+    dragScrollPastEdge(drag) {
+        return drag.row < drag.region.rowStart || drag.row > drag.region.rowEnd;
+    }
+    dragScrollDirection(drag) {
+        if (drag.row < drag.region.rowStart)
+            return "back";
+        if (drag.row > drag.region.rowEnd)
+            return "forward";
+        return drag.edgeIntent;
+    }
+    startDragScroll() {
+        if (this.dragScrollTimer)
+            return;
+        if (!this.dragScrollTick())
+            return;
+        if (this.dragScrollTimer)
+            return;
+        const timer = this.setIntervalFn(() => {
+            this.dragScrollTick();
+        }, DRAG_SCROLL_INTERVAL_MS);
+        this.dragScrollTimer = timer;
+        const maybeTimer = timer;
+        maybeTimer.unref?.();
+    }
+    stopDragScroll() {
+        const timer = this.dragScrollTimer;
+        if (!timer)
+            return;
+        this.clearIntervalFn(timer);
+        this.dragScrollTimer = undefined;
+    }
+    resetDragScrollState() {
+        this.stopDragScroll();
+        this.cancelDragEdgeIntent();
+        this.dragScroll = undefined;
+    }
+    cancelDragEdgeIntent() {
+        if (this.dragEdgeIntent) {
+            this.clearTimeoutFn(this.dragEdgeIntent.timer);
+            this.dragEdgeIntent = undefined;
+        }
+        if (this.dragScroll)
+            this.dragScroll.edgeIntent = undefined;
+    }
+    updateDragEdgeIntent() {
+        const drag = this.dragScroll;
+        const direction = drag ? this.terminalEdgeDragDirection(drag) : undefined;
+        if (!drag || !direction) {
+            this.cancelDragEdgeIntent();
+            return false;
+        }
+        if (drag.edgeIntent === direction)
+            return true;
+        if (this.dragEdgeIntent?.direction === direction)
+            return true;
+        this.cancelDragEdgeIntent();
+        const timer = this.setTimeoutFn(() => {
+            if (!this.dragScroll || this.gestureOwner !== "host")
+                return;
+            if (this.terminalEdgeDragDirection(this.dragScroll) !== direction)
+                return;
+            this.dragEdgeIntent = undefined;
+            this.dragScroll.edgeIntent = direction;
+            this.startDragScroll();
+        }, DRAG_EDGE_LOSS_MS);
+        const maybeTimer = timer;
+        maybeTimer.unref?.();
+        this.dragEdgeIntent = { direction, timer };
+        return true;
+    }
+    terminalEdgeDragDirection(drag) {
+        if (drag.target === "none")
+            return undefined;
+        const layout = this.layout;
+        if (!layout)
+            return undefined;
+        if (drag.row === drag.region.rowStart && drag.region.rowStart === 1)
+            return "back";
+        if (drag.row === drag.region.rowEnd && drag.region.rowEnd === layout.rows)
+            return "forward";
+        return undefined;
+    }
+    dragScrollTick() {
+        const drag = this.dragScroll;
+        if (!drag || drag.target === "none") {
+            this.stopDragScroll();
+            return false;
+        }
+        const direction = this.dragScrollDirection(drag);
+        if (!direction) {
+            this.stopDragScroll();
+            return false;
+        }
+        const moved = this.scrollSurface(direction);
+        if (moved === 0) {
+            this.stopDragScroll();
+            return false;
+        }
+        if (!this.growSelectionAfterDragScroll(direction)) {
+            this.stopDragScroll();
+            return false;
+        }
+        this.scheduleRender();
+        return true;
+    }
+    scrollSurface(direction) {
+        const drag = this.dragScroll;
+        if (!drag)
+            return 0;
+        switch (drag.target) {
+            case "main-vt":
+            case "agent-vt": {
+                if (!this.vt)
+                    return 0;
+                const before = this.vt.viewportY;
+                if (direction === "back")
+                    this.vt.scrollBack(DRAG_SCROLL_LINES);
+                else
+                    this.vt.scrollForward(DRAG_SCROLL_LINES);
+                return Math.abs(this.vt.viewportY - before);
+            }
+            case "agent-artifact": {
+                const placement = this.agentSplitArtifactPlacement();
+                return placement?.pane.scrollLines(direction, DRAG_SCROLL_LINES) ?? 0;
+            }
+            case "offscreen-inquiry":
+            case "offscreen-artifact": {
+                if (!this.parentUi || !isHostParentUiMode(this.parentUi))
+                    return 0;
+                const column = Math.min(Math.max(drag.col, drag.region.colStart), drag.region.colEnd);
+                return this.parentUi.scrollSelectableSurfaceAt?.(column, drag.row, direction) ?? 0;
+            }
+            case "parent-doc-surface": {
+                const state = this.selection.getState();
+                if (state?.kind !== "doc-surface")
+                    return 0;
+                return scrollDocSurfacePane(state.pane, direction, DRAG_SCROLL_LINES);
+            }
+            case "none":
+                return 0;
+        }
+    }
+    growSelectionAfterDragScroll(direction) {
+        const drag = this.dragScroll;
+        if (!drag)
+            return false;
+        const edgeScreenRow = direction === "back" ? drag.region.rowStart : drag.region.rowEnd;
+        const focusColLocal = this.localColumnForRegion(drag.region, drag.col);
+        if (drag.target === "main-vt" || drag.target === "agent-vt") {
+            if (!this.vt)
+                return false;
+            const state = this.selection.getState();
+            if (state?.kind !== "agent-buffer")
+                return false;
+            const absRow = this.vt.viewportY + (edgeScreenRow - drag.region.rowStart);
+            const marker = this.vt.registerMarker(absRow);
+            if (!marker)
+                return false;
+            this.selection.growAgentBufferByMarker(marker, direction, focusColLocal, (row) => composeAbsoluteRow(this.vt, row, state.composeCols));
+            return true;
+        }
+        if (drag.target === "offscreen-inquiry") {
+            const placement = this.parentUi && isHostParentUiMode(this.parentUi)
+                ? this.parentUi.forkSelectionPlacement?.()
+                : undefined;
+            const state = this.selection.getState();
+            if (!placement || state?.kind !== "fork-buffer")
+                return false;
+            const absRow = placement.vt.viewportY + (edgeScreenRow - placement.region.rowStart);
+            const marker = placement.vt.registerMarker(absRow);
+            if (!marker)
+                return false;
+            this.selection.growForkByMarker(marker, direction, focusColLocal, (row) => composeAbsoluteRow(placement.vt, row, state.composeCols));
+            return true;
+        }
+        if (drag.target === "agent-artifact"
+            || drag.target === "offscreen-artifact"
+            || drag.target === "parent-doc-surface") {
+            const state = this.selection.getState();
+            if (state?.kind !== "doc-surface")
+                return false;
+            const placement = this.docSurfacePlacement(state.pane);
+            if (!placement)
+                return false;
+            const edgeDocLine = placement.pane.getScrollTop()
+                + (direction === "back" ? 0 : placement.pane.getViewportRows() - 1);
+            this.selection.growDocSurface(direction, focusColLocal, edgeDocLine);
+            return true;
+        }
+        return false;
+    }
+    hitTestSelectable(column, row) {
+        const layout = this.layout;
+        if (!layout)
+            return null;
+        if (column < 1 || column > layout.columns || row < 1 || row > layout.rows)
+            return null;
+        if (layout.statusRow !== undefined && row === layout.statusRow)
+            return null;
+        if (this.vt?.isAlternate !== true
+            &&
+                layout.warningRows > 0
+            && layout.warningStartRow !== undefined
+            && this.bufferOutput.snapshot().length > 0) {
+            const rowStart = layout.warningStartRow;
+            const rowEnd = layout.warningStartRow + layout.warningRows - 1;
+            if (row >= rowStart && row <= rowEnd) {
+                return {
+                    source: "surface",
+                    scrollTarget: "none",
+                    region: { rowStart, rowEnd, colStart: 1, colEnd: layout.columns },
+                };
+            }
+        }
+        if (this.isAgentSplitOpen()) {
+            return this.hitTestAgentSplitPane(column, row);
+        }
+        if (this.parentUi && isHostParentUiMode(this.parentUi)) {
+            const perPane = this.parentUi.selectionRegionAt?.(column, row);
+            if (perPane !== undefined) {
+                if (!perPane)
+                    return null;
+                return {
+                    source: "surface",
+                    scrollTarget: this.parentUi.selectionTargetAt?.(column, row) ?? "none",
+                    region: perPane,
+                };
+            }
+        }
+        if (this.vt?.isAlternate === true)
+            return null;
+        if (this.parentUi && isHostParentUiMode(this.parentUi)) {
+            const surface = this.parentUi.getSurface();
+            const maxLines = Math.min(surface.lines.length, layout.childRows);
+            if (maxLines > 0) {
+                const rowStart = layout.childRows - maxLines + 1;
+                const rowEnd = layout.childRows;
+                if (row >= rowStart && row <= rowEnd) {
+                    return {
+                        source: "surface",
+                        scrollTarget: "none",
+                        region: { rowStart, rowEnd, colStart: 1, colEnd: layout.columns },
+                    };
+                }
+            }
+            return null;
+        }
+        if (this.hasAttachedChild() && layout.childRows > 0) {
+            return {
+                source: "agent-buffer",
+                scrollTarget: "main-vt",
+                region: {
+                    rowStart: 1,
+                    rowEnd: layout.childRows,
+                    colStart: 1,
+                    colEnd: layout.columns,
+                },
+            };
+        }
+        return null;
+    }
+    hitTestAgentSplitPane(column, row) {
+        const layout = this.layout;
+        if (!layout)
+            return null;
+        const pane = this.routeAgentSplitMouse(column, row);
+        if (!pane)
+            return null;
+        const metrics = computeSplitMetrics({
+            cols: layout.columns,
+            rows: layout.childRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        });
+        if (!metrics.collapsed) {
+            if (pane === "agent") {
+                if (this.vt?.isAlternate === true)
+                    return null;
+                return {
+                    source: "agent-buffer",
+                    scrollTarget: "agent-vt",
+                    region: {
+                        rowStart: 1,
+                        rowEnd: layout.childRows,
+                        colStart: 1,
+                        colEnd: metrics.leftWidth,
+                    },
+                };
+            }
+            return {
+                source: "surface",
+                scrollTarget: "agent-artifact",
+                region: {
+                    rowStart: 1,
+                    rowEnd: layout.childRows,
+                    colStart: metrics.leftWidth + 2,
+                    colEnd: layout.columns,
+                },
+            };
+        }
+        const topRows = this.collapsedTopRows(layout.childRows);
+        if (pane === "agent") {
+            if (this.vt?.isAlternate === true)
+                return null;
+            return {
+                source: "agent-buffer",
+                scrollTarget: "agent-vt",
+                region: {
+                    rowStart: 1,
+                    rowEnd: topRows,
+                    colStart: 1,
+                    colEnd: layout.columns,
+                },
+            };
+        }
+        return {
+            source: "surface",
+            scrollTarget: "agent-artifact",
+            region: {
+                rowStart: topRows + 1,
+                rowEnd: layout.childRows,
+                colStart: 1,
+                colEnd: layout.columns,
+            },
+        };
+    }
+    snapshotRegion(region) {
+        return this.snapshotRegionFromRows(region, this.lastBaseRows);
+    }
+    snapshotRegionFromRows(region, rows) {
+        const snapshot = [];
+        for (let row = region.rowStart; row <= region.rowEnd; row++) {
+            snapshot.push(rows?.[row - 1] ?? "");
+        }
+        return snapshot;
+    }
     /**
      * Schedule a coalesced full render; multiple events in the same tick
      * produce one frame. Use this for any change that can affect the child
@@ -777,6 +1537,71 @@ export class TerminalHost {
             : null;
         return buildVerticalStackSurface(agent, artifact, { cols: layout.childCols, rows: layout.childRows, topRows });
     }
+    agentSplitArtifactPlacement() {
+        if (!this.isAgentSplitOpen() || !this.layout || this.agentSplit?.pane === undefined) {
+            return undefined;
+        }
+        const layout = this.layout;
+        const metrics = computeSplitMetrics({
+            cols: layout.columns,
+            rows: layout.childRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        });
+        if (!metrics.collapsed) {
+            return {
+                region: {
+                    rowStart: 1,
+                    rowEnd: layout.childRows,
+                    colStart: metrics.leftWidth + 2,
+                    colEnd: layout.columns,
+                },
+                pane: this.agentSplit.pane,
+            };
+        }
+        const topRows = this.collapsedTopRows(layout.childRows);
+        if (topRows >= layout.childRows)
+            return undefined;
+        return {
+            region: {
+                rowStart: topRows + 1,
+                rowEnd: layout.childRows,
+                colStart: 1,
+                colEnd: layout.columns,
+            },
+            pane: this.agentSplit.pane,
+        };
+    }
+    docSurfacePlacementForTarget(target, point) {
+        if (target === "agent-artifact")
+            return this.agentSplitArtifactPlacement();
+        if (!this.parentUi || !isHostParentUiMode(this.parentUi))
+            return undefined;
+        if (point) {
+            const placement = this.parentUi.docSurfaceSelectionPlacementAt?.(point.col, point.row);
+            if (placement)
+                return placement;
+        }
+        if (target === "parent-doc-surface")
+            return undefined;
+        return this.parentUi.artifactSelectionPlacement?.();
+    }
+    docSurfacePlacement(pane) {
+        const agentPlacement = this.agentSplitArtifactPlacement();
+        if (agentPlacement?.pane === pane)
+            return agentPlacement;
+        const parentPlacements = this.parentUi && isHostParentUiMode(this.parentUi)
+            ? this.parentUi.docSurfaceSelectionPlacements?.()
+            : undefined;
+        const parentPlacement = parentPlacements?.find((placement) => placement.pane === pane);
+        if (parentPlacement)
+            return parentPlacement;
+        const offscreenPlacement = this.parentUi && isHostParentUiMode(this.parentUi)
+            ? this.parentUi.artifactSelectionPlacement?.()
+            : undefined;
+        if (offscreenPlacement?.pane === pane)
+            return offscreenPlacement;
+        return undefined;
+    }
     routeAgentSplitMouse(column, row) {
         if (!this.isAgentSplitOpen() || !this.layout)
             return null;
@@ -809,6 +1634,8 @@ export class TerminalHost {
         }
     }
     handleChildAlternateChange(isAlternate) {
+        if (isAlternate)
+            this.clearSelection({ schedule: false });
         this.agentSplit?.collaborator?.onChildAlternateChange?.(isAlternate);
     }
     renderUiSurfaceRows(rows, layout, surface) {
@@ -841,6 +1668,7 @@ export class TerminalHost {
     handleResize(size) {
         if (!this.isActive)
             return;
+        this.clearSelection({ schedule: false });
         let next;
         if (size) {
             // Source-provided dimensions are already post-resize and may be
@@ -900,6 +1728,7 @@ export class TerminalHost {
         this.layout = next;
         if (prev !== undefined
             && (prev.childCols !== next.childCols || prev.childRows !== next.childRows)) {
+            this.clearSelection({ schedule: false });
             this.invalidateFrameCache();
             this.applyChildViewportSize();
             this.notifyParentUiResize();
@@ -923,6 +1752,18 @@ export class TerminalHost {
 function isHostParentUiMode(mode) {
     return typeof mode.getSurface === "function";
 }
+function scrollDocSurfacePane(pane, direction, lines) {
+    const scrollable = pane;
+    return scrollable.scrollLines?.(direction, lines) ?? 0;
+}
+function normalizeSelectionRegion(region) {
+    return {
+        rowStart: Math.min(region.rowStart, region.rowEnd),
+        rowEnd: Math.max(region.rowStart, region.rowEnd),
+        colStart: Math.min(region.colStart, region.colEnd),
+        colEnd: Math.max(region.colStart, region.colEnd),
+    };
+}
 /**
  * Map a surface-relative cursor position to a 1-based screen position.
  *