@opentui/core 0.1.101 → 0.1.102

package/{index-xsfpee0k.js → index-qpcsqve6.js}

@@ -6867,7 +6867,8 @@ var DEFAULT_PROTOCOL_CONTEXT = {
   kittyKeyboardEnabled: false,
   privateCapabilityRepliesActive: false,
   pixelResolutionQueryActive: false,
-  explicitWidthCprActive: false
+  explicitWidthCprActive: false,
+  startupCursorCprActive: false
 };
 var RXVT_DOLLAR_CSI_RE = /^\x1b\[\d+\$$/;
 var SYSTEM_CLOCK = new SystemClock;
@@ -7056,11 +7057,14 @@ function canStillBeKittySpecial(state) {
 function canStillBeExplicitWidthCpr(state) {
   return state.firstParamValue === 1 && state.semicolons === 1;
 }
+function canStillBeStartupCursorCpr(state) {
+  return state.semicolons === 1;
+}
 function canStillBePixelResolution(state) {
   return state.firstParamValue === 4 && state.semicolons === 2;
 }
 function canDeferParametricCsi(state, context) {
-  return context.kittyKeyboardEnabled && (canStillBeKittyU(state) || canStillBeKittySpecial(state)) || context.explicitWidthCprActive && canStillBeExplicitWidthCpr(state) || context.pixelResolutionQueryActive && canStillBePixelResolution(state);
+  return context.kittyKeyboardEnabled && (canStillBeKittyU(state) || canStillBeKittySpecial(state)) || context.explicitWidthCprActive && canStillBeExplicitWidthCpr(state) || context.startupCursorCprActive && canStillBeStartupCursorCpr(state) || context.pixelResolutionQueryActive && canStillBePixelResolution(state);
 }
 function canCompleteDeferredParametricCsi(state, byte, context) {
   if (context.kittyKeyboardEnabled) {
@@ -7073,11 +7077,20 @@ function canCompleteDeferredParametricCsi(state, byte, context) {
   if (context.explicitWidthCprActive && state.hasDigit && state.firstParamValue === 1 && state.semicolons === 1 && byte === 82) {
     return true;
   }
+  if (context.startupCursorCprActive && state.hasDigit && state.semicolons === 1 && byte === 82) {
+    return true;
+  }
   if (context.pixelResolutionQueryActive && state.hasDigit && state.firstParamValue === 4 && state.semicolons === 2 && byte === 116) {
     return true;
   }
   return false;
 }
+function classifyParametricCsiProtocol(state, finalByte) {
+  if (finalByte === 82 && state.semicolons === 1 && state.segments === 1 && state.hasDigit) {
+    return "cpr";
+  }
+  return "csi";
+}
 function canDeferPrivateReplyCsi(context) {
   return context.privateCapabilityRepliesActive;
 }
@@ -7184,7 +7197,8 @@ class StdinParser {
       kittyKeyboardEnabled: options.protocolContext?.kittyKeyboardEnabled ?? false,
       privateCapabilityRepliesActive: options.protocolContext?.privateCapabilityRepliesActive ?? false,
       pixelResolutionQueryActive: options.protocolContext?.pixelResolutionQueryActive ?? false,
-      explicitWidthCprActive: options.protocolContext?.explicitWidthCprActive ?? false
+      explicitWidthCprActive: options.protocolContext?.explicitWidthCprActive ?? false,
+      startupCursorCprActive: options.protocolContext?.startupCursorCprActive ?? false
     };
   }
   get bufferCapacity() {
@@ -7686,7 +7700,8 @@ class StdinParser {
           }
           if (byte >= 64 && byte <= 126) {
             const end = this.cursor + 1;
-            this.emitKeyOrResponse("csi", decodeUtf8(bytes.subarray(this.unitStart, end)));
+            const protocol = classifyParametricCsiProtocol(this.state, byte);
+            this.emitKeyOrResponse(protocol, decodeUtf8(bytes.subarray(this.unitStart, end)));
             this.state = { tag: "ground" };
             this.consumePrefix(end);
             continue;
@@ -11895,6 +11910,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "bool"],
       returns: "void"
     },
+    setClearOnShutdown: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
     setBackgroundColor: {
       args: ["ptr", "ptr"],
       returns: "void"
@@ -11903,6 +11922,22 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u32"],
       returns: "void"
     },
+    resetSplitScrollback: {
+      args: ["ptr", "u32", "u32"],
+      returns: "u32"
+    },
+    syncSplitScrollback: {
+      args: ["ptr", "u32"],
+      returns: "u32"
+    },
+    setPendingSplitFooterTransition: {
+      args: ["ptr", "u8", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    clearPendingSplitFooterTransition: {
+      args: ["ptr"],
+      returns: "void"
+    },
     updateStats: {
       args: ["ptr", "f64", "u32", "f64"],
       returns: "void"
@@ -11915,6 +11950,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "bool"],
       returns: "void"
     },
+    repaintSplitFooter: {
+      args: ["ptr", "u32", "bool"],
+      returns: "u32"
+    },
+    commitSplitFooterSnapshot: {
+      args: ["ptr", "ptr", "u32", "bool", "bool", "u32", "bool", "bool", "bool"],
+      returns: "u32"
+    },
     getNextBuffer: {
       args: ["ptr"],
       returns: "ptr"
@@ -12387,6 +12430,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u8"],
       returns: "void"
     },
+    textBufferViewSetFirstLineOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
     textBufferViewSetViewportSize: {
       args: ["ptr", "u32", "u32"],
       returns: "void"
@@ -13124,12 +13171,27 @@ class FFIRenderLib {
   setUseThread(renderer, useThread) {
     this.opentui.symbols.setUseThread(renderer, useThread);
   }
+  setClearOnShutdown(renderer, clear) {
+    this.opentui.symbols.setClearOnShutdown(renderer, clear);
+  }
   setBackgroundColor(renderer, color) {
     this.opentui.symbols.setBackgroundColor(renderer, color.buffer);
   }
   setRenderOffset(renderer, offset) {
     this.opentui.symbols.setRenderOffset(renderer, offset);
   }
+  resetSplitScrollback(renderer, seedRows, pinnedRenderOffset) {
+    return this.opentui.symbols.resetSplitScrollback(renderer, seedRows, pinnedRenderOffset);
+  }
+  syncSplitScrollback(renderer, pinnedRenderOffset) {
+    return this.opentui.symbols.syncSplitScrollback(renderer, pinnedRenderOffset);
+  }
+  setPendingSplitFooterTransition(renderer, mode, sourceTopLine, sourceHeight, targetTopLine, targetHeight) {
+    this.opentui.symbols.setPendingSplitFooterTransition(renderer, mode, sourceTopLine, sourceHeight, targetTopLine, targetHeight);
+  }
+  clearPendingSplitFooterTransition(renderer) {
+    this.opentui.symbols.clearPendingSplitFooterTransition(renderer);
+  }
   updateStats(renderer, time, fps, frameCallbackTime) {
     this.opentui.symbols.updateStats(renderer, time, fps, frameCallbackTime);
   }
@@ -13319,6 +13381,12 @@ class FFIRenderLib {
   render(renderer, force) {
     this.opentui.symbols.render(renderer, force);
   }
+  repaintSplitFooter(renderer, pinnedRenderOffset, force) {
+    return this.opentui.symbols.repaintSplitFooter(renderer, pinnedRenderOffset, force);
+  }
+  commitSplitFooterSnapshot(renderer, snapshot, rowColumns, startOnNewLine, trailingNewline, pinnedRenderOffset, force, beginFrame = true, finalizeFrame = true) {
+    return this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, startOnNewLine, trailingNewline, pinnedRenderOffset, force, beginFrame, finalizeFrame);
+  }
   createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
     if (Number.isNaN(width) || Number.isNaN(height)) {
       console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack);
@@ -13598,6 +13666,9 @@ class FFIRenderLib {
     const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2;
     this.opentui.symbols.textBufferViewSetWrapMode(view, modeValue);
   }
+  textBufferViewSetFirstLineOffset(view, offset) {
+    this.opentui.symbols.textBufferViewSetFirstLineOffset(view, offset);
+  }
   textBufferViewSetViewportSize(view, width, height) {
     this.opentui.symbols.textBufferViewSetViewportSize(view, width, height);
   }
@@ -16051,6 +16122,139 @@ function delegate(mapping, vnode) {
   return vnode;
 }
 
+// src/text-buffer-view.ts
+class TextBufferView {
+  lib;
+  viewPtr;
+  textBuffer;
+  _destroyed = false;
+  constructor(lib, ptr5, textBuffer) {
+    this.lib = lib;
+    this.viewPtr = ptr5;
+    this.textBuffer = textBuffer;
+  }
+  static create(textBuffer) {
+    const lib = resolveRenderLib();
+    const viewPtr = lib.createTextBufferView(textBuffer.ptr);
+    return new TextBufferView(lib, viewPtr, textBuffer);
+  }
+  guard() {
+    if (this._destroyed)
+      throw new Error("TextBufferView is destroyed");
+  }
+  get ptr() {
+    this.guard();
+    return this.viewPtr;
+  }
+  setSelection(start, end, bgColor, fgColor) {
+    this.guard();
+    this.lib.textBufferViewSetSelection(this.viewPtr, start, end, bgColor || null, fgColor || null);
+  }
+  updateSelection(end, bgColor, fgColor) {
+    this.guard();
+    this.lib.textBufferViewUpdateSelection(this.viewPtr, end, bgColor || null, fgColor || null);
+  }
+  resetSelection() {
+    this.guard();
+    this.lib.textBufferViewResetSelection(this.viewPtr);
+  }
+  getSelection() {
+    this.guard();
+    return this.lib.textBufferViewGetSelection(this.viewPtr);
+  }
+  hasSelection() {
+    this.guard();
+    return this.getSelection() !== null;
+  }
+  setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    this.guard();
+    return this.lib.textBufferViewSetLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null);
+  }
+  updateLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    this.guard();
+    return this.lib.textBufferViewUpdateLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null);
+  }
+  resetLocalSelection() {
+    this.guard();
+    this.lib.textBufferViewResetLocalSelection(this.viewPtr);
+  }
+  setWrapWidth(width) {
+    this.guard();
+    this.lib.textBufferViewSetWrapWidth(this.viewPtr, width ?? 0);
+  }
+  setWrapMode(mode) {
+    this.guard();
+    this.lib.textBufferViewSetWrapMode(this.viewPtr, mode);
+  }
+  setFirstLineOffset(offset) {
+    this.guard();
+    this.lib.textBufferViewSetFirstLineOffset(this.viewPtr, offset);
+  }
+  setViewportSize(width, height) {
+    this.guard();
+    this.lib.textBufferViewSetViewportSize(this.viewPtr, width, height);
+  }
+  setViewport(x, y, width, height) {
+    this.guard();
+    this.lib.textBufferViewSetViewport(this.viewPtr, x, y, width, height);
+  }
+  get lineInfo() {
+    this.guard();
+    return this.lib.textBufferViewGetLineInfo(this.viewPtr);
+  }
+  get logicalLineInfo() {
+    this.guard();
+    return this.lib.textBufferViewGetLogicalLineInfo(this.viewPtr);
+  }
+  getSelectedText() {
+    this.guard();
+    const byteSize = this.textBuffer.byteSize;
+    if (byteSize === 0)
+      return "";
+    const selectedBytes = this.lib.textBufferViewGetSelectedTextBytes(this.viewPtr, byteSize);
+    if (!selectedBytes)
+      return "";
+    return this.lib.decoder.decode(selectedBytes);
+  }
+  getPlainText() {
+    this.guard();
+    const byteSize = this.textBuffer.byteSize;
+    if (byteSize === 0)
+      return "";
+    const plainBytes = this.lib.textBufferViewGetPlainTextBytes(this.viewPtr, byteSize);
+    if (!plainBytes)
+      return "";
+    return this.lib.decoder.decode(plainBytes);
+  }
+  setTabIndicator(indicator) {
+    this.guard();
+    const codePoint = typeof indicator === "string" ? indicator.codePointAt(0) ?? 0 : indicator;
+    this.lib.textBufferViewSetTabIndicator(this.viewPtr, codePoint);
+  }
+  setTabIndicatorColor(color) {
+    this.guard();
+    this.lib.textBufferViewSetTabIndicatorColor(this.viewPtr, color);
+  }
+  setTruncate(truncate) {
+    this.guard();
+    this.lib.textBufferViewSetTruncate(this.viewPtr, truncate);
+  }
+  measureForDimensions(width, height) {
+    this.guard();
+    return this.lib.textBufferViewMeasureForDimensions(this.viewPtr, width, height);
+  }
+  getVirtualLineCount() {
+    this.guard();
+    return this.lib.textBufferViewGetVirtualLineCount(this.viewPtr);
+  }
+  destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
+    this.lib.destroyTextBufferView(this.viewPtr);
+  }
+}
+
 // src/edit-buffer.ts
 import { EventEmitter as EventEmitter6 } from "events";
 
@@ -16555,117 +16759,1552 @@ class EditorView {
   }
 }
 
-// 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";
+// src/syntax-style.ts
+function convertThemeToStyles(theme) {
+  const flatStyles = {};
+  for (const tokenStyle of theme) {
+    const styleDefinition = {};
+    if (tokenStyle.style.foreground) {
+      styleDefinition.fg = parseColor(tokenStyle.style.foreground);
+    }
+    if (tokenStyle.style.background) {
+      styleDefinition.bg = parseColor(tokenStyle.style.background);
+    }
+    if (tokenStyle.style.bold !== undefined) {
+      styleDefinition.bold = tokenStyle.style.bold;
+    }
+    if (tokenStyle.style.italic !== undefined) {
+      styleDefinition.italic = tokenStyle.style.italic;
+    }
+    if (tokenStyle.style.underline !== undefined) {
+      styleDefinition.underline = tokenStyle.style.underline;
+    }
+    if (tokenStyle.style.dim !== undefined) {
+      styleDefinition.dim = tokenStyle.style.dim;
+    }
+    for (const scope of tokenStyle.scope) {
+      flatStyles[scope] = styleDefinition;
+    }
+  }
+  return flatStyles;
+}
 
