nastech-tui 0.0.1

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

@@ -0,0 +1,2705 @@
+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,
+  enableMouseTrackingFor,
+  ENTER_ALT_SCREEN,
+  EXIT_ALT_SCREEN,
+  type MouseTrackingMode,
+  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 which mouse
+  // tracking preset to re-enable (not all <AlternateScreen> uses want
+  // tracking, and tmux users routinely opt into the hover-free 'wheel'
+  // subset to silence prompt-row clipboard probes).
+  private altScreenMouseTracking: MouseTrackingMode = 'off'
+  // 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
+    }
+
+    // Mouse tracking — DISABLE first so we land in the exact preset state
+    // even if an external app/terminal/tmux left DEC 1003 hover asserted.
+    // DISABLE_MOUSE_TRACKING is idempotent (resets all four modes
+    // unconditionally), safe to send even when current preset is 'off'.
+    this.options.stdout.write(DISABLE_MOUSE_TRACKING + enableMouseTrackingFor(this.altScreenMouseTracking))
+
+    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 !== 'off' ? 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
+        // DISABLE first so external editors/tmux that left DEC 1003 hover
+        // on can't survive the handoff back — same pattern as
+        // setAltScreenMouseTracking / reenterAltScreen.
+        DISABLE_MOUSE_TRACKING +
+        enableMouseTrackingFor(this.altScreenMouseTracking) +
+        (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: MouseTrackingMode = 'off'): void {
+    if (this.altScreenActive === active) {
+      return
+    }
+
+    this.altScreenActive = active
+    this.altScreenMouseTracking = active ? mouseTracking : 'off'
+
+    // 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()
+      this.scheduleRender()
+    } else {
+      this.repaint()
+    }
+  }
+
+  /**
+   * Switch mouse tracking preset at runtime while the alt screen is
+   * active. Always issues DISABLE first so switching between subsets (e.g.
+   * 'all' → 'wheel') clears mode 1003 instead of leaving it asserted —
+   * DEC private modes have no "set this exact bitmask" form, only
+   * individual set/reset, and tmux's mouse-mode bookkeeping does honor the
+   * reset so the prompt-row "No image in clipboard" spam stops.
+   */
+  setAltScreenMouseTracking(mode: MouseTrackingMode): void {
+    if (this.altScreenMouseTracking === mode) {
+      return
+    }
+
+    this.altScreenMouseTracking = mode
+
+    if (this.altScreenActive) {
+      this.options.stdout.write(DISABLE_MOUSE_TRACKING + enableMouseTrackingFor(mode))
+    }
+  }
+  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.
+    // DISABLE first so we land in the exact preset state even if an
+    // external app or tmux left DEC 1003 hover asserted out from under us
+    // since the last assertion.
+    this.options.stdout.write(DISABLE_MOUSE_TRACKING + enableMouseTrackingFor(this.altScreenMouseTracking))
+
+    // 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 {
+    // DISABLE_MOUSE_TRACKING before enableMouseTrackingFor — same as
+    // setAltScreenMouseTracking / AlternateScreen mount / handleResize.
+    // DEC private modes have no atomic "set this bitmask" sequence, only
+    // per-mode set/reset, so for 'wheel'/'buttons' presets we must reset
+    // first to drop any lingering DEC 1003 hover from before re-entry.
+    this.options.stdout.write(
+      ENTER_ALT_SCREEN +
+        ERASE_SCREEN +
+        CURSOR_HOME +
+        DISABLE_MOUSE_TRACKING +
+        enableMouseTrackingFor(this.altScreenMouseTracking)
+    )
+    this.resetFramesForAltScreen()
+    // ERASE_SCREEN above leaves the physical alt screen blank, and
+    // resetFramesForAltScreen() seeds prev/back as blank rows×cols, so
+    // nothing on the front frame survives the re-entry. Callers
+    // (handleResume on SIGCONT, the resize self-heal, the stdin-gap
+    // re-assertion) all return early after invoking us, so without an
+    // explicit render schedule the alt screen sits blank until some
+    // unrelated state change fires the next commit. queueing one
+    // microtask matches scheduleRender's normal cadence.
+    this.scheduleRender()
+  }
+
+  /**
+   * 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 = this.getTextSelectionText()
+
+    if (text) {
+      try {
+        const { sequence, success } = await setClipboard(text)
+
+        if (sequence) {
+          this.options.stdout.write(sequence)
+        }
+
+        if (success) {
+          return text
+        }
+      } catch {
+        // Clipboard failed across every path — caller sees the empty
+        // return below and surfaces a hint via the slash command.
+      }
+    }
+
+    return ''
+  }
+
+  getTextSelectionText(): string {
+    return hasSelection(this.selection) ? getSelectedText(this.selection, this.frontFrame.screen) : ''
+  }
+
+  /**
+   * 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}
+        getSelectedText={this.getTextSelectionText}
+        onClickAt={this.dispatchClick}
+        onCopySelectionNoClear={this.copySelectionNoClear}
+        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":"AAAA,OAAOA,QAAQ,MAAM,WAAW;AAChC,SACEC,SAAS,EACTC,SAAS,IAAIC,WAAW,EACxBC,QAAQ,EACRC,QAAQ,EACRC,SAAS,QACJ,IAAI;AACX,OAAOC,IAAI,MAAM,mBAAmB;AACpC,OAAOC,QAAQ,MAAM,uBAAuB;AAC5C,OAAOC,KAAK,IAAI,KAAKC,SAAS,QAAQ,OAAO;AAC7C,cAAcC,SAAS,QAAQ,kBAAkB;AACjD,SAASC,cAAc,QAAQ,+BAA+B;AAC9D,SAASC,MAAM,QAAQ,aAAa;AACpC,SAASC,oBAAoB,QAAQ,wBAAwB;AAC7D,SAASC,eAAe,QAAQ,oCAAoC;AACpE,SAASC,eAAe,QAAQ,oBAAoB;AACpD,SAASC,QAAQ,QAAQ,kBAAkB;AAC3C,SAASC,MAAM,QAAQ,MAAM;AAC7B,SAASC,QAAQ,QAAQ,eAAe;AACxC,OAAOC,GAAG,MAAM,qBAAqB;AACrC,cACEC,iBAAiB,EACjBC,uBAAuB,QAClB,0CAA0C;AACjD,SAASC,iBAAiB,QAAQ,gBAAgB;AAClD,OAAO,KAAKC,GAAG,MAAM,UAAU;AAC/B,SAASC,aAAa,QAAQ,4BAA4B;AAC1D,SAASC,YAAY,QAAQ,YAAY;AACzC,SAASC,UAAU,EAAE,KAAKC,KAAK,EAAE,KAAKC,UAAU,QAAQ,YAAY;AACpE,SAASC,aAAa,EAAEC,aAAa,QAAQ,eAAe;AAC5D,OAAOC,SAAS,MAAM,gBAAgB;AACtC,SAASC,SAAS,QAAQ,iBAAiB;AAC3C,SAASC,SAAS,QAAQ,iBAAiB;AAC3C,SAASC,QAAQ,QAAQ,gBAAgB;AACzC,OAAOC,MAAM,MAAM,aAAa;AAChC,cAAcC,SAAS,QAAQ,qBAAqB;AACpD,OAAOC,UAAU,IACfC,UAAU,EACVC,eAAe,EACfC,aAAa,EACbC,sBAAsB,EACtBC,YAAY,EACZC,oBAAoB,QACf,iBAAiB;AACxB,OAAOC,kBAAkB,IACvBC,mBAAmB,EACnBC,cAAc,QACT,4BAA4B;AACnC,SACEC,wBAAwB,EACxB,KAAKC,aAAa,EAClBC,aAAa,QACR,uBAAuB;AAC9B,OAAOC,cAAc,IAAI,KAAKC,QAAQ,QAAQ,eAAe;AAC7D,SACEC,SAAS,EACTC,QAAQ,EACRC,MAAM,EACNC,YAAY,EACZC,aAAa,EACbC,aAAa,EACbC,kBAAkB,EAClBC,SAAS,QACJ,aAAa;AACpB,SAASC,oBAAoB,QAAQ,sBAAsB;AAC3D,SACEC,qBAAqB,EACrBC,mBAAmB,EACnBC,cAAc,EACdC,oBAAoB,EACpBC,eAAe,EACf,KAAKC,SAAS,EACdC,kBAAkB,EAClBC,eAAe,EACfC,YAAY,EACZC,SAAS,EACT,KAAKC,cAAc,EACnBC,YAAY,EACZC,YAAY,EACZC,WAAW,EACXC,cAAc,EACdC,uBAAuB,EACvBC,cAAc,EACdC,eAAe,QACV,gBAAgB;AACvB,SACEC,qBAAqB,EACrBC,oBAAoB,EACpB,KAAKC,QAAQ,EACbC,mBAAmB,QACd,eAAe;AACtB,SACEC,WAAW,EACXC,UAAU,EACVC,cAAc,EACdC,sBAAsB,EACtBC,yBAAyB,EACzBC,qBAAqB,EACrBC,wBAAwB,EACxBC,YAAY,QACP,iBAAiB;AACxB,SACEC,GAAG,EACHC,GAAG,EACHC,sBAAsB,EACtBC,qBAAqB,EACrBC,gBAAgB,EAChBC,eAAe,EACfC,WAAW,QACN,iBAAiB;AACxB,SACEC,qBAAqB,EACrBC,gBAAgB,EAChBC,YAAY,EACZC,iBAAiB,EACjBC,kBAAkB,QACb,iBAAiB;AACxB,SAASC,qBAAqB,QAAQ,8BAA8B;;AAEpE;AACA;AACA;AACA,MAAMC,wBAAwB,GAAGC,MAAM,CAACC,MAAM,CAAC;EAAEC,CAAC,EAAE,CAAC;EAAEC,CAAC,EAAE,CAAC;EAAEC,OAAO,EAAE;AAAM,CAAC,CAAC;AAC9E,MAAMC,iBAAiB,GAAGL,MAAM,CAACC,MAAM,CAAC;EACtCK,IAAI,EAAE,QAAQ,IAAIC,KAAK;EACvBC,OAAO,EAAE9B;AACX,CAAC,CAAC;AACF,MAAM+B,qBAAqB,GAAGT,MAAM,CAACC,MAAM,CAAC;EAC1CK,IAAI,EAAE,QAAQ,IAAIC,KAAK;EACvBC,OAAO,EAAEvB,YAAY,GAAGP;AAC1B,CAAC,CAAC;;AAEF;AACA;AACA,SAASgC,sBAAsBA,CAACC,YAAY,EAAE,MAAM,EAAE;EACpD,OAAOX,MAAM,CAACC,MAAM,CAAC;IACnBK,IAAI,EAAE,QAAQ,IAAIC,KAAK;IACvBC,OAAO,EAAE5B,cAAc,CAAC+B,YAAY,EAAE,CAAC;EACzC,CAAC,CAAC;AACJ;AAEA,OAAO,KAAKC,OAAO,GAAG;EACpBC,MAAM,EAAEC,MAAM,CAACC,WAAW;EAC1BC,KAAK,EAAEF,MAAM,CAACG,UAAU;EACxBC,MAAM,EAAEJ,MAAM,CAACC,WAAW;EAC1BI,WAAW,EAAE,OAAO;EACpBC,YAAY,EAAE,OAAO;EACrBC,aAAa,CAAC,EAAE,GAAG,GAAGC,OAAO,CAAC,IAAI,CAAC;EACnCC,OAAO,CAAC,EAAE,CAACC,KAAK,EAAErG,UAAU,EAAE,GAAG,IAAI;AACvC,CAAC;AAED,eAAe,MAAMsG,GAAG,CAAC;EACvB,iBAAiBC,GAAG,EAAEnG,SAAS;EAC/B,iBAAiBoG,QAAQ,EAAEnD,QAAQ;EACnC,QAAQoD,cAAc,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG;IAAEC,MAAM,CAAC,EAAE,GAAG,GAAG,IAAI;EAAC,CAAC;EAC9D;EACA,QAAQC,WAAW,GAAG,KAAK;EAC3B,QAAQC,QAAQ,GAAG,KAAK;EACxB,iBAAiBC,SAAS,EAAE/H,SAAS;EACrC,QAAQgI,QAAQ,EAAEnH,GAAG,CAACoH,UAAU;EAChC,SAASC,YAAY,EAAEnH,YAAY;EACnC,QAAQoH,QAAQ,EAAE1F,QAAQ;EAC1B,iBAAiB2F,SAAS,EAAEnF,SAAS;EACrC,QAAQoF,QAAQ,EAAE1F,QAAQ;EAC1B,QAAQ2F,aAAa,EAAExF,aAAa;EACpC,QAAQyF,WAAW,CAAC,EAAElB,OAAO,CAAC,IAAI,CAAC;EACnC,QAAQmB,cAAc,CAAC,EAAE,GAAG,GAAG,IAAI;EACnC,QAAQC,aAAa,CAAC,EAAE,GAAG,GAAG,IAAI;EAClC,iBAAiBC,sBAAsB,CAAC,EAAE,GAAG,GAAG,IAAI;EACpD,QAAQC,eAAe,EAAE,MAAM;EAC/B,QAAQjC,YAAY,EAAE,MAAM;EAC5B,QAAQkC,WAAW,EAAE7I,SAAS,GAAG,IAAI;EACrC,QAAQ8I,UAAU,EAAE5H,KAAK;EACzB,QAAQ6H,SAAS,EAAE7H,KAAK;EACxB,QAAQ8H,iBAAiB,GAAGC,WAAW,CAACC,GAAG,CAAC,CAAC;EAC7C,QAAQC,UAAU,EAAEC,UAAU,CAAC,OAAOC,UAAU,CAAC,GAAG,IAAI,GAAG,IAAI;EAC/D,QAAQC,gBAAgB,EAAE;IACxBC,EAAE,EAAE,MAAM;IACVC,OAAO,EAAE,MAAM;IACfC,QAAQ,EAAE,MAAM;IAChBC,SAAS,EAAE,MAAM;IACjBC,IAAI,EAAE,MAAM;EACd,CAAC,GAAG;IAAEJ,EAAE,EAAE,CAAC;IAAEC,OAAO,EAAE,CAAC;IAAEC,QAAQ,EAAE,CAAC;IAAEC,SAAS,EAAE,CAAC;IAAEC,IAAI,EAAE;EAAE,CAAC;EAC7D,QAAQC,kBAAkB,EAAEC,QAAQ,CAAC;IAAEvD,IAAI,EAAE,QAAQ;IAAEE,OAAO,EAAE,MAAM;EAAC,CAAC,CAAC;EACzE;EACA;EACA;EACA,SAASsD,SAAS,EAAEhG,cAAc,GAAGP,oBAAoB,CAAC,CAAC;EAC3D;EACA;EACA,QAAQwG,oBAAoB,GAAG,EAAE;EACjC;EACA;EACA;EACA;EACA;EACA;EACA,QAAQC,eAAe,EAAE;IACvBC,SAAS,EAAE1H,aAAa,EAAE;IAC1B2H,SAAS,EAAE,MAAM;IACjBC,UAAU,EAAE,MAAM;EACpB,CAAC,GAAG,IAAI,GAAG,IAAI;EACf;EACA;EACA;EACA,iBAAiBC,kBAAkB,GAAG,IAAIC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC;EAC3D;EACA;EACA;EACA,iBAAiBC,YAAY,GAAG,IAAID,GAAG,CAACvJ,GAAG,CAACoH,UAAU,CAAC,CAAC,CAAC;EACzD;EACA;EACA;EACA;EACA,QAAQqC,eAAe,GAAG,KAAK;EAC/B;EACA;EACA,QAAQC,sBAAsB,GAAG,KAAK;EACtC;EACA;EACA;EACA;EACA;EACA,QAAQC,qBAAqB,GAAG,KAAK;EACrC;EACA;EACA;EACA;EACA;EACA,QAAQC,qBAAqB,GAAG,KAAK;EACrC;EACA;EACA;EACA;EACA;EACA,QAAQC,iBAAiB,EAAEhK,iBAAiB,GAAG,IAAI,GAAG,IAAI;EAC1D;EACA;EACA;EACA;EACA,QAAQiK,aAAa,EAAE;IAAE1E,CAAC,EAAE,MAAM;IAAEC,CAAC,EAAE,MAAM;EAAC,CAAC,GAAG,IAAI,GAAG,IAAI;EAE7D0E,WAAWA,CAAC,iBAAiBC,OAAO,EAAElE,OAAO,EAAE;IAC7CtH,QAAQ,CAAC,IAAI,CAAC;IAEd,IAAI,IAAI,CAACwL,OAAO,CAAC1D,YAAY,EAAE;MAC7B,IAAI,CAACqB,cAAc,GAAG,IAAI,CAACrB,YAAY,CAAC,CAAC;MACzC,IAAI,CAACsB,aAAa,GAAG,IAAI,CAACqC,WAAW,CAAC,CAAC;IACzC;IAEA,IAAI,CAACpD,QAAQ,GAAG;MACdd,MAAM,EAAEiE,OAAO,CAACjE,MAAM;MACtBK,MAAM,EAAE4D,OAAO,CAAC5D;IAClB,CAAC;IAED,IAAI,CAAC0B,eAAe,GAAGkC,OAAO,CAACjE,MAAM,CAACmE,OAAO,IAAI,EAAE;IACnD,IAAI,CAACrE,YAAY,GAAGmE,OAAO,CAACjE,MAAM,CAACoE,IAAI,IAAI,EAAE;IAC7C,IAAI,CAACrB,kBAAkB,GAAGlD,sBAAsB,CAAC,IAAI,CAACC,YAAY,CAAC;IACnE,IAAI,CAAC0B,SAAS,GAAG,IAAInF,SAAS,CAAC,CAAC;IAChC,IAAI,CAACoF,QAAQ,GAAG,IAAI1F,QAAQ,CAAC,CAAC;IAC9B,IAAI,CAAC2F,aAAa,GAAG,IAAIxF,aAAa,CAAC,CAAC;IACxC,IAAI,CAAC+F,UAAU,GAAG7H,UAAU,CAC1B,IAAI,CAAC0F,YAAY,EACjB,IAAI,CAACiC,eAAe,EACpB,IAAI,CAACP,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD,IAAI,CAACQ,SAAS,GAAG9H,UAAU,CACzB,IAAI,CAAC0F,YAAY,EACjB,IAAI,CAACiC,eAAe,EACpB,IAAI,CAACP,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IAED,IAAI,CAACb,GAAG,GAAG,IAAInG,SAAS,CAAC;MACvB2J,KAAK,EAAGJ,OAAO,CAACjE,MAAM,CAACqE,KAAK,IAAI,OAAO,GAAG,SAAS,IAAK,KAAK;MAC7D7C,SAAS,EAAE,IAAI,CAACA;IAClB,CAAC,CAAC;;IAEF;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAM8C,cAAc,GAAGA,CAAA,CAAE,EAAE,IAAI,IAAIC,cAAc,CAAC,IAAI,CAACC,QAAQ,CAAC;IAChE,IAAI,CAACzD,cAAc,GAAG9H,QAAQ,CAACqL,cAAc,EAAEtK,iBAAiB,EAAE;MAChEyK,OAAO,EAAE,IAAI;MACbC,QAAQ,EAAE;IACZ,CAAC,CAAC;;IAEF;IACA,IAAI,CAACzD,WAAW,GAAG,KAAK;;IAExB;IACA,IAAI,CAAC0D,eAAe,GAAGrL,MAAM,CAAC,IAAI,CAACsL,OAAO,EAAE;MAAEC,UAAU,EAAE;IAAM,CAAC,CAAC;IAElE,IAAIZ,OAAO,CAACjE,MAAM,CAACqE,KAAK,EAAE;MACxBJ,OAAO,CAACjE,MAAM,CAAC8E,EAAE,CAAC,QAAQ,EAAE,IAAI,CAACC,YAAY,CAAC;MAC9CC,OAAO,CAACF,EAAE,CAAC,SAAS,EAAE,IAAI,CAACG,YAAY,CAAC;MAExC,IAAI,CAACnD,sBAAsB,GAAG,MAAM;QAClCmC,OAAO,CAACjE,MAAM,CAACkF,GAAG,CAAC,QAAQ,EAAE,IAAI,CAACH,YAAY,CAAC;QAC/CC,OAAO,CAACE,GAAG,CAAC,SAAS,EAAE,IAAI,CAACD,YAAY,CAAC;MAC3C,CAAC;IACH;IAEA,IAAI,CAAC7D,QAAQ,GAAGnH,GAAG,CAACkL,UAAU,CAAC,UAAU,CAAC;IAC1C,IAAI,CAAC7D,YAAY,GAAG,IAAInH,YAAY,CAAC,CAACiL,MAAM,EAAEzE,KAAK,KACjD3F,UAAU,CAACqK,gBAAgB,CAACD,MAAM,EAAEzE,KAAK,CAC3C,CAAC;IACD,IAAI,CAACS,QAAQ,CAACE,YAAY,GAAG,IAAI,CAACA,YAAY;IAC9C,IAAI,CAACC,QAAQ,GAAG3F,cAAc,CAAC,IAAI,CAACwF,QAAQ,EAAE,IAAI,CAACI,SAAS,CAAC;IAC7D,IAAI,CAACJ,QAAQ,CAACoD,QAAQ,GAAG,IAAI,CAACzD,cAAc;IAC5C,IAAI,CAACK,QAAQ,CAACkE,iBAAiB,GAAG,IAAI,CAACd,QAAQ;IAC/C,IAAI,CAACpD,QAAQ,CAACmE,eAAe,GAAG,MAAM;MACpC;MACA;MACA;MACA,IAAI,IAAI,CAACtE,WAAW,EAAE;QACpB;MACF;MAEA,IAAI,IAAI,CAACG,QAAQ,CAACoE,QAAQ,EAAE;QAC1B,MAAMC,EAAE,GAAGrD,WAAW,CAACC,GAAG,CAAC,CAAC;QAC5B,IAAI,CAACjB,QAAQ,CAACoE,QAAQ,CAACE,QAAQ,CAAC,IAAI,CAAC3D,eAAe,CAAC;QACrD,IAAI,CAACX,QAAQ,CAACoE,QAAQ,CAACG,eAAe,CAAC,IAAI,CAAC5D,eAAe,CAAC;QAC5D,MAAMW,EAAE,GAAGN,WAAW,CAACC,GAAG,CAAC,CAAC,GAAGoD,EAAE;QACjCrK,YAAY,CAACsH,EAAE,CAAC;QAChB,MAAMkD,CAAC,GAAGpM,eAAe,CAAC,CAAC;QAC3B,IAAI,CAACiJ,gBAAgB,GAAG;UAAEC,EAAE;UAAE,GAAGkD;QAAE,CAAC;MACtC;IACF,CAAC;;IAED;IACA;IACA,IAAI,CAACzE,SAAS,GAAGpG,UAAU,CAAC8K,eAAe,CACzC,IAAI,CAACzE,QAAQ,EACb/H,cAAc,EACd,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,IAAI,EACJL,IAAI;IAAE;IACNA,IAAI;IAAE;IACNA,IAAI;IAAE;IACNA,IAAI,CAAE;IACR,CAAC;IAED,IAAI,YAAY,KAAK,aAAa,EAAE;MAClC+B,UAAU,CAAC+K,kBAAkB,CAAC;QAC5BC,UAAU,EAAE,CAAC;QACb;QACA;QACAC,OAAO,EAAE,SAAS;QAClBC,mBAAmB,EAAE;MACvB,CAAC,CAAC;IACJ;EACF;EAEA,QAAQhB,YAAY,GAAGA,CAAA,KAAM;IAC3B,IAAI,CAAC,IAAI,CAAChB,OAAO,CAACjE,MAAM,CAACqE,KAAK,EAAE;MAC9B;IACF;;IAEA;IACA;IACA;IACA,IAAI,IAAI,CAACX,eAAe,EAAE;MACxB,IAAI,CAACwC,gBAAgB,CAAC,CAAC;MACvB;IACF;;IAEA;IACA,IAAI,CAACjE,UAAU,GAAG7H,UAAU,CAC1B,IAAI,CAAC6H,UAAU,CAACkE,QAAQ,CAACC,MAAM,EAC/B,IAAI,CAACnE,UAAU,CAACkE,QAAQ,CAACE,KAAK,EAC9B,IAAI,CAAC7E,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD,IAAI,CAACQ,SAAS,GAAG9H,UAAU,CACzB,IAAI,CAAC8H,SAAS,CAACiE,QAAQ,CAACC,MAAM,EAC9B,IAAI,CAAClE,SAAS,CAACiE,QAAQ,CAACE,KAAK,EAC7B,IAAI,CAAC7E,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD,IAAI,CAACb,GAAG,CAACyF,KAAK,CAAC,CAAC;IAChB;IACA;IACA;IACA,IAAI,CAACvC,aAAa,GAAG,IAAI;EAC3B,CAAC;;EAED;EACA;EACA;EACA;EACA;EACA;EACA,QAAQgB,YAAY,GAAGA,CAAA,KAAM;IAC3B,MAAMwB,IAAI,GAAG,IAAI,CAACtC,OAAO,CAACjE,MAAM,CAACmE,OAAO,IAAI,EAAE;IAC9C,MAAMC,IAAI,GAAG,IAAI,CAACH,OAAO,CAACjE,MAAM,CAACoE,IAAI,IAAI,EAAE;IAC3C;IACA;IACA;IACA,IAAImC,IAAI,KAAK,IAAI,CAACxE,eAAe,IAAIqC,IAAI,KAAK,IAAI,CAACtE,YAAY,EAAE;IACjE,IAAI,CAACiC,eAAe,GAAGwE,IAAI;IAC3B,IAAI,CAACzG,YAAY,GAAGsE,IAAI;IACxB,IAAI,CAACrB,kBAAkB,GAAGlD,sBAAsB,CAAC,IAAI,CAACC,YAAY,CAAC;;IAEnE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAI,IAAI,CAAC4D,eAAe,IAAI,CAAC,IAAI,CAACxC,QAAQ,IAAI,IAAI,CAAC+C,OAAO,CAACjE,MAAM,CAACqE,KAAK,EAAE;MACvE,IAAI,IAAI,CAACV,sBAAsB,EAAE;QAC/B,IAAI,CAACM,OAAO,CAACjE,MAAM,CAACwG,KAAK,CAAChI,qBAAqB,CAAC;MAClD;MACA,IAAI,CAACiI,uBAAuB,CAAC,CAAC;MAC9B,IAAI,CAAC5C,qBAAqB,GAAG,IAAI;IACnC;;IAEA;IACA;IACA;IACA;IACA;IACA,IAAI,IAAI,CAAC7B,WAAW,KAAK,IAAI,EAAE;MAC7B,IAAI,CAAC0E,MAAM,CAAC,IAAI,CAAC1E,WAAW,CAAC;IAC/B;EACF,CAAC;EAED2E,kBAAkB,EAAE,GAAG,GAAG,IAAI,GAAGA,CAAA,KAAM,CAAC,CAAC;EACzCC,iBAAiB,EAAE,CAACC,MAAc,CAAP,EAAEC,KAAK,EAAE,GAAG,IAAI,GAAGF,CAAA,KAAM,CAAC,CAAC;EACtDjC,eAAe,EAAE,GAAG,GAAG,IAAI,GAAGA,CAAA,KAAM,CAAC,CAAC;;EAEtC;AACF;AACA;AACA;AACA;AACA;EACEoC,oBAAoBA,CAAA,CAAE,EAAE,IAAI,CAAC;IAC3B,IAAI,CAACC,KAAK,CAAC,CAAC;IACZ,IAAI,CAACC,YAAY,CAAC,CAAC;IACnB,IAAI,CAAChD,OAAO,CAACjE,MAAM,CAACwG,KAAK;IACvB;IACA;IACA;IACAxI,sBAAsB,GACpBC,yBAAyB,IACxB,IAAI,CAAC0F,sBAAsB,GAAGpF,sBAAsB,GAAG,EAAE,CAAC;IAAG;IAC7D,IAAI,CAACmF,eAAe,GAAG,EAAE,GAAG,aAAa,CAAC;IAAG;IAC9C,aAAa;IAAG;IAChB,SAAS;IAAG;IACZ,WAAW;IAAG;IACd,SAAS;IAAG;IACZ,QAAQ,CAAE;IACd,CAAC;EACH;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEwD,mBAAmBA,CAAA,CAAE,EAAE,IAAI,CAAC;IAC1B,IAAI,CAACjD,OAAO,CAACjE,MAAM,CAACwG,KAAK,CACvB,CAAC,IAAI,CAAC9C,eAAe,GAAGjF,gBAAgB,GAAG,EAAE;IAAI;IAC/C,SAAS;IAAG;IACZ,QAAQ;IAAG;IACV,IAAI,CAACkF,sBAAsB,GAAGnF,qBAAqB,GAAG,EAAE,CAAC;IAAG;IAC5D,IAAI,CAACkF,eAAe,GAAG,EAAE,GAAG,aAAa,CAAC;IAAG;IAC9C,WAAW,CAAE;IACjB,CAAC;IACD,IAAI,CAACyD,WAAW,CAAC,CAAC;IAClB,IAAI,IAAI,CAACzD,eAAe,EAAE;MACxB,IAAI,CAAC+C,uBAAuB,CAAC,CAAC;IAChC,CAAC,MAAM;MACL,IAAI,CAACW,OAAO,CAAC,CAAC;IAChB;IACA,IAAI,CAACC,MAAM,CAAC,CAAC;IACb;IACA;IACA;IACA;IACA;IACA;IACA,IAAI,CAACpD,OAAO,CAACjE,MAAM,CAACwG,KAAK,CACvB,aAAa,IACV9I,oBAAoB,CAAC,CAAC,GACnBM,sBAAsB,GACtBE,qBAAqB,GACrBC,wBAAwB,GACxB,EAAE,CACV,CAAC;EACH;EAEAqG,QAAQA,CAAA,EAAG;IACT,IAAI,IAAI,CAACvD,WAAW,IAAI,IAAI,CAACC,QAAQ,EAAE;MACrC;IACF;IACA;IACA;IACA;IACA,IAAI,IAAI,CAACoB,UAAU,KAAK,IAAI,EAAE;MAC5BgF,YAAY,CAAC,IAAI,CAAChF,UAAU,CAAC;MAC7B,IAAI,CAACA,UAAU,GAAG,IAAI;IACxB;;IAEA;IACA;IACA;IACA;IACA/I,oBAAoB,CAAC,CAAC;IAEtB,MAAMgO,WAAW,GAAGnF,WAAW,CAACC,GAAG,CAAC,CAAC;IACrC,MAAMmF,aAAa,GAAG,IAAI,CAACvD,OAAO,CAACjE,MAAM,CAACmE,OAAO,IAAI,EAAE;IACvD,MAAMrE,YAAY,GAAG,IAAI,CAACmE,OAAO,CAACjE,MAAM,CAACoE,IAAI,IAAI,EAAE;IAEnD,MAAMqD,KAAK,GAAG,IAAI,CAAClG,QAAQ,CAAC;MAC1BU,UAAU,EAAE,IAAI,CAACA,UAAU;MAC3BC,SAAS,EAAE,IAAI,CAACA,SAAS;MACzBmC,KAAK,EAAE,IAAI,CAACJ,OAAO,CAACjE,MAAM,CAACqE,KAAK;MAChCmD,aAAa;MACb1H,YAAY;MACZ4H,SAAS,EAAE,IAAI,CAAChE,eAAe;MAC/BE,qBAAqB,EAAE,IAAI,CAACA;IAC9B,CAAC,CAAC;IACF,MAAM+D,UAAU,GAAGvF,WAAW,CAACC,GAAG,CAAC,CAAC,GAAGkF,WAAW;;IAElD;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMK,MAAM,GAAGrM,mBAAmB,CAAC,CAAC;IACpC,IACEqM,MAAM,IACN,IAAI,CAAC3E,SAAS,CAAC4E,MAAM;IACrB;IACA;IACA;IACA;IACA;IACA;IACA,IAAI,CAAC5E,SAAS,CAAC4E,MAAM,CAACC,GAAG,IAAIF,MAAM,CAACG,WAAW,IAC/C,IAAI,CAAC9E,SAAS,CAAC4E,MAAM,CAACC,GAAG,IAAIF,MAAM,CAACI,cAAc,EAClD;MACA,MAAM;QAAEC,KAAK;QAAEF,WAAW;QAAEC;MAAe,CAAC,GAAGJ,MAAM;MACrD;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAI,IAAI,CAAC3E,SAAS,CAACiF,UAAU,EAAE;QAC7B,IAAInL,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC,EAAE;UAChCzG,mBAAmB,CACjB,IAAI,CAACyG,SAAS,EACd,IAAI,CAAChB,UAAU,CAACkG,MAAM,EACtBJ,WAAW,EACXA,WAAW,GAAGE,KAAK,GAAG,CAAC,EACvB,OACF,CAAC;QACH;QACA7K,WAAW,CAAC,IAAI,CAAC6F,SAAS,EAAE,CAACgF,KAAK,EAAEF,WAAW,EAAEC,cAAc,CAAC;MAClE,CAAC,MAAM;MACL;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,CAAC,IAAI,CAAC/E,SAAS,CAACmF,KAAK,IACpB,IAAI,CAACnF,SAAS,CAACmF,KAAK,CAACN,GAAG,IAAIC,WAAW,IACtC,IAAI,CAAC9E,SAAS,CAACmF,KAAK,CAACN,GAAG,IAAIE,cAAe,EAC7C;QACA,IAAIjL,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC,EAAE;UAChCzG,mBAAmB,CACjB,IAAI,CAACyG,SAAS,EACd,IAAI,CAAChB,UAAU,CAACkG,MAAM,EACtBJ,WAAW,EACXA,WAAW,GAAGE,KAAK,GAAG,CAAC,EACvB,OACF,CAAC;QACH;QACA,MAAMI,OAAO,GAAG/K,uBAAuB,CACrC,IAAI,CAAC2F,SAAS,EACd,CAACgF,KAAK,EACNF,WAAW,EACXC,cACF,CAAC;QACD;QACA;QACA;QACA;QACA;QACA,IAAIK,OAAO,EAAE,KAAK,MAAMC,EAAE,IAAI,IAAI,CAAC/E,kBAAkB,EAAE+E,EAAE,CAAC,CAAC;MAC7D;IACF;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIC,SAAS,GAAG,KAAK;IACrB,IAAIC,QAAQ,GAAG,KAAK;IACpB,IAAI,IAAI,CAAC9E,eAAe,EAAE;MACxB6E,SAAS,GAAGxL,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC;MACxC,IAAIsF,SAAS,EAAE;QACbhM,qBAAqB,CAACkL,KAAK,CAACU,MAAM,EAAE,IAAI,CAAClF,SAAS,EAAE,IAAI,CAACzB,SAAS,CAAC;MACrE;MACA;MACA;MACAgH,QAAQ,GAAGlM,oBAAoB,CAC7BmL,KAAK,CAACU,MAAM,EACZ,IAAI,CAACjF,oBAAoB,EACzB,IAAI,CAAC1B,SACP,CAAC;MACD;MACA;MACA;MACA,IAAI,IAAI,CAAC2B,eAAe,EAAE;QACxB,MAAMsF,EAAE,GAAG,IAAI,CAACtF,eAAe;QAC/B,MAAMuF,UAAU,GAAGjN,wBAAwB,CACzCgM,KAAK,CAACU,MAAM,EACZ,IAAI,CAAC3G,SAAS,EACdiH,EAAE,CAACrF,SAAS,EACZqF,EAAE,CAACpF,SAAS,EACZoF,EAAE,CAACnF,UACL,CAAC;QACDkF,QAAQ,GAAGA,QAAQ,IAAIE,UAAU;MACnC;IACF;;IAEA;IACA;IACA;IACA;IACA;IACA,IACElN,cAAc,CAAC,CAAC,IAChB+M,SAAS,IACTC,QAAQ,IACR,IAAI,CAAC5E,qBAAqB,EAC1B;MACA6D,KAAK,CAACU,MAAM,CAACQ,MAAM,GAAG;QACpBtJ,CAAC,EAAE,CAAC;QACJC,CAAC,EAAE,CAAC;QACJ+G,KAAK,EAAEoB,KAAK,CAACU,MAAM,CAAC9B,KAAK;QACzBD,MAAM,EAAEqB,KAAK,CAACU,MAAM,CAAC/B;MACvB,CAAC;IACH;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIwC,SAAS,GAAG,IAAI,CAAC3G,UAAU;IAC/B,IAAI,IAAI,CAACyB,eAAe,EAAE;MACxBkF,SAAS,GAAG;QAAE,GAAG,IAAI,CAAC3G,UAAU;QAAE4G,MAAM,EAAE3J;MAAyB,CAAC;IACtE;IAEA,MAAM4J,KAAK,GAAG1G,WAAW,CAACC,GAAG,CAAC,CAAC;IAC/B,MAAM0G,IAAI,GAAG,IAAI,CAAClI,GAAG,CAAC6F,MAAM,CAC1BkC,SAAS,EACTnB,KAAK,EACL,IAAI,CAAC/D,eAAe;IACpB;IACA;IACA;IACA;IACAjG,qBACF,CAAC;IACD,MAAMuL,MAAM,GAAG5G,WAAW,CAACC,GAAG,CAAC,CAAC,GAAGyG,KAAK;IACxC;IACA,IAAI,CAAC5G,SAAS,GAAG,IAAI,CAACD,UAAU;IAChC,IAAI,CAACA,UAAU,GAAGwF,KAAK;;IAEvB;IACA;IACA;IACA,IAAIF,WAAW,GAAG,IAAI,CAACpF,iBAAiB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE;MACxD,IAAI,CAAC8G,UAAU,CAAC,CAAC;MACjB,IAAI,CAAC9G,iBAAiB,GAAGoF,WAAW;IACtC;IAEA,MAAM2B,QAAQ,EAAE5O,UAAU,CAAC,UAAU,CAAC,GAAG,EAAE;IAC3C,KAAK,MAAM6O,KAAK,IAAIJ,IAAI,EAAE;MACxB,IAAII,KAAK,CAAC1J,IAAI,KAAK,eAAe,EAAE;QAClCyJ,QAAQ,CAACE,IAAI,CAAC;UACZC,aAAa,EAAE5B,KAAK,CAACU,MAAM,CAAC/B,MAAM;UAClCkD,eAAe,EAAE7B,KAAK,CAACtB,QAAQ,CAACC,MAAM;UACtCS,MAAM,EAAEsC,KAAK,CAACtC;QAChB,CAAC,CAAC;QACF,IAAI1L,sBAAsB,CAAC,CAAC,IAAIgO,KAAK,CAACI,KAAK,EAAE;UAC3C,MAAMC,KAAK,GAAGvP,GAAG,CAACwP,mBAAmB,CACnC,IAAI,CAACrI,QAAQ,EACb+H,KAAK,CAACI,KAAK,CAACG,QACd,CAAC;UACDjQ,eAAe,CACb,0BAA0B0P,KAAK,CAACtC,MAAM,UAAUsC,KAAK,CAACI,KAAK,CAACG,QAAQ,IAAI,GACtE,YAAYP,KAAK,CAACI,KAAK,CAACI,QAAQ,KAAK,GACrC,YAAYR,KAAK,CAACI,KAAK,CAACK,QAAQ,KAAK,GACrC,cAAcJ,KAAK,CAACK,MAAM,GAAGL,KAAK,CAACM,IAAI,CAAC,KAAK,CAAC,GAAG,2BAA2B,EAAE,EAChF;YAAEC,KAAK,EAAE;UAAO,CAClB,CAAC;QACH;MACF;IACF;IAEA,MAAMC,SAAS,GAAG5H,WAAW,CAACC,GAAG,CAAC,CAAC;IACnC,MAAM4H,SAAS,GAAGrP,QAAQ,CAACmO,IAAI,CAAC;IAChC,MAAMmB,UAAU,GAAG9H,WAAW,CAACC,GAAG,CAAC,CAAC,GAAG2H,SAAS;IAChD,MAAMG,OAAO,GAAGF,SAAS,CAACJ,MAAM,GAAG,CAAC;IACpC,IAAI,IAAI,CAACnG,eAAe,IAAIyG,OAAO,EAAE;MACnC;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAI,IAAI,CAACtG,qBAAqB,EAAE;QAC9B,IAAI,CAACA,qBAAqB,GAAG,KAAK;QAClCoG,SAAS,CAACG,OAAO,CAACxK,qBAAqB,CAAC;MAC1C,CAAC,MAAM;QACLqK,SAAS,CAACG,OAAO,CAAC5K,iBAAiB,CAAC;MACtC;MACAyK,SAAS,CAACb,IAAI,CAAC,IAAI,CAACrG,kBAAkB,CAAC;IACzC;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMsH,IAAI,GAAG,IAAI,CAACvG,iBAAiB;IACnC,MAAMwG,IAAI,GAAGD,IAAI,KAAK,IAAI,GAAG1P,SAAS,CAAC4P,GAAG,CAACF,IAAI,CAACG,IAAI,CAAC,GAAGC,SAAS;IACjE,MAAMrF,MAAM,GACViF,IAAI,KAAK,IAAI,IAAIC,IAAI,KAAKG,SAAS,GAC/B;MAAEpL,CAAC,EAAEiL,IAAI,CAACjL,CAAC,GAAGgL,IAAI,CAACK,SAAS;MAAEpL,CAAC,EAAEgL,IAAI,CAAChL,CAAC,GAAG+K,IAAI,CAACM;IAAU,CAAC,GAC1D,IAAI;IACV,MAAMC,MAAM,GAAG,IAAI,CAAC7G,aAAa;;IAEjC;IACA;IACA,MAAM8G,WAAW,GACfzF,MAAM,KAAK,IAAI,KACdwF,MAAM,KAAK,IAAI,IAAIA,MAAM,CAACvL,CAAC,KAAK+F,MAAM,CAAC/F,CAAC,IAAIuL,MAAM,CAACtL,CAAC,KAAK8F,MAAM,CAAC9F,CAAC,CAAC;IACrE,IAAI6K,OAAO,IAAIU,WAAW,IAAKzF,MAAM,KAAK,IAAI,IAAIwF,MAAM,KAAK,IAAK,EAAE;MAClE;MACA;MACA;MACA;MACA,IAAIA,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,CAAClH,eAAe,IAAIyG,OAAO,EAAE;QACvD,MAAMW,GAAG,GAAGlC,SAAS,CAACC,MAAM,CAACxJ,CAAC,GAAGuL,MAAM,CAACvL,CAAC;QACzC,MAAM0L,GAAG,GAAGnC,SAAS,CAACC,MAAM,CAACvJ,CAAC,GAAGsL,MAAM,CAACtL,CAAC;QACzC,IAAIwL,GAAG,KAAK,CAAC,IAAIC,GAAG,KAAK,CAAC,EAAE;UAC1Bd,SAAS,CAACG,OAAO,CAAC;YAAE3K,IAAI,EAAE,QAAQ;YAAEE,OAAO,EAAE7B,UAAU,CAACgN,GAAG,EAAEC,GAAG;UAAE,CAAC,CAAC;QACtE;MACF;MAEA,IAAI3F,MAAM,KAAK,IAAI,EAAE;QACnB,IAAI,IAAI,CAAC1B,eAAe,EAAE;UACxB;UACA;UACA,MAAMoE,GAAG,GAAGkD,IAAI,CAACC,GAAG,CAACD,IAAI,CAACE,GAAG,CAAC9F,MAAM,CAAC9F,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAEQ,YAAY,CAAC;UAC7D,MAAMqL,GAAG,GAAGH,IAAI,CAACC,GAAG,CAACD,IAAI,CAACE,GAAG,CAAC9F,MAAM,CAAC/F,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAEmI,aAAa,CAAC;UAC9DyC,SAAS,CAACb,IAAI,CAAC;YAAE3J,IAAI,EAAE,QAAQ;YAAEE,OAAO,EAAE5B,cAAc,CAAC+J,GAAG,EAAEqD,GAAG;UAAE,CAAC,CAAC;QACvE,CAAC,MAAM;UACL;UACA;UACA;UACA,MAAMC,IAAI,GACR,CAACjB,OAAO,IAAIS,MAAM,KAAK,IAAI,GACvBA,MAAM,GACN;YAAEvL,CAAC,EAAEoI,KAAK,CAACoB,MAAM,CAACxJ,CAAC;YAAEC,CAAC,EAAEmI,KAAK,CAACoB,MAAM,CAACvJ;UAAE,CAAC;UAC9C,MAAM+L,EAAE,GAAGjG,MAAM,CAAC/F,CAAC,GAAG+L,IAAI,CAAC/L,CAAC;UAC5B,MAAMiM,EAAE,GAAGlG,MAAM,CAAC9F,CAAC,GAAG8L,IAAI,CAAC9L,CAAC;UAC5B,IAAI+L,EAAE,KAAK,CAAC,IAAIC,EAAE,KAAK,CAAC,EAAE;YACxBrB,SAAS,CAACb,IAAI,CAAC;cAAE3J,IAAI,EAAE,QAAQ;cAAEE,OAAO,EAAE7B,UAAU,CAACuN,EAAE,EAAEC,EAAE;YAAE,CAAC,CAAC;UACjE;QACF;QACA,IAAI,CAACvH,aAAa,GAAGqB,MAAM;MAC7B,CAAC,MAAM;QACL;QACA;QACA;QACA;QACA;QACA;QACA;QACA,IAAIwF,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,CAAClH,eAAe,IAAI,CAACyG,OAAO,EAAE;UACxD,MAAMoB,GAAG,GAAG9D,KAAK,CAACoB,MAAM,CAACxJ,CAAC,GAAGuL,MAAM,CAACvL,CAAC;UACrC,MAAMmM,GAAG,GAAG/D,KAAK,CAACoB,MAAM,CAACvJ,CAAC,GAAGsL,MAAM,CAACtL,CAAC;UACrC,IAAIiM,GAAG,KAAK,CAAC,IAAIC,GAAG,KAAK,CAAC,EAAE;YAC1BvB,SAAS,CAACb,IAAI,CAAC;cAAE3J,IAAI,EAAE,QAAQ;cAAEE,OAAO,EAAE7B,UAAU,CAACyN,GAAG,EAAEC,GAAG;YAAE,CAAC,CAAC;UACnE;QACF;QACA,IAAI,CAACzH,aAAa,GAAG,IAAI;MAC3B;IACF;IAEA,MAAM0H,MAAM,GAAGrJ,WAAW,CAACC,GAAG,CAAC,CAAC;IAChCzE,mBAAmB,CACjB,IAAI,CAACkD,QAAQ,EACbmJ,SAAS,EACT,IAAI,CAACvG,eAAe,IAAI,CAACjG,qBAC3B,CAAC;IACD,MAAMiO,OAAO,GAAGtJ,WAAW,CAACC,GAAG,CAAC,CAAC,GAAGoJ,MAAM;;IAE1C;IACA;IACA;IACA;IACA,IAAI,CAAC7H,qBAAqB,GAAG2E,SAAS,IAAIC,QAAQ;;IAElD;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIf,KAAK,CAACkE,kBAAkB,EAAE;MAC5B,IAAI,CAACrJ,UAAU,GAAGE,UAAU,CAC1B,MAAM,IAAI,CAACgC,QAAQ,CAAC,CAAC,EACrBxK,iBAAiB,IAAI,CACvB,CAAC;IACH;IAEA,MAAM4R,MAAM,GAAG1Q,aAAa,CAAC,CAAC;IAC9B,MAAM2Q,QAAQ,GAAG5Q,eAAe,CAAC,CAAC;IAClC,MAAM6Q,EAAE,GAAG,IAAI,CAACrJ,gBAAgB;IAChC;IACApH,oBAAoB,CAAC,CAAC;IACtB,IAAI,CAACoH,gBAAgB,GAAG;MACtBC,EAAE,EAAE,CAAC;MACLC,OAAO,EAAE,CAAC;MACVC,QAAQ,EAAE,CAAC;MACXC,SAAS,EAAE,CAAC;MACZC,IAAI,EAAE;IACR,CAAC;IACD,IAAI,CAACmB,OAAO,CAACvD,OAAO,GAAG;MACrBqL,UAAU,EAAE3J,WAAW,CAACC,GAAG,CAAC,CAAC,GAAGkF,WAAW;MAC3CyE,MAAM,EAAE;QACNzK,QAAQ,EAAEoG,UAAU;QACpBoB,IAAI,EAAEC,MAAM;QACZpO,QAAQ,EAAEsP,UAAU;QACpB1D,KAAK,EAAEkF,OAAO;QACdO,OAAO,EAAElD,IAAI,CAACc,MAAM;QACpBqC,IAAI,EAAEN,MAAM;QACZO,MAAM,EAAEN,QAAQ;QAChBO,WAAW,EAAEN,EAAE,CAACnJ,OAAO;QACvB0J,YAAY,EAAEP,EAAE,CAAClJ,QAAQ;QACzB0J,aAAa,EAAER,EAAE,CAACjJ,SAAS;QAC3B0J,QAAQ,EAAET,EAAE,CAAChJ;MACf,CAAC;MACDoG;IACF,CAAC,CAAC;EACJ;EAEAlC,KAAKA,CAAA,CAAE,EAAE,IAAI,CAAC;IACZ;IACA;IACAjM,UAAU,CAACyR,uBAAuB,CAAC,CAAC;IACpC,IAAI,CAAChI,QAAQ,CAAC,CAAC;IAEf,IAAI,CAACtD,QAAQ,GAAG,IAAI;EACtB;EAEAmG,MAAMA,CAAA,CAAE,EAAE,IAAI,CAAC;IACb,IAAI,CAACnG,QAAQ,GAAG,KAAK;IACrB,IAAI,CAACsD,QAAQ,CAAC,CAAC;EACjB;;EAEA;AACF;AACA;AACA;AACA;EACE4C,OAAOA,CAAA,CAAE,EAAE,IAAI,CAAC;IACd,IAAI,CAACnF,UAAU,GAAG7H,UAAU,CAC1B,IAAI,CAAC6H,UAAU,CAACkE,QAAQ,CAACC,MAAM,EAC/B,IAAI,CAACnE,UAAU,CAACkE,QAAQ,CAACE,KAAK,EAC9B,IAAI,CAAC7E,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD,IAAI,CAACQ,SAAS,GAAG9H,UAAU,CACzB,IAAI,CAAC8H,SAAS,CAACiE,QAAQ,CAACC,MAAM,EAC9B,IAAI,CAAClE,SAAS,CAACiE,QAAQ,CAACE,KAAK,EAC7B,IAAI,CAAC7E,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD,IAAI,CAACb,GAAG,CAACyF,KAAK,CAAC,CAAC;IAChB;IACA;IACA;IACA,IAAI,CAACvC,aAAa,GAAG,IAAI;EAC3B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACE0I,WAAWA,CAAA,CAAE,EAAE,IAAI,CAAC;IAClB,IAAI,CAAC,IAAI,CAACxI,OAAO,CAACjE,MAAM,CAACqE,KAAK,IAAI,IAAI,CAACpD,WAAW,IAAI,IAAI,CAACC,QAAQ,EAAE;IACrE,IAAI,CAAC+C,OAAO,CAACjE,MAAM,CAACwG,KAAK,CAACpI,YAAY,GAAGP,WAAW,CAAC;IACrD,IAAI,IAAI,CAAC6F,eAAe,EAAE;MACxB,IAAI,CAAC+C,uBAAuB,CAAC,CAAC;IAChC,CAAC,MAAM;MACL,IAAI,CAACW,OAAO,CAAC,CAAC;MACd;MACA;MACA;MACA,IAAI,CAACxD,qBAAqB,GAAG,IAAI;IACnC;IACA,IAAI,CAACY,QAAQ,CAAC,CAAC;EACjB;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEkI,mBAAmBA,CAAA,CAAE,EAAE,IAAI,CAAC;IAC1B,IAAI,CAAC9I,qBAAqB,GAAG,IAAI;EACnC;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACE+I,kBAAkBA,CAACC,MAAM,EAAE,OAAO,EAAEC,aAAa,GAAG,KAAK,CAAC,EAAE,IAAI,CAAC;IAC/D,IAAI,IAAI,CAACnJ,eAAe,KAAKkJ,MAAM,EAAE;IACrC,IAAI,CAAClJ,eAAe,GAAGkJ,MAAM;IAC7B,IAAI,CAACjJ,sBAAsB,GAAGiJ,MAAM,IAAIC,aAAa;IACrD,IAAID,MAAM,EAAE;MACV,IAAI,CAACnG,uBAAuB,CAAC,CAAC;IAChC,CAAC,MAAM;MACL,IAAI,CAACW,OAAO,CAAC,CAAC;IAChB;EACF;EAEA,IAAI0F,iBAAiBA,CAAA,CAAE,EAAE,OAAO,CAAC;IAC/B,OAAO,IAAI,CAACpJ,eAAe;EAC7B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEqJ,qBAAqB,GAAGA,CAACC,gBAAgB,GAAG,KAAK,CAAC,EAAE,IAAI,IAAI;IAC1D,IAAI,CAAC,IAAI,CAAC/I,OAAO,CAACjE,MAAM,CAACqE,KAAK,EAAE;IAChC;IACA;IACA;IACA,IAAI,IAAI,CAACnD,QAAQ,EAAE;IACnB;IACA;IACA;IACA;IACA,IAAIxD,oBAAoB,CAAC,CAAC,EAAE;MAC1B,IAAI,CAACuG,OAAO,CAACjE,MAAM,CAACwG,KAAK,CACvBxI,sBAAsB,GACpBE,qBAAqB,GACrBC,wBACJ,CAAC;IACH;IACA,IAAI,CAAC,IAAI,CAACuF,eAAe,EAAE;IAC3B;IACA,IAAI,IAAI,CAACC,sBAAsB,EAAE;MAC/B,IAAI,CAACM,OAAO,CAACjE,MAAM,CAACwG,KAAK,CAAChI,qBAAqB,CAAC;IAClD;IACA;IACA;IACA,IAAIwO,gBAAgB,EAAE;MACpB,IAAI,CAAC9G,gBAAgB,CAAC,CAAC;IACzB;EACF,CAAC;;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE+G,iBAAiBA,CAAA,CAAE,EAAE,IAAI,CAAC;IACxB,IAAI,CAAChM,WAAW,GAAG,IAAI;IACvB;IACA;IACA,IAAI,CAACF,cAAc,CAACC,MAAM,GAAG,CAAC;IAC9B;IACA;IACA;IACA;IACA;IACA,MAAMb,KAAK,GAAG,IAAI,CAAC8D,OAAO,CAAC9D,KAAK,IAAIF,MAAM,CAACG,UAAU,GAAG;MACtD8M,KAAK,CAAC,EAAE,OAAO;MACfC,UAAU,CAAC,EAAE,CAACC,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI;IACnC,CAAC;IACD,IAAI,CAACC,UAAU,CAAC,CAAC;IACjB,IAAIlN,KAAK,CAACkE,KAAK,IAAIlE,KAAK,CAAC+M,KAAK,IAAI/M,KAAK,CAACgN,UAAU,EAAE;MAClDhN,KAAK,CAACgN,UAAU,CAAC,KAAK,CAAC;IACzB;EACF;;EAEA;EACAE,UAAUA,CAAA,CAAE,EAAE,IAAI,CAAC;IACjBA,UAAU,CAAC,IAAI,CAACpJ,OAAO,CAAC9D,KAAK,CAAC;EAChC;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACE,QAAQ+F,gBAAgBA,CAAA,CAAE,EAAE,IAAI,CAAC;IAC/B,IAAI,CAACjC,OAAO,CAACjE,MAAM,CAACwG,KAAK,CACvB/H,gBAAgB,GACdL,YAAY,GACZP,WAAW,IACV,IAAI,CAAC8F,sBAAsB,GAAGnF,qBAAqB,GAAG,EAAE,CAC7D,CAAC;IACD,IAAI,CAACiI,uBAAuB,CAAC,CAAC;EAChC;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,QAAQA,uBAAuBA,CAAA,CAAE,EAAE,IAAI,CAAC;IACtC,MAAMrC,IAAI,GAAG,IAAI,CAACtE,YAAY;IAC9B,MAAMyG,IAAI,GAAG,IAAI,CAACxE,eAAe;IACjC,MAAMuL,KAAK,GAAGA,CAAA,CAAE,EAAEjT,KAAK,KAAK;MAC1B8N,MAAM,EAAElM,YAAY,CAClBsK,IAAI,EACJnC,IAAI,EACJ,IAAI,CAAC5C,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;MACDyE,QAAQ,EAAE;QAAEE,KAAK,EAAEE,IAAI;QAAEH,MAAM,EAAEhC,IAAI,GAAG;MAAE,CAAC;MAC3CyE,MAAM,EAAE;QAAExJ,CAAC,EAAE,CAAC;QAAEC,CAAC,EAAE,CAAC;QAAEC,OAAO,EAAE;MAAK;IACtC,CAAC,CAAC;IACF,IAAI,CAAC0C,UAAU,GAAGqL,KAAK,CAAC,CAAC;IACzB,IAAI,CAACpL,SAAS,GAAGoL,KAAK,CAAC,CAAC;IACxB,IAAI,CAACzM,GAAG,CAACyF,KAAK,CAAC,CAAC;IAChB;IACA;IACA;IACA,IAAI,CAACvC,aAAa,GAAG,IAAI;IACzB;IACA;IACA,IAAI,CAACH,qBAAqB,GAAG,IAAI;EACnC;;EAEA;AACF;AACA;AACA;AACA;EACE2J,oBAAoBA,CAAA,CAAE,EAAE,MAAM,CAAC;IAC7B,IAAI,CAACxQ,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC,EAAE,OAAO,EAAE;IAC5C,MAAMuK,IAAI,GAAG1Q,eAAe,CAAC,IAAI,CAACmG,SAAS,EAAE,IAAI,CAAChB,UAAU,CAACkG,MAAM,CAAC;IACpE,IAAIqF,IAAI,EAAE;MACR;MACA;MACA,KAAK1O,YAAY,CAAC0O,IAAI,CAAC,CAACC,IAAI,CAACC,GAAG,IAAI;QAClC,IAAIA,GAAG,EAAE,IAAI,CAACzJ,OAAO,CAACjE,MAAM,CAACwG,KAAK,CAACkH,GAAG,CAAC;MACzC,CAAC,CAAC;IACJ;IACA,OAAOF,IAAI;EACb;;EAEA;AACF;AACA;AACA;EACEG,aAAaA,CAAA,CAAE,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC5Q,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC,EAAE,OAAO,EAAE;IAC5C,MAAMuK,IAAI,GAAG,IAAI,CAACD,oBAAoB,CAAC,CAAC;IACxC9Q,cAAc,CAAC,IAAI,CAACwG,SAAS,CAAC;IAC9B,IAAI,CAAC2K,qBAAqB,CAAC,CAAC;IAC5B,OAAOJ,IAAI;EACb;;EAEA;EACAK,kBAAkBA,CAAA,CAAE,EAAE,IAAI,CAAC;IACzB,IAAI,CAAC9Q,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC,EAAE;IACnCxG,cAAc,CAAC,IAAI,CAACwG,SAAS,CAAC;IAC9B,IAAI,CAAC2K,qBAAqB,CAAC,CAAC;EAC9B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEE,kBAAkBA,CAACC,KAAK,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IACtC,IAAI,IAAI,CAAC7K,oBAAoB,KAAK6K,KAAK,EAAE;IACzC,IAAI,CAAC7K,oBAAoB,GAAG6K,KAAK;IACjC,IAAI,CAAChN,cAAc,CAAC,CAAC;EACvB;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEiN,kBAAkBA,CAACC,EAAE,EAAEhU,GAAG,CAACoH,UAAU,CAAC,EAAE3F,aAAa,EAAE,CAAC;IACtD,IAAI,CAAC,IAAI,CAACwH,oBAAoB,IAAI,CAAC+K,EAAE,CAACzI,QAAQ,EAAE,OAAO,EAAE;IACzD,MAAMa,KAAK,GAAG2E,IAAI,CAACkD,IAAI,CAACD,EAAE,CAACzI,QAAQ,CAAC2I,gBAAgB,CAAC,CAAC,CAAC;IACvD,MAAM/H,MAAM,GAAG4E,IAAI,CAACkD,IAAI,CAACD,EAAE,CAACzI,QAAQ,CAAC4I,iBAAiB,CAAC,CAAC,CAAC;IACzD,IAAI/H,KAAK,IAAI,CAAC,IAAID,MAAM,IAAI,CAAC,EAAE,OAAO,EAAE;IACxC;IACA;IACA,MAAMiI,MAAM,GAAGJ,EAAE,CAACzI,QAAQ,CAAC8I,eAAe,CAAC,CAAC;IAC5C,MAAMC,KAAK,GAAGN,EAAE,CAACzI,QAAQ,CAACgJ,cAAc,CAAC,CAAC;IAC1C,MAAMrG,MAAM,GAAGlM,YAAY,CACzBoK,KAAK,EACLD,MAAM,EACN,IAAI,CAAC5E,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD,MAAM+M,MAAM,GAAG,IAAI5T,MAAM,CAAC;MACxBwL,KAAK;MACLD,MAAM;MACN5E,SAAS,EAAE,IAAI,CAACA,SAAS;MACzB2G;IACF,CAAC,CAAC;IACF7M,kBAAkB,CAAC2S,EAAE,EAAEQ,MAAM,EAAE;MAC7BC,OAAO,EAAE,CAACL,MAAM;MAChBM,OAAO,EAAE,CAACJ,KAAK;MACfK,UAAU,EAAEnE;IACd,CAAC,CAAC;IACF,MAAMoE,QAAQ,GAAGJ,MAAM,CAAClE,GAAG,CAAC,CAAC;IAC7B;IACA;IACA;IACA;IACAtQ,GAAG,CAAC6U,SAAS,CAACb,EAAE,CAAC;IACjB,MAAM7K,SAAS,GAAGzH,aAAa,CAACkT,QAAQ,EAAE,IAAI,CAAC3L,oBAAoB,CAAC;IACpEzJ,eAAe,CACb,0BAA0B,IAAI,CAACyJ,oBAAoB,IAAI,GACrD,MAAMmD,KAAK,IAAID,MAAM,KAAKiI,MAAM,IAAIE,KAAK,OAAOnL,SAAS,CAACyG,MAAM,GAAG,GACnE,IAAIzG,SAAS,CACV2L,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CACZC,GAAG,CAACC,CAAC,IAAI,GAAGA,CAAC,CAACnH,GAAG,IAAImH,CAAC,CAAC9D,GAAG,EAAE,CAAC,CAC7BrB,IAAI,CAAC,GAAG,CAAC,EAAE,GACd,GAAG1G,SAAS,CAACyG,MAAM,GAAG,EAAE,GAAG,IAAI,GAAG,EAAE,GACxC,CAAC;IACD,OAAOzG,SAAS;EAClB;;EAEA;AACF;AACA;AACA;AACA;EACE8L,kBAAkBA,CAChBC,KAAK,EAAE;IACL/L,SAAS,EAAE1H,aAAa,EAAE;IAC1B2H,SAAS,EAAE,MAAM;IACjBC,UAAU,EAAE,MAAM;EACpB,CAAC,GAAG,IAAI,CACT,EAAE,IAAI,CAAC;IACN,IAAI,CAACH,eAAe,GAAGgM,KAAK;IAC5B,IAAI,CAACpO,cAAc,CAAC,CAAC;EACvB;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEqO,mBAAmBA,CAACC,KAAK,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IACvC;IACA;IACA;IACA,MAAMC,OAAO,GAAG1V,QAAQ,CAAC,IAAI,EAAEyV,KAAK,EAAE,YAAY,CAAC;IACnD,MAAME,GAAG,GAAGD,OAAO,CAACE,OAAO,CAAC,IAAI,CAAC;IACjC,IAAID,GAAG,IAAI,CAAC,IAAIA,GAAG,KAAKD,OAAO,CAACzF,MAAM,GAAG,CAAC,EAAE;MAC1C,IAAI,CAACrI,SAAS,CAACiO,cAAc,CAAC,IAAI,CAAC;MACnC;IACF;IACA,IAAI,CAACjO,SAAS,CAACiO,cAAc,CAAC;MAC5BhQ,IAAI,EAAE,MAAM;MACZiQ,IAAI,EAAEJ,OAAO,CAACP,KAAK,CAAC,CAAC,EAAEQ,GAAG,CAAC;MAC3BI,OAAO,EAAEL,OAAO,CAACP,KAAK,CAACQ,GAAG,GAAG,CAAC,CAAC,CAAE;IACnC,CAAC,CAAC;IACF;IACA;IACA;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;EACE/S,mBAAmBA,CACjBoT,QAAQ,EAAE,MAAM,EAChBC,OAAO,EAAE,MAAM,EACfC,IAAI,EAAE,OAAO,GAAG,OAAO,CACxB,EAAE,IAAI,CAAC;IACNtT,mBAAmB,CACjB,IAAI,CAACyG,SAAS,EACd,IAAI,CAAChB,UAAU,CAACkG,MAAM,EACtByH,QAAQ,EACRC,OAAO,EACPC,IACF,CAAC;EACH;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEC,uBAAuBA,CAACC,IAAI,EAAE,MAAM,EAAEC,MAAM,EAAE,MAAM,EAAEC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IAC1E,MAAMC,MAAM,GAAGpT,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC;IAC3C5F,cAAc,CACZ,IAAI,CAAC4F,SAAS,EACd+M,IAAI,EACJC,MAAM,EACNC,MAAM,EACN,IAAI,CAACjO,UAAU,CAACkG,MAAM,CAAC9B,KACzB,CAAC;IACD;IACA;IACA;IACA;IACA,IAAI8J,MAAM,IAAI,CAACpT,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC,EAAE;MAC3C,IAAI,CAAC2K,qBAAqB,CAAC,CAAC;IAC9B;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEwC,kBAAkBA,CAACC,IAAI,EAAEzT,SAAS,CAAC,EAAE,IAAI,CAAC;IACxC,IAAI,CAAC,IAAI,CAAC8G,eAAe,EAAE;IAC3B,MAAM;MAAE0E;IAAM,CAAC,GAAG,IAAI,CAACnF,SAAS;IAChC,IAAI,CAACmF,KAAK,EAAE;IACZ,MAAM;MAAE/B,KAAK;MAAED;IAAO,CAAC,GAAG,IAAI,CAACnE,UAAU,CAACkG,MAAM;IAChD,MAAMmI,MAAM,GAAGjK,KAAK,GAAG,CAAC;IACxB,MAAM6J,MAAM,GAAG9J,MAAM,GAAG,CAAC;IACzB,IAAI;MAAE+E,GAAG;MAAErD;IAAI,CAAC,GAAGM,KAAK;IACxB,QAAQiI,IAAI;MACV,KAAK,MAAM;QACT,IAAIlF,GAAG,GAAG,CAAC,EAAEA,GAAG,EAAE,MACb,IAAIrD,GAAG,GAAG,CAAC,EAAE;UAChBqD,GAAG,GAAGmF,MAAM;UACZxI,GAAG,EAAE;QACP;QACA;MACF,KAAK,OAAO;QACV,IAAIqD,GAAG,GAAGmF,MAAM,EAAEnF,GAAG,EAAE,MAClB,IAAIrD,GAAG,GAAGoI,MAAM,EAAE;UACrB/E,GAAG,GAAG,CAAC;UACPrD,GAAG,EAAE;QACP;QACA;MACF,KAAK,IAAI;QACP,IAAIA,GAAG,GAAG,CAAC,EAAEA,GAAG,EAAE;QAClB;MACF,KAAK,MAAM;QACT,IAAIA,GAAG,GAAGoI,MAAM,EAAEpI,GAAG,EAAE;QACvB;MACF,KAAK,WAAW;QACdqD,GAAG,GAAG,CAAC;QACP;MACF,KAAK,SAAS;QACZA,GAAG,GAAGmF,MAAM;QACZ;IACJ;IACA,IAAInF,GAAG,KAAK/C,KAAK,CAAC+C,GAAG,IAAIrD,GAAG,KAAKM,KAAK,CAACN,GAAG,EAAE;IAC5C9K,SAAS,CAAC,IAAI,CAACiG,SAAS,EAAEkI,GAAG,EAAErD,GAAG,CAAC;IACnC,IAAI,CAAC8F,qBAAqB,CAAC,CAAC;EAC9B;;EAEA;EACA2C,gBAAgBA,CAAA,CAAE,EAAE,OAAO,CAAC;IAC1B,OAAOxT,YAAY,CAAC,IAAI,CAACkG,SAAS,CAAC;EACrC;;EAEA;AACF;AACA;AACA;EACEuN,0BAA0BA,CAAClI,EAAE,EAAE,GAAG,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IACrD,IAAI,CAAC/E,kBAAkB,CAACkN,GAAG,CAACnI,EAAE,CAAC;IAC/B,OAAO,MAAM,IAAI,CAAC/E,kBAAkB,CAACmN,MAAM,CAACpI,EAAE,CAAC;EACjD;EAEA,QAAQsF,qBAAqBA,CAAA,CAAE,EAAE,IAAI,CAAC;IACpC,IAAI,CAACpJ,QAAQ,CAAC,CAAC;IACf,KAAK,MAAM8D,EAAE,IAAI,IAAI,CAAC/E,kBAAkB,EAAE+E,EAAE,CAAC,CAAC;EAChD;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACE/N,aAAaA,CAAC4Q,GAAG,EAAE,MAAM,EAAErD,GAAG,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAC/C,IAAI,CAAC,IAAI,CAACpE,eAAe,EAAE,OAAO,KAAK;IACvC,MAAM4J,KAAK,GAAGnR,aAAa,CAAC,IAAI,CAAC8F,UAAU,CAACkG,MAAM,EAAEgD,GAAG,EAAErD,GAAG,CAAC;IAC7D,OAAOvN,aAAa,CAAC,IAAI,CAAC6G,QAAQ,EAAE+J,GAAG,EAAErD,GAAG,EAAEwF,KAAK,CAAC;EACtD;EAEA9S,aAAaA,CAAC2Q,GAAG,EAAE,MAAM,EAAErD,GAAG,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IAC5C,IAAI,CAAC,IAAI,CAACpE,eAAe,EAAE;IAC3BlJ,aAAa,CAAC,IAAI,CAAC4G,QAAQ,EAAE+J,GAAG,EAAErD,GAAG,EAAE,IAAI,CAACrE,YAAY,CAAC;EAC3D;EAEAkN,qBAAqBA,CAACC,SAAS,EAAE9V,SAAS,CAAC,EAAE,IAAI,CAAC;IAChD,MAAMsK,MAAM,GAAG,IAAI,CAAC9D,YAAY,CAACuP,aAAa,IAAI,IAAI,CAACzP,QAAQ;IAC/D,MAAMT,KAAK,GAAG,IAAIzG,aAAa,CAAC0W,SAAS,CAAC;IAC1C5V,UAAU,CAACqK,gBAAgB,CAACD,MAAM,EAAEzE,KAAK,CAAC;;IAE1C;IACA;IACA,IACE,CAACA,KAAK,CAACmQ,gBAAgB,IACvBF,SAAS,CAACG,IAAI,KAAK,KAAK,IACxB,CAACH,SAAS,CAACI,IAAI,IACf,CAACJ,SAAS,CAACK,IAAI,EACf;MACA,IAAIL,SAAS,CAACM,KAAK,EAAE;QACnB,IAAI,CAAC5P,YAAY,CAAC6P,aAAa,CAAC,IAAI,CAAC/P,QAAQ,CAAC;MAChD,CAAC,MAAM;QACL,IAAI,CAACE,YAAY,CAAC8P,SAAS,CAAC,IAAI,CAAChQ,QAAQ,CAAC;MAC5C;IACF;EACF;EACA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEiQ,cAAcA,CAAClG,GAAG,EAAE,MAAM,EAAErD,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3D,IAAI,CAAC,IAAI,CAACpE,eAAe,EAAE,OAAO+G,SAAS;IAC3C,MAAMtC,MAAM,GAAG,IAAI,CAAClG,UAAU,CAACkG,MAAM;IACrC,MAAMmJ,IAAI,GAAGtV,MAAM,CAACmM,MAAM,EAAEgD,GAAG,EAAErD,GAAG,CAAC;IACrC,IAAIyJ,GAAG,GAAGD,IAAI,EAAEE,SAAS;IACzB;IACA;IACA,IAAI,CAACD,GAAG,IAAID,IAAI,EAAEjL,KAAK,KAAKvK,SAAS,CAAC2V,UAAU,IAAItG,GAAG,GAAG,CAAC,EAAE;MAC3DoG,GAAG,GAAGvV,MAAM,CAACmM,MAAM,EAAEgD,GAAG,GAAG,CAAC,EAAErD,GAAG,CAAC,EAAE0J,SAAS;IAC/C;IACA,OAAOD,GAAG,IAAI1U,kBAAkB,CAACsL,MAAM,EAAEgD,GAAG,EAAErD,GAAG,CAAC;EACpD;;EAEA;AACF;AACA;AACA;EACE4J,gBAAgB,EAAE,CAAC,CAACH,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,SAAS;;EAErD;AACF;AACA;AACA;AACA;EACEI,aAAaA,CAACJ,GAAG,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IAC/B,IAAI,CAACG,gBAAgB,GAAGH,GAAG,CAAC;EAC9B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEK,gBAAgBA,CAACzG,GAAG,EAAE,MAAM,EAAErD,GAAG,EAAE,MAAM,EAAE+J,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC;IAC7D,IAAI,CAAC,IAAI,CAACnO,eAAe,EAAE;IAC3B,MAAMyE,MAAM,GAAG,IAAI,CAAClG,UAAU,CAACkG,MAAM;IACrC;IACA;IACA;IACA5K,cAAc,CAAC,IAAI,CAAC0F,SAAS,EAAEkI,GAAG,EAAErD,GAAG,CAAC;IACxC,IAAI+J,KAAK,KAAK,CAAC,EAAE1U,YAAY,CAAC,IAAI,CAAC8F,SAAS,EAAEkF,MAAM,EAAEgD,GAAG,EAAErD,GAAG,CAAC,MAC1D5K,YAAY,CAAC,IAAI,CAAC+F,SAAS,EAAEkF,MAAM,EAAEL,GAAG,CAAC;IAC9C;IACA;IACA,IAAI,CAAC,IAAI,CAAC7E,SAAS,CAACmF,KAAK,EAAE,IAAI,CAACnF,SAAS,CAACmF,KAAK,GAAG,IAAI,CAACnF,SAAS,CAAC4E,MAAM;IACvE,IAAI,CAAC+F,qBAAqB,CAAC,CAAC;EAC9B;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEkE,mBAAmBA,CAAC3G,GAAG,EAAE,MAAM,EAAErD,GAAG,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IAClD,IAAI,CAAC,IAAI,CAACpE,eAAe,EAAE;IAC3B,MAAMqO,GAAG,GAAG,IAAI,CAAC9O,SAAS;IAC1B,IAAI8O,GAAG,CAACC,UAAU,EAAE;MAClBrV,eAAe,CAACoV,GAAG,EAAE,IAAI,CAAC9P,UAAU,CAACkG,MAAM,EAAEgD,GAAG,EAAErD,GAAG,CAAC;IACxD,CAAC,MAAM;MACLtK,eAAe,CAACuU,GAAG,EAAE5G,GAAG,EAAErD,GAAG,CAAC;IAChC;IACA,IAAI,CAAC8F,qBAAqB,CAAC,CAAC;EAC9B;;EAEA;EACA;EACA,QAAQqE,cAAc,EAAEC,KAAK,CAAC;IAC5BvR,KAAK,EAAE,MAAM;IACbwR,QAAQ,EAAE,CAAC,GAAGC,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI;EACxC,CAAC,CAAC,GAAG,EAAE;EACP,QAAQC,UAAU,GAAG,KAAK;EAE1BpL,YAAYA,CAAA,CAAE,EAAE,IAAI,CAAC;IACnB,MAAM9G,KAAK,GAAG,IAAI,CAAC8D,OAAO,CAAC9D,KAAK;IAChC,IAAI,CAACA,KAAK,CAACkE,KAAK,EAAE;MAChB;IACF;;IAEA;IACA;IACA,MAAMiO,iBAAiB,GAAGnS,KAAK,CAACoS,SAAS,CAAC,UAAU,CAAC;IACrD9Y,eAAe,CACb,kCAAkC6Y,iBAAiB,CAACzI,MAAM,qCAAqC,CAAC1J,KAAK,IAAIF,MAAM,CAACG,UAAU,GAAG;MAAE8M,KAAK,CAAC,EAAE,OAAO;IAAC,CAAC,EAAEA,KAAK,IAAI,KAAK,EAClK,CAAC;IACDoF,iBAAiB,CAACE,OAAO,CAACL,QAAQ,IAAI;MACpC,IAAI,CAACF,cAAc,CAAC7I,IAAI,CAAC;QACvBzI,KAAK,EAAE,UAAU;QACjBwR,QAAQ,EAAEA,QAAQ,IAAI,CAAC,GAAGC,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG;MAChD,CAAC,CAAC;MACFjS,KAAK,CAACsS,cAAc,CAAC,UAAU,EAAEN,QAAQ,IAAI,CAAC,GAAGC,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC;IAC5E,CAAC,CAAC;;IAEF;IACA,MAAMM,YAAY,GAAGvS,KAAK,IAAIF,MAAM,CAACG,UAAU,GAAG;MAChD8M,KAAK,CAAC,EAAE,OAAO;MACfC,UAAU,CAAC,EAAE,CAACwF,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IACtC,CAAC;IACD,IAAID,YAAY,CAACxF,KAAK,IAAIwF,YAAY,CAACvF,UAAU,EAAE;MACjDuF,YAAY,CAACvF,UAAU,CAAC,KAAK,CAAC;MAC9B,IAAI,CAACkF,UAAU,GAAG,IAAI;IACxB;EACF;EAEAlL,WAAWA,CAAA,CAAE,EAAE,IAAI,CAAC;IAClB,MAAMhH,KAAK,GAAG,IAAI,CAAC8D,OAAO,CAAC9D,KAAK;IAChC,IAAI,CAACA,KAAK,CAACkE,KAAK,EAAE;MAChB;IACF;;IAEA;IACA,IAAI,IAAI,CAAC4N,cAAc,CAACpI,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAACwI,UAAU,EAAE;MACxD5Y,eAAe,CACb,6FAA6F,EAC7F;QAAEsQ,KAAK,EAAE;MAAO,CAClB,CAAC;IACH;IACAtQ,eAAe,CACb,qCAAqC,IAAI,CAACwY,cAAc,CAACpI,MAAM,4BAA4B,IAAI,CAACwI,UAAU,EAC5G,CAAC;IACD,IAAI,CAACJ,cAAc,CAACO,OAAO,CAAC,CAAC;MAAE7R,KAAK;MAAEwR;IAAS,CAAC,KAAK;MACnDhS,KAAK,CAACyS,WAAW,CAACjS,KAAK,EAAEwR,QAAQ,CAAC;IACpC,CAAC,CAAC;IACF,IAAI,CAACF,cAAc,GAAG,EAAE;;IAExB;IACA,IAAI,IAAI,CAACI,UAAU,EAAE;MACnB,MAAMK,YAAY,GAAGvS,KAAK,IAAIF,MAAM,CAACG,UAAU,GAAG;QAChD+M,UAAU,CAAC,EAAE,CAACwF,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;MACtC,CAAC;MACD,IAAID,YAAY,CAACvF,UAAU,EAAE;QAC3BuF,YAAY,CAACvF,UAAU,CAAC,IAAI,CAAC;MAC/B;MACA,IAAI,CAACkF,UAAU,GAAG,KAAK;IACzB;EACF;;EAEA;EACA;EACA;EACA;EACA,QAAQQ,QAAQA,CAACC,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC;IACnC,IAAI,CAAC7O,OAAO,CAACjE,MAAM,CAACwG,KAAK,CAACsM,IAAI,CAAC;EACjC;EAEA,QAAQC,oBAAoB,EAAEhZ,uBAAuB,GAAGgZ,CACtD1I,IAAI,EACJ2I,WAAW,KACR;IACH,IACE3I,IAAI,KAAK,IAAI,IACb2I,WAAW,KAAKvI,SAAS,IACzB,IAAI,CAAC3G,iBAAiB,EAAE0G,IAAI,KAAKwI,WAAW,EAC5C;MACA;IACF;IACA,IAAI,CAAClP,iBAAiB,GAAGuG,IAAI;EAC/B,CAAC;EAED3D,MAAMA,CAAC8D,IAAI,EAAErR,SAAS,CAAC,EAAE,IAAI,CAAC;IAC5B,IAAI,CAAC6I,WAAW,GAAGwI,IAAI;IAEvB,MAAMyI,IAAI,GACR,CAAC,GAAG,CACF,KAAK,CAAC,CAAC,IAAI,CAAChP,OAAO,CAAC9D,KAAK,CAAC,CAC1B,MAAM,CAAC,CAAC,IAAI,CAAC8D,OAAO,CAACjE,MAAM,CAAC,CAC5B,MAAM,CAAC,CAAC,IAAI,CAACiE,OAAO,CAAC5D,MAAM,CAAC,CAC5B,WAAW,CAAC,CAAC,IAAI,CAAC4D,OAAO,CAAC3D,WAAW,CAAC,CACtC,MAAM,CAAC,CAAC,IAAI,CAACsE,OAAO,CAAC,CACrB,eAAe,CAAC,CAAC,IAAI,CAAC7C,eAAe,CAAC,CACtC,YAAY,CAAC,CAAC,IAAI,CAACjC,YAAY,CAAC,CAChC,SAAS,CAAC,CAAC,IAAI,CAACmD,SAAS,CAAC,CAC1B,iBAAiB,CAAC,CAAC,IAAI,CAAC2K,qBAAqB,CAAC,CAC9C,SAAS,CAAC,CAAC,IAAI,CAACrT,aAAa,CAAC,CAC9B,SAAS,CAAC,CAAC,IAAI,CAACC,aAAa,CAAC,CAC9B,cAAc,CAAC,CAAC,IAAI,CAAC6W,cAAc,CAAC,CACpC,eAAe,CAAC,CAAC,IAAI,CAACM,aAAa,CAAC,CACpC,YAAY,CAAC,CAAC,IAAI,CAACC,gBAAgB,CAAC,CACpC,eAAe,CAAC,CAAC,IAAI,CAACE,mBAAmB,CAAC,CAC1C,aAAa,CAAC,CAAC,IAAI,CAAC/E,qBAAqB,CAAC,CAC1C,mBAAmB,CAAC,CAAC,IAAI,CAACgG,oBAAoB,CAAC,CAC/C,qBAAqB,CAAC,CAAC,IAAI,CAACpC,qBAAqB,CAAC;AAE1D,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,IAAI,CAACkC,QAAQ,CAAC;AACpD,UAAU,CAACrI,IAAI;AACf,QAAQ,EAAE,qBAAqB;AAC/B,MAAM,EAAE,GAAG,CACN;;IAED;IACAzP,UAAU,CAACmY,mBAAmB,CAACD,IAAI,EAAE,IAAI,CAAC9R,SAAS,EAAE,IAAI,EAAEnI,IAAI,CAAC;IAChE;IACA+B,UAAU,CAACoY,aAAa,CAAC,CAAC;EAC5B;EAEAvO,OAAOA,CAACwO,KAA6B,CAAvB,EAAEtM,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC;IAC3C,IAAI,IAAI,CAAC7F,WAAW,EAAE;MACpB;IACF;IAEA,IAAI,CAACuD,QAAQ,CAAC,CAAC;IACf,IAAI,CAACG,eAAe,CAAC,CAAC;IAEtB,IAAI,OAAO,IAAI,CAAC/C,cAAc,KAAK,UAAU,EAAE;MAC7C,IAAI,CAACA,cAAc,CAAC,CAAC;IACvB;IACA,IAAI,CAACC,aAAa,GAAG,CAAC;IAEtB,IAAI,CAACC,sBAAsB,GAAG,CAAC;;IAE/B;IACA;IACA,MAAMiH,IAAI,GAAG,IAAI,CAAClI,GAAG,CAACwS,+BAA+B,CAAC,IAAI,CAACpR,UAAU,CAAC;IACtErE,mBAAmB,CAAC,IAAI,CAACkD,QAAQ,EAAElG,QAAQ,CAACmO,IAAI,CAAC,CAAC;;IAElD;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAI,IAAI,CAAC9E,OAAO,CAACjE,MAAM,CAACqE,KAAK,EAAE;MAC7B,IAAI,IAAI,CAACX,eAAe,EAAE;QACxB;QACA;QACA3K,SAAS,CAAC,CAAC,EAAE2F,eAAe,CAAC;MAC/B;MACA;MACA;MACA;MACA3F,SAAS,CAAC,CAAC,EAAEwF,sBAAsB,CAAC;MACpC;MACA,IAAI,CAAC8O,UAAU,CAAC,CAAC;MACjB;MACAtU,SAAS,CAAC,CAAC,EAAEkF,yBAAyB,CAAC;MACvClF,SAAS,CAAC,CAAC,EAAEiF,sBAAsB,CAAC;MACpC;MACAjF,SAAS,CAAC,CAAC,EAAEuF,GAAG,CAAC;MACjB;MACAvF,SAAS,CAAC,CAAC,EAAEsF,GAAG,CAAC;MACjB;MACAtF,SAAS,CAAC,CAAC,EAAE4F,WAAW,CAAC;MACzB;MACA5F,SAAS,CAAC,CAAC,EAAE6F,qBAAqB,CAAC;MACnC;MACA,IAAIG,iBAAiB,CAAC,CAAC,EACrBhG,SAAS,CAAC,CAAC,EAAEiG,kBAAkB,CAACH,gBAAgB,CAAC,CAAC;IACtD;IACA;;IAEA,IAAI,CAACoC,WAAW,GAAG,IAAI;;IAEvB;IACA,IAAI,CAACF,cAAc,CAACC,MAAM,GAAG,CAAC;IAC9B,IAAI,IAAI,CAACsB,UAAU,KAAK,IAAI,EAAE;MAC5BgF,YAAY,CAAC,IAAI,CAAChF,UAAU,CAAC;MAC7B,IAAI,CAACA,UAAU,GAAG,IAAI;IACxB;;IAEA;IACAvH,UAAU,CAACmY,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC/R,SAAS,EAAE,IAAI,EAAEnI,IAAI,CAAC;IAChE;IACA+B,UAAU,CAACoY,aAAa,CAAC,CAAC;IAC1B1Y,SAAS,CAACiW,MAAM,CAAC,IAAI,CAACzM,OAAO,CAACjE,MAAM,CAAC;;IAErC;IACA;IACA;IACA,IAAI,CAACoB,QAAQ,CAACoE,QAAQ,EAAE8N,IAAI,CAAC,CAAC;IAC9B,IAAI,CAAClS,QAAQ,CAACoE,QAAQ,GAAGiF,SAAS;IAElC,IAAI2I,KAAK,YAAYtM,KAAK,EAAE;MAC1B,IAAI,CAACF,iBAAiB,CAACwM,KAAK,CAAC;IAC/B,CAAC,MAAM;MACL,IAAI,CAACzM,kBAAkB,CAAC,CAAC;IAC3B;EACF;EAEA,MAAMnG,aAAaA,CAAA,CAAE,EAAEC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,CAACkB,WAAW,KAAK,IAAIlB,OAAO,CAAC,CAAC8S,OAAO,EAAEC,MAAM,KAAK;MACpD,IAAI,CAAC7M,kBAAkB,GAAG4M,OAAO;MACjC,IAAI,CAAC3M,iBAAiB,GAAG4M,MAAM;IACjC,CAAC,CAAC;IAEF,OAAO,IAAI,CAAC7R,WAAW;EACzB;EAEA8R,cAAcA,CAAA,CAAE,EAAE,IAAI,CAAC;IACrB,IAAI,IAAI,CAACxP,OAAO,CAACjE,MAAM,CAACqE,KAAK,EAAE;MAC7B;MACA,IAAI,CAACnC,SAAS,GAAG,IAAI,CAACD,UAAU;MAChC,IAAI,CAACA,UAAU,GAAG7H,UAAU,CAC1B,IAAI,CAAC6H,UAAU,CAACkE,QAAQ,CAACC,MAAM,EAC/B,IAAI,CAACnE,UAAU,CAACkE,QAAQ,CAACE,KAAK,EAC9B,IAAI,CAAC7E,SAAS,EACd,IAAI,CAACC,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;MACD,IAAI,CAACb,GAAG,CAACyF,KAAK,CAAC,CAAC;MAChB;MACA;MACA,IAAI,CAACvC,aAAa,GAAG,IAAI;IAC3B;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEkF,UAAUA,CAAA,CAAE,EAAE,IAAI,CAAC;IACjB,IAAI,CAACxH,QAAQ,GAAG,IAAI1F,QAAQ,CAAC,CAAC;IAC9B,IAAI,CAAC2F,aAAa,GAAG,IAAIxF,aAAa,CAAC,CAAC;IACxCE,kBAAkB,CAChB,IAAI,CAAC6F,UAAU,CAACkG,MAAM,EACtB,IAAI,CAAC1G,QAAQ,EACb,IAAI,CAACC,aACP,CAAC;IACD;IACA;IACA;IACA,IAAI,CAACQ,SAAS,CAACiG,MAAM,CAAC1G,QAAQ,GAAG,IAAI,CAACA,QAAQ;IAC9C,IAAI,CAACS,SAAS,CAACiG,MAAM,CAACzG,aAAa,GAAG,IAAI,CAACA,aAAa;EAC1D;EAEAnB,YAAYA,CAAA,CAAE,EAAE,GAAG,GAAG,IAAI,CAAC;IACzB;IACA,MAAMmT,GAAG,GAAGC,OAAO;IACnB,MAAMC,SAAS,EAAEC,OAAO,CAACC,MAAM,CAAC,MAAMC,OAAO,EAAEA,OAAO,CAAC,MAAMA,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC5E,MAAMC,OAAO,GAAGA,CAAC,GAAG5B,IAAI,EAAE,OAAO,EAAE,KACjC3Y,eAAe,CAAC,gBAAgBE,MAAM,CAAC,GAAGyY,IAAI,CAAC,EAAE,CAAC;IACpD,MAAM6B,OAAO,GAAGA,CAAC,GAAG7B,IAAI,EAAE,OAAO,EAAE,KACjC1Y,QAAQ,CAAC,IAAIoN,KAAK,CAAC,kBAAkBnN,MAAM,CAAC,GAAGyY,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1D,KAAK,MAAMhF,CAAC,IAAI8G,sBAAsB,EAAE;MACtCN,SAAS,CAACxG,CAAC,CAAC,GAAGsG,GAAG,CAACtG,CAAC,CAAC;MACrBsG,GAAG,CAACtG,CAAC,CAAC,GAAG4G,OAAO;IAClB;IACA,KAAK,MAAM5G,CAAC,IAAI+G,sBAAsB,EAAE;MACtCP,SAAS,CAACxG,CAAC,CAAC,GAAGsG,GAAG,CAACtG,CAAC,CAAC;MACrBsG,GAAG,CAACtG,CAAC,CAAC,GAAG6G,OAAO;IAClB;IACAL,SAAS,CAACQ,MAAM,GAAGV,GAAG,CAACU,MAAM;IAC7BV,GAAG,CAACU,MAAM,GAAG,CAACC,SAAS,EAAE,OAAO,EAAE,GAAGjC,IAAI,EAAE,OAAO,EAAE,KAAK;MACvD,IAAI,CAACiC,SAAS,EAAEJ,OAAO,CAAC,GAAG7B,IAAI,CAAC;IAClC,CAAC;IACD,OAAO,MAAMjT,MAAM,CAACmV,MAAM,CAACZ,GAAG,EAAEE,SAAS,CAAC;EAC5C;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,QAAQ1P,WAAWA,CAAA,CAAE,EAAE,GAAG,GAAG,IAAI,CAAC;IAChC,MAAM7D,MAAM,GAAG2E,OAAO,CAAC3E,MAAM;IAC7B,MAAMkU,aAAa,GAAGlU,MAAM,CAACmG,KAAK;IAClC,IAAIgO,SAAS,GAAG,KAAK;IACrB,MAAMC,SAAS,GAAGA,CAChBC,KAAK,EAAEC,UAAU,GAAG,MAAM,EAC1BC,YAAuD,CAA1C,EAAEC,cAAc,GAAG,CAAC,CAACC,GAAW,CAAP,EAAEhO,KAAK,EAAE,GAAG,IAAI,CAAC,EACvDwB,EAA0B,CAAvB,EAAE,CAACwM,GAAW,CAAP,EAAEhO,KAAK,EAAE,GAAG,IAAI,CAC3B,EAAE,OAAO,IAAI;MACZ,MAAMiO,QAAQ,GAAG,OAAOH,YAAY,KAAK,UAAU,GAAGA,YAAY,GAAGtM,EAAE;MACvE;MACA;MACA;MACA,IAAIkM,SAAS,EAAE;QACb,MAAMQ,QAAQ,GACZ,OAAOJ,YAAY,KAAK,QAAQ,GAAGA,YAAY,GAAGnK,SAAS;QAC7D,OAAO8J,aAAa,CAACU,IAAI,CAAC5U,MAAM,EAAEqU,KAAK,EAAEM,QAAQ,EAAED,QAAQ,CAAC;MAC9D;MACAP,SAAS,GAAG,IAAI;MAChB,IAAI;QACF,MAAMhH,IAAI,GACR,OAAOkH,KAAK,KAAK,QAAQ,GACrBA,KAAK,GACLQ,MAAM,CAAC9J,IAAI,CAACsJ,KAAK,CAAC,CAACS,QAAQ,CAAC,MAAM,CAAC;QACzC1b,eAAe,CAAC,YAAY+T,IAAI,EAAE,EAAE;UAAEzD,KAAK,EAAE;QAAO,CAAC,CAAC;QACtD,IAAI,IAAI,CAACrG,eAAe,IAAI,CAAC,IAAI,CAACzC,WAAW,IAAI,CAAC,IAAI,CAACC,QAAQ,EAAE;UAC/D,IAAI,CAAC0C,qBAAqB,GAAG,IAAI;UACjC,IAAI,CAAC7C,cAAc,CAAC,CAAC;QACvB;MACF,CAAC,SAAS;QACRyT,SAAS,GAAG,KAAK;QACjBO,QAAQ,GAAG,CAAC;MACd;MACA,OAAO,IAAI;IACb,CAAC;IACD1U,MAAM,CAACmG,KAAK,GAAGiO,SAAS;IACxB,OAAO,MAAM;MACX,IAAIpU,MAAM,CAACmG,KAAK,KAAKiO,SAAS,EAAE;QAC9BpU,MAAM,CAACmG,KAAK,GAAG+N,aAAa;MAC9B;IACF,CAAC;EACH;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASlH,UAAUA,CAAClN,KAAK,EAAEF,MAAM,CAACG,UAAU,GAAG4E,OAAO,CAAC7E,KAAK,CAAC,EAAE,IAAI,CAAC;EACzE,IAAI,CAACA,KAAK,CAACkE,KAAK,EAAE;EAClB;EACA;EACA,IAAI;IACF,OAAOlE,KAAK,CAACiV,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE;MAC5B;IAAA;EAEJ,CAAC,CAAC,MAAM;IACN;EAAA;EAEF;EACA;EACA,IAAIpQ,OAAO,CAACqQ,QAAQ,KAAK,OAAO,EAAE;EAClC;EACA;EACA;EACA,MAAMC,GAAG,GAAGnV,KAAK,IAAIF,MAAM,CAACG,UAAU,GAAG;IACvC8M,KAAK,CAAC,EAAE,OAAO;IACfC,UAAU,CAAC,EAAE,CAACO,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI;EACrC,CAAC;EACD,MAAM6H,MAAM,GAAGD,GAAG,CAACpI,KAAK,KAAK,IAAI;EACjC;EACA;EACA;EACA,IAAIsI,EAAE,GAAG,CAAC,CAAC;EACX,IAAI;IACF;IACA;IACA,IAAI,CAACD,MAAM,EAAED,GAAG,CAACnI,UAAU,GAAG,IAAI,CAAC;IACnCqI,EAAE,GAAG3c,QAAQ,CAAC,UAAU,EAAED,WAAW,CAAC6c,QAAQ,GAAG7c,WAAW,CAAC8c,UAAU,CAAC;IACxE,MAAMC,GAAG,GAAGT,MAAM,CAACU,KAAK,CAAC,IAAI,CAAC;IAC9B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,EAAE,EAAEA,CAAC,EAAE,EAAE;MAC3B,IAAI/c,QAAQ,CAAC0c,EAAE,EAAEG,GAAG,EAAE,CAAC,EAAEA,GAAG,CAAC9L,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;IACnD;EACF,CAAC,CAAC,MAAM;IACN;IACA;EAAA,CACD,SAAS;IACR,IAAI2L,EAAE,IAAI,CAAC,EAAE;MACX,IAAI;QACF9c,SAAS,CAAC8c,EAAE,CAAC;MACf,CAAC,CAAC,MAAM;QACN;MAAA;IAEJ;IACA,IAAI,CAACD,MAAM,EAAE;MACX,IAAI;QACFD,GAAG,CAACnI,UAAU,GAAG,KAAK,CAAC;MACzB,CAAC,CAAC,MAAM;QACN;MAAA;IAEJ;EACF;AACF;AACA;;AAEA,MAAM+G,sBAAsB,GAAG,CAC7B,KAAK,EACL,MAAM,EACN,OAAO,EACP,KAAK,EACL,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,OAAO,EACP,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,MAAM,EACN,SAAS,EACT,SAAS,CACV,IAAIxU,KAAK;AACV,MAAMyU,sBAAsB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAIzU,KAAK","ignoreList":[]}