hermes-agent/ui-tui/packages/hermes-ink/src/ink/ink.tsx

import { closeSync, constants as fsConstants, openSync, readSync, writeSync } from 'fs'
import { format } from 'util'

import autoBind from 'auto-bind'
import noop from 'lodash-es/noop.js'
import throttle from 'lodash-es/throttle.js'
import React, { type ReactNode } from 'react'
import type { FiberRoot } from 'react-reconciler'
import { ConcurrentRoot } from 'react-reconciler/constants.js'
import { onExit } from 'signal-exit'

import { flushInteractionTime } from '../bootstrap/state.js'
import { getYogaCounters } from '../native-ts/yoga-layout/index.js'
import { logForDebugging } from '../utils/debug.js'
import { logError } from '../utils/log.js'

import { colorize } from './colorize.js'
import App from './components/App.js'
import type { CursorAdvanceNotifier } from './components/CursorAdvanceContext.js'
import type { CursorDeclaration, CursorDeclarationSetter } from './components/CursorDeclarationContext.js'
import { FRAME_INTERVAL_MS } from './constants.js'
import * as dom from './dom.js'
import { markDirty } from './dom.js'
import { KeyboardEvent } from './events/keyboard-event.js'
import { FocusManager } from './focus.js'
import { emptyFrame, type Frame, type FrameEvent } from './frame.js'
import { dispatchClick, dispatchHover, dispatchMouse } from './hit-test.js'
import { applyHyperlinkHoverHighlight } from './hyperlinkHover.js'
import instances from './instances.js'
import { LogUpdate } from './log-update.js'
import { nodeCache } from './node-cache.js'
import { optimize } from './optimizer.js'
import Output from './output.js'
import type { ParsedKey } from './parse-keypress.js'
import reconciler, {
  dispatcher,
  getLastCommitMs,
  getLastYogaMs,
  recordYogaMs,
  resetProfileCounters
} from './reconciler.js'
import renderNodeToOutput, { consumeFollowScroll, didLayoutShift } from './render-node-to-output.js'
import { applyPositionedHighlight, type MatchPosition, scanPositions } from './render-to-screen.js'
import createRenderer, { type Renderer } from './renderer.js'
import {
  cellAt,
  CellWidth,
  CharPool,
  createScreen,
  HyperlinkPool,
  isEmptyCellAt,
  migrateScreenPools,
  StylePool
} from './screen.js'
import { applySearchHighlight } from './searchHighlight.js'
import {
  applySelectionOverlay,
  captureScrolledRows,
  clearSelection,
  createSelectionState,
  extendSelection,
  findPlainTextUrlAt,
  type FocusMove,
  getSelectedText,
  hasSelection,
  moveFocus,
  selectionBounds,
  selectionSignature,
  type SelectionState,
  selectLineAt,
  selectWordAt,
  shiftAnchor,
  shiftSelection,
  shiftSelectionForFollow,
  startSelection,
  updateSelection
} from './selection.js'
import {
  needsAltScreenResizeScrollbackClear,
  supportsExtendedKeys,
  SYNC_OUTPUT_SUPPORTED,
  type Terminal,
  writeDiffToTerminal
} from './terminal.js'
import {
  CURSOR_HOME,
  cursorMove,
  cursorPosition,
  DISABLE_KITTY_KEYBOARD,
  DISABLE_MODIFY_OTHER_KEYS,
  ENABLE_KITTY_KEYBOARD,
  ENABLE_MODIFY_OTHER_KEYS,
  ERASE_SCREEN,
  ERASE_SCROLLBACK
} from './termio/csi.js'
import {
  DBP,
  DFE,
  DISABLE_MOUSE_TRACKING,
  ENABLE_MOUSE_TRACKING,
  ENTER_ALT_SCREEN,
  EXIT_ALT_SCREEN,
  SHOW_CURSOR
} from './termio/dec.js'
import {
  CLEAR_ITERM2_PROGRESS,
  CLEAR_TAB_STATUS,
  setClipboard,
  supportsTabStatus,
  wrapForMultiplexer
} from './termio/osc.js'
import { TerminalWriteProvider } from './useTerminalNotification.js'

// Alt-screen: renderer.ts sets cursor.visible = !isTTY || screen.height===0,
// which is always false in alt-screen (TTY + content fills screen).
// Reusing a frozen object saves 1 allocation per frame.
const ALT_SCREEN_ANCHOR_CURSOR = Object.freeze({
  x: 0,
  y: 0,
  visible: false
})

const CURSOR_HOME_PATCH = Object.freeze({
  type: 'stdout' as const,
  content: CURSOR_HOME
})

const ERASE_THEN_HOME_PATCH = Object.freeze({
  type: 'stdout' as const,
  content: ERASE_SCREEN + CURSOR_HOME
})

const DEEP_ERASE_THEN_HOME_PATCH = Object.freeze({
  type: 'stdout' as const,
  content: ERASE_SCREEN + ERASE_SCROLLBACK + CURSOR_HOME
})

// Cached per-Ink-instance, invalidated on resize. frame.cursor.y for
// alt-screen is always terminalRows - 1 (renderer.ts).
function makeAltScreenParkPatch(terminalRows: number) {
  return Object.freeze({
    type: 'stdout' as const,
    content: cursorPosition(terminalRows, 1)
  })
}

export type Options = {
  stdout: NodeJS.WriteStream
  stdin: NodeJS.ReadStream
  stderr: NodeJS.WriteStream
  exitOnCtrlC: boolean
  patchConsole: boolean
  waitUntilExit?: () => Promise<void>
  onFrame?: (event: FrameEvent) => void
  /**
   * Called when a click lands on a cell with an OSC 8 hyperlink (or a
   * plain-text URL detected by findPlainTextUrlAt). The host is responsible
   * for opening the URL — `child_process.spawn` with an argv array (NOT
   * shell-mode) to the platform's native opener: `open` on macOS,
   * `xdg-open` on Linux/BSD, `explorer.exe` on Windows. Avoid
   * `cmd.exe /c start` — `start` is a cmd builtin that reparses the URL
   * through cmd's tokenizer (`&` / `|` / `^` / `<` / `>` get split or
   * reinterpreted), which both breaks plain URLs with `&` in query
   * strings and undermines any caller-side protocol allowlist. Without
   * this wired up, links rendered by `<Link>` look underlined but do
   * nothing on click in any terminal where mouse tracking is on
   * (Cmd+click is consumed by the TUI, not Terminal.app).
   */
  onHyperlinkClick?: (url: string) => void
}
export default class Ink {
  private readonly log: LogUpdate
  private readonly terminal: Terminal
  private scheduleRender: (() => void) & {
    cancel?: () => void
  }
  // Ignore last render after unmounting a tree to prevent empty output before exit
  private isUnmounted = false
  private isPaused = false
  private readonly container: FiberRoot
  private rootNode: dom.DOMElement
  readonly focusManager: FocusManager
  private renderer: Renderer
  private readonly stylePool: StylePool
  private charPool: CharPool
  private hyperlinkPool: HyperlinkPool
  private exitPromise?: Promise<void>
  private restoreConsole?: () => void
  private restoreStderr?: () => void
  private readonly unsubscribeTTYHandlers?: () => void
  private terminalColumns: number
  private terminalRows: number
  private currentNode: ReactNode = null
  private frontFrame: Frame
  private backFrame: Frame
  private lastPoolResetTime = performance.now()
  private drainTimer: ReturnType<typeof setTimeout> | null = null
  // Write-drain telemetry: pendingWriteStart is the performance.now() of
  // the most recent stdout.write waiting for its drain callback.  Set to
  // null when the callback fires (drained).  Read on the NEXT frame and
  // reported as prevFrameDrainMs so the FrameEvent records how long the
  // previous write took to actually hit the terminal — distinguishes
  // "queued in Node" (write returned true) from "terminal accepted bytes"
  // (callback fired).
  private pendingWriteStart: number | null = null
  private lastDrainMs = 0
  private lastYogaCounters: {
    ms: number
    visited: number
    measured: number
    cacheHits: number
    live: number
  } = {
    ms: 0,
    visited: 0,
    measured: 0,
    cacheHits: 0,
    live: 0
  }
  private altScreenParkPatch: Readonly<{
    type: 'stdout'
    content: string
  }>
  // Text selection state (alt-screen only). Owned here so the overlay
  // pass in onRender can read it and App.tsx can update it from mouse
  // events. Public so instances.get() callers can access.
  readonly selection: SelectionState = createSelectionState()
  // Search highlight query (alt-screen only). Setter below triggers
  // scheduleRender; applySearchHighlight in onRender inverts matching cells.
  private searchHighlightQuery = ''
  // Position-based highlight. VML scans positions ONCE (via
  // scanElementSubtree, when the target message is mounted), stores them
  // message-relative, sets this for every-frame apply. rowOffset =
  // message's current screen-top. currentIdx = which position is
  // "current" (yellow). null clears. Positions are known upfront —
  // navigation is index arithmetic, no scan-feedback loop.
  private searchPositions: {
    positions: MatchPosition[]
    rowOffset: number
    currentIdx: number
  } | null = null
  // React-land subscribers for selection state changes (useHasSelection).
  // Fired alongside the terminal repaint whenever the selection mutates
  // so UI (e.g. footer hints) can react to selection appearing/clearing.
  private readonly selectionListeners = new Set<() => void>()
  private selectionVersion = 0
  private lastSelectionSignature = ''
  // DOM nodes currently under the pointer (mode-1003 motion). Held here
  // so App.tsx's handleMouseEvent is stateless — dispatchHover diffs
  // against this set and mutates it in place.
  private readonly hoveredNodes = new Set<dom.DOMElement>()

  // The OSC 8 hyperlink URL under the pointer, or undefined when the cursor
  // isn't on a link. Updated from dispatchHover; consumed by the render-pass
  // overlay (applyHyperlinkHoverHighlight) to invert link cells under the
  // pointer. This is the closest the TUI can get to the desktop's
  // cursor-changes-on-hover affordance — terminals don't expose cursor
  // shape control to applications.
  private hoveredHyperlink: string | undefined = undefined

  // Last value of hoveredHyperlink that we actually painted. Compared in
  // onRender so we can scope full-screen damage to enter/leave/change
  // transitions, not every steady-state hover frame.
  private lastRenderedHoveredHyperlink: string | undefined = undefined
  // Set by <AlternateScreen> via setAltScreenActive(). Controls the
  // renderer's cursor.y clamping (keeps cursor in-viewport to avoid
  // LF-induced scroll when screen.height === terminalRows) and gates
  // alt-screen-aware SIGCONT/resize/unmount handling.
  private altScreenActive = false
  // Set alongside altScreenActive so SIGCONT resume knows whether to
  // re-enable mouse tracking (not all <AlternateScreen> uses want it).
  private altScreenMouseTracking = false
  // True when the previous frame's screen buffer cannot be trusted for
  // blit — selection overlay mutated it, resetFramesForAltScreen()
  // replaced it with blanks, or forceRedraw() reset it to 0×0. Forces
  // one full-render frame; steady-state frames after clear it and regain
  // the blit + narrow-damage fast path.
  private prevFrameContaminated = false
  // Set by handleResize: prepend ERASE_SCREEN to the next onRender's patches
  // INSIDE the BSU/ESU block so clear+paint is atomic. Writing ERASE_SCREEN
  // synchronously in handleResize would leave the screen blank for the ~80ms
  // render() takes; deferring into the atomic block means old content stays
  // visible until the new frame is fully ready.
  private needsEraseBeforePaint = false
  // Native cursor positioning: a component (via useDeclaredCursor) declares
  // where the terminal cursor should be parked after each frame. Terminal
  // emulators render IME preedit text at the physical cursor position, and
  // screen readers / screen magnifiers track it — so parking at the text
  // input's caret makes CJK input appear inline and lets a11y tools follow.
  private cursorDeclaration: CursorDeclaration | null = null
  // Main-screen: physical cursor position after the declared-cursor move,
  // tracked separately from frame.cursor (which must stay at content-bottom
  // for log-update's relative-move invariants). Alt-screen doesn't need
  // this — every frame begins with CSI H. null = no move emitted last frame.
  private displayCursor: {
    x: number
    y: number
  } | null = null
  // Burst of SIGWINCH (vscode panel drag) → one React commit per
  // microtask. Dims are captured sync in handleResize; only the
  // expensive tree rebuild defers.
  private pendingResizeRender = false
  private resizeSettleTimer: ReturnType<typeof setTimeout> | null = null

  // Fold synchronous re-entry (selection fanout, onFrame callback)
  // into one follow-up microtask instead of stacking renders.
  private isRendering = false
  private immediateRerenderRequested = false
  private selectionDragCell: { col: number; row: number } | null = null
  private selectionAutoScrollTimer: ReturnType<typeof setInterval> | null = null
  private selectionAutoScrollDir: -1 | 0 | 1 = 0
  constructor(private readonly options: Options) {
    autoBind(this)

    if (this.options.patchConsole) {
      this.restoreConsole = this.patchConsole()
      this.restoreStderr = this.patchStderr()
    }

    // Host-supplied hyperlink-open callback. The mouse-event pipeline
    // (App.tsx → onOpenHyperlink → Ink.openHyperlink → onHyperlinkClick)
    // is fully wired internally; without this assignment the optional
    // chain in openHyperlink() bails silently and clicks on URLs do
    // nothing. The field stays writable so tests / debug overlays can
    // still rebind it after construction.
    this.onHyperlinkClick = options.onHyperlinkClick

    this.terminal = {
      stdout: options.stdout,
      stderr: options.stderr
    }
    this.terminalColumns = options.stdout.columns || 80
    this.terminalRows = options.stdout.rows || 24
    this.altScreenParkPatch = makeAltScreenParkPatch(this.terminalRows)
    this.stylePool = new StylePool()
    this.charPool = new CharPool()
    this.hyperlinkPool = new HyperlinkPool()
    this.frontFrame = emptyFrame(
      this.terminalRows,
      this.terminalColumns,
      this.stylePool,
      this.charPool,
      this.hyperlinkPool
    )
    this.backFrame = emptyFrame(
      this.terminalRows,
      this.terminalColumns,
      this.stylePool,
      this.charPool,
      this.hyperlinkPool
    )
    this.log = new LogUpdate({
      isTTY: (options.stdout.isTTY as boolean | undefined) || false,
      stylePool: this.stylePool
    })

    // scheduleRender is called from the reconciler's resetAfterCommit, which
    // runs BEFORE React's layout phase (ref attach + useLayoutEffect). Any
    // state set in layout effects — notably the cursorDeclaration from
    // useDeclaredCursor — would lag one commit behind if we rendered
    // synchronously. Deferring to a microtask runs onRender after layout
    // effects have committed, so the native cursor tracks the caret without
    // a one-keystroke lag. Same event-loop tick, so throughput is unchanged.
    // Test env uses onImmediateRender (direct onRender, no throttle) so
    // existing synchronous lastFrame() tests are unaffected.
    const deferredRender = (): void => queueMicrotask(this.onRender)
    this.scheduleRender = throttle(deferredRender, FRAME_INTERVAL_MS, {
      leading: true,
      trailing: true
    })

    // Ignore last render after unmounting a tree to prevent empty output before exit
    this.isUnmounted = false

    // Unmount when process exits
    this.unsubscribeExit = onExit(this.unmount, {
      alwaysLast: false
    })

    if (options.stdout.isTTY) {
      options.stdout.on('resize', this.handleResize)
      process.on('SIGCONT', this.handleResume)

      this.unsubscribeTTYHandlers = () => {
        options.stdout.off('resize', this.handleResize)
        process.off('SIGCONT', this.handleResume)
      }
    }

    this.rootNode = dom.createNode('ink-root')
    this.focusManager = new FocusManager((target, event) => dispatcher.dispatchDiscrete(target, event))
    this.rootNode.focusManager = this.focusManager
    this.renderer = createRenderer(this.rootNode, this.stylePool)
    this.rootNode.onRender = this.scheduleRender
    this.rootNode.onImmediateRender = this.onRender

    this.rootNode.onComputeLayout = () => {
      // Calculate layout during React's commit phase so useLayoutEffect hooks
      // have access to fresh layout data
      // Guard against accessing freed Yoga nodes after unmount
      if (this.isUnmounted) {
        return
      }

      if (this.rootNode.yogaNode) {
        const t0 = performance.now()
        this.rootNode.yogaNode.setWidth(this.terminalColumns)
        this.rootNode.yogaNode.calculateLayout(this.terminalColumns)
        const ms = performance.now() - t0
        recordYogaMs(ms)
        const c = getYogaCounters()
        this.lastYogaCounters = {
          ms,
          ...c
        }
      }
    }

    this.container = reconciler.createContainer(
      this.rootNode,
      ConcurrentRoot,
      null,
      false,
      null,
      'id',
      noop,
      // onUncaughtError
      noop,
      // onCaughtError
      noop,
      // onRecoverableError
      noop // onDefaultTransitionIndicator
    )

    if (process.env.NODE_ENV === 'development') {
      reconciler.injectIntoDevTools({
        bundleType: 0,
        // Reporting React DOM's version, not Ink's
        // See https://github.com/facebook/react/issues/16666#issuecomment-532639905
        version: '16.13.1',
        rendererPackageName: 'ink'
      })
    }
  }
  private handleResume = () => {
    if (!this.options.stdout.isTTY) {
      return
    }

    // Alt screen: after SIGCONT, content is stale (shell may have written
    // to main screen, switching focus away) and mouse tracking was
    // disabled by handleSuspend.
    if (this.altScreenActive) {
      this.reenterAltScreen()

      return
    }

    // Main screen: start fresh to prevent clobbering terminal content
    this.frontFrame = emptyFrame(
      this.frontFrame.viewport.height,
      this.frontFrame.viewport.width,
      this.stylePool,
      this.charPool,
      this.hyperlinkPool
    )
    this.backFrame = emptyFrame(
      this.backFrame.viewport.height,
      this.backFrame.viewport.width,
      this.stylePool,
      this.charPool,
      this.hyperlinkPool
    )
    this.log.reset()
    // Physical cursor position is unknown after the shell took over during
    // suspend. Clear displayCursor so the next frame's cursor preamble
    // doesn't emit a relative move from a stale park position.
    this.displayCursor = null
  }

  // Dims captured sync — closes the stale-dim window the original
  // debounce rejection warned about. Expensive React commit defers to
  // one microtask per burst: vscode fires many SIGWINCHes per panel
  // drag, each ~80ms uncoalesced = event loop visibly locks up.
  private handleResize = () => {
    const cols = this.options.stdout.columns || 80
    const rows = this.options.stdout.rows || 24
    const dimsChanged = cols !== this.terminalColumns || rows !== this.terminalRows

    // Terminals often emit 2+ resize events for one user action
    // (window settling). Same-dimension events are usually no-ops,
    // but in alt-screen mode a same-dimension resize can signal a
    // terminal host reflow or buffer restore that leaves stale glyphs
    // on the physical screen — treat it as a repaint signal.
    if (!dimsChanged && !(this.altScreenActive && !this.isPaused && this.options.stdout.isTTY)) {
      return
    }

    if (dimsChanged) {
      this.terminalColumns = cols
      this.terminalRows = rows
      this.altScreenParkPatch = makeAltScreenParkPatch(this.terminalRows)
    }

    // Pending throttled/drain work captured stale dims — cancel so
    // the upcoming microtask owns the next frame.
    this.scheduleRender.cancel?.()

    if (this.drainTimer !== null) {
      clearTimeout(this.drainTimer)
      this.drainTimer = null
    }

    if (this.resizeSettleTimer !== null) {
      clearTimeout(this.resizeSettleTimer)
      this.resizeSettleTimer = null
    }

    // Alt screen: reset frame buffers so the next render repaints from
    // scratch (prevFrameContaminated → every cell written, wrapped in
    // BSU/ESU — old content stays visible until the new frame swaps
    // atomically). Re-assert mouse tracking (some emulators reset it on
    // resize). Do NOT write ENTER_ALT_SCREEN: iTerm2 treats ?1049h as a
    // buffer clear even when already in alt — that's the blank flicker.
    // Self-healing re-entry (if something kicked us out of alt) is handled
    // by handleResume (SIGCONT) and the sleep-wake detector; resize itself
    // doesn't exit alt-screen. Do NOT write ERASE_SCREEN: render() below
    // can take ~80ms; erasing first leaves the screen blank that whole time.
    if (this.altScreenActive && !this.isPaused && this.options.stdout.isTTY) {
      this.prepareAltScreenResizeRepaint()
    }

    // Already queued: later events in this burst updated dims/alt-screen
    // prep above; the queued render picks up the latest values when it
    // fires (React commit → onComputeLayout → scheduleRender → onRender).
    if (this.pendingResizeRender) {
      return
    }

    this.pendingResizeRender = true

    queueMicrotask(() => {
      this.pendingResizeRender = false

      if (this.isUnmounted || this.currentNode === null) {
        return
      }

      this.render(this.currentNode)
    })
  }

  private canAltScreenRepaint(): boolean {
    return (
      !this.isUnmounted &&
      !this.isPaused &&
      this.altScreenActive &&
      !!this.options.stdout.isTTY &&
      this.currentNode !== null
    )
  }

  private prepareAltScreenResizeRepaint(): void {
    // Clear any pending settle timer from a previous resize burst so
    // rapid events don't stack redundant delayed repaints. (handleResize
    // also clears this, but the defensive clear keeps the method safe
    // if it's ever called from other code paths.)
    if (this.resizeSettleTimer !== null) {
      clearTimeout(this.resizeSettleTimer)
      this.resizeSettleTimer = null
    }

    if (this.altScreenMouseTracking) {
      this.options.stdout.write(ENABLE_MOUSE_TRACKING)
    }

    this.resetFramesForAltScreen()
    this.needsEraseBeforePaint = true

    this.resizeSettleTimer = setTimeout(() => {
      this.resizeSettleTimer = null

      if (!this.canAltScreenRepaint()) {
        return
      }

      this.resetFramesForAltScreen()
      this.needsEraseBeforePaint = true
      this.render(this.currentNode!)
    }, 160)
  }

  resolveExitPromise: () => void = () => {}
  rejectExitPromise: (reason?: Error) => void = () => {}
  unsubscribeExit: () => void = () => {}

  /**
   * Pause Ink and hand the terminal over to an external TUI (e.g. git
   * commit editor). In non-fullscreen mode this enters the alt screen;
   * in fullscreen mode we're already in alt so we just clear it.
   * Call `exitAlternateScreen()` when done to restore Ink.
   */
  enterAlternateScreen(): void {
    this.pause()
    this.suspendStdin()
    this.options.stdout.write(
      // Disable extended key reporting first — editors that don't speak
      // CSI-u (e.g. nano) show "Unknown sequence" for every Ctrl-<key> if
      // kitty/modifyOtherKeys stays active. exitAlternateScreen re-enables.
      DISABLE_KITTY_KEYBOARD +
        DISABLE_MODIFY_OTHER_KEYS +
        (this.altScreenMouseTracking ? DISABLE_MOUSE_TRACKING : '') +
        // disable mouse (no-op if off)
        (this.altScreenActive ? '' : '\x1b[?1049h') +
        // enter alt (already in alt if fullscreen)
        '\x1b[?1004l' +
        // disable focus reporting
        '\x1b[0m' +
        // reset attributes
        '\x1b[?25h' +
        // show cursor
        '\x1b[2J' +
        // clear screen
        '\x1b[H' // cursor home
    )
  }

