nastech-tui 0.0.1

package/packages/nastech-ink/src/ink/components/App.tsx

@@ -0,0 +1,855 @@
+import { PureComponent, type ReactNode } from 'react'
+
+import { updateLastInteractionTime } from '../../bootstrap/state.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { stopCapturingEarlyInput } from '../../utils/earlyInput.js'
+import { isMouseClicksDisabled } from '../../utils/fullscreen.js'
+import { logError } from '../../utils/log.js'
+import type { DOMElement } from '../dom.js'
+import { EventEmitter } from '../events/emitter.js'
+import { InputEvent } from '../events/input-event.js'
+import { TerminalFocusEvent } from '../events/terminal-focus-event.js'
+import instances from '../instances.js'
+import {
+  INITIAL_STATE,
+  type ParsedInput,
+  type ParsedKey,
+  type ParsedMouse,
+  parseMultipleKeypresses
+} from '../parse-keypress.js'
+import reconciler from '../reconciler.js'
+import { clearSelection, finishSelection, hasSelection, type SelectionState, startSelection } from '../selection.js'
+import { getTerminalFocused, setTerminalFocused } from '../terminal-focus-state.js'
+import { TerminalQuerier, xtversion } from '../terminal-querier.js'
+import { isXtermJs, setXtversionName, supportsExtendedKeys } from '../terminal.js'
+import {
+  DISABLE_KITTY_KEYBOARD,
+  DISABLE_MODIFY_OTHER_KEYS,
+  ENABLE_KITTY_KEYBOARD,
+  ENABLE_MODIFY_OTHER_KEYS,
+  FOCUS_IN,
+  FOCUS_OUT
+} from '../termio/csi.js'
+import { DBP, DFE, DISABLE_MOUSE_TRACKING, EBP, EFE, SHOW_CURSOR } from '../termio/dec.js'
+
+import AppContext from './AppContext.js'
+import { ClockProvider } from './ClockContext.js'
+import CursorAdvanceContext, { type CursorAdvanceNotifier } from './CursorAdvanceContext.js'
+import CursorDeclarationContext, { type CursorDeclarationSetter } from './CursorDeclarationContext.js'
+import ErrorOverview from './ErrorOverview.js'
+import StdinContext from './StdinContext.js'
+import { TerminalFocusProvider } from './TerminalFocusContext.js'
+import { TerminalSizeContext } from './TerminalSizeContext.js'
+
+// Platforms that support Unix-style process suspension (SIGSTOP/SIGCONT)
+const SUPPORTS_SUSPEND = false
+
+// After this many milliseconds of stdin silence, the next chunk triggers
+// a terminal mode re-assert (mouse tracking). Catches tmux detach→attach,
+// ssh reconnect, and laptop wake — the terminal resets DEC private modes
+// but no signal reaches us. 5s is well above normal inter-keystroke gaps
+// but short enough that the first scroll after reattach works.
+const STDIN_RESUME_GAP_MS = 5000
+type Props = {
+  readonly children: ReactNode
+  readonly stdin: NodeJS.ReadStream
+  readonly stdout: NodeJS.WriteStream
+  readonly stderr: NodeJS.WriteStream
+  readonly exitOnCtrlC: boolean
+  readonly onExit: (error?: Error) => void
+  readonly terminalColumns: number
+  readonly terminalRows: number
+  // Text selection state. App mutates this directly from mouse events
+  // and calls onSelectionChange to trigger a repaint. Mouse events only
+  // arrive when <AlternateScreen> (or similar) enables mouse tracking,
+  // so the handler is always wired but dormant until tracking is on.
+  readonly selection: SelectionState
+  readonly onSelectionChange: () => void
+  // Dispatch a click at (col, row) — hit-tests the DOM tree and bubbles
+  // onClick handlers. Returns true if a DOM handler consumed the click.
+  // No-op (returns false) outside fullscreen mode (Ink.dispatchClick
+  // gates on altScreenActive).
+  readonly onClickAt: (col: number, row: number) => boolean
+  readonly onMouseDownAt: (col: number, row: number, button: number) => DOMElement | undefined
+  readonly onMouseUpAt: (target: DOMElement, col: number, row: number, button: number) => void
+  readonly onMouseDragAt: (target: DOMElement, col: number, row: number, button: number) => void
+  // Dispatch hover (onMouseEnter/onMouseLeave) as the pointer moves over
+  // DOM elements. Called for mode-1003 motion events with no button held.
+  // No-op outside fullscreen (Ink.dispatchHover gates on altScreenActive).
+  readonly onHoverAt: (col: number, row: number) => void
+  // Copy the active fullscreen text selection without clearing the highlight.
+  // Used for terminal-native right-click-copy behaviour.
+  readonly onCopySelectionNoClear: () => Promise<string>
+  readonly getSelectedText: () => string
+  // Look up the OSC 8 hyperlink at (col, row) synchronously at click
+  // time. Returns the URL or undefined. The browser-open is deferred by
+  // MULTI_CLICK_TIMEOUT_MS so double-click can cancel it.
+  readonly getHyperlinkAt: (col: number, row: number) => string | undefined
+  // Open a hyperlink URL in the browser. Called after the timer fires.
+  readonly onOpenHyperlink: (url: string) => void
+  // Called on double/triple-click PRESS at (col, row). count=2 selects
+  // the word under the cursor; count=3 selects the line. Ink reads the
+  // screen buffer to find word/line boundaries and mutates selection,
+  // setting isDragging=true so a subsequent drag extends by word/line.
+  readonly onMultiClick: (col: number, row: number, count: 2 | 3) => void
+  // Called on drag-motion. Mode-aware: char mode updates focus to the
+  // exact cell; word/line mode snaps to word/line boundaries. Needs
+  // screen-buffer access (word boundaries) so lives on Ink, not here.
+  readonly onSelectionDrag: (col: number, row: number) => void
+  // Called when stdin data arrives after a >STDIN_RESUME_GAP_MS gap.
+  // Ink re-asserts terminal modes: extended key reporting, and (when in
+  // fullscreen) re-enters alt-screen + mouse tracking. Idempotent on the
+  // terminal side. Optional so testing.tsx doesn't need to stub it.
+  readonly onStdinResume?: () => void
+  // Receives the declared native-cursor position from useDeclaredCursor
+  // so ink.tsx can park the terminal cursor there after each frame.
+  // Enables IME composition at the input caret and lets screen readers /
+  // magnifiers track the input. Optional so testing.tsx doesn't stub it.
+  readonly onCursorDeclaration?: CursorDeclarationSetter
+  // Receives notifications that the physical cursor was advanced out-of-band
+  // (e.g. TextInput's fast-echo bypass writing directly to stdout). The
+  // handler in ink.tsx updates two pieces of state from a single call:
+  //   - `displayCursor` (the relative-move basis log-update uses on the
+  //     next frame; skipped on alt-screen where CSI H resets it every
+  //     frame anyway), and
+  //   - the active `cursorDeclaration.relativeX/Y` (the target the cursor
+  //     parks at after every frame; bumped on BOTH screens because
+  //     onRender's alt-screen branch emits an absolute CUP from it and
+  //     a stale declaration there is still visibly wrong).
+  // Optional so testing.tsx doesn't need to stub it.
+  readonly onCursorAdvance?: CursorAdvanceNotifier
+  // Dispatch a keyboard event through the DOM tree. Called for each
+  // parsed key alongside the legacy EventEmitter path.
+  readonly dispatchKeyboardEvent: (parsedKey: ParsedKey) => void
+}
+
+// Multi-click detection thresholds. 500ms is the macOS default; a small
+// position tolerance allows for trackpad jitter between clicks.
+const MULTI_CLICK_TIMEOUT_MS = 500
+const MULTI_CLICK_DISTANCE = 1
+type State = {
+  readonly error?: Error
+}
+
+// Root component for all Ink apps
+// It renders stdin and stdout contexts, so that children can access them if needed
+// It also handles Ctrl+C exiting and cursor visibility
+export default class App extends PureComponent<Props, State> {
+  static displayName = 'InternalApp'
+  static getDerivedStateFromError(error: Error) {
+    return {
+      error
+    }
+  }
+  override state = {
+    error: undefined
+  }
+
+  // Count how many components enabled raw mode to avoid disabling
+  // raw mode until all components don't need it anymore
+  rawModeEnabledCount = 0
+  inputEmitter = new EventEmitter()
+  keyParseState = INITIAL_STATE
+  // Timer for flushing incomplete escape sequences
+  incompleteEscapeTimer: NodeJS.Timeout | null = null
+  // Timeout durations for incomplete sequences (ms)
+  readonly NORMAL_TIMEOUT = 50 // Short timeout for regular esc sequences
+  readonly PASTE_TIMEOUT = 500 // Longer timeout for paste operations
+
+  // Terminal query/response dispatch. Responses arrive on stdin (parsed
+  // out by parse-keypress) and are routed to pending promise resolvers.
+  querier = new TerminalQuerier(this.props.stdout)
+
+  // Multi-click tracking for double/triple-click text selection. A click
+  // within MULTI_CLICK_TIMEOUT_MS and MULTI_CLICK_DISTANCE of the previous
+  // click increments clickCount; otherwise it resets to 1.
+  lastClickTime = 0
+  lastClickCol = -1
+  lastClickRow = -1
+  clickCount = 0
+  // Deferred hyperlink-open timer — cancelled if a second click arrives
+  // within MULTI_CLICK_TIMEOUT_MS (so double-clicking a hyperlink selects
+  // the word without also opening the browser). DOM onClick dispatch is
+  // NOT deferred — it returns true from onClickAt and skips this timer.
+  pendingHyperlinkTimer: ReturnType<typeof setTimeout> | null = null
+  // Last mode-1003 motion position. Terminals already dedupe to cell
+  // granularity but this also lets us skip dispatchHover entirely on
+  // repeat events (drag-then-release at same cell, etc.).
+  lastHoverCol = -1
+  lastHoverRow = -1
+  mouseCaptureTarget: DOMElement | undefined
+
+  // Timestamp of last stdin chunk. Used to detect long gaps (tmux attach,
+  // ssh reconnect, laptop wake) and trigger terminal mode re-assert.
+  // Initialized to now so startup doesn't false-trigger.
+  lastStdinTime = Date.now()
+
+  // Determines if TTY is supported on the provided stdin
+  isRawModeSupported(): boolean {
+    return this.props.stdin.isTTY
+  }
+  override render() {
+    return (
+      <TerminalSizeContext.Provider
+        value={{
+          columns: this.props.terminalColumns,
+          rows: this.props.terminalRows
+        }}
+      >
+        <AppContext.Provider
+          value={{
+            exit: this.handleExit
+          }}
+        >
+          <StdinContext.Provider
+            value={{
+              stdin: this.props.stdin,
+              setRawMode: this.handleSetRawMode,
+              isRawModeSupported: this.isRawModeSupported(),
+              exitOnCtrlC: this.props.exitOnCtrlC,
+              inputEmitter: this.inputEmitter,
+              querier: this.querier
+            }}
+          >
+            <TerminalFocusProvider>
+              <ClockProvider>
+                <CursorDeclarationContext.Provider value={this.props.onCursorDeclaration ?? (() => {})}>
+                  <CursorAdvanceContext.Provider value={this.props.onCursorAdvance ?? (() => {})}>
+                    {this.state.error ? <ErrorOverview error={this.state.error as Error} /> : this.props.children}
+                  </CursorAdvanceContext.Provider>
+                </CursorDeclarationContext.Provider>
+              </ClockProvider>
+            </TerminalFocusProvider>
+          </StdinContext.Provider>
+        </AppContext.Provider>
+      </TerminalSizeContext.Provider>
+    )
+  }
+  override componentWillUnmount() {
+    if (this.props.stdout.isTTY) {
+      this.props.stdout.write(SHOW_CURSOR)
+    }
+
+    // Clear any pending timers
+    if (this.incompleteEscapeTimer) {
+      clearTimeout(this.incompleteEscapeTimer)
+      this.incompleteEscapeTimer = null
+    }
+
+    if (this.pendingHyperlinkTimer) {
+      clearTimeout(this.pendingHyperlinkTimer)
+      this.pendingHyperlinkTimer = null
+    }
+
+    // ignore calling setRawMode on an handle stdin it cannot be called
+    if (this.isRawModeSupported()) {
+      this.handleSetRawMode(false)
+    }
+  }
+  override componentDidCatch(error: Error) {
+    this.handleExit(error)
+  }
+  handleSetRawMode = (isEnabled: boolean): void => {
+    const { stdin } = this.props
+
+    if (!this.isRawModeSupported()) {
+      if (stdin === process.stdin) {
+        throw new Error(
+          'Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported'
+        )
+      } else {
+        throw new Error(
+          'Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported'
+        )
+      }
+    }
+
+    stdin.setEncoding('utf8')
+
+    if (isEnabled) {
+      // Ensure raw mode is enabled only once
+      if (this.rawModeEnabledCount === 0) {
+        // Stop early input capture right before we add our own readable handler.
+        // Both use the same stdin 'readable' + read() pattern, so they can't
+        // coexist -- our handler would drain stdin before Ink's can see it.
+        // The buffered text is preserved for REPL.tsx via consumeEarlyInput().
+        stopCapturingEarlyInput()
+        stdin.ref()
+        stdin.setRawMode(true)
+        stdin.addListener('readable', this.handleReadable)
+        // Enable bracketed paste mode
+        this.props.stdout.write(EBP)
+        // Enable terminal focus reporting (DECSET 1004)
+        this.props.stdout.write(EFE)
+
+        // Enable extended key reporting so ctrl+shift+<letter> is
+        // distinguishable from ctrl+<letter>. We write both the kitty stack
+        // push (CSI >1u) and xterm modifyOtherKeys level 2 (CSI >4;2m) —
+        // terminals honor whichever they implement (tmux only accepts the
+        // latter).
+        if (supportsExtendedKeys()) {
+          this.props.stdout.write(ENABLE_KITTY_KEYBOARD)
+          this.props.stdout.write(ENABLE_MODIFY_OTHER_KEYS)
+        }
+
+        // Probe terminal identity. XTVERSION survives SSH (query/reply goes
+        // through the pty), unlike TERM_PROGRAM. Used for wheel-scroll base
+        // detection when env vars are absent. Fire-and-forget: the DA1
+        // sentinel bounds the round-trip, and if the terminal ignores the
+        // query, flush() still resolves and name stays undefined.
+        // Deferred to next tick so it fires AFTER the current synchronous
+        // init sequence completes — avoids interleaving with alt-screen/mouse
+        // tracking enable writes that may happen in the same render cycle.
+        setImmediate(() => {
+          void Promise.all([this.querier.send(xtversion()), this.querier.flush()]).then(([r]) => {
+            if (r) {
+              setXtversionName(r.name)
+              logForDebugging(`XTVERSION: terminal identified as "${r.name}"`)
+            } else {
+              logForDebugging('XTVERSION: no reply (terminal ignored query)')
+            }
+          })
+        })
+
+        // Re-assert mouse tracking on raw-mode re-entry. <AlternateScreen>
+        // owns the initial enable, but its effect only re-runs on a
+        // mode/writeRaw change — NOT on a raw-mode bounce (count 1→0→1, e.g.
+        // an overlay that briefly drops the last useInput consumer). The
+        // teardown above now DISABLE_MOUSE_TRACKING's to stop the cooked-echo
+        // leak, so without this the terminal would be left with tracking off
+        // and the mouse silently dead until the next stdin-gap/resize
+        // re-assert. reassertTerminalModes() is gated on altScreenActive and
+        // idempotent, so it's a no-op when there's nothing to restore.
+        // Deferred (same setImmediate discipline as the XTVERSION probe) so it
+        // lands after any alt-screen enable writes in this render cycle.
+        setImmediate(() => {
+          instances.get(this.props.stdout)?.reassertTerminalModes()
+        })
+      }
+
+      this.rawModeEnabledCount++
+
+      return
+    }
+
+    // Disable raw mode only when no components left that are using it
+    if (--this.rawModeEnabledCount === 0) {
+      this.props.stdout.write(DISABLE_MODIFY_OTHER_KEYS)
+      this.props.stdout.write(DISABLE_KITTY_KEYBOARD)
+      // Disable terminal focus reporting (DECSET 1004)
+      this.props.stdout.write(DFE)
+      // Disable bracketed paste mode
+      this.props.stdout.write(DBP)
+      // Disable mouse tracking. Tracking is asserted by <AlternateScreen> /
+      // the Ink instance, NOT here — but dropping raw mode + detaching the
+      // readable listener while DEC 1003 hover stays on means the terminal
+      // falls back to cooked-mode echo and every mouse move leaks as text
+      // (`35;col;row M` shards over the prompt). Same hazard handleSuspend()
+      // already guards against; this teardown path missed it. Idempotent
+      // (no-op if tracking was never on), and re-enabling raw mode below
+      // re-asserts tracking so a transient drop→re-add round-trips cleanly.
+      this.props.stdout.write(DISABLE_MOUSE_TRACKING)
+      stdin.setRawMode(false)
+      stdin.removeListener('readable', this.handleReadable)
+      stdin.unref()
+    }
+  }
+
+  // Helper to flush incomplete escape sequences
+  flushIncomplete = (): void => {
+    // Clear the timer reference
+    this.incompleteEscapeTimer = null
+
+    // Only proceed if we have an incomplete escape sequence or an unterminated
+    // bracketed paste. Missing paste-end markers otherwise leave every later
+    // keystroke trapped in the paste buffer.
+    if (!this.keyParseState.incomplete && this.keyParseState.mode !== 'IN_PASTE') {
+      return
+    }
+
+    // Fullscreen: if stdin has data waiting, it's almost certainly the
+    // continuation of the buffered sequence (e.g. `[<64;74;16M` after a
+    // lone ESC). Node's event loop runs the timers phase before the poll
+    // phase, so when a heavy render blocks the loop past 50ms, this timer
+    // fires before the queued readable event even though the bytes are
+    // already buffered. Re-arm instead of flushing: handleReadable will
+    // drain stdin next and clear this timer. Prevents both the spurious
+    // Escape key and the lost scroll event.
+    if (this.props.stdin.readableLength > 0) {
+      this.incompleteEscapeTimer = setTimeout(
+        this.flushIncomplete,
+        this.keyParseState.mode === 'IN_PASTE' ? this.PASTE_TIMEOUT : this.NORMAL_TIMEOUT
+      )
+
+      return
+    }
+
+    // Process incomplete/paste state as a flush operation (input=null).
+    // This reuses all existing parsing logic.
+    this.processInput(null)
+  }
+
+  // Process input through the parser and handle the results
+  processInput = (input: string | Buffer | null): void => {
+    // Parse input using our state machine
+    const [keys, newState] = parseMultipleKeypresses(this.keyParseState, input)
+    this.keyParseState = newState
+
+    // Process ALL keys in a SINGLE discreteUpdates call to prevent
+    // "Maximum update depth exceeded" error when many keys arrive at once
+    // (e.g., from paste operations or holding keys rapidly).
+    // This batches all state updates from handleInput and all useInput
+    // listeners together within one high-priority update context.
+    if (keys.length > 0) {
+      reconciler.discreteUpdates(processKeysInBatch, this, keys, undefined, undefined)
+    }
+
+    // If we have incomplete escape sequences or an unterminated paste, set a
+    // timer to flush/reset them. Paste starts are complete CSI sequences, so
+    // checking only `incomplete` would never arm the watchdog.
+    if (this.keyParseState.incomplete || this.keyParseState.mode === 'IN_PASTE') {
+      // Cancel any existing timer first
+      if (this.incompleteEscapeTimer) {
+        clearTimeout(this.incompleteEscapeTimer)
+      }
+
+      this.incompleteEscapeTimer = setTimeout(
+        this.flushIncomplete,
+        this.keyParseState.mode === 'IN_PASTE' ? this.PASTE_TIMEOUT : this.NORMAL_TIMEOUT
+      )
+    }
+  }
+  handleReadable = (): void => {
+    // Detect long stdin gaps (tmux attach, ssh reconnect, laptop wake).
+    // The terminal may have reset DEC private modes; re-assert mouse
+    // tracking. Checked before the read loop so one Date.now() covers
+    // all chunks in this readable event.
+    const now = Date.now()
+
+    if (now - this.lastStdinTime > STDIN_RESUME_GAP_MS) {
+      this.props.onStdinResume?.()
+    }
+
+    this.lastStdinTime = now
+
+    try {
+      let chunk
+
+      while ((chunk = this.props.stdin.read() as string | null) !== null) {
+        // Process the input chunk
+        this.processInput(chunk)
+      }
+    } catch (error) {
+      // In Bun, an uncaught throw inside a stream 'readable' handler can
+      // permanently wedge the stream: data stays buffered and 'readable'
+      // never re-emits. Catching here ensures the stream stays healthy so
+      // subsequent keystrokes are still delivered.
+      logError(error)
+
+      // Re-attach the listener in case the exception detached it.
+      // Bun may remove the listener after an error; without this,
+      // the session freezes permanently (stdin reader dead, event loop alive).
+      const { stdin } = this.props
+
+      if (this.rawModeEnabledCount > 0 && !stdin.listeners('readable').includes(this.handleReadable)) {
+        logForDebugging('handleReadable: re-attaching stdin readable listener after error recovery', {
+          level: 'warn'
+        })
+        stdin.addListener('readable', this.handleReadable)
+      }
+    }
+  }
+  handleInput = (input: string | undefined): void => {
+    // Exit on Ctrl+C
+    if (input === '\x03' && this.props.exitOnCtrlC) {
+      this.handleExit()
+    }
+
+    // Note: Ctrl+Z (suspend) is now handled in processKeysInBatch using the
+    // parsed key to support both raw (\x1a) and CSI u format from Kitty
+    // keyboard protocol terminals (Ghostty, iTerm2, kitty, WezTerm)
+  }
+  handleExit = (error?: Error): void => {
+    if (this.isRawModeSupported()) {
+      this.handleSetRawMode(false)
+    }
+
+    this.props.onExit(error)
+  }
+  handleTerminalFocus = (isFocused: boolean): void => {
+    // setTerminalFocused notifies subscribers: TerminalFocusProvider (context)
+    // and Clock (interval speed) — no App setState needed.
+    setTerminalFocused(isFocused)
+  }
+  handleSuspend = (): void => {
+    if (!this.isRawModeSupported()) {
+      return
+    }
+
+    // Store the exact raw mode count to restore it properly
+    const rawModeCountBeforeSuspend = this.rawModeEnabledCount
+
+    // Completely disable raw mode before suspending
+    while (this.rawModeEnabledCount > 0) {
+      this.handleSetRawMode(false)
+    }
+
+    // Show cursor, disable focus reporting, and disable mouse tracking
+    // before suspending. DISABLE_MOUSE_TRACKING is a no-op if tracking
+    // wasn't enabled, so it's safe to emit unconditionally — without
+    // it, SGR mouse sequences would appear as garbled text at the
+    // shell prompt while suspended.
+    if (this.props.stdout.isTTY) {
+      this.props.stdout.write(SHOW_CURSOR + DFE + DISABLE_MOUSE_TRACKING)
+    }
+
+    this.inputEmitter.emit('suspend')
+
+    // Set up resume handler
+    const resumeHandler = () => {
+      // Restore raw mode to exact previous state
+      for (let i = 0; i < rawModeCountBeforeSuspend; i++) {
+        if (this.isRawModeSupported()) {
+          this.handleSetRawMode(true)
+        }
+      }
+
+      if (this.props.stdout.isTTY) {
+        this.props.stdout.write(EFE)
+      }
+
+      this.inputEmitter.emit('resume')
+      process.removeListener('SIGCONT', resumeHandler)
+    }
+
+    process.on('SIGCONT', resumeHandler)
+    process.kill(process.pid, 'SIGSTOP')
+  }
+}
+
+// Helper to process all keys within a single discrete update context.
+// discreteUpdates expects (fn, a, b, c, d) -> fn(a, b, c, d)
+function processKeysInBatch(app: App, items: ParsedInput[], _unused1: undefined, _unused2: undefined): void {
+  // Update interaction time for notification timeout tracking.
+  // This is called from the central input handler to avoid having multiple
+  // stdin listeners that can cause race conditions and dropped input.
+  // Terminal responses (kind: 'response') are automated, not user input.
+  // Mode-1003 no-button motion is also excluded — passive cursor drift is
+  // not engagement (would suppress idle notifications + defer housekeeping).
+  if (
+    items.some(i => i.kind === 'key' || (i.kind === 'mouse' && !((i.button & 0x20) !== 0 && (i.button & 0x03) === 3)))
+  ) {
+    updateLastInteractionTime()
+  }
+
+  for (const item of items) {
+    // Terminal responses (DECRPM, DA1, OSC replies, etc.) are not user
+    // input — route them to the querier to resolve pending promises.
+    if (item.kind === 'response') {
+      app.querier.onResponse(item.response)
+
+      continue
+    }
+
+    // Mouse click/drag events update selection state (fullscreen only).
+    // Terminal sends 1-indexed col/row; convert to 0-indexed for the
+    // screen buffer. Button bit 0x20 = drag (motion while button held).
+    if (item.kind === 'mouse') {
+      handleMouseEvent(app, item)
+
+      continue
+    }
+
+    const sequence = item.sequence
+
+    // Handle terminal focus events (DECSET 1004)
+    if (sequence === FOCUS_IN) {
+      app.handleTerminalFocus(true)
+      const event = new TerminalFocusEvent('terminalfocus')
+      app.inputEmitter.emit('terminalfocus', event)
+
+      continue
+    }
+
+    if (sequence === FOCUS_OUT) {
+      app.handleTerminalFocus(false)
+
+      // Defensive: if we lost the release event (mouse released outside
+      // terminal window — some emulators drop it rather than capturing the
+      // pointer), focus-out is the next observable signal that the drag is
+      // over. Without this, drag-to-scroll's timer runs until the scroll
+      // boundary is hit.
+      if (app.props.selection.isDragging) {
+        finishSelection(app.props.selection)
+        app.props.onSelectionChange()
+      }
+
+      const event = new TerminalFocusEvent('terminalblur')
+      app.inputEmitter.emit('terminalblur', event)
+
+      continue
+    }
+
+    // Failsafe: if we receive input, the terminal must be focused
+    if (!getTerminalFocused()) {
+      setTerminalFocused(true)
+    }
+
+    // Handle Ctrl+Z (suspend) using parsed key to support both raw (\x1a) and
+    // CSI u format (\x1b[122;5u) from Kitty keyboard protocol terminals
+    if (item.name === 'z' && item.ctrl && SUPPORTS_SUSPEND) {
+      app.handleSuspend()
+
+      continue
+    }
+
+    app.handleInput(sequence)
+    const event = new InputEvent(item)
+    app.inputEmitter.emit('input', event)
+
+    // Also dispatch through the DOM tree so onKeyDown handlers fire.
+    app.props.dispatchKeyboardEvent(item)
+  }
+}
+
+/** Exported for testing. Mutates app.props.selection and click/hover state. */
+export function handleMouseEvent(app: App, m: ParsedMouse): void {
+  const sel = app.props.selection
+  // Terminal coords are 1-indexed; screen buffer is 0-indexed
+  const col = m.col - 1
+  const row = m.row - 1
+  const baseButton = m.button & 0x03
+
+  // Disable app click handling without blocking wheel/right-click dispatch.
+  if (isMouseClicksDisabled() && baseButton === 0) {
+    return
+  }
+
+  if (m.action === 'press') {
+    if ((m.button & 0x20) !== 0 && baseButton === 3) {
+      if (app.mouseCaptureTarget) {
+        app.props.onMouseUpAt(app.mouseCaptureTarget, col, row, baseButton)
+        app.mouseCaptureTarget = undefined
+      }
+
+      // Mode-1003 motion with no button held. Dispatch hover; skip the
+      // rest of this handler (no selection, no click-count side effects).
+      // Lost-release recovery: no-button motion while isDragging=true means
+      // the release happened outside the terminal window (iTerm2 doesn't
+      // capture the pointer past window bounds, so the SGR 'm' never
+      // arrives). Finish the selection here so copy-on-select fires. The
+      // FOCUS_OUT handler covers the "switched apps" case but not "released
+      // past the edge, came back" — and tmux drops focus events unless
+      // `focus-events on` is set, so this is the more reliable signal.
+      if (sel.isDragging) {
+        finishSelection(sel)
+        app.props.onSelectionChange()
+      }
+
+      if (col === app.lastHoverCol && row === app.lastHoverRow) {
+        return
+      }
+
+      app.lastHoverCol = col
+      app.lastHoverRow = row
+      app.props.onHoverAt(col, row)
+
+      return
+    }
+
+    if (baseButton !== 0) {
+      // Non-left press breaks the multi-click chain.
+      app.clickCount = 0
+
+      if (baseButton === 2 && hasSelection(sel)) {
+        if ((m.button & 0x20) !== 0) {
+          return
+        }
+
+        if (!app.props.getSelectedText()) {
+          return
+        }
+
+        void app.props
+          .onCopySelectionNoClear()
+          .then(text => {
+            if (text) {
+              // Right-click copy is a deliberate action (unlike copy-on-select
+              // during a drag, which keeps the highlight so the drag can
+              // continue). Clear the highlight so the user gets visual
+              // confirmation the copy landed and a follow-up right-click on
+              // empty space pastes instead of re-copying the stale range.
+              clearSelection(sel)
+              app.props.onSelectionChange()
+            } else {
+              app.props.onMouseDownAt(col, row, baseButton)
+            }
+          })
+          .catch(() => app.props.onMouseDownAt(col, row, baseButton))
+
+        return
+      }
+
+      app.props.onMouseDownAt(col, row, baseButton)
+
+      return
+    }
+
+    if ((m.button & 0x20) !== 0) {
+      if (app.mouseCaptureTarget) {
+        app.props.onMouseDragAt(app.mouseCaptureTarget, col, row, baseButton)
+
+        return
+      }
+
+      // Drag motion: mode-aware extension (char/word/line). onSelectionDrag
+      // calls notifySelectionChange internally — no extra onSelectionChange.
+      app.props.onSelectionDrag(col, row)
+
+      return
+    }
+
+    // Lost-release fallback for mode-1002-only terminals: a fresh press
+    // while isDragging=true means the previous release was dropped (cursor
+    // left the window). Finish that selection so copy-on-select fires
+    // before startSelection/onMultiClick clobbers it. Mode-1003 terminals
+    // hit the no-button-motion recovery above instead, so this is rare.
+    if (sel.isDragging) {
+      finishSelection(sel)
+      app.props.onSelectionChange()
+    }
+
+    const capture = app.props.onMouseDownAt(col, row, baseButton)
+
+    if (capture) {
+      app.mouseCaptureTarget = capture
+      app.clickCount = 0
+
+      return
+    }
+
+    // Fresh left press. Detect multi-click HERE (not on release) so the
+    // word/line highlight appears immediately and a subsequent drag can
+    // extend by word/line like native macOS. Previously detected on
+    // release, which meant (a) visible latency before the word highlights
+    // and (b) double-click+drag fell through to char-mode selection.
+    const now = Date.now()
+
+    const nearLast =
+      now - app.lastClickTime < MULTI_CLICK_TIMEOUT_MS &&
+      Math.abs(col - app.lastClickCol) <= MULTI_CLICK_DISTANCE &&
+      Math.abs(row - app.lastClickRow) <= MULTI_CLICK_DISTANCE
+
+    app.clickCount = nearLast ? app.clickCount + 1 : 1
+    app.lastClickTime = now
+    app.lastClickCol = col
+    app.lastClickRow = row
+
+    if (app.clickCount >= 2) {
+      // Cancel any pending hyperlink-open from the first click — this is
+      // a double-click, not a single-click on a link.
+      if (app.pendingHyperlinkTimer) {
+        clearTimeout(app.pendingHyperlinkTimer)
+        app.pendingHyperlinkTimer = null
+      }
+
+      // Cap at 3 (line select) for quadruple+ clicks.
+      const count = app.clickCount === 2 ? 2 : 3
+      app.props.onMultiClick(col, row, count)
+
+      return
+    }
+
+    startSelection(sel, col, row)
+    // SGR bit 0x08 = alt (xterm.js wires altKey here, not metaKey — see
+    // comment at the hyperlink-open guard below). On macOS xterm.js,
+    // receiving alt means macOptionClickForcesSelection is OFF (otherwise
+    // xterm.js would have consumed the event for native selection).
+    sel.lastPressHadAlt = (m.button & 0x08) !== 0
+    app.props.onSelectionChange()
+
+    return
+  }
+
+  // Release: end the drag even for non-zero button codes. Some terminals
+  // encode release with the motion bit or button=3 "no button" (carried
+  // over from pre-SGR X10 encoding) — filtering those would orphan
+  // isDragging=true and leave drag-to-scroll's timer running until the
+  // scroll boundary. Only act on non-left releases when we ARE dragging
+  // (so an unrelated middle/right click-release doesn't touch selection).
+  if (app.mouseCaptureTarget) {
+    app.props.onMouseUpAt(app.mouseCaptureTarget, col, row, baseButton)
+    app.mouseCaptureTarget = undefined
+
+    return
+  }
+
+  if (baseButton !== 0) {
+    if (!sel.isDragging) {
+      return
+    }
+
+    finishSelection(sel)
+    app.props.onSelectionChange()
+
+    return
+  }
+
+  finishSelection(sel)
+
+  // NOTE: unlike the old release-based detection we do NOT reset clickCount
+  // on release-after-drag. This aligns with NSEvent.clickCount semantics:
+  // an intervening drag doesn't break the click chain. Practical upside:
+  // trackpad jitter during an intended double-click (press→wobble→release
+  // →press) now correctly resolves to word-select instead of breaking to a
+  // fresh single click. The nearLast window (500ms, 1 cell) bounds the
+  // effect — a deliberate drag past that just starts a fresh chain.
+  // A press+release with no drag in char mode is a click: anchor set,
+  // focus null → hasSelection false. In word/line mode the press already
+  // set anchor+focus (hasSelection true), so release just keeps the
+  // highlight. The anchor check guards against an orphaned release (no
+  // prior press — e.g. button was held when mouse tracking was enabled).
+  if (!hasSelection(sel) && sel.anchor) {
+    // Single click: dispatch DOM click immediately (cursor repositioning
+    // etc. are latency-sensitive). If no DOM handler consumed it, defer
+    // the hyperlink check so a second click can cancel it.
+    if (!app.props.onClickAt(col, row)) {
+      // Resolve the hyperlink URL synchronously while the screen buffer
+      // still reflects what the user clicked — deferring only the
+      // browser-open so double-click can cancel it.
+      const url = app.props.getHyperlinkAt(col, row)
+
+      // xterm.js (VS Code, Cursor, Windsurf, etc.) has its own OSC 8 link
+      // handler that fires on Cmd+click *without consuming the mouse event*
+      // (Linkifier._handleMouseUp calls link.activate() but never
+      // preventDefault/stopPropagation). The click is also forwarded to the
+      // pty as SGR, so both VS Code's terminalLinkManager AND our handler
+      // here would open the URL — twice. We can't filter on Cmd: xterm.js
+      // drops metaKey before SGR encoding (ICoreMouseEvent has no meta
+      // field; the SGR bit we call 'meta' is wired to alt). Let xterm.js
+      // own link-opening; Cmd+click is the native UX there anyway.
+      // TERM_PROGRAM is the sync fast-path; isXtermJs() is the XTVERSION
+      // probe result (catches SSH + non-VS Code embedders like Hyper).
+      if (url && process.env.TERM_PROGRAM !== 'vscode' && !isXtermJs()) {
+        // Clear any prior pending timer — clicking a second link
+        // supersedes the first (only the latest click opens).
+        if (app.pendingHyperlinkTimer) {
+          clearTimeout(app.pendingHyperlinkTimer)
+        }
+
+        app.pendingHyperlinkTimer = setTimeout(
+          (app, url) => {
+            app.pendingHyperlinkTimer = null
+            app.props.onOpenHyperlink(url)
+          },
+          MULTI_CLICK_TIMEOUT_MS,
+          app,
+          url
+        )
+      }
+    }
+  }
+
+  app.props.onSelectionChange()
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","PureComponent","ReactNode","updateLastInteractionTime","logForDebugging","stopCapturingEarlyInput","isEnvTruthy","isMouseClicksDisabled","logError","EventEmitter","InputEvent","TerminalFocusEvent","INITIAL_STATE","ParsedInput","ParsedKey","ParsedMouse","parseMultipleKeypresses","reconciler","finishSelection","hasSelection","SelectionState","startSelection","isXtermJs","setXtversionName","supportsExtendedKeys","getTerminalFocused","setTerminalFocused","TerminalQuerier","xtversion","DISABLE_KITTY_KEYBOARD","DISABLE_MODIFY_OTHER_KEYS","ENABLE_KITTY_KEYBOARD","ENABLE_MODIFY_OTHER_KEYS","FOCUS_IN","FOCUS_OUT","DBP","DFE","DISABLE_MOUSE_TRACKING","EBP","EFE","HIDE_CURSOR","SHOW_CURSOR","AppContext","ClockProvider","CursorDeclarationContext","CursorDeclarationSetter","ErrorOverview","StdinContext","TerminalFocusProvider","TerminalSizeContext","SUPPORTS_SUSPEND","process","platform","STDIN_RESUME_GAP_MS","Props","children","stdin","NodeJS","ReadStream","stdout","WriteStream","stderr","exitOnCtrlC","onExit","error","Error","terminalColumns","terminalRows","selection","onSelectionChange","onClickAt","col","row","onHoverAt","getHyperlinkAt","onOpenHyperlink","url","onMultiClick","count","onSelectionDrag","onStdinResume","onCursorDeclaration","dispatchKeyboardEvent","parsedKey","MULTI_CLICK_TIMEOUT_MS","MULTI_CLICK_DISTANCE","State","App","displayName","getDerivedStateFromError","state","undefined","rawModeEnabledCount","internal_eventEmitter","keyParseState","incompleteEscapeTimer","Timeout","NORMAL_TIMEOUT","PASTE_TIMEOUT","querier","props","lastClickTime","lastClickCol","lastClickRow","clickCount","pendingHyperlinkTimer","ReturnType","setTimeout","lastHoverCol","lastHoverRow","lastStdinTime","Date","now","isRawModeSupported","isTTY","render","columns","rows","exit","handleExit","setRawMode","handleSetRawMode","internal_exitOnCtrlC","internal_querier","componentDidMount","env","CLAUDE_CODE_ACCESSIBILITY","write","componentWillUnmount","clearTimeout","componentDidCatch","isEnabled","setEncoding","ref","addListener","handleReadable","setImmediate","Promise","all","send","flush","then","r","name","removeListener","unref","flushIncomplete","incomplete","readableLength","processInput","input","Buffer","keys","newState","length","discreteUpdates","processKeysInBatch","mode","chunk","read","listeners","includes","level","handleInput","handleTerminalFocus","isFocused","handleSuspend","rawModeCountBeforeSuspend","emit","resumeHandler","i","on","kill","pid","app","items","_unused1","_unused2","some","kind","button","item","onResponse","response","handleMouseEvent","sequence","event","isDragging","ctrl","m","sel","baseButton","action","nearLast","Math","abs","lastPressHadAlt","anchor","TERM_PROGRAM"],"sources":["App.tsx"],"sourcesContent":["import React, { PureComponent, type ReactNode } from 'react'\nimport { updateLastInteractionTime } from '../../bootstrap/state.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { stopCapturingEarlyInput } from '../../utils/earlyInput.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { isMouseClicksDisabled } from '../../utils/fullscreen.js'\nimport { logError } from '../../utils/log.js'\nimport { EventEmitter } from '../events/emitter.js'\nimport { InputEvent } from '../events/input-event.js'\nimport { TerminalFocusEvent } from '../events/terminal-focus-event.js'\nimport {\n  INITIAL_STATE,\n  type ParsedInput,\n  type ParsedKey,\n  type ParsedMouse,\n  parseMultipleKeypresses,\n} from '../parse-keypress.js'\nimport reconciler from '../reconciler.js'\nimport {\n  finishSelection,\n  hasSelection,\n  type SelectionState,\n  startSelection,\n} from '../selection.js'\nimport {\n  isXtermJs,\n  setXtversionName,\n  supportsExtendedKeys,\n} from '../terminal.js'\nimport {\n  getTerminalFocused,\n  setTerminalFocused,\n} from '../terminal-focus-state.js'\nimport { TerminalQuerier, xtversion } from '../terminal-querier.js'\nimport {\n  DISABLE_KITTY_KEYBOARD,\n  DISABLE_MODIFY_OTHER_KEYS,\n  ENABLE_KITTY_KEYBOARD,\n  ENABLE_MODIFY_OTHER_KEYS,\n  FOCUS_IN,\n  FOCUS_OUT,\n} from '../termio/csi.js'\nimport {\n  DBP,\n  DFE,\n  DISABLE_MOUSE_TRACKING,\n  EBP,\n  EFE,\n  HIDE_CURSOR,\n  SHOW_CURSOR,\n} from '../termio/dec.js'\nimport AppContext from './AppContext.js'\nimport { ClockProvider } from './ClockContext.js'\nimport CursorDeclarationContext, {\n  type CursorDeclarationSetter,\n} from './CursorDeclarationContext.js'\nimport ErrorOverview from './ErrorOverview.js'\nimport StdinContext from './StdinContext.js'\nimport { TerminalFocusProvider } from './TerminalFocusContext.js'\nimport { TerminalSizeContext } from './TerminalSizeContext.js'\n\n// Platforms that support Unix-style process suspension (SIGSTOP/SIGCONT)\nconst SUPPORTS_SUSPEND = process.platform !== 'win32'\n\n// After this many milliseconds of stdin silence, the next chunk triggers\n// a terminal mode re-assert (mouse tracking). Catches tmux detach→attach,\n// ssh reconnect, and laptop wake — the terminal resets DEC private modes\n// but no signal reaches us. 5s is well above normal inter-keystroke gaps\n// but short enough that the first scroll after reattach works.\nconst STDIN_RESUME_GAP_MS = 5000\n\ntype Props = {\n  readonly children: ReactNode\n  readonly stdin: NodeJS.ReadStream\n  readonly stdout: NodeJS.WriteStream\n  readonly stderr: NodeJS.WriteStream\n  readonly exitOnCtrlC: boolean\n  readonly onExit: (error?: Error) => void\n  readonly terminalColumns: number\n  readonly terminalRows: number\n  // Text selection state. App mutates this directly from mouse events\n  // and calls onSelectionChange to trigger a repaint. Mouse events only\n  // arrive when <AlternateScreen> (or similar) enables mouse tracking,\n  // so the handler is always wired but dormant until tracking is on.\n  readonly selection: SelectionState\n  readonly onSelectionChange: () => void\n  // Dispatch a click at (col, row) — hit-tests the DOM tree and bubbles\n  // onClick handlers. Returns true if a DOM handler consumed the click.\n  // No-op (returns false) outside fullscreen mode (Ink.dispatchClick\n  // gates on altScreenActive).\n  readonly onClickAt: (col: number, row: number) => boolean\n  // Dispatch hover (onMouseEnter/onMouseLeave) as the pointer moves over\n  // DOM elements. Called for mode-1003 motion events with no button held.\n  // No-op outside fullscreen (Ink.dispatchHover gates on altScreenActive).\n  readonly onHoverAt: (col: number, row: number) => void\n  // Look up the OSC 8 hyperlink at (col, row) synchronously at click\n  // time. Returns the URL or undefined. The browser-open is deferred by\n  // MULTI_CLICK_TIMEOUT_MS so double-click can cancel it.\n  readonly getHyperlinkAt: (col: number, row: number) => string | undefined\n  // Open a hyperlink URL in the browser. Called after the timer fires.\n  readonly onOpenHyperlink: (url: string) => void\n  // Called on double/triple-click PRESS at (col, row). count=2 selects\n  // the word under the cursor; count=3 selects the line. Ink reads the\n  // screen buffer to find word/line boundaries and mutates selection,\n  // setting isDragging=true so a subsequent drag extends by word/line.\n  readonly onMultiClick: (col: number, row: number, count: 2 | 3) => void\n  // Called on drag-motion. Mode-aware: char mode updates focus to the\n  // exact cell; word/line mode snaps to word/line boundaries. Needs\n  // screen-buffer access (word boundaries) so lives on Ink, not here.\n  readonly onSelectionDrag: (col: number, row: number) => void\n  // Called when stdin data arrives after a >STDIN_RESUME_GAP_MS gap.\n  // Ink re-asserts terminal modes: extended key reporting, and (when in\n  // fullscreen) re-enters alt-screen + mouse tracking. Idempotent on the\n  // terminal side. Optional so testing.tsx doesn't need to stub it.\n  readonly onStdinResume?: () => void\n  // Receives the declared native-cursor position from useDeclaredCursor\n  // so ink.tsx can park the terminal cursor there after each frame.\n  // Enables IME composition at the input caret and lets screen readers /\n  // magnifiers track the input. Optional so testing.tsx doesn't stub it.\n  readonly onCursorDeclaration?: CursorDeclarationSetter\n  // Dispatch a keyboard event through the DOM tree. Called for each\n  // parsed key alongside the legacy EventEmitter path.\n  readonly dispatchKeyboardEvent: (parsedKey: ParsedKey) => void\n}\n\n// Multi-click detection thresholds. 500ms is the macOS default; a small\n// position tolerance allows for trackpad jitter between clicks.\nconst MULTI_CLICK_TIMEOUT_MS = 500\nconst MULTI_CLICK_DISTANCE = 1\n\ntype State = {\n  readonly error?: Error\n}\n\n// Root component for all Ink apps\n// It renders stdin and stdout contexts, so that children can access them if needed\n// It also handles Ctrl+C exiting and cursor visibility\nexport default class App extends PureComponent<Props, State> {\n  static displayName = 'InternalApp'\n\n  static getDerivedStateFromError(error: Error) {\n    return { error }\n  }\n\n  override state = {\n    error: undefined,\n  }\n\n  // Count how many components enabled raw mode to avoid disabling\n  // raw mode until all components don't need it anymore\n  rawModeEnabledCount = 0\n\n  internal_eventEmitter = new EventEmitter()\n  keyParseState = INITIAL_STATE\n  // Timer for flushing incomplete escape sequences\n  incompleteEscapeTimer: NodeJS.Timeout | null = null\n  // Timeout durations for incomplete sequences (ms)\n  readonly NORMAL_TIMEOUT = 50 // Short timeout for regular esc sequences\n  readonly PASTE_TIMEOUT = 500 // Longer timeout for paste operations\n\n  // Terminal query/response dispatch. Responses arrive on stdin (parsed\n  // out by parse-keypress) and are routed to pending promise resolvers.\n  querier = new TerminalQuerier(this.props.stdout)\n\n  // Multi-click tracking for double/triple-click text selection. A click\n  // within MULTI_CLICK_TIMEOUT_MS and MULTI_CLICK_DISTANCE of the previous\n  // click increments clickCount; otherwise it resets to 1.\n  lastClickTime = 0\n  lastClickCol = -1\n  lastClickRow = -1\n  clickCount = 0\n  // Deferred hyperlink-open timer — cancelled if a second click arrives\n  // within MULTI_CLICK_TIMEOUT_MS (so double-clicking a hyperlink selects\n  // the word without also opening the browser). DOM onClick dispatch is\n  // NOT deferred — it returns true from onClickAt and skips this timer.\n  pendingHyperlinkTimer: ReturnType<typeof setTimeout> | null = null\n  // Last mode-1003 motion position. Terminals already dedupe to cell\n  // granularity but this also lets us skip dispatchHover entirely on\n  // repeat events (drag-then-release at same cell, etc.).\n  lastHoverCol = -1\n  lastHoverRow = -1\n\n  // Timestamp of last stdin chunk. Used to detect long gaps (tmux attach,\n  // ssh reconnect, laptop wake) and trigger terminal mode re-assert.\n  // Initialized to now so startup doesn't false-trigger.\n  lastStdinTime = Date.now()\n\n  // Determines if TTY is supported on the provided stdin\n  isRawModeSupported(): boolean {\n    return this.props.stdin.isTTY\n  }\n\n  override render() {\n    return (\n      <TerminalSizeContext.Provider\n        value={{\n          columns: this.props.terminalColumns,\n          rows: this.props.terminalRows,\n        }}\n      >\n        <AppContext.Provider\n          value={{\n            exit: this.handleExit,\n          }}\n        >\n          <StdinContext.Provider\n            value={{\n              stdin: this.props.stdin,\n              setRawMode: this.handleSetRawMode,\n              isRawModeSupported: this.isRawModeSupported(),\n\n              internal_exitOnCtrlC: this.props.exitOnCtrlC,\n\n              internal_eventEmitter: this.internal_eventEmitter,\n              internal_querier: this.querier,\n            }}\n          >\n            <TerminalFocusProvider>\n              <ClockProvider>\n                <CursorDeclarationContext.Provider\n                  value={this.props.onCursorDeclaration ?? (() => {})}\n                >\n                  {this.state.error ? (\n                    <ErrorOverview error={this.state.error as Error} />\n                  ) : (\n                    this.props.children\n                  )}\n                </CursorDeclarationContext.Provider>\n              </ClockProvider>\n            </TerminalFocusProvider>\n          </StdinContext.Provider>\n        </AppContext.Provider>\n      </TerminalSizeContext.Provider>\n    )\n  }\n\n  override componentDidMount() {\n    // In accessibility mode, keep the native cursor visible for screen magnifiers and other tools\n    if (\n      this.props.stdout.isTTY &&\n      !isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY)\n    ) {\n      this.props.stdout.write(HIDE_CURSOR)\n    }\n  }\n\n  override componentWillUnmount() {\n    if (this.props.stdout.isTTY) {\n      this.props.stdout.write(SHOW_CURSOR)\n    }\n\n    // Clear any pending timers\n    if (this.incompleteEscapeTimer) {\n      clearTimeout(this.incompleteEscapeTimer)\n      this.incompleteEscapeTimer = null\n    }\n    if (this.pendingHyperlinkTimer) {\n      clearTimeout(this.pendingHyperlinkTimer)\n      this.pendingHyperlinkTimer = null\n    }\n    // ignore calling setRawMode on an handle stdin it cannot be called\n    if (this.isRawModeSupported()) {\n      this.handleSetRawMode(false)\n    }\n  }\n\n  override componentDidCatch(error: Error) {\n    this.handleExit(error)\n  }\n\n  handleSetRawMode = (isEnabled: boolean): void => {\n    const { stdin } = this.props\n\n    if (!this.isRawModeSupported()) {\n      if (stdin === process.stdin) {\n        throw new Error(\n          'Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported',\n        )\n      } else {\n        throw new Error(\n          'Raw mode is not supported on the stdin provided to Ink.\\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported',\n        )\n      }\n    }\n\n    stdin.setEncoding('utf8')\n\n    if (isEnabled) {\n      // Ensure raw mode is enabled only once\n      if (this.rawModeEnabledCount === 0) {\n        // Stop early input capture right before we add our own readable handler.\n        // Both use the same stdin 'readable' + read() pattern, so they can't\n        // coexist -- our handler would drain stdin before Ink's can see it.\n        // The buffered text is preserved for REPL.tsx via consumeEarlyInput().\n        stopCapturingEarlyInput()\n        stdin.ref()\n        stdin.setRawMode(true)\n        stdin.addListener('readable', this.handleReadable)\n        // Enable bracketed paste mode\n        this.props.stdout.write(EBP)\n        // Enable terminal focus reporting (DECSET 1004)\n        this.props.stdout.write(EFE)\n        // Enable extended key reporting so ctrl+shift+<letter> is\n        // distinguishable from ctrl+<letter>. We write both the kitty stack\n        // push (CSI >1u) and xterm modifyOtherKeys level 2 (CSI >4;2m) —\n        // terminals honor whichever they implement (tmux only accepts the\n        // latter).\n        if (supportsExtendedKeys()) {\n          this.props.stdout.write(ENABLE_KITTY_KEYBOARD)\n          this.props.stdout.write(ENABLE_MODIFY_OTHER_KEYS)\n        }\n        // Probe terminal identity. XTVERSION survives SSH (query/reply goes\n        // through the pty), unlike TERM_PROGRAM. Used for wheel-scroll base\n        // detection when env vars are absent. Fire-and-forget: the DA1\n        // sentinel bounds the round-trip, and if the terminal ignores the\n        // query, flush() still resolves and name stays undefined.\n        // Deferred to next tick so it fires AFTER the current synchronous\n        // init sequence completes — avoids interleaving with alt-screen/mouse\n        // tracking enable writes that may happen in the same render cycle.\n        setImmediate(() => {\n          void Promise.all([\n            this.querier.send(xtversion()),\n            this.querier.flush(),\n          ]).then(([r]) => {\n            if (r) {\n              setXtversionName(r.name)\n              logForDebugging(`XTVERSION: terminal identified as \"${r.name}\"`)\n            } else {\n              logForDebugging('XTVERSION: no reply (terminal ignored query)')\n            }\n          })\n        })\n      }\n\n      this.rawModeEnabledCount++\n      return\n    }\n\n    // Disable raw mode only when no components left that are using it\n    if (--this.rawModeEnabledCount === 0) {\n      this.props.stdout.write(DISABLE_MODIFY_OTHER_KEYS)\n      this.props.stdout.write(DISABLE_KITTY_KEYBOARD)\n      // Disable terminal focus reporting (DECSET 1004)\n      this.props.stdout.write(DFE)\n      // Disable bracketed paste mode\n      this.props.stdout.write(DBP)\n      stdin.setRawMode(false)\n      stdin.removeListener('readable', this.handleReadable)\n      stdin.unref()\n    }\n  }\n\n  // Helper to flush incomplete escape sequences\n  flushIncomplete = (): void => {\n    // Clear the timer reference\n    this.incompleteEscapeTimer = null\n\n    // Only proceed if we have incomplete sequences\n    if (!this.keyParseState.incomplete) return\n\n    // Fullscreen: if stdin has data waiting, it's almost certainly the\n    // continuation of the buffered sequence (e.g. `[<64;74;16M` after a\n    // lone ESC). Node's event loop runs the timers phase before the poll\n    // phase, so when a heavy render blocks the loop past 50ms, this timer\n    // fires before the queued readable event even though the bytes are\n    // already buffered. Re-arm instead of flushing: handleReadable will\n    // drain stdin next and clear this timer. Prevents both the spurious\n    // Escape key and the lost scroll event.\n    if (this.props.stdin.readableLength > 0) {\n      this.incompleteEscapeTimer = setTimeout(\n        this.flushIncomplete,\n        this.NORMAL_TIMEOUT,\n      )\n      return\n    }\n\n    // Process incomplete as a flush operation (input=null)\n    // This reuses all existing parsing logic\n    this.processInput(null)\n  }\n\n  // Process input through the parser and handle the results\n  processInput = (input: string | Buffer | null): void => {\n    // Parse input using our state machine\n    const [keys, newState] = parseMultipleKeypresses(this.keyParseState, input)\n    this.keyParseState = newState\n\n    // Process ALL keys in a SINGLE discreteUpdates call to prevent\n    // \"Maximum update depth exceeded\" error when many keys arrive at once\n    // (e.g., from paste operations or holding keys rapidly).\n    // This batches all state updates from handleInput and all useInput\n    // listeners together within one high-priority update context.\n    if (keys.length > 0) {\n      reconciler.discreteUpdates(\n        processKeysInBatch,\n        this,\n        keys,\n        undefined,\n        undefined,\n      )\n    }\n\n    // If we have incomplete escape sequences, set a timer to flush them\n    if (this.keyParseState.incomplete) {\n      // Cancel any existing timer first\n      if (this.incompleteEscapeTimer) {\n        clearTimeout(this.incompleteEscapeTimer)\n      }\n      this.incompleteEscapeTimer = setTimeout(\n        this.flushIncomplete,\n        this.keyParseState.mode === 'IN_PASTE'\n          ? this.PASTE_TIMEOUT\n          : this.NORMAL_TIMEOUT,\n      )\n    }\n  }\n\n  handleReadable = (): void => {\n    // Detect long stdin gaps (tmux attach, ssh reconnect, laptop wake).\n    // The terminal may have reset DEC private modes; re-assert mouse\n    // tracking. Checked before the read loop so one Date.now() covers\n    // all chunks in this readable event.\n    const now = Date.now()\n    if (now - this.lastStdinTime > STDIN_RESUME_GAP_MS) {\n      this.props.onStdinResume?.()\n    }\n    this.lastStdinTime = now\n    try {\n      let chunk\n      while ((chunk = this.props.stdin.read() as string | null) !== null) {\n        // Process the input chunk\n        this.processInput(chunk)\n      }\n    } catch (error) {\n      // In Bun, an uncaught throw inside a stream 'readable' handler can\n      // permanently wedge the stream: data stays buffered and 'readable'\n      // never re-emits. Catching here ensures the stream stays healthy so\n      // subsequent keystrokes are still delivered.\n      logError(error)\n\n      // Re-attach the listener in case the exception detached it.\n      // Bun may remove the listener after an error; without this,\n      // the session freezes permanently (stdin reader dead, event loop alive).\n      const { stdin } = this.props\n      if (\n        this.rawModeEnabledCount > 0 &&\n        !stdin.listeners('readable').includes(this.handleReadable)\n      ) {\n        logForDebugging(\n          'handleReadable: re-attaching stdin readable listener after error recovery',\n          { level: 'warn' },\n        )\n        stdin.addListener('readable', this.handleReadable)\n      }\n    }\n  }\n\n  handleInput = (input: string | undefined): void => {\n    // Exit on Ctrl+C\n    if (input === '\\x03' && this.props.exitOnCtrlC) {\n      this.handleExit()\n    }\n\n    // Note: Ctrl+Z (suspend) is now handled in processKeysInBatch using the\n    // parsed key to support both raw (\\x1a) and CSI u format from Kitty\n    // keyboard protocol terminals (Ghostty, iTerm2, kitty, WezTerm)\n  }\n\n  handleExit = (error?: Error): void => {\n    if (this.isRawModeSupported()) {\n      this.handleSetRawMode(false)\n    }\n\n    this.props.onExit(error)\n  }\n\n  handleTerminalFocus = (isFocused: boolean): void => {\n    // setTerminalFocused notifies subscribers: TerminalFocusProvider (context)\n    // and Clock (interval speed) — no App setState needed.\n    setTerminalFocused(isFocused)\n  }\n\n  handleSuspend = (): void => {\n    if (!this.isRawModeSupported()) {\n      return\n    }\n\n    // Store the exact raw mode count to restore it properly\n    const rawModeCountBeforeSuspend = this.rawModeEnabledCount\n\n    // Completely disable raw mode before suspending\n    while (this.rawModeEnabledCount > 0) {\n      this.handleSetRawMode(false)\n    }\n\n    // Show cursor, disable focus reporting, and disable mouse tracking\n    // before suspending. DISABLE_MOUSE_TRACKING is a no-op if tracking\n    // wasn't enabled, so it's safe to emit unconditionally — without\n    // it, SGR mouse sequences would appear as garbled text at the\n    // shell prompt while suspended.\n    if (this.props.stdout.isTTY) {\n      this.props.stdout.write(SHOW_CURSOR + DFE + DISABLE_MOUSE_TRACKING)\n    }\n\n    // Emit suspend event for Claude Code to handle. Mostly just has a notification\n    this.internal_eventEmitter.emit('suspend')\n\n    // Set up resume handler\n    const resumeHandler = () => {\n      // Restore raw mode to exact previous state\n      for (let i = 0; i < rawModeCountBeforeSuspend; i++) {\n        if (this.isRawModeSupported()) {\n          this.handleSetRawMode(true)\n        }\n      }\n\n      // Hide cursor (unless in accessibility mode) and re-enable focus reporting after resuming\n      if (this.props.stdout.isTTY) {\n        if (!isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY)) {\n          this.props.stdout.write(HIDE_CURSOR)\n        }\n        // Re-enable focus reporting to restore terminal state\n        this.props.stdout.write(EFE)\n      }\n\n      // Emit resume event for Claude Code to handle\n      this.internal_eventEmitter.emit('resume')\n\n      process.removeListener('SIGCONT', resumeHandler)\n    }\n\n    process.on('SIGCONT', resumeHandler)\n    process.kill(process.pid, 'SIGSTOP')\n  }\n}\n\n// Helper to process all keys within a single discrete update context.\n// discreteUpdates expects (fn, a, b, c, d) -> fn(a, b, c, d)\nfunction processKeysInBatch(\n  app: App,\n  items: ParsedInput[],\n  _unused1: undefined,\n  _unused2: undefined,\n): void {\n  // Update interaction time for notification timeout tracking.\n  // This is called from the central input handler to avoid having multiple\n  // stdin listeners that can cause race conditions and dropped input.\n  // Terminal responses (kind: 'response') are automated, not user input.\n  // Mode-1003 no-button motion is also excluded — passive cursor drift is\n  // not engagement (would suppress idle notifications + defer housekeeping).\n  if (\n    items.some(\n      i =>\n        i.kind === 'key' ||\n        (i.kind === 'mouse' &&\n          !((i.button & 0x20) !== 0 && (i.button & 0x03) === 3)),\n    )\n  ) {\n    updateLastInteractionTime()\n  }\n\n  for (const item of items) {\n    // Terminal responses (DECRPM, DA1, OSC replies, etc.) are not user\n    // input — route them to the querier to resolve pending promises.\n    if (item.kind === 'response') {\n      app.querier.onResponse(item.response)\n      continue\n    }\n\n    // Mouse click/drag events update selection state (fullscreen only).\n    // Terminal sends 1-indexed col/row; convert to 0-indexed for the\n    // screen buffer. Button bit 0x20 = drag (motion while button held).\n    if (item.kind === 'mouse') {\n      handleMouseEvent(app, item)\n      continue\n    }\n\n    const sequence = item.sequence\n\n    // Handle terminal focus events (DECSET 1004)\n    if (sequence === FOCUS_IN) {\n      app.handleTerminalFocus(true)\n      const event = new TerminalFocusEvent('terminalfocus')\n      app.internal_eventEmitter.emit('terminalfocus', event)\n      continue\n    }\n    if (sequence === FOCUS_OUT) {\n      app.handleTerminalFocus(false)\n      // Defensive: if we lost the release event (mouse released outside\n      // terminal window — some emulators drop it rather than capturing the\n      // pointer), focus-out is the next observable signal that the drag is\n      // over. Without this, drag-to-scroll's timer runs until the scroll\n      // boundary is hit.\n      if (app.props.selection.isDragging) {\n        finishSelection(app.props.selection)\n        app.props.onSelectionChange()\n      }\n      const event = new TerminalFocusEvent('terminalblur')\n      app.internal_eventEmitter.emit('terminalblur', event)\n      continue\n    }\n\n    // Failsafe: if we receive input, the terminal must be focused\n    if (!getTerminalFocused()) {\n      setTerminalFocused(true)\n    }\n\n    // Handle Ctrl+Z (suspend) using parsed key to support both raw (\\x1a) and\n    // CSI u format (\\x1b[122;5u) from Kitty keyboard protocol terminals\n    if (item.name === 'z' && item.ctrl && SUPPORTS_SUSPEND) {\n      app.handleSuspend()\n      continue\n    }\n\n    app.handleInput(sequence)\n    const event = new InputEvent(item)\n    app.internal_eventEmitter.emit('input', event)\n\n    // Also dispatch through the DOM tree so onKeyDown handlers fire.\n    app.props.dispatchKeyboardEvent(item)\n  }\n}\n\n/** Exported for testing. Mutates app.props.selection and click/hover state. */\nexport function handleMouseEvent(app: App, m: ParsedMouse): void {\n  // Allow disabling click handling while keeping wheel scroll (which goes\n  // through the keybinding system as 'wheelup'/'wheeldown', not here).\n  if (isMouseClicksDisabled()) return\n\n  const sel = app.props.selection\n  // Terminal coords are 1-indexed; screen buffer is 0-indexed\n  const col = m.col - 1\n  const row = m.row - 1\n  const baseButton = m.button & 0x03\n\n  if (m.action === 'press') {\n    if ((m.button & 0x20) !== 0 && baseButton === 3) {\n      // Mode-1003 motion with no button held. Dispatch hover; skip the\n      // rest of this handler (no selection, no click-count side effects).\n      // Lost-release recovery: no-button motion while isDragging=true means\n      // the release happened outside the terminal window (iTerm2 doesn't\n      // capture the pointer past window bounds, so the SGR 'm' never\n      // arrives). Finish the selection here so copy-on-select fires. The\n      // FOCUS_OUT handler covers the \"switched apps\" case but not \"released\n      // past the edge, came back\" — and tmux drops focus events unless\n      // `focus-events on` is set, so this is the more reliable signal.\n      if (sel.isDragging) {\n        finishSelection(sel)\n        app.props.onSelectionChange()\n      }\n      if (col === app.lastHoverCol && row === app.lastHoverRow) return\n      app.lastHoverCol = col\n      app.lastHoverRow = row\n      app.props.onHoverAt(col, row)\n      return\n    }\n    if (baseButton !== 0) {\n      // Non-left press breaks the multi-click chain.\n      app.clickCount = 0\n      return\n    }\n    if ((m.button & 0x20) !== 0) {\n      // Drag motion: mode-aware extension (char/word/line). onSelectionDrag\n      // calls notifySelectionChange internally — no extra onSelectionChange.\n      app.props.onSelectionDrag(col, row)\n      return\n    }\n    // Lost-release fallback for mode-1002-only terminals: a fresh press\n    // while isDragging=true means the previous release was dropped (cursor\n    // left the window). Finish that selection so copy-on-select fires\n    // before startSelection/onMultiClick clobbers it. Mode-1003 terminals\n    // hit the no-button-motion recovery above instead, so this is rare.\n    if (sel.isDragging) {\n      finishSelection(sel)\n      app.props.onSelectionChange()\n    }\n    // Fresh left press. Detect multi-click HERE (not on release) so the\n    // word/line highlight appears immediately and a subsequent drag can\n    // extend by word/line like native macOS. Previously detected on\n    // release, which meant (a) visible latency before the word highlights\n    // and (b) double-click+drag fell through to char-mode selection.\n    const now = Date.now()\n    const nearLast =\n      now - app.lastClickTime < MULTI_CLICK_TIMEOUT_MS &&\n      Math.abs(col - app.lastClickCol) <= MULTI_CLICK_DISTANCE &&\n      Math.abs(row - app.lastClickRow) <= MULTI_CLICK_DISTANCE\n    app.clickCount = nearLast ? app.clickCount + 1 : 1\n    app.lastClickTime = now\n    app.lastClickCol = col\n    app.lastClickRow = row\n    if (app.clickCount >= 2) {\n      // Cancel any pending hyperlink-open from the first click — this is\n      // a double-click, not a single-click on a link.\n      if (app.pendingHyperlinkTimer) {\n        clearTimeout(app.pendingHyperlinkTimer)\n        app.pendingHyperlinkTimer = null\n      }\n      // Cap at 3 (line select) for quadruple+ clicks.\n      const count = app.clickCount === 2 ? 2 : 3\n      app.props.onMultiClick(col, row, count)\n      return\n    }\n    startSelection(sel, col, row)\n    // SGR bit 0x08 = alt (xterm.js wires altKey here, not metaKey — see\n    // comment at the hyperlink-open guard below). On macOS xterm.js,\n    // receiving alt means macOptionClickForcesSelection is OFF (otherwise\n    // xterm.js would have consumed the event for native selection).\n    sel.lastPressHadAlt = (m.button & 0x08) !== 0\n    app.props.onSelectionChange()\n    return\n  }\n\n  // Release: end the drag even for non-zero button codes. Some terminals\n  // encode release with the motion bit or button=3 \"no button\" (carried\n  // over from pre-SGR X10 encoding) — filtering those would orphan\n  // isDragging=true and leave drag-to-scroll's timer running until the\n  // scroll boundary. Only act on non-left releases when we ARE dragging\n  // (so an unrelated middle/right click-release doesn't touch selection).\n  if (baseButton !== 0) {\n    if (!sel.isDragging) return\n    finishSelection(sel)\n    app.props.onSelectionChange()\n    return\n  }\n  finishSelection(sel)\n  // NOTE: unlike the old release-based detection we do NOT reset clickCount\n  // on release-after-drag. This aligns with NSEvent.clickCount semantics:\n  // an intervening drag doesn't break the click chain. Practical upside:\n  // trackpad jitter during an intended double-click (press→wobble→release\n  // →press) now correctly resolves to word-select instead of breaking to a\n  // fresh single click. The nearLast window (500ms, 1 cell) bounds the\n  // effect — a deliberate drag past that just starts a fresh chain.\n  // A press+release with no drag in char mode is a click: anchor set,\n  // focus null → hasSelection false. In word/line mode the press already\n  // set anchor+focus (hasSelection true), so release just keeps the\n  // highlight. The anchor check guards against an orphaned release (no\n  // prior press — e.g. button was held when mouse tracking was enabled).\n  if (!hasSelection(sel) && sel.anchor) {\n    // Single click: dispatch DOM click immediately (cursor repositioning\n    // etc. are latency-sensitive). If no DOM handler consumed it, defer\n    // the hyperlink check so a second click can cancel it.\n    if (!app.props.onClickAt(col, row)) {\n      // Resolve the hyperlink URL synchronously while the screen buffer\n      // still reflects what the user clicked — deferring only the\n      // browser-open so double-click can cancel it.\n      const url = app.props.getHyperlinkAt(col, row)\n      // xterm.js (VS Code, Cursor, Windsurf, etc.) has its own OSC 8 link\n      // handler that fires on Cmd+click *without consuming the mouse event*\n      // (Linkifier._handleMouseUp calls link.activate() but never\n      // preventDefault/stopPropagation). The click is also forwarded to the\n      // pty as SGR, so both VS Code's terminalLinkManager AND our handler\n      // here would open the URL — twice. We can't filter on Cmd: xterm.js\n      // drops metaKey before SGR encoding (ICoreMouseEvent has no meta\n      // field; the SGR bit we call 'meta' is wired to alt). Let xterm.js\n      // own link-opening; Cmd+click is the native UX there anyway.\n      // TERM_PROGRAM is the sync fast-path; isXtermJs() is the XTVERSION\n      // probe result (catches SSH + non-VS Code embedders like Hyper).\n      if (url && process.env.TERM_PROGRAM !== 'vscode' && !isXtermJs()) {\n        // Clear any prior pending timer — clicking a second link\n        // supersedes the first (only the latest click opens).\n        if (app.pendingHyperlinkTimer) {\n          clearTimeout(app.pendingHyperlinkTimer)\n        }\n        app.pendingHyperlinkTimer = setTimeout(\n          (app, url) => {\n            app.pendingHyperlinkTimer = null\n            app.props.onOpenHyperlink(url)\n          },\n          MULTI_CLICK_TIMEOUT_MS,\n          app,\n          url,\n        )\n      }\n    }\n  }\n  app.props.onSelectionChange()\n}\n"],"mappings":"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","ignoreList":[]}