@opentui/core 0.1.101 → 0.1.103

package/{index-xsfpee0k.js → index-4pvh4sbk.js}

@@ -1969,23 +1969,126 @@ class InternalKeyHandler extends KeyHandler {
 }
 
 // src/lib/RGBA.ts
+var COLOR_TAG_RGB = 256;
+var COLOR_TAG_DEFAULT = 257;
+var DEFAULT_FOREGROUND_RGB = [255, 255, 255];
+var DEFAULT_BACKGROUND_RGB = [0, 0, 0];
+var RGBA_BUFFER_STRIDE = 5;
+var ANSI16_RGB = [
+  [0, 0, 0],
+  [128, 0, 0],
+  [0, 128, 0],
+  [128, 128, 0],
+  [0, 0, 128],
+  [128, 0, 128],
+  [0, 128, 128],
+  [192, 192, 192],
+  [128, 128, 128],
+  [255, 0, 0],
+  [0, 255, 0],
+  [255, 255, 0],
+  [0, 0, 255],
+  [255, 0, 255],
+  [0, 255, 255],
+  [255, 255, 255]
+];
+var ANSI_256_CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
+function normalizeColorTag(tag) {
+  const normalizedTag = tag != null && Number.isFinite(tag) ? Math.round(tag) : COLOR_TAG_RGB;
+  if (normalizedTag === COLOR_TAG_RGB || normalizedTag === COLOR_TAG_DEFAULT) {
+    return normalizedTag;
+  }
+  if (Number.isInteger(normalizedTag) && normalizedTag >= 0 && normalizedTag <= 255) {
+    return normalizedTag;
+  }
+  return COLOR_TAG_RGB;
+}
+function normalizeRGBABuffer(buffer) {
+  if (buffer.length === RGBA_BUFFER_STRIDE) {
+    buffer[4] = normalizeColorTag(buffer[4]);
+    return buffer;
+  }
+  const normalized = new Float32Array(RGBA_BUFFER_STRIDE);
+  normalized[0] = buffer[0] ?? 0;
+  normalized[1] = buffer[1] ?? 0;
+  normalized[2] = buffer[2] ?? 0;
+  normalized[3] = buffer[3] ?? 0;
+  normalized[4] = COLOR_TAG_RGB;
+  return normalized;
+}
+function withTag(rgba, tag) {
+  const tagged = RGBA.clone(rgba);
+  tagged.tag = tag;
+  return tagged;
+}
+function rgbaForAnsi256Index(index) {
+  const [r, g, b] = ansi256IndexToRgb(index);
+  return RGBA.fromInts(r, g, b);
+}
+function normalizeIndexedColorIndex(index) {
+  if (!Number.isInteger(index) || index < 0 || index > 255) {
+    throw new RangeError(`Indexed color must be an integer in the range 0..255, got ${index}`);
+  }
+  return index;
+}
+function ansi256IndexToRgb(index) {
+  const normalizedIndex = normalizeIndexedColorIndex(index);
+  if (normalizedIndex < ANSI16_RGB.length) {
+    return ANSI16_RGB[normalizedIndex];
+  }
+  if (normalizedIndex < 232) {
+    const cubeIndex = normalizedIndex - 16;
+    const r = Math.floor(cubeIndex / 36);
+    const g = Math.floor(cubeIndex / 6) % 6;
+    const b = cubeIndex % 6;
+    return [ANSI_256_CUBE_LEVELS[r], ANSI_256_CUBE_LEVELS[g], ANSI_256_CUBE_LEVELS[b]];
+  }
+  const value = 8 + (normalizedIndex - 232) * 10;
+  return [value, value, value];
+}
+function decodeColorTag(tag) {
+  if (tag === COLOR_TAG_DEFAULT) {
+    return { kind: "default" };
+  }
+  if (tag === COLOR_TAG_RGB) {
+    return { kind: "rgb" };
+  }
+  return { kind: "indexed", index: normalizeIndexedColorIndex(tag) };
+}
+
 class RGBA {
   buffer;
   constructor(buffer) {
-    this.buffer = buffer;
+    this.buffer = normalizeRGBABuffer(buffer);
   }
   static fromArray(array) {
     return new RGBA(array);
   }
-  static fromValues(r, g, b, a = 1) {
-    return new RGBA(new Float32Array([r, g, b, a]));
+  static fromValues(r, g, b, a = 1, tag = COLOR_TAG_RGB) {
+    return new RGBA(new Float32Array([r, g, b, a, normalizeColorTag(tag)]));
   }
-  static fromInts(r, g, b, a = 255) {
-    return new RGBA(new Float32Array([r / 255, g / 255, b / 255, a / 255]));
+  static clone(rgba) {
+    return RGBA.fromValues(rgba.r, rgba.g, rgba.b, rgba.a, rgba.tag);
+  }
+  static fromInts(r, g, b, a = 255, tag = COLOR_TAG_RGB) {
+    return new RGBA(new Float32Array([r / 255, g / 255, b / 255, a / 255, normalizeColorTag(tag)]));
   }
   static fromHex(hex) {
     return hexToRgb(hex);
   }
+  static fromIndex(index, snapshot) {
+    const normalizedIndex = normalizeIndexedColorIndex(index);
+    return withTag(snapshot ? parseColor(snapshot) : rgbaForAnsi256Index(normalizedIndex), normalizedIndex);
+  }
+  static defaultForeground(snapshot) {
+    return withTag(snapshot ? parseColor(snapshot) : RGBA.fromInts(...DEFAULT_FOREGROUND_RGB), COLOR_TAG_DEFAULT);
+  }
+  static defaultBackground(snapshot) {
+    return withTag(snapshot ? parseColor(snapshot) : RGBA.fromInts(...DEFAULT_BACKGROUND_RGB), COLOR_TAG_DEFAULT);
+  }
+  static getIntentTag(rgba) {
+    return rgba.tag;
+  }
   toInts() {
     return [Math.round(this.r * 255), Math.round(this.g * 255), Math.round(this.b * 255), Math.round(this.a * 255)];
   }
@@ -2013,6 +2116,12 @@ class RGBA {
   set a(value) {
     this.buffer[3] = value;
   }
+  get tag() {
+    return normalizeColorTag(this.buffer[4]);
+  }
+  set tag(value) {
+    this.buffer[4] = normalizeColorTag(value);
+  }
   map(fn) {
     return [fn(this.r), fn(this.g), fn(this.b), fn(this.a)];
   }
@@ -2022,9 +2131,15 @@ class RGBA {
   equals(other) {
     if (!other)
       return false;
-    return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a;
+    return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a && this.tag === other.tag;
   }
 }
+function normalizeColorValue(value) {
+  if (value == null)
+    return null;
+  const rgba = parseColor(value);
+  return { rgba, tag: rgba.tag };
+}
 function hexToRgb(hex) {
   hex = hex.replace(/^#/, "");
   if (hex.length === 3) {
@@ -6867,7 +6982,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 +7172,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 +7192,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 +7312,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 +7815,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;
@@ -10648,6 +10778,38 @@ class TerminalPalette {
 function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
   return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock);
 }
+var DEFAULT_FOREGROUND_FALLBACK = RGBA.fromInts(...DEFAULT_FOREGROUND_RGB);
+var DEFAULT_BACKGROUND_FALLBACK = RGBA.fromInts(...DEFAULT_BACKGROUND_RGB);
+var fallbackAnsi256Palette = null;
+function getFallbackAnsi256Palette() {
+  if (!fallbackAnsi256Palette) {
+    fallbackAnsi256Palette = Array.from({ length: 256 }, (_, index) => {
+      const [r, g, b] = ansi256IndexToRgb(index);
+      return RGBA.fromInts(r, g, b);
+    });
+  }
+  return fallbackAnsi256Palette;
+}
+function normalizeTerminalPalette(colors) {
+  const fallbackPalette = getFallbackAnsi256Palette();
+  return {
+    palette: Array.from({ length: 256 }, (_, index) => {
+      const detected = colors?.palette[index];
+      return detected ? RGBA.fromHex(detected) : RGBA.clone(fallbackPalette[index]);
+    }),
+    defaultForeground: colors?.defaultForeground ? RGBA.fromHex(colors.defaultForeground) : RGBA.clone(DEFAULT_FOREGROUND_FALLBACK),
+    defaultBackground: colors?.defaultBackground ? RGBA.fromHex(colors.defaultBackground) : RGBA.clone(DEFAULT_BACKGROUND_FALLBACK)
+  };
+}
+function buildTerminalPaletteSignature(colors) {
+  const normalized = normalizeTerminalPalette(colors);
+  const paletteSignature = normalized.palette.map((color) => color.toInts().join(",")).join(";");
+  return [
+    paletteSignature,
+    normalized.defaultForeground.toInts().join(","),
+    normalized.defaultBackground.toInts().join(",")
+  ].join("|");
+}
 
 // src/lib/paste.ts
 var PASTE_TEXT_DECODER = new TextDecoder;
@@ -10745,6 +10907,7 @@ class OptimizedBuffer {
   _widthMethod;
   respectAlpha = false;
   _rawBuffers = null;
+  _rawColorTags = null;
   _destroyed = false;
   get ptr() {
     return this.bufferPtr;
@@ -10753,23 +10916,38 @@ class OptimizedBuffer {
     if (this._destroyed)
       throw new Error(`Buffer ${this.id} is destroyed`);
   }
+  ensureRawBufferViews() {
+    if (this._rawBuffers !== null && this._rawColorTags !== null) {
+      return;
+    }
+    const size = this._width * this._height;
+    const charPtr = this.lib.bufferGetCharPtr(this.bufferPtr);
+    const fgPtr = this.lib.bufferGetFgPtr(this.bufferPtr);
+    const bgPtr = this.lib.bufferGetBgPtr(this.bufferPtr);
+    const fgTagPtr = this.lib.bufferGetFgTagPtr(this.bufferPtr);
+    const bgTagPtr = this.lib.bufferGetBgTagPtr(this.bufferPtr);
+    const attributesPtr = this.lib.bufferGetAttributesPtr(this.bufferPtr);
+    this._rawBuffers = {
+      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
+      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
+      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
+      attributes: new Uint32Array(toArrayBuffer(attributesPtr, 0, size * 4))
+    };
+    this._rawColorTags = {
+      fg: new Uint16Array(toArrayBuffer(fgTagPtr, 0, size * 2)),
+      bg: new Uint16Array(toArrayBuffer(bgTagPtr, 0, size * 2))
+    };
+  }
   get buffers() {
     this.guard();
-    if (this._rawBuffers === null) {
-      const size = this._width * this._height;
-      const charPtr = this.lib.bufferGetCharPtr(this.bufferPtr);
-      const fgPtr = this.lib.bufferGetFgPtr(this.bufferPtr);
-      const bgPtr = this.lib.bufferGetBgPtr(this.bufferPtr);
-      const attributesPtr = this.lib.bufferGetAttributesPtr(this.bufferPtr);
-      this._rawBuffers = {
-        char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
-        fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
-        bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
-        attributes: new Uint32Array(toArrayBuffer(attributesPtr, 0, size * 4))
-      };
-    }
+    this.ensureRawBufferViews();
     return this._rawBuffers;
   }
+  get rawColorTags() {
+    this.guard();
+    this.ensureRawBufferViews();
+    return this._rawColorTags;
+  }
   constructor(lib, ptr2, width, height, options) {
     this.id = options.id || `fb_${OptimizedBuffer.fbIdCounter++}`;
     this.lib = lib;
@@ -10814,6 +10992,7 @@ class OptimizedBuffer {
   getSpanLines() {
     this.guard();
     const { char, fg: fg2, bg: bg2, attributes } = this.buffers;
+    const { fg: fgTag, bg: bgTag } = this.rawColorTags;
     const lines = [];
     const CHAR_FLAG_CONTINUATION = 3221225472 | 0;
     const CHAR_FLAG_MASK = 3221225472 | 0;
@@ -10828,8 +11007,8 @@ class OptimizedBuffer {
       for (let x = 0;x < this._width; x++) {
         const i = y * this._width + x;
         const cp = char[i];
-        const cellFg = RGBA.fromValues(fg2[i * 4], fg2[i * 4 + 1], fg2[i * 4 + 2], fg2[i * 4 + 3]);
-        const cellBg = RGBA.fromValues(bg2[i * 4], bg2[i * 4 + 1], bg2[i * 4 + 2], bg2[i * 4 + 3]);
+        const cellFg = RGBA.fromValues(fg2[i * 4], fg2[i * 4 + 1], fg2[i * 4 + 2], fg2[i * 4 + 3], fgTag[i]);
+        const cellBg = RGBA.fromValues(bg2[i * 4], bg2[i * 4 + 1], bg2[i * 4 + 2], bg2[i * 4 + 3], bgTag[i]);
         const cellAttrs = attributes[i] & 255;
         const isContinuation = (cp & CHAR_FLAG_MASK) === CHAR_FLAG_CONTINUATION;
         const cellChar = isContinuation ? "" : lineChars[charIdx++] ?? " ";
@@ -10957,6 +11136,7 @@ class OptimizedBuffer {
     this._width = width;
     this._height = height;
     this._rawBuffers = null;
+    this._rawColorTags = null;
     this.lib.bufferResize(this.bufferPtr, width, height);
   }
   drawBox(options) {
@@ -11650,16 +11830,30 @@ var StyledChunkStruct = defineStruct([
       unpackTransform: rgbaUnpackTransform
     }
   ],
+  ["fg_tag", "u16", { default: COLOR_TAG_RGB }],
+  ["bg_tag", "u16", { default: COLOR_TAG_RGB }],
   ["attributes", "u32", { default: 0 }],
   ["link", "char*", { default: "" }],
   ["link_len", "u64", { lengthOf: "link" }]
 ], {
   mapValue: (chunk) => {
+    const normalizedFg = normalizeColorValue(chunk.fg ?? null);
+    const normalizedBg = normalizeColorValue(chunk.bg ?? null);
     if (!chunk.link || typeof chunk.link === "string") {
-      return chunk;
+      return {
+        ...chunk,
+        fg: normalizedFg?.rgba ?? null,
+        bg: normalizedBg?.rgba ?? null,
+        fg_tag: normalizedFg?.tag ?? COLOR_TAG_RGB,
+        bg_tag: normalizedBg?.tag ?? COLOR_TAG_RGB
+      };
     }
     return {
       ...chunk,
+      fg: normalizedFg?.rgba ?? null,
+      bg: normalizedBg?.rgba ?? null,
+      fg_tag: normalizedFg?.tag ?? COLOR_TAG_RGB,
+      bg_tag: normalizedBg?.tag ?? COLOR_TAG_RGB,
       link: chunk.link.url
     };
   }
@@ -11688,6 +11882,7 @@ var TerminalCapabilitiesStruct = defineStruct([
   ["kitty_keyboard", "bool_u8"],
   ["kitty_graphics", "bool_u8"],
   ["rgb", "bool_u8"],
+  ["ansi256", "bool_u8"],
   ["unicode", UnicodeMethodEnum],
   ["sgr_pixels", "bool_u8"],
   ["color_scheme_updates", "bool_u8"],
@@ -11895,6 +12090,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "bool"],
       returns: "void"
     },
+    setClearOnShutdown: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
     setBackgroundColor: {
       args: ["ptr", "ptr"],
       returns: "void"
@@ -11903,6 +12102,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 +12130,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"
@@ -11923,10 +12146,18 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    rendererSetPaletteState: {
+      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
     queryPixelResolution: {
       args: ["ptr"],
       returns: "void"
     },
+    queryThemeColors: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createOptimizedBuffer: {
       args: ["u32", "u32", "bool", "u8", "ptr", "usize"],
       returns: "ptr"
@@ -11963,6 +12194,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    bufferGetFgTagPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetBgTagPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
     bufferGetAttributesPtr: {
       args: ["ptr"],
       returns: "ptr"
@@ -12387,6 +12626,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u8"],
       returns: "void"
     },
+    textBufferViewSetFirstLineOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
     textBufferViewSetViewportSize: {
       args: ["ptr", "u32", "u32"],
       returns: "void"
@@ -12760,7 +13003,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     syntaxStyleRegister: {
-      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u8"],
+      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u32"],
       returns: "u32"
     },
     syntaxStyleResolveByName: {
@@ -13124,12 +13367,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);
   }
@@ -13154,6 +13412,18 @@ class FFIRenderLib {
     const height = this.opentui.symbols.getBufferHeight(bufferPtr);
     return new OptimizedBuffer(this, bufferPtr, width, height, { id: "current buffer", widthMethod: "unicode" });
   }
+  rendererSetPaletteState(renderer, palette, defaultForeground, defaultBackground, paletteEpoch) {
+    const paletteBuffer = new Float32Array(palette.length * 4);
+    for (let index = 0;index < palette.length; index++) {
+      const color = palette[index];
+      const base = index * 4;
+      paletteBuffer[base] = color.r;
+      paletteBuffer[base + 1] = color.g;
+      paletteBuffer[base + 2] = color.b;
+      paletteBuffer[base + 3] = color.a;
+    }
+    this.opentui.symbols.rendererSetPaletteState(renderer, paletteBuffer, paletteBuffer.length, defaultForeground.buffer, defaultBackground.buffer, paletteEpoch >>> 0);
+  }
   bufferGetCharPtr(buffer) {
     const ptr5 = this.opentui.symbols.bufferGetCharPtr(buffer);
     if (!ptr5) {
@@ -13175,6 +13445,20 @@ class FFIRenderLib {
     }
     return ptr5;
   }
+  bufferGetFgTagPtr(buffer) {
+    const ptr5 = this.opentui.symbols.bufferGetFgTagPtr(buffer);
+    if (!ptr5) {
+      throw new Error("Failed to get fg tag pointer");
+    }
+    return ptr5;
+  }
+  bufferGetBgTagPtr(buffer) {
+    const ptr5 = this.opentui.symbols.bufferGetBgTagPtr(buffer);
+    if (!ptr5) {
+      throw new Error("Failed to get bg tag pointer");
+    }
+    return ptr5;
+  }
   bufferGetAttributesPtr(buffer) {
     const ptr5 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
     if (!ptr5) {
@@ -13319,6 +13603,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);
@@ -13426,6 +13716,9 @@ class FFIRenderLib {
   queryPixelResolution(renderer) {
     this.opentui.symbols.queryPixelResolution(renderer);
   }
+  queryThemeColors(renderer) {
+    this.opentui.symbols.queryThemeColors(renderer);
+  }
   writeOut(renderer, data) {
     const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
     if (bytes.length === 0)
@@ -13598,6 +13891,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);
   }
@@ -14127,6 +14423,7 @@ class FFIRenderLib {
       kitty_keyboard: caps.kitty_keyboard,
       kitty_graphics: caps.kitty_graphics,
       rgb: caps.rgb,
+      ansi256: caps.ansi256,
       unicode: caps.unicode,
       sgr_pixels: caps.sgr_pixels,
       color_scheme_updates: caps.color_scheme_updates,
@@ -16051,6 +16348,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,54 +16985,1490 @@ 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;
+  }
+  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;
+  }
+  get ptr() {
+    this.guard();
+    return this.stylePtr;
+  }
+  getStyleCount() {
+    this.guard();
+    return this.lib.syntaxStyleGetStyleCount(this.stylePtr);
+  }
+  clearNameCache() {
+    this.nameCache.clear();
+  }
+  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) {
+        this.requestRender();
+        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;
@@ -18734,6 +20600,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)) {
@@ -18767,30 +20654,155 @@ function parsePixelResolution(sequence) {
       height: parseInt(match[1])
     };
   }
-  return null;
+  return null;
+}
+
+// src/renderer-theme-mode.ts
+var OSC_THEME_RESPONSE = /\x1b](10|11);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
+function scaleOscThemeComponent(component) {
+  const value = parseInt(component, 16);
+  const maxValue = (1 << 4 * component.length) - 1;
+  return Math.round(value / maxValue * 255).toString(16).padStart(2, "0");
+}
+function oscThemeColorToHex(r, g, b, hex6) {
+  if (hex6) {
+    return `#${hex6.toLowerCase()}`;
+  }
+  if (r && g && b) {
+    return `#${scaleOscThemeComponent(r)}${scaleOscThemeComponent(g)}${scaleOscThemeComponent(b)}`;
+  }
+  return "#000000";
+}
+function inferThemeModeFromBackgroundColor(color) {
+  const [r, g, b] = parseColor(color).toInts();
+  const brightness = (r * 299 + g * 587 + b * 114) / 1000;
+  return brightness > 128 ? "light" : "dark";
+}
+
+class RendererThemeMode {
+  host;
+  clock;
+  static QUERY_TIMEOUT_MS = 250;
+  _themeMode = null;
+  themeQueryPending = true;
+  themeOscForeground = null;
+  themeOscBackground = null;
+  themeRefreshTimeoutId = null;
+  waiters = new Set;
+  constructor(host, clock2) {
+    this.host = host;
+    this.clock = clock2;
+  }
+  get themeMode() {
+    return this._themeMode;
+  }
+  waitForThemeMode(timeoutMs, isDestroyed) {
+    if (this._themeMode !== null || isDestroyed || timeoutMs === 0) {
+      return Promise.resolve(this._themeMode);
+    }
+    return new Promise((resolve4) => {
+      const waiter = {
+        resolve: resolve4,
+        timeoutHandle: null
+      };
+      if (timeoutMs > 0) {
+        waiter.timeoutHandle = this.clock.setTimeout(() => {
+          this.waiters.delete(waiter);
+          waiter.timeoutHandle = null;
+          resolve4(this._themeMode);
+        }, timeoutMs);
+      }
+      this.waiters.add(waiter);
+    });
+  }
+  cancelRefresh() {
+    if (this.themeRefreshTimeoutId === null) {
+      return;
+    }
+    this.clock.clearTimeout(this.themeRefreshTimeoutId);
+    this.themeRefreshTimeoutId = null;
+    this.themeQueryPending = false;
+  }
+  dispose() {
+    this.cancelRefresh();
+    for (const waiter of this.waiters) {
+      if (waiter.timeoutHandle !== null) {
+        this.clock.clearTimeout(waiter.timeoutHandle);
+      }
+      waiter.resolve(this._themeMode);
+    }
+    this.waiters.clear();
+  }
+  handleSequence(sequence) {
+    if (sequence === "\x1B[?997;1n" || sequence === "\x1B[?997;2n") {
+      this.requestThemeOscColors();
+      return { handled: true, changedMode: null };
+    }
+    let handledOscThemeResponse = false;
+    let match;
+    OSC_THEME_RESPONSE.lastIndex = 0;
+    while (match = OSC_THEME_RESPONSE.exec(sequence)) {
+      handledOscThemeResponse = true;
+      const color = oscThemeColorToHex(match[2], match[3], match[4], match[5]);
+      if (match[1] === "10") {
+        this.themeOscForeground = color;
+      } else {
+        this.themeOscBackground = color;
+      }
+    }
+    if (!handledOscThemeResponse) {
+      return { handled: false, changedMode: null };
+    }
+    if (!this.themeQueryPending) {
+      return { handled: true, changedMode: null };
+    }
+    if (!this.themeOscForeground || !this.themeOscBackground) {
+      return { handled: true, changedMode: null };
+    }
+    const nextMode = inferThemeModeFromBackgroundColor(this.themeOscBackground);
+    const changedMode = this.applyThemeMode(nextMode);
+    this.completeThemeQuery();
+    return { handled: true, changedMode };
+  }
+  clearThemeRefreshTimeout() {
+    if (this.themeRefreshTimeoutId === null) {
+      return;
+    }
+    this.clock.clearTimeout(this.themeRefreshTimeoutId);
+    this.themeRefreshTimeoutId = null;
+  }
+  completeThemeQuery() {
+    this.clearThemeRefreshTimeout();
+    this.themeQueryPending = false;
+  }
+  requestThemeOscColors() {
+    this.themeQueryPending = true;
+    this.themeOscForeground = null;
+    this.themeOscBackground = null;
+    this.host.queryThemeColors();
+    this.clearThemeRefreshTimeout();
+    this.themeRefreshTimeoutId = this.clock.setTimeout(() => {
+      this.completeThemeQuery();
+    }, RendererThemeMode.QUERY_TIMEOUT_MS);
+  }
+  applyThemeMode(mode) {
+    const changed = this._themeMode !== mode;
+    this._themeMode = mode;
+    if (!changed) {
+      return null;
+    }
+    for (const waiter of this.waiters) {
+      if (waiter.timeoutHandle !== null) {
+        this.clock.clearTimeout(waiter.timeoutHandle);
+      }
+      waiter.resolve(mode);
+    }
+    this.waiters.clear();
+    return mode;
+  }
 }
 
 // src/renderer.ts
-var OSC_THEME_RESPONSE = /\x1b](10|11);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
-function scaleOscThemeComponent(component) {
-  const value = parseInt(component, 16);
-  const maxValue = (1 << 4 * component.length) - 1;
-  return Math.round(value / maxValue * 255).toString(16).padStart(2, "0");
-}
-function oscThemeColorToHex(r, g, b, hex6) {
-  if (hex6) {
-    return `#${hex6.toLowerCase()}`;
-  }
-  if (r && g && b) {
-    return `#${scaleOscThemeComponent(r)}${scaleOscThemeComponent(g)}${scaleOscThemeComponent(b)}`;
-  }
-  return "#000000";
-}
-function inferThemeModeFromBackgroundColor(color) {
-  const [r, g, b] = parseColor(color).toInts();
-  const brightness = (r * 299 + g * 587 + b * 114) / 1000;
-  return brightness > 128 ? "light" : "dark";
-}
 registerEnvVar({
   name: "OTUI_DUMP_CAPTURES",
   description: "Dump captured stdout and console caches when the renderer exit handler runs.",
@@ -18828,6 +20840,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;
@@ -18860,6 +20875,101 @@ function resolveModes(config) {
     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",
   "TERM",
@@ -18980,9 +21090,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 +21209,8 @@ class CliRenderer extends EventEmitter9 {
   animationRequest = new Map;
   resizeTimeoutId = null;
   capabilityTimeoutId = null;
+  splitStartupSeedTimeoutId = null;
+  pendingSplitStartupCursorSeed = false;
   resizeDebounceDelay = 100;
   enableMouseMovement = false;
   _useMouse = true;
@@ -19106,6 +21218,7 @@ class CliRenderer extends EventEmitter9 {
   _screenMode = "alternate-screen";
   _footerHeight = DEFAULT_FOOTER_HEIGHT;
   _externalOutputMode = "passthrough";
+  clearOnShutdown = true;
   _suspendedMouseEnabled = false;
   _previousControlState = "idle" /* IDLE */;
   capturedRenderable;
@@ -19116,15 +21229,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;
@@ -19144,18 +21257,20 @@ class CliRenderer extends EventEmitter9 {
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
   _paletteDetector = null;
+  _paletteCache = new Map;
   _cachedPalette = null;
   _paletteDetectionPromise = null;
+  _paletteDetectionSize = 0;
+  _paletteEpoch = 0;
+  _publishedPaletteSignature = null;
+  _palettePublishGeneration = 0;
   _onDestroy;
-  _themeMode = null;
-  _themeModeSource = "none";
-  _themeFallbackPending = true;
-  _themeOscForeground = null;
-  _themeOscBackground = null;
+  themeModeState;
   _terminalFocusState = null;
   sequenceHandlers = [];
   prependedInputHandlers = [];
   shouldRestoreModesOnNextFocus = false;
+  themeModeHandler;
   idleResolvers = [];
   _debugInputs = [];
   _debugModeEnabled = env.OTUI_DEBUG;
@@ -19167,8 +21282,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 +21298,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,14 +21338,19 @@ 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;
-    const forwardEnvKeys = config.forwardEnvKeys ?? [...DEFAULT_FORWARDED_ENV_KEYS];
+    this.clearOnShutdown = config.clearOnShutdown ?? true;
+    this.lib.setClearOnShutdown(this.rendererPtr, this.clearOnShutdown);
+    const forwardEnvKeys = config.forwardEnvKeys ?? (config.remote ? [] : [...DEFAULT_FORWARDED_ENV_KEYS]);
     for (const key of forwardEnvKeys) {
       const value = process.env[key];
       if (value === undefined)
@@ -19239,6 +21373,18 @@ Captured output:
     this.targetFps = config.targetFps || 30;
     this.maxFps = config.maxFps || 60;
     this.clock = config.clock ?? new SystemClock;
+    this.themeModeState = new RendererThemeMode({
+      queryThemeColors: () => {
+        this.lib.queryThemeColors(this.rendererPtr);
+      }
+    }, this.clock);
+    this.themeModeHandler = (sequence) => {
+      const result = this.themeModeState.handleSequence(sequence);
+      if (result.changedMode) {
+        this.emit("theme_mode" /* THEME_MODE */, result.changedMode);
+      }
+      return result.handled;
+    };
     this.memorySnapshotInterval = config.memorySnapshotInterval ?? 0;
     this.gatherStats = config.gatherStats || false;
     this.maxStatSamples = config.maxStatSamples || 300;
@@ -19283,7 +21429,8 @@ Captured output:
         kittyKeyboardEnabled: useKittyForParsing,
         privateCapabilityRepliesActive: false,
         pixelResolutionQueryActive: false,
-        explicitWidthCprActive: false
+        explicitWidthCprActive: false,
+        startupCursorCprActive: false
       },
       clock: this.clock
     });
@@ -19293,7 +21440,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) => {
@@ -19520,127 +21667,701 @@ Captured output:
     this._targetFps = targetFps;
     this.targetFrameTime = 1000 / this._targetFps;
   }
-  get maxFps() {
-    return this._maxFps;
+  get maxFps() {
+    return this._maxFps;
+  }
+  set maxFps(maxFps) {
+    this._maxFps = maxFps;
+    this.minTargetFrameTime = 1000 / this._maxFps;
+  }
+  get useMouse() {
+    return this._useMouse;
+  }
+  set useMouse(useMouse) {
+    if (this._useMouse === useMouse)
+      return;
+    this._useMouse = useMouse;
+    if (useMouse) {
+      this.enableMouse();
+    } else {
+      this.disableMouse();
+    }
+  }
+  get screenMode() {
+    return this._screenMode;
+  }
+  set screenMode(mode) {
+    if (this.externalOutputMode === "capture-stdout" && mode !== "split-footer") {
+      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+    }
+    this.applyScreenMode(mode);
+  }
+  get footerHeight() {
+    return this._footerHeight;
+  }
+  set footerHeight(footerHeight) {
+    const normalizedFooterHeight = normalizeFooterHeight(footerHeight);
+    if (normalizedFooterHeight === this._footerHeight) {
+      return;
+    }
+    this._footerHeight = normalizedFooterHeight;
+    if (this.screenMode === "split-footer") {
+      this.applyScreenMode("split-footer");
+    }
+  }
+  get externalOutputMode() {
+    return this._externalOutputMode;
+  }
+  set externalOutputMode(mode) {
+    if (mode === "capture-stdout" && this.screenMode !== "split-footer") {
+      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+    }
+    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;
+  }
+  get currentControlState() {
+    return this._controlState;
+  }
+  get capabilities() {
+    return this._capabilities;
+  }
+  get themeMode() {
+    return this.themeModeState.themeMode;
+  }
+  waitForThemeMode(timeoutMs = 1000) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new Error("timeoutMs must be a non-negative finite number");
+    }
+    return this.themeModeState.waitForThemeMode(timeoutMs, this._isDestroyed);
+  }
+  getDebugInputs() {
+    return [...this._debugInputs];
+  }
+  get useKittyKeyboard() {
+    return this.lib.getKittyKeyboardFlags(this.rendererPtr) > 0;
+  }
+  set useKittyKeyboard(use) {
+    const flags = use ? KITTY_FLAG_DISAMBIGUATE | KITTY_FLAG_ALTERNATE_KEYS : 0;
+    this.lib.setKittyKeyboardFlags(this.rendererPtr, flags);
+  }
+  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));
   }
-  set maxFps(maxFps) {
-    this._maxFps = maxFps;
-    this.minTargetFrameTime = 1000 / this._maxFps;
+  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);
   }
-  get useMouse() {
-    return this._useMouse;
+  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;
   }
-  set useMouse(useMouse) {
-    if (this._useMouse === useMouse)
+  publishSplitTailColumns(columns) {
+    if (columns <= 0) {
       return;
-    this._useMouse = useMouse;
-    if (useMouse) {
-      this.enableMouse();
-    } else {
-      this.disableMouse();
     }
+    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;
   }
-  get screenMode() {
-    return this._screenMode;
+  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;
+      }
+    }
   }
-  set screenMode(mode) {
-    if (this.externalOutputMode === "capture-stdout" && mode !== "split-footer") {
-      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+  enqueueRenderedScrollbackCommit(options) {
+    if (this._screenMode !== "split-footer" || this._externalOutputMode !== "capture-stdout") {
+      throw new Error('scrollback commit requires screenMode "split-footer" and externalOutputMode "capture-stdout"');
     }
-    this.applyScreenMode(mode);
+    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();
   }
-  get footerHeight() {
-    return this._footerHeight;
+  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();
+    }
   }
-  set footerHeight(footerHeight) {
-    const normalizedFooterHeight = normalizeFooterHeight(footerHeight);
-    if (normalizedFooterHeight === this._footerHeight) {
-      return;
+  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;
     }
-    this._footerHeight = normalizedFooterHeight;
-    if (this.screenMode === "split-footer") {
-      this.applyScreenMode("split-footer");
+    if (current.length > 0) {
+      rows.push({ line: current, trailingNewline: false });
     }
+    return rows;
   }
-  get externalOutputMode() {
-    return this._externalOutputMode;
-  }
-  set externalOutputMode(mode) {
-    if (mode === "capture-stdout" && this.screenMode !== "split-footer") {
-      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+  createStdoutSnapshotCommits(text) {
+    if (text.length === 0) {
+      return [];
     }
-    this._externalOutputMode = mode;
-    this.stdout.write = mode === "capture-stdout" ? this.interceptStdoutWrite : this.realStdoutWrite;
-  }
-  get liveRequestCount() {
-    return this.liveRequestCounter;
+    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;
   }
-  get currentControlState() {
-    return this._controlState;
+  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();
+    }
   }
-  get capabilities() {
-    return this._capabilities;
+  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;
   }
-  get themeMode() {
-    return this._themeMode;
+  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));
   }
-  waitForThemeMode(timeoutMs = 1000) {
-    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
-      throw new Error("timeoutMs must be a non-negative finite number");
+  flushPendingSplitOutputBeforeTransition(forceFooterRepaint = false) {
+    if (this._screenMode !== "split-footer" || this._splitHeight <= 0 || this._externalOutputMode !== "capture-stdout") {
+      return;
     }
-    if (this._themeMode !== null || this._isDestroyed || timeoutMs === 0) {
-      return Promise.resolve(this._themeMode);
+    if (this.externalOutputQueue.size === 0 && !forceFooterRepaint) {
+      return;
     }
-    return new Promise((resolve4) => {
-      let timeoutHandle = null;
-      const cleanup = () => {
-        if (timeoutHandle !== null) {
-          this.clock.clearTimeout(timeoutHandle);
-          timeoutHandle = null;
-        }
-        this.off("theme_mode" /* THEME_MODE */, handleThemeMode);
-        this.off("destroy" /* DESTROY */, handleDestroy);
-      };
-      const finish = () => {
-        cleanup();
-        resolve4(this._themeMode);
-      };
-      const handleThemeMode = () => {
-        finish();
-      };
-      const handleDestroy = () => {
-        finish();
-      };
-      this.on("theme_mode" /* THEME_MODE */, handleThemeMode);
-      this.on("destroy" /* DESTROY */, handleDestroy);
-      timeoutHandle = this.clock.setTimeout(finish, timeoutMs);
-    });
+    this.flushPendingSplitCommits(forceFooterRepaint);
   }
-  getDebugInputs() {
-    return [...this._debugInputs];
+  resetSplitScrollback(seedRows = 0) {
+    this.splitTailColumn = 0;
+    this.renderOffset = this.lib.resetSplitScrollback(this.rendererPtr, seedRows, this.getSplitPinnedRenderOffset());
   }
-  get useKittyKeyboard() {
-    return this.lib.getKittyKeyboardFlags(this.rendererPtr) > 0;
+  syncSplitScrollback() {
+    this.renderOffset = this.lib.syncSplitScrollback(this.rendererPtr, this.getSplitPinnedRenderOffset());
   }
-  set useKittyKeyboard(use) {
-    const flags = use ? KITTY_FLAG_DISAMBIGUATE | KITTY_FLAG_ALTERNATE_KEYS : 0;
-    this.lib.setKittyKeyboardFlags(this.rendererPtr, flags);
+  clearPendingSplitFooterTransition() {
+    if (this.pendingSplitFooterTransition === null) {
+      return;
+    }
+    this.pendingSplitFooterTransition = null;
+    this.lib.clearPendingSplitFooterTransition(this.rendererPtr);
   }
-  interceptStdoutWrite = (chunk, encoding, callback) => {
-    const text = chunk.toString();
-    capture.write("stdout", text);
-    if (this._splitHeight > 0) {
-      this.requestRender();
+  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 (typeof callback === "function") {
-      process.nextTick(callback);
+    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);
     }
-    return true;
-  };
+  }
+  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 +22369,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 +22401,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 +22453,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 +22506,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,16 +22524,42 @@ 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();
+    this.ensureNativePaletteState();
   }
   stdinListener = ((chunk) => {
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -19804,14 +22594,36 @@ 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);
+    if (hasStandardCapabilitySignature) {
+      this.forceFullRepaintRequested = true;
+      this.requestRender();
+    }
+    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") {
@@ -19835,52 +22647,6 @@ Captured output:
     }
     return false;
   }).bind(this);
-  themeModeHandler = ((sequence) => {
-    if (sequence === "\x1B[?997;1n") {
-      this.applyThemeMode("dark", "csi");
-      this._themeFallbackPending = false;
-      return true;
-    }
-    if (sequence === "\x1B[?997;2n") {
-      this.applyThemeMode("light", "csi");
-      this._themeFallbackPending = false;
-      return true;
-    }
-    let handledOscThemeResponse = false;
-    let match;
-    OSC_THEME_RESPONSE.lastIndex = 0;
-    while (match = OSC_THEME_RESPONSE.exec(sequence)) {
-      handledOscThemeResponse = true;
-      const color = oscThemeColorToHex(match[2], match[3], match[4], match[5]);
-      if (match[1] === "10") {
-        this._themeOscForeground = color;
-      } else {
-        this._themeOscBackground = color;
-      }
-    }
-    if (!handledOscThemeResponse) {
-      return false;
-    }
-    if (!this._themeFallbackPending) {
-      return true;
-    }
-    if (this._themeOscForeground && this._themeOscBackground) {
-      this.applyThemeMode(inferThemeModeFromBackgroundColor(this._themeOscBackground), "osc");
-      this._themeFallbackPending = false;
-    }
-    return true;
-  }).bind(this);
-  applyThemeMode(mode, source) {
-    if (source === "osc" && this._themeModeSource === "csi") {
-      return;
-    }
-    const changed = this._themeMode !== mode;
-    this._themeMode = mode;
-    this._themeModeSource = source;
-    if (changed) {
-      this.emit("theme_mode" /* THEME_MODE */, mode);
-    }
-  }
   dispatchSequenceHandlers(sequence) {
     if (this._debugModeEnabled) {
       this._debugInputs.push({
@@ -19925,6 +22691,9 @@ Captured output:
             subscriber(event.sequence);
           }
         }
+        if (event.protocol === "cpr" && this.processCapabilitySequence(event.sequence, true)) {
+          return;
+        }
         this.dispatchSequenceHandlers(event.sequence);
         return;
     }
@@ -20211,28 +22980,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 +23166,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,10 +23176,12 @@ Captured output:
     this.updateStdinParserProtocolContext({
       privateCapabilityRepliesActive: false,
       pixelResolutionQueryActive: false,
-      explicitWidthCprActive: false
+      explicitWidthCprActive: false,
+      startupCursorCprActive: false
     });
     this.stdinParser?.reset();
     this.stdin.removeListener("data", this.stdinListener);
+    this.themeModeState.cancelRefresh();
     this.lib.suspendRenderer(this.rendererPtr);
     if (this.stdin.setRawMode) {
       this.stdin.setRawMode(false);
@@ -20406,6 +23197,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 +23261,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 +23270,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;
@@ -20485,12 +23282,14 @@ Captured output:
       this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
+    this.themeModeState.cancelRefresh();
     this._isRunning = false;
     this.waitingForPixelResolution = false;
     this.updateStdinParserProtocolContext({
       privateCapabilityRepliesActive: false,
       pixelResolutionQueryActive: false,
-      explicitWidthCprActive: false
+      explicitWidthCprActive: false,
+      startupCursorCprActive: false
     }, true);
     this._useMouse = false;
     this.setCapturedRenderable(undefined);
@@ -20517,8 +23316,14 @@ Captured output:
       this._paletteDetector.cleanup();
       this._paletteDetector = null;
     }
+    this._paletteCache.clear();
     this._paletteDetectionPromise = null;
+    this._paletteDetectionSize = 0;
     this._cachedPalette = null;
+    this._publishedPaletteSignature = null;
+    this._paletteEpoch = 0;
+    this._palettePublishGeneration = 0;
+    this.themeModeState.dispose();
     this.emit("destroy" /* DESTROY */);
     try {
       this.root.destroyRecursively();
@@ -20529,6 +23334,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 +23452,22 @@ 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 {
+      const force = this.forceFullRepaintRequested;
+      this.forceFullRepaintRequested = false;
+      this.pendingSplitFooterTransition = null;
+      this.lib.render(this.rendererPtr, force);
+    }
     this.renderingNative = false;
   }
   collectStatSample(frameTime) {
@@ -20786,13 +23611,63 @@ Captured output:
     }
   }
   get paletteDetectionStatus() {
-    if (this._cachedPalette)
-      return "cached";
     if (this._paletteDetectionPromise)
       return "detecting";
+    if (this._paletteCache.size > 0)
+      return "cached";
     return "idle";
   }
+  getCachedPaletteBySize(size) {
+    const exactMatch = this._paletteCache.get(size);
+    if (exactMatch) {
+      return exactMatch;
+    }
+    const largerSize = [...this._paletteCache.keys()].sort((a, b) => a - b).find((candidate) => candidate >= size);
+    if (largerSize === undefined) {
+      return null;
+    }
+    const source = this._paletteCache.get(largerSize);
+    if (!source) {
+      return null;
+    }
+    const projected = {
+      ...source,
+      palette: source.palette.slice(0, size)
+    };
+    this._paletteCache.set(size, projected);
+    return projected;
+  }
+  ensurePaletteDetector() {
+    if (!this._paletteDetector) {
+      const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
+      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
+        subscribeOsc: this.subscribeOsc.bind(this)
+      }, this.clock);
+    }
+    return this._paletteDetector;
+  }
+  syncNativePaletteState(colors) {
+    const signature = buildTerminalPaletteSignature(colors);
+    if (this._publishedPaletteSignature !== null && this._publishedPaletteSignature !== signature) {
+      this._paletteEpoch = this._paletteEpoch + 1 >>> 0;
+    }
+    this._publishedPaletteSignature = signature;
+    const normalized = normalizeTerminalPalette(colors);
+    this.lib.rendererSetPaletteState(this.rendererPtr, normalized.palette, normalized.defaultForeground, normalized.defaultBackground, this._paletteEpoch);
+  }
+  ensureNativePaletteState() {
+    if (!this._terminalIsSetup || this._isDestroyed)
+      return;
+    const publishGeneration = this._palettePublishGeneration;
+    this.getPalette({ size: 256 }).then((colors) => {
+      if (this._palettePublishGeneration === publishGeneration) {
+        this.syncNativePaletteState(colors);
+      }
+      this.requestRender();
+    }).catch(() => {});
+  }
   clearPaletteCache() {
+    this._paletteCache.clear();
     this._cachedPalette = null;
   }
   async getPalette(options) {
@@ -20800,31 +23675,65 @@ Captured output:
       throw new Error("Cannot detect palette while renderer is suspended");
     }
     const requestedSize = options?.size ?? 16;
-    if (this._cachedPalette && this._cachedPalette.palette.length !== requestedSize) {
-      this._cachedPalette = null;
-    }
-    if (this._cachedPalette) {
-      return this._cachedPalette;
+    const detectionTimeout = options?.timeout;
+    const cachedPalette = this.getCachedPaletteBySize(requestedSize);
+    if (cachedPalette) {
+      this._cachedPalette = cachedPalette;
+      return cachedPalette;
     }
     if (this._paletteDetectionPromise) {
-      return this._paletteDetectionPromise;
-    }
-    if (!this._paletteDetector) {
-      const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
-      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
-        subscribeOsc: this.subscribeOsc.bind(this)
-      }, this.clock);
+      if (this._paletteDetectionSize >= requestedSize) {
+        return this._paletteDetectionPromise.then((palette) => {
+          const cached = this.getCachedPaletteBySize(requestedSize);
+          if (cached) {
+            this._cachedPalette = cached;
+            return cached;
+          }
+          const projected = {
+            ...palette,
+            palette: palette.palette.slice(0, requestedSize)
+          };
+          this._paletteCache.set(requestedSize, projected);
+          this._cachedPalette = projected;
+          return projected;
+        });
+      }
+      await this._paletteDetectionPromise;
+      const afterWait = this.getCachedPaletteBySize(requestedSize);
+      if (afterWait) {
+        this._cachedPalette = afterWait;
+        return afterWait;
+      }
     }
-    this._paletteDetectionPromise = this._paletteDetector.detect(options).then((result) => {
+    const detector = this.ensurePaletteDetector();
+    const publishGeneration = this._palettePublishGeneration;
+    this._paletteDetectionSize = requestedSize;
+    this._paletteDetectionPromise = detector.detect({ ...options, timeout: detectionTimeout }).then((result) => {
+      this._paletteCache.set(result.palette.length, result);
       this._cachedPalette = result;
       this._paletteDetectionPromise = null;
+      this._paletteDetectionSize = 0;
+      if (this._palettePublishGeneration === publishGeneration) {
+        if (result.palette.length >= 256) {
+          this.syncNativePaletteState(result);
+        } else if (this._terminalIsSetup && !this._paletteCache.has(256)) {
+          this.ensureNativePaletteState();
+        }
+      }
       return result;
+    }).catch((error) => {
+      this._paletteDetectionPromise = null;
+      this._paletteDetectionSize = 0;
+      throw error;
     });
-    return this._paletteDetectionPromise;
+    const detected = await this._paletteDetectionPromise;
+    const finalPalette = this.getCachedPaletteBySize(requestedSize) ?? detected;
+    this._cachedPalette = finalPalette;
+    return finalPalette;
   }
 }
 
-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, COLOR_TAG_RGB, COLOR_TAG_DEFAULT, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, decodeColorTag, RGBA, normalizeColorValue, 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, normalizeTerminalPalette, buildTerminalPaletteSignature, 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=B1BCF94D9F983F0164756E2164756E21
+//# sourceMappingURL=index-4pvh4sbk.js.map