  /**
   * Resume Ink after an external TUI handoff with a full repaint.
   * In non-fullscreen mode this exits the alt screen back to main;
   * in fullscreen mode we re-enter alt and clear + repaint.
   *
   * The re-enter matters: terminal editors (vim, nano, less) write
   * smcup/rmcup (?1049h/?1049l), so even though we started in alt,
   * the editor's rmcup on exit drops us to main screen. Without
   * re-entering, the 2J below wipes the user's main-screen scrollback
   * and subsequent renders land in main — native terminal scroll
   * returns, fullscreen scroll is dead.
   */
  exitAlternateScreen(): void {
    this.options.stdout.write(
      (this.altScreenActive ? ENTER_ALT_SCREEN : '') +
        // re-enter alt — vim's rmcup dropped us to main
        '\x1b[2J' +
        // clear screen (now alt if fullscreen)
        '\x1b[H' +
        // cursor home
        (this.altScreenMouseTracking ? ENABLE_MOUSE_TRACKING : '') +
        (this.altScreenActive ? '' : '\x1b[?1049l') +
        // exit alt (non-fullscreen only)
        '\x1b[?25l' // hide cursor (Ink manages)
    )
    this.resumeStdin()

    if (this.altScreenActive) {
      this.resetFramesForAltScreen()
    } else {
      this.repaint()
    }

    this.resume()
    // Re-enable focus reporting and extended key reporting — terminal
    // editors (vim, nano, etc.) write their own modifyOtherKeys level on
    // entry and reset it on exit, leaving us unable to distinguish
    // ctrl+shift+<letter> from ctrl+<letter>. Pop-before-push keeps the
    // Kitty stack balanced (a well-behaved editor restores our entry, so
    // without the pop we'd accumulate depth on each editor round-trip).
    this.options.stdout.write(
      '\x1b[?1004h' +
        (supportsExtendedKeys() ? DISABLE_KITTY_KEYBOARD + ENABLE_KITTY_KEYBOARD + ENABLE_MODIFY_OTHER_KEYS : '')
    )
  }
  onRender() {
    if (this.isUnmounted || this.isPaused) {
      return
    }

    // Fold synchronous re-entry (selection fanout, onFrame callback)
    // into one follow-up microtask — back-to-back renders within one
    // macrotask were the freeze multiplier.
    if (this.isRendering) {
      this.immediateRerenderRequested = true

      return
    }

    this.isRendering = true

    // Entering a render cancels any pending drain tick — this render will
    // handle the drain (and re-schedule below if needed). Prevents a
    // wheel-event-triggered render AND a drain-timer render both firing.
    if (this.drainTimer !== null) {
      clearTimeout(this.drainTimer)
      this.drainTimer = null
    }

    // Flush deferred interaction-time update before rendering so we call
    // Date.now() at most once per frame instead of once per keypress.
    // Done before the render to avoid dirtying state that would trigger
    // an extra React re-render cycle.
    flushInteractionTime()
    const renderStart = performance.now()
    const terminalWidth = this.options.stdout.columns || 80
    const terminalRows = this.options.stdout.rows || 24

    const frame = this.renderer({
      frontFrame: this.frontFrame,
      backFrame: this.backFrame,
      isTTY: this.options.stdout.isTTY,
      terminalWidth,
      terminalRows,
      altScreen: this.altScreenActive,
      prevFrameContaminated: this.prevFrameContaminated
    })

    const rendererMs = performance.now() - renderStart

    // Sticky/auto-follow scrolled the ScrollBox this frame. Translate the
    // selection by the same delta so the highlight stays anchored to the
    // TEXT (native terminal behavior — the selection walks up the screen
    // as content scrolls, eventually clipping at the top). frontFrame
    // still holds the PREVIOUS frame's screen (swap is at ~500 below), so
    // captureScrolledRows reads the rows that are about to scroll out
    // before they're overwritten — the text stays copyable until the
    // selection scrolls entirely off. During drag, focus tracks the mouse
    // (screen-local) so only anchor shifts — selection grows toward the
    // mouse as the anchor walks up. After release, both ends are text-
    // anchored and move as a block.
    const follow = consumeFollowScroll()

    if (
      follow &&
      this.selection.anchor &&
      // 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. Without this guard, a
      // footer selection would be shifted by -delta then clamped to
      // viewportBottom, teleporting it into the scrollbox. Mirror the
      // bounds check the deleted check() in ScrollKeybindingHandler had.
      this.selection.anchor.row >= follow.viewportTop &&
      this.selection.anchor.row <= follow.viewportBottom
    ) {
      const { delta, viewportTop, viewportBottom } = follow

      // captureScrolledRows and shift* are a pair: capture grabs rows about
      // to scroll off, shift moves the selection endpoint so the same rows
      // won't intersect again next frame. Capturing without shifting leaves
      // the endpoint in place, so the SAME viewport rows re-intersect every
      // frame and scrolledOffAbove grows without bound — getSelectedText
      // then returns ever-growing text on each re-copy. Keep capture inside
      // each shift branch so the pairing can't be broken by a new guard.
      if (this.selection.isDragging) {
        if (hasSelection(this.selection)) {
          captureScrolledRows(this.selection, this.frontFrame.screen, viewportTop, viewportTop + delta - 1, 'above')
        }

        shiftAnchor(this.selection, -delta, viewportTop, viewportBottom)
      } else if (
        // Flag-3 guard: the anchor check above only proves ONE endpoint is
        // on scrollbox content. A drag from row 3 (scrollbox) into the
        // footer at row 6, then release, leaves focus outside the viewport
        // — shiftSelectionForFollow would clamp it to viewportBottom,
        // teleporting the highlight from static footer into the scrollbox.
        // Symmetric check: require BOTH ends inside to translate. A
        // straddling selection falls through to NEITHER shift NOR capture:
        // the footer endpoint pins the selection, text scrolls away under
        // the highlight, and getSelectedText reads the CURRENT screen
        // contents — no accumulation. Dragging branch doesn't need this:
        // shiftAnchor ignores focus, and the anchor DOES shift (so capture
        // is correct there even when focus is in the footer).
        !this.selection.focus ||
        (this.selection.focus.row >= viewportTop && this.selection.focus.row <= viewportBottom)
      ) {
        if (hasSelection(this.selection)) {
          captureScrolledRows(this.selection, this.frontFrame.screen, viewportTop, viewportTop + delta - 1, 'above')
        }

        const cleared = shiftSelectionForFollow(this.selection, -delta, viewportTop, viewportBottom)

        // Auto-clear (both ends overshot minRow) must notify React-land
        // so useHasSelection re-renders and the footer copy/escape hint
        // disappears. notifySelectionChange() would recurse into onRender;
        // fire the listeners directly — they schedule a React update for
        // LATER, they don't re-enter this frame.
        if (cleared) {
          for (const cb of this.selectionListeners) {
            cb()
          }
        }
      }
    }

    // Selection overlay: invert cell styles in the screen buffer itself,
    // so the diff picks up selection as ordinary cell changes and
    // LogUpdate remains a pure diff engine.
    //
    // Full-screen damage (PR #20120) is a correctness backstop for the
    // sibling-resize bleed: when flexbox siblings resize between frames
    // (spinner appears → bottom grows → scrollbox shrinks), the
    // cached-clear + clip-and-cull + setCellAt damage union can miss
    // transition cells at the boundary. But that only happens when layout
    // actually SHIFTS — didLayoutShift() tracks exactly this (any node's
    // cached yoga position/size differs from current, or a child was
    // removed). Steady-state frames (spinner rotate, clock tick, text
    // stream into fixed-height box) don't shift layout, so normal damage
    // bounds are correct and diffEach only compares the damaged region.
    //
    // Selection also requires full damage: overlay writes via setCellStyleId
    // which doesn't track damage, and prev-frame overlay cells need to be
    // compared when selection moves/clears. prevFrameContaminated covers
    // the frame-after-selection-clears case.
    let selActive = false
    let hlActive = false

    if (this.altScreenActive) {
      selActive = hasSelection(this.selection)

      if (selActive) {
        applySelectionOverlay(frame.screen, this.selection, this.stylePool)
      }

      // Scan-highlight: inverse on ALL visible matches (less/vim style).
      // Position-highlight (below) overlays CURRENT (yellow) on top.
      hlActive = applySearchHighlight(frame.screen, this.searchHighlightQuery, this.stylePool)

      // Hyperlink hover overlay: inverts every cell of the link currently
      // under the pointer. Cheap-ish (linear scan of the visible buffer),
      // only fires when hoveredHyperlink is set.
      //
      // hlActive controls full-screen damage (used by selection/search to
      // make sure the previous frame's inverted cells get re-diffed when
      // the highlight set changes). For hover, the *transition* is what
      // needs the full-damage hammer — enter / leave / change-to-other-link.
      // During steady-state hover the painted cells don't change and the
      // ordinary per-cell diff handles the no-op. Folding the steady-state
      // case into hlActive would burn full-screen diffs every frame while
      // the pointer just sits on the link.
      const hoverApplied = applyHyperlinkHoverHighlight(frame.screen, this.hoveredHyperlink, this.stylePool)
      const hoverTransition = this.hoveredHyperlink !== this.lastRenderedHoveredHyperlink
      this.lastRenderedHoveredHyperlink = this.hoveredHyperlink

      if (hoverApplied && hoverTransition) {
        hlActive = true
      }

      // Position-based CURRENT: write yellow at positions[currentIdx] +
      // rowOffset. No scanning — positions came from a prior scan when
      // the message first mounted. Message-relative + rowOffset = screen.
      if (this.searchPositions) {
        const sp = this.searchPositions

        const posApplied = applyPositionedHighlight(
          frame.screen,
          this.stylePool,
          sp.positions,
          sp.rowOffset,
          sp.currentIdx
        )

        hlActive = hlActive || posApplied
      }
    }

    // Full-damage backstop: applies on BOTH alt-screen and main-screen.
    // Layout shifts (spinner appears, status line resizes) can leave stale
    // cells at sibling boundaries that per-node damage tracking misses.
    // Selection/highlight overlays write via setCellStyleId which doesn't
    // track damage. prevFrameContaminated covers the cleanup frame.
    if (didLayoutShift() || selActive || hlActive || this.prevFrameContaminated) {
      frame.screen.damage = {
        x: 0,
        y: 0,
        width: frame.screen.width,
        height: frame.screen.height
      }
    }

    // Alt-screen: anchor the physical cursor to (0,0) before every diff.
    // All cursor moves in log-update are RELATIVE to prev.cursor; if tmux
    // (or any emulator) perturbs the physical cursor out-of-band (status
    // bar refresh, pane redraw, Cmd+K wipe), the relative moves drift and
    // content creeps up 1 row/frame. CSI H resets the physical cursor;
    // passing prev.cursor=(0,0) makes the diff compute from the same spot.
    // Self-healing against any external cursor manipulation. Main-screen
    // can't do this — cursor.y tracks scrollback rows CSI H can't reach.
    // The CSI H write is deferred until after the diff is computed so we
    // can skip it for empty diffs (no writes → physical cursor unused).
    let prevFrame = this.frontFrame

    if (this.altScreenActive) {
      prevFrame = {
        ...this.frontFrame,
        cursor: ALT_SCREEN_ANCHOR_CURSOR
      }
    }

    const tDiff = performance.now()

    const diff = this.log.render(
      prevFrame,
      frame,
      this.altScreenActive,
      // DECSTBM needs BSU/ESU atomicity — without it the outer terminal
      // renders the scrolled-but-not-yet-repainted intermediate state.
      // tmux is the main case (re-emits DECSTBM with its own timing and
      // doesn't implement DEC 2026, so SYNC_OUTPUT_SUPPORTED is false).
      SYNC_OUTPUT_SUPPORTED
    )

    const diffMs = performance.now() - tDiff
    // Swap buffers
    this.backFrame = this.frontFrame
    this.frontFrame = frame

    // Periodically reset char/hyperlink pools to prevent unbounded growth
    // during long sessions. 5 minutes is infrequent enough that the O(cells)
    // migration cost is negligible. Reuses renderStart to avoid extra clock call.
    if (renderStart - this.lastPoolResetTime > 5 * 60 * 1000) {
      this.resetPools()
      this.lastPoolResetTime = renderStart
    }

    const flickers: FrameEvent['flickers'] = []

    for (const patch of diff) {
      if (patch.type === 'clearTerminal') {
        flickers.push({
          desiredHeight: frame.screen.height,
          availableHeight: frame.viewport.height,
          reason: patch.reason
        })
      }
    }

    const tOptimize = performance.now()
    const optimized = optimize(diff)
    const optimizeMs = performance.now() - tOptimize
    const hasDiff = optimized.length > 0
    const needsAltScreenErase = this.altScreenActive && this.needsEraseBeforePaint

    if (this.altScreenActive && (hasDiff || needsAltScreenErase)) {
      // Prepend CSI H to anchor the physical cursor to (0,0) so
      // log-update's relative moves compute from a known spot (self-healing
      // against out-of-band cursor drift, see the ALT_SCREEN_ANCHOR_CURSOR
      // comment above). Append CSI row;1 H to park the cursor at the bottom
      // row (where the prompt input is) — without this, the cursor ends
      // wherever the last diff write landed (a different row every frame),
      // making iTerm2's cursor guide flicker as it chases the cursor.
      // BSU/ESU protects content atomicity but iTerm2's guide tracks cursor
      // position independently. Parking at bottom (not 0,0) keeps the guide
      // where the user's attention is.
      //
      // After resize, prepend a clear too. The diff only writes cells
      // that changed; cells where new=blank and prev-buffer=blank get skipped
      // — but the physical terminal still has stale content there (shorter
      // lines at new width leave old-width text tails visible). Apple Terminal
      // can also preserve alt-screen reflow artifacts in scrollback during
      // resize, so it gets CSI 3J in this one recovery path. When BSU/ESU is
      // supported, the clear+paint lands atomically; otherwise the final state
      // is still healed even if the repaint is visible.
      if (needsAltScreenErase) {
        this.needsEraseBeforePaint = false
        optimized.unshift(needsAltScreenResizeScrollbackClear() ? DEEP_ERASE_THEN_HOME_PATCH : ERASE_THEN_HOME_PATCH)
      } else {
        optimized.unshift(CURSOR_HOME_PATCH)
      }

      optimized.push(this.altScreenParkPatch)
    }

    // Native cursor positioning: park the terminal cursor at the declared
    // position so IME preedit text renders inline and screen readers /
    // magnifiers can follow the input. nodeCache holds the absolute screen
    // rect populated by renderNodeToOutput this frame (including scrollTop
    // translation) — if the declared node didn't render (stale declaration
    // after remount, or scrolled out of view), it won't be in the cache
    // and no move is emitted.
    const decl = this.cursorDeclaration
    const rect = decl !== null ? nodeCache.get(decl.node) : undefined

    const target =
      decl !== null && rect !== undefined
        ? {
            x: rect.x + decl.relativeX,
            y: rect.y + decl.relativeY
          }
        : null

    const parked = this.displayCursor

    // Preserve the empty-diff zero-write fast path: skip all cursor writes
    // when nothing rendered AND the park target is unchanged.
    const targetMoved = target !== null && (parked === null || parked.x !== target.x || parked.y !== target.y)

    if (hasDiff || targetMoved || (target === null && parked !== null)) {
      // Main-screen preamble: log-update's relative moves assume the
      // physical cursor is at prevFrame.cursor. If last frame parked it
      // elsewhere, move back before the diff runs. Alt-screen's CSI H
      // already resets to (0,0) so no preamble needed.
      if (parked !== null && !this.altScreenActive && hasDiff) {
        const pdx = prevFrame.cursor.x - parked.x
        const pdy = prevFrame.cursor.y - parked.y

        if (pdx !== 0 || pdy !== 0) {
          optimized.unshift({
            type: 'stdout',
            content: cursorMove(pdx, pdy)
          })
        }
      }

      if (target !== null) {
        if (this.altScreenActive) {
          // Absolute CUP (1-indexed); next frame's CSI H resets regardless.
          // Emitted after altScreenParkPatch so the declared position wins.
          const row = Math.min(Math.max(target.y + 1, 1), terminalRows)
          const col = Math.min(Math.max(target.x + 1, 1), terminalWidth)
          optimized.push({
            type: 'stdout',
            content: cursorPosition(row, col)
          })
        } else {
          // After the diff (or preamble), cursor is at frame.cursor. If no
          // diff AND previously parked, it's still at the old park position
          // (log-update wrote nothing). Otherwise it's at frame.cursor.
          const from =
            !hasDiff && parked !== null
              ? parked
              : {
                  x: frame.cursor.x,
                  y: frame.cursor.y
                }

          const dx = target.x - from.x
          const dy = target.y - from.y

          if (dx !== 0 || dy !== 0) {
            optimized.push({
              type: 'stdout',
              content: cursorMove(dx, dy)
            })
          }
        }

        this.displayCursor = target
      } else {
        // Declaration cleared (input blur, unmount). Restore physical cursor
        // to frame.cursor before forgetting the park position — otherwise
        // displayCursor=null lies about where the cursor is, and the NEXT
        // frame's preamble (or log-update's relative moves) computes from a
        // wrong spot. The preamble above handles hasDiff; this handles
        // !hasDiff (e.g. accessibility mode where blur doesn't change
        // renderedValue since invert is identity).
        if (parked !== null && !this.altScreenActive && !hasDiff) {
          const rdx = frame.cursor.x - parked.x
          const rdy = frame.cursor.y - parked.y

          if (rdx !== 0 || rdy !== 0) {
            optimized.push({
              type: 'stdout',
              content: cursorMove(rdx, rdy)
            })
          }
        }

        this.displayCursor = null
      }
    }

    const tWrite = performance.now()

    // Capture any stale pending write BEFORE starting this frame's write —
    // if the callback already fired, pendingWriteStart is null and lastDrainMs
    // already reflects the previous frame's drain.  If it hasn't fired, we
    // report "still pending" via a non-zero duration based on now-then so
    // backpressure shows up even if Node never flushes this session.
    const staleDrain = this.pendingWriteStart !== null ? performance.now() - this.pendingWriteStart : this.lastDrainMs

    const prevFrameDrainMs = Math.round(staleDrain * 100) / 100
    this.lastDrainMs = 0

    // Only track drain on TTY. Piped/non-TTY stdout bypasses flow control.
    const trackDrain = this.options.stdout.isTTY && optimized.length > 0
    const drainStart = trackDrain ? tWrite : 0

    if (trackDrain) {
      this.pendingWriteStart = drainStart
    }

    const { bytes: writeBytes, backpressure } = writeDiffToTerminal(
      this.terminal,
      optimized,
      this.altScreenActive && !SYNC_OUTPUT_SUPPORTED,
      trackDrain
        ? () => {
            // Callback fires once Node has flushed the chunk to the OS.
            // Capture the drain time and clear pending so the NEXT frame's
            // staleDrain = the real end-to-end flush time.
            if (this.pendingWriteStart === drainStart) {
              this.lastDrainMs = performance.now() - drainStart
              this.pendingWriteStart = null
            }
          }
        : undefined
    )

    const writeMs = performance.now() - tWrite

    // Update blit safety for the NEXT frame. The frame just rendered
    // becomes frontFrame (= next frame's prevScreen). If we applied the
    // selection overlay, that buffer has inverted cells. selActive/hlActive
    // are only ever true in alt-screen; in main-screen this is false→false.
    this.prevFrameContaminated = selActive || hlActive || !!frame.absoluteOverlayMoved

    // Plain setTimeout (not scheduleRender) — lodash throttle's leading
    // edge would fire inside this trailing invocation and double-render.
    // Scroll drain only; absolute-overlay movement rides prevFrameContaminated
    // into the next natural render. Routing it here made caret re-layout a
    // 250fps self-oscillator that locked the event loop after resize.
    if (frame.scrollDrainPending) {
      this.drainTimer = setTimeout(() => this.onRender(), FRAME_INTERVAL_MS >> 2)
    }

    const yogaMs = getLastYogaMs()
    const commitMs = getLastCommitMs()
    const yc = this.lastYogaCounters
    // Reset so drain-only frames (no React commit) don't repeat stale values.
    resetProfileCounters()
    this.lastYogaCounters = {
      ms: 0,
      visited: 0,
      measured: 0,
      cacheHits: 0,
      live: 0
    }
    this.options.onFrame?.({
      durationMs: performance.now() - renderStart,
      phases: {
        renderer: rendererMs,
        diff: diffMs,
        optimize: optimizeMs,
        write: writeMs,
        patches: diff.length,
        optimizedPatches: optimized.length,
        writeBytes,
        backpressure,
        prevFrameDrainMs,
        yoga: yogaMs,
        commit: commitMs,
        yogaVisited: yc.visited,
        yogaMeasured: yc.measured,
        yogaCacheHits: yc.cacheHits,
        yogaLive: yc.live
      },
      flickers
    })

    this.isRendering = false

    if (this.immediateRerenderRequested) {
      this.immediateRerenderRequested = false
      queueMicrotask(() => this.onRender())
    }
  }
  pause(): void {
    // Flush pending React updates and render before pausing.
    reconciler.flushSyncFromReconciler()
    this.onRender()
    this.isPaused = true
  }
  resume(): void {
    this.isPaused = false
    this.onRender()
  }

  /**
   * Reset frame buffers so the next render writes the full screen from scratch.
   * Call this before resume() when the terminal content has been corrupted by
   * an external process (e.g. tmux, shell, full-screen TUI).
   */
  repaint(): void {
    this.frontFrame = emptyFrame(
      this.frontFrame.viewport.height,
      this.frontFrame.viewport.width,
      this.stylePool,
      this.charPool,
      this.hyperlinkPool
    )
    this.backFrame = emptyFrame(
      this.backFrame.viewport.height,
      this.backFrame.viewport.width,
      this.stylePool,
      this.charPool,
      this.hyperlinkPool
    )
    this.log.reset()
    // Physical cursor position is unknown after external terminal corruption.
    // Clear displayCursor so the cursor preamble doesn't emit a stale
    // relative move from where we last parked it.
    this.displayCursor = null
  }

  /**
   * Clear the physical terminal and force a full redraw.
   *
   * The traditional readline ctrl+l — clears the visible screen and
   * redraws the current content. Also the recovery path when the terminal
   * was cleared externally (macOS Cmd+K) and Ink's diff engine thinks
   * unchanged cells don't need repainting. Scrollback is preserved.
   */
  forceRedraw(): void {
    if (!this.options.stdout.isTTY || this.isUnmounted || this.isPaused) {
      return
    }

    this.options.stdout.write(ERASE_SCREEN + CURSOR_HOME)

    if (this.altScreenActive) {
      this.resetFramesForAltScreen()
    } else {
      this.repaint()
      // repaint() resets frontFrame to 0×0. Without this flag the next
      // frame's blit optimization copies from that empty screen and the
      // diff sees no content. onRender resets the flag at frame end.
      this.prevFrameContaminated = true
    }

    this.onRender()
  }

