Something went wrong. Try again.
source dump of claude code
Something went wrong. Try again.
149 kB · 1012 lines
TSX
at main
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012import React, { type RefObject, useEffect, useRef } from 'react';import { useNotifications } from '../context/notifications.js';import { useCopyOnSelect, useSelectionBgColor } from '../hooks/useCopyOnSelect.js';import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js';import { useSelection } from '../ink/hooks/use-selection.js';import type { FocusMove, SelectionState } from '../ink/selection.js';import { isXtermJs } from '../ink/terminal.js';import { getClipboardPath } from '../ink/termio/osc.js';// eslint-disable-next-line custom-rules/prefer-use-keybindings -- Esc needs conditional propagation based on selection stateimport { type Key, useInput } from '../ink.js';import { useKeybindings } from '../keybindings/useKeybinding.js';import { logForDebugging } from '../utils/debug.js';type Props = { scrollRef: RefObject<ScrollBoxHandle | null>; isActive: boolean; /** Called after every scroll action with the resulting sticky state and * the handle (for reading scrollTop/scrollHeight post-scroll). */ onScroll?: (sticky: boolean, handle: ScrollBoxHandle) => void; /** Enables modal pager keys (g/G, ctrl+u/d/b/f). Only safe when there * is no text input competing for those characters — i.e. transcript * mode. Defaults to false. When true, G works regardless of editorMode * and sticky state; ctrl+u/d/b/f don't conflict with kill-line/exit/ * task:background/kill-agents (none are mounted, or they mount after * this component so stopImmediatePropagation wins). */ isModal?: boolean;};
// Terminals send one SGR wheel event per intended row (verified in Ghostty// src/Surface.zig: `for (0..@abs(y.delta)) |_| { mouseReport(.four, ...) }`).// Ghostty already 3×'s discrete wheel ticks before that loop; trackpad// precision scroll is pixels/cell_size. 1 event = 1 row intended — use it// as the base, and ramp a multiplier when events arrive rapidly. The// pendingScrollDelta accumulator + proportional drain in// render-node-to-output handles smooth catch-up on big bursts.//// xterm.js (VS Code/Cursor/Windsurf integrated terminals) sends exactly 1// event per wheel notch — no pre-amplification. A separate exponential// decay curve (below) compensates for the lower event rate, with burst// detection and gap-dependent caps tuned to VS Code's event patterns.
// Native terminals: hard-window linear ramp. Events closer than the window// ramp the multiplier; idle gaps reset to `base` (default 1). Some emulators// pre-multiply at their layer (ghostty discrete=3 sends 3 SGR events/notch;// iTerm2 "faster scroll" similar) — base=1 is correct there. Others send 1// event/notch — users on those can set CLAUDE_CODE_SCROLL_SPEED=3 to match// vim/nvim/opencode app-side defaults. We can't detect which, so knob it.const WHEEL_ACCEL_WINDOW_MS = 40;const WHEEL_ACCEL_STEP = 0.3;const WHEEL_ACCEL_MAX = 6;
// Encoder bounce debounce + wheel-mode decay curve. Worn/cheap optical// encoders emit spurious reverse-direction ticks during fast spins — measured// 28% of events on Boris's mouse (2026-03-17, iTerm2). Pattern is always// flip-then-flip-back; trackpads produce ZERO flips (0/458 in same recording).// A confirmed bounce proves a physical wheel is attached — engage the same// exponential-decay curve the xterm.js path uses (it's already tuned), with// a higher cap to compensate for the lower event rate (~9/sec vs VS Code's// ~30/sec). Trackpad can't reach this path.//// The decay curve gives: 1st click after idle = 1 row (precision), 2nd = 10,// 3rd = cap. Slowing down decays smoothly toward 1 — no separate idle// threshold needed, large gaps just have m≈0 → mult→1. Wheel mode is STICKY:// once a bounce confirms it's a mouse, the decay curve applies until an idle// gap or trackpad-flick-burst signals a possible device switch.const WHEEL_BOUNCE_GAP_MAX_MS = 200; // flip-back must arrive within this// Mouse is ~9 events/sec vs VS Code's ~30 — STEP is 3× xterm.js's 5 to// compensate. At gap=100ms (m≈0.63): one click gives 1+15*0.63≈10.5.const WHEEL_MODE_STEP = 15;const WHEEL_MODE_CAP = 15;// Max mult growth per event. Without this, the +STEP*m term jumps mult// from 1→10 in one event when wheelMode engages mid-scroll (bounce// detected after N events in trackpad mode at mult=1). User sees scroll// suddenly go 10× faster. Cap=3 gives 1→4→7→10→13→15 over ~0.5s at// 9 events/sec — smooth ramp instead of a jump. Decay is unaffected// (target<mult wins the min).const WHEEL_MODE_RAMP = 3;// Device-switch disengage: mouse finger-repositions max at ~830ms (measured);// trackpad between-gesture pauses are 2000ms+. An idle gap above this means// the user stopped — might have switched devices. Disengage; the next mouse// bounce re-engages. Trackpad slow swipe (no <5ms bursts, so the burst-count// guard doesn't catch it) is what this protects against.const WHEEL_MODE_IDLE_DISENGAGE_MS = 1500;
// xterm.js: exponential decay. momentum=0.5^(gap/hl) — slow click → m≈0// → mult→1 (precision); fast → m≈1 → carries momentum. Steady-state// = 1 + step×m/(1-m), capped. Measured event rates in VS Code (wheel.log):// sustained scroll sends events at 20-50ms gaps (20-40 Hz), plus 0-2ms// same-batch bursts on flicks. Cap is low (3–6, gap-dependent) because event// frequency is high — at 40 Hz × 6 = 240 rows/sec max demand, which the// adaptive drain at ~200fps (measured) handles. Higher cap → pending explosion.// Tuned empirically (boris 2026-03). See docs/research/terminal-scroll-*.const WHEEL_DECAY_HALFLIFE_MS = 150;const WHEEL_DECAY_STEP = 5;// Same-batch events (<BURST_MS) arrive in one stdin batch — the terminal// is doing proportional reporting. Treat as 1 row/event like native.const WHEEL_BURST_MS = 5;// Cap boundary: slow events (≥GAP_MS) cap low for short smooth drains;// fast events cap higher for throughput (adaptive drain handles backlog).const WHEEL_DECAY_GAP_MS = 80;const WHEEL_DECAY_CAP_SLOW = 3; // gap ≥ GAP_MS: precisionconst WHEEL_DECAY_CAP_FAST = 6; // gap < GAP_MS: throughput// Idle threshold: gaps beyond this reset to the kick value (2) so the// first click after a pause feels responsive regardless of direction.const WHEEL_DECAY_IDLE_MS = 500;
/** * Whether a keypress should clear the virtual text selection. Mimics * native terminal selection: any keystroke clears, EXCEPT modified nav * keys (shift/opt/cmd + arrow/home/end/page*). In native macOS contexts, * shift+nav extends selection, and cmd/opt+nav are often intercepted by * the terminal emulator for scrollback nav — neither disturbs selection. * Bare arrows DO clear (user's cursor moves, native deselects). Wheel is * excluded — scroll:lineUp/Down already clears via the keybinding path. */export function shouldClearSelectionOnKey(key: Key): boolean { if (key.wheelUp || key.wheelDown) return false; const isNav = key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.home || key.end || key.pageUp || key.pageDown; if (isNav && (key.shift || key.meta || key.super)) return false; return true;}
/** * Map a keypress to a selection focus move (keyboard extension). Only * shift extends — that's the universal text-selection modifier. cmd * (super) only arrives via kitty keyboard protocol — in most terminals * cmd+arrow is intercepted by the emulator and never reaches the pty, so * no super branch. shift+home/end covers line-edge jumps (and fn+shift+ * left/right on mac laptops = shift+home/end). shift+opt (word-jump) not * yet implemented — falls through to shouldClearSelectionOnKey which * preserves (modified nav). Returns null for non-extend keys. */export function selectionFocusMoveForKey(key: Key): FocusMove | null { if (!key.shift || key.meta) return null; if (key.leftArrow) return 'left'; if (key.rightArrow) return 'right'; if (key.upArrow) return 'up'; if (key.downArrow) return 'down'; if (key.home) return 'lineStart'; if (key.end) return 'lineEnd'; return null;}export type WheelAccelState = { time: number; mult: number; dir: 0 | 1 | -1; xtermJs: boolean; /** Carried fractional scroll (xterm.js only). scrollBy floors, so without * this a mult of 1.5 gives 1 row every time. Carrying the remainder gives * 1,2,1,2 on average for mult=1.5 — correct throughput over time. */ frac: number; /** Native-path baseline rows/event. Reset value on idle/reversal; ramp * builds on top. xterm.js path ignores this (own kick=2 tuning). */ base: number; /** Deferred direction flip (native only). Might be encoder bounce or a * real reversal — resolved by the NEXT event. Real reversal loses 1 row * of latency; bounce is swallowed and triggers wheel mode. The flip's * direction and timestamp are derivable (it's always -state.dir at * state.time) so this is just a marker. */ pendingFlip: boolean; /** Set true once a bounce is confirmed (flip-then-flip-back within * BOUNCE_GAP_MAX). Sticky — but disengaged on idle gap >1500ms OR a * trackpad-signature burst (see burstCount). State lives in a useRef so * it persists across device switches; the disengages handle mouse→trackpad. */ wheelMode: boolean; /** Consecutive <5ms events. Trackpad flick produces 100+ at <5ms; mouse * produces ≤3 (verified in /tmp/wheel-tune.txt). 5+ in a row → trackpad * signature → disengage wheel mode so device-switch doesn't leak mouse * accel to trackpad. */ burstCount: number;};
/** Compute rows for one wheel event, mutating accel state. Returns 0 when * a direction flip is deferred for bounce detection — call sites no-op on * step=0 (scrollBy(0) is a no-op, onScroll(false) is idempotent). Exported * for tests. */export function computeWheelStep(state: WheelAccelState, dir: 1 | -1, now: number): number { if (!state.xtermJs) { // Device-switch guard ①: idle disengage. Runs BEFORE pendingFlip resolve // so a pending bounce (28% of last-mouse-events) doesn't bypass it via // the real-reversal early return. state.time is either the last committed // event OR the deferred flip — both count as "last activity". if (state.wheelMode && now - state.time > WHEEL_MODE_IDLE_DISENGAGE_MS) { state.wheelMode = false; state.burstCount = 0; state.mult = state.base; }
// Resolve any deferred flip BEFORE touching state.time/dir — we need the // pre-flip state.dir to distinguish bounce (flip-back) from real reversal // (flip persisted), and state.time (= bounce timestamp) for the gap check. if (state.pendingFlip) { state.pendingFlip = false; if (dir !== state.dir || now - state.time > WHEEL_BOUNCE_GAP_MAX_MS) { // Real reversal: new dir persisted, OR flip-back arrived too late. // Commit. The deferred event's 1 row is lost (acceptable latency). state.dir = dir; state.time = now; state.mult = state.base; return Math.floor(state.mult); } // Bounce confirmed: flipped back to original dir within the window. // state.dir/mult unchanged from pre-bounce. state.time was advanced to // the bounce below, so gap here = flip-back interval — reflects the // user's actual click cadence (bounce IS a physical click, just noisy). state.wheelMode = true; } const gap = now - state.time; if (dir !== state.dir && state.dir !== 0) { // Flip. Defer — next event decides bounce vs. real reversal. Advance // time (but NOT dir/mult): if this turns out to be a bounce, the // confirm event's gap will be the flip-back interval, which reflects // the user's actual click rate. The bounce IS a physical wheel click, // just misread by the encoder — it should count toward cadence. state.pendingFlip = true; state.time = now; return 0; } state.dir = dir; state.time = now;
// ─── MOUSE (wheel mode, sticky until device-switch signal) ─── if (state.wheelMode) { if (gap < WHEEL_BURST_MS) { // Same-batch burst check (ported from xterm.js): iTerm2 proportional // reporting sends 2+ SGR events for one detent when macOS gives // delta>1. Without this, the 2nd event at gap<1ms has m≈1 → STEP*m=15 // → one gentle click gives 1+15=16 rows. // // Device-switch guard ②: trackpad flick produces 100+ events at <5ms // (measured); mouse produces ≤3. 5+ consecutive → trackpad flick. if (++state.burstCount >= 5) { state.wheelMode = false; state.burstCount = 0; state.mult = state.base; } else { return 1; } } else { state.burstCount = 0; } } // Re-check: may have disengaged above. if (state.wheelMode) { // xterm.js decay curve with STEP×3, higher cap. No idle threshold — // the curve handles it (gap=1000ms → m≈0.01 → mult≈1). No frac — // rounding loss is minor at high mult, and frac persisting across idle // was causing off-by-one on the first click back. const m = Math.pow(0.5, gap / WHEEL_DECAY_HALFLIFE_MS); const cap = Math.max(WHEEL_MODE_CAP, state.base * 2); const next = 1 + (state.mult - 1) * m + WHEEL_MODE_STEP * m; state.mult = Math.min(cap, next, state.mult + WHEEL_MODE_RAMP); return Math.floor(state.mult); }
// ─── TRACKPAD / HI-RES (native, non-wheel-mode) ─── // Tight 40ms burst window: sub-40ms events ramp, anything slower resets. // Trackpad flick delivers 200+ events at <20ms gaps → rails to cap 6. // Trackpad slow swipe at 40-400ms gaps → resets every event → 1 row each. if (gap > WHEEL_ACCEL_WINDOW_MS) { state.mult = state.base; } else { const cap = Math.max(WHEEL_ACCEL_MAX, state.base * 2); state.mult = Math.min(cap, state.mult + WHEEL_ACCEL_STEP); } return Math.floor(state.mult); }
// ─── VSCODE (xterm.js, browser wheel events) ─── // Browser wheel events — no encoder bounce, no SGR bursts. Decay curve // unchanged from the original tuning. Same formula shape as wheel mode // above (keep in sync) but STEP=5 not 15 — higher event rate here. const gap = now - state.time; const sameDir = dir === state.dir; state.time = now; state.dir = dir; // xterm.js path. Debug log shows two patterns: (a) 20-50ms gaps during // sustained scroll (~30 Hz), (b) <5ms same-batch bursts on flicks. For // (b) give 1 row/event — the burst count IS the acceleration, same as // native. For (a) the decay curve gives 3-5 rows. For sparse events // (100ms+, slow deliberate scroll) the curve gives 1-3. if (sameDir && gap < WHEEL_BURST_MS) return 1; if (!sameDir || gap > WHEEL_DECAY_IDLE_MS) { // Direction reversal or long idle: start at 2 (not 1) so the first // click after a pause moves a visible amount. Without this, idle- // then-resume in the same direction decays to mult≈1 (1 row). state.mult = 2; state.frac = 0; } else { const m = Math.pow(0.5, gap / WHEEL_DECAY_HALFLIFE_MS); const cap = gap >= WHEEL_DECAY_GAP_MS ? WHEEL_DECAY_CAP_SLOW : WHEEL_DECAY_CAP_FAST; state.mult = Math.min(cap, 1 + (state.mult - 1) * m + WHEEL_DECAY_STEP * m); } const total = state.mult + state.frac; const rows = Math.floor(total); state.frac = total - rows; return rows;}
/** Read CLAUDE_CODE_SCROLL_SPEED, default 1, clamp (0, 20]. * Some terminals pre-multiply wheel events (ghostty discrete=3, iTerm2 * "faster scroll") — base=1 is correct there. Others send 1 event/notch — * set CLAUDE_CODE_SCROLL_SPEED=3 to match vim/nvim/opencode. We can't * detect which kind of terminal we're in, hence the knob. Called lazily * from initAndLogWheelAccel so globalSettings.env has loaded. */export function readScrollSpeedBase(): number { const raw = process.env.CLAUDE_CODE_SCROLL_SPEED; if (!raw) return 1; const n = parseFloat(raw); return Number.isNaN(n) || n <= 0 ? 1 : Math.min(n, 20);}
/** Initial wheel accel state. xtermJs=true selects the decay curve. * base is the native-path baseline rows/event (default 1). */export function initWheelAccel(xtermJs = false, base = 1): WheelAccelState { return { time: 0, mult: base, dir: 0, xtermJs, frac: 0, base, pendingFlip: false, wheelMode: false, burstCount: 0 };}
// Lazy-init helper. isXtermJs() combines the TERM_PROGRAM env check + async// XTVERSION probe — the probe may not have resolved at render time, so this// is called on the first wheel event (>>50ms after startup) when it's settled.// Logs detected mode once so --debug users can verify SSH detection worked.// The renderer also calls isXtermJsHost() (in render-node-to-output) to// select the drain algorithm — no state to pass through.function initAndLogWheelAccel(): WheelAccelState { const xtermJs = isXtermJs(); const base = readScrollSpeedBase(); logForDebugging(`wheel accel: ${xtermJs ? 'decay (xterm.js)' : 'window (native)'} · base=${base} · TERM_PROGRAM=${process.env.TERM_PROGRAM ?? 'unset'}`); return initWheelAccel(xtermJs, base);}
// Drag-to-scroll: when dragging past the viewport edge, scroll by this many// rows every AUTOSCROLL_INTERVAL_MS. Mode 1002 mouse tracking only fires on// cell change, so a timer is needed to continue scrolling while stationary.const AUTOSCROLL_LINES = 2;const AUTOSCROLL_INTERVAL_MS = 50;// Hard cap on consecutive auto-scroll ticks. If the release event is lost// (mouse released outside terminal window — some emulators don't capture the// pointer and drop the release), isDragging stays true and the timer would// run until a scroll boundary. Cap bounds the damage; any new drag motion// event restarts the count via check()→start().const AUTOSCROLL_MAX_TICKS = 200; // 10s @ 50ms
/** * Keyboard scroll navigation for the fullscreen layout's message scroll box. * PgUp/PgDn scroll by half-viewport. Mouse wheel scrolls by a few lines. * Scrolling breaks sticky mode; Ctrl+End re-enables it. Wheeling down at * the bottom also re-enables sticky so new content follows naturally. */export function ScrollKeybindingHandler({ scrollRef, isActive, onScroll, isModal = false}: Props): React.ReactNode { const selection = useSelection(); const { addNotification } = useNotifications(); // Lazy-inited on first wheel event so the XTVERSION probe (fired at // raw-mode-enable time) has resolved by then — initializing in useRef() // would read getWheelBase() before the probe reply arrives over SSH. const wheelAccel = useRef<WheelAccelState | null>(null); function showCopiedToast(text: string): void { // getClipboardPath reads env synchronously — predicts what setClipboard // did (native pbcopy / tmux load-buffer / raw OSC 52) so we can tell // the user whether paste will Just Work or needs prefix+]. const path = getClipboardPath(); const n = text.length; let msg: string; switch (path) { case 'native': msg = `copied ${n} chars to clipboard`; break; case 'tmux-buffer': msg = `copied ${n} chars to tmux buffer · paste with prefix + ]`; break; case 'osc52': msg = `sent ${n} chars via OSC 52 · check terminal clipboard settings if paste fails`; break; } addNotification({ key: 'selection-copied', text: msg, color: 'suggestion', priority: 'immediate', timeoutMs: path === 'native' ? 2000 : 4000 }); } function copyAndToast(): void { const text_0 = selection.copySelection(); if (text_0) showCopiedToast(text_0); }
// Translate selection to track a keyboard page jump. Selection coords are // screen-buffer-local; a scrollTo that moves content by N rows must also // shift anchor+focus by N so the highlight stays on the same text (native // terminal behavior: selection moves with content, clips at viewport // edges). Rows that scroll out of the viewport are captured into // scrolledOffAbove/Below before the scroll so getSelectedText still // returns the full text. Wheel scroll (scroll:lineUp/Down via scrollBy) // still clears — its async pendingScrollDelta drain means the actual // delta isn't known synchronously (follow-up). function translateSelectionForJump(s: ScrollBoxHandle, delta: number): void { const sel = selection.getState(); if (!sel?.anchor || !sel.focus) return; const top = s.getViewportTop(); const bottom = top + s.getViewportHeight() - 1; // Only translate if the selection is ON scrollbox content. Selections // in the footer/prompt/StickyPromptHeader are on static text — the // scroll doesn't move what's under them. Same guard as ink.tsx's // auto-follow translate (commit 36a8d154). if (sel.anchor.row < top || sel.anchor.row > bottom) return; // Cross-boundary: anchor in scrollbox, focus in footer/header. Mirror // ink.tsx's Flag-3 guard — fall through without shifting OR capturing. // The static endpoint pins the selection; shifting would teleport it // into scrollbox content. if (sel.focus.row < top || sel.focus.row > bottom) return; const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight()); const cur = s.getScrollTop() + s.getPendingDelta(); // Actual scroll distance after boundary clamp. jumpBy may call // scrollToBottom when target >= max but the view can't move past max, // so the selection shift is bounded here. const actual = Math.max(0, Math.min(max, cur + delta)) - cur; if (actual === 0) return; if (actual > 0) { // Scrolling down: content moves up. Rows at the TOP leave viewport. // Anchor+focus shift -actual so they track the content that moved up. selection.captureScrolledRows(top, top + actual - 1, 'above'); selection.shiftSelection(-actual, top, bottom); } else { // Scrolling up: content moves down. Rows at the BOTTOM leave viewport. const a = -actual; selection.captureScrolledRows(bottom - a + 1, bottom, 'below'); selection.shiftSelection(a, top, bottom); } } useKeybindings({ 'scroll:pageUp': () => { const s_0 = scrollRef.current; if (!s_0) return; const d = -Math.max(1, Math.floor(s_0.getViewportHeight() / 2)); translateSelectionForJump(s_0, d); const sticky = jumpBy(s_0, d); onScroll?.(sticky, s_0); }, 'scroll:pageDown': () => { const s_1 = scrollRef.current; if (!s_1) return; const d_0 = Math.max(1, Math.floor(s_1.getViewportHeight() / 2)); translateSelectionForJump(s_1, d_0); const sticky_0 = jumpBy(s_1, d_0); onScroll?.(sticky_0, s_1); }, 'scroll:lineUp': () => { // Wheel: scrollBy accumulates into pendingScrollDelta, drained async // by the renderer. captureScrolledRows can't read the outgoing rows // before they leave (drain is non-deterministic). Clear for now. selection.clearSelection(); const s_2 = scrollRef.current; // Return false (not consumed) when the ScrollBox content fits — // scroll would be a no-op. Lets a child component's handler take // the wheel event instead (e.g. Settings Config's list navigation // inside the centered Modal, where the paginated slice always fits). if (!s_2 || s_2.getScrollHeight() <= s_2.getViewportHeight()) return false; wheelAccel.current ??= initAndLogWheelAccel(); scrollUp(s_2, computeWheelStep(wheelAccel.current, -1, performance.now())); onScroll?.(false, s_2); }, 'scroll:lineDown': () => { selection.clearSelection(); const s_3 = scrollRef.current; if (!s_3 || s_3.getScrollHeight() <= s_3.getViewportHeight()) return false; wheelAccel.current ??= initAndLogWheelAccel(); const step = computeWheelStep(wheelAccel.current, 1, performance.now()); const reachedBottom = scrollDown(s_3, step); onScroll?.(reachedBottom, s_3); }, 'scroll:top': () => { const s_4 = scrollRef.current; if (!s_4) return; translateSelectionForJump(s_4, -(s_4.getScrollTop() + s_4.getPendingDelta())); s_4.scrollTo(0); onScroll?.(false, s_4); }, 'scroll:bottom': () => { const s_5 = scrollRef.current; if (!s_5) return; const max_0 = Math.max(0, s_5.getScrollHeight() - s_5.getViewportHeight()); translateSelectionForJump(s_5, max_0 - (s_5.getScrollTop() + s_5.getPendingDelta())); // scrollTo(max) eager-writes scrollTop so the render-phase sticky // follow computes followDelta=0. Without this, scrollToBottom() // alone leaves scrollTop stale → followDelta=max-stale → // shiftSelectionForFollow applies the SAME shift we already did // above, 2× offset. scrollToBottom() then re-enables sticky. s_5.scrollTo(max_0); s_5.scrollToBottom(); onScroll?.(true, s_5); }, 'selection:copy': copyAndToast }, { context: 'Scroll', isActive });
// scroll:halfPage*/fullPage* have no default key bindings — ctrl+u/d/b/f // all have real owners in normal mode (kill-line/exit/task:background/ // kill-agents). Transcript mode gets them via the isModal raw useInput // below. These handlers stay for custom rebinds only. useKeybindings({ 'scroll:halfPageUp': () => { const s_6 = scrollRef.current; if (!s_6) return; const d_1 = -Math.max(1, Math.floor(s_6.getViewportHeight() / 2)); translateSelectionForJump(s_6, d_1); const sticky_1 = jumpBy(s_6, d_1); onScroll?.(sticky_1, s_6); }, 'scroll:halfPageDown': () => { const s_7 = scrollRef.current; if (!s_7) return; const d_2 = Math.max(1, Math.floor(s_7.getViewportHeight() / 2)); translateSelectionForJump(s_7, d_2); const sticky_2 = jumpBy(s_7, d_2); onScroll?.(sticky_2, s_7); }, 'scroll:fullPageUp': () => { const s_8 = scrollRef.current; if (!s_8) return; const d_3 = -Math.max(1, s_8.getViewportHeight()); translateSelectionForJump(s_8, d_3); const sticky_3 = jumpBy(s_8, d_3); onScroll?.(sticky_3, s_8); }, 'scroll:fullPageDown': () => { const s_9 = scrollRef.current; if (!s_9) return; const d_4 = Math.max(1, s_9.getViewportHeight()); translateSelectionForJump(s_9, d_4); const sticky_4 = jumpBy(s_9, d_4); onScroll?.(sticky_4, s_9); } }, { context: 'Scroll', isActive });
// Modal pager keys — transcript mode only. less/tmux copy-mode lineage: // ctrl+u/d (half-page), ctrl+b/f (full-page), g/G (top/bottom). Tom's // resolution (2026-03-15): "In ctrl-o mode, ctrl-u, ctrl-d, etc. should // roughly just work!" — transcript is the copy-mode container. // // Safe because the conflicting handlers aren't reachable here: // ctrl+u → kill-line, ctrl+d → exit: PromptInput not mounted // ctrl+b → task:background: SessionBackgroundHint not mounted // ctrl+f → chat:killAgents moved to ctrl+x ctrl+k; no conflict // g/G → printable chars: no prompt to eat them, no vim/sticky gate needed // // TODO(search): `/`, n/N — build on Richard Kim's d94b07add4 (branch // claude/jump-recent-message-CEPcq). getItemY Yoga-walk + computeOrigin + // anchorY already solve scroll-to-index. jumpToPrevTurn is the n/N // template. Single-shot via OVERSCAN_ROWS=80; two-phase was tried and // abandoned (❯ oscillation). See team memory scroll-copy-mode-design.md. useInput((input, key, event) => { const s_10 = scrollRef.current; if (!s_10) return; const sticky_5 = applyModalPagerAction(s_10, modalPagerAction(input, key), d_5 => translateSelectionForJump(s_10, d_5)); if (sticky_5 === null) return; onScroll?.(sticky_5, s_10); event.stopImmediatePropagation(); }, { isActive: isActive && isModal });
// Esc clears selection; any other keystroke also clears it (matches // native terminal behavior where selection disappears on input). // Ctrl+C copies when a selection exists — needed on legacy terminals // where ctrl+shift+c sends the same byte (\x03, shift is lost) and // cmd+c never reaches the pty (terminal intercepts it for Edit > Copy). // Handled via raw useInput so we can conditionally consume: Esc/Ctrl+C // only stop propagation when a selection exists, letting them still work // for cancel-request / interrupt otherwise. Other keys never stop // propagation — they're observed to clear selection as a side-effect. // The selection:copy keybinding (ctrl+shift+c / cmd+c) registers above // via useKeybindings and consumes its event before reaching here. useInput((input_0, key_0, event_0) => { if (!selection.hasSelection()) return; if (key_0.escape) { selection.clearSelection(); event_0.stopImmediatePropagation(); return; } if (key_0.ctrl && !key_0.shift && !key_0.meta && input_0 === 'c') { copyAndToast(); event_0.stopImmediatePropagation(); return; } const move = selectionFocusMoveForKey(key_0); if (move) { selection.moveFocus(move); event_0.stopImmediatePropagation(); return; } if (shouldClearSelectionOnKey(key_0)) { selection.clearSelection(); } }, { isActive }); useDragToScroll(scrollRef, selection, isActive, onScroll); useCopyOnSelect(selection, isActive, showCopiedToast); useSelectionBgColor(selection); return null;}
/** * Auto-scroll the ScrollBox when the user drags a selection past its top or * bottom edge. The anchor is shifted in the opposite direction so it stays * on the same content (content that was at viewport row N is now at row N±d * after scrolling by d). Focus stays at the mouse position (edge row). * * Selection coords are screen-buffer-local, so the anchor is clamped to the * viewport bounds once the original content scrolls out. To preserve the full * selection, rows about to scroll out are captured into scrolledOffAbove/ * scrolledOffBelow before each scroll step and joined back in by * getSelectedText. */function useDragToScroll(scrollRef: RefObject<ScrollBoxHandle | null>, selection: ReturnType<typeof useSelection>, isActive: boolean, onScroll: Props['onScroll']): void { const timerRef = useRef<NodeJS.Timeout | null>(null); const dirRef = useRef<-1 | 0 | 1>(0); // -1 scrolling up, +1 down, 0 idle // Survives stop() — reset only on drag-finish. See check() for semantics. const lastScrolledDirRef = useRef<-1 | 0 | 1>(0); const ticksRef = useRef(0); // onScroll may change identity every render (if not memoized by caller). // Read through a ref so the effect doesn't re-subscribe and kill the timer // on each scroll-induced re-render. const onScrollRef = useRef(onScroll); onScrollRef.current = onScroll; useEffect(() => { if (!isActive) return; function stop(): void { dirRef.current = 0; if (timerRef.current) { clearInterval(timerRef.current); timerRef.current = null; } } function tick(): void { const sel = selection.getState(); const s = scrollRef.current; const dir = dirRef.current; // dir === 0 defends against a stale interval (start() may have set one // after the immediate tick already called stop() at a scroll boundary). // ticks cap defends against a lost release event (mouse released // outside terminal window) leaving isDragging stuck true. if (!sel?.isDragging || !sel.focus || !s || dir === 0 || ++ticksRef.current > AUTOSCROLL_MAX_TICKS) { stop(); return; } // scrollBy accumulates into pendingScrollDelta; the screen buffer // doesn't update until the next render drains it. If a previous // tick's scroll hasn't drained yet, captureScrolledRows would read // stale content (same rows as last tick → duplicated in the // accumulator AND missing the rows that actually scrolled out). // Skip this tick; the 50ms interval will retry after Ink's 16ms // render catches up. Also prevents shiftAnchor from desyncing. if (s.getPendingDelta() !== 0) return; const top = s.getViewportTop(); const bottom = top + s.getViewportHeight() - 1; // Clamp anchor within [top, bottom]. Not [0, bottom]: the ScrollBox // padding row at 0 would produce a blank line between scrolledOffAbove // and the on-screen content in getSelectedText. The padding-row // highlight was a minor visual nicety; text correctness wins. if (dir < 0) { if (s.getScrollTop() <= 0) { stop(); return; } // Scrolling up: content moves down in viewport, so anchor row +N. // Clamp to actual scroll distance so anchor stays in sync when near // the top boundary (renderer clamps scrollTop to 0 on drain). const actual = Math.min(AUTOSCROLL_LINES, s.getScrollTop()); // Capture rows about to scroll out the BOTTOM before scrollBy // overwrites them. Only rows inside the selection are captured // (captureScrolledRows intersects with selection bounds). selection.captureScrolledRows(bottom - actual + 1, bottom, 'below'); selection.shiftAnchor(actual, 0, bottom); s.scrollBy(-AUTOSCROLL_LINES); } else { const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight()); if (s.getScrollTop() >= max) { stop(); return; } // Scrolling down: content moves up in viewport, so anchor row -N. // Clamp to actual scroll distance so anchor stays in sync when near // the bottom boundary (renderer clamps scrollTop to max on drain). const actual_0 = Math.min(AUTOSCROLL_LINES, max - s.getScrollTop()); // Capture rows about to scroll out the TOP. selection.captureScrolledRows(top, top + actual_0 - 1, 'above'); selection.shiftAnchor(-actual_0, top, bottom); s.scrollBy(AUTOSCROLL_LINES); } onScrollRef.current?.(false, s); } function start(dir_0: -1 | 1): void { // Record BEFORE early-return: the empty-accumulator reset in check() // may have zeroed this during the pre-crossing phase (accumulators // empty until the anchor row enters the capture range). Re-record // on every call so the corruption is instantly healed. lastScrolledDirRef.current = dir_0; if (dirRef.current === dir_0) return; // already going this way stop(); dirRef.current = dir_0; ticksRef.current = 0; tick(); // tick() may have hit a scroll boundary and called stop() (dir reset to // 0). Only start the interval if we're still going — otherwise the // interval would run forever with dir === 0 doing nothing useful. if (dirRef.current === dir_0) { timerRef.current = setInterval(tick, AUTOSCROLL_INTERVAL_MS); } }
// Re-evaluated on every selection change (start/drag/finish/clear). // Drives drag-to-scroll autoscroll when the drag leaves the viewport. // Prior versions broke sticky here on drag-start to prevent selection // drift during streaming — ink.tsx now translates selection coords by // the follow delta instead (native terminal behavior: view keeps // scrolling, highlight walks up with the text). Keeping sticky also // avoids useVirtualScroll's tail-walk → forward-walk phantom growth. function check(): void { const s_0 = scrollRef.current; if (!s_0) { stop(); return; } const top_0 = s_0.getViewportTop(); const bottom_0 = top_0 + s_0.getViewportHeight() - 1; const sel_0 = selection.getState(); // Pass the LAST-scrolled direction (not dirRef) so the anchor guard is // bypassed after shiftAnchor has clamped anchor toward row 0. Using // lastScrolledDirRef (survives stop()) lets autoscroll resume after a // brief mouse dip into the viewport. Same-direction only — a mouse // jump from below-bottom to above-top must stop, since reversing while // the scrolledOffAbove/Below accumulators hold the prior direction's // rows would duplicate text in getSelectedText. Reset on drag-finish // OR when both accumulators are empty: startSelection clears them // (selection.ts), so a new drag after a lost-release (isDragging // stuck true, the reason AUTOSCROLL_MAX_TICKS exists) still resets. // Safe: start() below re-records lastScrolledDirRef before its // early-return, so a mid-scroll reset here is instantly undone. if (!sel_0?.isDragging || sel_0.scrolledOffAbove.length === 0 && sel_0.scrolledOffBelow.length === 0) { lastScrolledDirRef.current = 0; } const dir_1 = dragScrollDirection(sel_0, top_0, bottom_0, lastScrolledDirRef.current); if (dir_1 === 0) { // Blocked reversal: focus jumped to the opposite edge (off-window // drag return, fast flick). handleSelectionDrag already moved focus // past the anchor, flipping selectionBounds — the accumulator is // now orphaned (holds rows on the wrong side). Clear it so // getSelectedText matches the visible highlight. if (lastScrolledDirRef.current !== 0 && sel_0?.focus) { const want = sel_0.focus.row < top_0 ? -1 : sel_0.focus.row > bottom_0 ? 1 : 0; if (want !== 0 && want !== lastScrolledDirRef.current) { sel_0.scrolledOffAbove = []; sel_0.scrolledOffBelow = []; sel_0.scrolledOffAboveSW = []; sel_0.scrolledOffBelowSW = []; lastScrolledDirRef.current = 0; } } stop(); } else start(dir_1); } const unsubscribe = selection.subscribe(check); return () => { unsubscribe(); stop(); lastScrolledDirRef.current = 0; }; }, [isActive, scrollRef, selection]);}
/** * Compute autoscroll direction for a drag selection relative to the ScrollBox * viewport. Returns 0 when not dragging, anchor/focus missing, or the anchor * is outside the viewport — a multi-click or drag that started in the input * area must not commandeer the message scroll (double-click in the input area * while scrolled up previously corrupted the anchor via shiftAnchor and * spuriously scrolled the message history every 50ms until release). * * alreadyScrollingDir bypasses the anchor-in-viewport guard once autoscroll * is active (shiftAnchor legitimately clamps the anchor toward row 0, below * `top`) but only allows SAME-direction continuation. If the focus jumps to * the opposite edge (below→above or above→below — possible with a fast flick * or off-window drag since mode 1002 reports on cell change, not per cell), * returns 0 to stop — reversing without clearing scrolledOffAbove/Below * would duplicate captured rows when they scroll back on-screen. */export function dragScrollDirection(sel: SelectionState | null, top: number, bottom: number, alreadyScrollingDir: -1 | 0 | 1 = 0): -1 | 0 | 1 { if (!sel?.isDragging || !sel.anchor || !sel.focus) return 0; const row = sel.focus.row; const want: -1 | 0 | 1 = row < top ? -1 : row > bottom ? 1 : 0; if (alreadyScrollingDir !== 0) { // Same-direction only. Focus on the opposite side, or back inside the // viewport, stops the scroll — captured rows stay in scrolledOffAbove/ // Below but never scroll back on-screen, so getSelectedText is correct. return want === alreadyScrollingDir ? want : 0; } // Anchor must be inside the viewport for us to own this drag. If the // user started selecting in the input box or header, autoscrolling the // message history is surprising and corrupts the anchor via shiftAnchor. if (sel.anchor.row < top || sel.anchor.row > bottom) return 0; return want;}
// Keyboard page jumps: scrollTo() writes scrollTop directly and clears// pendingScrollDelta — one frame, no drain. scrollBy() accumulates into// pendingScrollDelta which the renderer drains over several frames// (render-node-to-output.ts drainProportional/drainAdaptive) — correct for// wheel smoothness, wrong for PgUp/ctrl+u where the user expects a snap.// Target is relative to scrollTop+pendingDelta so a jump mid-wheel-burst// lands where the wheel was heading.export function jumpBy(s: ScrollBoxHandle, delta: number): boolean { const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight()); const target = s.getScrollTop() + s.getPendingDelta() + delta; if (target >= max) { // Eager-write scrollTop so follow-scroll sees followDelta=0. Callers // that ran translateSelectionForJump already shifted; scrollToBottom() // alone would double-shift via the render-phase sticky follow. s.scrollTo(max); s.scrollToBottom(); return true; } s.scrollTo(Math.max(0, target)); return false;}
// Wheel-down past maxScroll re-enables sticky so wheeling at the bottom// naturally re-pins (matches typical chat-app behavior). Returns the// resulting sticky state so callers can propagate it.function scrollDown(s: ScrollBoxHandle, amount: number): boolean { const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight()); // Include pendingDelta: scrollBy accumulates into pendingScrollDelta // without updating scrollTop, so getScrollTop() alone is stale within // a batch of wheel events. Without this, wheeling to the bottom never // re-enables sticky scroll. const effectiveTop = s.getScrollTop() + s.getPendingDelta(); if (effectiveTop + amount >= max) { s.scrollToBottom(); return true; } s.scrollBy(amount); return false;}
// Wheel-up past scrollTop=0 clamps via scrollTo(0), clearing// pendingScrollDelta so aggressive wheel bursts (e.g. MX Master free-spin)// don't accumulate an unbounded negative delta. Without this clamp,// useVirtualScroll's [effLo, effHi] span grows past what MAX_MOUNTED_ITEMS// can cover and intermediate drain frames render at scrollTops with no// mounted children — blank viewport.export function scrollUp(s: ScrollBoxHandle, amount: number): void { // Include pendingDelta: scrollBy accumulates without updating scrollTop, // so getScrollTop() alone is stale within a batch of wheel events. const effectiveTop = s.getScrollTop() + s.getPendingDelta(); if (effectiveTop - amount <= 0) { s.scrollTo(0); return; } s.scrollBy(-amount);}export type ModalPagerAction = 'lineUp' | 'lineDown' | 'halfPageUp' | 'halfPageDown' | 'fullPageUp' | 'fullPageDown' | 'top' | 'bottom';
/** * Maps a keystroke to a modal pager action. Exported for testing. * Returns null for keys the modal pager doesn't handle (they fall through). * * ctrl+u/d/b/f are the less-lineage bindings. g/G are bare letters (only * safe when no prompt is mounted). G arrives as input='G' shift=false on * legacy terminals, or input='g' shift=true on kitty-protocol terminals. * Lowercase g needs the !shift guard so it doesn't also match kitty-G. * * Key-repeat: stdin coalesces held-down printables into one multi-char * string (e.g. 'ggg'). Only uniform-char batches are handled — mixed input * like 'gG' isn't key-repeat. g/G are idempotent absolute jumps, so the * count is irrelevant (consuming the batch just prevents it from leaking * to the selection-clear-on-printable handler). */export function modalPagerAction(input: string, key: Pick<Key, 'ctrl' | 'meta' | 'shift' | 'upArrow' | 'downArrow' | 'home' | 'end'>): ModalPagerAction | null { if (key.meta) return null; // Special keys first — arrows/home/end arrive with empty or junk input, // so these must be checked before any input-string logic. shift is // reserved for selection-extend (selectionFocusMoveForKey); ctrl+home/end // already has a useKeybindings route to scroll:top/bottom. if (!key.ctrl && !key.shift) { if (key.upArrow) return 'lineUp'; if (key.downArrow) return 'lineDown'; if (key.home) return 'top'; if (key.end) return 'bottom'; } if (key.ctrl) { if (key.shift) return null; switch (input) { case 'u': return 'halfPageUp'; case 'd': return 'halfPageDown'; case 'b': return 'fullPageUp'; case 'f': return 'fullPageDown'; // emacs-style line scroll (less accepts both ctrl+n/p and ctrl+e/y). // Works during search nav — fine-adjust after a jump without // leaving modal. No !searchOpen gate on this useInput's isActive. case 'n': return 'lineDown'; case 'p': return 'lineUp'; default: return null; } } // Bare letters. Key-repeat batches: only act on uniform runs. const c = input[0]; if (!c || input !== c.repeat(input.length)) return null; // kitty sends G as input='g' shift=true; legacy as 'G' shift=false. // Check BEFORE the shift-gate so both hit 'bottom'. if (c === 'G' || c === 'g' && key.shift) return 'bottom'; if (key.shift) return null; switch (c) { case 'g': return 'top'; // j/k re-added per Tom Mar 18 — reversal of Mar 16 removal. Works // during search nav (fine-adjust after n/N lands) since isModal is // independent of searchOpen. case 'j': return 'lineDown'; case 'k': return 'lineUp'; // less: space = page down, b = page up. ctrl+b already maps above; // bare b is the less-native version. case ' ': return 'fullPageDown'; case 'b': return 'fullPageUp'; default: return null; }}
/** * Applies a modal pager action to a ScrollBox. Returns the resulting sticky * state, or null if the action was null (nothing to do — caller should fall * through). Calls onBeforeJump(delta) before scrolling so the caller can * translate the text selection by the scroll delta (capture outgoing rows, * shift anchor+focus) instead of clearing it. Exported for testing. */export function applyModalPagerAction(s: ScrollBoxHandle, act: ModalPagerAction | null, onBeforeJump: (delta: number) => void): boolean | null { switch (act) { case null: return null; case 'lineUp': case 'lineDown': { const d = act === 'lineDown' ? 1 : -1; onBeforeJump(d); return jumpBy(s, d); } case 'halfPageUp': case 'halfPageDown': { const half = Math.max(1, Math.floor(s.getViewportHeight() / 2)); const d = act === 'halfPageDown' ? half : -half; onBeforeJump(d); return jumpBy(s, d); } case 'fullPageUp': case 'fullPageDown': { const page = Math.max(1, s.getViewportHeight()); const d = act === 'fullPageDown' ? page : -page; onBeforeJump(d); return jumpBy(s, d); } case 'top': onBeforeJump(-(s.getScrollTop() + s.getPendingDelta())); s.scrollTo(0); return false; case 'bottom': { const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight()); onBeforeJump(max - (s.getScrollTop() + s.getPendingDelta())); // Eager-write scrollTop before scrollToBottom — same double-shift // fix as scroll:bottom and jumpBy's max branch. s.scrollTo(max); s.scrollToBottom(); return true; } }}//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","RefObject","useEffect","useRef","useNotifications","useCopyOnSelect","useSelectionBgColor","ScrollBoxHandle","useSelection","FocusMove","SelectionState","isXtermJs","getClipboardPath","Key","useInput","useKeybindings","logForDebugging","Props","scrollRef","isActive","onScroll","sticky","handle","isModal","WHEEL_ACCEL_WINDOW_MS","WHEEL_ACCEL_STEP","WHEEL_ACCEL_MAX","WHEEL_BOUNCE_GAP_MAX_MS","WHEEL_MODE_STEP","WHEEL_MODE_CAP","WHEEL_MODE_RAMP","WHEEL_MODE_IDLE_DISENGAGE_MS","WHEEL_DECAY_HALFLIFE_MS","WHEEL_DECAY_STEP","WHEEL_BURST_MS","WHEEL_DECAY_GAP_MS","WHEEL_DECAY_CAP_SLOW","WHEEL_DECAY_CAP_FAST","WHEEL_DECAY_IDLE_MS","shouldClearSelectionOnKey","key","wheelUp","wheelDown","isNav","leftArrow","rightArrow","upArrow","downArrow","home","end","pageUp","pageDown","shift","meta","super","selectionFocusMoveForKey","WheelAccelState","time","mult","dir","xtermJs","frac","base","pendingFlip","wheelMode","burstCount","computeWheelStep","state","now","Math","floor","gap","m","pow","cap","max","next","min","sameDir","total","rows","readScrollSpeedBase","raw","process","env","CLAUDE_CODE_SCROLL_SPEED","n","parseFloat","Number","isNaN","initWheelAccel","initAndLogWheelAccel","TERM_PROGRAM","AUTOSCROLL_LINES","AUTOSCROLL_INTERVAL_MS","AUTOSCROLL_MAX_TICKS","ScrollKeybindingHandler","ReactNode","selection","addNotification","wheelAccel","showCopiedToast","text","path","length","msg","color","priority","timeoutMs","copyAndToast","copySelection","translateSelectionForJump","s","delta","sel","getState","anchor","focus","top","getViewportTop","bottom","getViewportHeight","row","getScrollHeight","cur","getScrollTop","getPendingDelta","actual","captureScrolledRows","shiftSelection","a","scroll:pageUp","current","d","jumpBy","scroll:pageDown","scroll:lineUp","clearSelection","scrollUp","performance","scroll:lineDown","step","reachedBottom","scrollDown","scroll:top","scrollTo","scroll:bottom","scrollToBottom","context","scroll:halfPageUp","scroll:halfPageDown","scroll:fullPageUp","scroll:fullPageDown","input","event","applyModalPagerAction","modalPagerAction","stopImmediatePropagation","hasSelection","escape","ctrl","move","moveFocus","useDragToScroll","ReturnType","timerRef","NodeJS","Timeout","dirRef","lastScrolledDirRef","ticksRef","onScrollRef","stop","clearInterval","tick","isDragging","shiftAnchor","scrollBy","start","setInterval","check","scrolledOffAbove","scrolledOffBelow","dragScrollDirection","want","scrolledOffAboveSW","scrolledOffBelowSW","unsubscribe","subscribe","alreadyScrollingDir","target","amount","effectiveTop","ModalPagerAction","Pick","c","repeat","act","onBeforeJump","half","page"],"sources":["ScrollKeybindingHandler.tsx"],"sourcesContent":["import React, { type RefObject, useEffect, useRef } from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport {\n  useCopyOnSelect,\n  useSelectionBgColor,\n} from '../hooks/useCopyOnSelect.js'\nimport type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'\nimport { useSelection } from '../ink/hooks/use-selection.js'\nimport type { FocusMove, SelectionState } from '../ink/selection.js'\nimport { isXtermJs } from '../ink/terminal.js'\nimport { getClipboardPath } from '../ink/termio/osc.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- Esc needs conditional propagation based on selection state\nimport { type Key, useInput } from '../ink.js'\nimport { useKeybindings } from '../keybindings/useKeybinding.js'\nimport { logForDebugging } from '../utils/debug.js'\n\ntype Props = {\n  scrollRef: RefObject<ScrollBoxHandle | null>\n  isActive: boolean\n  /** Called after every scroll action with the resulting sticky state and\n   *  the handle (for reading scrollTop/scrollHeight post-scroll). */\n  onScroll?: (sticky: boolean, handle: ScrollBoxHandle) => void\n  /** Enables modal pager keys (g/G, ctrl+u/d/b/f). Only safe when there\n   *  is no text input competing for those characters — i.e. transcript\n   *  mode. Defaults to false. When true, G works regardless of editorMode\n   *  and sticky state; ctrl+u/d/b/f don't conflict with kill-line/exit/\n   *  task:background/kill-agents (none are mounted, or they mount after\n   *  this component so stopImmediatePropagation wins). */\n  isModal?: boolean\n}\n\n// Terminals send one SGR wheel event per intended row (verified in Ghostty\n// src/Surface.zig: `for (0..@abs(y.delta)) |_| { mouseReport(.four, ...) }`).\n// Ghostty already 3×'s discrete wheel ticks before that loop; trackpad\n// precision scroll is pixels/cell_size. 1 event = 1 row intended — use it\n// as the base, and ramp a multiplier when events arrive rapidly. The\n// pendingScrollDelta accumulator + proportional drain in\n// render-node-to-output handles smooth catch-up on big bursts.\n//\n// xterm.js (VS Code/Cursor/Windsurf integrated terminals) sends exactly 1\n// event per wheel notch — no pre-amplification. A separate exponential\n// decay curve (below) compensates for the lower event rate, with burst\n// detection and gap-dependent caps tuned to VS Code's event patterns.\n\n// Native terminals: hard-window linear ramp. Events closer than the window\n// ramp the multiplier; idle gaps reset to `base` (default 1). Some emulators\n// pre-multiply at their layer (ghostty discrete=3 sends 3 SGR events/notch;\n// iTerm2 \"faster scroll\" similar) — base=1 is correct there. Others send 1\n// event/notch — users on those can set CLAUDE_CODE_SCROLL_SPEED=3 to match\n// vim/nvim/opencode app-side defaults. We can't detect which, so knob it.\nconst WHEEL_ACCEL_WINDOW_MS = 40\nconst WHEEL_ACCEL_STEP = 0.3\nconst WHEEL_ACCEL_MAX = 6\n\n// Encoder bounce debounce + wheel-mode decay curve. Worn/cheap optical\n// encoders emit spurious reverse-direction ticks during fast spins — measured\n// 28% of events on Boris's mouse (2026-03-17, iTerm2). Pattern is always\n// flip-then-flip-back; trackpads produce ZERO flips (0/458 in same recording).\n// A confirmed bounce proves a physical wheel is attached — engage the same\n// exponential-decay curve the xterm.js path uses (it's already tuned), with\n// a higher cap to compensate for the lower event rate (~9/sec vs VS Code's\n// ~30/sec). Trackpad can't reach this path.\n//\n// The decay curve gives: 1st click after idle = 1 row (precision), 2nd = 10,\n// 3rd = cap. Slowing down decays smoothly toward 1 — no separate idle\n// threshold needed, large gaps just have m≈0 → mult→1. Wheel mode is STICKY:\n// once a bounce confirms it's a mouse, the decay curve applies until an idle\n// gap or trackpad-flick-burst signals a possible device switch.\nconst WHEEL_BOUNCE_GAP_MAX_MS = 200 // flip-back must arrive within this\n// Mouse is ~9 events/sec vs VS Code's ~30 — STEP is 3× xterm.js's 5 to\n// compensate. At gap=100ms (m≈0.63): one click gives 1+15*0.63≈10.5.\nconst WHEEL_MODE_STEP = 15\nconst WHEEL_MODE_CAP = 15\n// Max mult growth per event. Without this, the +STEP*m term jumps mult\n// from 1→10 in one event when wheelMode engages mid-scroll (bounce\n// detected after N events in trackpad mode at mult=1). User sees scroll\n// suddenly go 10× faster. Cap=3 gives 1→4→7→10→13→15 over ~0.5s at\n// 9 events/sec — smooth ramp instead of a jump. Decay is unaffected\n// (target<mult wins the min).\nconst WHEEL_MODE_RAMP = 3\n// Device-switch disengage: mouse finger-repositions max at ~830ms (measured);\n// trackpad between-gesture pauses are 2000ms+. An idle gap above this means\n// the user stopped — might have switched devices. Disengage; the next mouse\n// bounce re-engages. Trackpad slow swipe (no <5ms bursts, so the burst-count\n// guard doesn't catch it) is what this protects against.\nconst WHEEL_MODE_IDLE_DISENGAGE_MS = 1500\n\n// xterm.js: exponential decay. momentum=0.5^(gap/hl) — slow click → m≈0\n// → mult→1 (precision); fast → m≈1 → carries momentum. Steady-state\n// = 1 + step×m/(1-m), capped. Measured event rates in VS Code (wheel.log):\n// sustained scroll sends events at 20-50ms gaps (20-40 Hz), plus 0-2ms\n// same-batch bursts on flicks. Cap is low (3–6, gap-dependent) because event\n// frequency is high — at 40 Hz × 6 = 240 rows/sec max demand, which the\n// adaptive drain at ~200fps (measured) handles. Higher cap → pending explosion.\n// Tuned empirically (boris 2026-03). See docs/research/terminal-scroll-*.\nconst WHEEL_DECAY_HALFLIFE_MS = 150\nconst WHEEL_DECAY_STEP = 5\n// Same-batch events (<BURST_MS) arrive in one stdin batch — the terminal\n// is doing proportional reporting. Treat as 1 row/event like native.\nconst WHEEL_BURST_MS = 5\n// Cap boundary: slow events (≥GAP_MS) cap low for short smooth drains;\n// fast events cap higher for throughput (adaptive drain handles backlog).\nconst WHEEL_DECAY_GAP_MS = 80\nconst WHEEL_DECAY_CAP_SLOW = 3 // gap ≥ GAP_MS: precision\nconst WHEEL_DECAY_CAP_FAST = 6 // gap < GAP_MS: throughput\n// Idle threshold: gaps beyond this reset to the kick value (2) so the\n// first click after a pause feels responsive regardless of direction.\nconst WHEEL_DECAY_IDLE_MS = 500\n\n/**\n * Whether a keypress should clear the virtual text selection. Mimics\n * native terminal selection: any keystroke clears, EXCEPT modified nav\n * keys (shift/opt/cmd + arrow/home/end/page*). In native macOS contexts,\n * shift+nav extends selection, and cmd/opt+nav are often intercepted by\n * the terminal emulator for scrollback nav — neither disturbs selection.\n * Bare arrows DO clear (user's cursor moves, native deselects). Wheel is\n * excluded — scroll:lineUp/Down already clears via the keybinding path.\n */\nexport function shouldClearSelectionOnKey(key: Key): boolean {\n  if (key.wheelUp || key.wheelDown) return false\n  const isNav =\n    key.leftArrow ||\n    key.rightArrow ||\n    key.upArrow ||\n    key.downArrow ||\n    key.home ||\n    key.end ||\n    key.pageUp ||\n    key.pageDown\n  if (isNav && (key.shift || key.meta || key.super)) return false\n  return true\n}\n\n/**\n * Map a keypress to a selection focus move (keyboard extension). Only\n * shift extends — that's the universal text-selection modifier. cmd\n * (super) only arrives via kitty keyboard protocol — in most terminals\n * cmd+arrow is intercepted by the emulator and never reaches the pty, so\n * no super branch. shift+home/end covers line-edge jumps (and fn+shift+\n * left/right on mac laptops = shift+home/end). shift+opt (word-jump) not\n * yet implemented — falls through to shouldClearSelectionOnKey which\n * preserves (modified nav). Returns null for non-extend keys.\n */\nexport function selectionFocusMoveForKey(key: Key): FocusMove | null {\n  if (!key.shift || key.meta) return null\n  if (key.leftArrow) return 'left'\n  if (key.rightArrow) return 'right'\n  if (key.upArrow) return 'up'\n  if (key.downArrow) return 'down'\n  if (key.home) return 'lineStart'\n  if (key.end) return 'lineEnd'\n  return null\n}\n\nexport type WheelAccelState = {\n  time: number\n  mult: number\n  dir: 0 | 1 | -1\n  xtermJs: boolean\n  /** Carried fractional scroll (xterm.js only). scrollBy floors, so without\n   *  this a mult of 1.5 gives 1 row every time. Carrying the remainder gives\n   *  1,2,1,2 on average for mult=1.5 — correct throughput over time. */\n  frac: number\n  /** Native-path baseline rows/event. Reset value on idle/reversal; ramp\n   *  builds on top. xterm.js path ignores this (own kick=2 tuning). */\n  base: number\n  /** Deferred direction flip (native only). Might be encoder bounce or a\n   *  real reversal — resolved by the NEXT event. Real reversal loses 1 row\n   *  of latency; bounce is swallowed and triggers wheel mode. The flip's\n   *  direction and timestamp are derivable (it's always -state.dir at\n   *  state.time) so this is just a marker. */\n  pendingFlip: boolean\n  /** Set true once a bounce is confirmed (flip-then-flip-back within\n   *  BOUNCE_GAP_MAX). Sticky — but disengaged on idle gap >1500ms OR a\n   *  trackpad-signature burst (see burstCount). State lives in a useRef so\n   *  it persists across device switches; the disengages handle mouse→trackpad. */\n  wheelMode: boolean\n  /** Consecutive <5ms events. Trackpad flick produces 100+ at <5ms; mouse\n   *  produces ≤3 (verified in /tmp/wheel-tune.txt). 5+ in a row → trackpad\n   *  signature → disengage wheel mode so device-switch doesn't leak mouse\n   *  accel to trackpad. */\n  burstCount: number\n}\n\n/** Compute rows for one wheel event, mutating accel state. Returns 0 when\n *  a direction flip is deferred for bounce detection — call sites no-op on\n *  step=0 (scrollBy(0) is a no-op, onScroll(false) is idempotent). Exported\n *  for tests. */\nexport function computeWheelStep(\n  state: WheelAccelState,\n  dir: 1 | -1,\n  now: number,\n): number {\n  if (!state.xtermJs) {\n    // Device-switch guard ①: idle disengage. Runs BEFORE pendingFlip resolve\n    // so a pending bounce (28% of last-mouse-events) doesn't bypass it via\n    // the real-reversal early return. state.time is either the last committed\n    // event OR the deferred flip — both count as \"last activity\".\n    if (state.wheelMode && now - state.time > WHEEL_MODE_IDLE_DISENGAGE_MS) {\n      state.wheelMode = false\n      state.burstCount = 0\n      state.mult = state.base\n    }\n\n    // Resolve any deferred flip BEFORE touching state.time/dir — we need the\n    // pre-flip state.dir to distinguish bounce (flip-back) from real reversal\n    // (flip persisted), and state.time (= bounce timestamp) for the gap check.\n    if (state.pendingFlip) {\n      state.pendingFlip = false\n      if (dir !== state.dir || now - state.time > WHEEL_BOUNCE_GAP_MAX_MS) {\n        // Real reversal: new dir persisted, OR flip-back arrived too late.\n        // Commit. The deferred event's 1 row is lost (acceptable latency).\n        state.dir = dir\n        state.time = now\n        state.mult = state.base\n        return Math.floor(state.mult)\n      }\n      // Bounce confirmed: flipped back to original dir within the window.\n      // state.dir/mult unchanged from pre-bounce. state.time was advanced to\n      // the bounce below, so gap here = flip-back interval — reflects the\n      // user's actual click cadence (bounce IS a physical click, just noisy).\n      state.wheelMode = true\n    }\n\n    const gap = now - state.time\n    if (dir !== state.dir && state.dir !== 0) {\n      // Flip. Defer — next event decides bounce vs. real reversal. Advance\n      // time (but NOT dir/mult): if this turns out to be a bounce, the\n      // confirm event's gap will be the flip-back interval, which reflects\n      // the user's actual click rate. The bounce IS a physical wheel click,\n      // just misread by the encoder — it should count toward cadence.\n      state.pendingFlip = true\n      state.time = now\n      return 0\n    }\n    state.dir = dir\n    state.time = now\n\n    // ─── MOUSE (wheel mode, sticky until device-switch signal) ───\n    if (state.wheelMode) {\n      if (gap < WHEEL_BURST_MS) {\n        // Same-batch burst check (ported from xterm.js): iTerm2 proportional\n        // reporting sends 2+ SGR events for one detent when macOS gives\n        // delta>1. Without this, the 2nd event at gap<1ms has m≈1 → STEP*m=15\n        // → one gentle click gives 1+15=16 rows.\n        //\n        // Device-switch guard ②: trackpad flick produces 100+ events at <5ms\n        // (measured); mouse produces ≤3. 5+ consecutive → trackpad flick.\n        if (++state.burstCount >= 5) {\n          state.wheelMode = false\n          state.burstCount = 0\n          state.mult = state.base\n        } else {\n          return 1\n        }\n      } else {\n        state.burstCount = 0\n      }\n    }\n    // Re-check: may have disengaged above.\n    if (state.wheelMode) {\n      // xterm.js decay curve with STEP×3, higher cap. No idle threshold —\n      // the curve handles it (gap=1000ms → m≈0.01 → mult≈1). No frac —\n      // rounding loss is minor at high mult, and frac persisting across idle\n      // was causing off-by-one on the first click back.\n      const m = Math.pow(0.5, gap / WHEEL_DECAY_HALFLIFE_MS)\n      const cap = Math.max(WHEEL_MODE_CAP, state.base * 2)\n      const next = 1 + (state.mult - 1) * m + WHEEL_MODE_STEP * m\n      state.mult = Math.min(cap, next, state.mult + WHEEL_MODE_RAMP)\n      return Math.floor(state.mult)\n    }\n\n    // ─── TRACKPAD / HI-RES (native, non-wheel-mode) ───\n    // Tight 40ms burst window: sub-40ms events ramp, anything slower resets.\n    // Trackpad flick delivers 200+ events at <20ms gaps → rails to cap 6.\n    // Trackpad slow swipe at 40-400ms gaps → resets every event → 1 row each.\n    if (gap > WHEEL_ACCEL_WINDOW_MS) {\n      state.mult = state.base\n    } else {\n      const cap = Math.max(WHEEL_ACCEL_MAX, state.base * 2)\n      state.mult = Math.min(cap, state.mult + WHEEL_ACCEL_STEP)\n    }\n    return Math.floor(state.mult)\n  }\n\n  // ─── VSCODE (xterm.js, browser wheel events) ───\n  // Browser wheel events — no encoder bounce, no SGR bursts. Decay curve\n  // unchanged from the original tuning. Same formula shape as wheel mode\n  // above (keep in sync) but STEP=5 not 15 — higher event rate here.\n  const gap = now - state.time\n  const sameDir = dir === state.dir\n  state.time = now\n  state.dir = dir\n  // xterm.js path. Debug log shows two patterns: (a) 20-50ms gaps during\n  // sustained scroll (~30 Hz), (b) <5ms same-batch bursts on flicks. For\n  // (b) give 1 row/event — the burst count IS the acceleration, same as\n  // native. For (a) the decay curve gives 3-5 rows. For sparse events\n  // (100ms+, slow deliberate scroll) the curve gives 1-3.\n  if (sameDir && gap < WHEEL_BURST_MS) return 1\n  if (!sameDir || gap > WHEEL_DECAY_IDLE_MS) {\n    // Direction reversal or long idle: start at 2 (not 1) so the first\n    // click after a pause moves a visible amount. Without this, idle-\n    // then-resume in the same direction decays to mult≈1 (1 row).\n    state.mult = 2\n    state.frac = 0\n  } else {\n    const m = Math.pow(0.5, gap / WHEEL_DECAY_HALFLIFE_MS)\n    const cap =\n      gap >= WHEEL_DECAY_GAP_MS ? WHEEL_DECAY_CAP_SLOW : WHEEL_DECAY_CAP_FAST\n    state.mult = Math.min(cap, 1 + (state.mult - 1) * m + WHEEL_DECAY_STEP * m)\n  }\n  const total = state.mult + state.frac\n  const rows = Math.floor(total)\n  state.frac = total - rows\n  return rows\n}\n\n/** Read CLAUDE_CODE_SCROLL_SPEED, default 1, clamp (0, 20].\n *  Some terminals pre-multiply wheel events (ghostty discrete=3, iTerm2\n *  \"faster scroll\") — base=1 is correct there. Others send 1 event/notch —\n *  set CLAUDE_CODE_SCROLL_SPEED=3 to match vim/nvim/opencode. We can't\n *  detect which kind of terminal we're in, hence the knob. Called lazily\n *  from initAndLogWheelAccel so globalSettings.env has loaded. */\nexport function readScrollSpeedBase(): number {\n  const raw = process.env.CLAUDE_CODE_SCROLL_SPEED\n  if (!raw) return 1\n  const n = parseFloat(raw)\n  return Number.isNaN(n) || n <= 0 ? 1 : Math.min(n, 20)\n}\n\n/** Initial wheel accel state. xtermJs=true selects the decay curve.\n *  base is the native-path baseline rows/event (default 1). */\nexport function initWheelAccel(xtermJs = false, base = 1): WheelAccelState {\n  return {\n    time: 0,\n    mult: base,\n    dir: 0,\n    xtermJs,\n    frac: 0,\n    base,\n    pendingFlip: false,\n    wheelMode: false,\n    burstCount: 0,\n  }\n}\n\n// Lazy-init helper. isXtermJs() combines the TERM_PROGRAM env check + async\n// XTVERSION probe — the probe may not have resolved at render time, so this\n// is called on the first wheel event (>>50ms after startup) when it's settled.\n// Logs detected mode once so --debug users can verify SSH detection worked.\n// The renderer also calls isXtermJsHost() (in render-node-to-output) to\n// select the drain algorithm — no state to pass through.\nfunction initAndLogWheelAccel(): WheelAccelState {\n  const xtermJs = isXtermJs()\n  const base = readScrollSpeedBase()\n  logForDebugging(\n    `wheel accel: ${xtermJs ? 'decay (xterm.js)' : 'window (native)'} · base=${base} · TERM_PROGRAM=${process.env.TERM_PROGRAM ?? 'unset'}`,\n  )\n  return initWheelAccel(xtermJs, base)\n}\n\n// Drag-to-scroll: when dragging past the viewport edge, scroll by this many\n// rows every AUTOSCROLL_INTERVAL_MS. Mode 1002 mouse tracking only fires on\n// cell change, so a timer is needed to continue scrolling while stationary.\nconst AUTOSCROLL_LINES = 2\nconst AUTOSCROLL_INTERVAL_MS = 50\n// Hard cap on consecutive auto-scroll ticks. If the release event is lost\n// (mouse released outside terminal window — some emulators don't capture the\n// pointer and drop the release), isDragging stays true and the timer would\n// run until a scroll boundary. Cap bounds the damage; any new drag motion\n// event restarts the count via check()→start().\nconst AUTOSCROLL_MAX_TICKS = 200 // 10s @ 50ms\n\n/**\n * Keyboard scroll navigation for the fullscreen layout's message scroll box.\n * PgUp/PgDn scroll by half-viewport. Mouse wheel scrolls by a few lines.\n * Scrolling breaks sticky mode; Ctrl+End re-enables it. Wheeling down at\n * the bottom also re-enables sticky so new content follows naturally.\n */\nexport function ScrollKeybindingHandler({\n  scrollRef,\n  isActive,\n  onScroll,\n  isModal = false,\n}: Props): React.ReactNode {\n  const selection = useSelection()\n  const { addNotification } = useNotifications()\n  // Lazy-inited on first wheel event so the XTVERSION probe (fired at\n  // raw-mode-enable time) has resolved by then — initializing in useRef()\n  // would read getWheelBase() before the probe reply arrives over SSH.\n  const wheelAccel = useRef<WheelAccelState | null>(null)\n\n  function showCopiedToast(text: string): void {\n    // getClipboardPath reads env synchronously — predicts what setClipboard\n    // did (native pbcopy / tmux load-buffer / raw OSC 52) so we can tell\n    // the user whether paste will Just Work or needs prefix+].\n    const path = getClipboardPath()\n    const n = text.length\n    let msg: string\n    switch (path) {\n      case 'native':\n        msg = `copied ${n} chars to clipboard`\n        break\n      case 'tmux-buffer':\n        msg = `copied ${n} chars to tmux buffer · paste with prefix + ]`\n        break\n      case 'osc52':\n        msg = `sent ${n} chars via OSC 52 · check terminal clipboard settings if paste fails`\n        break\n    }\n    addNotification({\n      key: 'selection-copied',\n      text: msg,\n      color: 'suggestion',\n      priority: 'immediate',\n      timeoutMs: path === 'native' ? 2000 : 4000,\n    })\n  }\n\n  function copyAndToast(): void {\n    const text = selection.copySelection()\n    if (text) showCopiedToast(text)\n  }\n\n  // Translate selection to track a keyboard page jump. Selection coords are\n  // screen-buffer-local; a scrollTo that moves content by N rows must also\n  // shift anchor+focus by N so the highlight stays on the same text (native\n  // terminal behavior: selection moves with content, clips at viewport\n  // edges). Rows that scroll out of the viewport are captured into\n  // scrolledOffAbove/Below before the scroll so getSelectedText still\n  // returns the full text. Wheel scroll (scroll:lineUp/Down via scrollBy)\n  // still clears — its async pendingScrollDelta drain means the actual\n  // delta isn't known synchronously (follow-up).\n  function translateSelectionForJump(s: ScrollBoxHandle, delta: number): void {\n    const sel = selection.getState()\n    if (!sel?.anchor || !sel.focus) return\n    const top = s.getViewportTop()\n    const bottom = top + s.getViewportHeight() - 1\n    // Only translate if the selection is ON scrollbox content. Selections\n    // in the footer/prompt/StickyPromptHeader are on static text — the\n    // scroll doesn't move what's under them. Same guard as ink.tsx's\n    // auto-follow translate (commit 36a8d154).\n    if (sel.anchor.row < top || sel.anchor.row > bottom) return\n    // Cross-boundary: anchor in scrollbox, focus in footer/header. Mirror\n    // ink.tsx's Flag-3 guard — fall through without shifting OR capturing.\n    // The static endpoint pins the selection; shifting would teleport it\n    // into scrollbox content.\n    if (sel.focus.row < top || sel.focus.row > bottom) return\n    const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight())\n    const cur = s.getScrollTop() + s.getPendingDelta()\n    // Actual scroll distance after boundary clamp. jumpBy may call\n    // scrollToBottom when target >= max but the view can't move past max,\n    // so the selection shift is bounded here.\n    const actual = Math.max(0, Math.min(max, cur + delta)) - cur\n    if (actual === 0) return\n    if (actual > 0) {\n      // Scrolling down: content moves up. Rows at the TOP leave viewport.\n      // Anchor+focus shift -actual so they track the content that moved up.\n      selection.captureScrolledRows(top, top + actual - 1, 'above')\n      selection.shiftSelection(-actual, top, bottom)\n    } else {\n      // Scrolling up: content moves down. Rows at the BOTTOM leave viewport.\n      const a = -actual\n      selection.captureScrolledRows(bottom - a + 1, bottom, 'below')\n      selection.shiftSelection(a, top, bottom)\n    }\n  }\n\n  useKeybindings(\n    {\n      'scroll:pageUp': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const d = -Math.max(1, Math.floor(s.getViewportHeight() / 2))\n        translateSelectionForJump(s, d)\n        const sticky = jumpBy(s, d)\n        onScroll?.(sticky, s)\n      },\n      'scroll:pageDown': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const d = Math.max(1, Math.floor(s.getViewportHeight() / 2))\n        translateSelectionForJump(s, d)\n        const sticky = jumpBy(s, d)\n        onScroll?.(sticky, s)\n      },\n      'scroll:lineUp': () => {\n        // Wheel: scrollBy accumulates into pendingScrollDelta, drained async\n        // by the renderer. captureScrolledRows can't read the outgoing rows\n        // before they leave (drain is non-deterministic). Clear for now.\n        selection.clearSelection()\n        const s = scrollRef.current\n        // Return false (not consumed) when the ScrollBox content fits —\n        // scroll would be a no-op. Lets a child component's handler take\n        // the wheel event instead (e.g. Settings Config's list navigation\n        // inside the centered Modal, where the paginated slice always fits).\n        if (!s || s.getScrollHeight() <= s.getViewportHeight()) return false\n        wheelAccel.current ??= initAndLogWheelAccel()\n        scrollUp(s, computeWheelStep(wheelAccel.current, -1, performance.now()))\n        onScroll?.(false, s)\n      },\n      'scroll:lineDown': () => {\n        selection.clearSelection()\n        const s = scrollRef.current\n        if (!s || s.getScrollHeight() <= s.getViewportHeight()) return false\n        wheelAccel.current ??= initAndLogWheelAccel()\n        const step = computeWheelStep(wheelAccel.current, 1, performance.now())\n        const reachedBottom = scrollDown(s, step)\n        onScroll?.(reachedBottom, s)\n      },\n      'scroll:top': () => {\n        const s = scrollRef.current\n        if (!s) return\n        translateSelectionForJump(s, -(s.getScrollTop() + s.getPendingDelta()))\n        s.scrollTo(0)\n        onScroll?.(false, s)\n      },\n      'scroll:bottom': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight())\n        translateSelectionForJump(\n          s,\n          max - (s.getScrollTop() + s.getPendingDelta()),\n        )\n        // scrollTo(max) eager-writes scrollTop so the render-phase sticky\n        // follow computes followDelta=0. Without this, scrollToBottom()\n        // alone leaves scrollTop stale → followDelta=max-stale →\n        // shiftSelectionForFollow applies the SAME shift we already did\n        // above, 2× offset. scrollToBottom() then re-enables sticky.\n        s.scrollTo(max)\n        s.scrollToBottom()\n        onScroll?.(true, s)\n      },\n      'selection:copy': copyAndToast,\n    },\n    { context: 'Scroll', isActive },\n  )\n\n  // scroll:halfPage*/fullPage* have no default key bindings — ctrl+u/d/b/f\n  // all have real owners in normal mode (kill-line/exit/task:background/\n  // kill-agents). Transcript mode gets them via the isModal raw useInput\n  // below. These handlers stay for custom rebinds only.\n  useKeybindings(\n    {\n      'scroll:halfPageUp': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const d = -Math.max(1, Math.floor(s.getViewportHeight() / 2))\n        translateSelectionForJump(s, d)\n        const sticky = jumpBy(s, d)\n        onScroll?.(sticky, s)\n      },\n      'scroll:halfPageDown': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const d = Math.max(1, Math.floor(s.getViewportHeight() / 2))\n        translateSelectionForJump(s, d)\n        const sticky = jumpBy(s, d)\n        onScroll?.(sticky, s)\n      },\n      'scroll:fullPageUp': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const d = -Math.max(1, s.getViewportHeight())\n        translateSelectionForJump(s, d)\n        const sticky = jumpBy(s, d)\n        onScroll?.(sticky, s)\n      },\n      'scroll:fullPageDown': () => {\n        const s = scrollRef.current\n        if (!s) return\n        const d = Math.max(1, s.getViewportHeight())\n        translateSelectionForJump(s, d)\n        const sticky = jumpBy(s, d)\n        onScroll?.(sticky, s)\n      },\n    },\n    { context: 'Scroll', isActive },\n  )\n\n  // Modal pager keys — transcript mode only. less/tmux copy-mode lineage:\n  // ctrl+u/d (half-page), ctrl+b/f (full-page), g/G (top/bottom). Tom's\n  // resolution (2026-03-15): \"In ctrl-o mode, ctrl-u, ctrl-d, etc. should\n  // roughly just work!\" — transcript is the copy-mode container.\n  //\n  // Safe because the conflicting handlers aren't reachable here:\n  //   ctrl+u → kill-line, ctrl+d → exit: PromptInput not mounted\n  //   ctrl+b → task:background: SessionBackgroundHint not mounted\n  //   ctrl+f → chat:killAgents moved to ctrl+x ctrl+k; no conflict\n  //   g/G → printable chars: no prompt to eat them, no vim/sticky gate needed\n  //\n  // TODO(search): `/`, n/N — build on Richard Kim's d94b07add4 (branch\n  // claude/jump-recent-message-CEPcq). getItemY Yoga-walk + computeOrigin +\n  // anchorY already solve scroll-to-index. jumpToPrevTurn is the n/N\n  // template. Single-shot via OVERSCAN_ROWS=80; two-phase was tried and\n  // abandoned (❯ oscillation). See team memory scroll-copy-mode-design.md.\n  useInput(\n    (input, key, event) => {\n      const s = scrollRef.current\n      if (!s) return\n      const sticky = applyModalPagerAction(s, modalPagerAction(input, key), d =>\n        translateSelectionForJump(s, d),\n      )\n      if (sticky === null) return\n      onScroll?.(sticky, s)\n      event.stopImmediatePropagation()\n    },\n    { isActive: isActive && isModal },\n  )\n\n  // Esc clears selection; any other keystroke also clears it (matches\n  // native terminal behavior where selection disappears on input).\n  // Ctrl+C copies when a selection exists — needed on legacy terminals\n  // where ctrl+shift+c sends the same byte (\\x03, shift is lost) and\n  // cmd+c never reaches the pty (terminal intercepts it for Edit > Copy).\n  // Handled via raw useInput so we can conditionally consume: Esc/Ctrl+C\n  // only stop propagation when a selection exists, letting them still work\n  // for cancel-request / interrupt otherwise. Other keys never stop\n  // propagation — they're observed to clear selection as a side-effect.\n  // The selection:copy keybinding (ctrl+shift+c / cmd+c) registers above\n  // via useKeybindings and consumes its event before reaching here.\n  useInput(\n    (input, key, event) => {\n      if (!selection.hasSelection()) return\n      if (key.escape) {\n        selection.clearSelection()\n        event.stopImmediatePropagation()\n        return\n      }\n      if (key.ctrl && !key.shift && !key.meta && input === 'c') {\n        copyAndToast()\n        event.stopImmediatePropagation()\n        return\n      }\n      const move = selectionFocusMoveForKey(key)\n      if (move) {\n        selection.moveFocus(move)\n        event.stopImmediatePropagation()\n        return\n      }\n      if (shouldClearSelectionOnKey(key)) {\n        selection.clearSelection()\n      }\n    },\n    { isActive },\n  )\n\n  useDragToScroll(scrollRef, selection, isActive, onScroll)\n  useCopyOnSelect(selection, isActive, showCopiedToast)\n  useSelectionBgColor(selection)\n\n  return null\n}\n\n/**\n * Auto-scroll the ScrollBox when the user drags a selection past its top or\n * bottom edge. The anchor is shifted in the opposite direction so it stays\n * on the same content (content that was at viewport row N is now at row N±d\n * after scrolling by d). Focus stays at the mouse position (edge row).\n *\n * Selection coords are screen-buffer-local, so the anchor is clamped to the\n * viewport bounds once the original content scrolls out. To preserve the full\n * selection, rows about to scroll out are captured into scrolledOffAbove/\n * scrolledOffBelow before each scroll step and joined back in by\n * getSelectedText.\n */\nfunction useDragToScroll(\n  scrollRef: RefObject<ScrollBoxHandle | null>,\n  selection: ReturnType<typeof useSelection>,\n  isActive: boolean,\n  onScroll: Props['onScroll'],\n): void {\n  const timerRef = useRef<NodeJS.Timeout | null>(null)\n  const dirRef = useRef<-1 | 0 | 1>(0) // -1 scrolling up, +1 down, 0 idle\n  // Survives stop() — reset only on drag-finish. See check() for semantics.\n  const lastScrolledDirRef = useRef<-1 | 0 | 1>(0)\n  const ticksRef = useRef(0)\n  // onScroll may change identity every render (if not memoized by caller).\n  // Read through a ref so the effect doesn't re-subscribe and kill the timer\n  // on each scroll-induced re-render.\n  const onScrollRef = useRef(onScroll)\n  onScrollRef.current = onScroll\n\n  useEffect(() => {\n    if (!isActive) return\n\n    function stop(): void {\n      dirRef.current = 0\n      if (timerRef.current) {\n        clearInterval(timerRef.current)\n        timerRef.current = null\n      }\n    }\n\n    function tick(): void {\n      const sel = selection.getState()\n      const s = scrollRef.current\n      const dir = dirRef.current\n      // dir === 0 defends against a stale interval (start() may have set one\n      // after the immediate tick already called stop() at a scroll boundary).\n      // ticks cap defends against a lost release event (mouse released\n      // outside terminal window) leaving isDragging stuck true.\n      if (\n        !sel?.isDragging ||\n        !sel.focus ||\n        !s ||\n        dir === 0 ||\n        ++ticksRef.current > AUTOSCROLL_MAX_TICKS\n      ) {\n        stop()\n        return\n      }\n      // scrollBy accumulates into pendingScrollDelta; the screen buffer\n      // doesn't update until the next render drains it. If a previous\n      // tick's scroll hasn't drained yet, captureScrolledRows would read\n      // stale content (same rows as last tick → duplicated in the\n      // accumulator AND missing the rows that actually scrolled out).\n      // Skip this tick; the 50ms interval will retry after Ink's 16ms\n      // render catches up. Also prevents shiftAnchor from desyncing.\n      if (s.getPendingDelta() !== 0) return\n      const top = s.getViewportTop()\n      const bottom = top + s.getViewportHeight() - 1\n      // Clamp anchor within [top, bottom]. Not [0, bottom]: the ScrollBox\n      // padding row at 0 would produce a blank line between scrolledOffAbove\n      // and the on-screen content in getSelectedText. The padding-row\n      // highlight was a minor visual nicety; text correctness wins.\n      if (dir < 0) {\n        if (s.getScrollTop() <= 0) {\n          stop()\n          return\n        }\n        // Scrolling up: content moves down in viewport, so anchor row +N.\n        // Clamp to actual scroll distance so anchor stays in sync when near\n        // the top boundary (renderer clamps scrollTop to 0 on drain).\n        const actual = Math.min(AUTOSCROLL_LINES, s.getScrollTop())\n        // Capture rows about to scroll out the BOTTOM before scrollBy\n        // overwrites them. Only rows inside the selection are captured\n        // (captureScrolledRows intersects with selection bounds).\n        selection.captureScrolledRows(bottom - actual + 1, bottom, 'below')\n        selection.shiftAnchor(actual, 0, bottom)\n        s.scrollBy(-AUTOSCROLL_LINES)\n      } else {\n        const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight())\n        if (s.getScrollTop() >= max) {\n          stop()\n          return\n        }\n        // Scrolling down: content moves up in viewport, so anchor row -N.\n        // Clamp to actual scroll distance so anchor stays in sync when near\n        // the bottom boundary (renderer clamps scrollTop to max on drain).\n        const actual = Math.min(AUTOSCROLL_LINES, max - s.getScrollTop())\n        // Capture rows about to scroll out the TOP.\n        selection.captureScrolledRows(top, top + actual - 1, 'above')\n        selection.shiftAnchor(-actual, top, bottom)\n        s.scrollBy(AUTOSCROLL_LINES)\n      }\n      onScrollRef.current?.(false, s)\n    }\n\n    function start(dir: -1 | 1): void {\n      // Record BEFORE early-return: the empty-accumulator reset in check()\n      // may have zeroed this during the pre-crossing phase (accumulators\n      // empty until the anchor row enters the capture range). Re-record\n      // on every call so the corruption is instantly healed.\n      lastScrolledDirRef.current = dir\n      if (dirRef.current === dir) return // already going this way\n      stop()\n      dirRef.current = dir\n      ticksRef.current = 0\n      tick()\n      // tick() may have hit a scroll boundary and called stop() (dir reset to\n      // 0). Only start the interval if we're still going — otherwise the\n      // interval would run forever with dir === 0 doing nothing useful.\n      if (dirRef.current === dir) {\n        timerRef.current = setInterval(tick, AUTOSCROLL_INTERVAL_MS)\n      }\n    }\n\n    // Re-evaluated on every selection change (start/drag/finish/clear).\n    // Drives drag-to-scroll autoscroll when the drag leaves the viewport.\n    // Prior versions broke sticky here on drag-start to prevent selection\n    // drift during streaming — ink.tsx now translates selection coords by\n    // the follow delta instead (native terminal behavior: view keeps\n    // scrolling, highlight walks up with the text). Keeping sticky also\n    // avoids useVirtualScroll's tail-walk → forward-walk phantom growth.\n    function check(): void {\n      const s = scrollRef.current\n      if (!s) {\n        stop()\n        return\n      }\n      const top = s.getViewportTop()\n      const bottom = top + s.getViewportHeight() - 1\n      const sel = selection.getState()\n      // Pass the LAST-scrolled direction (not dirRef) so the anchor guard is\n      // bypassed after shiftAnchor has clamped anchor toward row 0. Using\n      // lastScrolledDirRef (survives stop()) lets autoscroll resume after a\n      // brief mouse dip into the viewport. Same-direction only — a mouse\n      // jump from below-bottom to above-top must stop, since reversing while\n      // the scrolledOffAbove/Below accumulators hold the prior direction's\n      // rows would duplicate text in getSelectedText. Reset on drag-finish\n      // OR when both accumulators are empty: startSelection clears them\n      // (selection.ts), so a new drag after a lost-release (isDragging\n      // stuck true, the reason AUTOSCROLL_MAX_TICKS exists) still resets.\n      // Safe: start() below re-records lastScrolledDirRef before its\n      // early-return, so a mid-scroll reset here is instantly undone.\n      if (\n        !sel?.isDragging ||\n        (sel.scrolledOffAbove.length === 0 && sel.scrolledOffBelow.length === 0)\n      ) {\n        lastScrolledDirRef.current = 0\n      }\n      const dir = dragScrollDirection(\n        sel,\n        top,\n        bottom,\n        lastScrolledDirRef.current,\n      )\n      if (dir === 0) {\n        // Blocked reversal: focus jumped to the opposite edge (off-window\n        // drag return, fast flick). handleSelectionDrag already moved focus\n        // past the anchor, flipping selectionBounds — the accumulator is\n        // now orphaned (holds rows on the wrong side). Clear it so\n        // getSelectedText matches the visible highlight.\n        if (lastScrolledDirRef.current !== 0 && sel?.focus) {\n          const want = sel.focus.row < top ? -1 : sel.focus.row > bottom ? 1 : 0\n          if (want !== 0 && want !== lastScrolledDirRef.current) {\n            sel.scrolledOffAbove = []\n            sel.scrolledOffBelow = []\n            sel.scrolledOffAboveSW = []\n            sel.scrolledOffBelowSW = []\n            lastScrolledDirRef.current = 0\n          }\n        }\n        stop()\n      } else start(dir)\n    }\n\n    const unsubscribe = selection.subscribe(check)\n    return () => {\n      unsubscribe()\n      stop()\n      lastScrolledDirRef.current = 0\n    }\n  }, [isActive, scrollRef, selection])\n}\n\n/**\n * Compute autoscroll direction for a drag selection relative to the ScrollBox\n * viewport. Returns 0 when not dragging, anchor/focus missing, or the anchor\n * is outside the viewport — a multi-click or drag that started in the input\n * area must not commandeer the message scroll (double-click in the input area\n * while scrolled up previously corrupted the anchor via shiftAnchor and\n * spuriously scrolled the message history every 50ms until release).\n *\n * alreadyScrollingDir bypasses the anchor-in-viewport guard once autoscroll\n * is active (shiftAnchor legitimately clamps the anchor toward row 0, below\n * `top`) but only allows SAME-direction continuation. If the focus jumps to\n * the opposite edge (below→above or above→below — possible with a fast flick\n * or off-window drag since mode 1002 reports on cell change, not per cell),\n * returns 0 to stop — reversing without clearing scrolledOffAbove/Below\n * would duplicate captured rows when they scroll back on-screen.\n */\nexport function dragScrollDirection(\n  sel: SelectionState | null,\n  top: number,\n  bottom: number,\n  alreadyScrollingDir: -1 | 0 | 1 = 0,\n): -1 | 0 | 1 {\n  if (!sel?.isDragging || !sel.anchor || !sel.focus) return 0\n  const row = sel.focus.row\n  const want: -1 | 0 | 1 = row < top ? -1 : row > bottom ? 1 : 0\n  if (alreadyScrollingDir !== 0) {\n    // Same-direction only. Focus on the opposite side, or back inside the\n    // viewport, stops the scroll — captured rows stay in scrolledOffAbove/\n    // Below but never scroll back on-screen, so getSelectedText is correct.\n    return want === alreadyScrollingDir ? want : 0\n  }\n  // Anchor must be inside the viewport for us to own this drag. If the\n  // user started selecting in the input box or header, autoscrolling the\n  // message history is surprising and corrupts the anchor via shiftAnchor.\n  if (sel.anchor.row < top || sel.anchor.row > bottom) return 0\n  return want\n}\n\n// Keyboard page jumps: scrollTo() writes scrollTop directly and clears\n// pendingScrollDelta — one frame, no drain. scrollBy() accumulates into\n// pendingScrollDelta which the renderer drains over several frames\n// (render-node-to-output.ts drainProportional/drainAdaptive) — correct for\n// wheel smoothness, wrong for PgUp/ctrl+u where the user expects a snap.\n// Target is relative to scrollTop+pendingDelta so a jump mid-wheel-burst\n// lands where the wheel was heading.\nexport function jumpBy(s: ScrollBoxHandle, delta: number): boolean {\n  const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight())\n  const target = s.getScrollTop() + s.getPendingDelta() + delta\n  if (target >= max) {\n    // Eager-write scrollTop so follow-scroll sees followDelta=0. Callers\n    // that ran translateSelectionForJump already shifted; scrollToBottom()\n    // alone would double-shift via the render-phase sticky follow.\n    s.scrollTo(max)\n    s.scrollToBottom()\n    return true\n  }\n  s.scrollTo(Math.max(0, target))\n  return false\n}\n\n// Wheel-down past maxScroll re-enables sticky so wheeling at the bottom\n// naturally re-pins (matches typical chat-app behavior). Returns the\n// resulting sticky state so callers can propagate it.\nfunction scrollDown(s: ScrollBoxHandle, amount: number): boolean {\n  const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight())\n  // Include pendingDelta: scrollBy accumulates into pendingScrollDelta\n  // without updating scrollTop, so getScrollTop() alone is stale within\n  // a batch of wheel events. Without this, wheeling to the bottom never\n  // re-enables sticky scroll.\n  const effectiveTop = s.getScrollTop() + s.getPendingDelta()\n  if (effectiveTop + amount >= max) {\n    s.scrollToBottom()\n    return true\n  }\n  s.scrollBy(amount)\n  return false\n}\n\n// Wheel-up past scrollTop=0 clamps via scrollTo(0), clearing\n// pendingScrollDelta so aggressive wheel bursts (e.g. MX Master free-spin)\n// don't accumulate an unbounded negative delta. Without this clamp,\n// useVirtualScroll's [effLo, effHi] span grows past what MAX_MOUNTED_ITEMS\n// can cover and intermediate drain frames render at scrollTops with no\n// mounted children — blank viewport.\nexport function scrollUp(s: ScrollBoxHandle, amount: number): void {\n  // Include pendingDelta: scrollBy accumulates without updating scrollTop,\n  // so getScrollTop() alone is stale within a batch of wheel events.\n  const effectiveTop = s.getScrollTop() + s.getPendingDelta()\n  if (effectiveTop - amount <= 0) {\n    s.scrollTo(0)\n    return\n  }\n  s.scrollBy(-amount)\n}\n\nexport type ModalPagerAction =\n  | 'lineUp'\n  | 'lineDown'\n  | 'halfPageUp'\n  | 'halfPageDown'\n  | 'fullPageUp'\n  | 'fullPageDown'\n  | 'top'\n  | 'bottom'\n\n/**\n * Maps a keystroke to a modal pager action. Exported for testing.\n * Returns null for keys the modal pager doesn't handle (they fall through).\n *\n * ctrl+u/d/b/f are the less-lineage bindings. g/G are bare letters (only\n * safe when no prompt is mounted). G arrives as input='G' shift=false on\n * legacy terminals, or input='g' shift=true on kitty-protocol terminals.\n * Lowercase g needs the !shift guard so it doesn't also match kitty-G.\n *\n * Key-repeat: stdin coalesces held-down printables into one multi-char\n * string (e.g. 'ggg'). Only uniform-char batches are handled — mixed input\n * like 'gG' isn't key-repeat. g/G are idempotent absolute jumps, so the\n * count is irrelevant (consuming the batch just prevents it from leaking\n * to the selection-clear-on-printable handler).\n */\nexport function modalPagerAction(\n  input: string,\n  key: Pick<\n    Key,\n    'ctrl' | 'meta' | 'shift' | 'upArrow' | 'downArrow' | 'home' | 'end'\n  >,\n): ModalPagerAction | null {\n  if (key.meta) return null\n  // Special keys first — arrows/home/end arrive with empty or junk input,\n  // so these must be checked before any input-string logic. shift is\n  // reserved for selection-extend (selectionFocusMoveForKey); ctrl+home/end\n  // already has a useKeybindings route to scroll:top/bottom.\n  if (!key.ctrl && !key.shift) {\n    if (key.upArrow) return 'lineUp'\n    if (key.downArrow) return 'lineDown'\n    if (key.home) return 'top'\n    if (key.end) return 'bottom'\n  }\n  if (key.ctrl) {\n    if (key.shift) return null\n    switch (input) {\n      case 'u':\n        return 'halfPageUp'\n      case 'd':\n        return 'halfPageDown'\n      case 'b':\n        return 'fullPageUp'\n      case 'f':\n        return 'fullPageDown'\n      // emacs-style line scroll (less accepts both ctrl+n/p and ctrl+e/y).\n      // Works during search nav — fine-adjust after a jump without\n      // leaving modal. No !searchOpen gate on this useInput's isActive.\n      case 'n':\n        return 'lineDown'\n      case 'p':\n        return 'lineUp'\n      default:\n        return null\n    }\n  }\n  // Bare letters. Key-repeat batches: only act on uniform runs.\n  const c = input[0]\n  if (!c || input !== c.repeat(input.length)) return null\n  // kitty sends G as input='g' shift=true; legacy as 'G' shift=false.\n  // Check BEFORE the shift-gate so both hit 'bottom'.\n  if (c === 'G' || (c === 'g' && key.shift)) return 'bottom'\n  if (key.shift) return null\n  switch (c) {\n    case 'g':\n      return 'top'\n    // j/k re-added per Tom Mar 18 — reversal of Mar 16 removal. Works\n    // during search nav (fine-adjust after n/N lands) since isModal is\n    // independent of searchOpen.\n    case 'j':\n      return 'lineDown'\n    case 'k':\n      return 'lineUp'\n    // less: space = page down, b = page up. ctrl+b already maps above;\n    // bare b is the less-native version.\n    case ' ':\n      return 'fullPageDown'\n    case 'b':\n      return 'fullPageUp'\n    default:\n      return null\n  }\n}\n\n/**\n * Applies a modal pager action to a ScrollBox. Returns the resulting sticky\n * state, or null if the action was null (nothing to do — caller should fall\n * through). Calls onBeforeJump(delta) before scrolling so the caller can\n * translate the text selection by the scroll delta (capture outgoing rows,\n * shift anchor+focus) instead of clearing it. Exported for testing.\n */\nexport function applyModalPagerAction(\n  s: ScrollBoxHandle,\n  act: ModalPagerAction | null,\n  onBeforeJump: (delta: number) => void,\n): boolean | null {\n  switch (act) {\n    case null:\n      return null\n    case 'lineUp':\n    case 'lineDown': {\n      const d = act === 'lineDown' ? 1 : -1\n      onBeforeJump(d)\n      return jumpBy(s, d)\n    }\n    case 'halfPageUp':\n    case 'halfPageDown': {\n      const half = Math.max(1, Math.floor(s.getViewportHeight() / 2))\n      const d = act === 'halfPageDown' ? half : -half\n      onBeforeJump(d)\n      return jumpBy(s, d)\n    }\n    case 'fullPageUp':\n    case 'fullPageDown': {\n      const page = Math.max(1, s.getViewportHeight())\n      const d = act === 'fullPageDown' ? page : -page\n      onBeforeJump(d)\n      return jumpBy(s, d)\n    }\n    case 'top':\n      onBeforeJump(-(s.getScrollTop() + s.getPendingDelta()))\n      s.scrollTo(0)\n      return false\n    case 'bottom': {\n      const max = Math.max(0, s.getScrollHeight() - s.getViewportHeight())\n      onBeforeJump(max - (s.getScrollTop() + s.getPendingDelta()))\n      // Eager-write scrollTop before scrollToBottom — same double-shift\n      // fix as scroll:bottom and jumpBy's max branch.\n      s.scrollTo(max)\n      s.scrollToBottom()\n      return true\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}