lcclaude 1.0.0

package/dist/src/ink/ink.js

@@ -0,0 +1,978 @@
+import autoBind from "auto-bind";
+import { closeSync, constants as fsConstants, openSync, readSync, writeSync } from "fs";
+import noop from "lodash-es/noop.js";
+import throttle from "lodash-es/throttle.js";
+import React from "react";
+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 { format } from "util";
+import { colorize } from "./colorize.js";
+import App from "./components/App.js";
+import { FRAME_INTERVAL_MS } from "./constants.js";
+import * as dom from "./dom.js";
+import { KeyboardEvent } from "./events/keyboard-event.js";
+import { FocusManager } from "./focus.js";
+import { emptyFrame } from "./frame.js";
+import { dispatchClick, dispatchHover } from "./hit-test.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 reconciler, { dispatcher, getLastCommitMs, getLastYogaMs, isDebugRepaintsEnabled, recordYogaMs, resetProfileCounters } from "./reconciler.js";
+import renderNodeToOutput, { consumeFollowScroll, didLayoutShift } from "./render-node-to-output.js";
+import { applyPositionedHighlight, scanPositions } from "./render-to-screen.js";
+import createRenderer from "./renderer.js";
+import { CellWidth, CharPool, cellAt, createScreen, HyperlinkPool, isEmptyCellAt, migrateScreenPools, StylePool } from "./screen.js";
+import { applySearchHighlight } from "./searchHighlight.js";
+import { applySelectionOverlay, captureScrolledRows, clearSelection, createSelectionState, extendSelection, findPlainTextUrlAt, getSelectedText, hasSelection, moveFocus, selectLineAt, selectWordAt, shiftAnchor, shiftSelection, shiftSelectionForFollow, startSelection, updateSelection } from "./selection.js";
+import { SYNC_OUTPUT_SUPPORTED, supportsExtendedKeys, 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 } from "./termio/csi.js";
+import { DBP, DFE, DISABLE_MOUSE_TRACKING, ENABLE_MOUSE_TRACKING, ENTER_ALT_SCREEN, EXIT_ALT_SCREEN, SHOW_CURSOR } from "./termio/dec.js";
+import { CLEAR_ITERM2_PROGRESS, CLEAR_TAB_STATUS, setClipboard, supportsTabStatus, wrapForMultiplexer } from "./termio/osc.js";
+import { TerminalWriteProvider } from "./useTerminalNotification.js";
+const ALT_SCREEN_ANCHOR_CURSOR = Object.freeze({
+  x: 0,
+  y: 0,
+  visible: false
+});
+const CURSOR_HOME_PATCH = Object.freeze({
+  type: "stdout",
+  content: CURSOR_HOME
+});
+const ERASE_THEN_HOME_PATCH = Object.freeze({
+  type: "stdout",
+  content: ERASE_SCREEN + CURSOR_HOME
+});
+function makeAltScreenParkPatch(terminalRows) {
+  return Object.freeze({
+    type: "stdout",
+    content: cursorPosition(terminalRows, 1)
+  });
+}
+export default class Ink {
+  options;
+  log;
+  terminal;
+  scheduleRender;
+  isUnmounted = false;
+  isPaused = false;
+  container;
+  rootNode;
+  focusManager;
+  renderer;
+  stylePool;
+  charPool;
+  hyperlinkPool;
+  exitPromise;
+  restoreConsole;
+  restoreStderr;
+  unsubscribeTTYHandlers;
+  terminalColumns;
+  terminalRows;
+  currentNode = null;
+  frontFrame;
+  backFrame;
+  lastPoolResetTime = performance.now();
+  drainTimer = null;
+  lastYogaCounters = {
+    ms: 0,
+    visited: 0,
+    measured: 0,
+    cacheHits: 0,
+    live: 0
+  };
+  altScreenParkPatch;
+  selection = createSelectionState();
+  searchHighlightQuery = "";
+  searchPositions = null;
+  selectionListeners = new Set;
+  hoveredNodes = new Set;
+  altScreenActive = false;
+  altScreenMouseTracking = false;
+  prevFrameContaminated = false;
+  needsEraseBeforePaint = false;
+  cursorDeclaration = null;
+  displayCursor = null;
+  constructor(options) {
+    this.options = options;
+    autoBind(this);
+    if (this.options.patchConsole) {
+      this.restoreConsole = this.patchConsole();
+      this.restoreStderr = this.patchStderr();
+    }
+    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 || false,
+      stylePool: this.stylePool
+    });
+    const deferredRender = () => queueMicrotask(this.onRender);
+    this.scheduleRender = throttle(deferredRender, FRAME_INTERVAL_MS, {
+      leading: true,
+      trailing: true
+    });
+    this.isUnmounted = false;
+    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 = () => {
+      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, noop, noop, noop);
+    if (false) {}
+  }
+  handleResume = () => {
+    if (!this.options.stdout.isTTY) {
+      return;
+    }
+    if (this.altScreenActive) {
+      this.reenterAltScreen();
+      return;
+    }
+    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();
+    this.displayCursor = null;
+  };
+  handleResize = () => {
+    const cols = this.options.stdout.columns || 80;
+    const rows = this.options.stdout.rows || 24;
+    if (cols === this.terminalColumns && rows === this.terminalRows)
+      return;
+    this.terminalColumns = cols;
+    this.terminalRows = rows;
+    this.altScreenParkPatch = makeAltScreenParkPatch(this.terminalRows);
+    if (this.altScreenActive && !this.isPaused && this.options.stdout.isTTY) {
+      if (this.altScreenMouseTracking) {
+        this.options.stdout.write(ENABLE_MOUSE_TRACKING);
+      }
+      this.resetFramesForAltScreen();
+      this.needsEraseBeforePaint = true;
+    }
+    if (this.currentNode !== null) {
+      this.render(this.currentNode);
+    }
+  };
+  resolveExitPromise = () => {};
+  rejectExitPromise = () => {};
+  unsubscribeExit = () => {};
+  enterAlternateScreen() {
+    this.pause();
+    this.suspendStdin();
+    this.options.stdout.write(DISABLE_KITTY_KEYBOARD + DISABLE_MODIFY_OTHER_KEYS + (this.altScreenMouseTracking ? DISABLE_MOUSE_TRACKING : "") + (this.altScreenActive ? "" : "\x1B[?1049h") + "\x1B[?1004l" + "\x1B[0m" + "\x1B[?25h" + "\x1B[2J" + "\x1B[H");
+  }
+  exitAlternateScreen() {
+    this.options.stdout.write((this.altScreenActive ? ENTER_ALT_SCREEN : "") + "\x1B[2J" + "\x1B[H" + (this.altScreenMouseTracking ? ENABLE_MOUSE_TRACKING : "") + (this.altScreenActive ? "" : "\x1B[?1049l") + "\x1B[?25l");
+    this.resumeStdin();
+    if (this.altScreenActive) {
+      this.resetFramesForAltScreen();
+    } else {
+      this.repaint();
+    }
+    this.resume();
+    this.options.stdout.write("\x1B[?1004h" + (supportsExtendedKeys() ? DISABLE_KITTY_KEYBOARD + ENABLE_KITTY_KEYBOARD + ENABLE_MODIFY_OTHER_KEYS : ""));
+  }
+  onRender() {
+    if (this.isUnmounted || this.isPaused) {
+      return;
+    }
+    if (this.drainTimer !== null) {
+      clearTimeout(this.drainTimer);
+      this.drainTimer = null;
+    }
+    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;
+    const follow = consumeFollowScroll();
+    if (follow && this.selection.anchor && this.selection.anchor.row >= follow.viewportTop && this.selection.anchor.row <= follow.viewportBottom) {
+      const {
+        delta,
+        viewportTop,
+        viewportBottom
+      } = follow;
+      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 (!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);
+        if (cleared)
+          for (const cb of this.selectionListeners)
+            cb();
+      }
+    }
+    let selActive = false;
+    let hlActive = false;
+    if (this.altScreenActive) {
+      selActive = hasSelection(this.selection);
+      if (selActive) {
+        applySelectionOverlay(frame.screen, this.selection, this.stylePool);
+      }
+      hlActive = applySearchHighlight(frame.screen, this.searchHighlightQuery, this.stylePool);
+      if (this.searchPositions) {
+        const sp = this.searchPositions;
+        const posApplied = applyPositionedHighlight(frame.screen, this.stylePool, sp.positions, sp.rowOffset, sp.currentIdx);
+        hlActive = hlActive || posApplied;
+      }
+    }
+    if (didLayoutShift() || selActive || hlActive || this.prevFrameContaminated) {
+      frame.screen.damage = {
+        x: 0,
+        y: 0,
+        width: frame.screen.width,
+        height: frame.screen.height
+      };
+    }
+    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, SYNC_OUTPUT_SUPPORTED);
+    const diffMs = performance.now() - tDiff;
+    this.backFrame = this.frontFrame;
+    this.frontFrame = frame;
+    if (renderStart - this.lastPoolResetTime > 5 * 60 * 1000) {
+      this.resetPools();
+      this.lastPoolResetTime = renderStart;
+    }
+    const flickers = [];
+    for (const patch of diff) {
+      if (patch.type === "clearTerminal") {
+        flickers.push({
+          desiredHeight: frame.screen.height,
+          availableHeight: frame.viewport.height,
+          reason: patch.reason
+        });
+        if (isDebugRepaintsEnabled() && patch.debug) {
+          const chain = dom.findOwnerChainAtRow(this.rootNode, patch.debug.triggerY);
+          logForDebugging(`[REPAINT] full reset · ${patch.reason} · row ${patch.debug.triggerY}
+` + `  prev: "${patch.debug.prevLine}"
+` + `  next: "${patch.debug.nextLine}"
+` + `  culprit: ${chain.length ? chain.join(" < ") : "(no owner chain captured)"}`, {
+            level: "warn"
+          });
+        }
+      }
+    }
+    const tOptimize = performance.now();
+    const optimized = optimize(diff);
+    const optimizeMs = performance.now() - tOptimize;
+    const hasDiff = optimized.length > 0;
+    if (this.altScreenActive && hasDiff) {
+      if (this.needsEraseBeforePaint) {
+        this.needsEraseBeforePaint = false;
+        optimized.unshift(ERASE_THEN_HOME_PATCH);
+      } else {
+        optimized.unshift(CURSOR_HOME_PATCH);
+      }
+      optimized.push(this.altScreenParkPatch);
+    }
+    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;
+    const targetMoved = target !== null && (parked === null || parked.x !== target.x || parked.y !== target.y);
+    if (hasDiff || targetMoved || target === null && parked !== null) {
+      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) {
+          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 {
+          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 {
+        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();
+    writeDiffToTerminal(this.terminal, optimized, this.altScreenActive && !SYNC_OUTPUT_SUPPORTED);
+    const writeMs = performance.now() - tWrite;
+    this.prevFrameContaminated = selActive || hlActive;
+    if (frame.scrollDrainPending) {
+      this.drainTimer = setTimeout(() => this.onRender(), FRAME_INTERVAL_MS >> 2);
+    }
+    const yogaMs = getLastYogaMs();
+    const commitMs = getLastCommitMs();
+    const yc = this.lastYogaCounters;
+    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,
+        yoga: yogaMs,
+        commit: commitMs,
+        yogaVisited: yc.visited,
+        yogaMeasured: yc.measured,
+        yogaCacheHits: yc.cacheHits,
+        yogaLive: yc.live
+      },
+      flickers
+    });
+  }
+  pause() {
+    reconciler.flushSyncFromReconciler();
+    this.onRender();
+    this.isPaused = true;
+  }
+  resume() {
+    this.isPaused = false;
+    this.onRender();
+  }
+  repaint() {
+    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();
+    this.displayCursor = null;
+  }
+  forceRedraw() {
+    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();
+      this.prevFrameContaminated = true;
+    }
+    this.onRender();
+  }
+  invalidatePrevFrame() {
+    this.prevFrameContaminated = true;
+  }
+  setAltScreenActive(active, mouseTracking = false) {
+    if (this.altScreenActive === active)
+      return;
+    this.altScreenActive = active;
+    this.altScreenMouseTracking = active && mouseTracking;
+    if (active) {
+      this.resetFramesForAltScreen();
+    } else {
+      this.repaint();
+    }
+  }
+  get isAltScreenActive() {
+    return this.altScreenActive;
+  }
+  reassertTerminalModes = (includeAltScreen = false) => {
+    if (!this.options.stdout.isTTY)
+      return;
+    if (this.isPaused)
+      return;
+    if (supportsExtendedKeys()) {
+      this.options.stdout.write(DISABLE_KITTY_KEYBOARD + ENABLE_KITTY_KEYBOARD + ENABLE_MODIFY_OTHER_KEYS);
+    }
+    if (!this.altScreenActive)
+      return;
+    if (this.altScreenMouseTracking) {
+      this.options.stdout.write(ENABLE_MOUSE_TRACKING);
+    }
+    if (includeAltScreen) {
+      this.reenterAltScreen();
+    }
+  };
+  detachForShutdown() {
+    this.isUnmounted = true;
+    this.scheduleRender.cancel?.();
+    const stdin = this.options.stdin;
+    this.drainStdin();
+    if (stdin.isTTY && stdin.isRaw && stdin.setRawMode) {
+      stdin.setRawMode(false);
+    }
+  }
+  drainStdin() {
+    drainStdin(this.options.stdin);
+  }
+  reenterAltScreen() {
+    this.options.stdout.write(ENTER_ALT_SCREEN + ERASE_SCREEN + CURSOR_HOME + (this.altScreenMouseTracking ? ENABLE_MOUSE_TRACKING : ""));
+    this.resetFramesForAltScreen();
+  }
+  resetFramesForAltScreen() {
+    const rows = this.terminalRows;
+    const cols = this.terminalColumns;
+    const blank = () => ({
+      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();
+    this.displayCursor = null;
+    this.prevFrameContaminated = true;
+  }
+  copySelectionNoClear() {
+    if (!hasSelection(this.selection))
+      return "";
+    const text = getSelectedText(this.selection, this.frontFrame.screen);
+    if (text) {
+      setClipboard(text).then((raw) => {
+        if (raw)
+          this.options.stdout.write(raw);
+      });
+    }
+    return text;
+  }
+  copySelection() {
+    if (!hasSelection(this.selection))
+      return "";
+    const text = this.copySelectionNoClear();
+    clearSelection(this.selection);
+    this.notifySelectionChange();
+    return text;
+  }
+  clearTextSelection() {
+    if (!hasSelection(this.selection))
+      return;
+    clearSelection(this.selection);
+    this.notifySelectionChange();
+  }
+  setSearchHighlight(query) {
+    if (this.searchHighlightQuery === query)
+      return;
+    this.searchHighlightQuery = query;
+    this.scheduleRender();
+  }
+  scanElementSubtree(el) {
+    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 [];
+    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();
+    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;
+  }
+  setSearchPositions(state) {
+    this.searchPositions = state;
+    this.scheduleRender();
+  }
+  setSelectionBgColor(color) {
+    const wrapped = colorize("\x00", color, "background");
+    const nul = wrapped.indexOf("\x00");
+    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)
+    });
+  }
+  captureScrolledRows(firstRow, lastRow, side) {
+    captureScrolledRows(this.selection, this.frontFrame.screen, firstRow, lastRow, side);
+  }
+  shiftSelectionForScroll(dRow, minRow, maxRow) {
+    const hadSel = hasSelection(this.selection);
+    shiftSelection(this.selection, dRow, minRow, maxRow, this.frontFrame.screen.width);
+    if (hadSel && !hasSelection(this.selection)) {
+      this.notifySelectionChange();
+    }
+  }
+  moveSelectionFocus(move) {
+    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();
+  }
+  hasTextSelection() {
+    return hasSelection(this.selection);
+  }
+  subscribeToSelectionChange(cb) {
+    this.selectionListeners.add(cb);
+    return () => this.selectionListeners.delete(cb);
+  }
+  notifySelectionChange() {
+    this.onRender();
+    for (const cb of this.selectionListeners)
+      cb();
+  }
+  dispatchClick(col, row) {
+    if (!this.altScreenActive)
+      return false;
+    const blank = isEmptyCellAt(this.frontFrame.screen, col, row);
+    return dispatchClick(this.rootNode, col, row, blank);
+  }
+  dispatchHover(col, row) {
+    if (!this.altScreenActive)
+      return;
+    dispatchHover(this.rootNode, col, row, this.hoveredNodes);
+  }
+  dispatchKeyboardEvent(parsedKey) {
+    const target = this.focusManager.activeElement ?? this.rootNode;
+    const event = new KeyboardEvent(parsedKey);
+    dispatcher.dispatchDiscrete(target, event);
+    if (!event.defaultPrevented && parsedKey.name === "tab" && !parsedKey.ctrl && !parsedKey.meta) {
+      if (parsedKey.shift) {
+        this.focusManager.focusPrevious(this.rootNode);
+      } else {
+        this.focusManager.focusNext(this.rootNode);
+      }
+    }
+  }
+  getHyperlinkAt(col, row) {
+    if (!this.altScreenActive)
+      return;
+    const screen = this.frontFrame.screen;
+    const cell = cellAt(screen, col, row);
+    let url = cell?.hyperlink;
+    if (!url && cell?.width === CellWidth.SpacerTail && col > 0) {
+      url = cellAt(screen, col - 1, row)?.hyperlink;
+    }
+    return url ?? findPlainTextUrlAt(screen, col, row);
+  }
+  onHyperlinkClick;
+  openHyperlink(url) {
+    this.onHyperlinkClick?.(url);
+  }
+  handleMultiClick(col, row, count) {
+    if (!this.altScreenActive)
+      return;
+    const screen = this.frontFrame.screen;
+    startSelection(this.selection, col, row);
+    if (count === 2)
+      selectWordAt(this.selection, screen, col, row);
+    else
+      selectLineAt(this.selection, screen, row);
+    if (!this.selection.focus)
+      this.selection.focus = this.selection.anchor;
+    this.notifySelectionChange();
+  }
+  handleSelectionDrag(col, row) {
+    if (!this.altScreenActive)
+      return;
+    const sel = this.selection;
+    if (sel.anchorSpan) {
+      extendSelection(sel, this.frontFrame.screen, col, row);
+    } else {
+      updateSelection(sel, col, row);
+    }
+    this.notifySelectionChange();
+  }
+  stdinListeners = [];
+  wasRawMode = false;
+  suspendStdin() {
+    const stdin = this.options.stdin;
+    if (!stdin.isTTY) {
+      return;
+    }
+    const readableListeners = stdin.listeners("readable");
+    logForDebugging(`[stdin] suspendStdin: removing ${readableListeners.length} readable listener(s), wasRawMode=${stdin.isRaw ?? false}`);
+    readableListeners.forEach((listener) => {
+      this.stdinListeners.push({
+        event: "readable",
+        listener
+      });
+      stdin.removeListener("readable", listener);
+    });
+    const stdinWithRaw = stdin;
+    if (stdinWithRaw.isRaw && stdinWithRaw.setRawMode) {
+      stdinWithRaw.setRawMode(false);
+      this.wasRawMode = true;
+    }
+  }
+  resumeStdin() {
+    const stdin = this.options.stdin;
+    if (!stdin.isTTY) {
+      return;
+    }
+    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 = [];
+    if (this.wasRawMode) {
+      const stdinWithRaw = stdin;
+      if (stdinWithRaw.setRawMode) {
+        stdinWithRaw.setRawMode(true);
+      }
+      this.wasRawMode = false;
+    }
+  }
+  writeRaw(data) {
+    this.options.stdout.write(data);
+  }
+  setCursorDeclaration = (decl, clearIfNode) => {
+    if (decl === null && clearIfNode !== undefined && this.cursorDeclaration?.node !== clearIfNode) {
+      return;
+    }
+    this.cursorDeclaration = decl;
+  };
+  render(node) {
+    this.currentNode = node;
+    const tree = jsxDEV_7x81h0kn(App, {
+      stdin: this.options.stdin,
+      stdout: this.options.stdout,
+      stderr: this.options.stderr,
+      exitOnCtrlC: this.options.exitOnCtrlC,
+      onExit: this.unmount,
+      terminalColumns: this.terminalColumns,
+      terminalRows: this.terminalRows,
+      selection: this.selection,
+      onSelectionChange: this.notifySelectionChange,
+      onClickAt: this.dispatchClick,
+      onHoverAt: this.dispatchHover,
+      getHyperlinkAt: this.getHyperlinkAt,
+      onOpenHyperlink: this.openHyperlink,
+      onMultiClick: this.handleMultiClick,
+      onSelectionDrag: this.handleSelectionDrag,
+      onStdinResume: this.reassertTerminalModes,
+      onCursorDeclaration: this.setCursorDeclaration,
+      dispatchKeyboardEvent: this.dispatchKeyboardEvent,
+      children: jsxDEV_7x81h0kn(TerminalWriteProvider, {
+        value: this.writeRaw,
+        children: node
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+    reconciler.updateContainerSync(tree, this.container, null, noop);
+    reconciler.flushSyncWork();
+  }
+  unmount(error) {
+    if (this.isUnmounted) {
+      return;
+    }
+    this.onRender();
+    this.unsubscribeExit();
+    if (typeof this.restoreConsole === "function") {
+      this.restoreConsole();
+    }
+    this.restoreStderr?.();
+    this.unsubscribeTTYHandlers?.();
+    const diff = this.log.renderPreviousOutput_DEPRECATED(this.frontFrame);
+    writeDiffToTerminal(this.terminal, optimize(diff));
+    if (this.options.stdout.isTTY) {
+      if (this.altScreenActive) {
+        writeSync(1, EXIT_ALT_SCREEN);
+      }
+      writeSync(1, DISABLE_MOUSE_TRACKING);
+      this.drainStdin();
+      writeSync(1, DISABLE_MODIFY_OTHER_KEYS);
+      writeSync(1, DISABLE_KITTY_KEYBOARD);
+      writeSync(1, DFE);
+      writeSync(1, DBP);
+      writeSync(1, SHOW_CURSOR);
+      writeSync(1, CLEAR_ITERM2_PROGRESS);
+      if (supportsTabStatus())
+        writeSync(1, wrapForMultiplexer(CLEAR_TAB_STATUS));
+    }
+    this.isUnmounted = true;
+    this.scheduleRender.cancel?.();
+    if (this.drainTimer !== null) {
+      clearTimeout(this.drainTimer);
+      this.drainTimer = null;
+    }
+    reconciler.updateContainerSync(null, this.container, null, noop);
+    reconciler.flushSyncWork();
+    instances.delete(this.options.stdout);
+    this.rootNode.yogaNode?.free();
+    this.rootNode.yogaNode = undefined;
+    if (error instanceof Error) {
+      this.rejectExitPromise(error);
+    } else {
+      this.resolveExitPromise();
+    }
+  }
+  async waitUntilExit() {
+    this.exitPromise ||= new Promise((resolve, reject) => {
+      this.resolveExitPromise = resolve;
+      this.rejectExitPromise = reject;
+    });
+    return this.exitPromise;
+  }
+  resetLineCount() {
+    if (this.options.stdout.isTTY) {
+      this.backFrame = this.frontFrame;
+      this.frontFrame = emptyFrame(this.frontFrame.viewport.height, this.frontFrame.viewport.width, this.stylePool, this.charPool, this.hyperlinkPool);
+      this.log.reset();
+      this.displayCursor = null;
+    }
+  }
+  resetPools() {
+    this.charPool = new CharPool;
+    this.hyperlinkPool = new HyperlinkPool;
+    migrateScreenPools(this.frontFrame.screen, this.charPool, this.hyperlinkPool);
+    this.backFrame.screen.charPool = this.charPool;
+    this.backFrame.screen.hyperlinkPool = this.hyperlinkPool;
+  }
+  patchConsole() {
+    const con = console;
+    const originals = {};
+    const toDebug = (...args) => logForDebugging(`console.log: ${format(...args)}`);
+    const toError = (...args) => 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, ...args) => {
+      if (!condition)
+        toError(...args);
+    };
+    return () => Object.assign(con, originals);
+  }
+  patchStderr() {
+    const stderr = process.stderr;
+    const originalWrite = stderr.write;
+    let reentered = false;
+    const intercept = (chunk, encodingOrCb, cb) => {
+      const callback = typeof encodingOrCb === "function" ? encodingOrCb : cb;
+      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;
+      }
+    };
+  }
+}
+export function drainStdin(stdin = process.stdin) {
+  if (!stdin.isTTY)
+    return;
+  try {
+    while (stdin.read() !== null) {}
+  } catch {}
+  if (process.platform === "win32")
+    return;
+  const tty = stdin;
+  const wasRaw = tty.isRaw === true;
+  let fd = -1;
+  try {
+    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 {} finally {
+    if (fd >= 0) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+    if (!wasRaw) {
+      try {
+        tty.setRawMode?.(false);
+      } catch {}
+    }
+  }
+}
+const CONSOLE_STDOUT_METHODS = ["log", "info", "debug", "dir", "dirxml", "count", "countReset", "group", "groupCollapsed", "groupEnd", "table", "time", "timeEnd", "timeLog"];
+const CONSOLE_STDERR_METHODS = ["warn", "error", "trace"];