  /**
   * Mark the previous frame as untrustworthy for blit, forcing the next
   * render to do a full-damage diff instead of the per-node fast path.
   *
   * Lighter than forceRedraw() — no screen clear, no extra write. Call
   * from a useLayoutEffect cleanup when unmounting a tall overlay: the
   * blit fast path can copy stale cells from the overlay frame into rows
   * the shrunken layout no longer reaches, leaving a ghost title/divider.
   * onRender resets the flag at frame end so it's one-shot.
   */
  invalidatePrevFrame(): void {
    this.prevFrameContaminated = true
  }

  /**
   * Called by the <AlternateScreen> component on mount/unmount.
   * Controls cursor.y clamping in the renderer and gates alt-screen-aware
   * behavior in SIGCONT/resize/unmount handlers. Repaints on change so
   * the first alt-screen frame (and first main-screen frame on exit) is
   * a full redraw with no stale diff state.
   */
  setAltScreenActive(active: boolean, mouseTracking = false): void {
    if (this.altScreenActive === active) {
      return
    }

    this.altScreenActive = active
    this.altScreenMouseTracking = active && mouseTracking

    // Hover state is alt-screen-scoped: dispatchHover is gated on
    // altScreenActive, so once we leave the alt screen there's no path to
    // clear it on our own. Without this reset, remounting <AlternateScreen>
    // would render a phantom hover highlight from the previous session
    // until the next mouse-move event arrived. Clear both the live value
    // and the last-rendered tracker so the next onRender sees no transition
    // and no overlay.
    this.hoveredHyperlink = undefined
    this.lastRenderedHoveredHyperlink = undefined

    if (active) {
      this.resetFramesForAltScreen()
    } else {
      this.repaint()
    }
  }

  /**
   * Toggle mouse tracking at runtime while the alt screen is active.
   * Writes the appropriate DEC reset/set sequences so the terminal
   * (and ConPTY on Windows WSL2) reflects the change immediately.
   */
  setAltScreenMouseTracking(enabled: boolean): void {
    if (this.altScreenMouseTracking === enabled) {
      return
    }

    this.altScreenMouseTracking = enabled

    if (this.altScreenActive) {
      this.options.stdout.write(enabled ? ENABLE_MOUSE_TRACKING : DISABLE_MOUSE_TRACKING)
    }
  }
  get isAltScreenActive(): boolean {
    return this.altScreenActive
  }

  /**
   * Re-assert terminal modes after a gap (>5s stdin silence or event-loop
   * stall). Catches tmux detach→attach, ssh reconnect, and laptop
   * sleep/wake — none of which send SIGCONT. The terminal may reset DEC
   * private modes on reconnect; this method restores them.
   *
   * Always re-asserts extended key reporting and mouse tracking. Mouse
   * tracking is idempotent (DEC private mode set-when-set is a no-op). The
   * Kitty keyboard protocol is NOT — CSI >1u is a stack push, so we pop
   * first to keep depth balanced (pop on empty stack is a no-op per spec,
   * so after a terminal reset this still restores depth 0→1). Without the
   * pop, each >5s idle gap adds a stack entry, and the single pop on exit
   * or suspend can't drain them — the shell is left in CSI u mode where
   * Ctrl+C/Ctrl+D leak as escape sequences. The alt-screen
   * re-entry (ERASE_SCREEN + frame reset) is NOT idempotent — it blanks the
   * screen — so it's opt-in via includeAltScreen. The stdin-gap caller fires
   * on ordinary >5s idle + keypress and must not erase; the event-loop stall
   * detector fires on genuine sleep/wake and opts in. tmux attach / ssh
   * reconnect typically send a resize, which already covers alt-screen via
   * handleResize.
   */
  reassertTerminalModes = (includeAltScreen = false): void => {
    if (!this.options.stdout.isTTY) {
      return
    }

    // Don't touch the terminal during an editor handoff — re-enabling kitty
    // keyboard here would undo enterAlternateScreen's disable and nano would
    // start seeing CSI-u sequences again.
    if (this.isPaused) {
      return
    }

    // Extended keys — re-assert if enabled (App.tsx enables these on
    // allowlisted terminals at raw-mode entry; a terminal reset clears them).
    // Pop-before-push keeps Kitty stack depth at 1 instead of accumulating
    // on each call.
    if (supportsExtendedKeys()) {
      this.options.stdout.write(DISABLE_KITTY_KEYBOARD + ENABLE_KITTY_KEYBOARD + ENABLE_MODIFY_OTHER_KEYS)
    }

    if (!this.altScreenActive) {
      return
    }

    // Mouse tracking — idempotent, safe to re-assert on every stdin gap.
    if (this.altScreenMouseTracking) {
      this.options.stdout.write(ENABLE_MOUSE_TRACKING)
    }

    // Alt-screen re-entry — destructive (ERASE_SCREEN). Only for callers that
    // have a strong signal the terminal actually dropped mode 1049.
    if (includeAltScreen) {
      this.reenterAltScreen()
    }
  }

  /**
   * Mark this instance as unmounted so future unmount() calls early-return.
   * Called by gracefulShutdown's cleanupTerminalModes() after it has sent
   * EXIT_ALT_SCREEN but before the remaining terminal-reset sequences.
   * Without this, signal-exit's deferred ink.unmount() (triggered by
   * process.exit()) runs the full unmount path: onRender() + writeSync
   * cleanup block + updateContainerSync → AlternateScreen unmount cleanup.
   * The result is 2-3 redundant EXIT_ALT_SCREEN sequences landing on the
   * main screen AFTER printResumeHint(), which tmux (at least) interprets
   * as restoring the saved cursor position — clobbering the resume hint.
   */
  detachForShutdown(): void {
    this.isUnmounted = true
    // Cancel any pending throttled render so it doesn't fire between
    // cleanupTerminalModes() and process.exit() and write to main screen.
    this.scheduleRender.cancel?.()

    // Restore stdin from raw mode. unmount() used to do this via React
    // unmount (App.componentWillUnmount → handleSetRawMode(false)) but we're
    // short-circuiting that path. Must use this.options.stdin — NOT
    // process.stdin — because getStdinOverride() may have opened /dev/tty
    // when stdin is piped.
    const stdin = this.options.stdin as NodeJS.ReadStream & {
      isRaw?: boolean
      setRawMode?: (m: boolean) => void
    }

    this.drainStdin()

    if (stdin.isTTY && stdin.isRaw && stdin.setRawMode) {
      stdin.setRawMode(false)
    }
  }

  /** @see drainStdin */
  drainStdin(): void {
    drainStdin(this.options.stdin)
  }

  /**
   * Re-enter alt-screen, clear, home, re-enable mouse tracking, and reset
   * frame buffers so the next render repaints from scratch. Self-heal for
   * SIGCONT, resize, and stdin-gap/event-loop-stall (sleep/wake) — any of
   * which can leave the terminal in main-screen mode while altScreenActive
   * stays true. ENTER_ALT_SCREEN is a terminal-side no-op if already in alt.
   */
  private reenterAltScreen(): void {
    this.options.stdout.write(
      ENTER_ALT_SCREEN + ERASE_SCREEN + CURSOR_HOME + (this.altScreenMouseTracking ? ENABLE_MOUSE_TRACKING : '')
    )
    this.resetFramesForAltScreen()
  }

  /**
   * Seed prev/back frames with full-size BLANK screens (rows×cols of empty
   * cells, not 0×0). In alt-screen mode, next.screen.height is always
   * terminalRows; if prev.screen.height is 0 (emptyFrame's default),
   * log-update sees heightDelta > 0 ('growing') and calls renderFrameSlice,
   * whose trailing per-row CR+LF at the last row scrolls the alt screen,
   * permanently desyncing the virtual and physical cursors by 1 row.
   *
   * With a rows×cols blank prev, heightDelta === 0 → standard diffEach
   * → moveCursorTo (CSI cursorMove, no LF, no scroll).
   *
   * viewport.height = rows + 1 matches the renderer's alt-screen output,
   * preventing a spurious resize trigger on the first frame. cursor.y = 0
   * matches the physical cursor after ENTER_ALT_SCREEN + CSI H (home).
   */
  private resetFramesForAltScreen(): void {
    const rows = this.terminalRows
    const cols = this.terminalColumns

    const blank = (): Frame => ({
      screen: createScreen(cols, rows, this.stylePool, this.charPool, this.hyperlinkPool),
      viewport: {
        width: cols,
        height: rows + 1
      },
      cursor: {
        x: 0,
        y: 0,
        visible: true
      }
    })

    this.frontFrame = blank()
    this.backFrame = blank()
    this.log.reset()
    // Defense-in-depth: alt-screen skips the cursor preamble anyway (CSI H
    // resets), but a stale displayCursor would be misleading if we later
    // exit to main-screen without an intervening render.
    this.displayCursor = null
    // Fresh frontFrame is blank rows×cols — blitting from it would copy
    // blanks over content. Next alt-screen frame must full-render.
    this.prevFrameContaminated = true
  }

  /**
   * Copy the current text selection to the system clipboard without clearing the
   * selection. Returns the copied text when a clipboard path succeeded (native
   * tool fired, tmux buffer loaded, or OSC 52 emitted), or '' when no path was
   * taken (e.g. headless Linux without tmux). Matches iTerm2's copy-on-select
   * behavior where the selected region stays visible after the automatic copy.
   */
  async copySelectionNoClear(): Promise<string> {
    if (!hasSelection(this.selection)) {
      return ''
    }

    const text = getSelectedText(this.selection, this.frontFrame.screen)

    if (text) {
      try {
        const { sequence, success } = await setClipboard(text)

        if (sequence) {
          this.options.stdout.write(sequence)
        }

        if (success) {
          return text
        }

        if (process.env.HERMES_TUI_DEBUG_CLIPBOARD) {
          console.error(
            '[clipboard] no path reached the clipboard (headless + no tmux?) — set HERMES_TUI_FORCE_OSC52=1 to force the escape sequence'
          )
        }
      } catch (err) {
        if (process.env.HERMES_TUI_DEBUG_CLIPBOARD) {
          console.error('[clipboard] error:', err)
        }
      }
    }

    return ''
  }

  /**
   * Copy the current text selection to the system clipboard via OSC 52
   * and clear the selection. Returns the copied text (empty if no selection
   * or clipboard operation failed).
   */
  async copySelection(): Promise<string> {
    if (!hasSelection(this.selection)) {
      return ''
    }

    const text = await this.copySelectionNoClear()
    clearSelection(this.selection)
    this.notifySelectionChange()

    return text
  }

  /** Clear the current text selection without copying. */
  clearTextSelection(): void {
    if (!hasSelection(this.selection)) {
      return
    }

    clearSelection(this.selection)
    this.notifySelectionChange()
  }

  /**
   * Set the search highlight query. Non-empty → all visible occurrences
   * are inverted (SGR 7) on the next frame; first one also underlined.
   * Empty → clears (prevFrameContaminated handles the frame after). Same
   * damage-tracking machinery as selection — setCellStyleId doesn't track
   * damage, so the overlay forces full-frame damage while active.
   */
  setSearchHighlight(query: string): void {
    if (this.searchHighlightQuery === query) {
      return
    }

    this.searchHighlightQuery = query
    this.scheduleRender()
  }

  /** Paint an EXISTING DOM subtree to a fresh Screen at its natural
   *  height, scan for query. Returns positions relative to the element's
   *  bounding box (row 0 = element top).
   *
   *  The element comes from the MAIN tree — built with all real
   *  providers, yoga already computed. We paint it to a fresh buffer
   *  with offsets so it lands at (0,0). Same paint path as the main
   *  render. Zero drift. No second React root, no context bridge.
   *
   *  ~1-2ms (paint only, no reconcile — the DOM is already built). */
  scanElementSubtree(el: dom.DOMElement): MatchPosition[] {
    if (!this.searchHighlightQuery || !el.yogaNode) {
      return []
    }

    const width = Math.ceil(el.yogaNode.getComputedWidth())
    const height = Math.ceil(el.yogaNode.getComputedHeight())

    if (width <= 0 || height <= 0) {
      return []
    }

    // renderNodeToOutput adds el's OWN computedLeft/Top to offsetX/Y.
    // Passing -elLeft/-elTop nets to 0 → paints at (0,0) in our buffer.
    const elLeft = el.yogaNode.getComputedLeft()
    const elTop = el.yogaNode.getComputedTop()
    const screen = createScreen(width, height, this.stylePool, this.charPool, this.hyperlinkPool)

    const output = new Output({
      width,
      height,
      stylePool: this.stylePool,
      screen
    })

    renderNodeToOutput(el, output, {
      offsetX: -elLeft,
      offsetY: -elTop,
      prevScreen: undefined
    })
    const rendered = output.get()
    // renderNodeToOutput wrote our offset positions to nodeCache —
    // corrupts the main render (it'd blit from wrong coords). Mark the
    // subtree dirty so the next main render repaints + re-caches
    // correctly. One extra paint of this message, but correct > fast.
    dom.markDirty(el)
    const positions = scanPositions(rendered, this.searchHighlightQuery)
    logForDebugging(
      `scanElementSubtree: q='${this.searchHighlightQuery}' ` +
        `el=${width}x${height}@(${elLeft},${elTop}) n=${positions.length} ` +
        `[${positions
          .slice(0, 10)
          .map(p => `${p.row}:${p.col}`)
          .join(',')}` +
        `${positions.length > 10 ? ',…' : ''}]`
    )

    return positions
  }

  /** Set the position-based highlight state. Every frame, writes CURRENT
   *  style at positions[currentIdx] + rowOffset. null clears. The scan-
   *  highlight (inverse on all matches) still runs — this overlays yellow
   *  on top. rowOffset changes as the user scrolls (= message's current
   *  screen-top); positions stay stable (message-relative). */
  setSearchPositions(
    state: {
      positions: MatchPosition[]
      rowOffset: number
      currentIdx: number
    } | null
  ): void {
    this.searchPositions = state
    this.scheduleRender()
  }

  /**
   * Set the selection highlight background color. Replaces the per-cell
   * SGR-7 inverse with a solid theme-aware bg (matches native terminal
   * selection). Accepts the same color formats as Text backgroundColor
   * (rgb(), ansi:name, #hex, ansi256()) — colorize() routes through
   * chalk so the tmux/xterm.js level clamps in colorize.ts apply and
   * the emitted SGR is correct for the current terminal.
   *
   * Called by React-land once theme is known (ScrollKeybindingHandler's
   * useEffect watching useTheme). Before that call, withSelectionBg
   * falls back to withInverse so selection still renders on the first
   * frame; the effect fires before any mouse input so the fallback is
   * unobservable in practice.
   */
  setSelectionBgColor(color: string): void {
    // Wrap a NUL marker, then split on it to extract the open/close SGR.
    // colorize returns the input unchanged if the color string is bad —
    // no NUL-split then, so fall through to null (inverse fallback).
    const wrapped = colorize('\0', color, 'background')
    const nul = wrapped.indexOf('\0')

    if (nul <= 0 || nul === wrapped.length - 1) {
      this.stylePool.setSelectionBg(null)

      return
    }

    this.stylePool.setSelectionBg({
      type: 'ansi',
      code: wrapped.slice(0, nul),
      endCode: wrapped.slice(nul + 1) // always \x1b[49m for bg
    })
    // No scheduleRender: this is called from a React effect that already
    // runs inside the render cycle, and the bg only matters once a
    // selection exists (which itself triggers a full-damage frame).
  }

  /**
   * Capture text from rows about to scroll out of the viewport during
   * drag-to-scroll. Must be called BEFORE the ScrollBox scrolls so the
   * screen buffer still holds the outgoing content. Accumulated into
   * the selection state and joined back in by getSelectedText.
   */
  captureScrolledRows(firstRow: number, lastRow: number, side: 'above' | 'below'): void {
    captureScrolledRows(this.selection, this.frontFrame.screen, firstRow, lastRow, side)
  }

  /**
   * Shift anchor AND focus by dRow, clamped to [minRow, maxRow]. Used by
   * keyboard scroll handlers (PgUp/PgDn etc.) so the highlight tracks the
   * content instead of disappearing. Unlike shiftAnchor (drag-to-scroll),
   * this moves BOTH endpoints — the user isn't holding the mouse at one
   * edge. Supplies screen.width for the col-reset-on-clamp boundary.
   */
  shiftSelectionForScroll(dRow: number, minRow: number, maxRow: number): void {
    const hadSel = hasSelection(this.selection)
    shiftSelection(this.selection, dRow, minRow, maxRow, this.frontFrame.screen.width)

    // shiftSelection clears when both endpoints overshoot the same edge
    // (Home/g/End/G page-jump past the selection). Notify subscribers so
    // useHasSelection updates. Safe to call notifySelectionChange here —
    // this runs from keyboard handlers, not inside onRender().
    if (hadSel && !hasSelection(this.selection)) {
      this.notifySelectionChange()
    }
  }

  /**
   * Keyboard selection extension (shift+arrow/home/end). Moves focus;
   * anchor stays fixed so the highlight grows or shrinks relative to it.
   * Left/right wrap across row boundaries — native macOS text-edit
   * behavior: shift+left at col 0 wraps to end of the previous row.
   * Up/down clamp at viewport edges (no scroll-to-extend yet). Drops to
   * char mode. No-op outside alt-screen or without an active selection.
   */
  moveSelectionFocus(move: FocusMove): void {
    if (!this.altScreenActive) {
      return
    }

    const { focus } = this.selection

    if (!focus) {
      return
    }

    const { width, height } = this.frontFrame.screen

    const maxCol = width - 1
    const maxRow = height - 1

    let { col, row } = focus

    switch (move) {
      case 'left':
        if (col > 0) {
          col--
        } else if (row > 0) {
          col = maxCol
          row--
        }

        break

      case 'right':
        if (col < maxCol) {
          col++
        } else if (row < maxRow) {
          col = 0
          row++
        }

        break

      case 'up':
        if (row > 0) {
          row--
        }

        break

      case 'down':
        if (row < maxRow) {
          row++
        }

        break

      case 'lineStart':
        col = 0

        break

      case 'lineEnd':
        col = maxCol

        break
    }

    if (col === focus.col && row === focus.row) {
      return
    }

    moveFocus(this.selection, col, row)
    this.notifySelectionChange()
  }

  /** Whether there is an active text selection. */
  hasTextSelection(): boolean {
    return hasSelection(this.selection)
  }

  getSelectionVersion(): number {
    return this.selectionVersion
  }

  /**
   * Subscribe to selection state changes. Fires whenever the selection
   * mutates — anchor/focus moves, drag updates, programmatic clears.
   * Does NOT fire on `copySelectionNoClear()` (no mutation, no notify),
   * which is why version-based subscribers don't risk re-entrant copies.
   * Returns an unsubscribe fn.
   */
  subscribeToSelectionChange(cb: () => void): () => void {
    this.selectionListeners.add(cb)

    return () => this.selectionListeners.delete(cb)
  }
  private notifySelectionChange(): void {
    this.scheduleRender()

    // Only bump version when the selection range actually mutated.
    // Listeners still fire unconditionally — useHasSelection() snapshots
    // through React, which dedupes via Object.is on the boolean value.
    const sig = selectionSignature(this.selection)

    if (sig !== this.lastSelectionSignature) {
      this.lastSelectionSignature = sig
      this.selectionVersion += 1
    }

    for (const cb of this.selectionListeners) {
      cb()
    }
  }

  /**
   * Hit-test the rendered DOM tree at (col, row) and bubble a ClickEvent
   * from the deepest hit node up through ancestors with onClick handlers.
   * Returns true if a DOM handler consumed the click. Gated on
   * altScreenActive — clicks only make sense with a fixed viewport where
   * nodeCache rects map 1:1 to terminal cells (no scrollback offset).
   */
  dispatchClick(col: number, row: number): boolean {
    if (!this.altScreenActive) {
      return false
    }

    const blank = isEmptyCellAt(this.frontFrame.screen, col, row)

    return dispatchClick(this.rootNode, col, row, blank)
  }
  dispatchMouseDown(col: number, row: number, button: number): dom.DOMElement | undefined {
    if (!this.altScreenActive) {
      return undefined
    }

    this.stopSelectionAutoScroll()

    return dispatchMouse(
      this.rootNode,
      col,
      row,
      'onMouseDown',
      button,
      isEmptyCellAt(this.frontFrame.screen, col, row)
    )
  }
  dispatchMouseUp(target: dom.DOMElement, col: number, row: number, button: number): void {
    if (!this.altScreenActive) {
      return
    }

    this.stopSelectionAutoScroll()
    dispatchMouse(this.rootNode, col, row, 'onMouseUp', button, isEmptyCellAt(this.frontFrame.screen, col, row), target)
  }
  dispatchMouseDrag(target: dom.DOMElement, col: number, row: number, button: number): void {
    if (!this.altScreenActive) {
      return
    }

    dispatchMouse(
      this.rootNode,
      col,
      row,
      'onMouseDrag',
      button,
      isEmptyCellAt(this.frontFrame.screen, col, row),
      target
    )
  }
  dispatchHover(col: number, row: number): void {
    if (!this.altScreenActive) {
      return
    }

    dispatchHover(this.rootNode, col, row, this.hoveredNodes)

    // Hover affordance for hyperlinks: read the cell at the pointer, store
    // its URL (or clear when the pointer leaves a link), and request a
    // repaint when the value changes. The render-pass overlay paints the
    // highlight; we just track which URL is "hot".
    //
    // IMPORTANT: bypass getHyperlinkAt() here — its plain-text URL fallback
    // (findPlainTextUrlAt) would return URLs for cells whose `cell.hyperlink`
    // is undefined, which the overlay (applyHyperlinkHoverHighlight)
    // wouldn't match. That'd burn re-renders without ever producing an
    // affordance. Read the OSC 8 hyperlink directly off the cell so the
    // hover state is a 1:1 fit for what the overlay can paint. The
    // plain-text URL fallback still works for clicks; hover is a strictly
    // weaker signal and OK to skip on plain-text URLs.
    const screen = this.frontFrame.screen
    const cell = cellAt(screen, col, row)
    let next = cell?.hyperlink

    // SpacerTail (second half of a wide-char / emoji glyph) stores the
    // hyperlink on the head cell at col-1. Same logic as getHyperlinkAt.
    if (!next && cell?.width === CellWidth.SpacerTail && col > 0) {
      next = cellAt(screen, col - 1, row)?.hyperlink
    }

    if (next !== this.hoveredHyperlink) {
      this.hoveredHyperlink = next
      this.scheduleRender()
    }
  }
  dispatchKeyboardEvent(parsedKey: ParsedKey): void {
    const target = this.focusManager.activeElement ?? this.rootNode
    const event = new KeyboardEvent(parsedKey)
    dispatcher.dispatchDiscrete(target, event)

    // Tab cycling is the default action — only fires if no handler
    // called preventDefault(). Mirrors browser behavior.
    if (!event.defaultPrevented && parsedKey.name === 'tab' && !parsedKey.ctrl && !parsedKey.meta) {
      if (parsedKey.shift) {
        this.focusManager.focusPrevious(this.rootNode)
      } else {
        this.focusManager.focusNext(this.rootNode)
      }
    }
  }
  /**
   * Look up the URL at (col, row) in the current front frame. Checks for
   * an OSC 8 hyperlink first, then falls back to scanning the row for a
   * plain-text URL (mouse tracking intercepts the terminal's native
   * Cmd+Click URL detection, so we replicate it). This is a pure lookup
   * with no side effects — call it synchronously at click time so the
   * result reflects the screen the user actually clicked on, then defer
   * the browser-open action via a timer.
   */
  getHyperlinkAt(col: number, row: number): string | undefined {
    if (!this.altScreenActive) {
      return undefined
    }

    const screen = this.frontFrame.screen
    const cell = cellAt(screen, col, row)
    let url = cell?.hyperlink

    // SpacerTail cells (right half of wide/CJK/emoji chars) store the
    // hyperlink on the head cell at col-1.
    if (!url && cell?.width === CellWidth.SpacerTail && col > 0) {
      url = cellAt(screen, col - 1, row)?.hyperlink
    }

    return url ?? findPlainTextUrlAt(screen, col, row)
  }

