@workclaw/openclaw-workclaw 1.0.339 → 1.0.341

package/dist/node_modules/.pnpm/@earendil-works_pi-tui@0.75.4/node_modules/@earendil-works/pi-tui/dist/tui.js

@@ -1,938 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { performance } from "node:perf_hooks";
-import { matchesKey, isKeyRelease } from "./keys.js";
-import { getCapabilities, isImageLine, deleteKittyImage, setCellDimensions } from "./terminal-image.js";
-import { visibleWidth, sliceByColumn, normalizeTerminalOutput, extractSegments, sliceWithWidth } from "./utils.js";
-const KITTY_SEQUENCE_PREFIX = "\x1B_G";
-function extractKittyImageIds(line) {
-  const sequenceStart = line.indexOf(KITTY_SEQUENCE_PREFIX);
-  if (sequenceStart === -1)
-    return [];
-  const paramsStart = sequenceStart + KITTY_SEQUENCE_PREFIX.length;
-  const paramsEnd = line.indexOf(";", paramsStart);
-  if (paramsEnd === -1)
-    return [];
-  const params = line.slice(paramsStart, paramsEnd);
-  for (const param of params.split(",")) {
-    const [key, value] = param.split("=", 2);
-    if (key !== "i" || value === void 0)
-      continue;
-    const id = Number(value);
-    if (Number.isInteger(id) && id > 0 && id <= 4294967295) {
-      return [id];
-    }
-  }
-  return [];
-}
-function isFocusable(component) {
-  return component !== null && "focused" in component;
-}
-const CURSOR_MARKER = "\x1B_pi:c\x07";
-function parseSizeValue(value, referenceSize) {
-  if (value === void 0)
-    return void 0;
-  if (typeof value === "number")
-    return value;
-  const match = value.match(/^(\d+(?:\.\d+)?)%$/);
-  if (match) {
-    return Math.floor(referenceSize * parseFloat(match[1]) / 100);
-  }
-  return void 0;
-}
-function isTermuxSession() {
-  return Boolean(process.env.TERMUX_VERSION);
-}
-class Container {
-  children = [];
-  addChild(component) {
-    this.children.push(component);
-  }
-  removeChild(component) {
-    const index = this.children.indexOf(component);
-    if (index !== -1) {
-      this.children.splice(index, 1);
-    }
-  }
-  clear() {
-    this.children = [];
-  }
-  invalidate() {
-    for (const child of this.children) {
-      child.invalidate?.();
-    }
-  }
-  render(width) {
-    const lines = [];
-    for (const child of this.children) {
-      const childLines = child.render(width);
-      for (const line of childLines) {
-        lines.push(line);
-      }
-    }
-    return lines;
-  }
-}
-class TUI extends Container {
-  terminal;
-  previousLines = [];
-  previousKittyImageIds = /* @__PURE__ */ new Set();
-  previousWidth = 0;
-  previousHeight = 0;
-  focusedComponent = null;
-  inputListeners = /* @__PURE__ */ new Set();
-  /** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
-  onDebug;
-  renderRequested = false;
-  renderTimer;
-  lastRenderAt = 0;
-  static MIN_RENDER_INTERVAL_MS = 16;
-  cursorRow = 0;
-  // Logical cursor row (end of rendered content)
-  hardwareCursorRow = 0;
-  // Actual terminal cursor row (may differ due to IME positioning)
-  showHardwareCursor = process.env.PI_HARDWARE_CURSOR === "1";
-  clearOnShrink = process.env.PI_CLEAR_ON_SHRINK === "1";
-  // Clear empty rows when content shrinks (default: off)
-  maxLinesRendered = 0;
-  // Track terminal's working area (max lines ever rendered)
-  previousViewportTop = 0;
-  // Track previous viewport top for resize-aware cursor moves
-  fullRedrawCount = 0;
-  stopped = false;
-  // Overlay stack for modal components rendered on top of base content
-  focusOrderCounter = 0;
-  overlayStack = [];
-  constructor(terminal, showHardwareCursor) {
-    super();
-    this.terminal = terminal;
-    if (showHardwareCursor !== void 0) {
-      this.showHardwareCursor = showHardwareCursor;
-    }
-  }
-  get fullRedraws() {
-    return this.fullRedrawCount;
-  }
-  getShowHardwareCursor() {
-    return this.showHardwareCursor;
-  }
-  setShowHardwareCursor(enabled) {
-    if (this.showHardwareCursor === enabled)
-      return;
-    this.showHardwareCursor = enabled;
-    if (!enabled) {
-      this.terminal.hideCursor();
-    }
-    this.requestRender();
-  }
-  getClearOnShrink() {
-    return this.clearOnShrink;
-  }
-  /**
-   * Set whether to trigger full re-render when content shrinks.
-   * When true (default), empty rows are cleared when content shrinks.
-   * When false, empty rows remain (reduces redraws on slower terminals).
-   */
-  setClearOnShrink(enabled) {
-    this.clearOnShrink = enabled;
-  }
-  setFocus(component) {
-    if (isFocusable(this.focusedComponent)) {
-      this.focusedComponent.focused = false;
-    }
-    this.focusedComponent = component;
-    if (isFocusable(component)) {
-      component.focused = true;
-    }
-  }
-  /**
-   * Show an overlay component with configurable positioning and sizing.
-   * Returns a handle to control the overlay's visibility.
-   */
-  showOverlay(component, options) {
-    const entry = {
-      component,
-      options,
-      preFocus: this.focusedComponent,
-      hidden: false,
-      focusOrder: ++this.focusOrderCounter
-    };
-    this.overlayStack.push(entry);
-    if (!options?.nonCapturing && this.isOverlayVisible(entry)) {
-      this.setFocus(component);
-    }
-    this.terminal.hideCursor();
-    this.requestRender();
-    return {
-      hide: () => {
-        const index = this.overlayStack.indexOf(entry);
-        if (index !== -1) {
-          this.overlayStack.splice(index, 1);
-          if (this.focusedComponent === component) {
-            const topVisible = this.getTopmostVisibleOverlay();
-            this.setFocus(topVisible?.component ?? entry.preFocus);
-          }
-          if (this.overlayStack.length === 0)
-            this.terminal.hideCursor();
-          this.requestRender();
-        }
-      },
-      setHidden: (hidden) => {
-        if (entry.hidden === hidden)
-          return;
-        entry.hidden = hidden;
-        if (hidden) {
-          if (this.focusedComponent === component) {
-            const topVisible = this.getTopmostVisibleOverlay();
-            this.setFocus(topVisible?.component ?? entry.preFocus);
-          }
-        } else {
-          if (!options?.nonCapturing && this.isOverlayVisible(entry)) {
-            entry.focusOrder = ++this.focusOrderCounter;
-            this.setFocus(component);
-          }
-        }
-        this.requestRender();
-      },
-      isHidden: () => entry.hidden,
-      focus: () => {
-        if (!this.overlayStack.includes(entry) || !this.isOverlayVisible(entry))
-          return;
-        if (this.focusedComponent !== component) {
-          this.setFocus(component);
-        }
-        entry.focusOrder = ++this.focusOrderCounter;
-        this.requestRender();
-      },
-      unfocus: () => {
-        if (this.focusedComponent !== component)
-          return;
-        const topVisible = this.getTopmostVisibleOverlay();
-        this.setFocus(topVisible && topVisible !== entry ? topVisible.component : entry.preFocus);
-        this.requestRender();
-      },
-      isFocused: () => this.focusedComponent === component
-    };
-  }
-  /** Hide the topmost overlay and restore previous focus. */
-  hideOverlay() {
-    const overlay = this.overlayStack.pop();
-    if (!overlay)
-      return;
-    if (this.focusedComponent === overlay.component) {
-      const topVisible = this.getTopmostVisibleOverlay();
-      this.setFocus(topVisible?.component ?? overlay.preFocus);
-    }
-    if (this.overlayStack.length === 0)
-      this.terminal.hideCursor();
-    this.requestRender();
-  }
-  /** Check if there are any visible overlays */
-  hasOverlay() {
-    return this.overlayStack.some((o) => this.isOverlayVisible(o));
-  }
-  /** Check if an overlay entry is currently visible */
-  isOverlayVisible(entry) {
-    if (entry.hidden)
-      return false;
-    if (entry.options?.visible) {
-      return entry.options.visible(this.terminal.columns, this.terminal.rows);
-    }
-    return true;
-  }
-  /** Find the topmost visible capturing overlay, if any */
-  getTopmostVisibleOverlay() {
-    for (let i = this.overlayStack.length - 1; i >= 0; i--) {
-      if (this.overlayStack[i].options?.nonCapturing)
-        continue;
-      if (this.isOverlayVisible(this.overlayStack[i])) {
-        return this.overlayStack[i];
-      }
-    }
-    return void 0;
-  }
-  invalidate() {
-    super.invalidate();
-    for (const overlay of this.overlayStack)
-      overlay.component.invalidate?.();
-  }
-  start() {
-    this.stopped = false;
-    this.terminal.start((data) => this.handleInput(data), () => this.requestRender());
-    this.terminal.hideCursor();
-    this.queryCellSize();
-    this.requestRender();
-  }
-  addInputListener(listener) {
-    this.inputListeners.add(listener);
-    return () => {
-      this.inputListeners.delete(listener);
-    };
-  }
-  removeInputListener(listener) {
-    this.inputListeners.delete(listener);
-  }
-  queryCellSize() {
-    if (!getCapabilities().images) {
-      return;
-    }
-    this.terminal.write("\x1B[16t");
-  }
-  stop() {
-    this.stopped = true;
-    if (this.renderTimer) {
-      clearTimeout(this.renderTimer);
-      this.renderTimer = void 0;
-    }
-    if (this.previousLines.length > 0) {
-      const targetRow = this.previousLines.length;
-      const lineDiff = targetRow - this.hardwareCursorRow;
-      if (lineDiff > 0) {
-        this.terminal.write(`\x1B[${lineDiff}B`);
-      } else if (lineDiff < 0) {
-        this.terminal.write(`\x1B[${-lineDiff}A`);
-      }
-      this.terminal.write("\r\n");
-    }
-    this.terminal.showCursor();
-    this.terminal.stop();
-  }
-  requestRender(force = false) {
-    if (force) {
-      this.previousLines = [];
-      this.previousWidth = -1;
-      this.previousHeight = -1;
-      this.cursorRow = 0;
-      this.hardwareCursorRow = 0;
-      this.maxLinesRendered = 0;
-      this.previousViewportTop = 0;
-      if (this.renderTimer) {
-        clearTimeout(this.renderTimer);
-        this.renderTimer = void 0;
-      }
-      this.renderRequested = true;
-      process.nextTick(() => {
-        if (this.stopped || !this.renderRequested) {
-          return;
-        }
-        this.renderRequested = false;
-        this.lastRenderAt = performance.now();
-        this.doRender();
-      });
-      return;
-    }
-    if (this.renderRequested)
-      return;
-    this.renderRequested = true;
-    process.nextTick(() => this.scheduleRender());
-  }
-  scheduleRender() {
-    if (this.stopped || this.renderTimer || !this.renderRequested) {
-      return;
-    }
-    const elapsed = performance.now() - this.lastRenderAt;
-    const delay = Math.max(0, TUI.MIN_RENDER_INTERVAL_MS - elapsed);
-    this.renderTimer = setTimeout(() => {
-      this.renderTimer = void 0;
-      if (this.stopped || !this.renderRequested) {
-        return;
-      }
-      this.renderRequested = false;
-      this.lastRenderAt = performance.now();
-      this.doRender();
-      if (this.renderRequested) {
-        this.scheduleRender();
-      }
-    }, delay);
-  }
-  handleInput(data) {
-    if (this.inputListeners.size > 0) {
-      let current = data;
-      for (const listener of this.inputListeners) {
-        const result = listener(current);
-        if (result?.consume) {
-          return;
-        }
-        if (result?.data !== void 0) {
-          current = result.data;
-        }
-      }
-      if (current.length === 0) {
-        return;
-      }
-      data = current;
-    }
-    if (this.consumeCellSizeResponse(data)) {
-      return;
-    }
-    if (matchesKey(data, "shift+ctrl+d") && this.onDebug) {
-      this.onDebug();
-      return;
-    }
-    const focusedOverlay = this.overlayStack.find((o) => o.component === this.focusedComponent);
-    if (focusedOverlay && !this.isOverlayVisible(focusedOverlay)) {
-      const topVisible = this.getTopmostVisibleOverlay();
-      if (topVisible) {
-        this.setFocus(topVisible.component);
-      } else {
-        this.setFocus(focusedOverlay.preFocus);
-      }
-    }
-    if (this.focusedComponent?.handleInput) {
-      if (isKeyRelease(data) && !this.focusedComponent.wantsKeyRelease) {
-        return;
-      }
-      this.focusedComponent.handleInput(data);
-      this.requestRender();
-    }
-  }
-  consumeCellSizeResponse(data) {
-    const match = data.match(/^\x1b\[6;(\d+);(\d+)t$/);
-    if (!match) {
-      return false;
-    }
-    const heightPx = parseInt(match[1], 10);
-    const widthPx = parseInt(match[2], 10);
-    if (heightPx <= 0 || widthPx <= 0) {
-      return true;
-    }
-    setCellDimensions({ widthPx, heightPx });
-    this.invalidate();
-    this.requestRender();
-    return true;
-  }
-  /**
-   * Resolve overlay layout from options.
-   * Returns { width, row, col, maxHeight } for rendering.
-   */
-  resolveOverlayLayout(options, overlayHeight, termWidth, termHeight) {
-    const opt = options ?? {};
-    const margin = typeof opt.margin === "number" ? { top: opt.margin, right: opt.margin, bottom: opt.margin, left: opt.margin } : opt.margin ?? {};
-    const marginTop = Math.max(0, margin.top ?? 0);
-    const marginRight = Math.max(0, margin.right ?? 0);
-    const marginBottom = Math.max(0, margin.bottom ?? 0);
-    const marginLeft = Math.max(0, margin.left ?? 0);
-    const availWidth = Math.max(1, termWidth - marginLeft - marginRight);
-    const availHeight = Math.max(1, termHeight - marginTop - marginBottom);
-    let width = parseSizeValue(opt.width, termWidth) ?? Math.min(80, availWidth);
-    if (opt.minWidth !== void 0) {
-      width = Math.max(width, opt.minWidth);
-    }
-    width = Math.max(1, Math.min(width, availWidth));
-    let maxHeight = parseSizeValue(opt.maxHeight, termHeight);
-    if (maxHeight !== void 0) {
-      maxHeight = Math.max(1, Math.min(maxHeight, availHeight));
-    }
-    const effectiveHeight = maxHeight !== void 0 ? Math.min(overlayHeight, maxHeight) : overlayHeight;
-    let row;
-    let col;
-    if (opt.row !== void 0) {
-      if (typeof opt.row === "string") {
-        const match = opt.row.match(/^(\d+(?:\.\d+)?)%$/);
-        if (match) {
-          const maxRow = Math.max(0, availHeight - effectiveHeight);
-          const percent = parseFloat(match[1]) / 100;
-          row = marginTop + Math.floor(maxRow * percent);
-        } else {
-          row = this.resolveAnchorRow("center", effectiveHeight, availHeight, marginTop);
-        }
-      } else {
-        row = opt.row;
-      }
-    } else {
-      const anchor = opt.anchor ?? "center";
-      row = this.resolveAnchorRow(anchor, effectiveHeight, availHeight, marginTop);
-    }
-    if (opt.col !== void 0) {
-      if (typeof opt.col === "string") {
-        const match = opt.col.match(/^(\d+(?:\.\d+)?)%$/);
-        if (match) {
-          const maxCol = Math.max(0, availWidth - width);
-          const percent = parseFloat(match[1]) / 100;
-          col = marginLeft + Math.floor(maxCol * percent);
-        } else {
-          col = this.resolveAnchorCol("center", width, availWidth, marginLeft);
-        }
-      } else {
-        col = opt.col;
-      }
-    } else {
-      const anchor = opt.anchor ?? "center";
-      col = this.resolveAnchorCol(anchor, width, availWidth, marginLeft);
-    }
-    if (opt.offsetY !== void 0)
-      row += opt.offsetY;
-    if (opt.offsetX !== void 0)
-      col += opt.offsetX;
-    row = Math.max(marginTop, Math.min(row, termHeight - marginBottom - effectiveHeight));
-    col = Math.max(marginLeft, Math.min(col, termWidth - marginRight - width));
-    return { width, row, col, maxHeight };
-  }
-  resolveAnchorRow(anchor, height, availHeight, marginTop) {
-    switch (anchor) {
-      case "top-left":
-      case "top-center":
-      case "top-right":
-        return marginTop;
-      case "bottom-left":
-      case "bottom-center":
-      case "bottom-right":
-        return marginTop + availHeight - height;
-      case "left-center":
-      case "center":
-      case "right-center":
-        return marginTop + Math.floor((availHeight - height) / 2);
-    }
-  }
-  resolveAnchorCol(anchor, width, availWidth, marginLeft) {
-    switch (anchor) {
-      case "top-left":
-      case "left-center":
-      case "bottom-left":
-        return marginLeft;
-      case "top-right":
-      case "right-center":
-      case "bottom-right":
-        return marginLeft + availWidth - width;
-      case "top-center":
-      case "center":
-      case "bottom-center":
-        return marginLeft + Math.floor((availWidth - width) / 2);
-    }
-  }
-  /** Composite all overlays into content lines (sorted by focusOrder, higher = on top). */
-  compositeOverlays(lines, termWidth, termHeight) {
-    if (this.overlayStack.length === 0)
-      return lines;
-    const result = [...lines];
-    const rendered = [];
-    let minLinesNeeded = result.length;
-    const visibleEntries = this.overlayStack.filter((e) => this.isOverlayVisible(e));
-    visibleEntries.sort((a, b) => a.focusOrder - b.focusOrder);
-    for (const entry of visibleEntries) {
-      const { component, options } = entry;
-      const { width, maxHeight } = this.resolveOverlayLayout(options, 0, termWidth, termHeight);
-      let overlayLines = component.render(width);
-      if (maxHeight !== void 0 && overlayLines.length > maxHeight) {
-        overlayLines = overlayLines.slice(0, maxHeight);
-      }
-      const { row, col } = this.resolveOverlayLayout(options, overlayLines.length, termWidth, termHeight);
-      rendered.push({ overlayLines, row, col, w: width });
-      minLinesNeeded = Math.max(minLinesNeeded, row + overlayLines.length);
-    }
-    const workingHeight = Math.max(result.length, termHeight, minLinesNeeded);
-    while (result.length < workingHeight) {
-      result.push("");
-    }
-    const viewportStart = Math.max(0, workingHeight - termHeight);
-    for (const { overlayLines, row, col, w } of rendered) {
-      for (let i = 0; i < overlayLines.length; i++) {
-        const idx = viewportStart + row + i;
-        if (idx >= 0 && idx < result.length) {
-          const truncatedOverlayLine = visibleWidth(overlayLines[i]) > w ? sliceByColumn(overlayLines[i], 0, w, true) : overlayLines[i];
-          result[idx] = this.compositeLineAt(result[idx], truncatedOverlayLine, col, w, termWidth);
-        }
-      }
-    }
-    return result;
-  }
-  static SEGMENT_RESET = "\x1B[0m\x1B]8;;\x07";
-  applyLineResets(lines) {
-    const reset = TUI.SEGMENT_RESET;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (!isImageLine(line)) {
-        lines[i] = normalizeTerminalOutput(line) + reset;
-      }
-    }
-    return lines;
-  }
-  collectKittyImageIds(lines) {
-    const ids = /* @__PURE__ */ new Set();
-    for (const line of lines) {
-      for (const id of extractKittyImageIds(line)) {
-        ids.add(id);
-      }
-    }
-    return ids;
-  }
-  deleteKittyImages(ids) {
-    let buffer = "";
-    for (const id of ids) {
-      buffer += deleteKittyImage(id);
-    }
-    return buffer;
-  }
-  expandLastChangedForKittyImages(firstChanged, lastChanged) {
-    let expandedLastChanged = lastChanged;
-    for (let i = firstChanged; i < this.previousLines.length; i++) {
-      if (extractKittyImageIds(this.previousLines[i]).length > 0) {
-        expandedLastChanged = Math.max(expandedLastChanged, i);
-      }
-    }
-    return expandedLastChanged;
-  }
-  deleteChangedKittyImages(firstChanged, lastChanged) {
-    if (firstChanged < 0 || lastChanged < firstChanged)
-      return "";
-    const ids = /* @__PURE__ */ new Set();
-    const maxLine = Math.min(lastChanged, this.previousLines.length - 1);
-    for (let i = firstChanged; i <= maxLine; i++) {
-      for (const id of extractKittyImageIds(this.previousLines[i] ?? "")) {
-        ids.add(id);
-      }
-    }
-    return this.deleteKittyImages(ids);
-  }
-  /** Splice overlay content into a base line at a specific column. Single-pass optimized. */
-  compositeLineAt(baseLine, overlayLine, startCol, overlayWidth, totalWidth) {
-    if (isImageLine(baseLine))
-      return baseLine;
-    const afterStart = startCol + overlayWidth;
-    const base = extractSegments(baseLine, startCol, afterStart, totalWidth - afterStart, true);
-    const overlay = sliceWithWidth(overlayLine, 0, overlayWidth, true);
-    const beforePad = Math.max(0, startCol - base.beforeWidth);
-    const overlayPad = Math.max(0, overlayWidth - overlay.width);
-    const actualBeforeWidth = Math.max(startCol, base.beforeWidth);
-    const actualOverlayWidth = Math.max(overlayWidth, overlay.width);
-    const afterTarget = Math.max(0, totalWidth - actualBeforeWidth - actualOverlayWidth);
-    const afterPad = Math.max(0, afterTarget - base.afterWidth);
-    const r = TUI.SEGMENT_RESET;
-    const result = base.before + " ".repeat(beforePad) + r + overlay.text + " ".repeat(overlayPad) + r + base.after + " ".repeat(afterPad);
-    const resultWidth = visibleWidth(result);
-    if (resultWidth <= totalWidth) {
-      return result;
-    }
-    return sliceByColumn(result, 0, totalWidth, true);
-  }
-  /**
-   * Find and extract cursor position from rendered lines.
-   * Searches for CURSOR_MARKER, calculates its position, and strips it from the output.
-   * Only scans the bottom terminal height lines (visible viewport).
-   * @param lines - Rendered lines to search
-   * @param height - Terminal height (visible viewport size)
-   * @returns Cursor position { row, col } or null if no marker found
-   */
-  extractCursorPosition(lines, height) {
-    const viewportTop = Math.max(0, lines.length - height);
-    for (let row = lines.length - 1; row >= viewportTop; row--) {
-      const line = lines[row];
-      const markerIndex = line.indexOf(CURSOR_MARKER);
-      if (markerIndex !== -1) {
-        const beforeMarker = line.slice(0, markerIndex);
-        const col = visibleWidth(beforeMarker);
-        lines[row] = line.slice(0, markerIndex) + line.slice(markerIndex + CURSOR_MARKER.length);
-        return { row, col };
-      }
-    }
-    return null;
-  }
-  doRender() {
-    if (this.stopped)
-      return;
-    const width = this.terminal.columns;
-    const height = this.terminal.rows;
-    const widthChanged = this.previousWidth !== 0 && this.previousWidth !== width;
-    const heightChanged = this.previousHeight !== 0 && this.previousHeight !== height;
-    const previousBufferLength = this.previousHeight > 0 ? this.previousViewportTop + this.previousHeight : height;
-    let prevViewportTop = heightChanged ? Math.max(0, previousBufferLength - height) : this.previousViewportTop;
-    let viewportTop = prevViewportTop;
-    let hardwareCursorRow = this.hardwareCursorRow;
-    const computeLineDiff = (targetRow) => {
-      const currentScreenRow = hardwareCursorRow - prevViewportTop;
-      const targetScreenRow = targetRow - viewportTop;
-      return targetScreenRow - currentScreenRow;
-    };
-    let newLines = this.render(width);
-    if (this.overlayStack.length > 0) {
-      newLines = this.compositeOverlays(newLines, width, height);
-    }
-    const cursorPos = this.extractCursorPosition(newLines, height);
-    newLines = this.applyLineResets(newLines);
-    const fullRender = (clear) => {
-      this.fullRedrawCount += 1;
-      let buffer2 = "\x1B[?2026h";
-      if (clear) {
-        buffer2 += this.deleteKittyImages(this.previousKittyImageIds);
-        buffer2 += "\x1B[2J\x1B[H\x1B[3J";
-      }
-      for (let i = 0; i < newLines.length; i++) {
-        if (i > 0)
-          buffer2 += "\r\n";
-        buffer2 += newLines[i];
-      }
-      buffer2 += "\x1B[?2026l";
-      this.terminal.write(buffer2);
-      this.cursorRow = Math.max(0, newLines.length - 1);
-      this.hardwareCursorRow = this.cursorRow;
-      if (clear) {
-        this.maxLinesRendered = newLines.length;
-      } else {
-        this.maxLinesRendered = Math.max(this.maxLinesRendered, newLines.length);
-      }
-      const bufferLength = Math.max(height, newLines.length);
-      this.previousViewportTop = Math.max(0, bufferLength - height);
-      this.positionHardwareCursor(cursorPos, newLines.length);
-      this.previousLines = newLines;
-      this.previousKittyImageIds = this.collectKittyImageIds(newLines);
-      this.previousWidth = width;
-      this.previousHeight = height;
-    };
-    const debugRedraw = process.env.PI_DEBUG_REDRAW === "1";
-    const logRedraw = (reason) => {
-      if (!debugRedraw)
-        return;
-      const logPath = path.join(os.homedir(), ".pi", "agent", "pi-debug.log");
-      const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] fullRender: ${reason} (prev=${this.previousLines.length}, new=${newLines.length}, height=${height})
-`;
-      fs.appendFileSync(logPath, msg);
-    };
-    if (this.previousLines.length === 0 && !widthChanged && !heightChanged) {
-      logRedraw("first render");
-      fullRender(false);
-      return;
-    }
-    if (widthChanged) {
-      logRedraw(`terminal width changed (${this.previousWidth} -> ${width})`);
-      fullRender(true);
-      return;
-    }
-    if (heightChanged && !isTermuxSession()) {
-      logRedraw(`terminal height changed (${this.previousHeight} -> ${height})`);
-      fullRender(true);
-      return;
-    }
-    if (this.clearOnShrink && newLines.length < this.maxLinesRendered && this.overlayStack.length === 0) {
-      logRedraw(`clearOnShrink (maxLinesRendered=${this.maxLinesRendered})`);
-      fullRender(true);
-      return;
-    }
-    let firstChanged = -1;
-    let lastChanged = -1;
-    const maxLines = Math.max(newLines.length, this.previousLines.length);
-    for (let i = 0; i < maxLines; i++) {
-      const oldLine = i < this.previousLines.length ? this.previousLines[i] : "";
-      const newLine = i < newLines.length ? newLines[i] : "";
-      if (oldLine !== newLine) {
-        if (firstChanged === -1) {
-          firstChanged = i;
-        }
-        lastChanged = i;
-      }
-    }
-    const appendedLines = newLines.length > this.previousLines.length;
-    if (appendedLines) {
-      if (firstChanged === -1) {
-        firstChanged = this.previousLines.length;
-      }
-      lastChanged = newLines.length - 1;
-    }
-    if (firstChanged !== -1) {
-      lastChanged = this.expandLastChangedForKittyImages(firstChanged, lastChanged);
-    }
-    const appendStart = appendedLines && firstChanged === this.previousLines.length && firstChanged > 0;
-    if (firstChanged === -1) {
-      this.positionHardwareCursor(cursorPos, newLines.length);
-      this.previousViewportTop = prevViewportTop;
-      this.previousHeight = height;
-      return;
-    }
-    if (firstChanged >= newLines.length) {
-      if (this.previousLines.length > newLines.length) {
-        let buffer2 = "\x1B[?2026h";
-        buffer2 += this.deleteChangedKittyImages(firstChanged, lastChanged);
-        const targetRow = Math.max(0, newLines.length - 1);
-        if (targetRow < prevViewportTop) {
-          logRedraw(`deleted lines moved viewport up (${targetRow} < ${prevViewportTop})`);
-          fullRender(true);
-          return;
-        }
-        const lineDiff2 = computeLineDiff(targetRow);
-        if (lineDiff2 > 0)
-          buffer2 += `\x1B[${lineDiff2}B`;
-        else if (lineDiff2 < 0)
-          buffer2 += `\x1B[${-lineDiff2}A`;
-        buffer2 += "\r";
-        const extraLines = this.previousLines.length - newLines.length;
-        if (extraLines > height) {
-          logRedraw(`extraLines > height (${extraLines} > ${height})`);
-          fullRender(true);
-          return;
-        }
-        if (extraLines > 0) {
-          buffer2 += "\x1B[1B";
-        }
-        for (let i = 0; i < extraLines; i++) {
-          buffer2 += "\r\x1B[2K";
-          if (i < extraLines - 1)
-            buffer2 += "\x1B[1B";
-        }
-        if (extraLines > 0) {
-          buffer2 += `\x1B[${extraLines}A`;
-        }
-        buffer2 += "\x1B[?2026l";
-        this.terminal.write(buffer2);
-        this.cursorRow = targetRow;
-        this.hardwareCursorRow = targetRow;
-      }
-      this.positionHardwareCursor(cursorPos, newLines.length);
-      this.previousLines = newLines;
-      this.previousKittyImageIds = this.collectKittyImageIds(newLines);
-      this.previousWidth = width;
-      this.previousHeight = height;
-      this.previousViewportTop = prevViewportTop;
-      return;
-    }
-    if (firstChanged < prevViewportTop) {
-      logRedraw(`firstChanged < viewportTop (${firstChanged} < ${prevViewportTop})`);
-      fullRender(true);
-      return;
-    }
-    let buffer = "\x1B[?2026h";
-    buffer += this.deleteChangedKittyImages(firstChanged, lastChanged);
-    const prevViewportBottom = prevViewportTop + height - 1;
-    const moveTargetRow = appendStart ? firstChanged - 1 : firstChanged;
-    if (moveTargetRow > prevViewportBottom) {
-      const currentScreenRow = Math.max(0, Math.min(height - 1, hardwareCursorRow - prevViewportTop));
-      const moveToBottom = height - 1 - currentScreenRow;
-      if (moveToBottom > 0) {
-        buffer += `\x1B[${moveToBottom}B`;
-      }
-      const scroll = moveTargetRow - prevViewportBottom;
-      buffer += "\r\n".repeat(scroll);
-      prevViewportTop += scroll;
-      viewportTop += scroll;
-      hardwareCursorRow = moveTargetRow;
-    }
-    const lineDiff = computeLineDiff(moveTargetRow);
-    if (lineDiff > 0) {
-      buffer += `\x1B[${lineDiff}B`;
-    } else if (lineDiff < 0) {
-      buffer += `\x1B[${-lineDiff}A`;
-    }
-    buffer += appendStart ? "\r\n" : "\r";
-    const renderEnd = Math.min(lastChanged, newLines.length - 1);
-    for (let i = firstChanged; i <= renderEnd; i++) {
-      if (i > firstChanged)
-        buffer += "\r\n";
-      buffer += "\x1B[2K";
-      const line = newLines[i];
-      const isImage = isImageLine(line);
-      if (!isImage && visibleWidth(line) > width) {
-        const crashLogPath = path.join(os.homedir(), ".pi", "agent", "pi-crash.log");
-        const crashData = [
-          `Crash at ${(/* @__PURE__ */ new Date()).toISOString()}`,
-          `Terminal width: ${width}`,
-          `Line ${i} visible width: ${visibleWidth(line)}`,
-          "",
-          "=== All rendered lines ===",
-          ...newLines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
-          ""
-        ].join("\n");
-        fs.mkdirSync(path.dirname(crashLogPath), { recursive: true });
-        fs.writeFileSync(crashLogPath, crashData);
-        this.stop();
-        const errorMsg = [
-          `Rendered line ${i} exceeds terminal width (${visibleWidth(line)} > ${width}).`,
-          "",
-          "This is likely caused by a custom TUI component not truncating its output.",
-          "Use visibleWidth() to measure and truncateToWidth() to truncate lines.",
-          "",
-          `Debug log written to: ${crashLogPath}`
-        ].join("\n");
-        throw new Error(errorMsg);
-      }
-      buffer += line;
-    }
-    let finalCursorRow = renderEnd;
-    if (this.previousLines.length > newLines.length) {
-      if (renderEnd < newLines.length - 1) {
-        const moveDown = newLines.length - 1 - renderEnd;
-        buffer += `\x1B[${moveDown}B`;
-        finalCursorRow = newLines.length - 1;
-      }
-      const extraLines = this.previousLines.length - newLines.length;
-      for (let i = newLines.length; i < this.previousLines.length; i++) {
-        buffer += "\r\n\x1B[2K";
-      }
-      buffer += `\x1B[${extraLines}A`;
-    }
-    buffer += "\x1B[?2026l";
-    if (process.env.PI_TUI_DEBUG === "1") {
-      const debugDir = "/tmp/tui";
-      fs.mkdirSync(debugDir, { recursive: true });
-      const debugPath = path.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
-      const debugData = [
-        `firstChanged: ${firstChanged}`,
-        `viewportTop: ${viewportTop}`,
-        `cursorRow: ${this.cursorRow}`,
-        `height: ${height}`,
-        `lineDiff: ${lineDiff}`,
-        `hardwareCursorRow: ${hardwareCursorRow}`,
-        `renderEnd: ${renderEnd}`,
-        `finalCursorRow: ${finalCursorRow}`,
-        `cursorPos: ${JSON.stringify(cursorPos)}`,
-        `newLines.length: ${newLines.length}`,
-        `previousLines.length: ${this.previousLines.length}`,
-        "",
-        "=== newLines ===",
-        JSON.stringify(newLines, null, 2),
-        "",
-        "=== previousLines ===",
-        JSON.stringify(this.previousLines, null, 2),
-        "",
-        "=== buffer ===",
-        JSON.stringify(buffer)
-      ].join("\n");
-      fs.writeFileSync(debugPath, debugData);
-    }
-    this.terminal.write(buffer);
-    this.cursorRow = Math.max(0, newLines.length - 1);
-    this.hardwareCursorRow = finalCursorRow;
-    this.maxLinesRendered = Math.max(this.maxLinesRendered, newLines.length);
-    this.previousViewportTop = Math.max(prevViewportTop, finalCursorRow - height + 1);
-    this.positionHardwareCursor(cursorPos, newLines.length);
-    this.previousLines = newLines;
-    this.previousKittyImageIds = this.collectKittyImageIds(newLines);
-    this.previousWidth = width;
-    this.previousHeight = height;
-  }
-  /**
-   * Position the hardware cursor for IME candidate window.
-   * @param cursorPos The cursor position extracted from rendered output, or null
-   * @param totalLines Total number of rendered lines
-   */
-  positionHardwareCursor(cursorPos, totalLines) {
-    if (!cursorPos || totalLines <= 0) {
-      this.terminal.hideCursor();
-      return;
-    }
-    const targetRow = Math.max(0, Math.min(cursorPos.row, totalLines - 1));
-    const targetCol = Math.max(0, cursorPos.col);
-    const rowDelta = targetRow - this.hardwareCursorRow;
-    let buffer = "";
-    if (rowDelta > 0) {
-      buffer += `\x1B[${rowDelta}B`;
-    } else if (rowDelta < 0) {
-      buffer += `\x1B[${-rowDelta}A`;
-    }
-    buffer += `\x1B[${targetCol + 1}G`;
-    if (buffer) {
-      this.terminal.write(buffer);
-    }
-    this.hardwareCursorRow = targetRow;
-    if (this.showHardwareCursor) {
-      this.terminal.showCursor();
-    } else {
-      this.terminal.hideCursor();
-    }
-  }
-}
-export {
-  CURSOR_MARKER,
-  Container,
-  TUI,
-  isFocusable,
-  visibleWidth
-};