@fairyhunter13/opentui-core 0.1.101 → 0.1.103

package/{index-0dqa35pr.js → index-3zw722ea.js}

@@ -5168,7 +5168,7 @@ function visualizeRenderableTree(renderable, maxDepth = 10) {
 }
 
 // src/lib/styled-text.ts
-var BrandedStyledText = Symbol.for("@fairyhunter13/opentui-core/StyledText");
+var BrandedStyledText = Symbol.for("@opentui/core/StyledText");
 function isStyledText(obj) {
   return obj && obj[BrandedStyledText];
 }
@@ -6666,7 +6666,7 @@ class ASCIIFontSelectionHelper {
 }
 
 // src/lib/singleton.ts
-var singletonCacheSymbol = Symbol.for("@fairyhunter13/opentui-core/singleton");
+var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
 function singleton(key, factory) {
   const bag = globalThis[singletonCacheSymbol] ??= {};
   if (!(key in bag)) {
@@ -6843,7 +6843,7 @@ var env = new Proxy({}, {
 
 // src/lib/stdin-parser.ts
 import { Buffer as Buffer3 } from "buffer";
-var DEFAULT_TIMEOUT_MS = 10;
+var DEFAULT_TIMEOUT_MS = 20;
 var DEFAULT_MAX_PENDING_BYTES = 64 * 1024;
 var INITIAL_PENDING_CAPACITY = 256;
 var ESC = 27;
@@ -7014,6 +7014,28 @@ function parsePositiveDecimalPrefix(sequence, start, endExclusive) {
   }
   return sawDigit ? value : null;
 }
+function parseKittyFirstFieldCodepoint(sequence, start, endExclusive) {
+  if (start >= endExclusive)
+    return null;
+  let firstColon = -1;
+  for (let index = start;index < endExclusive; index += 1) {
+    if (sequence[index] === 58) {
+      firstColon = index;
+      break;
+    }
+  }
+  if (firstColon === -1)
+    return null;
+  const codepoint = parsePositiveDecimalPrefix(sequence, start, firstColon);
+  if (codepoint === null)
+    return null;
+  for (let index = firstColon + 1;index < endExclusive; index += 1) {
+    const byte = sequence[index];
+    if (byte !== 58 && !isAsciiDigit(byte))
+      return null;
+  }
+  return codepoint;
+}
 function canStillBeKittyU(state) {
   return state.semicolons >= 1;
 }
@@ -7215,10 +7237,13 @@ class StdinParser {
   }
   flushTimeout(nowMsValue = this.clock.now()) {
     this.ensureAlive();
-    if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
+    if (this.pendingSinceMs !== null && (nowMsValue < this.pendingSinceMs || nowMsValue - this.pendingSinceMs < this.timeoutMs)) {
       return;
     }
-    if (nowMsValue < this.pendingSinceMs || nowMsValue - this.pendingSinceMs < this.timeoutMs) {
+    this.tryForceFlush();
+  }
+  tryForceFlush() {
+    if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
       return;
     }
     this.forceFlush = true;
@@ -7480,7 +7505,12 @@ class StdinParser {
             continue;
           }
           if (byte === 59) {
-            const firstParamValue = parsePositiveDecimalPrefix(bytes, this.unitStart + 2, this.cursor);
+            const firstParamStart = this.unitStart + 2;
+            const firstParamEnd = this.cursor;
+            let firstParamValue = parsePositiveDecimalPrefix(bytes, firstParamStart, firstParamEnd);
+            if (firstParamValue === null && this.protocolContext.kittyKeyboardEnabled) {
+              firstParamValue = parseKittyFirstFieldCodepoint(bytes, firstParamStart, firstParamEnd);
+            }
             if (firstParamValue !== null) {
               this.cursor += 1;
               this.state = {
@@ -8078,7 +8108,7 @@ class StdinParser {
         return;
       }
       try {
-        this.flushTimeout(this.clock.now());
+        this.tryForceFlush();
         this.onTimeoutFlush?.();
       } catch (error) {
         console.error("stdin parser timeout flush failed", error);
@@ -9416,7 +9446,7 @@ class DownloadUtils {
 
 // src/lib/tree-sitter/assets/update.ts
 import { readdir } from "fs/promises";
-var __dirname = "/Users/runner/work/opentui/opentui/packages/core/src/lib/tree-sitter/assets";
+var __dirname = "/home/hafiz/git/github.com/fairyhunter13/opentui/packages/core/src/lib/tree-sitter/assets";
 function getDefaultOptions() {
   return {
     configPath: path4.resolve(__dirname, "../parsers-config"),
@@ -11768,7 +11798,7 @@ var ReserveInfoStruct = defineStruct([
 });
 
 // src/zig.ts
-var module = await import(`@fairyhunter13/opentui-core-${process.platform}-${process.arch}/index.ts`);
+var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
 var targetLibPath = module.default;
 if (isBunfsPath(targetLibPath)) {
   targetLibPath = targetLibPath.replace("../", "");
@@ -14544,7 +14574,7 @@ function isSizeType(value) {
 }
 
 // src/Renderable.ts
-var BrandedRenderable = Symbol.for("@fairyhunter13/opentui-core/Renderable");
+var BrandedRenderable = Symbol.for("@opentui/core/Renderable");
 var LayoutEvents;
 ((LayoutEvents2) => {
   LayoutEvents2["LAYOUT_CHANGED"] = "layout-changed";
@@ -14900,29 +14930,31 @@ class Renderable extends BaseRenderable {
     return this._widthValue;
   }
   set width(value) {
-    if (isDimensionType(value)) {
-      this._width = value;
-      this.yogaNode.setWidth(value);
-      if (typeof value === "number" && this._flexShrink === 1) {
-        this._flexShrink = 0;
-        this.yogaNode.setFlexShrink(0);
-      }
-      this.requestRender();
+    if (!isDimensionType(value) || this._width === value) {
+      return;
+    }
+    this._width = value;
+    this.yogaNode.setWidth(value);
+    if (typeof value === "number" && this._flexShrink === 1) {
+      this._flexShrink = 0;
+      this.yogaNode.setFlexShrink(0);
     }
+    this.requestRender();
   }
   get height() {
     return this._heightValue;
   }
   set height(value) {
-    if (isDimensionType(value)) {
-      this._height = value;
-      this.yogaNode.setHeight(value);
-      if (typeof value === "number" && this._flexShrink === 1) {
-        this._flexShrink = 0;
-        this.yogaNode.setFlexShrink(0);
-      }
-      this.requestRender();
+    if (!isDimensionType(value) || this._height === value) {
+      return;
     }
+    this._height = value;
+    this.yogaNode.setHeight(value);
+    if (typeof value === "number" && this._flexShrink === 1) {
+      this._flexShrink = 0;
+      this.yogaNode.setFlexShrink(0);
+    }
+    this.requestRender();
   }
   get zIndex() {
     return this._zIndex;
@@ -15778,7 +15810,7 @@ class RootRenderable extends Renderable {
 
 // src/renderables/composition/vnode.ts
 import util from "util";
-var BrandedVNode = Symbol.for("@fairyhunter13/opentui-core/VNode");
+var BrandedVNode = Symbol.for("@opentui/core/VNode");
 function isRenderableConstructor(value) {
   return typeof value === "function" && value.prototype && Renderable.prototype.isPrototypeOf(value.prototype);
 }
@@ -15942,1084 +15974,2506 @@ function delegate(mapping, vnode) {
   return vnode;
 }
 
-// src/console.ts
-import { EventEmitter as EventEmitter7 } from "events";
-import { Console } from "console";
-import fs from "fs";
-import path5 from "path";
-import util2 from "util";
-
-// src/lib/output.capture.ts
-import { Writable } from "stream";
+// src/edit-buffer.ts
 import { EventEmitter as EventEmitter6 } from "events";
 
-class Capture extends EventEmitter6 {
-  output = [];
-  constructor() {
+class EditBuffer extends EventEmitter6 {
+  static registry = new Map;
+  static nativeEventsSubscribed = false;
+  lib;
+  bufferPtr;
+  textBufferPtr;
+  id;
+  _destroyed = false;
+  _textBytes = [];
+  _singleTextBytes = null;
+  _singleTextMemId = null;
+  _syntaxStyle;
+  constructor(lib, ptr5) {
     super();
+    this.lib = lib;
+    this.bufferPtr = ptr5;
+    this.textBufferPtr = lib.editBufferGetTextBuffer(ptr5);
+    this.id = lib.editBufferGetId(ptr5);
+    EditBuffer.registry.set(this.id, this);
+    EditBuffer.subscribeToNativeEvents(lib);
   }
-  get size() {
-    return this.output.length;
+  static create(widthMethod) {
+    const lib = resolveRenderLib();
+    const ptr5 = lib.createEditBuffer(widthMethod);
+    return new EditBuffer(lib, ptr5);
   }
-  write(stream, data) {
-    this.output.push({ stream, output: data });
-    this.emit("write", stream, data);
+  static subscribeToNativeEvents(lib) {
+    if (EditBuffer.nativeEventsSubscribed)
+      return;
+    EditBuffer.nativeEventsSubscribed = true;
+    lib.onAnyNativeEvent((name, data) => {
+      const buffer = new Uint16Array(data);
+      if (name.startsWith("eb_") && buffer.length >= 1) {
+        const id = buffer[0];
+        const instance = EditBuffer.registry.get(id);
+        if (instance) {
+          const eventName = name.slice(3);
+          const eventData = data.slice(2);
+          instance.emit(eventName, eventData);
+        }
+      }
+    });
   }
-  claimOutput() {
-    const output = this.output.map((o) => o.output).join("");
-    this.clear();
-    return output;
+  guard() {
+    if (this._destroyed)
+      throw new Error("EditBuffer is destroyed");
   }
-  clear() {
-    this.output = [];
+  get ptr() {
+    this.guard();
+    return this.bufferPtr;
   }
-}
-
-class CapturedWritableStream extends Writable {
-  stream;
-  capture;
-  isTTY = true;
-  columns = process.stdout.columns || 80;
-  rows = process.stdout.rows || 24;
-  constructor(stream, capture) {
-    super();
-    this.stream = stream;
-    this.capture = capture;
+  setText(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    if (this._singleTextMemId !== null) {
+      this.lib.textBufferReplaceMemBuffer(this.textBufferPtr, this._singleTextMemId, textBytes, false);
+    } else {
+      this._singleTextMemId = this.lib.textBufferRegisterMemBuffer(this.textBufferPtr, textBytes, false);
+    }
+    this._singleTextBytes = textBytes;
+    this.lib.editBufferSetTextFromMem(this.bufferPtr, this._singleTextMemId);
   }
-  _write(chunk, encoding, callback) {
-    const data = chunk.toString();
-    this.capture.write(this.stream, data);
-    callback();
+  setTextOwned(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this.lib.editBufferSetText(this.bufferPtr, textBytes);
   }
-  getColorDepth() {
-    return process.stdout.getColorDepth?.() || 8;
+  replaceText(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this._textBytes.push(textBytes);
+    const memId = this.lib.textBufferRegisterMemBuffer(this.textBufferPtr, textBytes, false);
+    this.lib.editBufferReplaceTextFromMem(this.bufferPtr, memId);
   }
-}
-
-// src/lib/keymapping.ts
-var defaultKeyAliases = {
-  enter: "return",
-  esc: "escape"
-};
-function mergeKeyAliases(defaults, custom) {
-  return { ...defaults, ...custom };
-}
-function mergeKeyBindings(defaults, custom) {
-  const map = new Map;
-  for (const binding of defaults) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
+  replaceTextOwned(text) {
+    this.guard();
+    const textBytes = this.lib.encoder.encode(text);
+    this.lib.editBufferReplaceText(this.bufferPtr, textBytes);
   }
-  for (const binding of custom) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
+  getLineCount() {
+    this.guard();
+    return this.lib.textBufferGetLineCount(this.textBufferPtr);
   }
-  return Array.from(map.values());
-}
-function getKeyBindingKey(binding) {
-  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
-}
-function buildKeyBindingsMap(bindings, aliasMap) {
-  const map = new Map;
-  const aliases = aliasMap || {};
-  for (const binding of bindings) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding.action);
+  getText() {
+    this.guard();
+    const maxSize = 1024 * 1024;
+    const textBytes = this.lib.editBufferGetText(this.bufferPtr, maxSize);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
   }
-  for (const binding of bindings) {
-    const normalizedName = aliases[binding.name] || binding.name;
-    if (normalizedName !== binding.name) {
-      const aliasedKey = getKeyBindingKey({ ...binding, name: normalizedName });
-      map.set(aliasedKey, binding.action);
-    }
+  insertChar(char) {
+    this.guard();
+    this.lib.editBufferInsertChar(this.bufferPtr, char);
   }
-  return map;
-}
-function keyBindingToString(binding) {
-  const parts = [];
-  if (binding.ctrl)
-    parts.push("ctrl");
-  if (binding.shift)
-    parts.push("shift");
-  if (binding.meta)
-    parts.push("meta");
-  if (binding.super)
-    parts.push("super");
-  parts.push(binding.name);
-  return parts.join("+");
-}
-
-// src/console.ts
-function getCallerInfo() {
-  const err = new Error;
-  const stackLines = err.stack?.split(`
-`).slice(5) || [];
-  if (!stackLines.length)
-    return null;
-  const callerLine = stackLines[0].trim();
-  const regex = /at\s+(?:([\w$.<>]+)\s+\()?((?:\/|[A-Za-z]:\\)[^:]+):(\d+):(\d+)\)?/;
-  const match = callerLine.match(regex);
-  if (!match)
-    return null;
-  const functionName = match[1] || "<anonymous>";
-  const fullPath = match[2];
-  const fileName = fullPath.split(/[\\/]/).pop() || "<unknown>";
-  const lineNumber = parseInt(match[3], 10) || 0;
-  const columnNumber = parseInt(match[4], 10) || 0;
-  return { functionName, fullPath, fileName, lineNumber, columnNumber };
-}
-var capture = singleton("ConsoleCapture", () => new Capture);
-registerEnvVar({
-  name: "OTUI_USE_CONSOLE",
-  description: "Whether to use the console. Will not capture console output if set to false.",
-  type: "boolean",
-  default: true
-});
-registerEnvVar({
-  name: "SHOW_CONSOLE",
-  description: "Show the console at startup if set to true.",
-  type: "boolean",
-  default: false
-});
-
-class TerminalConsoleCache extends EventEmitter7 {
-  _cachedLogs = [];
-  MAX_CACHE_SIZE = 1000;
-  _collectCallerInfo = false;
-  _cachingEnabled = true;
-  _originalConsole = null;
-  get cachedLogs() {
-    return this._cachedLogs;
+  insertText(text) {
+    this.guard();
+    this.lib.editBufferInsertText(this.bufferPtr, text);
   }
-  constructor() {
-    super();
+  deleteChar() {
+    this.guard();
+    this.lib.editBufferDeleteChar(this.bufferPtr);
   }
-  activate() {
-    if (!this._originalConsole) {
-      this._originalConsole = global.console;
-    }
-    this.setupConsoleCapture();
-    this.overrideConsoleMethods();
+  deleteCharBackward() {
+    this.guard();
+    this.lib.editBufferDeleteCharBackward(this.bufferPtr);
   }
-  setupConsoleCapture() {
-    if (!env.OTUI_USE_CONSOLE)
-      return;
-    const mockStdout = new CapturedWritableStream("stdout", capture);
-    const mockStderr = new CapturedWritableStream("stderr", capture);
-    global.console = new Console({
-      stdout: mockStdout,
-      stderr: mockStderr,
-      colorMode: true,
-      inspectOptions: {
-        compact: false,
-        breakLength: 80,
-        depth: 2
-      }
-    });
+  deleteRange(startLine, startCol, endLine, endCol) {
+    this.guard();
+    this.lib.editBufferDeleteRange(this.bufferPtr, startLine, startCol, endLine, endCol);
   }
-  overrideConsoleMethods() {
-    console.log = (...args) => {
-      this.appendToConsole("LOG" /* LOG */, ...args);
-    };
-    console.info = (...args) => {
-      this.appendToConsole("INFO" /* INFO */, ...args);
-    };
-    console.warn = (...args) => {
-      this.appendToConsole("WARN" /* WARN */, ...args);
-    };
-    console.error = (...args) => {
-      this.appendToConsole("ERROR" /* ERROR */, ...args);
-    };
-    console.debug = (...args) => {
-      this.appendToConsole("DEBUG" /* DEBUG */, ...args);
-    };
+  newLine() {
+    this.guard();
+    this.lib.editBufferNewLine(this.bufferPtr);
   }
-  setCollectCallerInfo(enabled) {
-    this._collectCallerInfo = enabled;
+  deleteLine() {
+    this.guard();
+    this.lib.editBufferDeleteLine(this.bufferPtr);
   }
-  clearConsole() {
-    this._cachedLogs = [];
+  moveCursorLeft() {
+    this.guard();
+    this.lib.editBufferMoveCursorLeft(this.bufferPtr);
   }
-  setCachingEnabled(enabled) {
-    this._cachingEnabled = enabled;
+  moveCursorRight() {
+    this.guard();
+    this.lib.editBufferMoveCursorRight(this.bufferPtr);
   }
-  deactivate() {
-    this.restoreOriginalConsole();
+  moveCursorUp() {
+    this.guard();
+    this.lib.editBufferMoveCursorUp(this.bufferPtr);
   }
-  restoreOriginalConsole() {
-    if (this._originalConsole) {
-      global.console = this._originalConsole;
-    }
-    this.setupConsoleCapture();
+  moveCursorDown() {
+    this.guard();
+    this.lib.editBufferMoveCursorDown(this.bufferPtr);
   }
-  addLogEntry(level, ...args) {
-    const callerInfo = this._collectCallerInfo ? getCallerInfo() : null;
-    const logEntry = [new Date, level, args, callerInfo];
+  gotoLine(line) {
+    this.guard();
+    this.lib.editBufferGotoLine(this.bufferPtr, line);
+  }
+  setCursor(line, col) {
+    this.guard();
+    this.lib.editBufferSetCursor(this.bufferPtr, line, col);
+  }
+  setCursorToLineCol(line, col) {
+    this.guard();
+    this.lib.editBufferSetCursorToLineCol(this.bufferPtr, line, col);
+  }
+  setCursorByOffset(offset) {
+    this.guard();
+    this.lib.editBufferSetCursorByOffset(this.bufferPtr, offset);
+  }
+  getCursorPosition() {
+    this.guard();
+    return this.lib.editBufferGetCursorPosition(this.bufferPtr);
+  }
+  getNextWordBoundary() {
+    this.guard();
+    const boundary = this.lib.editBufferGetNextWordBoundary(this.bufferPtr);
+    return {
+      row: boundary.row,
+      col: boundary.col,
+      offset: boundary.offset
+    };
+  }
+  getPrevWordBoundary() {
+    this.guard();
+    const boundary = this.lib.editBufferGetPrevWordBoundary(this.bufferPtr);
+    return {
+      row: boundary.row,
+      col: boundary.col,
+      offset: boundary.offset
+    };
+  }
+  getEOL() {
+    this.guard();
+    const boundary = this.lib.editBufferGetEOL(this.bufferPtr);
+    return {
+      row: boundary.row,
+      col: boundary.col,
+      offset: boundary.offset
+    };
+  }
+  offsetToPosition(offset) {
+    this.guard();
+    const result = this.lib.editBufferOffsetToPosition(this.bufferPtr, offset);
+    if (!result)
+      return null;
+    return { row: result.row, col: result.col };
+  }
+  positionToOffset(row, col) {
+    this.guard();
+    return this.lib.editBufferPositionToOffset(this.bufferPtr, row, col);
+  }
+  getLineStartOffset(row) {
+    this.guard();
+    return this.lib.editBufferGetLineStartOffset(this.bufferPtr, row);
+  }
+  getTextRange(startOffset, endOffset) {
+    this.guard();
+    if (startOffset >= endOffset)
+      return "";
+    const maxSize = 1024 * 1024;
+    const textBytes = this.lib.editBufferGetTextRange(this.bufferPtr, startOffset, endOffset, maxSize);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
+  }
+  getTextRangeByCoords(startRow, startCol, endRow, endCol) {
+    this.guard();
+    const maxSize = 1024 * 1024;
+    const textBytes = this.lib.editBufferGetTextRangeByCoords(this.bufferPtr, startRow, startCol, endRow, endCol, maxSize);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
+  }
+  debugLogRope() {
+    this.guard();
+    this.lib.editBufferDebugLogRope(this.bufferPtr);
+  }
+  undo() {
+    this.guard();
+    const maxSize = 256;
+    const metaBytes = this.lib.editBufferUndo(this.bufferPtr, maxSize);
+    if (!metaBytes)
+      return null;
+    return this.lib.decoder.decode(metaBytes);
+  }
+  redo() {
+    this.guard();
+    const maxSize = 256;
+    const metaBytes = this.lib.editBufferRedo(this.bufferPtr, maxSize);
+    if (!metaBytes)
+      return null;
+    return this.lib.decoder.decode(metaBytes);
+  }
+  canUndo() {
+    this.guard();
+    return this.lib.editBufferCanUndo(this.bufferPtr);
+  }
+  canRedo() {
+    this.guard();
+    return this.lib.editBufferCanRedo(this.bufferPtr);
+  }
+  clearHistory() {
+    this.guard();
+    this.lib.editBufferClearHistory(this.bufferPtr);
+  }
+  setDefaultFg(fg2) {
+    this.guard();
+    this.lib.textBufferSetDefaultFg(this.textBufferPtr, fg2);
+  }
+  setDefaultBg(bg2) {
+    this.guard();
+    this.lib.textBufferSetDefaultBg(this.textBufferPtr, bg2);
+  }
+  setDefaultAttributes(attributes) {
+    this.guard();
+    this.lib.textBufferSetDefaultAttributes(this.textBufferPtr, attributes);
+  }
+  resetDefaults() {
+    this.guard();
+    this.lib.textBufferResetDefaults(this.textBufferPtr);
+  }
+  setSyntaxStyle(style) {
+    this.guard();
+    this._syntaxStyle = style ?? undefined;
+    this.lib.textBufferSetSyntaxStyle(this.textBufferPtr, style?.ptr ?? null);
+  }
+  getSyntaxStyle() {
+    this.guard();
+    return this._syntaxStyle ?? null;
+  }
+  addHighlight(lineIdx, highlight) {
+    this.guard();
+    this.lib.textBufferAddHighlight(this.textBufferPtr, lineIdx, highlight);
+  }
+  addHighlightByCharRange(highlight) {
+    this.guard();
+    this.lib.textBufferAddHighlightByCharRange(this.textBufferPtr, highlight);
+  }
+  removeHighlightsByRef(hlRef) {
+    this.guard();
+    this.lib.textBufferRemoveHighlightsByRef(this.textBufferPtr, hlRef);
+  }
+  clearLineHighlights(lineIdx) {
+    this.guard();
+    this.lib.textBufferClearLineHighlights(this.textBufferPtr, lineIdx);
+  }
+  clearAllHighlights() {
+    this.guard();
+    this.lib.textBufferClearAllHighlights(this.textBufferPtr);
+  }
+  getLineHighlights(lineIdx) {
+    this.guard();
+    return this.lib.textBufferGetLineHighlights(this.textBufferPtr, lineIdx);
+  }
+  clear() {
+    this.guard();
+    this.lib.editBufferClear(this.bufferPtr);
+  }
+  destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
+    EditBuffer.registry.delete(this.id);
+    this.lib.destroyEditBuffer(this.bufferPtr);
+  }
+}
+
+// src/editor-view.ts
+class EditorView {
+  lib;
+  viewPtr;
+  editBuffer;
+  _destroyed = false;
+  _extmarksController;
+  _textBufferViewPtr;
+  constructor(lib, ptr5, editBuffer) {
+    this.lib = lib;
+    this.viewPtr = ptr5;
+    this.editBuffer = editBuffer;
+  }
+  static create(editBuffer, viewportWidth, viewportHeight) {
+    const lib = resolveRenderLib();
+    const viewPtr = lib.createEditorView(editBuffer.ptr, viewportWidth, viewportHeight);
+    return new EditorView(lib, viewPtr, editBuffer);
+  }
+  guard() {
+    if (this._destroyed)
+      throw new Error("EditorView is destroyed");
+  }
+  get ptr() {
+    this.guard();
+    return this.viewPtr;
+  }
+  setViewportSize(width, height) {
+    this.guard();
+    this.lib.editorViewSetViewportSize(this.viewPtr, width, height);
+  }
+  setViewport(x, y, width, height, moveCursor = true) {
+    this.guard();
+    this.lib.editorViewSetViewport(this.viewPtr, x, y, width, height, moveCursor);
+  }
+  getViewport() {
+    this.guard();
+    return this.lib.editorViewGetViewport(this.viewPtr);
+  }
+  setScrollMargin(margin) {
+    this.guard();
+    this.lib.editorViewSetScrollMargin(this.viewPtr, margin);
+  }
+  setWrapMode(mode) {
+    this.guard();
+    this.lib.editorViewSetWrapMode(this.viewPtr, mode);
+  }
+  getVirtualLineCount() {
+    this.guard();
+    return this.lib.editorViewGetVirtualLineCount(this.viewPtr);
+  }
+  getTotalVirtualLineCount() {
+    this.guard();
+    return this.lib.editorViewGetTotalVirtualLineCount(this.viewPtr);
+  }
+  setSelection(start, end, bgColor, fgColor) {
+    this.guard();
+    this.lib.editorViewSetSelection(this.viewPtr, start, end, bgColor || null, fgColor || null);
+  }
+  updateSelection(end, bgColor, fgColor) {
+    this.guard();
+    this.lib.editorViewUpdateSelection(this.viewPtr, end, bgColor || null, fgColor || null);
+  }
+  resetSelection() {
+    this.guard();
+    this.lib.editorViewResetSelection(this.viewPtr);
+  }
+  getSelection() {
+    this.guard();
+    return this.lib.editorViewGetSelection(this.viewPtr);
+  }
+  hasSelection() {
+    this.guard();
+    return this.getSelection() !== null;
+  }
+  setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
+    this.guard();
+    return this.lib.editorViewSetLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null, updateCursor ?? false, followCursor ?? false);
+  }
+  updateLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
+    this.guard();
+    return this.lib.editorViewUpdateLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null, updateCursor ?? false, followCursor ?? false);
+  }
+  resetLocalSelection() {
+    this.guard();
+    this.lib.editorViewResetLocalSelection(this.viewPtr);
+  }
+  getSelectedText() {
+    this.guard();
+    const maxLength = 1024 * 1024;
+    const selectedBytes = this.lib.editorViewGetSelectedTextBytes(this.viewPtr, maxLength);
+    if (!selectedBytes)
+      return "";
+    return this.lib.decoder.decode(selectedBytes);
+  }
+  getCursor() {
+    this.guard();
+    return this.lib.editorViewGetCursor(this.viewPtr);
+  }
+  getText() {
+    this.guard();
+    const maxLength = 1024 * 1024;
+    const textBytes = this.lib.editorViewGetText(this.viewPtr, maxLength);
+    if (!textBytes)
+      return "";
+    return this.lib.decoder.decode(textBytes);
+  }
+  getVisualCursor() {
+    this.guard();
+    return this.lib.editorViewGetVisualCursor(this.viewPtr);
+  }
+  moveUpVisual() {
+    this.guard();
+    this.lib.editorViewMoveUpVisual(this.viewPtr);
+  }
+  moveDownVisual() {
+    this.guard();
+    this.lib.editorViewMoveDownVisual(this.viewPtr);
+  }
+  deleteSelectedText() {
+    this.guard();
+    this.lib.editorViewDeleteSelectedText(this.viewPtr);
+  }
+  setCursorByOffset(offset) {
+    this.guard();
+    this.lib.editorViewSetCursorByOffset(this.viewPtr, offset);
+  }
+  getNextWordBoundary() {
+    this.guard();
+    return this.lib.editorViewGetNextWordBoundary(this.viewPtr);
+  }
+  getPrevWordBoundary() {
+    this.guard();
+    return this.lib.editorViewGetPrevWordBoundary(this.viewPtr);
+  }
+  getEOL() {
+    this.guard();
+    return this.lib.editorViewGetEOL(this.viewPtr);
+  }
+  getVisualSOL() {
+    this.guard();
+    return this.lib.editorViewGetVisualSOL(this.viewPtr);
+  }
+  getVisualEOL() {
+    this.guard();
+    return this.lib.editorViewGetVisualEOL(this.viewPtr);
+  }
+  getLineInfo() {
+    this.guard();
+    return this.lib.editorViewGetLineInfo(this.viewPtr);
+  }
+  getLogicalLineInfo() {
+    this.guard();
+    return this.lib.editorViewGetLogicalLineInfo(this.viewPtr);
+  }
+  get extmarks() {
+    if (!this._extmarksController) {
+      this._extmarksController = createExtmarksController(this.editBuffer, this);
+    }
+    return this._extmarksController;
+  }
+  setPlaceholderStyledText(chunks) {
+    this.guard();
+    this.lib.editorViewSetPlaceholderStyledText(this.viewPtr, chunks);
+  }
+  setTabIndicator(indicator) {
+    this.guard();
+    const codePoint = typeof indicator === "string" ? indicator.codePointAt(0) ?? 0 : indicator;
+    this.lib.editorViewSetTabIndicator(this.viewPtr, codePoint);
+  }
+  setTabIndicatorColor(color) {
+    this.guard();
+    this.lib.editorViewSetTabIndicatorColor(this.viewPtr, color);
+  }
+  measureForDimensions(width, height) {
+    this.guard();
+    if (!this._textBufferViewPtr) {
+      this._textBufferViewPtr = this.lib.editorViewGetTextBufferView(this.viewPtr);
+    }
+    return this.lib.textBufferViewMeasureForDimensions(this._textBufferViewPtr, width, height);
+  }
+  destroy() {
+    if (this._destroyed)
+      return;
+    if (this._extmarksController) {
+      this._extmarksController.destroy();
+      this._extmarksController = undefined;
+    }
+    this._destroyed = true;
+    this.lib.destroyEditorView(this.viewPtr);
+  }
+}
+
+// src/console.ts
+import { EventEmitter as EventEmitter8 } from "events";
+import { Console } from "console";
+import fs from "fs";
+import path5 from "path";
+import util2 from "util";
+
+// src/lib/output.capture.ts
+import { Writable } from "stream";
+import { EventEmitter as EventEmitter7 } from "events";
+
+class Capture extends EventEmitter7 {
+  output = [];
+  constructor() {
+    super();
+  }
+  get size() {
+    return this.output.length;
+  }
+  write(stream, data) {
+    this.output.push({ stream, output: data });
+    this.emit("write", stream, data);
+  }
+  claimOutput() {
+    const output = this.output.map((o) => o.output).join("");
+    this.clear();
+    return output;
+  }
+  clear() {
+    this.output = [];
+  }
+}
+
+class CapturedWritableStream extends Writable {
+  stream;
+  capture;
+  isTTY = true;
+  columns = process.stdout.columns || 80;
+  rows = process.stdout.rows || 24;
+  constructor(stream, capture) {
+    super();
+    this.stream = stream;
+    this.capture = capture;
+  }
+  _write(chunk, encoding, callback) {
+    const data = chunk.toString();
+    this.capture.write(this.stream, data);
+    callback();
+  }
+  getColorDepth() {
+    return process.stdout.getColorDepth?.() || 8;
+  }
+}
+
+// src/lib/keymapping.ts
+var defaultKeyAliases = {
+  enter: "return",
+  esc: "escape",
+  kp0: "0",
+  kp1: "1",
+  kp2: "2",
+  kp3: "3",
+  kp4: "4",
+  kp5: "5",
+  kp6: "6",
+  kp7: "7",
+  kp8: "8",
+  kp9: "9",
+  kpdecimal: ".",
+  kpdivide: "/",
+  kpmultiply: "*",
+  kpminus: "-",
+  kpplus: "+",
+  kpenter: "enter",
+  kpequal: "=",
+  kpseparator: ",",
+  kpleft: "left",
+  kpright: "right",
+  kpup: "up",
+  kpdown: "down",
+  kppageup: "pageup",
+  kppagedown: "pagedown",
+  kphome: "home",
+  kpend: "end",
+  kpinsert: "insert",
+  kpdelete: "delete"
+};
+function mergeKeyAliases(defaults, custom) {
+  return { ...defaults, ...custom };
+}
+function mergeKeyBindings(defaults, custom) {
+  const map = new Map;
+  for (const binding of defaults) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  for (const binding of custom) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  return Array.from(map.values());
+}
+function getKeyBindingKey(binding) {
+  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
+}
+function buildKeyBindingsMap(bindings, aliasMap) {
+  const map = new Map;
+  const aliases = aliasMap || {};
+  for (const binding of bindings) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding.action);
+  }
+  for (const binding of bindings) {
+    const normalizedName = aliases[binding.name] || binding.name;
+    if (normalizedName !== binding.name) {
+      const aliasedKey = getKeyBindingKey({ ...binding, name: normalizedName });
+      map.set(aliasedKey, binding.action);
+    }
+  }
+  return map;
+}
+function keyBindingToString(binding) {
+  const parts = [];
+  if (binding.ctrl)
+    parts.push("ctrl");
+  if (binding.shift)
+    parts.push("shift");
+  if (binding.meta)
+    parts.push("meta");
+  if (binding.super)
+    parts.push("super");
+  parts.push(binding.name);
+  return parts.join("+");
+}
+
+// src/console.ts
+function getCallerInfo() {
+  const err = new Error;
+  const stackLines = err.stack?.split(`
+`).slice(5) || [];
+  if (!stackLines.length)
+    return null;
+  const callerLine = stackLines[0].trim();
+  const regex = /at\s+(?:([\w$.<>]+)\s+\()?((?:\/|[A-Za-z]:\\)[^:]+):(\d+):(\d+)\)?/;
+  const match = callerLine.match(regex);
+  if (!match)
+    return null;
+  const functionName = match[1] || "<anonymous>";
+  const fullPath = match[2];
+  const fileName = fullPath.split(/[\\/]/).pop() || "<unknown>";
+  const lineNumber = parseInt(match[3], 10) || 0;
+  const columnNumber = parseInt(match[4], 10) || 0;
+  return { functionName, fullPath, fileName, lineNumber, columnNumber };
+}
+var capture = singleton("ConsoleCapture", () => new Capture);
+registerEnvVar({
+  name: "OTUI_USE_CONSOLE",
+  description: "Whether to use the console. Will not capture console output if set to false.",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "SHOW_CONSOLE",
+  description: "Show the console at startup if set to true.",
+  type: "boolean",
+  default: false
+});
+
+class TerminalConsoleCache extends EventEmitter8 {
+  _cachedLogs = [];
+  MAX_CACHE_SIZE = 1000;
+  _collectCallerInfo = false;
+  _cachingEnabled = true;
+  _originalConsole = null;
+  get cachedLogs() {
+    return this._cachedLogs;
+  }
+  constructor() {
+    super();
+  }
+  activate() {
+    if (!this._originalConsole) {
+      this._originalConsole = global.console;
+    }
+    this.setupConsoleCapture();
+    this.overrideConsoleMethods();
+  }
+  setupConsoleCapture() {
+    if (!env.OTUI_USE_CONSOLE)
+      return;
+    const mockStdout = new CapturedWritableStream("stdout", capture);
+    const mockStderr = new CapturedWritableStream("stderr", capture);
+    global.console = new Console({
+      stdout: mockStdout,
+      stderr: mockStderr,
+      colorMode: true,
+      inspectOptions: {
+        compact: false,
+        breakLength: 80,
+        depth: 2
+      }
+    });
+  }
+  overrideConsoleMethods() {
+    console.log = (...args) => {
+      this.appendToConsole("LOG" /* LOG */, ...args);
+    };
+    console.info = (...args) => {
+      this.appendToConsole("INFO" /* INFO */, ...args);
+    };
+    console.warn = (...args) => {
+      this.appendToConsole("WARN" /* WARN */, ...args);
+    };
+    console.error = (...args) => {
+      this.appendToConsole("ERROR" /* ERROR */, ...args);
+    };
+    console.debug = (...args) => {
+      this.appendToConsole("DEBUG" /* DEBUG */, ...args);
+    };
+  }
+  setCollectCallerInfo(enabled) {
+    this._collectCallerInfo = enabled;
+  }
+  clearConsole() {
+    this._cachedLogs = [];
+  }
+  setCachingEnabled(enabled) {
+    this._cachingEnabled = enabled;
+  }
+  deactivate() {
+    this.restoreOriginalConsole();
+  }
+  restoreOriginalConsole() {
+    if (this._originalConsole) {
+      global.console = this._originalConsole;
+    }
+  }
+  addLogEntry(level, ...args) {
+    const callerInfo = this._collectCallerInfo ? getCallerInfo() : null;
+    const logEntry = [new Date, level, args, callerInfo];
     if (this._cachingEnabled) {
       if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
         this._cachedLogs.shift();
       }
-      this._cachedLogs.push(logEntry);
+      this._cachedLogs.push(logEntry);
+    }
+    return logEntry;
+  }
+  appendToConsole(level, ...args) {
+    if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
+      this._cachedLogs.shift();
+    }
+    const entry = this.addLogEntry(level, ...args);
+    this.emit("entry", entry);
+  }
+  destroy() {
+    this.deactivate();
+  }
+}
+var terminalConsoleCache = singleton("TerminalConsoleCache", () => {
+  const terminalConsoleCache2 = new TerminalConsoleCache;
+  process.on("exit", () => {
+    terminalConsoleCache2.destroy();
+  });
+  return terminalConsoleCache2;
+});
+var ConsolePosition;
+((ConsolePosition2) => {
+  ConsolePosition2["TOP"] = "top";
+  ConsolePosition2["BOTTOM"] = "bottom";
+  ConsolePosition2["LEFT"] = "left";
+  ConsolePosition2["RIGHT"] = "right";
+})(ConsolePosition ||= {});
+var defaultConsoleKeybindings = [
+  { name: "up", action: "scroll-up" },
+  { name: "down", action: "scroll-down" },
+  { name: "up", shift: true, action: "scroll-to-top" },
+  { name: "down", shift: true, action: "scroll-to-bottom" },
+  { name: "p", ctrl: true, action: "position-previous" },
+  { name: "o", ctrl: true, action: "position-next" },
+  { name: "+", action: "size-increase" },
+  { name: "=", shift: true, action: "size-increase" },
+  { name: "-", action: "size-decrease" },
+  { name: "s", ctrl: true, action: "save-logs" },
+  { name: "c", ctrl: true, shift: true, action: "copy-selection" }
+];
+var DEFAULT_CONSOLE_OPTIONS = {
+  position: "bottom" /* BOTTOM */,
+  sizePercent: 30,
+  zIndex: Infinity,
+  colorInfo: "#00FFFF",
+  colorWarn: "#FFFF00",
+  colorError: "#FF0000",
+  colorDebug: "#808080",
+  colorDefault: "#FFFFFF",
+  backgroundColor: RGBA.fromValues(0.1, 0.1, 0.1, 0.7),
+  startInDebugMode: false,
+  title: "Console",
+  titleBarColor: RGBA.fromValues(0.05, 0.05, 0.05, 0.7),
+  titleBarTextColor: "#FFFFFF",
+  cursorColor: "#00A0FF",
+  maxStoredLogs: 2000,
+  maxDisplayLines: 3000,
+  onCopySelection: undefined,
+  keyBindings: undefined,
+  keyAliasMap: undefined,
+  selectionColor: RGBA.fromValues(0.3, 0.5, 0.8, 0.5),
+  copyButtonColor: "#00A0FF"
+};
+var INDENT_WIDTH = 2;
+
+class TerminalConsole extends EventEmitter8 {
+  isVisible = false;
+  isFocused = false;
+  renderer;
+  keyHandler;
+  options;
+  _debugModeEnabled = false;
+  frameBuffer = null;
+  consoleX = 0;
+  consoleY = 0;
+  consoleWidth = 0;
+  consoleHeight = 0;
+  scrollTopIndex = 0;
+  isScrolledToBottom = true;
+  currentLineIndex = 0;
+  _displayLines = [];
+  _allLogEntries = [];
+  _needsFrameBufferUpdate = false;
+  _entryListener;
+  _selectionStart = null;
+  _selectionEnd = null;
+  _isDragging = false;
+  _copyButtonBounds = {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  };
+  _autoScrollInterval = null;
+  clock;
+  _keyBindingsMap;
+  _keyAliasMap;
+  _keyBindings;
+  _mergedKeyBindings;
+  _actionHandlers;
+  markNeedsRerender() {
+    this._needsFrameBufferUpdate = true;
+    this.renderer.requestRender();
+  }
+  getCopyButtonLabel() {
+    const copyBindings = this._mergedKeyBindings.filter((b) => b.action === "copy-selection");
+    const copyBinding = copyBindings[copyBindings.length - 1];
+    if (copyBinding) {
+      const shortcut = keyBindingToString(copyBinding);
+      return `[Copy (${shortcut})]`;
+    }
+    return "[Copy]";
+  }
+  _rgbaInfo;
+  _rgbaWarn;
+  _rgbaError;
+  _rgbaDebug;
+  _rgbaDefault;
+  backgroundColor;
+  _rgbaTitleBar;
+  _rgbaTitleBarText;
+  _title;
+  _rgbaCursor;
+  _rgbaSelection;
+  _rgbaCopyButton;
+  _positions = [
+    "top" /* TOP */,
+    "right" /* RIGHT */,
+    "bottom" /* BOTTOM */,
+    "left" /* LEFT */
+  ];
+  constructor(renderer, options = {}) {
+    super();
+    this.renderer = renderer;
+    this.clock = options.clock ?? new SystemClock;
+    this.options = { ...DEFAULT_CONSOLE_OPTIONS, ...options };
+    this.keyHandler = this.handleKeyPress.bind(this);
+    this._debugModeEnabled = this.options.startInDebugMode;
+    terminalConsoleCache.setCollectCallerInfo(this._debugModeEnabled);
+    this._rgbaInfo = parseColor(this.options.colorInfo);
+    this._rgbaWarn = parseColor(this.options.colorWarn);
+    this._rgbaError = parseColor(this.options.colorError);
+    this._rgbaDebug = parseColor(this.options.colorDebug);
+    this._rgbaDefault = parseColor(this.options.colorDefault);
+    this.backgroundColor = parseColor(this.options.backgroundColor);
+    this._rgbaTitleBar = parseColor(this.options.titleBarColor);
+    this._rgbaTitleBarText = parseColor(this.options.titleBarTextColor || this.options.colorDefault);
+    this._title = this.options.title;
+    this._rgbaCursor = parseColor(this.options.cursorColor);
+    this._rgbaSelection = parseColor(this.options.selectionColor);
+    this._rgbaCopyButton = parseColor(this.options.copyButtonColor);
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+    this._keyBindings = options.keyBindings || [];
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this._actionHandlers = this.buildActionHandlers();
+    this._updateConsoleDimensions();
+    this._scrollToBottom(true);
+    this._entryListener = (logEntry) => {
+      this._handleNewLog(logEntry);
+    };
+    terminalConsoleCache.on("entry", this._entryListener);
+    if (env.SHOW_CONSOLE) {
+      this.show();
+    }
+  }
+  buildActionHandlers() {
+    return new Map([
+      ["scroll-up", () => this.scrollUp()],
+      ["scroll-down", () => this.scrollDown()],
+      ["scroll-to-top", () => this.scrollToTop()],
+      ["scroll-to-bottom", () => this.scrollToBottomAction()],
+      ["position-previous", () => this.positionPrevious()],
+      ["position-next", () => this.positionNext()],
+      ["size-increase", () => this.sizeIncrease()],
+      ["size-decrease", () => this.sizeDecrease()],
+      ["save-logs", () => this.saveLogsAction()],
+      ["copy-selection", () => this.triggerCopyAction()]
+    ]);
+  }
+  activate() {
+    terminalConsoleCache.activate();
+  }
+  deactivate() {
+    terminalConsoleCache.deactivate();
+  }
+  _handleNewLog(logEntry) {
+    if (!this.isVisible)
+      return;
+    this._allLogEntries.push(logEntry);
+    if (this._allLogEntries.length > this.options.maxStoredLogs) {
+      this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
+    }
+    const newDisplayLines = this._processLogEntry(logEntry);
+    this._displayLines.push(...newDisplayLines);
+    if (this._displayLines.length > this.options.maxDisplayLines) {
+      this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
+      const linesRemoved = this._displayLines.length - this.options.maxDisplayLines;
+      this.scrollTopIndex = Math.max(0, this.scrollTopIndex - linesRemoved);
+    }
+    if (this.isScrolledToBottom) {
+      this._scrollToBottom();
+    }
+    this.markNeedsRerender();
+  }
+  _updateConsoleDimensions(termWidth, termHeight) {
+    const width = termWidth ?? this.renderer.width;
+    const height = termHeight ?? this.renderer.height;
+    const sizePercent = this.options.sizePercent / 100;
+    switch (this.options.position) {
+      case "top" /* TOP */:
+        this.consoleX = 0;
+        this.consoleY = 0;
+        this.consoleWidth = width;
+        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
+        break;
+      case "bottom" /* BOTTOM */:
+        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
+        this.consoleWidth = width;
+        this.consoleX = 0;
+        this.consoleY = height - this.consoleHeight;
+        break;
+      case "left" /* LEFT */:
+        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
+        this.consoleHeight = height;
+        this.consoleX = 0;
+        this.consoleY = 0;
+        break;
+      case "right" /* RIGHT */:
+        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
+        this.consoleHeight = height;
+        this.consoleY = 0;
+        this.consoleX = width - this.consoleWidth;
+        break;
+    }
+    this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
+  }
+  handleKeyPress(event) {
+    if (event.name === "escape") {
+      this.blur();
+      return;
+    }
+    const bindingKey = getKeyBindingKey({
+      name: event.name,
+      ctrl: event.ctrl,
+      shift: event.shift,
+      meta: event.meta,
+      super: event.super,
+      action: "scroll-up"
+    });
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      const handler = this._actionHandlers.get(action);
+      if (handler) {
+        handler();
+        return;
+      }
+    }
+  }
+  scrollUp() {
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    if (this.currentLineIndex > 0) {
+      this.currentLineIndex--;
+      this.markNeedsRerender();
+    } else if (this.scrollTopIndex > 0) {
+      this.scrollTopIndex--;
+      this.isScrolledToBottom = false;
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollDown() {
+    const displayLineCount = this._displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+    const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
+    if (canCursorMoveDown) {
+      this.currentLineIndex++;
+      this.markNeedsRerender();
+    } else if (this.scrollTopIndex < maxScrollTop) {
+      this.scrollTopIndex++;
+      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollToTop() {
+    if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
+      this.scrollTopIndex = 0;
+      this.currentLineIndex = 0;
+      this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollToBottomAction() {
+    const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
+    const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
+    if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
+      this._scrollToBottom(true);
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  positionPrevious() {
+    const currentPositionIndex = this._positions.indexOf(this.options.position);
+    const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
+    this.options.position = this._positions[prevIndex];
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  positionNext() {
+    const currentPositionIndex = this._positions.indexOf(this.options.position);
+    const nextIndex = (currentPositionIndex + 1) % this._positions.length;
+    this.options.position = this._positions[nextIndex];
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  sizeIncrease() {
+    this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  sizeDecrease() {
+    this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  saveLogsAction() {
+    this.saveLogsToFile();
+    return true;
+  }
+  triggerCopyAction() {
+    this.triggerCopy();
+    return true;
+  }
+  attachStdin() {
+    if (this.isFocused)
+      return;
+    this.renderer.keyInput.on("keypress", this.keyHandler);
+    this.isFocused = true;
+  }
+  detachStdin() {
+    if (!this.isFocused)
+      return;
+    this.renderer.keyInput.off("keypress", this.keyHandler);
+    this.isFocused = false;
+  }
+  formatTimestamp(date) {
+    return new Intl.DateTimeFormat("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).format(date);
+  }
+  formatArguments(args) {
+    return args.map((arg) => {
+      if (arg instanceof Error) {
+        const errorProps = arg;
+        return `Error: ${errorProps.message}
+` + (errorProps.stack ? `${errorProps.stack}
+` : "");
+      }
+      if (typeof arg === "object" && arg !== null) {
+        try {
+          return util2.inspect(arg, { depth: 2 });
+        } catch (e) {
+          return String(arg);
+        }
+      }
+      try {
+        return util2.inspect(arg, { depth: 2 });
+      } catch (e) {
+        return String(arg);
+      }
+    }).join(" ");
+  }
+  resize(width, height) {
+    this._updateConsoleDimensions(width, height);
+    if (this.frameBuffer) {
+      this.frameBuffer.resize(this.consoleWidth, this.consoleHeight);
+      const displayLineCount = this._displayLines.length;
+      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+      const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+      this.scrollTopIndex = Math.min(this.scrollTopIndex, maxScrollTop);
+      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+      const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
+      this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, visibleLineCount - 1));
+      if (this.isVisible) {
+        this.markNeedsRerender();
+      }
+    }
+  }
+  clear() {
+    terminalConsoleCache.clearConsole();
+    this._allLogEntries = [];
+    this._displayLines = [];
+    this.markNeedsRerender();
+  }
+  toggle() {
+    if (this.isVisible) {
+      if (this.isFocused) {
+        this.hide();
+      } else {
+        this.focus();
+      }
+    } else {
+      this.show();
+    }
+    if (!this.renderer.isRunning) {
+      this.renderer.requestRender();
+    }
+  }
+  focus() {
+    this.attachStdin();
+    this._scrollToBottom(true);
+    this.markNeedsRerender();
+  }
+  blur() {
+    this.detachStdin();
+    this.markNeedsRerender();
+  }
+  show() {
+    if (!this.isVisible) {
+      this.isVisible = true;
+      this._processCachedLogs();
+      terminalConsoleCache.setCachingEnabled(false);
+      if (!this.frameBuffer) {
+        this.frameBuffer = OptimizedBuffer.create(this.consoleWidth, this.consoleHeight, this.renderer.widthMethod, {
+          respectAlpha: this.backgroundColor.a < 1,
+          id: "console framebuffer"
+        });
+      }
+      const logCount = terminalConsoleCache.cachedLogs.length;
+      const visibleLogLines = Math.min(this.consoleHeight, logCount);
+      this.currentLineIndex = Math.max(0, visibleLogLines - 1);
+      this.scrollTopIndex = 0;
+      this._scrollToBottom(true);
+      this.focus();
+      this.markNeedsRerender();
     }
-    return logEntry;
   }
-  appendToConsole(level, ...args) {
-    if (this._cachedLogs.length >= this.MAX_CACHE_SIZE) {
-      this._cachedLogs.shift();
+  hide() {
+    if (this.isVisible) {
+      this.isVisible = false;
+      this.blur();
+      terminalConsoleCache.setCachingEnabled(true);
     }
-    const entry = this.addLogEntry(level, ...args);
-    this.emit("entry", entry);
   }
   destroy() {
+    this.stopAutoScroll();
+    this.hide();
     this.deactivate();
+    terminalConsoleCache.off("entry", this._entryListener);
   }
-}
-var terminalConsoleCache = singleton("TerminalConsoleCache", () => {
-  const terminalConsoleCache2 = new TerminalConsoleCache;
-  process.on("exit", () => {
-    terminalConsoleCache2.destroy();
-  });
-  return terminalConsoleCache2;
-});
-var ConsolePosition;
-((ConsolePosition2) => {
-  ConsolePosition2["TOP"] = "top";
-  ConsolePosition2["BOTTOM"] = "bottom";
-  ConsolePosition2["LEFT"] = "left";
-  ConsolePosition2["RIGHT"] = "right";
-})(ConsolePosition ||= {});
-var defaultConsoleKeybindings = [
-  { name: "up", action: "scroll-up" },
-  { name: "down", action: "scroll-down" },
-  { name: "up", shift: true, action: "scroll-to-top" },
-  { name: "down", shift: true, action: "scroll-to-bottom" },
-  { name: "p", ctrl: true, action: "position-previous" },
-  { name: "o", ctrl: true, action: "position-next" },
-  { name: "+", action: "size-increase" },
-  { name: "=", shift: true, action: "size-increase" },
-  { name: "-", action: "size-decrease" },
-  { name: "s", ctrl: true, action: "save-logs" },
-  { name: "c", ctrl: true, shift: true, action: "copy-selection" }
-];
-var DEFAULT_CONSOLE_OPTIONS = {
-  position: "bottom" /* BOTTOM */,
-  sizePercent: 30,
-  zIndex: Infinity,
-  colorInfo: "#00FFFF",
-  colorWarn: "#FFFF00",
-  colorError: "#FF0000",
-  colorDebug: "#808080",
-  colorDefault: "#FFFFFF",
-  backgroundColor: RGBA.fromValues(0.1, 0.1, 0.1, 0.7),
-  startInDebugMode: false,
-  title: "Console",
-  titleBarColor: RGBA.fromValues(0.05, 0.05, 0.05, 0.7),
-  titleBarTextColor: "#FFFFFF",
-  cursorColor: "#00A0FF",
-  maxStoredLogs: 2000,
-  maxDisplayLines: 3000,
-  onCopySelection: undefined,
-  keyBindings: undefined,
-  keyAliasMap: undefined,
-  selectionColor: RGBA.fromValues(0.3, 0.5, 0.8, 0.5),
-  copyButtonColor: "#00A0FF"
-};
-var INDENT_WIDTH = 2;
-
-class TerminalConsole extends EventEmitter7 {
-  isVisible = false;
-  isFocused = false;
-  renderer;
-  keyHandler;
-  options;
-  _debugModeEnabled = false;
-  frameBuffer = null;
-  consoleX = 0;
-  consoleY = 0;
-  consoleWidth = 0;
-  consoleHeight = 0;
-  scrollTopIndex = 0;
-  isScrolledToBottom = true;
-  currentLineIndex = 0;
-  _displayLines = [];
-  _allLogEntries = [];
-  _needsFrameBufferUpdate = false;
-  _entryListener;
-  _selectionStart = null;
-  _selectionEnd = null;
-  _isDragging = false;
-  _copyButtonBounds = {
-    x: 0,
-    y: 0,
-    width: 0,
-    height: 0
-  };
-  _autoScrollInterval = null;
-  clock;
-  _keyBindingsMap;
-  _keyAliasMap;
-  _keyBindings;
-  _mergedKeyBindings;
-  _actionHandlers;
-  markNeedsRerender() {
-    this._needsFrameBufferUpdate = true;
-    this.renderer.requestRender();
+  getCachedLogs() {
+    return terminalConsoleCache.cachedLogs.map((logEntry) => logEntry[0].toISOString() + " " + logEntry.slice(1).join(" ")).join(`
+`);
   }
-  getCopyButtonLabel() {
-    const copyBindings = this._mergedKeyBindings.filter((b) => b.action === "copy-selection");
-    const copyBinding = copyBindings[copyBindings.length - 1];
-    if (copyBinding) {
-      const shortcut = keyBindingToString(copyBinding);
-      return `[Copy (${shortcut})]`;
+  updateFrameBuffer() {
+    if (!this.frameBuffer)
+      return;
+    this.frameBuffer.clear(this.backgroundColor);
+    const displayLines = this._displayLines;
+    const displayLineCount = displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    this.frameBuffer.fillRect(0, 0, this.consoleWidth, 1, this._rgbaTitleBar);
+    const dynamicTitle = `${this._title}${this.isFocused ? " (Focused)" : ""}`;
+    const titleX = Math.max(0, Math.floor((this.consoleWidth - dynamicTitle.length) / 2));
+    this.frameBuffer.drawText(dynamicTitle, titleX, 0, this._rgbaTitleBarText, this._rgbaTitleBar);
+    const copyLabel = this.getCopyButtonLabel();
+    const copyButtonX = this.consoleWidth - copyLabel.length - 1;
+    if (copyButtonX >= 0) {
+      const copyButtonEnabled = this.hasSelection();
+      const disabledColor = RGBA.fromInts(100, 100, 100, 255);
+      const copyColor = copyButtonEnabled ? this._rgbaCopyButton : disabledColor;
+      this.frameBuffer.drawText(copyLabel, copyButtonX, 0, copyColor, this._rgbaTitleBar);
+      this._copyButtonBounds = { x: copyButtonX, y: 0, width: copyLabel.length, height: 1 };
+    } else {
+      this._copyButtonBounds = { x: -1, y: -1, width: 0, height: 0 };
     }
-    return "[Copy]";
-  }
-  _rgbaInfo;
-  _rgbaWarn;
-  _rgbaError;
-  _rgbaDebug;
-  _rgbaDefault;
-  backgroundColor;
-  _rgbaTitleBar;
-  _rgbaTitleBarText;
-  _title;
-  _rgbaCursor;
-  _rgbaSelection;
-  _rgbaCopyButton;
-  _positions = [
-    "top" /* TOP */,
-    "right" /* RIGHT */,
-    "bottom" /* BOTTOM */,
-    "left" /* LEFT */
-  ];
-  constructor(renderer, options = {}) {
-    super();
-    this.renderer = renderer;
-    this.clock = options.clock ?? new SystemClock;
-    this.options = { ...DEFAULT_CONSOLE_OPTIONS, ...options };
-    this.keyHandler = this.handleKeyPress.bind(this);
-    this._debugModeEnabled = this.options.startInDebugMode;
-    terminalConsoleCache.setCollectCallerInfo(this._debugModeEnabled);
-    this._rgbaInfo = parseColor(this.options.colorInfo);
-    this._rgbaWarn = parseColor(this.options.colorWarn);
-    this._rgbaError = parseColor(this.options.colorError);
-    this._rgbaDebug = parseColor(this.options.colorDebug);
-    this._rgbaDefault = parseColor(this.options.colorDefault);
-    this.backgroundColor = parseColor(this.options.backgroundColor);
-    this._rgbaTitleBar = parseColor(this.options.titleBarColor);
-    this._rgbaTitleBarText = parseColor(this.options.titleBarTextColor || this.options.colorDefault);
-    this._title = this.options.title;
-    this._rgbaCursor = parseColor(this.options.cursorColor);
-    this._rgbaSelection = parseColor(this.options.selectionColor);
-    this._rgbaCopyButton = parseColor(this.options.copyButtonColor);
-    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
-    this._keyBindings = options.keyBindings || [];
+    const startIndex = this.scrollTopIndex;
+    const endIndex = Math.min(startIndex + logAreaHeight, displayLineCount);
+    const visibleDisplayLines = displayLines.slice(startIndex, endIndex);
+    let lineY = 1;
+    for (let i = 0;i < visibleDisplayLines.length; i++) {
+      if (lineY >= this.consoleHeight)
+        break;
+      const displayLine = visibleDisplayLines[i];
+      const absoluteLineIndex = startIndex + i;
+      let levelColor = this._rgbaDefault;
+      switch (displayLine.level) {
+        case "INFO" /* INFO */:
+          levelColor = this._rgbaInfo;
+          break;
+        case "WARN" /* WARN */:
+          levelColor = this._rgbaWarn;
+          break;
+        case "ERROR" /* ERROR */:
+          levelColor = this._rgbaError;
+          break;
+        case "DEBUG" /* DEBUG */:
+          levelColor = this._rgbaDebug;
+          break;
+      }
+      const linePrefix = displayLine.indent ? " ".repeat(INDENT_WIDTH) : "";
+      const textToDraw = displayLine.text;
+      const textAvailableWidth = this.consoleWidth - 1 - (displayLine.indent ? INDENT_WIDTH : 0);
+      const showCursor = this.isFocused && lineY - 1 === this.currentLineIndex;
+      if (showCursor) {
+        this.frameBuffer.drawText(">", 0, lineY, this._rgbaCursor, this.backgroundColor);
+      } else {
+        this.frameBuffer.drawText(" ", 0, lineY, this._rgbaDefault, this.backgroundColor);
+      }
+      const fullText = `${linePrefix}${textToDraw.substring(0, textAvailableWidth)}`;
+      const selectionRange = this.getLineSelectionRange(absoluteLineIndex);
+      if (selectionRange) {
+        const adjustedStart = Math.max(0, selectionRange.start);
+        const adjustedEnd = Math.min(fullText.length, selectionRange.end);
+        if (adjustedStart > 0) {
+          this.frameBuffer.drawText(fullText.substring(0, adjustedStart), 1, lineY, levelColor);
+        }
+        if (adjustedStart < adjustedEnd) {
+          this.frameBuffer.fillRect(1 + adjustedStart, lineY, adjustedEnd - adjustedStart, 1, this._rgbaSelection);
+          this.frameBuffer.drawText(fullText.substring(adjustedStart, adjustedEnd), 1 + adjustedStart, lineY, levelColor, this._rgbaSelection);
+        }
+        if (adjustedEnd < fullText.length) {
+          this.frameBuffer.drawText(fullText.substring(adjustedEnd), 1 + adjustedEnd, lineY, levelColor);
+        }
+      } else {
+        this.frameBuffer.drawText(fullText, 1, lineY, levelColor);
+      }
+      lineY++;
+    }
+  }
+  renderToBuffer(buffer) {
+    if (!this.isVisible || !this.frameBuffer)
+      return;
+    if (this._needsFrameBufferUpdate) {
+      this.updateFrameBuffer();
+      this._needsFrameBufferUpdate = false;
+    }
+    buffer.drawFrameBuffer(this.consoleX, this.consoleY, this.frameBuffer);
+  }
+  setDebugMode(enabled) {
+    this._debugModeEnabled = enabled;
+    terminalConsoleCache.setCollectCallerInfo(enabled);
+    if (this.isVisible) {
+      this.markNeedsRerender();
+    }
+  }
+  toggleDebugMode() {
+    this.setDebugMode(!this._debugModeEnabled);
+  }
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this.markNeedsRerender();
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
     this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
     this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
-    this._actionHandlers = this.buildActionHandlers();
-    this._updateConsoleDimensions();
-    this._scrollToBottom(true);
-    this._entryListener = (logEntry) => {
-      this._handleNewLog(logEntry);
-    };
-    terminalConsoleCache.on("entry", this._entryListener);
-    if (env.SHOW_CONSOLE) {
-      this.show();
-    }
+    this.markNeedsRerender();
   }
-  buildActionHandlers() {
-    return new Map([
-      ["scroll-up", () => this.scrollUp()],
-      ["scroll-down", () => this.scrollDown()],
-      ["scroll-to-top", () => this.scrollToTop()],
-      ["scroll-to-bottom", () => this.scrollToBottomAction()],
-      ["position-previous", () => this.positionPrevious()],
-      ["position-next", () => this.positionNext()],
-      ["size-increase", () => this.sizeIncrease()],
-      ["size-decrease", () => this.sizeDecrease()],
-      ["save-logs", () => this.saveLogsAction()],
-      ["copy-selection", () => this.triggerCopyAction()]
-    ]);
+  set onCopySelection(callback) {
+    this.options.onCopySelection = callback;
   }
-  activate() {
-    terminalConsoleCache.activate();
+  get onCopySelection() {
+    return this.options.onCopySelection;
   }
-  deactivate() {
-    terminalConsoleCache.deactivate();
+  _scrollToBottom(forceCursorToLastLine = false) {
+    const displayLineCount = this._displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+    this.scrollTopIndex = maxScrollTop;
+    this.isScrolledToBottom = true;
+    const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
+    if (forceCursorToLastLine || this.currentLineIndex >= visibleLineCount) {
+      this.currentLineIndex = Math.max(0, visibleLineCount - 1);
+    }
   }
-  _handleNewLog(logEntry) {
-    if (!this.isVisible)
-      return;
-    this._allLogEntries.push(logEntry);
+  _processLogEntry(logEntry) {
+    const [date, level, args, callerInfo] = logEntry;
+    const displayLines = [];
+    const timestamp = this.formatTimestamp(date);
+    const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
+    const prefix = `[${timestamp}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
+    const formattedArgs = this.formatArguments(args);
+    const initialLines = formattedArgs.split(`
+`);
+    for (let i = 0;i < initialLines.length; i++) {
+      const lineText = initialLines[i];
+      const isFirstLineOfEntry = i === 0;
+      const availableWidth = this.consoleWidth - 1 - (isFirstLineOfEntry ? 0 : INDENT_WIDTH);
+      const linePrefix = isFirstLineOfEntry ? prefix : " ".repeat(INDENT_WIDTH);
+      const textToWrap = isFirstLineOfEntry ? linePrefix + lineText : lineText;
+      let currentPos = 0;
+      while (currentPos < textToWrap.length || isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0) {
+        const segment = textToWrap.substring(currentPos, currentPos + availableWidth);
+        const isFirstSegmentOfLine = currentPos === 0;
+        displayLines.push({
+          text: isFirstSegmentOfLine && !isFirstLineOfEntry ? linePrefix + segment : segment,
+          level,
+          indent: !isFirstLineOfEntry || !isFirstSegmentOfLine
+        });
+        currentPos += availableWidth;
+        if (isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0)
+          break;
+      }
+    }
+    return displayLines;
+  }
+  _processCachedLogs() {
+    const logsToProcess = [...terminalConsoleCache.cachedLogs];
+    terminalConsoleCache.clearConsole();
+    this._allLogEntries.push(...logsToProcess);
     if (this._allLogEntries.length > this.options.maxStoredLogs) {
       this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
     }
-    const newDisplayLines = this._processLogEntry(logEntry);
-    this._displayLines.push(...newDisplayLines);
+    for (const logEntry of logsToProcess) {
+      const processed = this._processLogEntry(logEntry);
+      this._displayLines.push(...processed);
+    }
     if (this._displayLines.length > this.options.maxDisplayLines) {
       this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
-      const linesRemoved = this._displayLines.length - this.options.maxDisplayLines;
-      this.scrollTopIndex = Math.max(0, this.scrollTopIndex - linesRemoved);
     }
-    if (this.isScrolledToBottom) {
-      this._scrollToBottom();
+  }
+  hasSelection() {
+    if (this._selectionStart === null || this._selectionEnd === null)
+      return false;
+    return this._selectionStart.line !== this._selectionEnd.line || this._selectionStart.col !== this._selectionEnd.col;
+  }
+  normalizeSelection() {
+    if (!this._selectionStart || !this._selectionEnd)
+      return null;
+    const start = this._selectionStart;
+    const end = this._selectionEnd;
+    const startBeforeEnd = start.line < end.line || start.line === end.line && start.col <= end.col;
+    if (startBeforeEnd) {
+      return {
+        startLine: start.line,
+        startCol: start.col,
+        endLine: end.line,
+        endCol: end.col
+      };
+    } else {
+      return {
+        startLine: end.line,
+        startCol: end.col,
+        endLine: start.line,
+        endCol: start.col
+      };
     }
-    this.markNeedsRerender();
   }
-  _updateConsoleDimensions(termWidth, termHeight) {
-    const width = termWidth ?? this.renderer.width;
-    const height = termHeight ?? this.renderer.height;
-    const sizePercent = this.options.sizePercent / 100;
-    switch (this.options.position) {
-      case "top" /* TOP */:
-        this.consoleX = 0;
-        this.consoleY = 0;
-        this.consoleWidth = width;
-        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
-        break;
-      case "bottom" /* BOTTOM */:
-        this.consoleHeight = Math.max(1, Math.floor(height * sizePercent));
-        this.consoleWidth = width;
-        this.consoleX = 0;
-        this.consoleY = height - this.consoleHeight;
-        break;
-      case "left" /* LEFT */:
-        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
-        this.consoleHeight = height;
-        this.consoleX = 0;
-        this.consoleY = 0;
-        break;
-      case "right" /* RIGHT */:
-        this.consoleWidth = Math.max(1, Math.floor(width * sizePercent));
-        this.consoleHeight = height;
-        this.consoleY = 0;
-        this.consoleX = width - this.consoleWidth;
-        break;
+  getSelectedText() {
+    const selection2 = this.normalizeSelection();
+    if (!selection2)
+      return "";
+    const lines = [];
+    for (let i = selection2.startLine;i <= selection2.endLine; i++) {
+      if (i < 0 || i >= this._displayLines.length)
+        continue;
+      const line = this._displayLines[i];
+      const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
+      const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
+      const fullText = linePrefix + line.text.substring(0, textAvailableWidth);
+      let text = fullText;
+      if (i === selection2.startLine && i === selection2.endLine) {
+        text = fullText.substring(selection2.startCol, selection2.endCol);
+      } else if (i === selection2.startLine) {
+        text = fullText.substring(selection2.startCol);
+      } else if (i === selection2.endLine) {
+        text = fullText.substring(0, selection2.endCol);
+      }
+      lines.push(text);
     }
-    this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
+    return lines.join(`
+`);
   }
-  handleKeyPress(event) {
-    if (event.name === "escape") {
-      this.blur();
-      return;
+  clearSelection() {
+    this._selectionStart = null;
+    this._selectionEnd = null;
+    this._isDragging = false;
+    this.stopAutoScroll();
+  }
+  stopAutoScroll() {
+    if (this._autoScrollInterval !== null) {
+      this.clock.clearInterval(this._autoScrollInterval);
+      this._autoScrollInterval = null;
     }
-    const bindingKey = getKeyBindingKey({
-      name: event.name,
-      ctrl: event.ctrl,
-      shift: event.shift,
-      meta: event.meta,
-      super: event.super,
-      action: "scroll-up"
-    });
-    const action = this._keyBindingsMap.get(bindingKey);
-    if (action) {
-      const handler = this._actionHandlers.get(action);
-      if (handler) {
-        handler();
-        return;
+  }
+  startAutoScroll(direction) {
+    this.stopAutoScroll();
+    this._autoScrollInterval = this.clock.setInterval(() => {
+      if (direction === "up") {
+        if (this.scrollTopIndex > 0) {
+          this.scrollTopIndex--;
+          this.isScrolledToBottom = false;
+          if (this._selectionEnd) {
+            this._selectionEnd = {
+              line: this.scrollTopIndex,
+              col: this._selectionEnd.col
+            };
+          }
+          this.markNeedsRerender();
+        } else {
+          this.stopAutoScroll();
+        }
+      } else {
+        const displayLineCount = this._displayLines.length;
+        const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+        const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+        if (this.scrollTopIndex < maxScrollTop) {
+          this.scrollTopIndex++;
+          this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+          if (this._selectionEnd) {
+            const maxLine = this.scrollTopIndex + logAreaHeight - 1;
+            this._selectionEnd = {
+              line: Math.min(maxLine, displayLineCount - 1),
+              col: this._selectionEnd.col
+            };
+          }
+          this.markNeedsRerender();
+        } else {
+          this.stopAutoScroll();
+        }
       }
-    }
+    }, 50);
   }
-  scrollUp() {
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    if (this.currentLineIndex > 0) {
-      this.currentLineIndex--;
-      this.markNeedsRerender();
-    } else if (this.scrollTopIndex > 0) {
-      this.scrollTopIndex--;
-      this.isScrolledToBottom = false;
+  triggerCopy() {
+    if (!this.hasSelection())
+      return;
+    const text = this.getSelectedText();
+    if (text && this.options.onCopySelection) {
+      try {
+        this.options.onCopySelection(text);
+      } catch {}
+      this.clearSelection();
       this.markNeedsRerender();
     }
-    return true;
   }
-  scrollDown() {
-    const displayLineCount = this._displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-    const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
-    if (canCursorMoveDown) {
-      this.currentLineIndex++;
-      this.markNeedsRerender();
-    } else if (this.scrollTopIndex < maxScrollTop) {
-      this.scrollTopIndex++;
-      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-      this.markNeedsRerender();
+  getLineSelectionRange(lineIndex) {
+    const selection2 = this.normalizeSelection();
+    if (!selection2)
+      return null;
+    if (lineIndex < selection2.startLine || lineIndex > selection2.endLine) {
+      return null;
     }
-    return true;
+    const line = this._displayLines[lineIndex];
+    if (!line)
+      return null;
+    const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
+    const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
+    const fullTextLength = linePrefix.length + Math.min(line.text.length, textAvailableWidth);
+    let start = 0;
+    let end = fullTextLength;
+    if (lineIndex === selection2.startLine) {
+      start = Math.max(0, selection2.startCol);
+    }
+    if (lineIndex === selection2.endLine) {
+      end = Math.min(fullTextLength, selection2.endCol);
+    }
+    if (start >= end)
+      return null;
+    return { start, end };
   }
-  scrollToTop() {
-    if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
-      this.scrollTopIndex = 0;
-      this.currentLineIndex = 0;
-      this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
+  handleMouse(event) {
+    if (!this.isVisible)
+      return false;
+    const localX = event.x - this.consoleX;
+    const localY = event.y - this.consoleY;
+    if (localX < 0 || localX >= this.consoleWidth || localY < 0 || localY >= this.consoleHeight) {
+      return false;
+    }
+    if (event.type === "scroll" && event.scroll) {
+      if (event.scroll.direction === "up") {
+        this.scrollUp();
+      } else if (event.scroll.direction === "down") {
+        this.scrollDown();
+      }
+      return true;
+    }
+    if (localY === 0) {
+      if (event.type === "down" && event.button === 0 && localX >= this._copyButtonBounds.x && localX < this._copyButtonBounds.x + this._copyButtonBounds.width) {
+        this.triggerCopy();
+        return true;
+      }
+      return true;
+    }
+    const lineIndex = this.scrollTopIndex + (localY - 1);
+    const colIndex = Math.max(0, localX - 1);
+    if (event.type === "down" && event.button === 0) {
+      this.clearSelection();
+      this._selectionStart = { line: lineIndex, col: colIndex };
+      this._selectionEnd = { line: lineIndex, col: colIndex };
+      this._isDragging = true;
       this.markNeedsRerender();
+      return true;
     }
-    return true;
-  }
-  scrollToBottomAction() {
-    const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
-    const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
-    if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
-      this._scrollToBottom(true);
+    if (event.type === "drag" && this._isDragging) {
+      this._selectionEnd = { line: lineIndex, col: colIndex };
+      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+      const relativeY = localY - 1;
+      if (relativeY <= 0) {
+        this.startAutoScroll("up");
+      } else if (relativeY >= logAreaHeight - 1) {
+        this.startAutoScroll("down");
+      } else {
+        this.stopAutoScroll();
+      }
       this.markNeedsRerender();
+      return true;
+    }
+    if (event.type === "up") {
+      if (this._isDragging) {
+        this._selectionEnd = { line: lineIndex, col: colIndex };
+        this._isDragging = false;
+        this.stopAutoScroll();
+        this.markNeedsRerender();
+      }
+      return true;
     }
     return true;
   }
-  positionPrevious() {
-    const currentPositionIndex = this._positions.indexOf(this.options.position);
-    const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
-    this.options.position = this._positions[prevIndex];
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
-  }
-  positionNext() {
-    const currentPositionIndex = this._positions.indexOf(this.options.position);
-    const nextIndex = (currentPositionIndex + 1) % this._positions.length;
-    this.options.position = this._positions[nextIndex];
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
-  }
-  sizeIncrease() {
-    this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
-  }
-  sizeDecrease() {
-    this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
-    this.resize(this.renderer.width, this.renderer.height);
-    return true;
-  }
-  saveLogsAction() {
-    this.saveLogsToFile();
-    return true;
-  }
-  triggerCopyAction() {
-    this.triggerCopy();
-    return true;
-  }
-  attachStdin() {
-    if (this.isFocused)
-      return;
-    this.renderer.keyInput.on("keypress", this.keyHandler);
-    this.isFocused = true;
-  }
-  detachStdin() {
-    if (!this.isFocused)
-      return;
-    this.renderer.keyInput.off("keypress", this.keyHandler);
-    this.isFocused = false;
+  get visible() {
+    return this.isVisible;
   }
-  formatTimestamp(date) {
-    return new Intl.DateTimeFormat("en-US", {
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hour12: false
-    }).format(date);
+  get bounds() {
+    return {
+      x: this.consoleX,
+      y: this.consoleY,
+      width: this.consoleWidth,
+      height: this.consoleHeight
+    };
   }
-  formatArguments(args) {
-    return args.map((arg) => {
-      if (arg instanceof Error) {
-        const errorProps = arg;
-        return `Error: ${errorProps.message}
-` + (errorProps.stack ? `${errorProps.stack}
-` : "");
-      }
-      if (typeof arg === "object" && arg !== null) {
-        try {
-          return util2.inspect(arg, { depth: 2 });
-        } catch (e) {
-          return String(arg);
-        }
-      }
-      try {
-        return util2.inspect(arg, { depth: 2 });
-      } catch (e) {
-        return String(arg);
+  saveLogsToFile() {
+    try {
+      const timestamp = Date.now();
+      const filename = `_console_${timestamp}.log`;
+      const filepath = path5.join(process.cwd(), filename);
+      const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
+      const logLines = [];
+      for (const [date, level, args, callerInfo] of allLogEntries) {
+        const timestampStr = this.formatTimestamp(date);
+        const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
+        const prefix = `[${timestampStr}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
+        const formattedArgs = this.formatArguments(args);
+        logLines.push(prefix + formattedArgs);
       }
-    }).join(" ");
+      const content = logLines.join(`
+`);
+      fs.writeFileSync(filepath, content, "utf8");
+      console.info(`Console logs saved to: ${filename}`);
+    } catch (error) {
+      console.error(`Failed to save console logs:`, error);
+    }
   }
-  resize(width, height) {
-    this._updateConsoleDimensions(width, height);
-    if (this.frameBuffer) {
-      this.frameBuffer.resize(this.consoleWidth, this.consoleHeight);
-      const displayLineCount = this._displayLines.length;
-      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-      const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-      this.scrollTopIndex = Math.min(this.scrollTopIndex, maxScrollTop);
-      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-      const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
-      this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, visibleLineCount - 1));
-      if (this.isVisible) {
-        this.markNeedsRerender();
+}
+
+// src/renderables/EditBufferRenderable.ts
+var BrandedEditBufferRenderable = Symbol.for("@opentui/core/EditBufferRenderable");
+var EditBufferRenderableEvents;
+((EditBufferRenderableEvents2) => {
+  EditBufferRenderableEvents2["TRAITS_CHANGED"] = "traits-changed";
+})(EditBufferRenderableEvents ||= {});
+function sameCapture(a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return !a && !b;
+  if (a.length !== b.length)
+    return false;
+  return a.every((item, i) => item === b[i]);
+}
+function sameTraits(a, b) {
+  return a.suspend === b.suspend && a.status === b.status && sameCapture(a.capture, b.capture);
+}
+function isEditBufferRenderable(obj) {
+  return !!(obj && typeof obj === "object" && (BrandedEditBufferRenderable in obj));
+}
+
+class EditBufferRenderable extends Renderable {
+  [BrandedEditBufferRenderable] = true;
+  _focusable = true;
+  selectable = true;
+  _traits = {};
+  _textColor;
+  _backgroundColor;
+  _defaultAttributes;
+  _selectionBg;
+  _selectionFg;
+  _wrapMode = "word";
+  _scrollMargin = 0.2;
+  _showCursor = true;
+  _cursorColor;
+  _cursorStyle;
+  lastLocalSelection = null;
+  _tabIndicator;
+  _tabIndicatorColor;
+  _cursorChangeListener = undefined;
+  _contentChangeListener = undefined;
+  _autoScrollVelocity = 0;
+  _autoScrollAccumulator = 0;
+  _scrollSpeed = 16;
+  _keyboardSelectionActive = false;
+  editBuffer;
+  editorView;
+  _defaultOptions = {
+    textColor: RGBA.fromValues(1, 1, 1, 1),
+    backgroundColor: "transparent",
+    selectionBg: undefined,
+    selectionFg: undefined,
+    selectable: true,
+    attributes: 0,
+    wrapMode: "word",
+    scrollMargin: 0.2,
+    scrollSpeed: 16,
+    showCursor: true,
+    cursorColor: RGBA.fromValues(1, 1, 1, 1),
+    cursorStyle: {
+      style: "block",
+      blinking: true
+    },
+    tabIndicator: undefined,
+    tabIndicatorColor: undefined
+  };
+  constructor(ctx, options) {
+    super(ctx, options);
+    this._textColor = parseColor(options.textColor ?? this._defaultOptions.textColor);
+    this._backgroundColor = parseColor(options.backgroundColor ?? this._defaultOptions.backgroundColor);
+    this._defaultAttributes = options.attributes ?? this._defaultOptions.attributes;
+    this._selectionBg = options.selectionBg ? parseColor(options.selectionBg) : this._defaultOptions.selectionBg;
+    this._selectionFg = options.selectionFg ? parseColor(options.selectionFg) : this._defaultOptions.selectionFg;
+    this.selectable = options.selectable ?? this._defaultOptions.selectable;
+    this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
+    this._scrollMargin = options.scrollMargin ?? this._defaultOptions.scrollMargin;
+    this._scrollSpeed = options.scrollSpeed ?? this._defaultOptions.scrollSpeed;
+    this._showCursor = options.showCursor ?? this._defaultOptions.showCursor;
+    this._cursorColor = parseColor(options.cursorColor ?? this._defaultOptions.cursorColor);
+    this._cursorStyle = options.cursorStyle ?? this._defaultOptions.cursorStyle;
+    this._tabIndicator = options.tabIndicator ?? this._defaultOptions.tabIndicator;
+    this._tabIndicatorColor = options.tabIndicatorColor ? parseColor(options.tabIndicatorColor) : this._defaultOptions.tabIndicatorColor;
+    this.editBuffer = EditBuffer.create(this._ctx.widthMethod);
+    this.editorView = EditorView.create(this.editBuffer, this.width || 80, this.height || 24);
+    this.editorView.setWrapMode(this._wrapMode);
+    this.editorView.setScrollMargin(this._scrollMargin);
+    this.editBuffer.setDefaultFg(this._textColor);
+    this.editBuffer.setDefaultBg(this._backgroundColor);
+    this.editBuffer.setDefaultAttributes(this._defaultAttributes);
+    if (options.syntaxStyle) {
+      this.editBuffer.setSyntaxStyle(options.syntaxStyle);
+    }
+    if (this._tabIndicator !== undefined) {
+      this.editorView.setTabIndicator(this._tabIndicator);
+    }
+    if (this._tabIndicatorColor !== undefined) {
+      this.editorView.setTabIndicatorColor(this._tabIndicatorColor);
+    }
+    this.setupMeasureFunc();
+    this.setupEventListeners(options);
+  }
+  get lineInfo() {
+    return this.editorView.getLogicalLineInfo();
+  }
+  setupEventListeners(options) {
+    this._cursorChangeListener = options.onCursorChange;
+    this._contentChangeListener = options.onContentChange;
+    this.editBuffer.on("cursor-changed", () => {
+      if (this._cursorChangeListener) {
+        const cursor = this.editBuffer.getCursorPosition();
+        this._cursorChangeListener({
+          line: cursor.row,
+          visualColumn: cursor.col
+        });
       }
-    }
+    });
+    this.editBuffer.on("content-changed", () => {
+      this.yogaNode.markDirty();
+      this.requestRender();
+      this.emit("line-info-change");
+      if (this._contentChangeListener) {
+        this._contentChangeListener({});
+      }
+    });
   }
-  clear() {
-    terminalConsoleCache.clearConsole();
-    this._allLogEntries = [];
-    this._displayLines = [];
-    this.markNeedsRerender();
+  get lineCount() {
+    return this.editBuffer.getLineCount();
   }
-  toggle() {
-    if (this.isVisible) {
-      if (this.isFocused) {
-        this.hide();
-      } else {
-        this.focus();
-      }
-    } else {
-      this.show();
-    }
-    if (!this.renderer.isRunning) {
-      this.renderer.requestRender();
-    }
+  get virtualLineCount() {
+    return this.editorView.getVirtualLineCount();
   }
-  focus() {
-    this.attachStdin();
-    this._scrollToBottom(true);
-    this.markNeedsRerender();
+  get scrollY() {
+    return this.editorView.getViewport().offsetY;
   }
-  blur() {
-    this.detachStdin();
-    this.markNeedsRerender();
+  get plainText() {
+    return this.editBuffer.getText();
   }
-  show() {
-    if (!this.isVisible) {
-      this.isVisible = true;
-      this._processCachedLogs();
-      terminalConsoleCache.setCachingEnabled(false);
-      if (!this.frameBuffer) {
-        this.frameBuffer = OptimizedBuffer.create(this.consoleWidth, this.consoleHeight, this.renderer.widthMethod, {
-          respectAlpha: this.backgroundColor.a < 1,
-          id: "console framebuffer"
-        });
-      }
-      const logCount = terminalConsoleCache.cachedLogs.length;
-      const visibleLogLines = Math.min(this.consoleHeight, logCount);
-      this.currentLineIndex = Math.max(0, visibleLogLines - 1);
-      this.scrollTopIndex = 0;
-      this._scrollToBottom(true);
-      this.focus();
-      this.markNeedsRerender();
+  get logicalCursor() {
+    return this.editBuffer.getCursorPosition();
+  }
+  get visualCursor() {
+    return this.editorView.getVisualCursor();
+  }
+  get cursorOffset() {
+    return this.editorView.getVisualCursor().offset;
+  }
+  set cursorOffset(offset) {
+    this.editorView.setCursorByOffset(offset);
+    this.requestRender();
+  }
+  get cursorCharacterOffset() {
+    const len = this.plainText.length;
+    if (len <= 0)
+      return;
+    const cursor = this.logicalCursor;
+    const offset = this.cursorOffset;
+    if (offset >= len) {
+      if (cursor.col > 0)
+        return len - 1;
+      return 0;
     }
+    if (this.plainText[offset] === `
+` && cursor.col > 0) {
+      return offset - 1;
+    }
+    return offset;
   }
-  hide() {
-    if (this.isVisible) {
-      this.isVisible = false;
-      this.blur();
-      terminalConsoleCache.setCachingEnabled(true);
+  get textColor() {
+    return this._textColor;
+  }
+  set textColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.textColor);
+    if (this._textColor !== newColor) {
+      this._textColor = newColor;
+      this.editBuffer.setDefaultFg(newColor);
+      this.requestRender();
     }
   }
-  destroy() {
-    this.stopAutoScroll();
-    this.hide();
-    this.deactivate();
-    terminalConsoleCache.off("entry", this._entryListener);
+  get selectionBg() {
+    return this._selectionBg;
   }
-  getCachedLogs() {
-    return terminalConsoleCache.cachedLogs.map((logEntry) => logEntry[0].toISOString() + " " + logEntry.slice(1).join(" ")).join(`
-`);
+  get traits() {
+    return this._traits;
   }
-  updateFrameBuffer() {
-    if (!this.frameBuffer)
+  set traits(value) {
+    if (sameTraits(this._traits, value))
       return;
-    this.frameBuffer.clear(this.backgroundColor);
-    const displayLines = this._displayLines;
-    const displayLineCount = displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    this.frameBuffer.fillRect(0, 0, this.consoleWidth, 1, this._rgbaTitleBar);
-    const dynamicTitle = `${this._title}${this.isFocused ? " (Focused)" : ""}`;
-    const titleX = Math.max(0, Math.floor((this.consoleWidth - dynamicTitle.length) / 2));
-    this.frameBuffer.drawText(dynamicTitle, titleX, 0, this._rgbaTitleBarText, this._rgbaTitleBar);
-    const copyLabel = this.getCopyButtonLabel();
-    const copyButtonX = this.consoleWidth - copyLabel.length - 1;
-    if (copyButtonX >= 0) {
-      const copyButtonEnabled = this.hasSelection();
-      const disabledColor = RGBA.fromInts(100, 100, 100, 255);
-      const copyColor = copyButtonEnabled ? this._rgbaCopyButton : disabledColor;
-      this.frameBuffer.drawText(copyLabel, copyButtonX, 0, copyColor, this._rgbaTitleBar);
-      this._copyButtonBounds = { x: copyButtonX, y: 0, width: copyLabel.length, height: 1 };
-    } else {
-      this._copyButtonBounds = { x: -1, y: -1, width: 0, height: 0 };
+    const prev = this._traits;
+    this._traits = value;
+    this.emit("traits-changed" /* TRAITS_CHANGED */, value, prev);
+  }
+  set selectionBg(value) {
+    const newColor = value ? parseColor(value) : this._defaultOptions.selectionBg;
+    if (this._selectionBg !== newColor) {
+      this._selectionBg = newColor;
+      this.refreshSelectionStyle();
+      this.requestRender();
     }
-    const startIndex = this.scrollTopIndex;
-    const endIndex = Math.min(startIndex + logAreaHeight, displayLineCount);
-    const visibleDisplayLines = displayLines.slice(startIndex, endIndex);
-    let lineY = 1;
-    for (let i = 0;i < visibleDisplayLines.length; i++) {
-      if (lineY >= this.consoleHeight)
-        break;
-      const displayLine = visibleDisplayLines[i];
-      const absoluteLineIndex = startIndex + i;
-      let levelColor = this._rgbaDefault;
-      switch (displayLine.level) {
-        case "INFO" /* INFO */:
-          levelColor = this._rgbaInfo;
-          break;
-        case "WARN" /* WARN */:
-          levelColor = this._rgbaWarn;
-          break;
-        case "ERROR" /* ERROR */:
-          levelColor = this._rgbaError;
-          break;
-        case "DEBUG" /* DEBUG */:
-          levelColor = this._rgbaDebug;
-          break;
-      }
-      const linePrefix = displayLine.indent ? " ".repeat(INDENT_WIDTH) : "";
-      const textToDraw = displayLine.text;
-      const textAvailableWidth = this.consoleWidth - 1 - (displayLine.indent ? INDENT_WIDTH : 0);
-      const showCursor = this.isFocused && lineY - 1 === this.currentLineIndex;
-      if (showCursor) {
-        this.frameBuffer.drawText(">", 0, lineY, this._rgbaCursor, this.backgroundColor);
-      } else {
-        this.frameBuffer.drawText(" ", 0, lineY, this._rgbaDefault, this.backgroundColor);
-      }
-      const fullText = `${linePrefix}${textToDraw.substring(0, textAvailableWidth)}`;
-      const selectionRange = this.getLineSelectionRange(absoluteLineIndex);
-      if (selectionRange) {
-        const adjustedStart = Math.max(0, selectionRange.start);
-        const adjustedEnd = Math.min(fullText.length, selectionRange.end);
-        if (adjustedStart > 0) {
-          this.frameBuffer.drawText(fullText.substring(0, adjustedStart), 1, lineY, levelColor);
-        }
-        if (adjustedStart < adjustedEnd) {
-          this.frameBuffer.fillRect(1 + adjustedStart, lineY, adjustedEnd - adjustedStart, 1, this._rgbaSelection);
-          this.frameBuffer.drawText(fullText.substring(adjustedStart, adjustedEnd), 1 + adjustedStart, lineY, levelColor, this._rgbaSelection);
-        }
-        if (adjustedEnd < fullText.length) {
-          this.frameBuffer.drawText(fullText.substring(adjustedEnd), 1 + adjustedEnd, lineY, levelColor);
-        }
-      } else {
-        this.frameBuffer.drawText(fullText, 1, lineY, levelColor);
-      }
-      lineY++;
+  }
+  get selectionFg() {
+    return this._selectionFg;
+  }
+  set selectionFg(value) {
+    const newColor = value ? parseColor(value) : this._defaultOptions.selectionFg;
+    if (this._selectionFg !== newColor) {
+      this._selectionFg = newColor;
+      this.refreshSelectionStyle();
+      this.requestRender();
     }
   }
-  renderToBuffer(buffer) {
-    if (!this.isVisible || !this.frameBuffer)
-      return;
-    if (this._needsFrameBufferUpdate) {
-      this.updateFrameBuffer();
-      this._needsFrameBufferUpdate = false;
+  get backgroundColor() {
+    return this._backgroundColor;
+  }
+  set backgroundColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.backgroundColor);
+    if (this._backgroundColor !== newColor) {
+      this._backgroundColor = newColor;
+      this.editBuffer.setDefaultBg(newColor);
+      this.requestRender();
     }
-    buffer.drawFrameBuffer(this.consoleX, this.consoleY, this.frameBuffer);
   }
-  setDebugMode(enabled) {
-    this._debugModeEnabled = enabled;
-    terminalConsoleCache.setCollectCallerInfo(enabled);
-    if (this.isVisible) {
-      this.markNeedsRerender();
+  get attributes() {
+    return this._defaultAttributes;
+  }
+  set attributes(value) {
+    if (this._defaultAttributes !== value) {
+      this._defaultAttributes = value;
+      this.editBuffer.setDefaultAttributes(value);
+      this.requestRender();
     }
   }
-  toggleDebugMode() {
-    this.setDebugMode(!this._debugModeEnabled);
+  get wrapMode() {
+    return this._wrapMode;
   }
-  set keyBindings(bindings) {
-    this._keyBindings = bindings;
-    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, bindings);
-    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
-    this.markNeedsRerender();
+  set wrapMode(value) {
+    if (this._wrapMode !== value) {
+      this._wrapMode = value;
+      this.editorView.setWrapMode(value);
+      this.yogaNode.markDirty();
+      this.requestRender();
+    }
   }
-  set keyAliasMap(aliases) {
-    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
-    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
-    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
-    this.markNeedsRerender();
+  get showCursor() {
+    return this._showCursor;
   }
-  set onCopySelection(callback) {
-    this.options.onCopySelection = callback;
+  set showCursor(value) {
+    if (this._showCursor !== value) {
+      this._showCursor = value;
+      if (!value && this._focused) {
+        this._ctx.setCursorPosition(0, 0, false);
+      }
+      this.requestRender();
+    }
   }
-  get onCopySelection() {
-    return this.options.onCopySelection;
+  get cursorColor() {
+    return this._cursorColor;
   }
-  _scrollToBottom(forceCursorToLastLine = false) {
-    const displayLineCount = this._displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-    this.scrollTopIndex = maxScrollTop;
-    this.isScrolledToBottom = true;
-    const visibleLineCount = Math.min(logAreaHeight, displayLineCount - this.scrollTopIndex);
-    if (forceCursorToLastLine || this.currentLineIndex >= visibleLineCount) {
-      this.currentLineIndex = Math.max(0, visibleLineCount - 1);
+  set cursorColor(value) {
+    const newColor = parseColor(value);
+    if (this._cursorColor !== newColor) {
+      this._cursorColor = newColor;
+      if (this._focused) {
+        this.requestRender();
+      }
     }
   }
-  _processLogEntry(logEntry) {
-    const [date, level, args, callerInfo] = logEntry;
-    const displayLines = [];
-    const timestamp = this.formatTimestamp(date);
-    const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
-    const prefix = `[${timestamp}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
-    const formattedArgs = this.formatArguments(args);
-    const initialLines = formattedArgs.split(`
-`);
-    for (let i = 0;i < initialLines.length; i++) {
-      const lineText = initialLines[i];
-      const isFirstLineOfEntry = i === 0;
-      const availableWidth = this.consoleWidth - 1 - (isFirstLineOfEntry ? 0 : INDENT_WIDTH);
-      const linePrefix = isFirstLineOfEntry ? prefix : " ".repeat(INDENT_WIDTH);
-      const textToWrap = isFirstLineOfEntry ? linePrefix + lineText : lineText;
-      let currentPos = 0;
-      while (currentPos < textToWrap.length || isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0) {
-        const segment = textToWrap.substring(currentPos, currentPos + availableWidth);
-        const isFirstSegmentOfLine = currentPos === 0;
-        displayLines.push({
-          text: isFirstSegmentOfLine && !isFirstLineOfEntry ? linePrefix + segment : segment,
-          level,
-          indent: !isFirstLineOfEntry || !isFirstSegmentOfLine
-        });
-        currentPos += availableWidth;
-        if (isFirstLineOfEntry && currentPos === 0 && textToWrap.length === 0)
-          break;
+  get cursorStyle() {
+    return this._cursorStyle;
+  }
+  set cursorStyle(style) {
+    const newStyle = style;
+    if (this.cursorStyle.style !== newStyle.style || this.cursorStyle.blinking !== newStyle.blinking) {
+      this._cursorStyle = newStyle;
+      if (this._focused) {
+        this.requestRender();
       }
     }
-    return displayLines;
   }
-  _processCachedLogs() {
-    const logsToProcess = [...terminalConsoleCache.cachedLogs];
-    terminalConsoleCache.clearConsole();
-    this._allLogEntries.push(...logsToProcess);
-    if (this._allLogEntries.length > this.options.maxStoredLogs) {
-      this._allLogEntries.splice(0, this._allLogEntries.length - this.options.maxStoredLogs);
+  get tabIndicator() {
+    return this._tabIndicator;
+  }
+  set tabIndicator(value) {
+    if (this._tabIndicator !== value) {
+      this._tabIndicator = value;
+      if (value !== undefined) {
+        this.editorView.setTabIndicator(value);
+      }
+      this.requestRender();
     }
-    for (const logEntry of logsToProcess) {
-      const processed = this._processLogEntry(logEntry);
-      this._displayLines.push(...processed);
+  }
+  get tabIndicatorColor() {
+    return this._tabIndicatorColor;
+  }
+  set tabIndicatorColor(value) {
+    const newColor = value ? parseColor(value) : undefined;
+    if (this._tabIndicatorColor !== newColor) {
+      this._tabIndicatorColor = newColor;
+      if (newColor !== undefined) {
+        this.editorView.setTabIndicatorColor(newColor);
+      }
+      this.requestRender();
+    }
+  }
+  get scrollSpeed() {
+    return this._scrollSpeed;
+  }
+  set scrollSpeed(value) {
+    this._scrollSpeed = Math.max(0, value);
+  }
+  onMouseEvent(event) {
+    if (event.type === "scroll") {
+      this.handleScroll(event);
+    }
+  }
+  handleScroll(event) {
+    if (!event.scroll)
+      return;
+    const { direction, delta } = event.scroll;
+    const viewport = this.editorView.getViewport();
+    if (direction === "up") {
+      const newOffsetY = Math.max(0, viewport.offsetY - delta);
+      this.editorView.setViewport(viewport.offsetX, newOffsetY, viewport.width, viewport.height, true);
+      this.requestRender();
+    } else if (direction === "down") {
+      const totalVirtualLines = this.editorView.getTotalVirtualLineCount();
+      const maxOffsetY = Math.max(0, totalVirtualLines - viewport.height);
+      const newOffsetY = Math.min(viewport.offsetY + delta, maxOffsetY);
+      this.editorView.setViewport(viewport.offsetX, newOffsetY, viewport.width, viewport.height, true);
+      this.requestRender();
+    }
+    if (this._wrapMode === "none") {
+      if (direction === "left") {
+        const newOffsetX = Math.max(0, viewport.offsetX - delta);
+        this.editorView.setViewport(newOffsetX, viewport.offsetY, viewport.width, viewport.height, true);
+        this.requestRender();
+      } else if (direction === "right") {
+        const newOffsetX = viewport.offsetX + delta;
+        this.editorView.setViewport(newOffsetX, viewport.offsetY, viewport.width, viewport.height, true);
+        this.requestRender();
+      }
     }
-    if (this._displayLines.length > this.options.maxDisplayLines) {
-      this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
+  }
+  onResize(width, height) {
+    this.editorView.setViewportSize(width, height);
+  }
+  refreshLocalSelection() {
+    if (this.lastLocalSelection) {
+      return this.updateLocalSelection(this.lastLocalSelection);
     }
+    return false;
   }
-  hasSelection() {
-    if (this._selectionStart === null || this._selectionEnd === null)
+  updateLocalSelection(localSelection) {
+    if (!localSelection?.isActive) {
+      this.editorView.resetLocalSelection();
+      return true;
+    }
+    return this.editorView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg, false);
+  }
+  shouldStartSelection(x, y) {
+    if (!this.selectable)
       return false;
-    return this._selectionStart.line !== this._selectionEnd.line || this._selectionStart.col !== this._selectionEnd.col;
+    const localX = x - this.x;
+    const localY = y - this.y;
+    return localX >= 0 && localX < this.width && localY >= 0 && localY < this.height;
   }
-  normalizeSelection() {
-    if (!this._selectionStart || !this._selectionEnd)
-      return null;
-    const start = this._selectionStart;
-    const end = this._selectionEnd;
-    const startBeforeEnd = start.line < end.line || start.line === end.line && start.col <= end.col;
-    if (startBeforeEnd) {
-      return {
-        startLine: start.line,
-        startCol: start.col,
-        endLine: end.line,
-        endCol: end.col
-      };
+  onSelectionChanged(selection2) {
+    const localSelection = convertGlobalToLocalSelection(selection2, this.x, this.y);
+    this.lastLocalSelection = localSelection;
+    const updateCursor = true;
+    const followCursor = this._keyboardSelectionActive;
+    let changed;
+    if (!localSelection?.isActive) {
+      this._keyboardSelectionActive = false;
+      this.editorView.resetLocalSelection();
+      changed = true;
+    } else if (selection2?.isStart) {
+      changed = this.editorView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg, updateCursor, followCursor);
     } else {
-      return {
-        startLine: end.line,
-        startCol: end.col,
-        endLine: start.line,
-        endCol: start.col
-      };
+      changed = this.editorView.updateLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg, updateCursor, followCursor);
+    }
+    if (changed && localSelection?.isActive && selection2?.isDragging) {
+      const viewport = this.editorView.getViewport();
+      const focusY = localSelection.focusY;
+      const scrollMargin = Math.max(1, Math.floor(viewport.height * this._scrollMargin));
+      if (focusY < scrollMargin) {
+        this._autoScrollVelocity = -this._scrollSpeed;
+      } else if (focusY >= viewport.height - scrollMargin) {
+        this._autoScrollVelocity = this._scrollSpeed;
+      } else {
+        this._autoScrollVelocity = 0;
+      }
+    } else {
+      this._keyboardSelectionActive = false;
+      this._autoScrollVelocity = 0;
+      this._autoScrollAccumulator = 0;
     }
-  }
-  getSelectedText() {
-    const selection2 = this.normalizeSelection();
-    if (!selection2)
-      return "";
-    const lines = [];
-    for (let i = selection2.startLine;i <= selection2.endLine; i++) {
-      if (i < 0 || i >= this._displayLines.length)
-        continue;
-      const line = this._displayLines[i];
-      const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
-      const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
-      const fullText = linePrefix + line.text.substring(0, textAvailableWidth);
-      let text = fullText;
-      if (i === selection2.startLine && i === selection2.endLine) {
-        text = fullText.substring(selection2.startCol, selection2.endCol);
-      } else if (i === selection2.startLine) {
-        text = fullText.substring(selection2.startCol);
-      } else if (i === selection2.endLine) {
-        text = fullText.substring(0, selection2.endCol);
+    if (changed) {
+      this.requestRender();
+    }
+    return this.hasSelection();
+  }
+  onUpdate(deltaTime) {
+    super.onUpdate(deltaTime);
+    if (this._autoScrollVelocity !== 0 && this.hasSelection()) {
+      const deltaSeconds = deltaTime / 1000;
+      this._autoScrollAccumulator += this._autoScrollVelocity * deltaSeconds;
+      const linesToScroll = Math.floor(Math.abs(this._autoScrollAccumulator));
+      if (linesToScroll > 0) {
+        const direction = this._autoScrollVelocity > 0 ? 1 : -1;
+        const viewport = this.editorView.getViewport();
+        const totalVirtualLines = this.editorView.getTotalVirtualLineCount();
+        const maxOffsetY = Math.max(0, totalVirtualLines - viewport.height);
+        const newOffsetY = Math.max(0, Math.min(viewport.offsetY + direction * linesToScroll, maxOffsetY));
+        if (newOffsetY !== viewport.offsetY) {
+          this.editorView.setViewport(viewport.offsetX, newOffsetY, viewport.width, viewport.height, false);
+          this._ctx.requestSelectionUpdate();
+        }
+        this._autoScrollAccumulator -= direction * linesToScroll;
       }
-      lines.push(text);
     }
-    return lines.join(`
-`);
   }
-  clearSelection() {
-    this._selectionStart = null;
-    this._selectionEnd = null;
-    this._isDragging = false;
-    this.stopAutoScroll();
+  getSelectedText() {
+    return this.editorView.getSelectedText();
   }
-  stopAutoScroll() {
-    if (this._autoScrollInterval !== null) {
-      this.clock.clearInterval(this._autoScrollInterval);
-      this._autoScrollInterval = null;
+  hasSelection() {
+    return this.editorView.hasSelection();
+  }
+  getSelection() {
+    return this.editorView.getSelection();
+  }
+  refreshSelectionStyle() {
+    if (this.lastLocalSelection) {
+      this.updateLocalSelection(this.lastLocalSelection);
+      return;
     }
+    const selection2 = this.getSelection();
+    if (!selection2)
+      return;
+    this.editorView.setSelection(selection2.start, selection2.end, this._selectionBg, this._selectionFg);
   }
-  startAutoScroll(direction) {
-    this.stopAutoScroll();
-    this._autoScrollInterval = this.clock.setInterval(() => {
-      if (direction === "up") {
-        if (this.scrollTopIndex > 0) {
-          this.scrollTopIndex--;
-          this.isScrolledToBottom = false;
-          if (this._selectionEnd) {
-            this._selectionEnd = {
-              line: this.scrollTopIndex,
-              col: this._selectionEnd.col
-            };
-          }
-          this.markNeedsRerender();
-        } else {
-          this.stopAutoScroll();
-        }
-      } else {
-        const displayLineCount = this._displayLines.length;
-        const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-        const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-        if (this.scrollTopIndex < maxScrollTop) {
-          this.scrollTopIndex++;
-          this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-          if (this._selectionEnd) {
-            const maxLine = this.scrollTopIndex + logAreaHeight - 1;
-            this._selectionEnd = {
-              line: Math.min(maxLine, displayLineCount - 1),
-              col: this._selectionEnd.col
-            };
-          }
-          this.markNeedsRerender();
-        } else {
-          this.stopAutoScroll();
-        }
-      }
-    }, 50);
+  deleteSelectedText() {
+    this.editorView.deleteSelectedText();
+    this._ctx.clearSelection();
+    this.requestRender();
   }
-  triggerCopy() {
+  setSelection(start, end) {
+    this.lastLocalSelection = null;
+    this.editorView.resetLocalSelection();
+    this._ctx.clearSelection();
+    this.editorView.setSelection(start, end, this._selectionBg, this._selectionFg);
+    this.requestRender();
+  }
+  setSelectionInclusive(start, end) {
+    this.setSelection(Math.min(start, end), Math.max(start, end) + 1);
+  }
+  clearSelection() {
+    const had = this.hasSelection();
+    this.lastLocalSelection = null;
+    this.editorView.resetSelection();
+    this.editorView.resetLocalSelection();
+    this._ctx.clearSelection();
+    if (had) {
+      this.requestRender();
+    }
+    return had;
+  }
+  deleteSelection() {
     if (!this.hasSelection())
-      return;
-    const text = this.getSelectedText();
-    if (text && this.options.onCopySelection) {
-      try {
-        this.options.onCopySelection(text);
-      } catch {}
-      this.clearSelection();
-      this.markNeedsRerender();
+      return false;
+    this.lastLocalSelection = null;
+    this.deleteSelectedText();
+    return true;
+  }
+  setCursor(row, col) {
+    this.editBuffer.setCursor(row, col);
+    this.requestRender();
+  }
+  insertChar(char) {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
     }
+    this.editBuffer.insertChar(char);
+    this.requestRender();
   }
-  getLineSelectionRange(lineIndex) {
-    const selection2 = this.normalizeSelection();
-    if (!selection2)
-      return null;
-    if (lineIndex < selection2.startLine || lineIndex > selection2.endLine) {
-      return null;
+  insertText(text) {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
     }
-    const line = this._displayLines[lineIndex];
-    if (!line)
-      return null;
-    const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
-    const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
-    const fullTextLength = linePrefix.length + Math.min(line.text.length, textAvailableWidth);
-    let start = 0;
-    let end = fullTextLength;
-    if (lineIndex === selection2.startLine) {
-      start = Math.max(0, selection2.startCol);
+    this.editBuffer.insertText(text);
+    this.requestRender();
+  }
+  deleteChar() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
+      return true;
     }
-    if (lineIndex === selection2.endLine) {
-      end = Math.min(fullTextLength, selection2.endCol);
+    this._ctx.clearSelection();
+    this.editBuffer.deleteChar();
+    this.requestRender();
+    return true;
+  }
+  deleteCharBackward() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
+      return true;
     }
-    if (start >= end)
-      return null;
-    return { start, end };
+    this._ctx.clearSelection();
+    this.editBuffer.deleteCharBackward();
+    this.requestRender();
+    return true;
   }
-  handleMouse(event) {
-    if (!this.isVisible)
-      return false;
-    const localX = event.x - this.consoleX;
-    const localY = event.y - this.consoleY;
-    if (localX < 0 || localX >= this.consoleWidth || localY < 0 || localY >= this.consoleHeight) {
-      return false;
+  newLine() {
+    this._ctx.clearSelection();
+    this.editBuffer.newLine();
+    this.requestRender();
+    return true;
+  }
+  deleteLine() {
+    this._ctx.clearSelection();
+    this.editBuffer.deleteLine();
+    this.requestRender();
+    return true;
+  }
+  moveCursorLeft(options) {
+    const select = options?.select ?? false;
+    if (!select && this.hasSelection()) {
+      const selection2 = this.getSelection();
+      this.editBuffer.setCursorByOffset(selection2.start);
+      this._ctx.clearSelection();
+      this.requestRender();
+      return true;
     }
-    if (event.type === "scroll" && event.scroll) {
-      if (event.scroll.direction === "up") {
-        this.scrollUp();
-      } else if (event.scroll.direction === "down") {
-        this.scrollDown();
-      }
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.moveCursorLeft();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveCursorRight(options) {
+    const select = options?.select ?? false;
+    if (!select && this.hasSelection()) {
+      const selection2 = this.getSelection();
+      const targetOffset = this.cursorOffset === selection2.start ? selection2.end - 1 : selection2.end;
+      this.editBuffer.setCursorByOffset(targetOffset);
+      this._ctx.clearSelection();
+      this.requestRender();
       return true;
     }
-    if (localY === 0) {
-      if (event.type === "down" && event.button === 0 && localX >= this._copyButtonBounds.x && localX < this._copyButtonBounds.x + this._copyButtonBounds.width) {
-        this.triggerCopy();
-        return true;
-      }
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.moveCursorRight();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveCursorUp(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editorView.moveUpVisual();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveCursorDown(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editorView.moveDownVisual();
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoLine(line) {
+    this.editBuffer.gotoLine(line);
+    this.requestRender();
+  }
+  gotoLineStart() {
+    this.setCursor(this.logicalCursor.row, 0);
+  }
+  gotoLineTextEnd() {
+    const eol = this.editBuffer.getEOL();
+    this.setCursor(eol.row, eol.col);
+  }
+  gotoLineHome(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const cursor = this.editorView.getCursor();
+    if (cursor.col === 0 && cursor.row > 0) {
+      this.editBuffer.setCursor(cursor.row - 1, 0);
+      const prevLineEol = this.editBuffer.getEOL();
+      this.editBuffer.setCursor(prevLineEol.row, prevLineEol.col);
+    } else {
+      this.editBuffer.setCursor(cursor.row, 0);
+    }
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoLineEnd(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const cursor = this.editorView.getCursor();
+    const eol = this.editBuffer.getEOL();
+    const lineCount = this.editBuffer.getLineCount();
+    if (cursor.col === eol.col && cursor.row < lineCount - 1) {
+      this.editBuffer.setCursor(cursor.row + 1, 0);
+    } else {
+      this.editBuffer.setCursor(eol.row, eol.col);
+    }
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoVisualLineHome(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const sol = this.editorView.getVisualSOL();
+    this.editBuffer.setCursor(sol.logicalRow, sol.logicalCol);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoVisualLineEnd(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const eol = this.editorView.getVisualEOL();
+    this.editBuffer.setCursor(eol.logicalRow, eol.logicalCol);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoBufferHome(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.setCursor(0, 0);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  gotoBufferEnd(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    this.editBuffer.gotoLine(999999);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  selectAll() {
+    this.updateSelectionForMovement(false, true);
+    this.editBuffer.setCursor(0, 0);
+    return this.gotoBufferEnd({ select: true });
+  }
+  deleteToLineEnd() {
+    const cursor = this.editorView.getCursor();
+    const eol = this.editBuffer.getEOL();
+    if (eol.col > cursor.col) {
+      this.editBuffer.deleteRange(cursor.row, cursor.col, eol.row, eol.col);
+    }
+    this.requestRender();
+    return true;
+  }
+  deleteToLineStart() {
+    const cursor = this.editorView.getCursor();
+    if (cursor.col > 0) {
+      this.editBuffer.deleteRange(cursor.row, 0, cursor.row, cursor.col);
+    }
+    this.requestRender();
+    return true;
+  }
+  undo() {
+    this._ctx.clearSelection();
+    this.editBuffer.undo();
+    this.requestRender();
+    return true;
+  }
+  redo() {
+    this._ctx.clearSelection();
+    this.editBuffer.redo();
+    this.requestRender();
+    return true;
+  }
+  moveWordForward(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const nextWord = this.editBuffer.getNextWordBoundary();
+    this.editBuffer.setCursorByOffset(nextWord.offset);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  moveWordBackward(options) {
+    const select = options?.select ?? false;
+    this.updateSelectionForMovement(select, true);
+    const prevWord = this.editBuffer.getPrevWordBoundary();
+    this.editBuffer.setCursorByOffset(prevWord.offset);
+    this.updateSelectionForMovement(select, false);
+    this.requestRender();
+    return true;
+  }
+  deleteWordForward() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
       return true;
     }
-    const lineIndex = this.scrollTopIndex + (localY - 1);
-    const colIndex = Math.max(0, localX - 1);
-    if (event.type === "down" && event.button === 0) {
-      this.clearSelection();
-      this._selectionStart = { line: lineIndex, col: colIndex };
-      this._selectionEnd = { line: lineIndex, col: colIndex };
-      this._isDragging = true;
-      this.markNeedsRerender();
+    const currentCursor = this.editBuffer.getCursorPosition();
+    const nextWord = this.editBuffer.getNextWordBoundary();
+    if (nextWord.offset > currentCursor.offset) {
+      this.editBuffer.deleteRange(currentCursor.row, currentCursor.col, nextWord.row, nextWord.col);
+    }
+    this._ctx.clearSelection();
+    this.requestRender();
+    return true;
+  }
+  deleteWordBackward() {
+    if (this.hasSelection()) {
+      this.deleteSelectedText();
       return true;
     }
-    if (event.type === "drag" && this._isDragging) {
-      this._selectionEnd = { line: lineIndex, col: colIndex };
-      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-      const relativeY = localY - 1;
-      if (relativeY <= 0) {
-        this.startAutoScroll("up");
-      } else if (relativeY >= logAreaHeight - 1) {
-        this.startAutoScroll("down");
+    const currentCursor = this.editBuffer.getCursorPosition();
+    const prevWord = this.editBuffer.getPrevWordBoundary();
+    if (prevWord.offset < currentCursor.offset) {
+      this.editBuffer.deleteRange(prevWord.row, prevWord.col, currentCursor.row, currentCursor.col);
+    }
+    this._ctx.clearSelection();
+    this.requestRender();
+    return true;
+  }
+  setupMeasureFunc() {
+    const measureFunc = (width, widthMode, height, heightMode) => {
+      let effectiveWidth;
+      if (widthMode === MeasureMode.Undefined || isNaN(width)) {
+        effectiveWidth = 0;
       } else {
-        this.stopAutoScroll();
+        effectiveWidth = width;
       }
-      this.markNeedsRerender();
-      return true;
-    }
-    if (event.type === "up") {
-      if (this._isDragging) {
-        this._selectionEnd = { line: lineIndex, col: colIndex };
-        this._isDragging = false;
-        this.stopAutoScroll();
-        this.markNeedsRerender();
+      const effectiveHeight = isNaN(height) ? 1 : height;
+      const measureResult = this.editorView.measureForDimensions(Math.floor(effectiveWidth), Math.floor(effectiveHeight));
+      const measuredWidth = measureResult ? Math.max(1, measureResult.widthColsMax) : 1;
+      const measuredHeight = measureResult ? Math.max(1, measureResult.lineCount) : 1;
+      if (widthMode === MeasureMode.AtMost && this._positionType !== "absolute") {
+        return {
+          width: Math.min(effectiveWidth, measuredWidth),
+          height: Math.min(effectiveHeight, measuredHeight)
+        };
       }
-      return true;
+      return {
+        width: measuredWidth,
+        height: measuredHeight
+      };
+    };
+    this.yogaNode.setMeasureFunc(measureFunc);
+  }
+  render(buffer, deltaTime) {
+    if (!this.visible)
+      return;
+    if (this.isDestroyed)
+      return;
+    this.markClean();
+    this._ctx.addToHitGrid(this.x, this.y, this.width, this.height, this.num);
+    this.renderSelf(buffer);
+    this.renderCursor(buffer);
+  }
+  renderSelf(buffer) {
+    buffer.drawEditorView(this.editorView, this.x, this.y);
+  }
+  renderCursor(buffer) {
+    if (!this._showCursor || !this._focused)
+      return;
+    const visualCursor = this.editorView.getVisualCursor();
+    const cursorX = this.x + visualCursor.visualCol + 1;
+    const cursorY = this.y + visualCursor.visualRow + 1;
+    this._ctx.setCursorPosition(cursorX, cursorY, true);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
+  }
+  focus() {
+    super.focus();
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
+    this.requestRender();
+  }
+  blur() {
+    super.blur();
+    this._ctx.setCursorPosition(0, 0, false);
+    this.requestRender();
+  }
+  onRemove() {
+    if (this._focused) {
+      this._ctx.setCursorPosition(0, 0, false);
     }
-    return true;
   }
-  get visible() {
-    return this.isVisible;
+  destroy() {
+    if (this.isDestroyed)
+      return;
+    this.traits = {};
+    if (this._focused) {
+      this._ctx.setCursorPosition(0, 0, false);
+      this.blur();
+    }
+    this.editorView.destroy();
+    this.editBuffer.destroy();
+    super.destroy();
   }
-  get bounds() {
-    return {
-      x: this.consoleX,
-      y: this.consoleY,
-      width: this.consoleWidth,
-      height: this.consoleHeight
-    };
+  set onCursorChange(handler) {
+    this._cursorChangeListener = handler;
   }
-  saveLogsToFile() {
-    try {
-      const timestamp = Date.now();
-      const filename = `_console_${timestamp}.log`;
-      const filepath = path5.join(process.cwd(), filename);
-      const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
-      const logLines = [];
-      for (const [date, level, args, callerInfo] of allLogEntries) {
-        const timestampStr = this.formatTimestamp(date);
-        const callerSource = callerInfo ? `${callerInfo.fileName}:${callerInfo.lineNumber}` : "unknown";
-        const prefix = `[${timestampStr}] [${level}]` + (this._debugModeEnabled ? ` [${callerSource}]` : "") + " ";
-        const formattedArgs = this.formatArguments(args);
-        logLines.push(prefix + formattedArgs);
+  get onCursorChange() {
+    return this._cursorChangeListener;
+  }
+  set onContentChange(handler) {
+    this._contentChangeListener = handler;
+  }
+  get onContentChange() {
+    return this._contentChangeListener;
+  }
+  get syntaxStyle() {
+    return this.editBuffer.getSyntaxStyle();
+  }
+  set syntaxStyle(style) {
+    this.editBuffer.setSyntaxStyle(style);
+    this.requestRender();
+  }
+  addHighlight(lineIdx, highlight) {
+    this.editBuffer.addHighlight(lineIdx, highlight);
+    this.requestRender();
+  }
+  addHighlightByCharRange(highlight) {
+    this.editBuffer.addHighlightByCharRange(highlight);
+    this.requestRender();
+  }
+  removeHighlightsByRef(hlRef) {
+    this.editBuffer.removeHighlightsByRef(hlRef);
+    this.requestRender();
+  }
+  clearLineHighlights(lineIdx) {
+    this.editBuffer.clearLineHighlights(lineIdx);
+    this.requestRender();
+  }
+  clearAllHighlights() {
+    this.editBuffer.clearAllHighlights();
+    this.requestRender();
+  }
+  getLineHighlights(lineIdx) {
+    return this.editBuffer.getLineHighlights(lineIdx);
+  }
+  setText(text) {
+    this.editBuffer.setText(text);
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  replaceText(text) {
+    this.editBuffer.replaceText(text);
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  clear() {
+    this.editBuffer.clear();
+    this.editBuffer.clearAllHighlights();
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  deleteRange(startLine, startCol, endLine, endCol) {
+    this.editBuffer.deleteRange(startLine, startCol, endLine, endCol);
+    this.yogaNode.markDirty();
+    this.requestRender();
+  }
+  getTextRange(startOffset, endOffset) {
+    return this.editBuffer.getTextRange(startOffset, endOffset);
+  }
+  getTextRangeByCoords(startRow, startCol, endRow, endCol) {
+    return this.editBuffer.getTextRangeByCoords(startRow, startCol, endRow, endCol);
+  }
+  updateSelectionForMovement(shiftPressed, isBeforeMovement) {
+    if (!this.selectable)
+      return;
+    if (!shiftPressed) {
+      this._keyboardSelectionActive = false;
+      this._ctx.clearSelection();
+      return;
+    }
+    this._keyboardSelectionActive = true;
+    const visualCursor = this.editorView.getVisualCursor();
+    const cursorX = this.x + visualCursor.visualCol;
+    const cursorY = this.y + visualCursor.visualRow;
+    if (isBeforeMovement) {
+      if (!this._ctx.hasSelection) {
+        this._ctx.startSelection(this, cursorX, cursorY);
       }
-      const content = logLines.join(`
-`);
-      fs.writeFileSync(filepath, content, "utf8");
-      console.info(`Console logs saved to: ${filename}`);
-    } catch (error) {
-      console.error(`Failed to save console logs:`, error);
+      return;
     }
+    this._ctx.updateSelection(this, cursorX, cursorY, { finishDragging: true });
   }
 }
 
@@ -17071,7 +18525,7 @@ class Clipboard {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -17209,25 +18663,25 @@ function parsePixelResolution(sequence) {
 // src/renderer.ts
 registerEnvVar({
   name: "OTUI_DUMP_CAPTURES",
-  description: "Dump captured output when the renderer exits.",
+  description: "Dump captured stdout and console caches when the renderer exit handler runs.",
   type: "boolean",
   default: false
 });
 registerEnvVar({
   name: "OTUI_NO_NATIVE_RENDER",
-  description: "Disable native rendering. This will not actually output ansi and is useful for debugging.",
+  description: "Skip the Zig/native frame renderer. Useful for debugging the render loop; split-footer stdout flushing may still write ANSI.",
   type: "boolean",
   default: false
 });
 registerEnvVar({
   name: "OTUI_USE_ALTERNATE_SCREEN",
-  description: "Use the terminal alternate screen buffer.",
+  description: "When explicitly set, force screen mode selection: true=alternate-screen, false=main-screen.",
   type: "boolean",
   default: true
 });
 registerEnvVar({
   name: "OTUI_OVERRIDE_STDOUT",
-  description: "Override the stdout stream. This is useful for debugging.",
+  description: "When explicitly set, force stdout routing: false=passthrough, true=capture in split-footer mode.",
   type: "boolean",
   default: true
 });
@@ -17243,6 +18697,39 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+var DEFAULT_FOOTER_HEIGHT = 12;
+function normalizeFooterHeight(footerHeight) {
+  if (footerHeight === undefined) {
+    return DEFAULT_FOOTER_HEIGHT;
+  }
+  if (!Number.isFinite(footerHeight)) {
+    throw new Error("footerHeight must be a finite number");
+  }
+  const normalizedFooterHeight = Math.trunc(footerHeight);
+  if (normalizedFooterHeight <= 0) {
+    throw new Error("footerHeight must be greater than 0");
+  }
+  return normalizedFooterHeight;
+}
+function resolveModes(config) {
+  let screenMode = config.screenMode ?? "alternate-screen";
+  if (process.env.OTUI_USE_ALTERNATE_SCREEN !== undefined) {
+    screenMode = env.OTUI_USE_ALTERNATE_SCREEN ? "alternate-screen" : "main-screen";
+  }
+  const footerHeight = screenMode === "split-footer" ? normalizeFooterHeight(config.footerHeight) : DEFAULT_FOOTER_HEIGHT;
+  let externalOutputMode = config.externalOutputMode ?? (screenMode === "split-footer" ? "capture-stdout" : "passthrough");
+  if (process.env.OTUI_OVERRIDE_STDOUT !== undefined) {
+    externalOutputMode = env.OTUI_OVERRIDE_STDOUT && screenMode === "split-footer" ? "capture-stdout" : "passthrough";
+  }
+  if (externalOutputMode === "capture-stdout" && screenMode !== "split-footer") {
+    throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+  }
+  return {
+    screenMode,
+    footerHeight,
+    externalOutputMode
+  };
+}
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
   "TERM",
@@ -17259,7 +18746,9 @@ var DEFAULT_FORWARDED_ENV_KEYS = [
   "OPENTUI_FORCE_NOZWJ",
   "OPENTUI_FORCE_EXPLICIT_WIDTH",
   "WT_SESSION",
-  "STY"
+  "STY",
+  "WSL_DISTRO_NAME",
+  "WSL_INTEROP"
 ];
 var KITTY_FLAG_DISAMBIGUATE = 1;
 var KITTY_FLAG_EVENT_TYPES = 2;
@@ -17358,9 +18847,10 @@ async function createCliRenderer(config = {}) {
   }
   const stdin = config.stdin || process.stdin;
   const stdout = config.stdout || process.stdout;
+  const { screenMode, footerHeight } = resolveModes(config);
   const width = stdout.columns || 80;
   const height = stdout.rows || 24;
-  const renderHeight = config.experimental_splitHeight && config.experimental_splitHeight > 0 ? config.experimental_splitHeight : height;
+  const renderHeight = screenMode === "split-footer" ? footerHeight : height;
   const ziglib = resolveRenderLib();
   const rendererPtr = ziglib.createRenderer(width, renderHeight, {
     remote: config.remote ?? false,
@@ -17390,6 +18880,7 @@ var CliRenderEvents;
   CliRenderEvents2["RESIZE"] = "resize";
   CliRenderEvents2["FOCUS"] = "focus";
   CliRenderEvents2["BLUR"] = "blur";
+  CliRenderEvents2["FOCUSED_EDITOR"] = "focused_editor";
   CliRenderEvents2["THEME_MODE"] = "theme_mode";
   CliRenderEvents2["CAPABILITIES"] = "capabilities";
   CliRenderEvents2["SELECTION"] = "selection";
@@ -17407,7 +18898,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter8 {
+class CliRenderer extends EventEmitter9 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -17419,11 +18910,12 @@ class CliRenderer extends EventEmitter8 {
   _isDestroyed = false;
   _destroyPending = false;
   _destroyFinalized = false;
+  _destroyCleanupPrepared = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
-  targetFps = 30;
-  maxFps = 60;
+  _targetFps = 30;
+  _maxFps = 60;
   automaticMemorySnapshot = false;
   memorySnapshotInterval;
   memorySnapshotTimer = null;
@@ -17450,8 +18942,8 @@ class CliRenderer extends EventEmitter8 {
   frameCount = 0;
   lastFpsTime = 0;
   currentFps = 0;
-  targetFrameTime = 1000 / this.targetFps;
-  minTargetFrameTime = 1000 / this.maxFps;
+  targetFrameTime = 1000 / this._targetFps;
+  minTargetFrameTime = 1000 / this._maxFps;
   immediateRerenderRequested = false;
   updateScheduled = false;
   liveRequestCounter = 0;
@@ -17480,7 +18972,9 @@ class CliRenderer extends EventEmitter8 {
   enableMouseMovement = false;
   _useMouse = true;
   autoFocus = true;
-  _useAlternateScreen = env.OTUI_USE_ALTERNATE_SCREEN;
+  _screenMode = "alternate-screen";
+  _footerHeight = DEFAULT_FOOTER_HEIGHT;
+  _externalOutputMode = "passthrough";
   _suspendedMouseEnabled = false;
   _previousControlState = "idle" /* IDLE */;
   capturedRenderable;
@@ -17579,13 +19073,9 @@ Captured output:
     this.width = width;
     this.height = height;
     this._useThread = config.useThread === undefined ? false : config.useThread;
-    this._splitHeight = config.experimental_splitHeight || 0;
-    if (this._splitHeight > 0) {
-      capture.on("write", this.captureCallback);
-      this.renderOffset = height - this._splitHeight;
-      this.height = this._splitHeight;
-      lib.setRenderOffset(rendererPtr, this.renderOffset);
-    }
+    const { screenMode, footerHeight, externalOutputMode } = resolveModes(config);
+    this._footerHeight = footerHeight;
+    this._screenMode = screenMode;
     this.rendererPtr = rendererPtr;
     const forwardEnvKeys = config.forwardEnvKeys ?? [...DEFAULT_FORWARDED_ENV_KEYS];
     for (const key of forwardEnvKeys) {
@@ -17610,8 +19100,6 @@ Captured output:
     this.resizeDebounceDelay = config.debounceDelay || 100;
     this.targetFps = config.targetFps || 30;
     this.maxFps = config.maxFps || 60;
-    this.targetFrameTime = 1000 / this.targetFps;
-    this.minTargetFrameTime = 1000 / this.maxFps;
     this.clock = config.clock ?? new SystemClock;
     this.memorySnapshotInterval = config.memorySnapshotInterval ?? 0;
     this.gatherStats = config.gatherStats || false;
@@ -17619,7 +19107,6 @@ Captured output:
     this.enableMouseMovement = config.enableMouseMovement ?? true;
     this._useMouse = config.useMouse ?? true;
     this.autoFocus = config.autoFocus ?? true;
-    this._useAlternateScreen = config.useAlternateScreen ?? env.OTUI_USE_ALTERNATE_SCREEN;
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
@@ -17628,9 +19115,6 @@ Captured output:
     if (this.memorySnapshotInterval > 0) {
       this.startMemorySnapshotTimer();
     }
-    if (env.OTUI_OVERRIDE_STDOUT) {
-      this.stdout.write = this.interceptStdoutWrite.bind(this);
-    }
     process.on("SIGWINCH", this.sigwinchHandler);
     process.on("warning", this.warningHandler);
     process.on("uncaughtException", this.handleError);
@@ -17650,7 +19134,7 @@ Captured output:
     this.addExitListeners();
     const stdinParserMaxBufferBytes = config.stdinParserMaxBufferBytes ?? DEFAULT_STDIN_PARSER_MAX_BUFFER_BYTES;
     this.stdinParser = new StdinParser({
-      timeoutMs: 10,
+      timeoutMs: 20,
       maxPendingBytes: stdinParserMaxBufferBytes,
       armTimeouts: true,
       onTimeoutFlush: () => {
@@ -17669,7 +19153,9 @@ Captured output:
       ...config.consoleOptions ?? {},
       clock: this.clock
     });
-    this.useConsole = config.useConsole ?? true;
+    this.consoleMode = config.consoleMode ?? "console-overlay";
+    this.applyScreenMode(screenMode, false, false);
+    this.externalOutputMode = externalOutputMode;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
     this._onDestroy = config.onDestroy;
     global.requestAnimationFrame = (callback) => {
@@ -17726,6 +19212,13 @@ Captured output:
   get currentFocusedRenderable() {
     return this._currentFocusedRenderable;
   }
+  get currentFocusedEditor() {
+    if (!this._currentFocusedRenderable)
+      return null;
+    if (!isEditBufferRenderable(this._currentFocusedRenderable))
+      return null;
+    return this._currentFocusedRenderable;
+  }
   normalizeClockTime(now, fallback) {
     if (Number.isFinite(now)) {
       return now;
@@ -17741,10 +19234,15 @@ Captured output:
   focusRenderable(renderable) {
     if (this._currentFocusedRenderable === renderable)
       return;
+    const prev = this.currentFocusedEditor;
     if (this._currentFocusedRenderable) {
       this._currentFocusedRenderable.blur();
     }
     this._currentFocusedRenderable = renderable;
+    const next = this.currentFocusedEditor;
+    if (prev !== next) {
+      this.emit("focused_editor" /* FOCUSED_EDITOR */, next, prev);
+    }
   }
   setCapturedRenderable(renderable) {
     if (this.capturedRenderable === renderable) {
@@ -17805,16 +19303,23 @@ Captured output:
     }
   }
   async activateFrame() {
-    await this.loop();
-    this.updateScheduled = false;
-    this.resolveIdleIfNeeded();
+    if (!this.updateScheduled) {
+      this.resolveIdleIfNeeded();
+      return;
+    }
+    try {
+      await this.loop();
+    } finally {
+      this.updateScheduled = false;
+      this.resolveIdleIfNeeded();
+    }
   }
-  get useConsole() {
-    return this._useConsole;
+  get consoleMode() {
+    return this._useConsole ? "console-overlay" : "disabled";
   }
-  set useConsole(value) {
-    this._useConsole = value;
-    if (value) {
+  set consoleMode(mode) {
+    this._useConsole = mode === "console-overlay";
+    if (this._useConsole) {
       this.console.activate();
     } else {
       this.console.deactivate();
@@ -17864,6 +19369,20 @@ Captured output:
   get useThread() {
     return this._useThread;
   }
+  get targetFps() {
+    return this._targetFps;
+  }
+  set targetFps(targetFps) {
+    this._targetFps = targetFps;
+    this.targetFrameTime = 1000 / this._targetFps;
+  }
+  get maxFps() {
+    return this._maxFps;
+  }
+  set maxFps(maxFps) {
+    this._maxFps = maxFps;
+    this.minTargetFrameTime = 1000 / this._maxFps;
+  }
   get useMouse() {
     return this._useMouse;
   }
@@ -17877,8 +19396,37 @@ Captured output:
       this.disableMouse();
     }
   }
-  get experimental_splitHeight() {
-    return this._splitHeight;
+  get screenMode() {
+    return this._screenMode;
+  }
+  set screenMode(mode) {
+    if (this.externalOutputMode === "capture-stdout" && mode !== "split-footer") {
+      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+    }
+    this.applyScreenMode(mode);
+  }
+  get footerHeight() {
+    return this._footerHeight;
+  }
+  set footerHeight(footerHeight) {
+    const normalizedFooterHeight = normalizeFooterHeight(footerHeight);
+    if (normalizedFooterHeight === this._footerHeight) {
+      return;
+    }
+    this._footerHeight = normalizedFooterHeight;
+    if (this.screenMode === "split-footer") {
+      this.applyScreenMode("split-footer");
+    }
+  }
+  get externalOutputMode() {
+    return this._externalOutputMode;
+  }
+  set externalOutputMode(mode) {
+    if (mode === "capture-stdout" && this.screenMode !== "split-footer") {
+      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+    }
+    this._externalOutputMode = mode;
+    this.stdout.write = mode === "capture-stdout" ? this.interceptStdoutWrite : this.realStdoutWrite;
   }
   get liveRequestCount() {
     return this.liveRequestCounter;
@@ -17902,61 +19450,75 @@ Captured output:
     const flags = use ? KITTY_FLAG_DISAMBIGUATE | KITTY_FLAG_ALTERNATE_KEYS : 0;
     this.lib.setKittyKeyboardFlags(this.rendererPtr, flags);
   }
-  set experimental_splitHeight(splitHeight) {
-    if (splitHeight < 0)
-      splitHeight = 0;
+  interceptStdoutWrite = (chunk, encoding, callback) => {
+    const text = chunk.toString();
+    capture.write("stdout", text);
+    if (this._splitHeight > 0) {
+      this.requestRender();
+    }
+    if (typeof callback === "function") {
+      process.nextTick(callback);
+    }
+    return true;
+  };
+  applyScreenMode(screenMode, emitResize = true, requestRender = true) {
+    const prevScreenMode = this._screenMode;
     const prevSplitHeight = this._splitHeight;
-    if (splitHeight > 0) {
-      this._splitHeight = splitHeight;
-      this.renderOffset = this._terminalHeight - this._splitHeight;
-      this.height = this._splitHeight;
-      if (prevSplitHeight === 0) {
-        this.useConsole = false;
-        capture.on("write", this.captureCallback);
-        const freedLines = this._terminalHeight - this._splitHeight;
+    const nextSplitHeight = screenMode === "split-footer" ? this._footerHeight : 0;
+    if (prevScreenMode === screenMode && prevSplitHeight === nextSplitHeight) {
+      return;
+    }
+    const prevUseAlternateScreen = prevScreenMode === "alternate-screen";
+    const nextUseAlternateScreen = screenMode === "alternate-screen";
+    const terminalScreenModeChanged = this._terminalIsSetup && prevUseAlternateScreen !== nextUseAlternateScreen;
+    const leavingSplitFooter = prevSplitHeight > 0 && nextSplitHeight === 0;
+    if (this._terminalIsSetup && leavingSplitFooter) {
+      this.flushStdoutCache(this._terminalHeight, true);
+    }
+    if (this._terminalIsSetup && !terminalScreenModeChanged) {
+      if (prevSplitHeight === 0 && nextSplitHeight > 0) {
+        const freedLines = this._terminalHeight - nextSplitHeight;
         const scrollDown = ANSI.scrollDown(freedLines);
         this.writeOut(scrollDown);
-      } else if (prevSplitHeight > this._splitHeight) {
-        const freedLines = prevSplitHeight - this._splitHeight;
+      } else if (prevSplitHeight > nextSplitHeight && nextSplitHeight > 0) {
+        const freedLines = prevSplitHeight - nextSplitHeight;
         const scrollDown = ANSI.scrollDown(freedLines);
         this.writeOut(scrollDown);
-      } else if (prevSplitHeight < this._splitHeight) {
-        const additionalLines = this._splitHeight - prevSplitHeight;
+      } else if (prevSplitHeight < nextSplitHeight && prevSplitHeight > 0) {
+        const additionalLines = nextSplitHeight - prevSplitHeight;
         const scrollUp = ANSI.scrollUp(additionalLines);
         this.writeOut(scrollUp);
       }
-    } else {
-      if (prevSplitHeight > 0) {
-        this.flushStdoutCache(this._terminalHeight, true);
-        capture.off("write", this.captureCallback);
-        this.useConsole = true;
-      }
-      this._splitHeight = 0;
-      this.renderOffset = 0;
-      this.height = this._terminalHeight;
     }
+    if (prevSplitHeight === 0 && nextSplitHeight > 0) {
+      capture.on("write", this.captureCallback);
+    } else if (prevSplitHeight > 0 && nextSplitHeight === 0) {
+      capture.off("write", this.captureCallback);
+    }
+    this._screenMode = screenMode;
+    this._splitHeight = nextSplitHeight;
+    this.renderOffset = nextSplitHeight > 0 ? this._terminalHeight - nextSplitHeight : 0;
     this.width = this._terminalWidth;
+    this.height = nextSplitHeight > 0 ? nextSplitHeight : this._terminalHeight;
     this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
     this.lib.resizeRenderer(this.rendererPtr, this.width, this.height);
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
+    this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this._console.resize(this.width, this.height);
     this.root.resize(this.width, this.height);
-    this.emit("resize" /* RESIZE */, this.width, this.height);
-    this.requestRender();
-  }
-  interceptStdoutWrite = (chunk, encoding, callback) => {
-    const text = chunk.toString();
-    capture.write("stdout", text);
-    if (this._splitHeight > 0) {
-      this.requestRender();
+    if (terminalScreenModeChanged) {
+      this.lib.suspendRenderer(this.rendererPtr);
+      this.lib.setupTerminal(this.rendererPtr, nextUseAlternateScreen);
+      if (this._useMouse) {
+        this.enableMouse();
+      }
     }
-    if (typeof callback === "function") {
-      process.nextTick(callback);
+    if (emitResize) {
+      this.emit("resize" /* RESIZE */, this.width, this.height);
+    }
+    if (requestRender) {
+      this.requestRender();
     }
-    return true;
-  };
-  disableStdoutInterception() {
-    this.stdout.write = this.realStdoutWrite;
   }
   flushStdoutCache(space, force = false) {
     if (capture.size === 0 && !force)
@@ -18010,7 +19572,7 @@ Captured output:
       privateCapabilityRepliesActive: true,
       explicitWidthCprActive: true
     });
-    this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
+    this.lib.setupTerminal(this.rendererPtr, this._screenMode === "alternate-screen");
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
     if (this.debugOverlay.enabled) {
       this.lib.setDebugOverlay(this.rendererPtr, true, this.debugOverlay.corner);
@@ -18583,6 +20145,7 @@ Captured output:
   internalStart() {
     if (!this._isRunning && !this._isDestroyed) {
       this._isRunning = true;
+      this.updateScheduled = false;
       if (this.memorySnapshotInterval > 0) {
         this.startMemorySnapshotTimer();
       }
@@ -18670,15 +20233,15 @@ Captured output:
     this._isDestroyed = true;
     this._destroyPending = true;
     if (this.rendering) {
+      this.prepareDestroyDuringRender();
       return;
     }
     this.finalizeDestroy();
   }
-  finalizeDestroy() {
-    if (this._destroyFinalized)
+  cleanupBeforeDestroy() {
+    if (this._destroyCleanupPrepared)
       return;
-    this._destroyFinalized = true;
-    this._destroyPending = false;
+    this._destroyCleanupPrepared = true;
     process.removeListener("SIGWINCH", this.sigwinchHandler);
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
@@ -18696,14 +20259,8 @@ Captured output:
     }
     if (this.memorySnapshotTimer) {
       this.clock.clearInterval(this.memorySnapshotTimer);
+      this.memorySnapshotTimer = null;
     }
-    if (this._paletteDetector) {
-      this._paletteDetector.cleanup();
-      this._paletteDetector = null;
-    }
-    this._paletteDetectionPromise = null;
-    this._cachedPalette = null;
-    this.emit("destroy" /* DESTROY */);
     if (this.renderTimeout) {
       this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
@@ -18716,23 +20273,41 @@ Captured output:
       explicitWidthCprActive: false
     }, true);
     this.setCapturedRenderable(undefined);
+    this.stdin.removeListener("data", this.stdinListener);
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.externalOutputMode = "passthrough";
+    if (this._splitHeight > 0) {
+      this.flushStdoutCache(this._splitHeight, true);
+    }
+  }
+  prepareDestroyDuringRender() {
+    this.cleanupBeforeDestroy();
+    this.lib.suspendRenderer(this.rendererPtr);
+  }
+  finalizeDestroy() {
+    if (this._destroyFinalized)
+      return;
+    this._destroyFinalized = true;
+    this._destroyPending = false;
+    this.cleanupBeforeDestroy();
+    if (this._paletteDetector) {
+      this._paletteDetector.cleanup();
+      this._paletteDetector = null;
+    }
+    this._paletteDetectionPromise = null;
+    this._cachedPalette = null;
+    this.emit("destroy" /* DESTROY */);
     try {
       this.root.destroyRecursively();
     } catch (e) {
       console.error("Error destroying root renderable:", e instanceof Error ? e.stack : String(e));
     }
-    this.stdin.removeListener("data", this.stdinListener);
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(false);
-    }
     this.stdinParser?.destroy();
     this.stdinParser = null;
     this.oscSubscribers.clear();
     this._console.destroy();
-    this.disableStdoutInterception();
-    if (this._splitHeight > 0) {
-      this.flushStdoutCache(this._splitHeight, true);
-    }
     this.lib.destroyRenderer(this.rendererPtr);
     rendererTracker.removeRenderer(this);
     if (this._onDestroy) {
@@ -19027,7 +20602,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, EditBuffer, EditorView, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=B1812E5E11B86E8C64756E2164756E21
-//# sourceMappingURL=index-0dqa35pr.js.map
+//# debugId=3CFEF67BF8CCE60C64756E2164756E21
+//# sourceMappingURL=index-3zw722ea.js.map