  /**
   * Optional callback fired when clicking a cell that has an associated URL
   * in fullscreen mode. `url` may be either an OSC 8 hyperlink (from a
   * `<Link>` render or external OSC 8 escape that landed in the buffer) or
   * a plain-text URL detected on the clicked row by findPlainTextUrlAt
   * (App.tsx routes both into the same callback). Set from the host via
   * the `onHyperlinkClick` Render/Ink option, or directly on the instance
   * for late-bound test scenarios.
   */
  onHyperlinkClick: ((url: string) => void) | undefined

  /**
   * Stable prototype wrapper for onHyperlinkClick. Passed to <App> as
   * onOpenHyperlink so the prop is a bound method (autoBind'd) that reads
   * the mutable field at call time — not the undefined-at-render value.
   */
  openHyperlink(url: string): void {
    this.onHyperlinkClick?.(url)
  }

  /**
   * Handle a double- or triple-click at (col, row): select the word or
   * line under the cursor by reading the current screen buffer. Called on
   * PRESS (not release) so the highlight appears immediately and drag can
   * extend the selection word-by-word / line-by-line. Falls back to
   * char-mode startSelection if the click lands on a noSelect cell.
   */
  handleMultiClick(col: number, row: number, count: 2 | 3): void {
    if (!this.altScreenActive) {
      return
    }

    const screen = this.frontFrame.screen
    // selectWordAt/selectLineAt no-op on noSelect/out-of-bounds. Seed with
    // a char-mode selection so the press still starts a drag even if the
    // word/line scan finds nothing selectable.
    startSelection(this.selection, col, row)

    if (count === 2) {
      selectWordAt(this.selection, screen, col, row)
    } else {
      selectLineAt(this.selection, screen, row)
    }

    // Ensure hasSelection is true so release doesn't re-dispatch onClickAt.
    // selectWordAt no-ops on noSelect; selectLineAt no-ops out-of-bounds.
    if (!this.selection.focus) {
      this.selection.focus = this.selection.anchor
    }

    this.notifySelectionChange()
  }

  /**
   * Handle a drag-motion at (col, row). In char mode updates focus to the
   * exact cell. In word/line mode snaps to word/line boundaries so the
   * selection extends by word/line like native macOS. Gated on
   * altScreenActive for the same reason as dispatchClick.
   */
  handleSelectionDrag(col: number, row: number): void {
    if (!this.altScreenActive) {
      return
    }

    if (this.selectionDragCell?.col === col && this.selectionDragCell.row === row) {
      this.updateSelectionAutoScroll(row)

      return
    }

    this.selectionDragCell = { col, row }
    this.applySelectionDrag(col, row)
    this.updateSelectionAutoScroll(row)
  }

  private applySelectionDrag(col: number, row: number): void {
    const sel = this.selection

    if (sel.anchorSpan) {
      extendSelection(sel, this.frontFrame.screen, col, row)
    } else {
      updateSelection(sel, col, row)
    }

    this.notifySelectionChange()
  }

  private updateSelectionAutoScroll(row: number): void {
    if (!this.selection.isDragging || !this.altScreenActive) {
      this.stopSelectionAutoScroll()

      return
    }

    const dir: -1 | 0 | 1 = row <= 0 ? -1 : row >= this.terminalRows - 1 ? 1 : 0

    if (dir === 0) {
      this.stopSelectionAutoScroll()

      return
    }

    if (this.selectionAutoScrollDir === dir && this.selectionAutoScrollTimer) {
      return
    }

    this.stopSelectionAutoScroll()
    this.selectionAutoScrollDir = dir
    this.selectionAutoScrollTimer = setInterval(() => this.stepSelectionAutoScroll(), 50)
  }

  private stepSelectionAutoScroll(): void {
    if (!this.selection.isDragging || !this.altScreenActive || this.selectionAutoScrollDir === 0) {
      this.stopSelectionAutoScroll()

      return
    }

    const box = this.findPrimaryScrollBox()

    if (!box) {
      this.stopSelectionAutoScroll()

      return
    }

    const viewport = Math.max(0, box.scrollViewportHeight ?? 0)
    const max = Math.max(0, (box.scrollHeight ?? 0) - viewport)
    const current = box.scrollTop ?? 0
    const next = Math.max(0, Math.min(max, current + this.selectionAutoScrollDir))

    if (next === current) {
      return
    }

    const top = box.scrollViewportTop ?? 0
    const bottom = top + viewport - 1
    const before = selectionBounds(this.selection)

    if (before) {
      if (this.selectionAutoScrollDir > 0) {
        captureScrolledRows(this.selection, this.frontFrame.screen, top, top, 'above')
      } else {
        captureScrolledRows(this.selection, this.frontFrame.screen, bottom, bottom, 'below')
      }
    }

    box.stickyScroll = false
    box.pendingScrollDelta = undefined
    box.scrollAnchor = undefined
    box.scrollTop = next
    markDirty(box)
    shiftAnchor(this.selection, -this.selectionAutoScrollDir, top, bottom)

    if (this.selectionDragCell) {
      this.selectionDragCell = {
        col: this.selectionDragCell.col,
        row: this.selectionAutoScrollDir > 0 ? bottom : top
      }
    }

    this.applySelectionDrag(
      this.selectionDragCell?.col ?? 0,
      this.selectionDragCell?.row ?? (this.selectionAutoScrollDir > 0 ? bottom : top)
    )
  }

  private stopSelectionAutoScroll(): void {
    if (this.selectionAutoScrollTimer) {
      clearInterval(this.selectionAutoScrollTimer)
      this.selectionAutoScrollTimer = null
    }

    this.selectionAutoScrollDir = 0
    this.selectionDragCell = null
  }

  private findPrimaryScrollBox(): dom.DOMElement | undefined {
    const stack = [this.rootNode]

    while (stack.length) {
      const node = stack.shift()!

      if (
        node.style.overflowY === 'scroll' &&
        node.scrollHeight !== undefined &&
        node.scrollViewportHeight !== undefined
      ) {
        return node
      }

      for (const child of node.childNodes) {
        if (child.nodeName !== '#text') {
          stack.push(child)
        }
      }
    }
  }

  // Methods to properly suspend stdin for external editor usage
  // This is needed to prevent Ink from swallowing keystrokes when an external editor is active
  private stdinListeners: Array<{
    event: string
    listener: (...args: unknown[]) => void
  }> = []
  private wasRawMode = false
  suspendStdin(): void {
    const stdin = this.options.stdin

    if (!stdin.isTTY) {
      return
    }

    // Store and remove all 'readable' event listeners temporarily
    // This prevents Ink from consuming stdin while the editor is active
    const readableListeners = stdin.listeners('readable')
    logForDebugging(
      `[stdin] suspendStdin: removing ${readableListeners.length} readable listener(s), wasRawMode=${
        (
          stdin as NodeJS.ReadStream & {
            isRaw?: boolean
          }
        ).isRaw ?? false
      }`
    )
    readableListeners.forEach(listener => {
      this.stdinListeners.push({
        event: 'readable',
        listener: listener as (...args: unknown[]) => void
      })
      stdin.removeListener('readable', listener as (...args: unknown[]) => void)
    })

    // If raw mode is enabled, disable it temporarily
    const stdinWithRaw = stdin as NodeJS.ReadStream & {
      isRaw?: boolean
      setRawMode?: (mode: boolean) => void
    }

    if (stdinWithRaw.isRaw && stdinWithRaw.setRawMode) {
      stdinWithRaw.setRawMode(false)
      this.wasRawMode = true
    }
  }
  resumeStdin(): void {
    const stdin = this.options.stdin

    if (!stdin.isTTY) {
      return
    }

    // Re-attach all the stored listeners
    if (this.stdinListeners.length === 0 && !this.wasRawMode) {
      logForDebugging('[stdin] resumeStdin: called with no stored listeners and wasRawMode=false (possible desync)', {
        level: 'warn'
      })
    }

    logForDebugging(
      `[stdin] resumeStdin: re-attaching ${this.stdinListeners.length} listener(s), wasRawMode=${this.wasRawMode}`
    )
    this.stdinListeners.forEach(({ event, listener }) => {
      stdin.addListener(event, listener)
    })
    this.stdinListeners = []

    // Re-enable raw mode if it was enabled before
    if (this.wasRawMode) {
      const stdinWithRaw = stdin as NodeJS.ReadStream & {
        setRawMode?: (mode: boolean) => void
      }

      if (stdinWithRaw.setRawMode) {
        stdinWithRaw.setRawMode(true)
      }

      this.wasRawMode = false
    }
  }

  // Stable identity for TerminalWriteContext. An inline arrow here would
  // change on every render() call (initial mount + each resize), which
  // cascades through useContext → <AlternateScreen>'s useLayoutEffect dep
  // array → spurious exit+re-enter of the alt screen on every SIGWINCH.
  private writeRaw(data: string): void {
    this.options.stdout.write(data)
  }
  private setCursorDeclaration: CursorDeclarationSetter = (decl, clearIfNode) => {
    if (decl === null && clearIfNode !== undefined && this.cursorDeclaration?.node !== clearIfNode) {
      return
    }

    this.cursorDeclaration = decl
  }
  // Caller writes raw bytes to stdout that move the physical terminal
  // cursor (e.g. TextInput's fast-echo bypass). Without this notification,
  // Ink's `displayCursor` cache and log-update's prevFrame.cursor stay
  // unchanged, so the next frame's relative cursor moves compute from a
  // stale position and the hardware cursor parks `dx` cells offset from
  // the actual caret. Visible symptom: extra whitespace between the just-
  // typed character and the cursor block, more pronounced on long
  // sessions where unrelated components re-render between fast-echo and
  // the deferred composer re-render.
  //
  // If displayCursor was already tracked, just bump it. Otherwise seed it
  // to (prevFrame.cursor + delta) so the next frame's preamble emits a
  // (-dx, -dy) relative move that brings the cursor back to log-update's
  // expected start position before the diff body runs.
  //
  // Public so tests can drive it directly without mounting App.
  //
  // Bumps BOTH `displayCursor` (used by log-update's relative-move
  // preamble) AND, if non-null, `cursorDeclaration.relativeX/Y` (the
  // target the cursor parks at after every frame). Advancing only one
  // of the two would leave the other stale: e.g. if the deferred React
  // `setCur` hasn't flushed yet, the next unrelated re-render would
  // re-compute `target` from the stale declaration and park the
  // hardware cursor back at the old caret column. We advance both so
  // the fast-echo is invisible to intervening frames until React
  // catches up.
  noteExternalCursorAdvance: CursorAdvanceNotifier = (dx, dy = 0) => {
    if (dx === 0 && dy === 0) {
      return
    }

    // displayCursor / log-update relative-move basis only matters on
    // main screen — alt-screen frames begin with absolute CSI H every
    // frame so the next preamble naturally resets to (0,0). cursorDeclaration,
    // however, IS still consulted on alt-screen — onRender's park branch
    // emits an absolute CUP using `rect.x + decl.relativeX`, so a stale
    // declaration in the deferred-setCur window would park the cursor
    // at the pre-keystroke caret. We therefore skip ONLY the displayCursor
    // half on alt-screen, not the declaration half.
    if (!this.altScreenActive) {
      if (this.displayCursor !== null) {
        this.displayCursor = {
          x: this.displayCursor.x + dx,
          y: this.displayCursor.y + dy
        }
      } else {
        // No prior parked position. Seed from frontFrame.cursor (where
        // log-update parked the cursor at the end of the last frame) so
        // the next preamble's relative move correctly cancels the
        // external advance.
        const baseX = this.frontFrame.cursor.x
        const baseY = this.frontFrame.cursor.y
        this.displayCursor = { x: baseX + dx, y: baseY + dy }
      }
    }

    // Also advance the active cursor declaration if any. Without this,
    // a TextInput that defers its React `cur` state update (16ms timer
    // in textInput.tsx — perf optimization that batches re-renders
    // during heavy typing) leaves `cursorDeclaration.relativeX` pointing
    // at the pre-keystroke caret column. If an unrelated component
    // re-renders before the deferred `setCur` flushes, the cursor-park
    // branch at the end of onRender would move the hardware cursor back
    // to that stale relativeX and visually undo the fast-echo's
    // advance. Bumping relativeX here keeps the declared target in
    // lock-step with the physical cursor until React state catches up.
    // Applies to BOTH main-screen and alt-screen — the alt-screen park
    // branch uses an absolute CUP to (rect.x + decl.relativeX), so a
    // stale declaration there would still produce the wrong column.
    const decl = this.cursorDeclaration

    if (decl !== null) {
      this.cursorDeclaration = {
        node: decl.node,
        relativeX: decl.relativeX + dx,
        relativeY: decl.relativeY + dy
      }
    }
  }
  render(node: ReactNode): void {
    this.currentNode = node

    const tree = (
      <App
        dispatchKeyboardEvent={this.dispatchKeyboardEvent}
        exitOnCtrlC={this.options.exitOnCtrlC}
        getHyperlinkAt={this.getHyperlinkAt}
        onClickAt={this.dispatchClick}
        onCursorAdvance={this.noteExternalCursorAdvance}
        onCursorDeclaration={this.setCursorDeclaration}
        onExit={this.unmount}
        onHoverAt={this.dispatchHover}
        onMouseDownAt={this.dispatchMouseDown}
        onMouseDragAt={this.dispatchMouseDrag}
        onMouseUpAt={this.dispatchMouseUp}
        onMultiClick={this.handleMultiClick}
        onOpenHyperlink={this.openHyperlink}
        onSelectionChange={this.notifySelectionChange}
        onSelectionDrag={this.handleSelectionDrag}
        onStdinResume={this.reassertTerminalModes}
        selection={this.selection}
        stderr={this.options.stderr}
        stdin={this.options.stdin}
        stdout={this.options.stdout}
        terminalColumns={this.terminalColumns}
        terminalRows={this.terminalRows}
      >
        <TerminalWriteProvider value={this.writeRaw}>{node}</TerminalWriteProvider>
      </App>
    )

    reconciler.updateContainerSync(tree, this.container, null, noop)
    reconciler.flushSyncWork()
  }
  unmount(error?: Error | number | null): void {
    if (this.isUnmounted) {
      return
    }

    this.onRender()
    this.unsubscribeExit()

    if (typeof this.restoreConsole === 'function') {
      this.restoreConsole()
    }

    this.restoreStderr?.()
    this.unsubscribeTTYHandlers?.()

    // Non-TTY environments don't handle erasing ansi escapes well, so it's better to
    // only render last frame of non-static output
    const diff = this.log.renderPreviousOutput_DEPRECATED(this.frontFrame)
    writeDiffToTerminal(this.terminal, optimize(diff))

    // Clean up terminal modes synchronously before process exit.
    // React's componentWillUnmount won't run in time when process.exit() is called,
    // so we must reset terminal modes here to prevent escape sequence leakage.
    // Use writeSync to stdout (fd 1) to ensure writes complete before exit.
    // We unconditionally send all disable sequences because terminal detection
    // may not work correctly (e.g., in tmux, screen) and these are no-ops on
    // terminals that don't support them.

    if (this.options.stdout.isTTY) {
      if (this.altScreenActive) {
        // <AlternateScreen>'s unmount effect won't run during signal-exit.
        // Exit alt screen FIRST so other cleanup sequences go to the main screen.
        writeSync(1, EXIT_ALT_SCREEN)
      }

      // Disable mouse tracking — unconditional because altScreenActive can be
      // stale if AlternateScreen's unmount (which flips the flag) raced a
      // blocked event loop + SIGINT. No-op if tracking was never enabled.
      writeSync(1, DISABLE_MOUSE_TRACKING)
      // Drain stdin so in-flight mouse events don't leak to the shell
      this.drainStdin()
      // Disable extended key reporting (both kitty and modifyOtherKeys)
      writeSync(1, DISABLE_MODIFY_OTHER_KEYS)
      writeSync(1, DISABLE_KITTY_KEYBOARD)
      // Disable focus events (DECSET 1004)
      writeSync(1, DFE)
      // Disable bracketed paste mode
      writeSync(1, DBP)
      // Show cursor
      writeSync(1, SHOW_CURSOR)
      // Clear iTerm2 progress bar
      writeSync(1, CLEAR_ITERM2_PROGRESS)

      // Clear tab status (OSC 21337) so a stale dot doesn't linger
      if (supportsTabStatus()) {
        writeSync(1, wrapForMultiplexer(CLEAR_TAB_STATUS))
      }
    }

    this.isUnmounted = true

    // Cancel any pending throttled renders to prevent accessing freed Yoga nodes
    this.scheduleRender.cancel?.()

    if (this.drainTimer !== null) {
      clearTimeout(this.drainTimer)
      this.drainTimer = null
    }

    if (this.resizeSettleTimer !== null) {
      clearTimeout(this.resizeSettleTimer)
      this.resizeSettleTimer = null
    }

    reconciler.updateContainerSync(null, this.container, null, noop)
    reconciler.flushSyncWork()
    instances.delete(this.options.stdout)

    // Free the root yoga node, then clear its reference. Children are already
    // freed by the reconciler's removeChildFromContainer; using .free() (not
    // .freeRecursive()) avoids double-freeing them.
    this.rootNode.yogaNode?.free()
    this.rootNode.yogaNode = undefined

    if (error instanceof Error) {
      this.rejectExitPromise(error)
    } else {
      this.resolveExitPromise()
    }
  }
  async waitUntilExit(): Promise<void> {
    this.exitPromise ||= new Promise((resolve, reject) => {
      this.resolveExitPromise = resolve
      this.rejectExitPromise = reject
    })

    return this.exitPromise
  }
  resetLineCount(): void {
    if (this.options.stdout.isTTY) {
      // Swap so old front becomes back (for screen reuse), then reset front
      this.backFrame = this.frontFrame
      this.frontFrame = emptyFrame(
        this.frontFrame.viewport.height,
        this.frontFrame.viewport.width,
        this.stylePool,
        this.charPool,
        this.hyperlinkPool
      )
      this.log.reset()
      // frontFrame is reset, so frame.cursor on the next render is (0,0).
      // Clear displayCursor so the preamble doesn't compute a stale delta.
      this.displayCursor = null
    }
  }

  /**
   * Replace char/hyperlink pools with fresh instances to prevent unbounded
   * growth during long sessions. Migrates the front frame's screen IDs into
   * the new pools so diffing remains correct. The back frame doesn't need
   * migration — resetScreen zeros it before any reads.
   *
   * Call between conversation turns or periodically.
   */
  resetPools(): void {
    this.charPool = new CharPool()
    this.hyperlinkPool = new HyperlinkPool()
    migrateScreenPools(this.frontFrame.screen, this.charPool, this.hyperlinkPool)
    // Back frame's data is zeroed by resetScreen before reads, but its pool
    // references are used by the renderer to intern new characters. Point
    // them at the new pools so the next frame's IDs are comparable.
    this.backFrame.screen.charPool = this.charPool
    this.backFrame.screen.hyperlinkPool = this.hyperlinkPool
  }
  patchConsole(): () => void {
    // biome-ignore lint/suspicious/noConsole: intentionally patching global console
    const con = console
    const originals: Partial<Record<keyof Console, Console[keyof Console]>> = {}
    const toDebug = (...args: unknown[]) => logForDebugging(`console.log: ${format(...args)}`)
    const toError = (...args: unknown[]) => logError(new Error(`console.error: ${format(...args)}`))

    for (const m of CONSOLE_STDOUT_METHODS) {
      originals[m] = con[m]
      con[m] = toDebug
    }

    for (const m of CONSOLE_STDERR_METHODS) {
      originals[m] = con[m]
      con[m] = toError
    }

    originals.assert = con.assert

    con.assert = (condition: unknown, ...args: unknown[]) => {
      if (!condition) {
        toError(...args)
      }
    }

    return () => Object.assign(con, originals)
  }

  /**
   * Intercept process.stderr.write so stray writes (config.ts, hooks.ts,
   * third-party deps) don't corrupt the alt-screen buffer. patchConsole only
   * hooks console.* methods — direct stderr writes bypass it, land at the
   * parked cursor, scroll the alt-screen, and desync frontFrame from the
   * physical terminal. Next diff writes only changed-in-React cells at
   * absolute coords → interleaved garbage.
   *
   * Swallows the write (routes text to the debug log) and, in alt-screen,
   * forces a full-damage repaint as a defensive recovery. Not patching
   * process.stdout — Ink itself writes there.
   */
  private patchStderr(): () => void {
    const stderr = process.stderr
    const originalWrite = stderr.write
    let reentered = false

    const intercept = (
      chunk: Uint8Array | string,
      encodingOrCb?: BufferEncoding | ((err?: Error | null) => void),
      cb?: (err?: Error | null) => void
    ): boolean => {
      const callback = typeof encodingOrCb === 'function' ? encodingOrCb : cb

      // Reentrancy guard: logForDebugging → writeToStderr → here. Pass
      // through to the original so --debug-to-stderr still works and we
      // don't stack-overflow.
      if (reentered) {
        const encoding = typeof encodingOrCb === 'string' ? encodingOrCb : undefined

        return originalWrite.call(stderr, chunk, encoding, callback)
      }

      reentered = true

      try {
        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
        logForDebugging(`[stderr] ${text}`, {
          level: 'warn'
        })

        if (this.altScreenActive && !this.isUnmounted && !this.isPaused) {
          this.prevFrameContaminated = true
          this.scheduleRender()
        }
      } finally {
        reentered = false
        callback?.()
      }

      return true
    }

    stderr.write = intercept

    return () => {
      if (stderr.write === intercept) {
        stderr.write = originalWrite
      }
    }
  }
}

