@deepseek-harness-tui/dsh-tui 0.8.7 → 0.9.0

package/lib/types/ink/parse-keypress.js

@@ -610,7 +610,12 @@ export function parseMultipleKeypresses(prevState, input = '') {
                         keys.push({ kind: 'response', sequence: token.value, response });
                     }
                     else {
-                        const mouse = parseMouseEvent(token.value);
+                        // SGR first (1006); X10 (legacy 1000/1002 without SGR) as the
+                        // compatibility fallback for clicks/drags. Wheel falls through
+                        // to parseKeypress, which turns it into a wheel key WITH the
+                        // pointer coordinates for position-based routing.
+                        const mouse = parseMouseEvent(token.value) ??
+                            parseX10MouseEvent(token.value);
                         if (mouse) {
                             keys.push(mouse);
                         }
@@ -819,6 +824,8 @@ export const nonAlphanumericKeys = [
     'backspace',
     'wheelup',
     'wheeldown',
+    'wheelleft',
+    'wheelright',
     'mouse',
 ];
 const isShiftKey = (code) => {
@@ -955,6 +962,39 @@ function parseMouseEvent(s) {
         sequence: s,
     };
 }
+/**
+ * Parse an X10 mouse sequence (CSI M + Cb/Cx/Cy raw bytes, each +32) into
+ * a ParsedMouse, or null for anything else. Serves terminals that honor
+ * DECSET 1000/1002 but ignore 1006 (SGR): clicks and button-drags become
+ * real ParsedMouse events so text selection works there too.
+ *
+ * Protocol limits (documented, accepted): X10 has no release events — a
+ * started selection finishes via App's lost-release recovery (next press /
+ * focus-out / no-button motion), and click dispatch (release-based) stays
+ * SGR-only. No-button motion (hover) is unrepresentable without the drag
+ * bit, so hover stays SGR-only. Wheel returns null (parseKeypress's wheel
+ * branch turns it into a key with coordinates).
+ */
+function parseX10MouseEvent(s) {
+    if (s.length !== 6 || !s.startsWith('\x1b[M'))
+        return null;
+    const button = s.charCodeAt(3) - 32;
+    // Wheel (bit 6) → key path; no-button without drag bit → unsupported
+    // hover encoding, swallow upstream.
+    if ((button & 0x40) !== 0)
+        return null;
+    if ((button & 0x03) === 3 && (button & 0x20) === 0)
+        return null;
+    return {
+        kind: 'mouse',
+        button,
+        action: 'press',
+        // X10 coords are 1-indexed like SGR (charCode - 32).
+        col: s.charCodeAt(4) - 32,
+        row: s.charCodeAt(5) - 32,
+        sequence: s,
+    };
+}
 function parseKeypress(s = '') {
     let parts;
     const key = {
@@ -1020,26 +1060,53 @@ function parseKeypress(s = '') {
     // + direction while ignoring modifier bits (Shift=0x04, Meta=0x08,
     // Ctrl=0x10) — modified wheel events (e.g. Ctrl+scroll, button=80)
     // should still be recognized as wheelup/wheeldown.
+    //
+    // The SGR sequence carries the pointer position (CSI < btn;col;row M) —
+    // preserved on the ParsedKey (mouseCol/mouseRow, 0-indexed) so wheel
+    // routing can hit-test the ScrollBox under the pointer instead of
+    // scrolling a hardcoded target. Buttons 66/67 are horizontal wheel
+    // (wheelleft/wheelright); kept as keys with coords for future consumers.
     if ((match = SGR_MOUSE_RE.exec(s))) {
         const button = parseInt(match[1], 10);
-        if ((button & 0x43) === 0x40)
-            return createNavKey(s, 'wheelup', false);
-        if ((button & 0x43) === 0x41)
-            return createNavKey(s, 'wheeldown', false);
+        const col = parseInt(match[2], 10) - 1;
+        const row = parseInt(match[3], 10) - 1;
+        const dir = button & 0x43;
+        if (dir === 0x40)
+            return createWheelKey(s, 'wheelup', col, row, button);
+        if (dir === 0x41)
+            return createWheelKey(s, 'wheeldown', col, row, button);
+        if (dir === 0x42)
+            return createWheelKey(s, 'wheelleft', col, row, button);
+        if (dir === 0x43)
+            return createWheelKey(s, 'wheelright', col, row, button);
         // Shouldn't reach here (parseMouseEvent catches non-wheel) but be safe
         return createNavKey(s, 'mouse', false);
     }
     // X10 mouse: CSI M + 3 raw bytes (Cb+32, Cx+32, Cy+32). Terminals that
     // ignore DECSET 1006 (SGR) but honor 1000/1002 emit this legacy encoding.
-    // Button bits match SGR: 0x40 = wheel, low bit = direction. Non-wheel
-    // X10 events (clicks/drags) are swallowed here — we only enable mouse
-    // tracking in alt-screen and only need wheel for ScrollBox.
+    // Button bits match SGR: 0x40 = wheel, low bit = direction, 0x20 = drag.
+    // Wheel events become wheel keys (with coordinates, like SGR); clicks and
+    // drags become ParsedMouse so X10-only terminals get selection support.
+    // X10 cannot report button release — click dispatch (release-based) stays
+    // SGR-only; a started selection finishes via the lost-release recovery
+    // paths (next press / focus-out / no-button motion).
     if (s.length === 6 && s.startsWith('\x1b[M')) {
         const button = s.charCodeAt(3) - 32;
-        if ((button & 0x43) === 0x40)
-            return createNavKey(s, 'wheelup', false);
-        if ((button & 0x43) === 0x41)
-            return createNavKey(s, 'wheeldown', false);
+        const col = s.charCodeAt(4) - 32 - 1;
+        const row = s.charCodeAt(5) - 32 - 1;
+        const dir = button & 0x43;
+        if (dir === 0x40)
+            return createWheelKey(s, 'wheelup', col, row, button);
+        if (dir === 0x41)
+            return createWheelKey(s, 'wheeldown', col, row, button);
+        if (dir === 0x42)
+            return createWheelKey(s, 'wheelleft', col, row, button);
+        if (dir === 0x43)
+            return createWheelKey(s, 'wheelright', col, row, button);
+        // Non-wheel X10 clicks/drags are intercepted by parseX10MouseEvent in
+        // parseMultipleKeypresses before this function runs; reaching here means
+        // a flush path bypassed it (no-button motion without the drag bit — X10
+        // hover, unsupported). Swallow as before.
         return createNavKey(s, 'mouse', false);
     }
     if (s === '\r') {
@@ -1157,3 +1224,25 @@ function createNavKey(s, name, ctrl) {
         isPasted: false,
     };
 }
+/**
+ * Build a wheel ParsedKey preserving the pointer position and modifier
+ * bits from the protocol's button byte (Shift=0x04, Meta/Alt=0x08,
+ * Ctrl=0x10 — same bit layout decodeModifier documents).
+ */
+function createWheelKey(s, name, col, row, button) {
+    return {
+        kind: 'key',
+        name,
+        ctrl: (button & 0x10) !== 0,
+        meta: (button & 0x08) !== 0,
+        shift: (button & 0x04) !== 0,
+        option: false,
+        super: false,
+        fn: false,
+        sequence: s,
+        raw: s,
+        isPasted: false,
+        mouseCol: col,
+        mouseRow: row,
+    };
+}

package/lib/types/ink/render-node-to-output.d.ts

@@ -1,4 +1,5 @@
 import type { DOMElement } from './dom.js';
+import type { Rectangle } from './layout/geometry.js';
 import type Output from './output.js';
 import type { Screen } from './screen.js';
 import { type StyledSegment } from './squash-text-nodes.js';
@@ -22,6 +23,15 @@ export type ScrollHint = {
     bottom: number;
     delta: number;
 };
+export type AbsoluteHitEntry = {
+    node: DOMElement;
+    rect: Rectangle;
+};
+/**
+ * The current frame's absolute-positioned nodes in paint order.
+ * @returns read-only list; reverse-iterate for topmost-first hit-testing.
+ */
+export declare function getAbsoluteHitList(): readonly AbsoluteHitEntry[];
 /** Reset the scroll hint for the next frame and rotate the absolute-rect buffers. */
 export declare function resetScrollHint(): void;
 /**
@@ -47,10 +57,13 @@ export type FollowScroll = {
     viewportBottom: number;
 };
 /**
- * Read and clear the follow-scroll event recorded this frame.
- * @returns the follow-scroll delta and viewport bounds, or null.
+ * Read and clear the follow-scroll events recorded this frame. At most one
+ * per ScrollBox (a box that follows AND drains reports only the follow —
+ * the follow branch clears pendingScrollDelta before the drain runs);
+ * several boxes may each report when they scroll in the same frame.
+ * @returns this frame's follow-scroll events; empty when none.
  */
-export declare function consumeFollowScroll(): FollowScroll | null;
+export declare function consumeFollowScroll(): FollowScroll[];
 /**
  * Build a mapping from each character position in the plain text to its segment index.
  * Returns an array where charToSegment[i] is the segment index for character i.

package/lib/types/ink/render-node-to-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-node-to-output.d.ts","sourceRoot":"","sources":["../../../src/ink/render-node-to-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAqBxC,6CAA6C;AAC7C,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAOD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAWvE,qFAAqF;AACrF,wBAAgB,eAAe,IAAI,IAAI,CAItC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AASD,8DAA8D;AAC9D,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,GAAG,IAAI,CAEtD;AAUD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAGD;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,GAAG,IAAI,CAIzD;AAoFD;;;;;GAKG;AACH,iBAAS,qBAAqB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,CASlE;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,wBAAwB,CAC/B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,aAAa,EAAE,EACzB,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,OAAe,GAC3B,MAAM,CA0GR;AA+DD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAM9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,wBAAwB,CAAC,EAAE,KAAK,CAAA;CACjC,GACA,IAAI,CA62BN;AAyOD,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA;AAE1D,eAAe,kBAAkB,CAAA"}
+{"version":3,"file":"render-node-to-output.d.ts","sourceRoot":"","sources":["../../../src/ink/render-node-to-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAGrD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAqBxC,6CAA6C;AAC7C,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAOD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAkBvE,MAAM,MAAM,gBAAgB,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAGpE;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,SAAS,gBAAgB,EAAE,CAEhE;AAED,qFAAqF;AACrF,wBAAgB,eAAe,IAAI,IAAI,CAKtC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AASD,8DAA8D;AAC9D,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,GAAG,IAAI,CAEtD;AAgBD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAGD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,EAAE,CAIpD;AAoFD;;;;;GAKG;AACH,iBAAS,qBAAqB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,CASlE;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,wBAAwB,CAC/B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,aAAa,EAAE,EACzB,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,OAAe,GAC3B,MAAM,CA0GR;AA+DD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAM9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,wBAAwB,CAAC,EAAE,KAAK,CAAA;CACjC,GACA,IAAI,CAq9BN;AA0OD,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA;AAE1D,eAAe,kBAAkB,CAAA"}

package/lib/types/ink/render-node-to-output.js

@@ -1,5 +1,6 @@
 import indentString from 'indent-string';
 import { applyTextStyles } from './colorize.js';
+import { GEOMETRY_TRACE_ENABLED, noteScrollGeometry } from './geometry-trace.js';
 import getMaxWidth from './get-max-width.js';
 import { LayoutDisplay, LayoutEdge } from './layout/node.js';
 import { nodeCache, pendingClears } from './node-cache.js';
@@ -41,11 +42,20 @@ let scrollHint = null;
 // still have the rect.
 let absoluteRectsPrev = [];
 let absoluteRectsCur = [];
+let absoluteHitList = [];
+/**
+ * The current frame's absolute-positioned nodes in paint order.
+ * @returns read-only list; reverse-iterate for topmost-first hit-testing.
+ */
+export function getAbsoluteHitList() {
+    return absoluteHitList;
+}
 /** Reset the scroll hint for the next frame and rotate the absolute-rect buffers. */
 export function resetScrollHint() {
     scrollHint = null;
     absoluteRectsPrev = absoluteRectsCur;
     absoluteRectsCur = [];
+    absoluteHitList = [];
 }
 /**
  * The scroll hint captured this frame, or null.
@@ -71,14 +81,17 @@ export function resetScrollDrainNode() {
 export function getScrollDrainNode() {
     return scrollDrainNode;
 }
-let followScroll = null;
+let followScrolls = [];
 /**
- * Read and clear the follow-scroll event recorded this frame.
- * @returns the follow-scroll delta and viewport bounds, or null.
+ * Read and clear the follow-scroll events recorded this frame. At most one
+ * per ScrollBox (a box that follows AND drains reports only the follow —
+ * the follow branch clears pendingScrollDelta before the drain runs);
+ * several boxes may each report when they scroll in the same frame.
+ * @returns this frame's follow-scroll events; empty when none.
  */
 export function consumeFollowScroll() {
-    const f = followScroll;
-    followScroll = null;
+    const f = followScrolls;
+    followScrolls = [];
     return f;
 }
 // ── Native terminal drain (iTerm2/Ghostty/etc. — proportional events) ──
@@ -356,18 +369,34 @@ function renderNodeToOutput(node, output, options) {
         let y = offsetY + yogaTop;
         const width = yogaNode.getComputedWidth();
         const height = yogaNode.getComputedHeight();
-        // Absolute-positioned overlays (e.g. autocomplete menus with bottom='100%')
-        // can compute negative screen y when they extend above the viewport. Without
-        // clamping, setCellAt drops cells at y<0, clipping the TOP of the content
-        // (best matches in an autocomplete). By clamping to 0, we shift the element
-        // down so the top rows are visible and the bottom overflows below — the
-        // opaque prop ensures it paints over whatever is underneath.
-        if (y < 0 && node.style.position === 'absolute') {
-            y = 0;
-        }
+        // Absolute-positioned overlays anchored above their parent
+        // (bottom='100%') compute negative screen y when their content is
+        // taller than the space above the anchor. Do NOT clamp y to 0 here:
+        // shifting the node down breaks the bottom-anchoring contract — the
+        // panel's BOTTOM would overflow past the anchor and paint over the
+        // composer/status rows below it (small-terminal overlay reports).
+        // Instead let the y<0 rows clip naturally: setCellAt drops cells above
+        // row 0 and blitRegion clamps in screen space, so the panel keeps its
+        // bottom pinned at the anchor and only loses its topmost rows — the
+        // same semantics as CSS clipping above the containing block. Producers
+        // prevent the case entirely by maxHeight-ing the overlay to the actual
+        // space above the anchor (OverlayAbove), so clipping is the last
+        // resort, not the layout.
         // Check if we can skip this subtree (clean node with unchanged layout).
         // Blit cells from previous screen instead of re-rendering.
         const cached = nodeCache.get(node);
+        // The node's EFFECTIVE background = its own + the inherited one. When it
+        // changed since the last frame (hover on/off toggles a row's
+        // backgroundColor, a parent's bg swap changes every child's inherited
+        // value), prevScreen still holds the OLD background — a clean child
+        // blitting it would resurrect the stale color (stuck hover highlights:
+        // the row's fill is skipped once the bg is removed, its clean children
+        // then blit the previous bg'd cells, the frame equals prevScreen, the
+        // diff finds nothing, and the highlight never clears). Compare against
+        // the value recorded at the previous render and refuse the blit when it
+        // moved.
+        const effectiveBg = node.style.backgroundColor ?? inheritedBackgroundColor;
+        const bgChanged = cached?.bg !== effectiveBg;
         if (!node.dirty &&
             !skipSelfBlit &&
             node.pendingScrollDelta === undefined &&
@@ -376,6 +405,7 @@ function renderNodeToOutput(node, output, options) {
             cached.y === y &&
             cached.width === width &&
             cached.height === height &&
+            !bgChanged &&
             prevScreen) {
             const fx = Math.floor(x);
             const fy = Math.floor(y);
@@ -384,6 +414,7 @@ function renderNodeToOutput(node, output, options) {
             output.blit(prevScreen, fx, fy, fw, fh);
             if (node.style.position === 'absolute') {
                 absoluteRectsCur.push(cached);
+                absoluteHitList.push({ node, rect: cached });
             }
             // Absolute descendants can paint outside this node's layout bounds
             // (e.g. a slash menu with position='absolute' bottom='100%' floats
@@ -590,7 +621,29 @@ function renderNodeToOutput(node, output, options) {
                 // within the viewport (equal to the scroll container's
                 // paddingTop), and innerHeight already subtracts padding, so
                 // including it double-counts padding and inflates maxScroll.
-                const scrollHeight = contentYoga?.getComputedHeight() ?? 0;
+                let scrollHeight = contentYoga?.getComputedHeight() ?? 0;
+                // Defensive extent floor: the wrapper's Yoga height can land ONE LINE
+                // short of its children's laid-out extent (the engine's flex-basis
+                // measure cache and the child's final subtree layout can disagree by
+                // a row — measured on resume of a long session: wrapper 286 while the
+                // last row's bottom sat at 287, stable across forced re-layouts). A
+                // short scrollHeight clamps maxScroll below the real bottom, so the
+                // sticky pin parks the viewport a line up and the tail line culls
+                // against the viewport edge — permanently invisible AND unreachable
+                // (no scroll position ever shows it; the user loses the newest
+                // message). The children's real extent is the authoritative floor.
+                // O(direct children) — the windowed list keeps this tiny, and the
+                // painter walks the same nodes right below.
+                if (content !== undefined) {
+                    for (const child of content.childNodes) {
+                        const childYoga = child.yogaNode;
+                        if (childYoga === undefined)
+                            continue;
+                        const bottom = childYoga.getComputedTop() + childYoga.getComputedHeight();
+                        if (bottom > scrollHeight)
+                            scrollHeight = bottom;
+                    }
+                }
                 // Capture previous scroll bounds BEFORE overwriting — the at-bottom
                 // follow check compares against last frame's max.
                 const prevScrollHeight = node.scrollHeight ?? scrollHeight;
@@ -684,11 +737,11 @@ function renderNodeToOutput(node, output, options) {
                 const followDelta = (node.scrollTop ?? 0) - scrollTopBeforeFollow;
                 if (followDelta > 0) {
                     const vpTop = node.scrollViewportTop ?? 0;
-                    followScroll = {
+                    followScrolls.push({
                         delta: followDelta,
                         viewportTop: vpTop,
                         viewportBottom: vpTop + innerHeight - 1,
-                    };
+                    });
                 }
                 // Drain pendingScrollDelta. Native terminals (proportional burst
                 // events) use proportional drain; xterm.js (VS Code, sparse events +
@@ -732,7 +785,17 @@ function renderNodeToOutput(node, output, options) {
                 // Keep the pre-frame position on a shrink frame (measurement
                 // artifact) instead of clamping to the shrunken maxScroll — the
                 // clamp would persist the yank even after content grows back.
-                let scrollTop = shrunk ? cur : Math.max(0, Math.min(cur, maxScroll));
+                // Exception: a STICKY view must stay pinned to the bottom. A width
+                // change clears MessageList's row-height cache, collapsing the
+                // estimated scrollHeight; freezing the pre-shrink scrollTop then
+                // parks it PAST the whole shrunken content — every child culls and
+                // the frame paints only the bottom chrome. With the resize erase
+                // (needsEraseBeforePaint) that lands as a pure blank screen with
+                // just the input box, and an idle app produces no follow-up frame
+                // to heal it (user-reported full-screen loss on pane-width jitter —
+                // issue #421; repro-resize-blank). Clamping a sticky view to the shrunken
+                // maxScroll is exactly its contract — show the bottom.
+                let scrollTop = shrunk && !sticky ? cur : Math.max(0, Math.min(cur, maxScroll));
                 // Virtual-scroll clamp: if scrollTop raced past the currently-mounted
                 // range (burst PageUp before React re-renders), render at the EDGE of
                 // the mounted children instead of blank spacer. Do NOT write back to
@@ -741,7 +804,15 @@ function renderNodeToOutput(node, output, options) {
                 // the right range. Not scheduling scrollDrainNode here keeps the
                 // clamp passive — React's commit → resetAfterCommit → onRender will
                 // paint again with fresh bounds.
-                const clamped = Math.max(cMin ?? -Infinity, Math.min(scrollTop, cMax ?? Infinity));
+                // Cap both bounds at maxScroll: the clamp bounds come from
+                // MessageList's height ESTIMATES while maxScroll comes from the
+                // frame's actual Yoga height. A width change resets the estimates
+                // (row-height cache clear), and a stale bound can point PAST the
+                // shrunken content bottom — the painted viewport then sits entirely
+                // below the content and every child culls to blank (the sticky
+                // full-screen loss — issue #421; repro-resize-blank). Nothing renderable exists
+                // below maxScroll regardless of what the estimates claim.
+                const clamped = Math.max(Math.min(cMin ?? -Infinity, maxScroll), Math.min(scrollTop, Math.min(cMax ?? Infinity, maxScroll)));
                 node.scrollTop = scrollTop;
                 // Clamp hitting top/bottom consumes any remainder. Set drainPending
                 // only after clamp so a wasted no-op frame isn't scheduled.
@@ -749,6 +820,51 @@ function renderNodeToOutput(node, output, options) {
                     node.pendingScrollDelta = undefined;
                 if (node.pendingScrollDelta !== undefined)
                     scrollDrainNode = node;
+                // Geometry forensics (#421/#433): everything that decides where this
+                // viewport painted — captured AFTER all clamps so the trace shows the
+                // final renderScrollTop, not the requested one.
+                if (GEOMETRY_TRACE_ENABLED) {
+                    noteScrollGeometry({
+                        sticky,
+                        shrunk,
+                        grew,
+                        atBottom,
+                        scrollTopBeforeFollow,
+                        cur,
+                        scrollTop,
+                        renderScrollTop: clamped,
+                        scrollHeight,
+                        prevScrollHeight,
+                        innerHeight,
+                        maxScroll,
+                        prevMaxScroll,
+                        clampMin: cMin ?? null,
+                        clampMax: cMax ?? null,
+                    });
+                }
+                // Wheel-drain selection translate (#438): the drain moved content
+                // by (scrollTop - scrollTopBeforeFollow) rows this frame, minus
+                // what at-bottom follow already reported above (followDelta is 0
+                // unless the follow branch fired — and when it did, it cleared
+                // pendingScrollDelta, so the drain contributed nothing). Record
+                // the remainder as a follow-scroll event with a SIGNED delta so
+                // ink.tsx re-anchors any active selection to the text. Without
+                // this, wheel scrolling leaves the highlight pinned to screen
+                // rows and copy-on-select grabs whatever scrolled under it.
+                // scrollTo/scrollToElement jumps never contribute: they write
+                // scrollTop before scrollTopBeforeFollow is captured. Multi-frame
+                // drains record per-frame portions; the selection's virtual-row
+                // tracking accumulates the clamp overshoot across frames. Multiple
+                // boxes may each record; ink.tsx attributes by viewport containment.
+                const wheelDelta = scrollTop - scrollTopBeforeFollow - followDelta;
+                if (wheelDelta !== 0) {
+                    const wheelVpTop = node.scrollViewportTop ?? 0;
+                    followScrolls.push({
+                        delta: wheelDelta,
+                        viewportTop: wheelVpTop,
+                        viewportBottom: wheelVpTop + innerHeight - 1
+                    });
+                }
                 // A manual scroll that lands exactly on the bottom re-pins sticky
                 // IMMEDIATELY on this frame — the follow-block restore above only
                 // fires when a later frame happens, but an idle stream (turn done,
@@ -1066,11 +1182,12 @@ function renderNodeToOutput(node, output, options) {
                 // backgroundColor and opaque both disable child blit: the fill
                 // overwrites the entire interior each render, so any child whose
                 // layout position shifted would blit stale cells from prevScreen
-                // on top of the fresh fill. Previously opaque kept blit enabled
-                // on the assumption that plain-space fill + unchanged children =
-                // valid composite, but children CAN reposition (ScrollBox remeasure
-                // on re-render → /permissions body blanked on Down arrow, #25436).
-                ownBackgroundColor || node.style.opaque ? undefined : prevScreen, boxBackgroundColor);
+                // on top of the fresh fill. bgChanged (effective background moved,
+                // e.g. a hover highlight removed) must disable child blit for the
+                // same reason: the old fill lives in prevScreen and the children's
+                // blits would resurrect it — the frame then equals prevScreen and
+                // the diff never clears the stale highlight.
+                ownBackgroundColor || node.style.opaque || bgChanged ? undefined : prevScreen, boxBackgroundColor);
             }
             if (needsClip) {
                 output.unclip();
@@ -1084,10 +1201,11 @@ function renderNodeToOutput(node, output, options) {
             renderChildren(node, output, x, y, hasRemovedChild, prevScreen, inheritedBackgroundColor);
         }
         // Cache layout bounds for dirty tracking
-        const rect = { x, y, width, height, top: yogaTop };
+        const rect = { x, y, width, height, top: yogaTop, bg: effectiveBg };
         nodeCache.set(node, rect);
         if (node.style.position === 'absolute') {
             absoluteRectsCur.push(rect);
+            absoluteHitList.push({ node, rect });
         }
         node.dirty = false;
     }
@@ -1201,6 +1319,7 @@ function blitEscapingAbsoluteDescendants(node, output, prevScreen, px, py, pw, p
             const cached = nodeCache.get(elem);
             if (cached) {
                 absoluteRectsCur.push(cached);
+                absoluteHitList.push({ node: elem, rect: cached });
                 const cx = Math.floor(cached.x);
                 const cy = Math.floor(cached.y);
                 const cw = Math.floor(cached.width);

package/lib/types/ink/selection.d.ts

@@ -213,10 +213,12 @@ export declare function shiftAnchor(s: SelectionState, dRow: number, minRow: num
  * the selection is text-anchored at both ends — both must move. The
  * isDragging check in ink.tsx picks which shift to apply.
  *
- * If both ends would shift strictly BELOW minRow (unclamped), the selected
- * text has scrolled entirely off the top. Clear it — otherwise a single
- * inverted cell lingers at the viewport top as a ghost (native terminals
- * drop the selection when it leaves scrollback). Landing AT minRow is
+ * If both ends would shift strictly BELOW minRow or strictly ABOVE maxRow
+ * (unclamped), the selected text has scrolled entirely off the viewport —
+ * off the top via streaming follow / wheel-down, off the bottom via
+ * wheel-up. Clear it — otherwise a single inverted cell lingers at the
+ * edge as a ghost (native terminals drop the selection when it leaves
+ * scrollback). Landing AT the edge row is
  * still valid: that cell holds the correct text. Returns true if the
  * selection was cleared so the caller can notify React-land subscribers
  * (useHasSelection) — the caller is inside onRender so it can't use
@@ -229,6 +231,29 @@ export declare function shiftAnchor(s: SelectionState, dRow: number, minRow: num
  *   entirely off the top, false otherwise.
  */
 export declare function shiftSelectionForFollow(s: SelectionState, dRow: number, minRow: number, maxRow: number): boolean;
+/** A scroll event reported by a ScrollBox this frame (follow or wheel
+ *  drain): signed delta plus the box's viewport bounds. Structurally
+ *  identical to FollowScroll in render-node-to-output. */
+export type ScrollEvent = {
+    delta: number;
+    viewportTop: number;
+    viewportBottom: number;
+};
+/**
+ * Pick which scroll event a selection belongs to when several ScrollBoxes
+ * scrolled in the same frame (e.g., the transcript still draining a wheel
+ * burst while an overlay panel's box scrolls). The selection follows the
+ * INNERMOST viewport containing the anchor: overlay panels render on top
+ * of the transcript, so a selection inside the overlap rows belongs to
+ * the panel, not the covered transcript beneath it. A selection outside
+ * every viewport (footer/prompt, static text) follows nothing — scrolling
+ * doesn't move the content under it.
+ * @param events - this frame's scroll events (signed deltas).
+ * @param anchorRow - the selection anchor's screen row, or null when no
+ *   selection is active.
+ * @returns the event the selection should be translated by, or null.
+ */
+export declare function pickFollowForSelection(events: ScrollEvent[], anchorRow: number | null): ScrollEvent | null;
 /**
  * True when a selection is active, meaning both anchor and focus are set.
  * @param s - the selection state to inspect.

package/lib/types/ink/selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../src/ink/selection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../src/ink/selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGpD,KAAK,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzC;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,6DAA6D;IAC7D,MAAM,EAAE,KAAK,GAAG,IAAI,CAAA;IACpB,oEAAoE;IACpE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAA;IACnB;;;;4EAIwE;IACxE,UAAU,EAAE;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAClE;;;;0EAIsE;IACtE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,qEAAqE;IACrE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B;;;;;iBAKa;IACb,kBAAkB,EAAE,OAAO,EAAE,CAAA;IAC7B,oCAAoC;IACpC,kBAAkB,EAAE,OAAO,EAAE,CAAA;IAC7B;;;;uEAImE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,sBAAsB;IACtB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;;;gFAI4E;IAC5E,eAAe,EAAE,OAAO,CAAA;CACzB,CAAA;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAYrD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,IAAI,CAeN;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,IAAI,CAUN;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,CAIvD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,CAYtD;AAmGD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,cAAc,EACjB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,IAAI,CASN;AAYD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAmFpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,cAAc,EACjB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,IAAI,CAQN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,cAAc,EACjB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,IAAI,CA2BN;AAED;gDACgD;AAChD,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,OAAO,GACP,IAAI,GACJ,MAAM,GACN,WAAW,GACX,SAAS,CAAA;AAEb;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAQ3E;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,cAAc,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,IAAI,CAyFN;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,cAAc,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,IAAI,CAwBN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,cAAc,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAkDT;AAED;;0DAE0D;AAC1D,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,EAAE,EACrB,SAAS,EAAE,MAAM,GAAG,IAAI,GACvB,WAAW,GAAG,IAAI,CAapB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,cAAc,GAAG,OAAO,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,GAAG;IAClD,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACnC,GAAG,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAClC,GAAG,IAAI,CAKP;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,OAAO,CAQT;AAoDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAsBzE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,cAAc,EACjB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,GAAG,OAAO,GACtB,IAAI,CAwDN;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,SAAS,GACnB,IAAI,CAoBN"}

package/lib/types/ink/selection.js

@@ -579,10 +579,12 @@ export function shiftAnchor(s, dRow, minRow, maxRow) {
  * the selection is text-anchored at both ends — both must move. The
  * isDragging check in ink.tsx picks which shift to apply.
  *
- * If both ends would shift strictly BELOW minRow (unclamped), the selected
- * text has scrolled entirely off the top. Clear it — otherwise a single
- * inverted cell lingers at the viewport top as a ghost (native terminals
- * drop the selection when it leaves scrollback). Landing AT minRow is
+ * If both ends would shift strictly BELOW minRow or strictly ABOVE maxRow
+ * (unclamped), the selected text has scrolled entirely off the viewport —
+ * off the top via streaming follow / wheel-down, off the bottom via
+ * wheel-up. Clear it — otherwise a single inverted cell lingers at the
+ * edge as a ghost (native terminals drop the selection when it leaves
+ * scrollback). Landing AT the edge row is
  * still valid: that cell holds the correct text. Returns true if the
  * selection was cleared so the caller can notify React-land subscribers
  * (useHasSelection) — the caller is inside onRender so it can't use
@@ -609,7 +611,11 @@ export function shiftSelectionForFollow(s, dRow, minRow, maxRow) {
     const rawFocus = s.focus
         ? (s.virtualFocusRow ?? s.focus.row) + dRow
         : undefined;
-    if (rawAnchor < minRow && rawFocus !== undefined && rawFocus < minRow) {
+    // Both ends strictly past the same edge = selection fully scrolled off
+    // (top: follow/wheel-down; bottom: wheel-up). Symmetric clear — a
+    // clamped-to-edge pair would render as a 1-row ghost highlight.
+    if ((rawAnchor < minRow && rawFocus !== undefined && rawFocus < minRow) ||
+        (rawAnchor > maxRow && rawFocus !== undefined && rawFocus > maxRow)) {
         clearSelection(s);
         return true;
     }
@@ -640,6 +646,36 @@ export function shiftSelectionForFollow(s, dRow, minRow, maxRow) {
     }
     return false;
 }
+/**
+ * Pick which scroll event a selection belongs to when several ScrollBoxes
+ * scrolled in the same frame (e.g., the transcript still draining a wheel
+ * burst while an overlay panel's box scrolls). The selection follows the
+ * INNERMOST viewport containing the anchor: overlay panels render on top
+ * of the transcript, so a selection inside the overlap rows belongs to
+ * the panel, not the covered transcript beneath it. A selection outside
+ * every viewport (footer/prompt, static text) follows nothing — scrolling
+ * doesn't move the content under it.
+ * @param events - this frame's scroll events (signed deltas).
+ * @param anchorRow - the selection anchor's screen row, or null when no
+ *   selection is active.
+ * @returns the event the selection should be translated by, or null.
+ */
+export function pickFollowForSelection(events, anchorRow) {
+    if (anchorRow === null)
+        return null;
+    let best = null;
+    let bestHeight = Infinity;
+    for (const e of events) {
+        if (anchorRow < e.viewportTop || anchorRow > e.viewportBottom)
+            continue;
+        const height = e.viewportBottom - e.viewportTop;
+        if (best === null || height < bestHeight) {
+            best = e;
+            bestHeight = height;
+        }
+    }
+    return best;
+}
 /**
  * True when a selection is active, meaning both anchor and focus are set.
  * @param s - the selection state to inspect.