-class Capture extends EventEmitter7 {
-  output = [];
-  constructor() {
-    super();
+class SyntaxStyle {
+  lib;
+  stylePtr;
+  _destroyed = false;
+  nameCache = new Map;
+  styleDefs = new Map;
+  mergedCache = new Map;
+  constructor(lib, ptr5) {
+    this.lib = lib;
+    this.stylePtr = ptr5;
   }
-  get size() {
-    return this.output.length;
+  static create() {
+    const lib = resolveRenderLib();
+    const ptr5 = lib.createSyntaxStyle();
+    return new SyntaxStyle(lib, ptr5);
   }
-  write(stream, data) {
-    this.output.push({ stream, output: data });
-    this.emit("write", stream, data);
+  static fromTheme(theme) {
+    const style = SyntaxStyle.create();
+    const flatStyles = convertThemeToStyles(theme);
+    for (const [name, styleDef] of Object.entries(flatStyles)) {
+      style.registerStyle(name, styleDef);
+    }
+    return style;
   }
-  claimOutput() {
-    const output = this.output.map((o) => o.output).join("");
-    this.clear();
-    return output;
+  static fromStyles(styles) {
+    const style = SyntaxStyle.create();
+    for (const [name, styleDef] of Object.entries(styles)) {
+      style.registerStyle(name, styleDef);
+    }
+    return style;
   }
-  clear() {
-    this.output = [];
+  guard() {
+    if (this._destroyed)
+      throw new Error("NativeSyntaxStyle is destroyed");
   }
-}
-
-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;
+  registerStyle(name, style) {
+    this.guard();
+    const attributes = createTextAttributes({
+      bold: style.bold,
+      italic: style.italic,
+      underline: style.underline,
+      dim: style.dim
+    });
+    const id = this.lib.syntaxStyleRegister(this.stylePtr, name, style.fg || null, style.bg || null, attributes);
+    this.nameCache.set(name, id);
+    this.styleDefs.set(name, style);
+    return id;
   }
-  _write(chunk, encoding, callback) {
-    const data = chunk.toString();
-    this.capture.write(this.stream, data);
-    callback();
+  resolveStyleId(name) {
+    this.guard();
+    const cached = this.nameCache.get(name);
+    if (cached !== undefined)
+      return cached;
+    const id = this.lib.syntaxStyleResolveByName(this.stylePtr, name);
+    if (id !== null) {
+      this.nameCache.set(name, id);
+    }
+    return id;
   }
-  getColorDepth() {
-    return process.stdout.getColorDepth?.() || 8;
+  getStyleId(name) {
+    this.guard();
+    const id = this.resolveStyleId(name);
+    if (id !== null)
+      return id;
+    if (name.includes(".")) {
+      const baseName = name.split(".")[0];
+      return this.resolveStyleId(baseName);
+    }
+    return null;
   }
-}
-
-// 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);
+  get ptr() {
+    this.guard();
+    return this.stylePtr;
   }
-  for (const binding of custom) {
-    const key = getKeyBindingKey(binding);
-    map.set(key, binding);
+  getStyleCount() {
+    this.guard();
+    return this.lib.syntaxStyleGetStyleCount(this.stylePtr);
   }
-  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 getBaseCodeKeyName(baseCode) {
-  if (baseCode === undefined || baseCode < 32 || baseCode === 127) {
-    return;
+  clearNameCache() {
+    this.nameCache.clear();
   }
-  try {
-    const name = String.fromCodePoint(baseCode);
+  getStyle(name) {
+    this.guard();
+    if (Object.prototype.hasOwnProperty.call(this.styleDefs, name)) {
+      return;
+    }
+    const style = this.styleDefs.get(name);
+    if (style)
+      return style;
+    if (name.includes(".")) {
+      const baseName = name.split(".")[0];
+      if (Object.prototype.hasOwnProperty.call(this.styleDefs, baseName)) {
+        return;
+      }
+      return this.styleDefs.get(baseName);
+    }
+    return;
+  }
+  mergeStyles(...styleNames) {
+    this.guard();
+    const cacheKey = styleNames.join(":");
+    const cached = this.mergedCache.get(cacheKey);
+    if (cached)
+      return cached;
+    const styleDefinition = {};
+    for (const name of styleNames) {
+      const style = this.getStyle(name);
+      if (!style)
+        continue;
+      if (style.fg)
+        styleDefinition.fg = style.fg;
+      if (style.bg)
+        styleDefinition.bg = style.bg;
+      if (style.bold !== undefined)
+        styleDefinition.bold = style.bold;
+      if (style.italic !== undefined)
+        styleDefinition.italic = style.italic;
+      if (style.underline !== undefined)
+        styleDefinition.underline = style.underline;
+      if (style.dim !== undefined)
+        styleDefinition.dim = style.dim;
+    }
+    const attributes = createTextAttributes({
+      bold: styleDefinition.bold,
+      italic: styleDefinition.italic,
+      underline: styleDefinition.underline,
+      dim: styleDefinition.dim
+    });
+    const merged = {
+      fg: styleDefinition.fg,
+      bg: styleDefinition.bg,
+      attributes
+    };
+    this.mergedCache.set(cacheKey, merged);
+    return merged;
+  }
+  clearCache() {
+    this.guard();
+    this.mergedCache.clear();
+  }
+  getCacheSize() {
+    this.guard();
+    return this.mergedCache.size;
+  }
+  getAllStyles() {
+    this.guard();
+    return new Map(this.styleDefs);
+  }
+  getRegisteredNames() {
+    this.guard();
+    return Array.from(this.styleDefs.keys());
+  }
+  destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
+    this.nameCache.clear();
+    this.styleDefs.clear();
+    this.mergedCache.clear();
+    this.lib.destroySyntaxStyle(this.stylePtr);
+  }
+}
+
+// src/renderables/Box.ts
+function isGapType(value) {
+  if (value === undefined) {
+    return true;
+  }
+  if (typeof value === "number" && !Number.isNaN(value)) {
+    return true;
+  }
+  return isValidPercentage(value);
+}
+
+class BoxRenderable extends Renderable {
+  _backgroundColor;
+  _border;
+  _borderStyle;
+  _borderColor;
+  _focusedBorderColor;
+  _customBorderCharsObj;
+  _customBorderChars;
+  borderSides;
+  shouldFill;
+  _title;
+  _titleAlignment;
+  _bottomTitle;
+  _bottomTitleAlignment;
+  _defaultOptions = {
+    backgroundColor: "transparent",
+    borderStyle: "single",
+    border: false,
+    borderColor: "#FFFFFF",
+    shouldFill: true,
+    titleAlignment: "left",
+    bottomTitleAlignment: "left",
+    focusedBorderColor: "#00AAFF"
+  };
+  constructor(ctx, options) {
+    super(ctx, options);
+    if (options.focusable === true) {
+      this._focusable = true;
+    }
+    this._backgroundColor = parseColor(options.backgroundColor || this._defaultOptions.backgroundColor);
+    this._border = options.border ?? this._defaultOptions.border;
+    if (!options.border && (options.borderStyle || options.borderColor || options.focusedBorderColor || options.customBorderChars)) {
+      this._border = true;
+    }
+    this._borderStyle = parseBorderStyle(options.borderStyle, this._defaultOptions.borderStyle);
+    this._borderColor = parseColor(options.borderColor || this._defaultOptions.borderColor);
+    this._focusedBorderColor = parseColor(options.focusedBorderColor || this._defaultOptions.focusedBorderColor);
+    this._customBorderCharsObj = options.customBorderChars;
+    this._customBorderChars = this._customBorderCharsObj ? borderCharsToArray(this._customBorderCharsObj) : undefined;
+    this.borderSides = getBorderSides(this._border);
+    this.shouldFill = options.shouldFill ?? this._defaultOptions.shouldFill;
+    this._title = options.title;
+    this._titleAlignment = options.titleAlignment || this._defaultOptions.titleAlignment;
+    this._bottomTitle = options.bottomTitle;
+    this._bottomTitleAlignment = options.bottomTitleAlignment || this._defaultOptions.bottomTitleAlignment;
+    this.applyYogaBorders();
+    const hasInitialGapProps = options.gap !== undefined || options.rowGap !== undefined || options.columnGap !== undefined;
+    if (hasInitialGapProps) {
+      this.applyYogaGap(options);
+    }
+  }
+  initializeBorder() {
+    if (this._border === false) {
+      this._border = true;
+      this.borderSides = getBorderSides(this._border);
+      this.applyYogaBorders();
+    }
+  }
+  get customBorderChars() {
+    return this._customBorderCharsObj;
+  }
+  set customBorderChars(value) {
+    this._customBorderCharsObj = value;
+    this._customBorderChars = value ? borderCharsToArray(value) : undefined;
+    this.requestRender();
+  }
+  get backgroundColor() {
+    return this._backgroundColor;
+  }
+  set backgroundColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.backgroundColor);
+    if (this._backgroundColor !== newColor) {
+      this._backgroundColor = newColor;
+      this.requestRender();
+    }
+  }
+  get border() {
+    return this._border;
+  }
+  set border(value) {
+    if (this._border !== value) {
+      this._border = value;
+      this.borderSides = getBorderSides(value);
+      this.applyYogaBorders();
+      this.requestRender();
+    }
+  }
+  get borderStyle() {
+    return this._borderStyle;
+  }
+  set borderStyle(value) {
+    const _value = parseBorderStyle(value, this._defaultOptions.borderStyle);
+    if (this._borderStyle !== _value || !this._border) {
+      this._borderStyle = _value;
+      this._customBorderChars = undefined;
+      this.initializeBorder();
+      this.requestRender();
+    }
+  }
+  get borderColor() {
+    return this._borderColor;
+  }
+  set borderColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.borderColor);
+    if (this._borderColor !== newColor) {
+      this._borderColor = newColor;
+      this.initializeBorder();
+      this.requestRender();
+    }
+  }
+  get focusedBorderColor() {
+    return this._focusedBorderColor;
+  }
+  set focusedBorderColor(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.focusedBorderColor);
+    if (this._focusedBorderColor !== newColor) {
+      this._focusedBorderColor = newColor;
+      this.initializeBorder();
+      if (this._focused) {
+        this.requestRender();
+      }
+    }
+  }
+  get title() {
+    return this._title;
+  }
+  set title(value) {
+    if (this._title !== value) {
+      this._title = value;
+      this.requestRender();
+    }
+  }
+  get titleAlignment() {
+    return this._titleAlignment;
+  }
+  set titleAlignment(value) {
+    if (this._titleAlignment !== value) {
+      this._titleAlignment = value;
+      this.requestRender();
+    }
+  }
+  get bottomTitle() {
+    return this._bottomTitle;
+  }
+  set bottomTitle(value) {
+    if (this._bottomTitle !== value) {
+      this._bottomTitle = value;
+      this.requestRender();
+    }
+  }
+  get bottomTitleAlignment() {
+    return this._bottomTitleAlignment;
+  }
+  set bottomTitleAlignment(value) {
+    if (this._bottomTitleAlignment !== value) {
+      this._bottomTitleAlignment = value;
+      this.requestRender();
+    }
+  }
+  renderSelf(buffer) {
+    const hasBorder = this.borderSides.top || this.borderSides.right || this.borderSides.bottom || this.borderSides.left;
+    const hasVisibleFill = this.shouldFill && this._backgroundColor.a > 0;
+    if (!hasBorder && !hasVisibleFill) {
+      return;
+    }
+    const hasFocusWithin = this._focusable && (this._focused || this._hasFocusedDescendant);
+    const currentBorderColor = hasFocusWithin ? this._focusedBorderColor : this._borderColor;
+    const screenX = this._screenX;
+    const screenY = this._screenY;
+    buffer.drawBox({
+      x: screenX,
+      y: screenY,
+      width: this.width,
+      height: this.height,
+      borderStyle: this._borderStyle,
+      customBorderChars: this._customBorderChars,
+      border: this._border,
+      borderColor: currentBorderColor,
+      backgroundColor: this._backgroundColor,
+      shouldFill: this.shouldFill,
+      title: this._title,
+      titleAlignment: this._titleAlignment,
+      bottomTitle: this._bottomTitle,
+      bottomTitleAlignment: this._bottomTitleAlignment
+    });
+  }
+  getScissorRect() {
+    const baseRect = super.getScissorRect();
+    if (!this.borderSides.top && !this.borderSides.right && !this.borderSides.bottom && !this.borderSides.left) {
+      return baseRect;
+    }
+    const leftInset = this.borderSides.left ? 1 : 0;
+    const rightInset = this.borderSides.right ? 1 : 0;
+    const topInset = this.borderSides.top ? 1 : 0;
+    const bottomInset = this.borderSides.bottom ? 1 : 0;
+    return {
+      x: baseRect.x + leftInset,
+      y: baseRect.y + topInset,
+      width: Math.max(0, baseRect.width - leftInset - rightInset),
+      height: Math.max(0, baseRect.height - topInset - bottomInset)
+    };
+  }
+  applyYogaBorders() {
+    const node = this.yogaNode;
+    node.setBorder(Edge.Left, this.borderSides.left ? 1 : 0);
+    node.setBorder(Edge.Right, this.borderSides.right ? 1 : 0);
+    node.setBorder(Edge.Top, this.borderSides.top ? 1 : 0);
+    node.setBorder(Edge.Bottom, this.borderSides.bottom ? 1 : 0);
+    this.requestRender();
+  }
+  applyYogaGap(options) {
+    const node = this.yogaNode;
+    if (isGapType(options.gap)) {
+      node.setGap(Gutter.All, options.gap);
+    }
+    if (isGapType(options.rowGap)) {
+      node.setGap(Gutter.Row, options.rowGap);
+    }
+    if (isGapType(options.columnGap)) {
+      node.setGap(Gutter.Column, options.columnGap);
+    }
+  }
+  set gap(gap) {
+    if (isGapType(gap)) {
+      this.yogaNode.setGap(Gutter.All, gap);
+      this.requestRender();
+    }
+  }
+  set rowGap(rowGap) {
+    if (isGapType(rowGap)) {
+      this.yogaNode.setGap(Gutter.Row, rowGap);
+      this.requestRender();
+    }
+  }
+  set columnGap(columnGap) {
+    if (isGapType(columnGap)) {
+      this.yogaNode.setGap(Gutter.Column, columnGap);
+      this.requestRender();
+    }
+  }
+}
+
+// src/renderables/TextBufferRenderable.ts
+class TextBufferRenderable extends Renderable {
+  selectable = true;
+  _defaultFg;
+  _defaultBg;
+  _defaultAttributes;
+  _selectionBg;
+  _selectionFg;
+  _wrapMode = "word";
+  lastLocalSelection = null;
+  _tabIndicator;
+  _tabIndicatorColor;
+  _scrollX = 0;
+  _scrollY = 0;
+  _truncate = false;
+  _firstLineOffset = 0;
+  textBuffer;
+  textBufferView;
+  _textBufferSyntaxStyle;
+  _defaultOptions = {
+    fg: RGBA.fromValues(1, 1, 1, 1),
+    bg: RGBA.fromValues(0, 0, 0, 0),
+    selectionBg: undefined,
+    selectionFg: undefined,
+    selectable: true,
+    attributes: 0,
+    wrapMode: "word",
+    tabIndicator: undefined,
+    tabIndicatorColor: undefined,
+    truncate: false
+  };
+  constructor(ctx, options) {
+    super(ctx, options);
+    this._defaultFg = parseColor(options.fg ?? this._defaultOptions.fg);
+    this._defaultBg = parseColor(options.bg ?? this._defaultOptions.bg);
+    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._tabIndicator = options.tabIndicator ?? this._defaultOptions.tabIndicator;
+    this._tabIndicatorColor = options.tabIndicatorColor ? parseColor(options.tabIndicatorColor) : this._defaultOptions.tabIndicatorColor;
+    this._truncate = options.truncate ?? this._defaultOptions.truncate;
+    this.textBuffer = TextBuffer.create(this._ctx.widthMethod);
+    this.textBufferView = TextBufferView.create(this.textBuffer);
+    this._firstLineOffset = ctx.claimFirstLineOffset?.(this) ?? 0;
+    this._textBufferSyntaxStyle = SyntaxStyle.create();
+    this.textBuffer.setSyntaxStyle(this._textBufferSyntaxStyle);
+    this.textBufferView.setWrapMode(this._wrapMode);
+    this.textBufferView.setFirstLineOffset(this._firstLineOffset);
+    this.setupMeasureFunc();
+    this.textBuffer.setDefaultFg(this._defaultFg);
+    this.textBuffer.setDefaultBg(this._defaultBg);
+    this.textBuffer.setDefaultAttributes(this._defaultAttributes);
+    if (this._tabIndicator !== undefined) {
+      this.textBufferView.setTabIndicator(this._tabIndicator);
+    }
+    if (this._tabIndicatorColor !== undefined) {
+      this.textBufferView.setTabIndicatorColor(this._tabIndicatorColor);
+    }
+    if (this._wrapMode !== "none" && this.width > 0) {
+      this.textBufferView.setWrapWidth(this.width);
+    }
+    if (this.width > 0 && this.height > 0) {
+      this.textBufferView.setViewport(this._scrollX, this._scrollY, this.width, this.height);
+    }
+    this.textBufferView.setTruncate(this._truncate);
+    this.updateTextInfo();
+  }
+  onMouseEvent(event) {
+    if (event.type === "scroll") {
+      this.handleScroll(event);
+    }
+  }
+  handleScroll(event) {
+    if (!event.scroll)
+      return;
+    const { direction, delta } = event.scroll;
+    if (direction === "up") {
+      this.scrollY -= delta;
+    } else if (direction === "down") {
+      this.scrollY += delta;
+    }
+    if (this._wrapMode === "none") {
+      if (direction === "left") {
+        this.scrollX -= delta;
+      } else if (direction === "right") {
+        this.scrollX += delta;
+      }
+    }
+  }
+  get lineInfo() {
+    return this.textBufferView.logicalLineInfo;
+  }
+  get lineCount() {
+    return this.textBuffer.getLineCount();
+  }
+  get virtualLineCount() {
+    return this.textBufferView.getVirtualLineCount();
+  }
+  get scrollY() {
+    return this._scrollY;
+  }
+  set scrollY(value) {
+    const maxScrollY = Math.max(0, this.scrollHeight - this.height);
+    const clamped = Math.max(0, Math.min(value, maxScrollY));
+    if (this._scrollY !== clamped) {
+      this._scrollY = clamped;
+      this.updateViewportOffset();
+      this.requestRender();
+    }
+  }
+  get scrollX() {
+    return this._scrollX;
+  }
+  set scrollX(value) {
+    const maxScrollX = Math.max(0, this.scrollWidth - this.width);
+    const clamped = Math.max(0, Math.min(value, maxScrollX));
+    if (this._scrollX !== clamped) {
+      this._scrollX = clamped;
+      this.updateViewportOffset();
+      this.requestRender();
+    }
+  }
+  get scrollWidth() {
+    return this.lineInfo.lineWidthColsMax;
+  }
+  get scrollHeight() {
+    return this.lineInfo.lineStartCols.length;
+  }
+  get maxScrollY() {
+    return Math.max(0, this.scrollHeight - this.height);
+  }
+  get maxScrollX() {
+    return Math.max(0, this.scrollWidth - this.width);
+  }
+  updateViewportOffset() {
+    if (this.width > 0 && this.height > 0) {
+      this.textBufferView.setViewport(this._scrollX, this._scrollY, this.width, this.height);
+    }
+  }
+  get plainText() {
+    return this.textBuffer.getPlainText();
+  }
+  get textLength() {
+    return this.textBuffer.length;
+  }
+  get fg() {
+    return this._defaultFg;
+  }
+  set fg(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.fg);
+    if (this._defaultFg !== newColor) {
+      this._defaultFg = newColor;
+      this.textBuffer.setDefaultFg(this._defaultFg);
+      this.onFgChanged(newColor);
+      this.requestRender();
+    }
+  }
+  get selectionBg() {
+    return this._selectionBg;
+  }
+  set selectionBg(value) {
+    const newColor = value ? parseColor(value) : this._defaultOptions.selectionBg;
+    if (this._selectionBg !== newColor) {
+      this._selectionBg = newColor;
+      if (this.lastLocalSelection) {
+        this.updateLocalSelection(this.lastLocalSelection);
+      }
+      this.requestRender();
+    }
+  }
+  get selectionFg() {
+    return this._selectionFg;
+  }
+  set selectionFg(value) {
+    const newColor = value ? parseColor(value) : this._defaultOptions.selectionFg;
+    if (this._selectionFg !== newColor) {
+      this._selectionFg = newColor;
+      if (this.lastLocalSelection) {
+        this.updateLocalSelection(this.lastLocalSelection);
+      }
+      this.requestRender();
+    }
+  }
+  get bg() {
+    return this._defaultBg;
+  }
+  set bg(value) {
+    const newColor = parseColor(value ?? this._defaultOptions.bg);
+    if (this._defaultBg !== newColor) {
+      this._defaultBg = newColor;
+      this.textBuffer.setDefaultBg(this._defaultBg);
+      this.onBgChanged(newColor);
+      this.requestRender();
+    }
+  }
+  get attributes() {
+    return this._defaultAttributes;
+  }
+  set attributes(value) {
+    if (this._defaultAttributes !== value) {
+      this._defaultAttributes = value;
+      this.textBuffer.setDefaultAttributes(this._defaultAttributes);
+      this.onAttributesChanged(value);
+      this.requestRender();
+    }
+  }
+  get wrapMode() {
+    return this._wrapMode;
+  }
+  set wrapMode(value) {
+    if (this._wrapMode !== value) {
+      this._wrapMode = value;
+      this.textBufferView.setWrapMode(this._wrapMode);
+      if (value !== "none" && this.width > 0) {
+        this.textBufferView.setWrapWidth(this.width);
+      }
+      this.yogaNode.markDirty();
+      this.requestRender();
+    }
+  }
+  get tabIndicator() {
+    return this._tabIndicator;
+  }
+  set tabIndicator(value) {
+    if (this._tabIndicator !== value) {
+      this._tabIndicator = value;
+      if (value !== undefined) {
+        this.textBufferView.setTabIndicator(value);
+      }
+      this.requestRender();
+    }
+  }
+  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.textBufferView.setTabIndicatorColor(newColor);
+      }
+      this.requestRender();
+    }
+  }
+  get truncate() {
+    return this._truncate;
+  }
+  set truncate(value) {
+    if (this._truncate !== value) {
+      this._truncate = value;
+      this.textBufferView.setTruncate(value);
+      this.requestRender();
+    }
+  }
+  onResize(width, height) {
+    this.textBufferView.setViewport(this._scrollX, this._scrollY, width, height);
+    this.yogaNode.markDirty();
+    this.requestRender();
+    this.emit("line-info-change");
+  }
+  refreshLocalSelection() {
+    if (this.lastLocalSelection) {
+      return this.updateLocalSelection(this.lastLocalSelection);
+    }
+    return false;
+  }
+  updateLocalSelection(localSelection) {
+    if (!localSelection?.isActive) {
+      this.textBufferView.resetLocalSelection();
+      return true;
+    }
+    return this.textBufferView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg);
+  }
+  updateTextInfo() {
+    if (this.lastLocalSelection) {
+      this.updateLocalSelection(this.lastLocalSelection);
+    }
+    this.yogaNode.markDirty();
+    this.requestRender();
+    this.emit("line-info-change");
+  }
+  setupMeasureFunc() {
+    const measureFunc = (width, widthMode, height, heightMode) => {
+      let effectiveWidth;
+      if (widthMode === MeasureMode.Undefined || isNaN(width)) {
+        effectiveWidth = 0;
+      } else {
+        effectiveWidth = width;
+      }
+      const effectiveHeight = isNaN(height) ? 1 : height;
+      const measureResult = this.textBufferView.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 {
+        width: measuredWidth,
+        height: measuredHeight
+      };
+    };
+    this.yogaNode.setMeasureFunc(measureFunc);
+  }
+  shouldStartSelection(x, y) {
+    if (!this.selectable)
+      return false;
+    const localX = x - this.x;
+    const localY = y - this.y;
+    return localX >= 0 && localX < this.width && localY >= 0 && localY < this.height;
+  }
+  onSelectionChanged(selection2) {
+    const localSelection = convertGlobalToLocalSelection(selection2, this.x, this.y);
+    this.lastLocalSelection = localSelection;
+    let changed;
+    if (!localSelection?.isActive) {
+      this.textBufferView.resetLocalSelection();
+      changed = true;
+    } else if (selection2?.isStart) {
+      changed = this.textBufferView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg);
+    } else {
+      changed = this.textBufferView.updateLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg);
+    }
+    if (changed) {
+      this.requestRender();
+    }
+    return this.hasSelection();
+  }
+  getSelectedText() {
+    return this.textBufferView.getSelectedText();
+  }
+  hasSelection() {
+    return this.textBufferView.hasSelection();
+  }
+  getSelection() {
+    return this.textBufferView.getSelection();
+  }
+  render(buffer, deltaTime) {
+    if (!this.visible)
+      return;
+    const screenX = this._screenX;
+    const screenY = this._screenY;
+    this.markClean();
+    this._ctx.addToHitGrid(screenX, screenY, this.width, this.height, this.num);
+    this.renderSelf(buffer);
+    if (this.buffered && this.frameBuffer) {
+      buffer.drawFrameBuffer(screenX, screenY, this.frameBuffer);
+    }
+  }
+  renderSelf(buffer) {
+    if (this.textBuffer.ptr) {
+      buffer.drawTextBuffer(this.textBufferView, this._screenX, this._screenY);
+    }
+  }
+  destroy() {
+    if (this.isDestroyed)
+      return;
+    this.textBuffer.setSyntaxStyle(null);
+    this._textBufferSyntaxStyle.destroy();
+    this.textBufferView.destroy();
+    this.textBuffer.destroy();
+    super.destroy();
+  }
+  onFgChanged(newColor) {}
+  onBgChanged(newColor) {}
+  onAttributesChanged(newAttributes) {}
+}
+
+// src/renderables/Code.ts
+class CodeRenderable extends TextBufferRenderable {
+  _content;
+  _filetype;
+  _syntaxStyle;
+  _isHighlighting = false;
+  _treeSitterClient;
+  _highlightsDirty = false;
+  _highlightSnapshotId = 0;
+  _conceal;
+  _drawUnstyledText;
+  _shouldRenderTextBuffer = true;
+  _streaming;
+  _hadInitialContent = false;
+  _lastHighlights = [];
+  _onHighlight;
+  _onChunks;
+  _highlightingPromise = Promise.resolve();
+  _contentDefaultOptions = {
+    content: "",
+    conceal: true,
+    drawUnstyledText: true,
+    streaming: false
+  };
+  constructor(ctx, options) {
+    super(ctx, options);
+    this._content = options.content ?? this._contentDefaultOptions.content;
+    this._filetype = options.filetype;
+    this._syntaxStyle = options.syntaxStyle;
+    this._treeSitterClient = options.treeSitterClient ?? getTreeSitterClient();
+    this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
+    this._drawUnstyledText = options.drawUnstyledText ?? this._contentDefaultOptions.drawUnstyledText;
+    this._streaming = options.streaming ?? this._contentDefaultOptions.streaming;
+    this._onHighlight = options.onHighlight;
+    this._onChunks = options.onChunks;
+    if (this._content.length > 0) {
+      this.textBuffer.setText(this._content);
+      this.updateTextInfo();
+      this._shouldRenderTextBuffer = this._drawUnstyledText || !this._filetype;
+    }
+    this._highlightsDirty = this._content.length > 0;
+  }
+  get content() {
+    return this._content;
+  }
+  set content(value) {
+    if (this._content !== value) {
+      this._content = value;
+      this._highlightsDirty = true;
+      this._highlightSnapshotId++;
+      if (this._streaming && !this._drawUnstyledText && this._filetype) {
+        return;
+      }
+      this.textBuffer.setText(value);
+      this.updateTextInfo();
+    }
+  }
+  get filetype() {
+    return this._filetype;
+  }
+  set filetype(value) {
+    if (this._filetype !== value) {
+      this._filetype = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get syntaxStyle() {
+    return this._syntaxStyle;
+  }
+  set syntaxStyle(value) {
+    if (this._syntaxStyle !== value) {
+      this._syntaxStyle = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get conceal() {
+    return this._conceal;
+  }
+  set conceal(value) {
+    if (this._conceal !== value) {
+      this._conceal = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get drawUnstyledText() {
+    return this._drawUnstyledText;
+  }
+  set drawUnstyledText(value) {
+    if (this._drawUnstyledText !== value) {
+      this._drawUnstyledText = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get streaming() {
+    return this._streaming;
+  }
+  set streaming(value) {
+    if (this._streaming !== value) {
+      this._streaming = value;
+      this._hadInitialContent = false;
+      this._lastHighlights = [];
+      this._highlightsDirty = true;
+    }
+  }
+  get treeSitterClient() {
+    return this._treeSitterClient;
+  }
+  set treeSitterClient(value) {
+    if (this._treeSitterClient !== value) {
+      this._treeSitterClient = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get onHighlight() {
+    return this._onHighlight;
+  }
+  set onHighlight(value) {
+    if (this._onHighlight !== value) {
+      this._onHighlight = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get onChunks() {
+    return this._onChunks;
+  }
+  set onChunks(value) {
+    if (this._onChunks !== value) {
+      this._onChunks = value;
+      this._highlightsDirty = true;
+    }
+  }
+  get isHighlighting() {
+    return this._isHighlighting;
+  }
+  get highlightingDone() {
+    return this._highlightingPromise;
+  }
+  async transformChunks(chunks, context) {
+    if (!this._onChunks)
+      return chunks;
+    const modified = await this._onChunks(chunks, context);
+    return modified ?? chunks;
+  }
+  ensureVisibleTextBeforeHighlight() {
+    if (this.isDestroyed)
+      return;
+    const content = this._content;
+    if (!this._filetype) {
+      this._shouldRenderTextBuffer = true;
+      return;
+    }
+    const isInitialContent = this._streaming && !this._hadInitialContent;
+    const shouldDrawUnstyledNow = this._streaming ? isInitialContent && this._drawUnstyledText : this._drawUnstyledText;
+    if (this._streaming && !isInitialContent) {
+      this._shouldRenderTextBuffer = true;
+    } else if (shouldDrawUnstyledNow) {
+      this.textBuffer.setText(content);
+      this._shouldRenderTextBuffer = true;
+    } else {
+      this._shouldRenderTextBuffer = false;
+    }
+  }
+  async startHighlight() {
+    const content = this._content;
+    const filetype = this._filetype;
+    const snapshotId = ++this._highlightSnapshotId;
+    if (!filetype)
+      return;
+    const isInitialContent = this._streaming && !this._hadInitialContent;
+    if (isInitialContent) {
+      this._hadInitialContent = true;
+    }
+    this._isHighlighting = true;
+    try {
+      const result = await this._treeSitterClient.highlightOnce(content, filetype);
+      if (snapshotId !== this._highlightSnapshotId) {
+        return;
+      }
+      if (this.isDestroyed)
+        return;
+      let highlights = result.highlights ?? [];
+      if (this._onHighlight && highlights.length >= 0) {
+        const context = {
+          content,
+          filetype,
+          syntaxStyle: this._syntaxStyle
+        };
+        const modified = await this._onHighlight(highlights, context);
+        if (modified !== undefined) {
+          highlights = modified;
+        }
+      }
+      if (snapshotId !== this._highlightSnapshotId) {
+        return;
+      }
+      if (this.isDestroyed)
+        return;
+      if (highlights.length > 0) {
+        if (this._streaming) {
+          this._lastHighlights = highlights;
+        }
+      }
+      if (highlights.length > 0 || this._onChunks) {
+        const context = {
+          content,
+          filetype,
+          syntaxStyle: this._syntaxStyle,
+          highlights
+        };
+        let chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
+          enabled: this._conceal
+        });
+        chunks = await this.transformChunks(chunks, context);
+        if (snapshotId !== this._highlightSnapshotId) {
+          return;
+        }
+        if (this.isDestroyed)
+          return;
+        const styledText = new StyledText(chunks);
+        this.textBuffer.setStyledText(styledText);
+      } else {
+        this.textBuffer.setText(content);
+      }
+      this._shouldRenderTextBuffer = true;
+      this._isHighlighting = false;
+      this._highlightsDirty = false;
+      this.updateTextInfo();
+      this.requestRender();
+    } catch (error) {
+      if (snapshotId !== this._highlightSnapshotId) {
+        return;
+      }
+      console.warn("Code highlighting failed, falling back to plain text:", error);
+      if (this.isDestroyed)
+        return;
+      this.textBuffer.setText(content);
+      this._shouldRenderTextBuffer = true;
+      this._isHighlighting = false;
+      this._highlightsDirty = false;
+      this.updateTextInfo();
+      this.requestRender();
+    }
+  }
+  getLineHighlights(lineIdx) {
+    return this.textBuffer.getLineHighlights(lineIdx);
+  }
+  renderSelf(buffer) {
+    if (this._highlightsDirty) {
+      if (this.isDestroyed)
+        return;
+      if (this._content.length === 0) {
+        this._shouldRenderTextBuffer = false;
+        this._highlightsDirty = false;
+      } else if (!this._filetype) {
+        this._shouldRenderTextBuffer = true;
+        this._highlightsDirty = false;
+      } else {
+        this.ensureVisibleTextBeforeHighlight();
+        this._highlightsDirty = false;
+        this._highlightingPromise = this.startHighlight();
+      }
+    }
+    if (!this._shouldRenderTextBuffer)
+      return;
+    super.renderSelf(buffer);
+  }
+}
+
+// src/renderables/TextNode.ts
+var BrandedTextNodeRenderable = Symbol.for("@opentui/core/TextNodeRenderable");
+function isTextNodeRenderable(obj) {
+  return !!obj?.[BrandedTextNodeRenderable];
+}
+function styledTextToTextNodes(styledText) {
+  return styledText.chunks.map((chunk) => {
+    const node = new TextNodeRenderable({
+      fg: chunk.fg,
+      bg: chunk.bg,
+      attributes: chunk.attributes,
+      link: chunk.link
+    });
+    node.add(chunk.text);
+    return node;
+  });
+}
+
+class TextNodeRenderable extends BaseRenderable {
+  [BrandedTextNodeRenderable] = true;
+  _fg;
+  _bg;
+  _attributes;
+  _link;
+  _children = [];
+  parent = null;
+  constructor(options) {
+    super(options);
+    this._fg = options.fg ? parseColor(options.fg) : undefined;
+    this._bg = options.bg ? parseColor(options.bg) : undefined;
+    this._attributes = options.attributes ?? 0;
+    this._link = options.link;
+  }
+  get children() {
+    return this._children;
+  }
+  set children(children) {
+    this._children = children;
+    this.requestRender();
+  }
+  requestRender() {
+    this.markDirty();
+    this.parent?.requestRender();
+  }
+  add(obj, index) {
+    if (typeof obj === "string") {
+      if (index !== undefined) {
+        this._children.splice(index, 0, obj);
+        this.requestRender();
+        return index;
+      }
+      const insertIndex = this._children.length;
+      this._children.push(obj);
+      this.requestRender();
+      return insertIndex;
+    }
+    if (isTextNodeRenderable(obj)) {
+      if (index !== undefined) {
+        this._children.splice(index, 0, obj);
+        obj.parent = this;
+        this.requestRender();
+        return index;
+      }
+      const insertIndex = this._children.length;
+      this._children.push(obj);
+      obj.parent = this;
+      this.requestRender();
+      return insertIndex;
+    }
+    if (isStyledText(obj)) {
+      const textNodes = styledTextToTextNodes(obj);
+      if (index !== undefined) {
+        this._children.splice(index, 0, ...textNodes);
+        textNodes.forEach((node) => node.parent = this);
+        this.requestRender();
+        return index;
+      }
+      const insertIndex = this._children.length;
+      this._children.push(...textNodes);
+      textNodes.forEach((node) => node.parent = this);
+      this.requestRender();
+      return insertIndex;
+    }
+    throw new Error("TextNodeRenderable only accepts strings, TextNodeRenderable instances, or StyledText instances");
+  }
+  replace(obj, index) {
+    this._children[index] = obj;
+    if (typeof obj !== "string") {
+      obj.parent = this;
+    }
+    this.requestRender();
+  }
+  insertBefore(child, anchorNode) {
+    if (!anchorNode || !isTextNodeRenderable(anchorNode)) {
+      throw new Error("Anchor must be a TextNodeRenderable");
+    }
+    const anchorIndex = this._children.indexOf(anchorNode);
+    if (anchorIndex === -1) {
+      throw new Error("Anchor node not found in children");
+    }
+    if (typeof child === "string") {
+      this._children.splice(anchorIndex, 0, child);
+    } else if (isTextNodeRenderable(child)) {
+      this._children.splice(anchorIndex, 0, child);
+      child.parent = this;
+    } else if (child instanceof StyledText) {
+      const textNodes = styledTextToTextNodes(child);
+      this._children.splice(anchorIndex, 0, ...textNodes);
+      textNodes.forEach((node) => node.parent = this);
+    } else {
+      throw new Error("Child must be a string, TextNodeRenderable, or StyledText instance");
+    }
+    this.requestRender();
+    return this;
+  }
+  remove(id) {
+    const childIndex = this.getRenderableIndex(id);
+    if (childIndex === -1) {
+      throw new Error("Child not found in children");
+    }
+    const child = this._children[childIndex];
+    this._children.splice(childIndex, 1);
+    child.parent = null;
+    this.requestRender();
+    return this;
+  }
+  clear() {
+    this._children = [];
+    this.requestRender();
+  }
+  mergeStyles(parentStyle) {
+    return {
+      fg: this._fg ?? parentStyle.fg,
+      bg: this._bg ?? parentStyle.bg,
+      attributes: this._attributes | parentStyle.attributes,
+      link: this._link ?? parentStyle.link
+    };
+  }
+  gatherWithInheritedStyle(parentStyle = {
+    fg: undefined,
+    bg: undefined,
+    attributes: 0
+  }) {
+    const currentStyle = this.mergeStyles(parentStyle);
+    const chunks = [];
+    for (const child of this._children) {
+      if (typeof child === "string") {
+        chunks.push({
+          __isChunk: true,
+          text: child,
+          fg: currentStyle.fg,
+          bg: currentStyle.bg,
+          attributes: currentStyle.attributes,
+          link: currentStyle.link
+        });
+      } else {
+        const childChunks = child.gatherWithInheritedStyle(currentStyle);
+        chunks.push(...childChunks);
+      }
+    }
+    this.markClean();
+    return chunks;
+  }
+  static fromString(text, options = {}) {
+    const node = new TextNodeRenderable(options);
+    node.add(text);
+    return node;
+  }
+  static fromNodes(nodes, options = {}) {
+    const node = new TextNodeRenderable(options);
+    for (const childNode of nodes) {
+      node.add(childNode);
+    }
+    return node;
+  }
+  toChunks(parentStyle = {
+    fg: undefined,
+    bg: undefined,
+    attributes: 0
+  }) {
+    return this.gatherWithInheritedStyle(parentStyle);
+  }
+  getChildren() {
+    return this._children.filter((child) => typeof child !== "string");
+  }
+  getChildrenCount() {
+    return this._children.length;
+  }
+  getRenderable(id) {
+    return this._children.find((child) => typeof child !== "string" && child.id === id);
+  }
+  getRenderableIndex(id) {
+    return this._children.findIndex((child) => isTextNodeRenderable(child) && child.id === id);
+  }
+  get fg() {
+    return this._fg;
+  }
+  set fg(fg2) {
+    if (!fg2) {
+      this._fg = undefined;
+      this.requestRender();
+      return;
+    }
+    this._fg = parseColor(fg2);
+    this.requestRender();
+  }
+  set bg(bg2) {
+    if (!bg2) {
+      this._bg = undefined;
+      this.requestRender();
+      return;
+    }
+    this._bg = parseColor(bg2);
+    this.requestRender();
+  }
+  get bg() {
+    return this._bg;
+  }
+  set attributes(attributes) {
+    this._attributes = attributes;
+    this.requestRender();
+  }
+  get attributes() {
+    return this._attributes;
+  }
+  set link(link2) {
+    this._link = link2;
+    this.requestRender();
+  }
+  get link() {
+    return this._link;
+  }
+  findDescendantById(id) {
+    return;
+  }
+}
+
+class RootTextNodeRenderable extends TextNodeRenderable {
+  ctx;
+  textParent;
+  constructor(ctx, options, textParent) {
+    super(options);
+    this.ctx = ctx;
+    this.textParent = textParent;
+  }
+  requestRender() {
+    this.markDirty();
+    this.ctx.requestRender();
+  }
+}
+
+// src/renderables/Text.ts
+class TextRenderable extends TextBufferRenderable {
+  _text;
+  _hasManualStyledText = false;
+  rootTextNode;
+  _contentDefaultOptions = {
+    content: ""
+  };
+  constructor(ctx, options) {
+    super(ctx, options);
+    const content = options.content ?? this._contentDefaultOptions.content;
+    const styledText = typeof content === "string" ? stringToStyledText(content) : content;
+    this._text = styledText;
+    this._hasManualStyledText = options.content !== undefined && content !== "";
+    this.rootTextNode = new RootTextNodeRenderable(ctx, {
+      id: `${this.id}-root`,
+      fg: this._defaultFg,
+      bg: this._defaultBg,
+      attributes: this._defaultAttributes
+    }, this);
+    this.updateTextBuffer(styledText);
+  }
+  updateTextBuffer(styledText) {
+    this.textBuffer.setStyledText(styledText);
+    this.clearChunks(styledText);
+  }
+  clearChunks(styledText) {}
+  get content() {
+    return this._text;
+  }
+  get chunks() {
+    return this._text.chunks;
+  }
+  get textNode() {
+    return this.rootTextNode;
+  }
+  set content(value) {
+    this._hasManualStyledText = true;
+    const styledText = typeof value === "string" ? stringToStyledText(value) : value;
+    if (this._text !== styledText) {
+      this._text = styledText;
+      this.updateTextBuffer(styledText);
+      this.updateTextInfo();
+    }
+  }
+  updateTextFromNodes() {
+    if (this.rootTextNode.isDirty && !this._hasManualStyledText) {
+      const chunks = this.rootTextNode.gatherWithInheritedStyle({
+        fg: this._defaultFg,
+        bg: this._defaultBg,
+        attributes: this._defaultAttributes,
+        link: undefined
+      });
+      this.textBuffer.setStyledText(new StyledText(chunks));
+      this.refreshLocalSelection();
+      this.yogaNode.markDirty();
+    }
+  }
+  add(obj, index) {
+    return this.rootTextNode.add(obj, index);
+  }
+  remove(id) {
+    this.rootTextNode.remove(id);
+  }
+  insertBefore(obj, anchor) {
+    this.rootTextNode.insertBefore(obj, anchor);
+    return this.rootTextNode.children.indexOf(obj);
+  }
+  getTextChildren() {
+    return this.rootTextNode.getChildren();
+  }
+  clear() {
+    this.rootTextNode.clear();
+    const emptyStyledText = stringToStyledText("");
+    this._text = emptyStyledText;
+    this.updateTextBuffer(emptyStyledText);
+    this.updateTextInfo();
+    this.requestRender();
+  }
+  onLifecyclePass = () => {
+    this.updateTextFromNodes();
+  };
+  onFgChanged(newColor) {
+    this.rootTextNode.fg = newColor;
+  }
+  onBgChanged(newColor) {
+    this.rootTextNode.bg = newColor;
+  }
+  onAttributesChanged(newAttributes) {
+    this.rootTextNode.attributes = newAttributes;
+  }
+  destroy() {
+    this.rootTextNode.children.length = 0;
+    super.destroy();
+  }
+}
+
+// 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 getBaseCodeKeyName(baseCode) {
+  if (baseCode === undefined || baseCode < 32 || baseCode === 127) {
+    return;
+  }
+  try {
+    const name = String.fromCodePoint(baseCode);
     if (name.length === 1 && name >= "A" && name <= "Z") {
       return name.toLowerCase();
     }
@@ -18734,6 +20373,27 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   return visibleChildren;
 }
 
+// src/lib/render-geometry.ts
+function calculateRenderGeometry(screenMode, terminalWidth, terminalHeight, footerHeight) {
+  const safeTerminalWidth = Math.max(terminalWidth, 0);
+  const safeTerminalHeight = Math.max(terminalHeight, 0);
+  if (screenMode !== "split-footer") {
+    return {
+      effectiveFooterHeight: 0,
+      renderOffset: 0,
+      renderWidth: safeTerminalWidth,
+      renderHeight: safeTerminalHeight
+    };
+  }
+  const effectiveFooterHeight = Math.min(footerHeight, safeTerminalHeight);
+  return {
+    effectiveFooterHeight,
+    renderOffset: safeTerminalHeight - effectiveFooterHeight,
+    renderWidth: safeTerminalWidth,
+    renderHeight: effectiveFooterHeight
+  };
+}
+
 // src/lib/terminal-capability-detection.ts
 function isCapabilityResponse(sequence) {
   if (/\x1b\[\?\d+(?:;\d+)*\$y/.test(sequence)) {
@@ -18828,6 +20488,9 @@ registerEnvVar({
   default: false
 });
 var DEFAULT_FOOTER_HEIGHT = 12;
+var MAX_SCROLLBACK_SURFACE_HEIGHT_PASSES = 4;
+var TRANSPARENT_RGBA = RGBA.fromValues(0, 0, 0, 0);
+var scrollbackSurfaceCounter = 0;
 function normalizeFooterHeight(footerHeight) {
   if (footerHeight === undefined) {
     return DEFAULT_FOOTER_HEIGHT;
@@ -18854,11 +20517,106 @@ function resolveModes(config) {
   if (externalOutputMode === "capture-stdout" && screenMode !== "split-footer") {
     throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
   }
-  return {
-    screenMode,
-    footerHeight,
-    externalOutputMode
-  };
+  return {
+    screenMode,
+    footerHeight,
+    externalOutputMode
+  };
+}
+
+class ExternalOutputQueue {
+  commits = [];
+  get size() {
+    return this.commits.length;
+  }
+  writeSnapshot(commit) {
+    this.commits.push(commit);
+  }
+  claim(limit = Number.POSITIVE_INFINITY) {
+    if (this.commits.length === 0) {
+      return [];
+    }
+    const clampedLimit = Number.isFinite(limit) ? Math.max(1, Math.trunc(limit)) : this.commits.length;
+    if (clampedLimit >= this.commits.length) {
+      const output2 = this.commits;
+      this.commits = [];
+      return output2;
+    }
+    const output = this.commits.slice(0, clampedLimit);
+    this.commits = this.commits.slice(clampedLimit);
+    return output;
+  }
+  clear() {
+    for (const commit of this.commits) {
+      commit.snapshot.destroy();
+    }
+    this.commits = [];
+  }
+}
+var CHAR_FLAG_CONTINUATION = 3221225472 >>> 0;
+var CHAR_FLAG_MASK = 3221225472 >>> 0;
+
+class ScrollbackSnapshotRenderContext extends EventEmitter9 {
+  width;
+  height;
+  frameId = 0;
+  widthMethod;
+  capabilities = null;
+  hasSelection = false;
+  currentFocusedRenderable = null;
+  keyInput;
+  _internalKeyInput;
+  lifecyclePasses = new Set;
+  constructor(width, height, widthMethod) {
+    super();
+    this.width = width;
+    this.height = height;
+    this.widthMethod = widthMethod;
+    this.keyInput = new KeyHandler;
+    this._internalKeyInput = new InternalKeyHandler;
+  }
+  addToHitGrid(_x, _y, _width, _height, _id) {}
+  pushHitGridScissorRect(_x, _y, _width, _height) {}
+  popHitGridScissorRect() {}
+  clearHitGridScissorRects() {}
+  requestRender() {}
+  setCursorPosition(_x, _y, _visible) {}
+  setCursorStyle(_options) {}
+  setCursorColor(_color) {}
+  setMousePointer(_shape) {}
+  requestLive() {}
+  dropLive() {}
+  getSelection() {
+    return null;
+  }
+  get currentFocusedEditor() {
+    if (!this.currentFocusedRenderable)
+      return null;
+    if (!isEditBufferRenderable(this.currentFocusedRenderable))
+      return null;
+    return this.currentFocusedRenderable;
+  }
+  requestSelectionUpdate() {}
+  focusRenderable(renderable) {
+    this.currentFocusedRenderable = renderable;
+  }
+  blurRenderable(renderable) {
+    if (this.currentFocusedRenderable === renderable) {
+      this.currentFocusedRenderable = null;
+    }
+  }
+  registerLifecyclePass(renderable) {
+    this.lifecyclePasses.add(renderable);
+  }
+  unregisterLifecyclePass(renderable) {
+    this.lifecyclePasses.delete(renderable);
+  }
+  getLifecyclePasses() {
+    return this.lifecyclePasses;
+  }
+  clearSelection() {}
+  startSelection(_renderable, _x, _y) {}
+  updateSelection(_currentRenderable, _x, _y, _options) {}
 }
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
@@ -18980,9 +20738,9 @@ async function createCliRenderer(config = {}) {
   const { screenMode, footerHeight } = resolveModes(config);
   const width = stdout.columns || 80;
   const height = stdout.rows || 24;
-  const renderHeight = screenMode === "split-footer" ? footerHeight : height;
+  const geometry = calculateRenderGeometry(screenMode, width, height, footerHeight);
   const ziglib = resolveRenderLib();
-  const rendererPtr = ziglib.createRenderer(width, renderHeight, {
+  const rendererPtr = ziglib.createRenderer(geometry.renderWidth, geometry.renderHeight, {
     remote: config.remote ?? false,
     testing: config.testing ?? false
   });
@@ -19099,6 +20857,8 @@ class CliRenderer extends EventEmitter9 {
   animationRequest = new Map;
   resizeTimeoutId = null;
   capabilityTimeoutId = null;
+  splitStartupSeedTimeoutId = null;
+  pendingSplitStartupCursorSeed = false;
   resizeDebounceDelay = 100;
   enableMouseMovement = false;
   _useMouse = true;
@@ -19106,6 +20866,7 @@ class CliRenderer extends EventEmitter9 {
   _screenMode = "alternate-screen";
   _footerHeight = DEFAULT_FOOTER_HEIGHT;
   _externalOutputMode = "passthrough";
+  clearOnShutdown = true;
   _suspendedMouseEnabled = false;
   _previousControlState = "idle" /* IDLE */;
   capturedRenderable;
@@ -19116,15 +20877,15 @@ class CliRenderer extends EventEmitter9 {
   clipboard;
   _splitHeight = 0;
   renderOffset = 0;
+  splitTailColumn = 0;
+  pendingSplitFooterTransition = null;
+  forceFullRepaintRequested = false;
+  maxSplitCommitsPerFrame = 8;
   _terminalWidth = 0;
   _terminalHeight = 0;
   _terminalIsSetup = false;
+  externalOutputQueue = new ExternalOutputQueue;
   realStdoutWrite;
-  captureCallback = () => {
-    if (this._splitHeight > 0) {
-      this.requestRender();
-    }
-  };
   _useConsole = true;
   sigwinchHandler = (() => {
     const width = this.stdout.columns || 80;
@@ -19167,8 +20928,15 @@ class CliRenderer extends EventEmitter9 {
   }).bind(this);
   dumpOutputCache(optionalMessage = "") {
     const cachedLogs = this.console.getCachedLogs();
-    const capturedOutput = capture.claimOutput();
-    if (capturedOutput.length > 0 || cachedLogs.length > 0) {
+    const capturedConsoleOutput = capture.claimOutput();
+    const capturedExternalOutputCommits = this.externalOutputQueue.claim();
+    let capturedExternalOutput = "";
+    for (const commit of capturedExternalOutputCommits) {
+      capturedExternalOutput += `[snapshot ${commit.snapshot.width}x${commit.snapshot.height}]
+`;
+      commit.snapshot.destroy();
+    }
+    if (capturedConsoleOutput.length > 0 || capturedExternalOutput.length > 0 || cachedLogs.length > 0) {
       this.realStdoutWrite.call(this.stdout, optionalMessage);
     }
     if (cachedLogs.length > 0) {
@@ -19176,11 +20944,18 @@ class CliRenderer extends EventEmitter9 {
 `);
       this.realStdoutWrite.call(this.stdout, cachedLogs);
     }
-    if (capturedOutput.length > 0) {
+    if (capturedConsoleOutput.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `
+Captured console output:
+`);
+      this.realStdoutWrite.call(this.stdout, capturedConsoleOutput + `
+`);
+    }
+    if (capturedExternalOutput.length > 0) {
       this.realStdoutWrite.call(this.stdout, `
-Captured output:
+Captured external output:
 `);
-      this.realStdoutWrite.call(this.stdout, capturedOutput + `
+      this.realStdoutWrite.call(this.stdout, capturedExternalOutput + `
 `);
     }
     this.realStdoutWrite.call(this.stdout, ANSI.reset);
@@ -19209,13 +20984,18 @@ Captured output:
     this.lib = lib;
     this._terminalWidth = stdout.columns ?? width;
     this._terminalHeight = stdout.rows ?? height;
-    this.width = width;
-    this.height = height;
     this._useThread = config.useThread === undefined ? false : config.useThread;
     const { screenMode, footerHeight, externalOutputMode } = resolveModes(config);
+    this._externalOutputMode = externalOutputMode;
+    const initialGeometry = calculateRenderGeometry(screenMode, this._terminalWidth, this._terminalHeight, footerHeight);
+    this.width = initialGeometry.renderWidth;
+    this.height = initialGeometry.renderHeight;
+    this._splitHeight = initialGeometry.effectiveFooterHeight;
+    this.renderOffset = screenMode === "split-footer" ? 0 : initialGeometry.renderOffset;
     this._footerHeight = footerHeight;
-    this._screenMode = screenMode;
     this.rendererPtr = rendererPtr;
+    this.clearOnShutdown = config.clearOnShutdown ?? true;
+    this.lib.setClearOnShutdown(this.rendererPtr, this.clearOnShutdown);
     const forwardEnvKeys = config.forwardEnvKeys ?? [...DEFAULT_FORWARDED_ENV_KEYS];
     for (const key of forwardEnvKeys) {
       const value = process.env[key];
@@ -19283,7 +21063,8 @@ Captured output:
         kittyKeyboardEnabled: useKittyForParsing,
         privateCapabilityRepliesActive: false,
         pixelResolutionQueryActive: false,
-        explicitWidthCprActive: false
+        explicitWidthCprActive: false,
+        startupCursorCprActive: false
       },
       clock: this.clock
     });
@@ -19293,7 +21074,7 @@ Captured output:
     });
     this.consoleMode = config.consoleMode ?? "console-overlay";
     this.applyScreenMode(screenMode, false, false);
-    this.externalOutputMode = externalOutputMode;
+    this.stdout.write = externalOutputMode === "capture-stdout" ? this.interceptStdoutWrite : this.realStdoutWrite;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
     this._onDestroy = config.onDestroy;
     global.requestAnimationFrame = (callback) => {
@@ -19569,8 +21350,25 @@ Captured output:
     if (mode === "capture-stdout" && this.screenMode !== "split-footer") {
       throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
     }
+    const previousMode = this._externalOutputMode;
+    if (previousMode === mode) {
+      return;
+    }
+    if (previousMode === "capture-stdout" && mode === "passthrough" && this._splitHeight > 0) {
+      this.flushPendingSplitOutputBeforeTransition();
+    }
     this._externalOutputMode = mode;
     this.stdout.write = mode === "capture-stdout" ? this.interceptStdoutWrite : this.realStdoutWrite;
+    if (this._screenMode === "split-footer" && this._splitHeight > 0 && mode === "capture-stdout") {
+      this.clearPendingSplitFooterTransition();
+      this.resetSplitScrollback(this.getSplitCursorSeedRows());
+      return;
+    }
+    if (this._screenMode === "split-footer" && this._splitHeight > 0 && previousMode === "capture-stdout" && mode === "passthrough") {
+      this.clearPendingSplitFooterTransition();
+      return;
+    }
+    this.syncSplitFooterState();
   }
   get liveRequestCount() {
     return this.liveRequestCounter;
@@ -19626,21 +21424,604 @@ Captured output:
     const flags = use ? KITTY_FLAG_DISAMBIGUATE | KITTY_FLAG_ALTERNATE_KEYS : 0;
     this.lib.setKittyKeyboardFlags(this.rendererPtr, flags);
   }
-  interceptStdoutWrite = (chunk, encoding, callback) => {
-    const text = chunk.toString();
-    capture.write("stdout", text);
-    if (this._splitHeight > 0) {
+  createScrollbackSurface(options = {}) {
+    if (this._screenMode !== "split-footer" || this._externalOutputMode !== "capture-stdout") {
+      throw new Error('createScrollbackSurface requires screenMode "split-footer" and externalOutputMode "capture-stdout"');
+    }
+    const renderer = this;
+    const surfaceId = scrollbackSurfaceCounter++;
+    const startOnNewLine = options.startOnNewLine ?? true;
+    const firstLineOffset = !startOnNewLine && renderer.splitTailColumn > 0 && renderer.splitTailColumn < renderer.width ? renderer.splitTailColumn : 0;
+    const snapshotContext = new ScrollbackSnapshotRenderContext(renderer.width, 1, renderer.widthMethod);
+    let firstLineOffsetOwner = null;
+    const renderContext = Object.create(snapshotContext);
+    Object.defineProperty(renderContext, "claimFirstLineOffset", {
+      value: (renderable) => {
+        if (firstLineOffsetOwner?.isDestroyed) {
+          firstLineOffsetOwner = null;
+        }
+        if (firstLineOffsetOwner) {
+          return 0;
+        }
+        firstLineOffsetOwner = renderable ?? null;
+        return firstLineOffset;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    const internalRoot = new RootRenderable(renderContext);
+    const publicRoot = new BoxRenderable(renderContext, {
+      id: `scrollback-surface-root-${surfaceId}`,
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: renderer.width,
+      height: "auto",
+      border: false,
+      backgroundColor: "transparent",
+      shouldFill: false,
+      flexDirection: "column"
+    });
+    internalRoot.add(publicRoot);
+    let surfaceWidth = renderer.width;
+    let surfaceHeight = 1;
+    let surfaceWidthMethod = renderer.widthMethod;
+    let surfaceDestroyed = false;
+    let hasRendered = false;
+    let nextCommitStartOnNewLine = startOnNewLine;
+    let backingBuffer = OptimizedBuffer.create(surfaceWidth, surfaceHeight, surfaceWidthMethod, {
+      id: `scrollback-surface-buffer-${surfaceId}`
+    });
+    const destroyListener = () => {
+      destroySurface();
+    };
+    const assertNotDestroyed = () => {
+      if (surfaceDestroyed) {
+        throw new Error("ScrollbackSurface is destroyed");
+      }
+    };
+    const assertRendered = () => {
+      if (!hasRendered) {
+        throw new Error("ScrollbackSurface.commitRows requires render() before commitRows()");
+      }
+    };
+    const assertGeometryStillCurrent = () => {
+      if (renderer.width !== surfaceWidth || renderer.widthMethod !== surfaceWidthMethod) {
+        throw new Error("ScrollbackSurface.commitRows requires render() after renderer geometry changes");
+      }
+    };
+    const assertRowRange = (startRow, endRowExclusive) => {
+      if (!Number.isInteger(startRow) || !Number.isInteger(endRowExclusive)) {
+        throw new Error("ScrollbackSurface.commitRows requires finite integer row bounds");
+      }
+      if (startRow < 0) {
+        throw new Error("ScrollbackSurface.commitRows requires startRow >= 0");
+      }
+      if (endRowExclusive < startRow) {
+        throw new Error("ScrollbackSurface.commitRows requires endRowExclusive >= startRow");
+      }
+      if (endRowExclusive > surfaceHeight) {
+        throw new Error("ScrollbackSurface.commitRows row range exceeds rendered surface height");
+      }
+    };
+    const collectPendingCodeRenderables = (node) => {
+      const pending = [];
+      if (node instanceof CodeRenderable && node.isHighlighting) {
+        pending.push(node);
+      }
+      for (const child of node.getChildren()) {
+        pending.push(...collectPendingCodeRenderables(child));
+      }
+      return pending;
+    };
+    const waitForPendingHighlights = async (pending, timeoutMs) => {
+      await new Promise((resolve4, reject) => {
+        let settled = false;
+        const timeoutHandle = renderer.clock.setTimeout(() => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          reject(new Error("ScrollbackSurface.settle timed out waiting for CodeRenderable highlighting"));
+        }, timeoutMs);
+        Promise.all(pending.map((renderable) => renderable.highlightingDone)).then(() => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          renderer.clock.clearTimeout(timeoutHandle);
+          resolve4();
+        }, (error) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          renderer.clock.clearTimeout(timeoutHandle);
+          reject(error);
+        });
+      });
+    };
+    const renderSurface = () => {
+      assertNotDestroyed();
+      const width = renderer.width;
+      const widthMethod = renderer.widthMethod;
+      snapshotContext.width = width;
+      snapshotContext.widthMethod = widthMethod;
+      publicRoot.width = width;
+      const renderPass = (height) => {
+        snapshotContext.height = height;
+        internalRoot.resize(width, height);
+        backingBuffer.resize(width, height);
+        backingBuffer.clear(TRANSPARENT_RGBA);
+        snapshotContext.frameId += 1;
+        internalRoot.render(backingBuffer, 0);
+      };
+      let targetHeight = Math.max(1, surfaceHeight);
+      if (surfaceWidthMethod !== widthMethod) {
+        backingBuffer.destroy();
+        backingBuffer = OptimizedBuffer.create(width, targetHeight, widthMethod, {
+          id: `scrollback-surface-buffer-${surfaceId}`
+        });
+      } else {
+        backingBuffer.resize(width, targetHeight);
+      }
+      for (let pass = 0;pass < MAX_SCROLLBACK_SURFACE_HEIGHT_PASSES; pass += 1) {
+        renderPass(targetHeight);
+        const measuredHeight = Math.max(1, publicRoot.height);
+        if (measuredHeight === targetHeight) {
+          surfaceWidth = width;
+          surfaceHeight = measuredHeight;
+          surfaceWidthMethod = widthMethod;
+          hasRendered = true;
+          return;
+        }
+        targetHeight = measuredHeight;
+      }
+      renderPass(targetHeight);
+      surfaceWidth = width;
+      surfaceHeight = targetHeight;
+      surfaceWidthMethod = widthMethod;
+      hasRendered = true;
+    };
+    const settleSurface = async (timeoutMs = 2000) => {
+      assertNotDestroyed();
+      const startedAt = renderer.clock.now();
+      renderSurface();
+      while (true) {
+        assertNotDestroyed();
+        const pending = collectPendingCodeRenderables(publicRoot);
+        if (pending.length === 0) {
+          return;
+        }
+        const remainingMs = timeoutMs - (renderer.clock.now() - startedAt);
+        if (remainingMs <= 0) {
+          throw new Error("ScrollbackSurface.settle timed out waiting for CodeRenderable highlighting");
+        }
+        await waitForPendingHighlights(pending, remainingMs);
+        assertNotDestroyed();
+        renderSurface();
+      }
+    };
+    const commitRows = (startRow, endRowExclusive, commitOptions = {}) => {
+      assertNotDestroyed();
+      assertRendered();
+      assertGeometryStillCurrent();
+      assertRowRange(startRow, endRowExclusive);
+      if (startRow === endRowExclusive) {
+        return;
+      }
+      const rowCount = endRowExclusive - startRow;
+      const commitBuffer = OptimizedBuffer.create(surfaceWidth, rowCount, surfaceWidthMethod, {
+        id: `scrollback-surface-commit-${surfaceId}`
+      });
+      try {
+        commitBuffer.drawFrameBuffer(0, 0, backingBuffer, 0, startRow, surfaceWidth, rowCount);
+        renderer.enqueueRenderedScrollbackCommit({
+          snapshot: commitBuffer,
+          rowColumns: commitOptions.rowColumns,
+          startOnNewLine: nextCommitStartOnNewLine,
+          trailingNewline: commitOptions.trailingNewline ?? false
+        });
+        nextCommitStartOnNewLine = false;
+      } catch (error) {
+        commitBuffer.destroy();
+        throw error;
+      }
+    };
+    const destroySurface = () => {
+      if (surfaceDestroyed) {
+        return;
+      }
+      surfaceDestroyed = true;
+      renderer.off("destroy" /* DESTROY */, destroyListener);
+      let destroyError = null;
+      try {
+        internalRoot.destroyRecursively();
+      } catch (error) {
+        destroyError = error;
+      }
+      try {
+        backingBuffer.destroy();
+      } catch (error) {
+        if (destroyError === null) {
+          destroyError = error;
+        }
+      }
+      renderContext.removeAllListeners();
+      snapshotContext.removeAllListeners();
+      if (destroyError !== null) {
+        throw destroyError;
+      }
+    };
+    renderer.on("destroy" /* DESTROY */, destroyListener);
+    return {
+      get renderContext() {
+        return renderContext;
+      },
+      get root() {
+        return publicRoot;
+      },
+      get width() {
+        return surfaceWidth;
+      },
+      get height() {
+        return surfaceHeight;
+      },
+      get isDestroyed() {
+        return surfaceDestroyed;
+      },
+      render: renderSurface,
+      settle: settleSurface,
+      commitRows,
+      destroy: destroySurface
+    };
+  }
+  writeToScrollback(write) {
+    if (this._screenMode !== "split-footer" || this._externalOutputMode !== "capture-stdout") {
+      throw new Error('writeToScrollback requires screenMode "split-footer" and externalOutputMode "capture-stdout"');
+    }
+    const snapshotContext = new ScrollbackSnapshotRenderContext(this.width, this.height, this.widthMethod);
+    const snapshot = write({
+      width: this.width,
+      widthMethod: this.widthMethod,
+      tailColumn: this.splitTailColumn,
+      renderContext: snapshotContext
+    });
+    if (!snapshot || !snapshot.root) {
+      throw new Error("writeToScrollback must return a snapshot root renderable");
+    }
+    let renderFailed = false;
+    let snapshotRoot = null;
+    let snapshotBuffer = null;
+    try {
+      const rootRenderable = snapshot.root;
+      const snapshotWidth = this.getSnapshotWidth(snapshot.width, rootRenderable.width);
+      const snapshotHeight = this.getSnapshotHeight(snapshot.height, rootRenderable.height);
+      snapshotContext.width = snapshotWidth;
+      snapshotContext.height = snapshotHeight;
+      snapshotContext.widthMethod = this.widthMethod;
+      snapshotRoot = new RootRenderable(snapshotContext);
+      snapshotBuffer = OptimizedBuffer.create(snapshotWidth, snapshotHeight, this.widthMethod, {
+        id: "scrollback-snapshot-commit"
+      });
+      snapshotRoot.add(rootRenderable);
+      snapshotRoot.render(snapshotBuffer, 0);
+      this.enqueueRenderedScrollbackCommit({
+        snapshot: snapshotBuffer,
+        rowColumns: snapshot.rowColumns,
+        startOnNewLine: snapshot.startOnNewLine,
+        trailingNewline: snapshot.trailingNewline
+      });
+    } catch (error) {
+      renderFailed = true;
+      snapshotBuffer?.destroy();
+      throw error;
+    } finally {
+      let cleanupError = null;
+      try {
+        if (snapshotRoot) {
+          snapshotRoot.destroyRecursively();
+        } else {
+          snapshot.root.destroyRecursively();
+        }
+      } catch (error) {
+        cleanupError = error;
+      }
+      try {
+        snapshot.teardown?.();
+      } catch (error) {
+        if (cleanupError === null) {
+          cleanupError = error;
+        }
+      }
+      if (!renderFailed && cleanupError) {
+        throw cleanupError;
+      }
+    }
+  }
+  getSnapshotWidth(value, fallback) {
+    const rawValue = value ?? fallback;
+    if (!Number.isFinite(rawValue)) {
+      throw new Error("writeToScrollback produced a non-finite width");
+    }
+    return Math.min(Math.max(Math.trunc(rawValue), 1), Math.max(this.width, 1));
+  }
+  getSnapshotHeight(value, fallback) {
+    const rawValue = value ?? fallback;
+    if (!Number.isFinite(rawValue)) {
+      throw new Error("writeToScrollback produced a non-finite height");
+    }
+    return Math.max(Math.trunc(rawValue), 1);
+  }
+  getSnapshotRowWidths(snapshot, rowColumns) {
+    const widths = [];
+    const limit = Math.min(Math.max(Math.trunc(rowColumns), 0), snapshot.width);
+    const chars = snapshot.buffers.char;
+    for (let y = 0;y < snapshot.height; y += 1) {
+      let x = limit;
+      while (x > 0) {
+        const cp = chars[y * snapshot.width + x - 1];
+        if (cp === 0 || (cp & CHAR_FLAG_MASK) === CHAR_FLAG_CONTINUATION) {
+          x -= 1;
+          continue;
+        }
+        break;
+      }
+      widths.push(x);
+    }
+    return widths;
+  }
+  publishSplitTailColumns(columns) {
+    if (columns <= 0) {
+      return;
+    }
+    const width = Math.max(this.width, 1);
+    let tail = this.splitTailColumn;
+    let remaining = columns;
+    while (remaining > 0) {
+      if (tail >= width) {
+        tail = 0;
+      }
+      const step = Math.min(remaining, width - tail);
+      tail += step;
+      remaining -= step;
+      if (remaining > 0 && tail >= width) {
+        tail = 0;
+      }
+    }
+    this.splitTailColumn = tail;
+  }
+  recordSplitCommit(commit) {
+    if (commit.startOnNewLine && this.splitTailColumn > 0) {
+      this.splitTailColumn = 0;
+    }
+    const rowWidths = this.getSnapshotRowWidths(commit.snapshot, commit.rowColumns);
+    for (const [index, rowWidth] of rowWidths.entries()) {
+      this.publishSplitTailColumns(rowWidth);
+      if (index < rowWidths.length - 1 || commit.trailingNewline) {
+        this.splitTailColumn = 0;
+      }
+    }
+  }
+  enqueueRenderedScrollbackCommit(options) {
+    if (this._screenMode !== "split-footer" || this._externalOutputMode !== "capture-stdout") {
+      throw new Error('scrollback commit requires screenMode "split-footer" and externalOutputMode "capture-stdout"');
+    }
+    const rowColumns = Math.min(Math.max(Math.trunc(options.rowColumns ?? options.snapshot.width), 0), options.snapshot.width);
+    this.enqueueSplitCommit({
+      snapshot: options.snapshot,
+      rowColumns,
+      startOnNewLine: options.startOnNewLine ?? true,
+      trailingNewline: options.trailingNewline ?? true
+    });
+    this.requestRender();
+  }
+  enqueueSplitCommit(commit) {
+    this.recordSplitCommit(commit);
+    this.externalOutputQueue.writeSnapshot(commit);
+  }
+  createStdoutSnapshotCommit(line, trailingNewline) {
+    const snapshotContext = new ScrollbackSnapshotRenderContext(this.width, 1, this.widthMethod);
+    const maxWidth = Math.max(1, this.width);
+    const lineCells = [...line];
+    const rowColumns = Math.min(lineCells.length, maxWidth);
+    const renderedLine = lineCells.slice(0, maxWidth).join("");
+    const snapshotRoot = new RootRenderable(snapshotContext);
+    const snapshotRenderable = new TextRenderable(snapshotContext, {
+      id: "captured-stdout-snapshot",
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: Math.max(1, rowColumns),
+      height: 1,
+      content: renderedLine
+    });
+    const snapshotBuffer = OptimizedBuffer.create(Math.max(1, rowColumns), 1, this.widthMethod, {
+      id: "captured-stdout-snapshot"
+    });
+    try {
+      snapshotRoot.add(snapshotRenderable);
+      snapshotRoot.render(snapshotBuffer, 0);
+      return {
+        snapshot: snapshotBuffer,
+        rowColumns,
+        startOnNewLine: false,
+        trailingNewline
+      };
+    } catch (error) {
+      snapshotBuffer.destroy();
+      throw error;
+    } finally {
+      snapshotRoot.destroyRecursively();
+    }
+  }
+  splitStdoutRows(text) {
+    const rows = [];
+    let current = "";
+    for (const char of text) {
+      if (char === "\r") {
+        current = "";
+        continue;
+      }
+      if (char === `
+`) {
+        rows.push({ line: current, trailingNewline: true });
+        current = "";
+        continue;
+      }
+      current += char;
+    }
+    if (current.length > 0) {
+      rows.push({ line: current, trailingNewline: false });
+    }
+    return rows;
+  }
+  createStdoutSnapshotCommits(text) {
+    if (text.length === 0) {
+      return [];
+    }
+    const commits = [];
+    const chunkWidth = Math.max(1, this.width);
+    for (const row of this.splitStdoutRows(text)) {
+      const rowCells = [...row.line];
+      if (rowCells.length === 0) {
+        commits.push(this.createStdoutSnapshotCommit("", row.trailingNewline));
+        continue;
+      }
+      let offset = 0;
+      while (offset < rowCells.length) {
+        const chunk = rowCells.slice(offset, offset + chunkWidth).join("");
+        offset += chunkWidth;
+        const isLastChunk = offset >= rowCells.length;
+        commits.push(this.createStdoutSnapshotCommit(chunk, isLastChunk ? row.trailingNewline : false));
+      }
+    }
+    return commits;
+  }
+  flushPendingSplitCommits(forceFooterRepaint = false) {
+    const commits = this.externalOutputQueue.claim(this.maxSplitCommitsPerFrame);
+    let hasCommittedOutput = false;
+    const lastCommitIndex = commits.length - 1;
+    for (const [index, commit] of commits.entries()) {
+      const forceCommit = forceFooterRepaint && index === lastCommitIndex;
+      const beginFrame = index === 0;
+      const finalizeFrame = index === lastCommitIndex;
+      try {
+        this.renderOffset = this.lib.commitSplitFooterSnapshot(this.rendererPtr, commit.snapshot, commit.rowColumns, commit.startOnNewLine, commit.trailingNewline, this.getSplitPinnedRenderOffset(), forceCommit, beginFrame, finalizeFrame);
+        hasCommittedOutput = true;
+      } finally {
+        commit.snapshot.destroy();
+      }
+    }
+    if (!hasCommittedOutput) {
+      this.renderOffset = this.lib.repaintSplitFooter(this.rendererPtr, this.getSplitPinnedRenderOffset(), forceFooterRepaint);
+    }
+    this.pendingSplitFooterTransition = null;
+    if (this.externalOutputQueue.size > 0) {
       this.requestRender();
     }
-    if (typeof callback === "function") {
-      process.nextTick(callback);
+  }
+  interceptStdoutWrite = (chunk, encoding, callback) => {
+    const resolvedCallback = typeof encoding === "function" ? encoding : callback;
+    const resolvedEncoding = typeof encoding === "string" ? encoding : undefined;
+    const text = typeof chunk === "string" ? chunk : chunk?.toString(resolvedEncoding) ?? "";
+    if (this._externalOutputMode === "capture-stdout" && this._screenMode === "split-footer" && this._splitHeight > 0) {
+      const commits = this.createStdoutSnapshotCommits(text);
+      for (const commit of commits) {
+        this.enqueueSplitCommit(commit);
+      }
+      if (commits.length > 0) {
+        this.requestRender();
+      }
+    }
+    if (typeof resolvedCallback === "function") {
+      process.nextTick(resolvedCallback);
     }
     return true;
   };
+  getSplitPinnedRenderOffset() {
+    return this._screenMode === "split-footer" ? Math.max(this._terminalHeight - this._splitHeight, 0) : 0;
+  }
+  getSplitCursorSeedRows() {
+    const cursorState = this.lib.getCursorState(this.rendererPtr);
+    const cursorRow = Number.isFinite(cursorState.y) ? Math.max(Math.trunc(cursorState.y), 1) : 1;
+    return Math.min(cursorRow, Math.max(this._terminalHeight, 1));
+  }
+  flushPendingSplitOutputBeforeTransition(forceFooterRepaint = false) {
+    if (this._screenMode !== "split-footer" || this._splitHeight <= 0 || this._externalOutputMode !== "capture-stdout") {
+      return;
+    }
+    if (this.externalOutputQueue.size === 0 && !forceFooterRepaint) {
+      return;
+    }
+    this.flushPendingSplitCommits(forceFooterRepaint);
+  }
+  resetSplitScrollback(seedRows = 0) {
+    this.splitTailColumn = 0;
+    this.renderOffset = this.lib.resetSplitScrollback(this.rendererPtr, seedRows, this.getSplitPinnedRenderOffset());
+  }
+  syncSplitScrollback() {
+    this.renderOffset = this.lib.syncSplitScrollback(this.rendererPtr, this.getSplitPinnedRenderOffset());
+  }
+  clearPendingSplitFooterTransition() {
+    if (this.pendingSplitFooterTransition === null) {
+      return;
+    }
+    this.pendingSplitFooterTransition = null;
+    this.lib.clearPendingSplitFooterTransition(this.rendererPtr);
+  }
+  setPendingSplitFooterTransition(transition) {
+    this.pendingSplitFooterTransition = transition;
+    this.lib.setPendingSplitFooterTransition(this.rendererPtr, transition.mode === "viewport-scroll" ? 1 : 2, transition.sourceTopLine, transition.sourceHeight, transition.targetTopLine, transition.targetHeight);
+  }
+  syncSplitFooterState() {
+    const splitActive = this._screenMode === "split-footer" && this._splitHeight > 0;
+    if (!splitActive) {
+      this.clearPendingSplitFooterTransition();
+      this.splitTailColumn = 0;
+      this.lib.resetSplitScrollback(this.rendererPtr, 0, 0);
+      this.renderOffset = 0;
+      this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
+      return;
+    }
+    if (this._externalOutputMode === "capture-stdout") {
+      this.syncSplitScrollback();
+    } else {
+      this.clearPendingSplitFooterTransition();
+      this.splitTailColumn = 0;
+      this.lib.resetSplitScrollback(this.rendererPtr, 0, 0);
+      this.renderOffset = this.getSplitPinnedRenderOffset();
+      this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
+    }
+  }
+  clearStaleSplitSurfaceRows(previousTopLine, previousHeight, nextTopLine, nextHeight) {
+    if (!this._terminalIsSetup || previousHeight <= 0 || this._terminalHeight <= 0) {
+      return;
+    }
+    const terminalBottom = this._terminalHeight;
+    const previousStart = Math.max(1, previousTopLine);
+    const previousEnd = Math.min(terminalBottom, previousTopLine + previousHeight - 1);
+    if (previousEnd < previousStart) {
+      return;
+    }
+    const nextStart = Math.max(1, nextTopLine);
+    const nextEnd = Math.min(terminalBottom, nextTopLine + Math.max(nextHeight, 0) - 1);
+    let clear = "";
+    for (let line = previousStart;line <= previousEnd; line += 1) {
+      if (line >= nextStart && line <= nextEnd) {
+        continue;
+      }
+      clear += `${ANSI.moveCursor(line, 1)}\x1B[2K`;
+    }
+    if (clear.length > 0) {
+      this.writeOut(clear);
+    }
+  }
   applyScreenMode(screenMode, emitResize = true, requestRender = true) {
     const prevScreenMode = this._screenMode;
     const prevSplitHeight = this._splitHeight;
-    const nextSplitHeight = screenMode === "split-footer" ? this._footerHeight : 0;
+    const nextGeometry = calculateRenderGeometry(screenMode, this._terminalWidth, this._terminalHeight, this._footerHeight);
+    const nextSplitHeight = nextGeometry.effectiveFooterHeight;
     if (prevScreenMode === screenMode && prevSplitHeight === nextSplitHeight) {
       return;
     }
@@ -19648,10 +22029,24 @@ Captured output:
     const nextUseAlternateScreen = screenMode === "alternate-screen";
     const terminalScreenModeChanged = this._terminalIsSetup && prevUseAlternateScreen !== nextUseAlternateScreen;
     const leavingSplitFooter = prevSplitHeight > 0 && nextSplitHeight === 0;
+    if (this._terminalIsSetup && prevSplitHeight > 0) {
+      this.flushPendingSplitOutputBeforeTransition();
+    }
+    const previousSurfaceTopLine = this.renderOffset + 1;
+    const previousPinnedRenderOffset = Math.max(this._terminalHeight - prevSplitHeight, 0);
+    const splitWasSettled = prevSplitHeight === 0 || this.renderOffset >= previousPinnedRenderOffset;
+    const shouldUseViewportScrollTransitions = this._externalOutputMode !== "capture-stdout" || splitWasSettled;
+    const shouldDeferSplitFooterResizeTransition = this._terminalIsSetup && prevScreenMode === "split-footer" && screenMode === "split-footer" && this._externalOutputMode === "capture-stdout" && prevSplitHeight > 0 && nextSplitHeight > 0 && !terminalScreenModeChanged;
+    const splitStartupSeedBlocksFirstNativeFrame = this.pendingSplitStartupCursorSeed && this.splitStartupSeedTimeoutId !== null;
+    const splitTransitionSourceTopLine = this.pendingSplitFooterTransition?.sourceTopLine ?? previousSurfaceTopLine;
+    const splitTransitionSourceHeight = this.pendingSplitFooterTransition?.sourceHeight ?? prevSplitHeight;
+    const splitTransitionMode = this.pendingSplitFooterTransition?.mode ?? (splitWasSettled ? "viewport-scroll" : "clear-stale-rows");
     if (this._terminalIsSetup && leavingSplitFooter) {
-      this.flushStdoutCache(this._terminalHeight, true);
+      this.clearPendingSplitFooterTransition();
+      this.renderOffset = 0;
+      this.lib.setRenderOffset(this.rendererPtr, 0);
     }
-    if (this._terminalIsSetup && !terminalScreenModeChanged) {
+    if (this._terminalIsSetup && !terminalScreenModeChanged && shouldUseViewportScrollTransitions && !shouldDeferSplitFooterResizeTransition) {
       if (prevSplitHeight === 0 && nextSplitHeight > 0) {
         const freedLines = this._terminalHeight - nextSplitHeight;
         const scrollDown = ANSI.scrollDown(freedLines);
@@ -19666,18 +22061,39 @@ Captured output:
         this.writeOut(scrollUp);
       }
     }
-    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.width = nextGeometry.renderWidth;
+    this.height = nextGeometry.renderHeight;
     this.lib.resizeRenderer(this.rendererPtr, this.width, this.height);
+    if (this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
+      if (prevScreenMode !== "split-footer") {
+        this.resetSplitScrollback(this.getSplitCursorSeedRows());
+      } else {
+        this.syncSplitScrollback();
+      }
+      if (shouldDeferSplitFooterResizeTransition) {
+        if (splitStartupSeedBlocksFirstNativeFrame) {
+          this.clearPendingSplitFooterTransition();
+        } else {
+          this.setPendingSplitFooterTransition({
+            mode: splitTransitionMode,
+            sourceTopLine: splitTransitionSourceTopLine,
+            sourceHeight: splitTransitionSourceHeight,
+            targetTopLine: this.renderOffset + 1,
+            targetHeight: nextSplitHeight
+          });
+        }
+        this.forceFullRepaintRequested = true;
+      } else if (!shouldUseViewportScrollTransitions && prevSplitHeight > 0 && nextSplitHeight > 0) {
+        this.clearPendingSplitFooterTransition();
+        this.clearStaleSplitSurfaceRows(previousSurfaceTopLine, prevSplitHeight, this.renderOffset + 1, nextSplitHeight);
+      } else {
+        this.clearPendingSplitFooterTransition();
+      }
+    } else {
+      this.syncSplitFooterState();
+    }
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this._console.resize(this.width, this.height);
@@ -19697,12 +22113,18 @@ Captured output:
     }
   }
   flushStdoutCache(space, force = false) {
-    if (capture.size === 0 && !force)
+    if (this.externalOutputQueue.size === 0 && !force)
       return false;
-    const output = capture.claimOutput();
-    const rendererStartLine = this._terminalHeight - this._splitHeight;
+    const outputCommits = this.externalOutputQueue.claim();
+    let output = "";
+    for (const commit of outputCommits) {
+      output += `[snapshot ${commit.snapshot.width}x${commit.snapshot.height}]
+`;
+      commit.snapshot.destroy();
+    }
+    const rendererStartLine = this.renderOffset + 1;
     const flush = ANSI.moveCursorAndClear(rendererStartLine, 1);
-    const outputLine = this._terminalHeight - this._splitHeight;
+    const outputLine = this.renderOffset + 1;
     const move = ANSI.moveCursor(outputLine, 1);
     let clear = "";
     if (space > 0) {
@@ -19744,9 +22166,11 @@ Captured output:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
+    const startupCursorCprActive = this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout";
     this.updateStdinParserProtocolContext({
       privateCapabilityRepliesActive: true,
-      explicitWidthCprActive: true
+      explicitWidthCprActive: true,
+      startupCursorCprActive
     });
     this.lib.setupTerminal(this.rendererPtr, this._screenMode === "alternate-screen");
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
@@ -19760,15 +22184,40 @@ Captured output:
     }
     this.capabilityTimeoutId = this.clock.setTimeout(() => {
       this.capabilityTimeoutId = null;
+      this.pendingSplitStartupCursorSeed = false;
+      if (this.splitStartupSeedTimeoutId !== null) {
+        this.clock.clearTimeout(this.splitStartupSeedTimeoutId);
+        this.splitStartupSeedTimeoutId = null;
+      }
+      if (this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
+        this.requestRender();
+      }
       this.removeInputHandler(this.capabilityHandler);
       this.updateStdinParserProtocolContext({
         privateCapabilityRepliesActive: false,
-        explicitWidthCprActive: false
+        explicitWidthCprActive: false,
+        startupCursorCprActive: false
       }, true);
     }, 5000);
     if (this._useMouse) {
       this.enableMouse();
     }
+    if (this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
+      this.pendingSplitStartupCursorSeed = true;
+      if (this.splitStartupSeedTimeoutId !== null) {
+        this.clock.clearTimeout(this.splitStartupSeedTimeoutId);
+      }
+      this.splitStartupSeedTimeoutId = this.clock.setTimeout(() => {
+        this.splitStartupSeedTimeoutId = null;
+        if (!this.pendingSplitStartupCursorSeed) {
+          return;
+        }
+        this.updateStdinParserProtocolContext({ startupCursorCprActive: false });
+        if (this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
+          this.requestRender();
+        }
+      }, 120);
+    }
     this.queryPixelResolution();
   }
   stdinListener = ((chunk) => {
@@ -19804,14 +22253,32 @@ Captured output:
       this.oscSubscribers.delete(handler);
     };
   }
-  capabilityHandler = ((sequence) => {
-    if (isCapabilityResponse(sequence)) {
-      this.lib.processCapabilityResponse(this.rendererPtr, sequence);
-      this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
-      this.emit("capabilities" /* CAPABILITIES */, this._capabilities);
-      return true;
+  processCapabilitySequence(sequence, hasCursorReport) {
+    const hasStandardCapabilitySignature = isCapabilityResponse(sequence);
+    const shouldProcessAsCapability = hasStandardCapabilitySignature || hasCursorReport && this.capabilityTimeoutId !== null;
+    if (!shouldProcessAsCapability) {
+      return false;
     }
-    return false;
+    this.lib.processCapabilityResponse(this.rendererPtr, sequence);
+    this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
+    this.emit("capabilities" /* CAPABILITIES */, this._capabilities);
+    const hadPendingSplitStartupCursorSeed = this.pendingSplitStartupCursorSeed;
+    if (hadPendingSplitStartupCursorSeed && hasCursorReport && this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
+      this.resetSplitScrollback(this.getSplitCursorSeedRows());
+      this.clearPendingSplitFooterTransition();
+      this.pendingSplitStartupCursorSeed = false;
+      this.updateStdinParserProtocolContext({ startupCursorCprActive: false });
+      if (this.splitStartupSeedTimeoutId !== null) {
+        this.clock.clearTimeout(this.splitStartupSeedTimeoutId);
+        this.splitStartupSeedTimeoutId = null;
+      }
+      this.requestRender();
+    }
+    const consumeStartupCursorReport = hadPendingSplitStartupCursorSeed && hasCursorReport && this.splitStartupSeedTimeoutId !== null;
+    return hasStandardCapabilitySignature || consumeStartupCursorReport;
+  }
+  capabilityHandler = ((sequence) => {
+    return this.processCapabilitySequence(sequence, false);
   }).bind(this);
   focusHandler = ((sequence) => {
     if (sequence === "\x1B[I") {
@@ -19925,6 +22392,9 @@ Captured output:
             subscriber(event.sequence);
           }
         }
+        if (event.protocol === "cpr" && this.processCapabilitySequence(event.sequence, true)) {
+          return;
+        }
         this.dispatchSequenceHandlers(event.sequence);
         return;
     }
@@ -20211,28 +22681,45 @@ Captured output:
   processResize(width, height) {
     if (width === this._terminalWidth && height === this._terminalHeight)
       return;
+    if (this._terminalIsSetup && this._controlState !== "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
+      this.flushPendingSplitOutputBeforeTransition();
+    }
+    const pendingSplitFooterTransition = this.pendingSplitFooterTransition;
+    const previousGeometry = calculateRenderGeometry(this._screenMode, this._terminalWidth, this._terminalHeight, this._footerHeight);
     const prevWidth = this._terminalWidth;
+    const previousTerminalHeight = this._terminalHeight;
+    const visiblePreviousSplitHeight = pendingSplitFooterTransition?.sourceHeight ?? previousGeometry.effectiveFooterHeight;
     this._terminalWidth = width;
     this._terminalHeight = height;
     this.queryPixelResolution();
     this.setCapturedRenderable(undefined);
     this.stdinParser?.resetMouseState();
-    if (this._splitHeight > 0) {
-      if (width < prevWidth) {
-        const start = this._terminalHeight - this._splitHeight * 2;
-        const flush = ANSI.moveCursorAndClear(start, 1);
+    const nextGeometry = calculateRenderGeometry(this._screenMode, this._terminalWidth, this._terminalHeight, this._footerHeight);
+    const splitFooterActive = this._screenMode === "split-footer";
+    if (splitFooterActive) {
+      let clearStart = null;
+      if (width < prevWidth && visiblePreviousSplitHeight > 0) {
+        clearStart = Math.max(previousTerminalHeight - visiblePreviousSplitHeight * 2, 1);
+      }
+      if (pendingSplitFooterTransition !== null) {
+        clearStart = clearStart === null ? pendingSplitFooterTransition.sourceTopLine : Math.min(clearStart, pendingSplitFooterTransition.sourceTopLine);
+      }
+      if (clearStart !== null) {
+        const flush = ANSI.moveCursorAndClear(clearStart, 1);
         this.writeOut(flush);
       }
-      this.renderOffset = height - this._splitHeight;
-      this.width = width;
-      this.height = this._splitHeight;
       this.currentRenderBuffer.clear(this.backgroundColor);
-      this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
-    } else {
-      this.width = width;
-      this.height = height;
     }
+    this.clearPendingSplitFooterTransition();
+    this._splitHeight = nextGeometry.effectiveFooterHeight;
+    this.width = nextGeometry.renderWidth;
+    this.height = nextGeometry.renderHeight;
     this.lib.resizeRenderer(this.rendererPtr, this.width, this.height);
+    if (this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
+      this.syncSplitScrollback();
+    } else {
+      this.syncSplitFooterState();
+    }
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this._console.resize(this.width, this.height);
@@ -20380,6 +22867,9 @@ Captured output:
     this._previousControlState = this._controlState;
     this._controlState = "explicit_suspended" /* EXPLICIT_SUSPENDED */;
     this.internalPause();
+    if (this._terminalIsSetup) {
+      this.flushPendingSplitOutputBeforeTransition(true);
+    }
     this._suspendedMouseEnabled = this._useMouse;
     this.disableMouse();
     this.removeExitListeners();
@@ -20387,7 +22877,8 @@ Captured output:
     this.updateStdinParserProtocolContext({
       privateCapabilityRepliesActive: false,
       pixelResolutionQueryActive: false,
-      explicitWidthCprActive: false
+      explicitWidthCprActive: false,
+      startupCursorCprActive: false
     });
     this.stdinParser?.reset();
     this.stdin.removeListener("data", this.stdinListener);
@@ -20406,6 +22897,9 @@ Captured output:
     this.stdin.resume();
     this.addExitListeners();
     this.lib.resumeRenderer(this.rendererPtr);
+    if (this._screenMode === "split-footer" && this._splitHeight > 0) {
+      this.syncSplitFooterState();
+    }
     if (this._suspendedMouseEnabled) {
       this.enableMouse();
     }
@@ -20467,7 +22961,6 @@ Captured output:
     process.removeListener("unhandledRejection", this.handleError);
     process.removeListener("warning", this.warningHandler);
     process.removeListener("beforeExit", this.exitHandler);
-    capture.removeListener("write", this.captureCallback);
     this.removeExitListeners();
     if (this.resizeTimeoutId !== null) {
       this.clock.clearTimeout(this.resizeTimeoutId);
@@ -20477,6 +22970,10 @@ Captured output:
       this.clock.clearTimeout(this.capabilityTimeoutId);
       this.capabilityTimeoutId = null;
     }
+    if (this.splitStartupSeedTimeoutId !== null) {
+      this.clock.clearTimeout(this.splitStartupSeedTimeoutId);
+      this.splitStartupSeedTimeoutId = null;
+    }
     if (this.memorySnapshotTimer) {
       this.clock.clearInterval(this.memorySnapshotTimer);
       this.memorySnapshotTimer = null;
@@ -20490,7 +22987,8 @@ Captured output:
     this.updateStdinParserProtocolContext({
       privateCapabilityRepliesActive: false,
       pixelResolutionQueryActive: false,
-      explicitWidthCprActive: false
+      explicitWidthCprActive: false,
+      startupCursorCprActive: false
     }, true);
     this._useMouse = false;
     this.setCapturedRenderable(undefined);
@@ -20529,6 +23027,16 @@ Captured output:
     this.stdinParser = null;
     this.oscSubscribers.clear();
     this._console.destroy();
+    if (this._splitHeight > 0 && this._terminalIsSetup && this._controlState !== "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
+      this.flushPendingSplitOutputBeforeTransition(true);
+      this.renderOffset = 0;
+      if (this.clearOnShutdown) {
+        this.lib.setRenderOffset(this.rendererPtr, 0);
+      }
+    }
+    this._externalOutputMode = "passthrough";
+    this.stdout.write = this.realStdoutWrite;
+    this.externalOutputQueue.clear();
     this.lib.destroyRenderer(this.rendererPtr);
     rendererTracker.removeRenderer(this);
     if (this._onDestroy) {
@@ -20637,12 +23145,21 @@ Captured output:
       console.error("Rendering called concurrently");
       throw new Error("Rendering called concurrently");
     }
-    let force = false;
-    if (this._splitHeight > 0) {
-      force = this.flushStdoutCache(this._splitHeight);
-    }
     this.renderingNative = true;
-    this.lib.render(this.rendererPtr, force);
+    if (this.pendingSplitStartupCursorSeed && this.splitStartupSeedTimeoutId !== null && this._splitHeight > 0 && this._externalOutputMode === "capture-stdout") {
+      this.renderingNative = false;
+      return;
+    }
+    if (this._splitHeight > 0 && this._externalOutputMode === "capture-stdout") {
+      const forceSplitRepaint = this.forceFullRepaintRequested;
+      this.forceFullRepaintRequested = false;
+      this.flushPendingSplitCommits(forceSplitRepaint);
+      this.pendingSplitFooterTransition = null;
+    } else {
+      this.forceFullRepaintRequested = false;
+      this.pendingSplitFooterTransition = null;
+      this.lib.render(this.rendererPtr, false);
+    }
     this.renderingNative = false;
   }
   collectStatSample(frameTime) {
@@ -20824,7 +23341,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, EditBuffer, EditorView, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, 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, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, ANSI, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, TextRenderable, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, calculateRenderGeometry, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=9682C54D228A139264756E2164756E21
-//# sourceMappingURL=index-xsfpee0k.js.map
+//# debugId=F970487203C0DBFC64756E2164756E21
+//# sourceMappingURL=index-qpcsqve6.js.map