/**
 * Discard pending stdin bytes so in-flight escape sequences (mouse tracking
 * reports, bracketed-paste markers) don't leak to the shell after exit.
 *
 * Two layers of trickiness:
 *
 * 1. setRawMode is termios, not fcntl — the stdin fd stays blocking, so
 *    readSync on it would hang forever. Node doesn't expose fcntl, so we
 *    open /dev/tty fresh with O_NONBLOCK (all fds to the controlling
 *    terminal share one line-discipline input queue).
 *
 * 2. By the time forceExit calls this, detachForShutdown has already put
 *    the TTY back in cooked (canonical) mode. Canonical mode line-buffers
 *    input until newline, so O_NONBLOCK reads return EAGAIN even when
 *    mouse bytes are sitting in the buffer. We briefly re-enter raw mode
 *    so reads return any available bytes, then restore cooked mode.
 *
 * Safe to call multiple times. Call as LATE as possible in the exit path:
 * DISABLE_MOUSE_TRACKING has terminal round-trip latency, so events can
 * arrive for a few ms after it's written.
 */

export function drainStdin(stdin: NodeJS.ReadStream = process.stdin): void {
  if (!stdin.isTTY) {
    return
  }

  // Drain Node's stream buffer (bytes libuv already pulled in). read()
  // returns null when empty — never blocks.
  try {
    while (stdin.read() !== null) {
      /* discard */
    }
  } catch {
    /* stream may be destroyed */
  }

  // No /dev/tty on Windows; CONIN$ doesn't support O_NONBLOCK semantics.
  // Windows Terminal also doesn't buffer mouse reports the same way.
  if (process.platform === 'win32') {
    return
  }

  // termios is per-device: flip stdin to raw so canonical-mode line
  // buffering doesn't hide partial input from the non-blocking read.
  // Restored in the finally block.
  const tty = stdin as NodeJS.ReadStream & {
    isRaw?: boolean
    setRawMode?: (raw: boolean) => void
  }

  const wasRaw = tty.isRaw === true
  // Drain the kernel TTY buffer via a fresh O_NONBLOCK fd. Bounded at 64
  // reads (64KB) — a real mouse burst is a few hundred bytes; the cap
  // guards against a terminal that ignores O_NONBLOCK.
  let fd = -1

  try {
    // setRawMode inside try: on revoked TTY (SIGHUP/SSH disconnect) the
    // ioctl throws EBADF — same recovery path as openSync/readSync below.
    if (!wasRaw) {
      tty.setRawMode?.(true)
    }

    fd = openSync('/dev/tty', fsConstants.O_RDONLY | fsConstants.O_NONBLOCK)
    const buf = Buffer.alloc(1024)

    for (let i = 0; i < 64; i++) {
      if (readSync(fd, buf, 0, buf.length, null) <= 0) {
        break
      }
    }
  } catch {
    // EAGAIN (buffer empty — expected), ENXIO/ENOENT (no controlling tty),
    // EBADF/EIO (TTY revoked — SIGHUP, SSH disconnect)
  } finally {
    if (fd >= 0) {
      try {
        closeSync(fd)
      } catch {
        /* ignore */
      }
    }

    if (!wasRaw) {
      try {
        tty.setRawMode?.(false)
      } catch {
        /* TTY may be gone */
      }
    }
  }
}

const CONSOLE_STDOUT_METHODS = [
  'log',
  'info',
  'debug',
  'dir',
  'dirxml',
  'count',
  'countReset',
  'group',
  'groupCollapsed',
  'groupEnd',
  'table',
  'time',
  'timeEnd',
  'timeLog'
] as const

