claude-code / components / ScrollKeybindingHandler.tsx

import 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 state
import { 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: precision
const 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":[]}