const CONSOLE_STDERR_METHODS = ['warn', 'error', 'trace'] as const
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["autoBind","closeSync","constants","fsConstants","openSync","readSync","writeSync","noop","throttle","React","ReactNode","FiberRoot","ConcurrentRoot","onExit","flushInteractionTime","getYogaCounters","logForDebugging","logError","format","colorize","App","CursorDeclaration","CursorDeclarationSetter","FRAME_INTERVAL_MS","dom","KeyboardEvent","FocusManager","emptyFrame","Frame","FrameEvent","dispatchClick","dispatchHover","instances","LogUpdate","nodeCache","optimize","Output","ParsedKey","reconciler","dispatcher","getLastCommitMs","getLastYogaMs","isDebugRepaintsEnabled","recordYogaMs","resetProfileCounters","renderNodeToOutput","consumeFollowScroll","didLayoutShift","applyPositionedHighlight","MatchPosition","scanPositions","createRenderer","Renderer","CellWidth","CharPool","cellAt","createScreen","HyperlinkPool","isEmptyCellAt","migrateScreenPools","StylePool","applySearchHighlight","applySelectionOverlay","captureScrolledRows","clearSelection","createSelectionState","extendSelection","FocusMove","findPlainTextUrlAt","getSelectedText","hasSelection","moveFocus","SelectionState","selectLineAt","selectWordAt","shiftAnchor","shiftSelection","shiftSelectionForFollow","startSelection","updateSelection","SYNC_OUTPUT_SUPPORTED","supportsExtendedKeys","Terminal","writeDiffToTerminal","CURSOR_HOME","cursorMove","cursorPosition","DISABLE_KITTY_KEYBOARD","DISABLE_MODIFY_OTHER_KEYS","ENABLE_KITTY_KEYBOARD","ENABLE_MODIFY_OTHER_KEYS","ERASE_SCREEN","DBP","DFE","DISABLE_MOUSE_TRACKING","ENABLE_MOUSE_TRACKING","ENTER_ALT_SCREEN","EXIT_ALT_SCREEN","SHOW_CURSOR","CLEAR_ITERM2_PROGRESS","CLEAR_TAB_STATUS","setClipboard","supportsTabStatus","wrapForMultiplexer","TerminalWriteProvider","ALT_SCREEN_ANCHOR_CURSOR","Object","freeze","x","y","visible","CURSOR_HOME_PATCH","type","const","content","ERASE_THEN_HOME_PATCH","makeAltScreenParkPatch","terminalRows","Options","stdout","NodeJS","WriteStream","stdin","ReadStream","stderr","exitOnCtrlC","patchConsole","waitUntilExit","Promise","onFrame","event","Ink","log","terminal","scheduleRender","cancel","isUnmounted","isPaused","container","rootNode","DOMElement","focusManager","renderer","stylePool","charPool","hyperlinkPool","exitPromise","restoreConsole","restoreStderr","unsubscribeTTYHandlers","terminalColumns","currentNode","frontFrame","backFrame","lastPoolResetTime","performance","now","drainTimer","ReturnType","setTimeout","lastYogaCounters","ms","visited","measured","cacheHits","live","altScreenParkPatch","Readonly","selection","searchHighlightQuery","searchPositions","positions","rowOffset","currentIdx","selectionListeners","Set","hoveredNodes","altScreenActive","altScreenMouseTracking","prevFrameContaminated","needsEraseBeforePaint","cursorDeclaration","displayCursor","constructor","options","patchStderr","columns","rows","isTTY","deferredRender","queueMicrotask","onRender","leading","trailing","unsubscribeExit","unmount","alwaysLast","on","handleResize","process","handleResume","off","createNode","target","dispatchDiscrete","onImmediateRender","onComputeLayout","yogaNode","t0","setWidth","calculateLayout","c","createContainer","injectIntoDevTools","bundleType","version","rendererPackageName","reenterAltScreen","viewport","height","width","reset","cols","write","resetFramesForAltScreen","render","resolveExitPromise","rejectExitPromise","reason","Error","enterAlternateScreen","pause","suspendStdin","exitAlternateScreen","resumeStdin","repaint","resume","clearTimeout","renderStart","terminalWidth","frame","altScreen","rendererMs","follow","anchor","row","viewportTop","viewportBottom","delta","isDragging","screen","focus","cleared","cb","selActive","hlActive","sp","posApplied","damage","prevFrame","cursor","tDiff","diff","diffMs","resetPools","flickers","patch","push","desiredHeight","availableHeight","debug","chain","findOwnerChainAtRow","triggerY","prevLine","nextLine","length","join","level","tOptimize","optimized","optimizeMs","hasDiff","unshift","decl","rect","get","node","undefined","relativeX","relativeY","parked","targetMoved","pdx","pdy","Math","min","max","col","from","dx","dy","rdx","rdy","tWrite","writeMs","scrollDrainPending","yogaMs","commitMs","yc","durationMs","phases","patches","yoga","commit","yogaVisited","yogaMeasured","yogaCacheHits","yogaLive","flushSyncFromReconciler","forceRedraw","invalidatePrevFrame","setAltScreenActive","active","mouseTracking","isAltScreenActive","reassertTerminalModes","includeAltScreen","detachForShutdown","isRaw","setRawMode","m","drainStdin","blank","copySelectionNoClear","text","then","raw","copySelection","notifySelectionChange","clearTextSelection","setSearchHighlight","query","scanElementSubtree","el","ceil","getComputedWidth","getComputedHeight","elLeft","getComputedLeft","elTop","getComputedTop","output","offsetX","offsetY","prevScreen","rendered","markDirty","slice","map","p","setSearchPositions","state","setSelectionBgColor","color","wrapped","nul","indexOf","setSelectionBg","code","endCode","firstRow","lastRow","side","shiftSelectionForScroll","dRow","minRow","maxRow","hadSel","moveSelectionFocus","move","maxCol","hasTextSelection","subscribeToSelectionChange","add","delete","dispatchKeyboardEvent","parsedKey","activeElement","defaultPrevented","name","ctrl","meta","shift","focusPrevious","focusNext","getHyperlinkAt","cell","url","hyperlink","SpacerTail","onHyperlinkClick","openHyperlink","handleMultiClick","count","handleSelectionDrag","sel","anchorSpan","stdinListeners","Array","listener","args","wasRawMode","readableListeners","listeners","forEach","removeListener","stdinWithRaw","mode","addListener","writeRaw","data","setCursorDeclaration","clearIfNode","tree","updateContainerSync","flushSyncWork","error","renderPreviousOutput_DEPRECATED","free","resolve","reject","resetLineCount","con","console","originals","Partial","Record","Console","toDebug","toError","CONSOLE_STDOUT_METHODS","CONSOLE_STDERR_METHODS","assert","condition","assign","originalWrite","reentered","intercept","chunk","Uint8Array","encodingOrCb","BufferEncoding","err","callback","encoding","call","Buffer","toString","read","platform","tty","wasRaw","fd","O_RDONLY","O_NONBLOCK","buf","alloc","i"],"sources":["ink.tsx"],"sourcesContent":["import autoBind from 'auto-bind'\nimport {\n  closeSync,\n  constants as fsConstants,\n  openSync,\n  readSync,\n  writeSync,\n} from 'fs'\nimport noop from 'lodash-es/noop.js'\nimport throttle from 'lodash-es/throttle.js'\nimport React, { type ReactNode } from 'react'\nimport type { FiberRoot } from 'react-reconciler'\nimport { ConcurrentRoot } from 'react-reconciler/constants.js'\nimport { onExit } from 'signal-exit'\nimport { flushInteractionTime } from 'src/bootstrap/state.js'\nimport { getYogaCounters } from 'src/native-ts/yoga-layout/index.js'\nimport { logForDebugging } from 'src/utils/debug.js'\nimport { logError } from 'src/utils/log.js'\nimport { format } from 'util'\nimport { colorize } from './colorize.js'\nimport App from './components/App.js'\nimport type {\n  CursorDeclaration,\n  CursorDeclarationSetter,\n} from './components/CursorDeclarationContext.js'\nimport { FRAME_INTERVAL_MS } from './constants.js'\nimport * as dom from './dom.js'\nimport { KeyboardEvent } from './events/keyboard-event.js'\nimport { FocusManager } from './focus.js'\nimport { emptyFrame, type Frame, type FrameEvent } from './frame.js'\nimport { dispatchClick, dispatchHover } from './hit-test.js'\nimport instances from './instances.js'\nimport { LogUpdate } from './log-update.js'\nimport { nodeCache } from './node-cache.js'\nimport { optimize } from './optimizer.js'\nimport Output from './output.js'\nimport type { ParsedKey } from './parse-keypress.js'\nimport reconciler, {\n  dispatcher,\n  getLastCommitMs,\n  getLastYogaMs,\n  isDebugRepaintsEnabled,\n  recordYogaMs,\n  resetProfileCounters,\n} from './reconciler.js'\nimport renderNodeToOutput, {\n  consumeFollowScroll,\n  didLayoutShift,\n} from './render-node-to-output.js'\nimport {\n  applyPositionedHighlight,\n  type MatchPosition,\n  scanPositions,\n} from './render-to-screen.js'\nimport createRenderer, { type Renderer } from './renderer.js'\nimport {\n  CellWidth,\n  CharPool,\n  cellAt,\n  createScreen,\n  HyperlinkPool,\n  isEmptyCellAt,\n  migrateScreenPools,\n  StylePool,\n} from './screen.js'\nimport { applySearchHighlight } from './searchHighlight.js'\nimport {\n  applySelectionOverlay,\n  captureScrolledRows,\n  clearSelection,\n  createSelectionState,\n  extendSelection,\n  type FocusMove,\n  findPlainTextUrlAt,\n  getSelectedText,\n  hasSelection,\n  moveFocus,\n  type SelectionState,\n  selectLineAt,\n  selectWordAt,\n  shiftAnchor,\n  shiftSelection,\n  shiftSelectionForFollow,\n  startSelection,\n  updateSelection,\n} from './selection.js'\nimport {\n  SYNC_OUTPUT_SUPPORTED,\n  supportsExtendedKeys,\n  type Terminal,\n  writeDiffToTerminal,\n} from './terminal.js'\nimport {\n  CURSOR_HOME,\n  cursorMove,\n  cursorPosition,\n  DISABLE_KITTY_KEYBOARD,\n  DISABLE_MODIFY_OTHER_KEYS,\n  ENABLE_KITTY_KEYBOARD,\n  ENABLE_MODIFY_OTHER_KEYS,\n  ERASE_SCREEN,\n} from './termio/csi.js'\nimport {\n  DBP,\n  DFE,\n  DISABLE_MOUSE_TRACKING,\n  ENABLE_MOUSE_TRACKING,\n  ENTER_ALT_SCREEN,\n  EXIT_ALT_SCREEN,\n  SHOW_CURSOR,\n} from './termio/dec.js'\nimport {\n  CLEAR_ITERM2_PROGRESS,\n  CLEAR_TAB_STATUS,\n  setClipboard,\n  supportsTabStatus,\n  wrapForMultiplexer,\n} from './termio/osc.js'\nimport { TerminalWriteProvider } from './useTerminalNotification.js'\n\n// Alt-screen: renderer.ts sets cursor.visible = !isTTY || screen.height===0,\n// which is always false in alt-screen (TTY + content fills screen).\n// Reusing a frozen object saves 1 allocation per frame.\nconst ALT_SCREEN_ANCHOR_CURSOR = Object.freeze({ x: 0, y: 0, visible: false })\nconst CURSOR_HOME_PATCH = Object.freeze({\n  type: 'stdout' as const,\n  content: CURSOR_HOME,\n})\nconst ERASE_THEN_HOME_PATCH = Object.freeze({\n  type: 'stdout' as const,\n  content: ERASE_SCREEN + CURSOR_HOME,\n})\n\n// Cached per-Ink-instance, invalidated on resize. frame.cursor.y for\n// alt-screen is always terminalRows - 1 (renderer.ts).\nfunction makeAltScreenParkPatch(terminalRows: number) {\n  return Object.freeze({\n    type: 'stdout' as const,\n    content: cursorPosition(terminalRows, 1),\n  })\n}\n\nexport type Options = {\n  stdout: NodeJS.WriteStream\n  stdin: NodeJS.ReadStream\n  stderr: NodeJS.WriteStream\n  exitOnCtrlC: boolean\n  patchConsole: boolean\n  waitUntilExit?: () => Promise<void>\n  onFrame?: (event: FrameEvent) => void\n}\n\nexport default class Ink {\n  private readonly log: LogUpdate\n  private readonly terminal: Terminal\n  private scheduleRender: (() => void) & { cancel?: () => void }\n  // Ignore last render after unmounting a tree to prevent empty output before exit\n  private isUnmounted = false\n  private isPaused = false\n  private readonly container: FiberRoot\n  private rootNode: dom.DOMElement\n  readonly focusManager: FocusManager\n  private renderer: Renderer\n  private readonly stylePool: StylePool\n  private charPool: CharPool\n  private hyperlinkPool: HyperlinkPool\n  private exitPromise?: Promise<void>\n  private restoreConsole?: () => void\n  private restoreStderr?: () => void\n  private readonly unsubscribeTTYHandlers?: () => void\n  private terminalColumns: number\n  private terminalRows: number\n  private currentNode: ReactNode = null\n  private frontFrame: Frame\n  private backFrame: Frame\n  private lastPoolResetTime = performance.now()\n  private drainTimer: ReturnType<typeof setTimeout> | null = null\n  private lastYogaCounters: {\n    ms: number\n    visited: number\n    measured: number\n    cacheHits: number\n    live: number\n  } = { ms: 0, visited: 0, measured: 0, cacheHits: 0, live: 0 }\n  private altScreenParkPatch: Readonly<{ type: 'stdout'; content: string }>\n  // Text selection state (alt-screen only). Owned here so the overlay\n  // pass in onRender can read it and App.tsx can update it from mouse\n  // events. Public so instances.get() callers can access.\n  readonly selection: SelectionState = createSelectionState()\n  // Search highlight query (alt-screen only). Setter below triggers\n  // scheduleRender; applySearchHighlight in onRender inverts matching cells.\n  private searchHighlightQuery = ''\n  // Position-based highlight. VML scans positions ONCE (via\n  // scanElementSubtree, when the target message is mounted), stores them\n  // message-relative, sets this for every-frame apply. rowOffset =\n  // message's current screen-top. currentIdx = which position is\n  // \"current\" (yellow). null clears. Positions are known upfront —\n  // navigation is index arithmetic, no scan-feedback loop.\n  private searchPositions: {\n    positions: MatchPosition[]\n    rowOffset: number\n    currentIdx: number\n  } | null = null\n  // React-land subscribers for selection state changes (useHasSelection).\n  // Fired alongside the terminal repaint whenever the selection mutates\n  // so UI (e.g. footer hints) can react to selection appearing/clearing.\n  private readonly selectionListeners = new Set<() => void>()\n  // DOM nodes currently under the pointer (mode-1003 motion). Held here\n  // so App.tsx's handleMouseEvent is stateless — dispatchHover diffs\n  // against this set and mutates it in place.\n  private readonly hoveredNodes = new Set<dom.DOMElement>()\n  // Set by <AlternateScreen> via setAltScreenActive(). Controls the\n  // renderer's cursor.y clamping (keeps cursor in-viewport to avoid\n  // LF-induced scroll when screen.height === terminalRows) and gates\n  // alt-screen-aware SIGCONT/resize/unmount handling.\n  private altScreenActive = false\n  // Set alongside altScreenActive so SIGCONT resume knows whether to\n  // re-enable mouse tracking (not all <AlternateScreen> uses want it).\n  private altScreenMouseTracking = false\n  // True when the previous frame's screen buffer cannot be trusted for\n  // blit — selection overlay mutated it, resetFramesForAltScreen()\n  // replaced it with blanks, or forceRedraw() reset it to 0×0. Forces\n  // one full-render frame; steady-state frames after clear it and regain\n  // the blit + narrow-damage fast path.\n  private prevFrameContaminated = false\n  // Set by handleResize: prepend ERASE_SCREEN to the next onRender's patches\n  // INSIDE the BSU/ESU block so clear+paint is atomic. Writing ERASE_SCREEN\n  // synchronously in handleResize would leave the screen blank for the ~80ms\n  // render() takes; deferring into the atomic block means old content stays\n  // visible until the new frame is fully ready.\n  private needsEraseBeforePaint = false\n  // Native cursor positioning: a component (via useDeclaredCursor) declares\n  // where the terminal cursor should be parked after each frame. Terminal\n  // emulators render IME preedit text at the physical cursor position, and\n  // screen readers / screen magnifiers track it — so parking at the text\n  // input's caret makes CJK input appear inline and lets a11y tools follow.\n  private cursorDeclaration: CursorDeclaration | null = null\n  // Main-screen: physical cursor position after the declared-cursor move,\n  // tracked separately from frame.cursor (which must stay at content-bottom\n  // for log-update's relative-move invariants). Alt-screen doesn't need\n  // this — every frame begins with CSI H. null = no move emitted last frame.\n  private displayCursor: { x: number; y: number } | null = null\n\n  constructor(private readonly options: Options) {\n    autoBind(this)\n\n    if (this.options.patchConsole) {\n      this.restoreConsole = this.patchConsole()\n      this.restoreStderr = this.patchStderr()\n    }\n\n    this.terminal = {\n      stdout: options.stdout,\n      stderr: options.stderr,\n    }\n\n    this.terminalColumns = options.stdout.columns || 80\n    this.terminalRows = options.stdout.rows || 24\n    this.altScreenParkPatch = makeAltScreenParkPatch(this.terminalRows)\n    this.stylePool = new StylePool()\n    this.charPool = new CharPool()\n    this.hyperlinkPool = new HyperlinkPool()\n    this.frontFrame = emptyFrame(\n      this.terminalRows,\n      this.terminalColumns,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    this.backFrame = emptyFrame(\n      this.terminalRows,\n      this.terminalColumns,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n\n    this.log = new LogUpdate({\n      isTTY: (options.stdout.isTTY as boolean | undefined) || false,\n      stylePool: this.stylePool,\n    })\n\n    // scheduleRender is called from the reconciler's resetAfterCommit, which\n    // runs BEFORE React's layout phase (ref attach + useLayoutEffect). Any\n    // state set in layout effects — notably the cursorDeclaration from\n    // useDeclaredCursor — would lag one commit behind if we rendered\n    // synchronously. Deferring to a microtask runs onRender after layout\n    // effects have committed, so the native cursor tracks the caret without\n    // a one-keystroke lag. Same event-loop tick, so throughput is unchanged.\n    // Test env uses onImmediateRender (direct onRender, no throttle) so\n    // existing synchronous lastFrame() tests are unaffected.\n    const deferredRender = (): void => queueMicrotask(this.onRender)\n    this.scheduleRender = throttle(deferredRender, FRAME_INTERVAL_MS, {\n      leading: true,\n      trailing: true,\n    })\n\n    // Ignore last render after unmounting a tree to prevent empty output before exit\n    this.isUnmounted = false\n\n    // Unmount when process exits\n    this.unsubscribeExit = onExit(this.unmount, { alwaysLast: false })\n\n    if (options.stdout.isTTY) {\n      options.stdout.on('resize', this.handleResize)\n      process.on('SIGCONT', this.handleResume)\n\n      this.unsubscribeTTYHandlers = () => {\n        options.stdout.off('resize', this.handleResize)\n        process.off('SIGCONT', this.handleResume)\n      }\n    }\n\n    this.rootNode = dom.createNode('ink-root')\n    this.focusManager = new FocusManager((target, event) =>\n      dispatcher.dispatchDiscrete(target, event),\n    )\n    this.rootNode.focusManager = this.focusManager\n    this.renderer = createRenderer(this.rootNode, this.stylePool)\n    this.rootNode.onRender = this.scheduleRender\n    this.rootNode.onImmediateRender = this.onRender\n    this.rootNode.onComputeLayout = () => {\n      // Calculate layout during React's commit phase so useLayoutEffect hooks\n      // have access to fresh layout data\n      // Guard against accessing freed Yoga nodes after unmount\n      if (this.isUnmounted) {\n        return\n      }\n\n      if (this.rootNode.yogaNode) {\n        const t0 = performance.now()\n        this.rootNode.yogaNode.setWidth(this.terminalColumns)\n        this.rootNode.yogaNode.calculateLayout(this.terminalColumns)\n        const ms = performance.now() - t0\n        recordYogaMs(ms)\n        const c = getYogaCounters()\n        this.lastYogaCounters = { ms, ...c }\n      }\n    }\n\n    // @ts-expect-error @types/react-reconciler@0.32.3 declares 11 args with transitionCallbacks,\n    // but react-reconciler 0.33.0 source only accepts 10 args (no transitionCallbacks)\n    this.container = reconciler.createContainer(\n      this.rootNode,\n      ConcurrentRoot,\n      null,\n      false,\n      null,\n      'id',\n      noop, // onUncaughtError\n      noop, // onCaughtError\n      noop, // onRecoverableError\n      noop, // onDefaultTransitionIndicator\n    )\n\n    if (\"production\" === 'development') {\n      reconciler.injectIntoDevTools({\n        bundleType: 0,\n        // Reporting React DOM's version, not Ink's\n        // See https://github.com/facebook/react/issues/16666#issuecomment-532639905\n        version: '16.13.1',\n        rendererPackageName: 'ink',\n      })\n    }\n  }\n\n  private handleResume = () => {\n    if (!this.options.stdout.isTTY) {\n      return\n    }\n\n    // Alt screen: after SIGCONT, content is stale (shell may have written\n    // to main screen, switching focus away) and mouse tracking was\n    // disabled by handleSuspend.\n    if (this.altScreenActive) {\n      this.reenterAltScreen()\n      return\n    }\n\n    // Main screen: start fresh to prevent clobbering terminal content\n    this.frontFrame = emptyFrame(\n      this.frontFrame.viewport.height,\n      this.frontFrame.viewport.width,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    this.backFrame = emptyFrame(\n      this.backFrame.viewport.height,\n      this.backFrame.viewport.width,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    this.log.reset()\n    // Physical cursor position is unknown after the shell took over during\n    // suspend. Clear displayCursor so the next frame's cursor preamble\n    // doesn't emit a relative move from a stale park position.\n    this.displayCursor = null\n  }\n\n  // NOT debounced. A debounce opens a window where stdout.columns is NEW\n  // but this.terminalColumns/Yoga are OLD — any scheduleRender during that\n  // window (spinner, clock) makes log-update detect a width change and\n  // clear the screen, then the debounce fires and clears again (double\n  // blank→paint flicker). useVirtualScroll's height scaling already bounds\n  // the per-resize cost; synchronous handling keeps dimensions consistent.\n  private handleResize = () => {\n    const cols = this.options.stdout.columns || 80\n    const rows = this.options.stdout.rows || 24\n    // Terminals often emit 2+ resize events for one user action (window\n    // settling). Same-dimension events are no-ops; skip to avoid redundant\n    // frame resets and renders.\n    if (cols === this.terminalColumns && rows === this.terminalRows) return\n    this.terminalColumns = cols\n    this.terminalRows = rows\n    this.altScreenParkPatch = makeAltScreenParkPatch(this.terminalRows)\n\n    // Alt screen: reset frame buffers so the next render repaints from\n    // scratch (prevFrameContaminated → every cell written, wrapped in\n    // BSU/ESU — old content stays visible until the new frame swaps\n    // atomically). Re-assert mouse tracking (some emulators reset it on\n    // resize). Do NOT write ENTER_ALT_SCREEN: iTerm2 treats ?1049h as a\n    // buffer clear even when already in alt — that's the blank flicker.\n    // Self-healing re-entry (if something kicked us out of alt) is handled\n    // by handleResume (SIGCONT) and the sleep-wake detector; resize itself\n    // doesn't exit alt-screen. Do NOT write ERASE_SCREEN: render() below\n    // can take ~80ms; erasing first leaves the screen blank that whole time.\n    if (this.altScreenActive && !this.isPaused && this.options.stdout.isTTY) {\n      if (this.altScreenMouseTracking) {\n        this.options.stdout.write(ENABLE_MOUSE_TRACKING)\n      }\n      this.resetFramesForAltScreen()\n      this.needsEraseBeforePaint = true\n    }\n\n    // Re-render the React tree with updated props so the context value changes.\n    // React's commit phase will call onComputeLayout() to recalculate yoga layout\n    // with the new dimensions, then call onRender() to render the updated frame.\n    // We don't call scheduleRender() here because that would render before the\n    // layout is updated, causing a mismatch between viewport and content dimensions.\n    if (this.currentNode !== null) {\n      this.render(this.currentNode)\n    }\n  }\n\n  resolveExitPromise: () => void = () => {}\n  rejectExitPromise: (reason?: Error) => void = () => {}\n  unsubscribeExit: () => void = () => {}\n\n  /**\n   * Pause Ink and hand the terminal over to an external TUI (e.g. git\n   * commit editor). In non-fullscreen mode this enters the alt screen;\n   * in fullscreen mode we're already in alt so we just clear it.\n   * Call `exitAlternateScreen()` when done to restore Ink.\n   */\n  enterAlternateScreen(): void {\n    this.pause()\n    this.suspendStdin()\n    this.options.stdout.write(\n      // Disable extended key reporting first — editors that don't speak\n      // CSI-u (e.g. nano) show \"Unknown sequence\" for every Ctrl-<key> if\n      // kitty/modifyOtherKeys stays active. exitAlternateScreen re-enables.\n      DISABLE_KITTY_KEYBOARD +\n        DISABLE_MODIFY_OTHER_KEYS +\n        (this.altScreenMouseTracking ? DISABLE_MOUSE_TRACKING : '') + // disable mouse (no-op if off)\n        (this.altScreenActive ? '' : '\\x1b[?1049h') + // enter alt (already in alt if fullscreen)\n        '\\x1b[?1004l' + // disable focus reporting\n        '\\x1b[0m' + // reset attributes\n        '\\x1b[?25h' + // show cursor\n        '\\x1b[2J' + // clear screen\n        '\\x1b[H', // cursor home\n    )\n  }\n\n  /**\n   * Resume Ink after an external TUI handoff with a full repaint.\n   * In non-fullscreen mode this exits the alt screen back to main;\n   * in fullscreen mode we re-enter alt and clear + repaint.\n   *\n   * The re-enter matters: terminal editors (vim, nano, less) write\n   * smcup/rmcup (?1049h/?1049l), so even though we started in alt,\n   * the editor's rmcup on exit drops us to main screen. Without\n   * re-entering, the 2J below wipes the user's main-screen scrollback\n   * and subsequent renders land in main — native terminal scroll\n   * returns, fullscreen scroll is dead.\n   */\n  exitAlternateScreen(): void {\n    this.options.stdout.write(\n      (this.altScreenActive ? ENTER_ALT_SCREEN : '') + // re-enter alt — vim's rmcup dropped us to main\n        '\\x1b[2J' + // clear screen (now alt if fullscreen)\n        '\\x1b[H' + // cursor home\n        (this.altScreenMouseTracking ? ENABLE_MOUSE_TRACKING : '') + // re-enable mouse (skip if CLAUDE_CODE_DISABLE_MOUSE)\n        (this.altScreenActive ? '' : '\\x1b[?1049l') + // exit alt (non-fullscreen only)\n        '\\x1b[?25l', // hide cursor (Ink manages)\n    )\n    this.resumeStdin()\n    if (this.altScreenActive) {\n      this.resetFramesForAltScreen()\n    } else {\n      this.repaint()\n    }\n    this.resume()\n    // Re-enable focus reporting and extended key reporting — terminal\n    // editors (vim, nano, etc.) write their own modifyOtherKeys level on\n    // entry and reset it on exit, leaving us unable to distinguish\n    // ctrl+shift+<letter> from ctrl+<letter>. Pop-before-push keeps the\n    // Kitty stack balanced (a well-behaved editor restores our entry, so\n    // without the pop we'd accumulate depth on each editor round-trip).\n    this.options.stdout.write(\n      '\\x1b[?1004h' +\n        (supportsExtendedKeys()\n          ? DISABLE_KITTY_KEYBOARD +\n            ENABLE_KITTY_KEYBOARD +\n            ENABLE_MODIFY_OTHER_KEYS\n          : ''),\n    )\n  }\n\n  onRender() {\n    if (this.isUnmounted || this.isPaused) {\n      return\n    }\n    // Entering a render cancels any pending drain tick — this render will\n    // handle the drain (and re-schedule below if needed). Prevents a\n    // wheel-event-triggered render AND a drain-timer render both firing.\n    if (this.drainTimer !== null) {\n      clearTimeout(this.drainTimer)\n      this.drainTimer = null\n    }\n\n    // Flush deferred interaction-time update before rendering so we call\n    // Date.now() at most once per frame instead of once per keypress.\n    // Done before the render to avoid dirtying state that would trigger\n    // an extra React re-render cycle.\n    flushInteractionTime()\n\n    const renderStart = performance.now()\n    const terminalWidth = this.options.stdout.columns || 80\n    const terminalRows = this.options.stdout.rows || 24\n\n    const frame = this.renderer({\n      frontFrame: this.frontFrame,\n      backFrame: this.backFrame,\n      isTTY: this.options.stdout.isTTY,\n      terminalWidth,\n      terminalRows,\n      altScreen: this.altScreenActive,\n      prevFrameContaminated: this.prevFrameContaminated,\n    })\n    const rendererMs = performance.now() - renderStart\n\n    // Sticky/auto-follow scrolled the ScrollBox this frame. Translate the\n    // selection by the same delta so the highlight stays anchored to the\n    // TEXT (native terminal behavior — the selection walks up the screen\n    // as content scrolls, eventually clipping at the top). frontFrame\n    // still holds the PREVIOUS frame's screen (swap is at ~500 below), so\n    // captureScrolledRows reads the rows that are about to scroll out\n    // before they're overwritten — the text stays copyable until the\n    // selection scrolls entirely off. During drag, focus tracks the mouse\n    // (screen-local) so only anchor shifts — selection grows toward the\n    // mouse as the anchor walks up. After release, both ends are text-\n    // anchored and move as a block.\n    const follow = consumeFollowScroll()\n    if (\n      follow &&\n      this.selection.anchor &&\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. Without this guard, a\n      // footer selection would be shifted by -delta then clamped to\n      // viewportBottom, teleporting it into the scrollbox. Mirror the\n      // bounds check the deleted check() in ScrollKeybindingHandler had.\n      this.selection.anchor.row >= follow.viewportTop &&\n      this.selection.anchor.row <= follow.viewportBottom\n    ) {\n      const { delta, viewportTop, viewportBottom } = follow\n      // captureScrolledRows and shift* are a pair: capture grabs rows about\n      // to scroll off, shift moves the selection endpoint so the same rows\n      // won't intersect again next frame. Capturing without shifting leaves\n      // the endpoint in place, so the SAME viewport rows re-intersect every\n      // frame and scrolledOffAbove grows without bound — getSelectedText\n      // then returns ever-growing text on each re-copy. Keep capture inside\n      // each shift branch so the pairing can't be broken by a new guard.\n      if (this.selection.isDragging) {\n        if (hasSelection(this.selection)) {\n          captureScrolledRows(\n            this.selection,\n            this.frontFrame.screen,\n            viewportTop,\n            viewportTop + delta - 1,\n            'above',\n          )\n        }\n        shiftAnchor(this.selection, -delta, viewportTop, viewportBottom)\n      } else if (\n        // Flag-3 guard: the anchor check above only proves ONE endpoint is\n        // on scrollbox content. A drag from row 3 (scrollbox) into the\n        // footer at row 6, then release, leaves focus outside the viewport\n        // — shiftSelectionForFollow would clamp it to viewportBottom,\n        // teleporting the highlight from static footer into the scrollbox.\n        // Symmetric check: require BOTH ends inside to translate. A\n        // straddling selection falls through to NEITHER shift NOR capture:\n        // the footer endpoint pins the selection, text scrolls away under\n        // the highlight, and getSelectedText reads the CURRENT screen\n        // contents — no accumulation. Dragging branch doesn't need this:\n        // shiftAnchor ignores focus, and the anchor DOES shift (so capture\n        // is correct there even when focus is in the footer).\n        !this.selection.focus ||\n        (this.selection.focus.row >= viewportTop &&\n          this.selection.focus.row <= viewportBottom)\n      ) {\n        if (hasSelection(this.selection)) {\n          captureScrolledRows(\n            this.selection,\n            this.frontFrame.screen,\n            viewportTop,\n            viewportTop + delta - 1,\n            'above',\n          )\n        }\n        const cleared = shiftSelectionForFollow(\n          this.selection,\n          -delta,\n          viewportTop,\n          viewportBottom,\n        )\n        // Auto-clear (both ends overshot minRow) must notify React-land\n        // so useHasSelection re-renders and the footer copy/escape hint\n        // disappears. notifySelectionChange() would recurse into onRender;\n        // fire the listeners directly — they schedule a React update for\n        // LATER, they don't re-enter this frame.\n        if (cleared) for (const cb of this.selectionListeners) cb()\n      }\n    }\n\n    // Selection overlay: invert cell styles in the screen buffer itself,\n    // so the diff picks up selection as ordinary cell changes and\n    // LogUpdate remains a pure diff engine.\n    //\n    // Full-screen damage (PR #20120) is a correctness backstop for the\n    // sibling-resize bleed: when flexbox siblings resize between frames\n    // (spinner appears → bottom grows → scrollbox shrinks), the\n    // cached-clear + clip-and-cull + setCellAt damage union can miss\n    // transition cells at the boundary. But that only happens when layout\n    // actually SHIFTS — didLayoutShift() tracks exactly this (any node's\n    // cached yoga position/size differs from current, or a child was\n    // removed). Steady-state frames (spinner rotate, clock tick, text\n    // stream into fixed-height box) don't shift layout, so normal damage\n    // bounds are correct and diffEach only compares the damaged region.\n    //\n    // Selection also requires full damage: overlay writes via setCellStyleId\n    // which doesn't track damage, and prev-frame overlay cells need to be\n    // compared when selection moves/clears. prevFrameContaminated covers\n    // the frame-after-selection-clears case.\n    let selActive = false\n    let hlActive = false\n    if (this.altScreenActive) {\n      selActive = hasSelection(this.selection)\n      if (selActive) {\n        applySelectionOverlay(frame.screen, this.selection, this.stylePool)\n      }\n      // Scan-highlight: inverse on ALL visible matches (less/vim style).\n      // Position-highlight (below) overlays CURRENT (yellow) on top.\n      hlActive = applySearchHighlight(\n        frame.screen,\n        this.searchHighlightQuery,\n        this.stylePool,\n      )\n      // Position-based CURRENT: write yellow at positions[currentIdx] +\n      // rowOffset. No scanning — positions came from a prior scan when\n      // the message first mounted. Message-relative + rowOffset = screen.\n      if (this.searchPositions) {\n        const sp = this.searchPositions\n        const posApplied = applyPositionedHighlight(\n          frame.screen,\n          this.stylePool,\n          sp.positions,\n          sp.rowOffset,\n          sp.currentIdx,\n        )\n        hlActive = hlActive || posApplied\n      }\n    }\n\n    // Full-damage backstop: applies on BOTH alt-screen and main-screen.\n    // Layout shifts (spinner appears, status line resizes) can leave stale\n    // cells at sibling boundaries that per-node damage tracking misses.\n    // Selection/highlight overlays write via setCellStyleId which doesn't\n    // track damage. prevFrameContaminated covers the cleanup frame.\n    if (\n      didLayoutShift() ||\n      selActive ||\n      hlActive ||\n      this.prevFrameContaminated\n    ) {\n      frame.screen.damage = {\n        x: 0,\n        y: 0,\n        width: frame.screen.width,\n        height: frame.screen.height,\n      }\n    }\n\n    // Alt-screen: anchor the physical cursor to (0,0) before every diff.\n    // All cursor moves in log-update are RELATIVE to prev.cursor; if tmux\n    // (or any emulator) perturbs the physical cursor out-of-band (status\n    // bar refresh, pane redraw, Cmd+K wipe), the relative moves drift and\n    // content creeps up 1 row/frame. CSI H resets the physical cursor;\n    // passing prev.cursor=(0,0) makes the diff compute from the same spot.\n    // Self-healing against any external cursor manipulation. Main-screen\n    // can't do this — cursor.y tracks scrollback rows CSI H can't reach.\n    // The CSI H write is deferred until after the diff is computed so we\n    // can skip it for empty diffs (no writes → physical cursor unused).\n    let prevFrame = this.frontFrame\n    if (this.altScreenActive) {\n      prevFrame = { ...this.frontFrame, cursor: ALT_SCREEN_ANCHOR_CURSOR }\n    }\n\n    const tDiff = performance.now()\n    const diff = this.log.render(\n      prevFrame,\n      frame,\n      this.altScreenActive,\n      // DECSTBM needs BSU/ESU atomicity — without it the outer terminal\n      // renders the scrolled-but-not-yet-repainted intermediate state.\n      // tmux is the main case (re-emits DECSTBM with its own timing and\n      // doesn't implement DEC 2026, so SYNC_OUTPUT_SUPPORTED is false).\n      SYNC_OUTPUT_SUPPORTED,\n    )\n    const diffMs = performance.now() - tDiff\n    // Swap buffers\n    this.backFrame = this.frontFrame\n    this.frontFrame = frame\n\n    // Periodically reset char/hyperlink pools to prevent unbounded growth\n    // during long sessions. 5 minutes is infrequent enough that the O(cells)\n    // migration cost is negligible. Reuses renderStart to avoid extra clock call.\n    if (renderStart - this.lastPoolResetTime > 5 * 60 * 1000) {\n      this.resetPools()\n      this.lastPoolResetTime = renderStart\n    }\n\n    const flickers: FrameEvent['flickers'] = []\n    for (const patch of diff) {\n      if (patch.type === 'clearTerminal') {\n        flickers.push({\n          desiredHeight: frame.screen.height,\n          availableHeight: frame.viewport.height,\n          reason: patch.reason,\n        })\n        if (isDebugRepaintsEnabled() && patch.debug) {\n          const chain = dom.findOwnerChainAtRow(\n            this.rootNode,\n            patch.debug.triggerY,\n          )\n          logForDebugging(\n            `[REPAINT] full reset · ${patch.reason} · row ${patch.debug.triggerY}\\n` +\n              `  prev: \"${patch.debug.prevLine}\"\\n` +\n              `  next: \"${patch.debug.nextLine}\"\\n` +\n              `  culprit: ${chain.length ? chain.join(' < ') : '(no owner chain captured)'}`,\n            { level: 'warn' },\n          )\n        }\n      }\n    }\n\n    const tOptimize = performance.now()\n    const optimized = optimize(diff)\n    const optimizeMs = performance.now() - tOptimize\n    const hasDiff = optimized.length > 0\n    if (this.altScreenActive && hasDiff) {\n      // Prepend CSI H to anchor the physical cursor to (0,0) so\n      // log-update's relative moves compute from a known spot (self-healing\n      // against out-of-band cursor drift, see the ALT_SCREEN_ANCHOR_CURSOR\n      // comment above). Append CSI row;1 H to park the cursor at the bottom\n      // row (where the prompt input is) — without this, the cursor ends\n      // wherever the last diff write landed (a different row every frame),\n      // making iTerm2's cursor guide flicker as it chases the cursor.\n      // BSU/ESU protects content atomicity but iTerm2's guide tracks cursor\n      // position independently. Parking at bottom (not 0,0) keeps the guide\n      // where the user's attention is.\n      //\n      // After resize, prepend ERASE_SCREEN too. The diff only writes cells\n      // that changed; cells where new=blank and prev-buffer=blank get skipped\n      // — but the physical terminal still has stale content there (shorter\n      // lines at new width leave old-width text tails visible). ERASE inside\n      // BSU/ESU is atomic: old content stays visible until the whole\n      // erase+paint lands, then swaps in one go. Writing ERASE_SCREEN\n      // synchronously in handleResize would blank the screen for the ~80ms\n      // render() takes.\n      if (this.needsEraseBeforePaint) {\n        this.needsEraseBeforePaint = false\n        optimized.unshift(ERASE_THEN_HOME_PATCH)\n      } else {\n        optimized.unshift(CURSOR_HOME_PATCH)\n      }\n      optimized.push(this.altScreenParkPatch)\n    }\n\n    // Native cursor positioning: park the terminal cursor at the declared\n    // position so IME preedit text renders inline and screen readers /\n    // magnifiers can follow the input. nodeCache holds the absolute screen\n    // rect populated by renderNodeToOutput this frame (including scrollTop\n    // translation) — if the declared node didn't render (stale declaration\n    // after remount, or scrolled out of view), it won't be in the cache\n    // and no move is emitted.\n    const decl = this.cursorDeclaration\n    const rect = decl !== null ? nodeCache.get(decl.node) : undefined\n    const target =\n      decl !== null && rect !== undefined\n        ? { x: rect.x + decl.relativeX, y: rect.y + decl.relativeY }\n        : null\n    const parked = this.displayCursor\n\n    // Preserve the empty-diff zero-write fast path: skip all cursor writes\n    // when nothing rendered AND the park target is unchanged.\n    const targetMoved =\n      target !== null &&\n      (parked === null || parked.x !== target.x || parked.y !== target.y)\n    if (hasDiff || targetMoved || (target === null && parked !== null)) {\n      // Main-screen preamble: log-update's relative moves assume the\n      // physical cursor is at prevFrame.cursor. If last frame parked it\n      // elsewhere, move back before the diff runs. Alt-screen's CSI H\n      // already resets to (0,0) so no preamble needed.\n      if (parked !== null && !this.altScreenActive && hasDiff) {\n        const pdx = prevFrame.cursor.x - parked.x\n        const pdy = prevFrame.cursor.y - parked.y\n        if (pdx !== 0 || pdy !== 0) {\n          optimized.unshift({ type: 'stdout', content: cursorMove(pdx, pdy) })\n        }\n      }\n\n      if (target !== null) {\n        if (this.altScreenActive) {\n          // Absolute CUP (1-indexed); next frame's CSI H resets regardless.\n          // Emitted after altScreenParkPatch so the declared position wins.\n          const row = Math.min(Math.max(target.y + 1, 1), terminalRows)\n          const col = Math.min(Math.max(target.x + 1, 1), terminalWidth)\n          optimized.push({ type: 'stdout', content: cursorPosition(row, col) })\n        } else {\n          // After the diff (or preamble), cursor is at frame.cursor. If no\n          // diff AND previously parked, it's still at the old park position\n          // (log-update wrote nothing). Otherwise it's at frame.cursor.\n          const from =\n            !hasDiff && parked !== null\n              ? parked\n              : { x: frame.cursor.x, y: frame.cursor.y }\n          const dx = target.x - from.x\n          const dy = target.y - from.y\n          if (dx !== 0 || dy !== 0) {\n            optimized.push({ type: 'stdout', content: cursorMove(dx, dy) })\n          }\n        }\n        this.displayCursor = target\n      } else {\n        // Declaration cleared (input blur, unmount). Restore physical cursor\n        // to frame.cursor before forgetting the park position — otherwise\n        // displayCursor=null lies about where the cursor is, and the NEXT\n        // frame's preamble (or log-update's relative moves) computes from a\n        // wrong spot. The preamble above handles hasDiff; this handles\n        // !hasDiff (e.g. accessibility mode where blur doesn't change\n        // renderedValue since invert is identity).\n        if (parked !== null && !this.altScreenActive && !hasDiff) {\n          const rdx = frame.cursor.x - parked.x\n          const rdy = frame.cursor.y - parked.y\n          if (rdx !== 0 || rdy !== 0) {\n            optimized.push({ type: 'stdout', content: cursorMove(rdx, rdy) })\n          }\n        }\n        this.displayCursor = null\n      }\n    }\n\n    const tWrite = performance.now()\n    writeDiffToTerminal(\n      this.terminal,\n      optimized,\n      this.altScreenActive && !SYNC_OUTPUT_SUPPORTED,\n    )\n    const writeMs = performance.now() - tWrite\n\n    // Update blit safety for the NEXT frame. The frame just rendered\n    // becomes frontFrame (= next frame's prevScreen). If we applied the\n    // selection overlay, that buffer has inverted cells. selActive/hlActive\n    // are only ever true in alt-screen; in main-screen this is false→false.\n    this.prevFrameContaminated = selActive || hlActive\n\n    // A ScrollBox has pendingScrollDelta left to drain — schedule the next\n    // frame. MUST NOT call this.scheduleRender() here: we're inside a\n    // trailing-edge throttle invocation, timerId is undefined, and lodash's\n    // debounce sees timeSinceLastCall >= wait (last call was at the start\n    // of this window) → leadingEdge fires IMMEDIATELY → double render ~0.1ms\n    // apart → jank. Use a plain timeout. If a wheel event arrives first,\n    // its scheduleRender path fires a render which clears this timer at\n    // the top of onRender — no double.\n    //\n    // Drain frames are cheap (DECSTBM + ~10 patches, ~200 bytes) so run at\n    // quarter interval (~250fps, setTimeout practical floor) for max scroll\n    // speed. Regular renders stay at FRAME_INTERVAL_MS via the throttle.\n    if (frame.scrollDrainPending) {\n      this.drainTimer = setTimeout(\n        () => this.onRender(),\n        FRAME_INTERVAL_MS >> 2,\n      )\n    }\n\n    const yogaMs = getLastYogaMs()\n    const commitMs = getLastCommitMs()\n    const yc = this.lastYogaCounters\n    // Reset so drain-only frames (no React commit) don't repeat stale values.\n    resetProfileCounters()\n    this.lastYogaCounters = {\n      ms: 0,\n      visited: 0,\n      measured: 0,\n      cacheHits: 0,\n      live: 0,\n    }\n    this.options.onFrame?.({\n      durationMs: performance.now() - renderStart,\n      phases: {\n        renderer: rendererMs,\n        diff: diffMs,\n        optimize: optimizeMs,\n        write: writeMs,\n        patches: diff.length,\n        yoga: yogaMs,\n        commit: commitMs,\n        yogaVisited: yc.visited,\n        yogaMeasured: yc.measured,\n        yogaCacheHits: yc.cacheHits,\n        yogaLive: yc.live,\n      },\n      flickers,\n    })\n  }\n\n  pause(): void {\n    // Flush pending React updates and render before pausing.\n    // @ts-expect-error flushSyncFromReconciler exists in react-reconciler 0.31 but not in @types/react-reconciler\n    reconciler.flushSyncFromReconciler()\n    this.onRender()\n\n    this.isPaused = true\n  }\n\n  resume(): void {\n    this.isPaused = false\n    this.onRender()\n  }\n\n  /**\n   * Reset frame buffers so the next render writes the full screen from scratch.\n   * Call this before resume() when the terminal content has been corrupted by\n   * an external process (e.g. tmux, shell, full-screen TUI).\n   */\n  repaint(): void {\n    this.frontFrame = emptyFrame(\n      this.frontFrame.viewport.height,\n      this.frontFrame.viewport.width,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    this.backFrame = emptyFrame(\n      this.backFrame.viewport.height,\n      this.backFrame.viewport.width,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    this.log.reset()\n    // Physical cursor position is unknown after external terminal corruption.\n    // Clear displayCursor so the cursor preamble doesn't emit a stale\n    // relative move from where we last parked it.\n    this.displayCursor = null\n  }\n\n  /**\n   * Clear the physical terminal and force a full redraw.\n   *\n   * The traditional readline ctrl+l — clears the visible screen and\n   * redraws the current content. Also the recovery path when the terminal\n   * was cleared externally (macOS Cmd+K) and Ink's diff engine thinks\n   * unchanged cells don't need repainting. Scrollback is preserved.\n   */\n  forceRedraw(): void {\n    if (!this.options.stdout.isTTY || this.isUnmounted || this.isPaused) return\n    this.options.stdout.write(ERASE_SCREEN + CURSOR_HOME)\n    if (this.altScreenActive) {\n      this.resetFramesForAltScreen()\n    } else {\n      this.repaint()\n      // repaint() resets frontFrame to 0×0. Without this flag the next\n      // frame's blit optimization copies from that empty screen and the\n      // diff sees no content. onRender resets the flag at frame end.\n      this.prevFrameContaminated = true\n    }\n    this.onRender()\n  }\n\n  /**\n   * Mark the previous frame as untrustworthy for blit, forcing the next\n   * render to do a full-damage diff instead of the per-node fast path.\n   *\n   * Lighter than forceRedraw() — no screen clear, no extra write. Call\n   * from a useLayoutEffect cleanup when unmounting a tall overlay: the\n   * blit fast path can copy stale cells from the overlay frame into rows\n   * the shrunken layout no longer reaches, leaving a ghost title/divider.\n   * onRender resets the flag at frame end so it's one-shot.\n   */\n  invalidatePrevFrame(): void {\n    this.prevFrameContaminated = true\n  }\n\n  /**\n   * Called by the <AlternateScreen> component on mount/unmount.\n   * Controls cursor.y clamping in the renderer and gates alt-screen-aware\n   * behavior in SIGCONT/resize/unmount handlers. Repaints on change so\n   * the first alt-screen frame (and first main-screen frame on exit) is\n   * a full redraw with no stale diff state.\n   */\n  setAltScreenActive(active: boolean, mouseTracking = false): void {\n    if (this.altScreenActive === active) return\n    this.altScreenActive = active\n    this.altScreenMouseTracking = active && mouseTracking\n    if (active) {\n      this.resetFramesForAltScreen()\n    } else {\n      this.repaint()\n    }\n  }\n\n  get isAltScreenActive(): boolean {\n    return this.altScreenActive\n  }\n\n  /**\n   * Re-assert terminal modes after a gap (>5s stdin silence or event-loop\n   * stall). Catches tmux detach→attach, ssh reconnect, and laptop\n   * sleep/wake — none of which send SIGCONT. The terminal may reset DEC\n   * private modes on reconnect; this method restores them.\n   *\n   * Always re-asserts extended key reporting and mouse tracking. Mouse\n   * tracking is idempotent (DEC private mode set-when-set is a no-op). The\n   * Kitty keyboard protocol is NOT — CSI >1u is a stack push, so we pop\n   * first to keep depth balanced (pop on empty stack is a no-op per spec,\n   * so after a terminal reset this still restores depth 0→1). Without the\n   * pop, each >5s idle gap adds a stack entry, and the single pop on exit\n   * or suspend can't drain them — the shell is left in CSI u mode where\n   * Ctrl+C/Ctrl+D leak as escape sequences. The alt-screen\n   * re-entry (ERASE_SCREEN + frame reset) is NOT idempotent — it blanks the\n   * screen — so it's opt-in via includeAltScreen. The stdin-gap caller fires\n   * on ordinary >5s idle + keypress and must not erase; the event-loop stall\n   * detector fires on genuine sleep/wake and opts in. tmux attach / ssh\n   * reconnect typically send a resize, which already covers alt-screen via\n   * handleResize.\n   */\n  reassertTerminalModes = (includeAltScreen = false): void => {\n    if (!this.options.stdout.isTTY) return\n    // Don't touch the terminal during an editor handoff — re-enabling kitty\n    // keyboard here would undo enterAlternateScreen's disable and nano would\n    // start seeing CSI-u sequences again.\n    if (this.isPaused) return\n    // Extended keys — re-assert if enabled (App.tsx enables these on\n    // allowlisted terminals at raw-mode entry; a terminal reset clears them).\n    // Pop-before-push keeps Kitty stack depth at 1 instead of accumulating\n    // on each call.\n    if (supportsExtendedKeys()) {\n      this.options.stdout.write(\n        DISABLE_KITTY_KEYBOARD +\n          ENABLE_KITTY_KEYBOARD +\n          ENABLE_MODIFY_OTHER_KEYS,\n      )\n    }\n    if (!this.altScreenActive) return\n    // Mouse tracking — idempotent, safe to re-assert on every stdin gap.\n    if (this.altScreenMouseTracking) {\n      this.options.stdout.write(ENABLE_MOUSE_TRACKING)\n    }\n    // Alt-screen re-entry — destructive (ERASE_SCREEN). Only for callers that\n    // have a strong signal the terminal actually dropped mode 1049.\n    if (includeAltScreen) {\n      this.reenterAltScreen()\n    }\n  }\n\n  /**\n   * Mark this instance as unmounted so future unmount() calls early-return.\n   * Called by gracefulShutdown's cleanupTerminalModes() after it has sent\n   * EXIT_ALT_SCREEN but before the remaining terminal-reset sequences.\n   * Without this, signal-exit's deferred ink.unmount() (triggered by\n   * process.exit()) runs the full unmount path: onRender() + writeSync\n   * cleanup block + updateContainerSync → AlternateScreen unmount cleanup.\n   * The result is 2-3 redundant EXIT_ALT_SCREEN sequences landing on the\n   * main screen AFTER printResumeHint(), which tmux (at least) interprets\n   * as restoring the saved cursor position — clobbering the resume hint.\n   */\n  detachForShutdown(): void {\n    this.isUnmounted = true\n    // Cancel any pending throttled render so it doesn't fire between\n    // cleanupTerminalModes() and process.exit() and write to main screen.\n    this.scheduleRender.cancel?.()\n    // Restore stdin from raw mode. unmount() used to do this via React\n    // unmount (App.componentWillUnmount → handleSetRawMode(false)) but we're\n    // short-circuiting that path. Must use this.options.stdin — NOT\n    // process.stdin — because getStdinOverride() may have opened /dev/tty\n    // when stdin is piped.\n    const stdin = this.options.stdin as NodeJS.ReadStream & {\n      isRaw?: boolean\n      setRawMode?: (m: boolean) => void\n    }\n    this.drainStdin()\n    if (stdin.isTTY && stdin.isRaw && stdin.setRawMode) {\n      stdin.setRawMode(false)\n    }\n  }\n\n  /** @see drainStdin */\n  drainStdin(): void {\n    drainStdin(this.options.stdin)\n  }\n\n  /**\n   * Re-enter alt-screen, clear, home, re-enable mouse tracking, and reset\n   * frame buffers so the next render repaints from scratch. Self-heal for\n   * SIGCONT, resize, and stdin-gap/event-loop-stall (sleep/wake) — any of\n   * which can leave the terminal in main-screen mode while altScreenActive\n   * stays true. ENTER_ALT_SCREEN is a terminal-side no-op if already in alt.\n   */\n  private reenterAltScreen(): void {\n    this.options.stdout.write(\n      ENTER_ALT_SCREEN +\n        ERASE_SCREEN +\n        CURSOR_HOME +\n        (this.altScreenMouseTracking ? ENABLE_MOUSE_TRACKING : ''),\n    )\n    this.resetFramesForAltScreen()\n  }\n\n  /**\n   * Seed prev/back frames with full-size BLANK screens (rows×cols of empty\n   * cells, not 0×0). In alt-screen mode, next.screen.height is always\n   * terminalRows; if prev.screen.height is 0 (emptyFrame's default),\n   * log-update sees heightDelta > 0 ('growing') and calls renderFrameSlice,\n   * whose trailing per-row CR+LF at the last row scrolls the alt screen,\n   * permanently desyncing the virtual and physical cursors by 1 row.\n   *\n   * With a rows×cols blank prev, heightDelta === 0 → standard diffEach\n   * → moveCursorTo (CSI cursorMove, no LF, no scroll).\n   *\n   * viewport.height = rows + 1 matches the renderer's alt-screen output,\n   * preventing a spurious resize trigger on the first frame. cursor.y = 0\n   * matches the physical cursor after ENTER_ALT_SCREEN + CSI H (home).\n   */\n  private resetFramesForAltScreen(): void {\n    const rows = this.terminalRows\n    const cols = this.terminalColumns\n    const blank = (): Frame => ({\n      screen: createScreen(\n        cols,\n        rows,\n        this.stylePool,\n        this.charPool,\n        this.hyperlinkPool,\n      ),\n      viewport: { width: cols, height: rows + 1 },\n      cursor: { x: 0, y: 0, visible: true },\n    })\n    this.frontFrame = blank()\n    this.backFrame = blank()\n    this.log.reset()\n    // Defense-in-depth: alt-screen skips the cursor preamble anyway (CSI H\n    // resets), but a stale displayCursor would be misleading if we later\n    // exit to main-screen without an intervening render.\n    this.displayCursor = null\n    // Fresh frontFrame is blank rows×cols — blitting from it would copy\n    // blanks over content. Next alt-screen frame must full-render.\n    this.prevFrameContaminated = true\n  }\n\n  /**\n   * Copy the current selection to the clipboard without clearing the\n   * highlight. Matches iTerm2's copy-on-select behavior where the selected\n   * region stays visible after the automatic copy.\n   */\n  copySelectionNoClear(): string {\n    if (!hasSelection(this.selection)) return ''\n    const text = getSelectedText(this.selection, this.frontFrame.screen)\n    if (text) {\n      // Raw OSC 52, or DCS-passthrough-wrapped OSC 52 inside tmux (tmux\n      // drops it silently unless allow-passthrough is on — no regression).\n      void setClipboard(text).then(raw => {\n        if (raw) this.options.stdout.write(raw)\n      })\n    }\n    return text\n  }\n\n  /**\n   * Copy the current text selection to the system clipboard via OSC 52\n   * and clear the selection. Returns the copied text (empty if no selection).\n   */\n  copySelection(): string {\n    if (!hasSelection(this.selection)) return ''\n    const text = this.copySelectionNoClear()\n    clearSelection(this.selection)\n    this.notifySelectionChange()\n    return text\n  }\n\n  /** Clear the current text selection without copying. */\n  clearTextSelection(): void {\n    if (!hasSelection(this.selection)) return\n    clearSelection(this.selection)\n    this.notifySelectionChange()\n  }\n\n  /**\n   * Set the search highlight query. Non-empty → all visible occurrences\n   * are inverted (SGR 7) on the next frame; first one also underlined.\n   * Empty → clears (prevFrameContaminated handles the frame after). Same\n   * damage-tracking machinery as selection — setCellStyleId doesn't track\n   * damage, so the overlay forces full-frame damage while active.\n   */\n  setSearchHighlight(query: string): void {\n    if (this.searchHighlightQuery === query) return\n    this.searchHighlightQuery = query\n    this.scheduleRender()\n  }\n\n  /** Paint an EXISTING DOM subtree to a fresh Screen at its natural\n   *  height, scan for query. Returns positions relative to the element's\n   *  bounding box (row 0 = element top).\n   *\n   *  The element comes from the MAIN tree — built with all real\n   *  providers, yoga already computed. We paint it to a fresh buffer\n   *  with offsets so it lands at (0,0). Same paint path as the main\n   *  render. Zero drift. No second React root, no context bridge.\n   *\n   *  ~1-2ms (paint only, no reconcile — the DOM is already built). */\n  scanElementSubtree(el: dom.DOMElement): MatchPosition[] {\n    if (!this.searchHighlightQuery || !el.yogaNode) return []\n    const width = Math.ceil(el.yogaNode.getComputedWidth())\n    const height = Math.ceil(el.yogaNode.getComputedHeight())\n    if (width <= 0 || height <= 0) return []\n    // renderNodeToOutput adds el's OWN computedLeft/Top to offsetX/Y.\n    // Passing -elLeft/-elTop nets to 0 → paints at (0,0) in our buffer.\n    const elLeft = el.yogaNode.getComputedLeft()\n    const elTop = el.yogaNode.getComputedTop()\n    const screen = createScreen(\n      width,\n      height,\n      this.stylePool,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    const output = new Output({\n      width,\n      height,\n      stylePool: this.stylePool,\n      screen,\n    })\n    renderNodeToOutput(el, output, {\n      offsetX: -elLeft,\n      offsetY: -elTop,\n      prevScreen: undefined,\n    })\n    const rendered = output.get()\n    // renderNodeToOutput wrote our offset positions to nodeCache —\n    // corrupts the main render (it'd blit from wrong coords). Mark the\n    // subtree dirty so the next main render repaints + re-caches\n    // correctly. One extra paint of this message, but correct > fast.\n    dom.markDirty(el)\n    const positions = scanPositions(rendered, this.searchHighlightQuery)\n    logForDebugging(\n      `scanElementSubtree: q='${this.searchHighlightQuery}' ` +\n        `el=${width}x${height}@(${elLeft},${elTop}) n=${positions.length} ` +\n        `[${positions\n          .slice(0, 10)\n          .map(p => `${p.row}:${p.col}`)\n          .join(',')}` +\n        `${positions.length > 10 ? ',…' : ''}]`,\n    )\n    return positions\n  }\n\n  /** Set the position-based highlight state. Every frame, writes CURRENT\n   *  style at positions[currentIdx] + rowOffset. null clears. The scan-\n   *  highlight (inverse on all matches) still runs — this overlays yellow\n   *  on top. rowOffset changes as the user scrolls (= message's current\n   *  screen-top); positions stay stable (message-relative). */\n  setSearchPositions(\n    state: {\n      positions: MatchPosition[]\n      rowOffset: number\n      currentIdx: number\n    } | null,\n  ): void {\n    this.searchPositions = state\n    this.scheduleRender()\n  }\n\n  /**\n   * Set the selection highlight background color. Replaces the per-cell\n   * SGR-7 inverse with a solid theme-aware bg (matches native terminal\n   * selection). Accepts the same color formats as Text backgroundColor\n   * (rgb(), ansi:name, #hex, ansi256()) — colorize() routes through\n   * chalk so the tmux/xterm.js level clamps in colorize.ts apply and\n   * the emitted SGR is correct for the current terminal.\n   *\n   * Called by React-land once theme is known (ScrollKeybindingHandler's\n   * useEffect watching useTheme). Before that call, withSelectionBg\n   * falls back to withInverse so selection still renders on the first\n   * frame; the effect fires before any mouse input so the fallback is\n   * unobservable in practice.\n   */\n  setSelectionBgColor(color: string): void {\n    // Wrap a NUL marker, then split on it to extract the open/close SGR.\n    // colorize returns the input unchanged if the color string is bad —\n    // no NUL-split then, so fall through to null (inverse fallback).\n    const wrapped = colorize('\\0', color, 'background')\n    const nul = wrapped.indexOf('\\0')\n    if (nul <= 0 || nul === wrapped.length - 1) {\n      this.stylePool.setSelectionBg(null)\n      return\n    }\n    this.stylePool.setSelectionBg({\n      type: 'ansi',\n      code: wrapped.slice(0, nul),\n      endCode: wrapped.slice(nul + 1), // always \\x1b[49m for bg\n    })\n    // No scheduleRender: this is called from a React effect that already\n    // runs inside the render cycle, and the bg only matters once a\n    // selection exists (which itself triggers a full-damage frame).\n  }\n\n  /**\n   * Capture text from rows about to scroll out of the viewport during\n   * drag-to-scroll. Must be called BEFORE the ScrollBox scrolls so the\n   * screen buffer still holds the outgoing content. Accumulated into\n   * the selection state and joined back in by getSelectedText.\n   */\n  captureScrolledRows(\n    firstRow: number,\n    lastRow: number,\n    side: 'above' | 'below',\n  ): void {\n    captureScrolledRows(\n      this.selection,\n      this.frontFrame.screen,\n      firstRow,\n      lastRow,\n      side,\n    )\n  }\n\n  /**\n   * Shift anchor AND focus by dRow, clamped to [minRow, maxRow]. Used by\n   * keyboard scroll handlers (PgUp/PgDn etc.) so the highlight tracks the\n   * content instead of disappearing. Unlike shiftAnchor (drag-to-scroll),\n   * this moves BOTH endpoints — the user isn't holding the mouse at one\n   * edge. Supplies screen.width for the col-reset-on-clamp boundary.\n   */\n  shiftSelectionForScroll(dRow: number, minRow: number, maxRow: number): void {\n    const hadSel = hasSelection(this.selection)\n    shiftSelection(\n      this.selection,\n      dRow,\n      minRow,\n      maxRow,\n      this.frontFrame.screen.width,\n    )\n    // shiftSelection clears when both endpoints overshoot the same edge\n    // (Home/g/End/G page-jump past the selection). Notify subscribers so\n    // useHasSelection updates. Safe to call notifySelectionChange here —\n    // this runs from keyboard handlers, not inside onRender().\n    if (hadSel && !hasSelection(this.selection)) {\n      this.notifySelectionChange()\n    }\n  }\n\n  /**\n   * Keyboard selection extension (shift+arrow/home/end). Moves focus;\n   * anchor stays fixed so the highlight grows or shrinks relative to it.\n   * Left/right wrap across row boundaries — native macOS text-edit\n   * behavior: shift+left at col 0 wraps to end of the previous row.\n   * Up/down clamp at viewport edges (no scroll-to-extend yet). Drops to\n   * char mode. No-op outside alt-screen or without an active selection.\n   */\n  moveSelectionFocus(move: FocusMove): void {\n    if (!this.altScreenActive) return\n    const { focus } = this.selection\n    if (!focus) return\n    const { width, height } = this.frontFrame.screen\n    const maxCol = width - 1\n    const maxRow = height - 1\n    let { col, row } = focus\n    switch (move) {\n      case 'left':\n        if (col > 0) col--\n        else if (row > 0) {\n          col = maxCol\n          row--\n        }\n        break\n      case 'right':\n        if (col < maxCol) col++\n        else if (row < maxRow) {\n          col = 0\n          row++\n        }\n        break\n      case 'up':\n        if (row > 0) row--\n        break\n      case 'down':\n        if (row < maxRow) row++\n        break\n      case 'lineStart':\n        col = 0\n        break\n      case 'lineEnd':\n        col = maxCol\n        break\n    }\n    if (col === focus.col && row === focus.row) return\n    moveFocus(this.selection, col, row)\n    this.notifySelectionChange()\n  }\n\n  /** Whether there is an active text selection. */\n  hasTextSelection(): boolean {\n    return hasSelection(this.selection)\n  }\n\n  /**\n   * Subscribe to selection state changes. Fires whenever the selection\n   * is started, updated, cleared, or copied. Returns an unsubscribe fn.\n   */\n  subscribeToSelectionChange(cb: () => void): () => void {\n    this.selectionListeners.add(cb)\n    return () => this.selectionListeners.delete(cb)\n  }\n\n  private notifySelectionChange(): void {\n    this.onRender()\n    for (const cb of this.selectionListeners) cb()\n  }\n\n  /**\n   * Hit-test the rendered DOM tree at (col, row) and bubble a ClickEvent\n   * from the deepest hit node up through ancestors with onClick handlers.\n   * Returns true if a DOM handler consumed the click. Gated on\n   * altScreenActive — clicks only make sense with a fixed viewport where\n   * nodeCache rects map 1:1 to terminal cells (no scrollback offset).\n   */\n  dispatchClick(col: number, row: number): boolean {\n    if (!this.altScreenActive) return false\n    const blank = isEmptyCellAt(this.frontFrame.screen, col, row)\n    return dispatchClick(this.rootNode, col, row, blank)\n  }\n\n  dispatchHover(col: number, row: number): void {\n    if (!this.altScreenActive) return\n    dispatchHover(this.rootNode, col, row, this.hoveredNodes)\n  }\n\n  dispatchKeyboardEvent(parsedKey: ParsedKey): void {\n    const target = this.focusManager.activeElement ?? this.rootNode\n    const event = new KeyboardEvent(parsedKey)\n    dispatcher.dispatchDiscrete(target, event)\n\n    // Tab cycling is the default action — only fires if no handler\n    // called preventDefault(). Mirrors browser behavior.\n    if (\n      !event.defaultPrevented &&\n      parsedKey.name === 'tab' &&\n      !parsedKey.ctrl &&\n      !parsedKey.meta\n    ) {\n      if (parsedKey.shift) {\n        this.focusManager.focusPrevious(this.rootNode)\n      } else {\n        this.focusManager.focusNext(this.rootNode)\n      }\n    }\n  }\n  /**\n   * Look up the URL at (col, row) in the current front frame. Checks for\n   * an OSC 8 hyperlink first, then falls back to scanning the row for a\n   * plain-text URL (mouse tracking intercepts the terminal's native\n   * Cmd+Click URL detection, so we replicate it). This is a pure lookup\n   * with no side effects — call it synchronously at click time so the\n   * result reflects the screen the user actually clicked on, then defer\n   * the browser-open action via a timer.\n   */\n  getHyperlinkAt(col: number, row: number): string | undefined {\n    if (!this.altScreenActive) return undefined\n    const screen = this.frontFrame.screen\n    const cell = cellAt(screen, col, row)\n    let url = cell?.hyperlink\n    // SpacerTail cells (right half of wide/CJK/emoji chars) store the\n    // hyperlink on the head cell at col-1.\n    if (!url && cell?.width === CellWidth.SpacerTail && col > 0) {\n      url = cellAt(screen, col - 1, row)?.hyperlink\n    }\n    return url ?? findPlainTextUrlAt(screen, col, row)\n  }\n\n  /**\n   * Optional callback fired when clicking an OSC 8 hyperlink in fullscreen\n   * mode. Set by FullscreenLayout via useLayoutEffect.\n   */\n  onHyperlinkClick: ((url: string) => void) | undefined\n\n  /**\n   * Stable prototype wrapper for onHyperlinkClick. Passed to <App> as\n   * onOpenHyperlink so the prop is a bound method (autoBind'd) that reads\n   * the mutable field at call time — not the undefined-at-render value.\n   */\n  openHyperlink(url: string): void {\n    this.onHyperlinkClick?.(url)\n  }\n\n  /**\n   * Handle a double- or triple-click at (col, row): select the word or\n   * line under the cursor by reading the current screen buffer. Called on\n   * PRESS (not release) so the highlight appears immediately and drag can\n   * extend the selection word-by-word / line-by-line. Falls back to\n   * char-mode startSelection if the click lands on a noSelect cell.\n   */\n  handleMultiClick(col: number, row: number, count: 2 | 3): void {\n    if (!this.altScreenActive) return\n    const screen = this.frontFrame.screen\n    // selectWordAt/selectLineAt no-op on noSelect/out-of-bounds. Seed with\n    // a char-mode selection so the press still starts a drag even if the\n    // word/line scan finds nothing selectable.\n    startSelection(this.selection, col, row)\n    if (count === 2) selectWordAt(this.selection, screen, col, row)\n    else selectLineAt(this.selection, screen, row)\n    // Ensure hasSelection is true so release doesn't re-dispatch onClickAt.\n    // selectWordAt no-ops on noSelect; selectLineAt no-ops out-of-bounds.\n    if (!this.selection.focus) this.selection.focus = this.selection.anchor\n    this.notifySelectionChange()\n  }\n\n  /**\n   * Handle a drag-motion at (col, row). In char mode updates focus to the\n   * exact cell. In word/line mode snaps to word/line boundaries so the\n   * selection extends by word/line like native macOS. Gated on\n   * altScreenActive for the same reason as dispatchClick.\n   */\n  handleSelectionDrag(col: number, row: number): void {\n    if (!this.altScreenActive) return\n    const sel = this.selection\n    if (sel.anchorSpan) {\n      extendSelection(sel, this.frontFrame.screen, col, row)\n    } else {\n      updateSelection(sel, col, row)\n    }\n    this.notifySelectionChange()\n  }\n\n  // Methods to properly suspend stdin for external editor usage\n  // This is needed to prevent Ink from swallowing keystrokes when an external editor is active\n  private stdinListeners: Array<{\n    event: string\n    listener: (...args: unknown[]) => void\n  }> = []\n  private wasRawMode = false\n\n  suspendStdin(): void {\n    const stdin = this.options.stdin\n    if (!stdin.isTTY) {\n      return\n    }\n\n    // Store and remove all 'readable' event listeners temporarily\n    // This prevents Ink from consuming stdin while the editor is active\n    const readableListeners = stdin.listeners('readable')\n    logForDebugging(\n      `[stdin] suspendStdin: removing ${readableListeners.length} readable listener(s), wasRawMode=${(stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw ?? false}`,\n    )\n    readableListeners.forEach(listener => {\n      this.stdinListeners.push({\n        event: 'readable',\n        listener: listener as (...args: unknown[]) => void,\n      })\n      stdin.removeListener('readable', listener as (...args: unknown[]) => void)\n    })\n\n    // If raw mode is enabled, disable it temporarily\n    const stdinWithRaw = stdin as NodeJS.ReadStream & {\n      isRaw?: boolean\n      setRawMode?: (mode: boolean) => void\n    }\n    if (stdinWithRaw.isRaw && stdinWithRaw.setRawMode) {\n      stdinWithRaw.setRawMode(false)\n      this.wasRawMode = true\n    }\n  }\n\n  resumeStdin(): void {\n    const stdin = this.options.stdin\n    if (!stdin.isTTY) {\n      return\n    }\n\n    // Re-attach all the stored listeners\n    if (this.stdinListeners.length === 0 && !this.wasRawMode) {\n      logForDebugging(\n        '[stdin] resumeStdin: called with no stored listeners and wasRawMode=false (possible desync)',\n        { level: 'warn' },\n      )\n    }\n    logForDebugging(\n      `[stdin] resumeStdin: re-attaching ${this.stdinListeners.length} listener(s), wasRawMode=${this.wasRawMode}`,\n    )\n    this.stdinListeners.forEach(({ event, listener }) => {\n      stdin.addListener(event, listener)\n    })\n    this.stdinListeners = []\n\n    // Re-enable raw mode if it was enabled before\n    if (this.wasRawMode) {\n      const stdinWithRaw = stdin as NodeJS.ReadStream & {\n        setRawMode?: (mode: boolean) => void\n      }\n      if (stdinWithRaw.setRawMode) {\n        stdinWithRaw.setRawMode(true)\n      }\n      this.wasRawMode = false\n    }\n  }\n\n  // Stable identity for TerminalWriteContext. An inline arrow here would\n  // change on every render() call (initial mount + each resize), which\n  // cascades through useContext → <AlternateScreen>'s useLayoutEffect dep\n  // array → spurious exit+re-enter of the alt screen on every SIGWINCH.\n  private writeRaw(data: string): void {\n    this.options.stdout.write(data)\n  }\n\n  private setCursorDeclaration: CursorDeclarationSetter = (\n    decl,\n    clearIfNode,\n  ) => {\n    if (\n      decl === null &&\n      clearIfNode !== undefined &&\n      this.cursorDeclaration?.node !== clearIfNode\n    ) {\n      return\n    }\n    this.cursorDeclaration = decl\n  }\n\n  render(node: ReactNode): void {\n    this.currentNode = node\n\n    const tree = (\n      <App\n        stdin={this.options.stdin}\n        stdout={this.options.stdout}\n        stderr={this.options.stderr}\n        exitOnCtrlC={this.options.exitOnCtrlC}\n        onExit={this.unmount}\n        terminalColumns={this.terminalColumns}\n        terminalRows={this.terminalRows}\n        selection={this.selection}\n        onSelectionChange={this.notifySelectionChange}\n        onClickAt={this.dispatchClick}\n        onHoverAt={this.dispatchHover}\n        getHyperlinkAt={this.getHyperlinkAt}\n        onOpenHyperlink={this.openHyperlink}\n        onMultiClick={this.handleMultiClick}\n        onSelectionDrag={this.handleSelectionDrag}\n        onStdinResume={this.reassertTerminalModes}\n        onCursorDeclaration={this.setCursorDeclaration}\n        dispatchKeyboardEvent={this.dispatchKeyboardEvent}\n      >\n        <TerminalWriteProvider value={this.writeRaw}>\n          {node}\n        </TerminalWriteProvider>\n      </App>\n    )\n\n    // @ts-expect-error updateContainerSync exists in react-reconciler but not in @types/react-reconciler\n    reconciler.updateContainerSync(tree, this.container, null, noop)\n    // @ts-expect-error flushSyncWork exists in react-reconciler but not in @types/react-reconciler\n    reconciler.flushSyncWork()\n  }\n\n  unmount(error?: Error | number | null): void {\n    if (this.isUnmounted) {\n      return\n    }\n\n    this.onRender()\n    this.unsubscribeExit()\n\n    if (typeof this.restoreConsole === 'function') {\n      this.restoreConsole()\n    }\n    this.restoreStderr?.()\n\n    this.unsubscribeTTYHandlers?.()\n\n    // Non-TTY environments don't handle erasing ansi escapes well, so it's better to\n    // only render last frame of non-static output\n    const diff = this.log.renderPreviousOutput_DEPRECATED(this.frontFrame)\n    writeDiffToTerminal(this.terminal, optimize(diff))\n\n    // Clean up terminal modes synchronously before process exit.\n    // React's componentWillUnmount won't run in time when process.exit() is called,\n    // so we must reset terminal modes here to prevent escape sequence leakage.\n    // Use writeSync to stdout (fd 1) to ensure writes complete before exit.\n    // We unconditionally send all disable sequences because terminal detection\n    // may not work correctly (e.g., in tmux, screen) and these are no-ops on\n    // terminals that don't support them.\n    /* eslint-disable custom-rules/no-sync-fs -- process exiting; async writes would be dropped */\n    if (this.options.stdout.isTTY) {\n      if (this.altScreenActive) {\n        // <AlternateScreen>'s unmount effect won't run during signal-exit.\n        // Exit alt screen FIRST so other cleanup sequences go to the main screen.\n        writeSync(1, EXIT_ALT_SCREEN)\n      }\n      // Disable mouse tracking — unconditional because altScreenActive can be\n      // stale if AlternateScreen's unmount (which flips the flag) raced a\n      // blocked event loop + SIGINT. No-op if tracking was never enabled.\n      writeSync(1, DISABLE_MOUSE_TRACKING)\n      // Drain stdin so in-flight mouse events don't leak to the shell\n      this.drainStdin()\n      // Disable extended key reporting (both kitty and modifyOtherKeys)\n      writeSync(1, DISABLE_MODIFY_OTHER_KEYS)\n      writeSync(1, DISABLE_KITTY_KEYBOARD)\n      // Disable focus events (DECSET 1004)\n      writeSync(1, DFE)\n      // Disable bracketed paste mode\n      writeSync(1, DBP)\n      // Show cursor\n      writeSync(1, SHOW_CURSOR)\n      // Clear iTerm2 progress bar\n      writeSync(1, CLEAR_ITERM2_PROGRESS)\n      // Clear tab status (OSC 21337) so a stale dot doesn't linger\n      if (supportsTabStatus())\n        writeSync(1, wrapForMultiplexer(CLEAR_TAB_STATUS))\n    }\n    /* eslint-enable custom-rules/no-sync-fs */\n\n    this.isUnmounted = true\n\n    // Cancel any pending throttled renders to prevent accessing freed Yoga nodes\n    this.scheduleRender.cancel?.()\n    if (this.drainTimer !== null) {\n      clearTimeout(this.drainTimer)\n      this.drainTimer = null\n    }\n\n    // @ts-expect-error updateContainerSync exists in react-reconciler but not in @types/react-reconciler\n    reconciler.updateContainerSync(null, this.container, null, noop)\n    // @ts-expect-error flushSyncWork exists in react-reconciler but not in @types/react-reconciler\n    reconciler.flushSyncWork()\n    instances.delete(this.options.stdout)\n\n    // Free the root yoga node, then clear its reference. Children are already\n    // freed by the reconciler's removeChildFromContainer; using .free() (not\n    // .freeRecursive()) avoids double-freeing them.\n    this.rootNode.yogaNode?.free()\n    this.rootNode.yogaNode = undefined\n\n    if (error instanceof Error) {\n      this.rejectExitPromise(error)\n    } else {\n      this.resolveExitPromise()\n    }\n  }\n\n  async waitUntilExit(): Promise<void> {\n    this.exitPromise ||= new Promise((resolve, reject) => {\n      this.resolveExitPromise = resolve\n      this.rejectExitPromise = reject\n    })\n\n    return this.exitPromise\n  }\n\n  resetLineCount(): void {\n    if (this.options.stdout.isTTY) {\n      // Swap so old front becomes back (for screen reuse), then reset front\n      this.backFrame = this.frontFrame\n      this.frontFrame = emptyFrame(\n        this.frontFrame.viewport.height,\n        this.frontFrame.viewport.width,\n        this.stylePool,\n        this.charPool,\n        this.hyperlinkPool,\n      )\n      this.log.reset()\n      // frontFrame is reset, so frame.cursor on the next render is (0,0).\n      // Clear displayCursor so the preamble doesn't compute a stale delta.\n      this.displayCursor = null\n    }\n  }\n\n  /**\n   * Replace char/hyperlink pools with fresh instances to prevent unbounded\n   * growth during long sessions. Migrates the front frame's screen IDs into\n   * the new pools so diffing remains correct. The back frame doesn't need\n   * migration — resetScreen zeros it before any reads.\n   *\n   * Call between conversation turns or periodically.\n   */\n  resetPools(): void {\n    this.charPool = new CharPool()\n    this.hyperlinkPool = new HyperlinkPool()\n    migrateScreenPools(\n      this.frontFrame.screen,\n      this.charPool,\n      this.hyperlinkPool,\n    )\n    // Back frame's data is zeroed by resetScreen before reads, but its pool\n    // references are used by the renderer to intern new characters. Point\n    // them at the new pools so the next frame's IDs are comparable.\n    this.backFrame.screen.charPool = this.charPool\n    this.backFrame.screen.hyperlinkPool = this.hyperlinkPool\n  }\n\n  patchConsole(): () => void {\n    // biome-ignore lint/suspicious/noConsole: intentionally patching global console\n    const con = console\n    const originals: Partial<Record<keyof Console, Console[keyof Console]>> = {}\n    const toDebug = (...args: unknown[]) =>\n      logForDebugging(`console.log: ${format(...args)}`)\n    const toError = (...args: unknown[]) =>\n      logError(new Error(`console.error: ${format(...args)}`))\n    for (const m of CONSOLE_STDOUT_METHODS) {\n      originals[m] = con[m]\n      con[m] = toDebug\n    }\n    for (const m of CONSOLE_STDERR_METHODS) {\n      originals[m] = con[m]\n      con[m] = toError\n    }\n    originals.assert = con.assert\n    con.assert = (condition: unknown, ...args: unknown[]) => {\n      if (!condition) toError(...args)\n    }\n    return () => Object.assign(con, originals)\n  }\n\n  /**\n   * Intercept process.stderr.write so stray writes (config.ts, hooks.ts,\n   * third-party deps) don't corrupt the alt-screen buffer. patchConsole only\n   * hooks console.* methods — direct stderr writes bypass it, land at the\n   * parked cursor, scroll the alt-screen, and desync frontFrame from the\n   * physical terminal. Next diff writes only changed-in-React cells at\n   * absolute coords → interleaved garbage.\n   *\n   * Swallows the write (routes text to the debug log) and, in alt-screen,\n   * forces a full-damage repaint as a defensive recovery. Not patching\n   * process.stdout — Ink itself writes there.\n   */\n  private patchStderr(): () => void {\n    const stderr = process.stderr\n    const originalWrite = stderr.write\n    let reentered = false\n    const intercept = (\n      chunk: Uint8Array | string,\n      encodingOrCb?: BufferEncoding | ((err?: Error) => void),\n      cb?: (err?: Error) => void,\n    ): boolean => {\n      const callback = typeof encodingOrCb === 'function' ? encodingOrCb : cb\n      // Reentrancy guard: logForDebugging → writeToStderr → here. Pass\n      // through to the original so --debug-to-stderr still works and we\n      // don't stack-overflow.\n      if (reentered) {\n        const encoding =\n          typeof encodingOrCb === 'string' ? encodingOrCb : undefined\n        return originalWrite.call(stderr, chunk, encoding, callback)\n      }\n      reentered = true\n      try {\n        const text =\n          typeof chunk === 'string'\n            ? chunk\n            : Buffer.from(chunk).toString('utf8')\n        logForDebugging(`[stderr] ${text}`, { level: 'warn' })\n        if (this.altScreenActive && !this.isUnmounted && !this.isPaused) {\n          this.prevFrameContaminated = true\n          this.scheduleRender()\n        }\n      } finally {\n        reentered = false\n        callback?.()\n      }\n      return true\n    }\n    stderr.write = intercept\n    return () => {\n      if (stderr.write === intercept) {\n        stderr.write = originalWrite\n      }\n    }\n  }\n}\n\n/**\n * Discard pending stdin bytes so in-flight escape sequences (mouse tracking\n * reports, bracketed-paste markers) don't leak to the shell after exit.\n *\n * Two layers of trickiness:\n *\n * 1. setRawMode is termios, not fcntl — the stdin fd stays blocking, so\n *    readSync on it would hang forever. Node doesn't expose fcntl, so we\n *    open /dev/tty fresh with O_NONBLOCK (all fds to the controlling\n *    terminal share one line-discipline input queue).\n *\n * 2. By the time forceExit calls this, detachForShutdown has already put\n *    the TTY back in cooked (canonical) mode. Canonical mode line-buffers\n *    input until newline, so O_NONBLOCK reads return EAGAIN even when\n *    mouse bytes are sitting in the buffer. We briefly re-enter raw mode\n *    so reads return any available bytes, then restore cooked mode.\n *\n * Safe to call multiple times. Call as LATE as possible in the exit path:\n * DISABLE_MOUSE_TRACKING has terminal round-trip latency, so events can\n * arrive for a few ms after it's written.\n */\n/* eslint-disable custom-rules/no-sync-fs -- must be sync; called from signal handler / unmount */\nexport function drainStdin(stdin: NodeJS.ReadStream = process.stdin): void {\n  if (!stdin.isTTY) return\n  // Drain Node's stream buffer (bytes libuv already pulled in). read()\n  // returns null when empty — never blocks.\n  try {\n    while (stdin.read() !== null) {\n      /* discard */\n    }\n  } catch {\n    /* stream may be destroyed */\n  }\n  // No /dev/tty on Windows; CONIN$ doesn't support O_NONBLOCK semantics.\n  // Windows Terminal also doesn't buffer mouse reports the same way.\n  if (process.platform === 'win32') return\n  // termios is per-device: flip stdin to raw so canonical-mode line\n  // buffering doesn't hide partial input from the non-blocking read.\n  // Restored in the finally block.\n  const tty = stdin as NodeJS.ReadStream & {\n    isRaw?: boolean\n    setRawMode?: (raw: boolean) => void\n  }\n  const wasRaw = tty.isRaw === true\n  // Drain the kernel TTY buffer via a fresh O_NONBLOCK fd. Bounded at 64\n  // reads (64KB) — a real mouse burst is a few hundred bytes; the cap\n  // guards against a terminal that ignores O_NONBLOCK.\n  let fd = -1\n  try {\n    // setRawMode inside try: on revoked TTY (SIGHUP/SSH disconnect) the\n    // ioctl throws EBADF — same recovery path as openSync/readSync below.\n    if (!wasRaw) tty.setRawMode?.(true)\n    fd = openSync('/dev/tty', fsConstants.O_RDONLY | fsConstants.O_NONBLOCK)\n    const buf = Buffer.alloc(1024)\n    for (let i = 0; i < 64; i++) {\n      if (readSync(fd, buf, 0, buf.length, null) <= 0) break\n    }\n  } catch {\n    // EAGAIN (buffer empty — expected), ENXIO/ENOENT (no controlling tty),\n    // EBADF/EIO (TTY revoked — SIGHUP, SSH disconnect)\n  } finally {\n    if (fd >= 0) {\n      try {\n        closeSync(fd)\n      } catch {\n        /* ignore */\n      }\n    }\n    if (!wasRaw) {\n      try {\n        tty.setRawMode?.(false)\n      } catch {\n        /* TTY may be gone */\n      }\n    }\n  }\n}\n/* eslint-enable custom-rules/no-sync-fs */\n\nconst CONSOLE_STDOUT_METHODS = [\n  'log',\n  'info',\n  'debug',\n  'dir',\n  'dirxml',\n  'count',\n  'countReset',\n  'group',\n  'groupCollapsed',\n  'groupEnd',\n  'table',\n  'time',\n  'timeEnd',\n  'timeLog',\n] as const\nconst CONSOLE_STDERR_METHODS = ['warn', 'error', 'trace'] as const\n"],"mappings":"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","ignoreList":[]}