@opentui/core 0.1.92 → 0.1.94

package/{index-j5fb4966.js → index-t7fkn9sh.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   exports_src
-} from "./index-jdn8a604.js";
+} from "./index-t2rqapaa.js";
 import {
   __require
-} from "./index-mdxq0qtt.js";
+} from "./index-wv534m5j.js";
 
 // src/runtime-plugin.ts
 var CORE_RUNTIME_SPECIFIER = "@opentui/core";
@@ -185,4 +185,4 @@ function createRuntimePlugin(input = {}) {
 export { isCoreRuntimeModuleSpecifier, runtimeModuleIdForSpecifier, createRuntimePlugin };
 
 //# debugId=320B34A5E2C7118F64756E2164756E21
-//# sourceMappingURL=index-j5fb4966.js.map
+//# sourceMappingURL=index-t7fkn9sh.js.map

package/{index-mdxq0qtt.js → index-wv534m5j.js}

@@ -6843,7 +6843,7 @@ var env = new Proxy({}, {
 
 // src/lib/stdin-parser.ts
 import { Buffer as Buffer3 } from "buffer";
-var DEFAULT_TIMEOUT_MS = 10;
+var DEFAULT_TIMEOUT_MS = 20;
 var DEFAULT_MAX_PENDING_BYTES = 64 * 1024;
 var INITIAL_PENDING_CAPACITY = 256;
 var ESC = 27;
@@ -7014,6 +7014,28 @@ function parsePositiveDecimalPrefix(sequence, start, endExclusive) {
   }
   return sawDigit ? value : null;
 }
+function parseKittyFirstFieldCodepoint(sequence, start, endExclusive) {
+  if (start >= endExclusive)
+    return null;
+  let firstColon = -1;
+  for (let index = start;index < endExclusive; index += 1) {
+    if (sequence[index] === 58) {
+      firstColon = index;
+      break;
+    }
+  }
+  if (firstColon === -1)
+    return null;
+  const codepoint = parsePositiveDecimalPrefix(sequence, start, firstColon);
+  if (codepoint === null)
+    return null;
+  for (let index = firstColon + 1;index < endExclusive; index += 1) {
+    const byte = sequence[index];
+    if (byte !== 58 && !isAsciiDigit(byte))
+      return null;
+  }
+  return codepoint;
+}
 function canStillBeKittyU(state) {
   return state.semicolons >= 1;
 }
@@ -7215,10 +7237,13 @@ class StdinParser {
   }
   flushTimeout(nowMsValue = this.clock.now()) {
     this.ensureAlive();
-    if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
+    if (this.pendingSinceMs !== null && (nowMsValue < this.pendingSinceMs || nowMsValue - this.pendingSinceMs < this.timeoutMs)) {
       return;
     }
-    if (nowMsValue < this.pendingSinceMs || nowMsValue - this.pendingSinceMs < this.timeoutMs) {
+    this.tryForceFlush();
+  }
+  tryForceFlush() {
+    if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
       return;
     }
     this.forceFlush = true;
@@ -7480,7 +7505,12 @@ class StdinParser {
             continue;
           }
           if (byte === 59) {
-            const firstParamValue = parsePositiveDecimalPrefix(bytes, this.unitStart + 2, this.cursor);
+            const firstParamStart = this.unitStart + 2;
+            const firstParamEnd = this.cursor;
+            let firstParamValue = parsePositiveDecimalPrefix(bytes, firstParamStart, firstParamEnd);
+            if (firstParamValue === null && this.protocolContext.kittyKeyboardEnabled) {
+              firstParamValue = parseKittyFirstFieldCodepoint(bytes, firstParamStart, firstParamEnd);
+            }
             if (firstParamValue !== null) {
               this.cursor += 1;
               this.state = {
@@ -8078,7 +8108,7 @@ class StdinParser {
         return;
       }
       try {
-        this.flushTimeout(this.clock.now());
+        this.tryForceFlush();
         this.onTimeoutFlush?.();
       } catch (error) {
         console.error("stdin parser timeout flush failed", error);
@@ -14900,29 +14930,31 @@ class Renderable extends BaseRenderable {
     return this._widthValue;
   }
   set width(value) {
-    if (isDimensionType(value)) {
-      this._width = value;
-      this.yogaNode.setWidth(value);
-      if (typeof value === "number" && this._flexShrink === 1) {
-        this._flexShrink = 0;
-        this.yogaNode.setFlexShrink(0);
-      }
-      this.requestRender();
+    if (!isDimensionType(value) || this._width === value) {
+      return;
+    }
+    this._width = value;
+    this.yogaNode.setWidth(value);
+    if (typeof value === "number" && this._flexShrink === 1) {
+      this._flexShrink = 0;
+      this.yogaNode.setFlexShrink(0);
     }
+    this.requestRender();
   }
   get height() {
     return this._heightValue;
   }
   set height(value) {
-    if (isDimensionType(value)) {
-      this._height = value;
-      this.yogaNode.setHeight(value);
-      if (typeof value === "number" && this._flexShrink === 1) {
-        this._flexShrink = 0;
-        this.yogaNode.setFlexShrink(0);
-      }
-      this.requestRender();
+    if (!isDimensionType(value) || this._height === value) {
+      return;
+    }
+    this._height = value;
+    this.yogaNode.setHeight(value);
+    if (typeof value === "number" && this._flexShrink === 1) {
+      this._flexShrink = 0;
+      this.yogaNode.setFlexShrink(0);
     }
+    this.requestRender();
   }
   get zIndex() {
     return this._zIndex;
@@ -16150,7 +16182,6 @@ class TerminalConsoleCache extends EventEmitter7 {
     if (this._originalConsole) {
       global.console = this._originalConsole;
     }
-    this.setupConsoleCapture();
   }
   addLogEntry(level, ...args) {
     const callerInfo = this._collectCallerInfo ? getCallerInfo() : null;
@@ -17209,25 +17240,25 @@ function parsePixelResolution(sequence) {
 // src/renderer.ts
 registerEnvVar({
   name: "OTUI_DUMP_CAPTURES",
-  description: "Dump captured output when the renderer exits.",
+  description: "Dump captured stdout and console caches when the renderer exit handler runs.",
   type: "boolean",
   default: false
 });
 registerEnvVar({
   name: "OTUI_NO_NATIVE_RENDER",
-  description: "Disable native rendering. This will not actually output ansi and is useful for debugging.",
+  description: "Skip the Zig/native frame renderer. Useful for debugging the render loop; split-footer stdout flushing may still write ANSI.",
   type: "boolean",
   default: false
 });
 registerEnvVar({
   name: "OTUI_USE_ALTERNATE_SCREEN",
-  description: "Use the terminal alternate screen buffer.",
+  description: "When explicitly set, force screen mode selection: true=alternate-screen, false=main-screen.",
   type: "boolean",
   default: true
 });
 registerEnvVar({
   name: "OTUI_OVERRIDE_STDOUT",
-  description: "Override the stdout stream. This is useful for debugging.",
+  description: "When explicitly set, force stdout routing: false=passthrough, true=capture in split-footer mode.",
   type: "boolean",
   default: true
 });
@@ -17243,6 +17274,39 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+var DEFAULT_FOOTER_HEIGHT = 12;
+function normalizeFooterHeight(footerHeight) {
+  if (footerHeight === undefined) {
+    return DEFAULT_FOOTER_HEIGHT;
+  }
+  if (!Number.isFinite(footerHeight)) {
+    throw new Error("footerHeight must be a finite number");
+  }
+  const normalizedFooterHeight = Math.trunc(footerHeight);
+  if (normalizedFooterHeight <= 0) {
+    throw new Error("footerHeight must be greater than 0");
+  }
+  return normalizedFooterHeight;
+}
+function resolveModes(config) {
+  let screenMode = config.screenMode ?? "alternate-screen";
+  if (process.env.OTUI_USE_ALTERNATE_SCREEN !== undefined) {
+    screenMode = env.OTUI_USE_ALTERNATE_SCREEN ? "alternate-screen" : "main-screen";
+  }
+  const footerHeight = screenMode === "split-footer" ? normalizeFooterHeight(config.footerHeight) : DEFAULT_FOOTER_HEIGHT;
+  let externalOutputMode = config.externalOutputMode ?? (screenMode === "split-footer" ? "capture-stdout" : "passthrough");
+  if (process.env.OTUI_OVERRIDE_STDOUT !== undefined) {
+    externalOutputMode = env.OTUI_OVERRIDE_STDOUT && screenMode === "split-footer" ? "capture-stdout" : "passthrough";
+  }
+  if (externalOutputMode === "capture-stdout" && screenMode !== "split-footer") {
+    throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+  }
+  return {
+    screenMode,
+    footerHeight,
+    externalOutputMode
+  };
+}
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
   "TERM",
@@ -17360,9 +17424,10 @@ async function createCliRenderer(config = {}) {
   }
   const stdin = config.stdin || process.stdin;
   const stdout = config.stdout || process.stdout;
+  const { screenMode, footerHeight } = resolveModes(config);
   const width = stdout.columns || 80;
   const height = stdout.rows || 24;
-  const renderHeight = config.experimental_splitHeight && config.experimental_splitHeight > 0 ? config.experimental_splitHeight : height;
+  const renderHeight = screenMode === "split-footer" ? footerHeight : height;
   const ziglib = resolveRenderLib();
   const rendererPtr = ziglib.createRenderer(width, renderHeight, {
     remote: config.remote ?? false,
@@ -17421,11 +17486,12 @@ class CliRenderer extends EventEmitter8 {
   _isDestroyed = false;
   _destroyPending = false;
   _destroyFinalized = false;
+  _destroyCleanupPrepared = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
-  targetFps = 30;
-  maxFps = 60;
+  _targetFps = 30;
+  _maxFps = 60;
   automaticMemorySnapshot = false;
   memorySnapshotInterval;
   memorySnapshotTimer = null;
@@ -17452,8 +17518,8 @@ class CliRenderer extends EventEmitter8 {
   frameCount = 0;
   lastFpsTime = 0;
   currentFps = 0;
-  targetFrameTime = 1000 / this.targetFps;
-  minTargetFrameTime = 1000 / this.maxFps;
+  targetFrameTime = 1000 / this._targetFps;
+  minTargetFrameTime = 1000 / this._maxFps;
   immediateRerenderRequested = false;
   updateScheduled = false;
   liveRequestCounter = 0;
@@ -17482,7 +17548,9 @@ class CliRenderer extends EventEmitter8 {
   enableMouseMovement = false;
   _useMouse = true;
   autoFocus = true;
-  _useAlternateScreen = env.OTUI_USE_ALTERNATE_SCREEN;
+  _screenMode = "alternate-screen";
+  _footerHeight = DEFAULT_FOOTER_HEIGHT;
+  _externalOutputMode = "passthrough";
   _suspendedMouseEnabled = false;
   _previousControlState = "idle" /* IDLE */;
   capturedRenderable;
@@ -17581,13 +17649,9 @@ Captured output:
     this.width = width;
     this.height = height;
     this._useThread = config.useThread === undefined ? false : config.useThread;
-    this._splitHeight = config.experimental_splitHeight || 0;
-    if (this._splitHeight > 0) {
-      capture.on("write", this.captureCallback);
-      this.renderOffset = height - this._splitHeight;
-      this.height = this._splitHeight;
-      lib.setRenderOffset(rendererPtr, this.renderOffset);
-    }
+    const { screenMode, footerHeight, externalOutputMode } = resolveModes(config);
+    this._footerHeight = footerHeight;
+    this._screenMode = screenMode;
     this.rendererPtr = rendererPtr;
     const forwardEnvKeys = config.forwardEnvKeys ?? [...DEFAULT_FORWARDED_ENV_KEYS];
     for (const key of forwardEnvKeys) {
@@ -17612,8 +17676,6 @@ Captured output:
     this.resizeDebounceDelay = config.debounceDelay || 100;
     this.targetFps = config.targetFps || 30;
     this.maxFps = config.maxFps || 60;
-    this.targetFrameTime = 1000 / this.targetFps;
-    this.minTargetFrameTime = 1000 / this.maxFps;
     this.clock = config.clock ?? new SystemClock;
     this.memorySnapshotInterval = config.memorySnapshotInterval ?? 0;
     this.gatherStats = config.gatherStats || false;
@@ -17621,7 +17683,6 @@ Captured output:
     this.enableMouseMovement = config.enableMouseMovement ?? true;
     this._useMouse = config.useMouse ?? true;
     this.autoFocus = config.autoFocus ?? true;
-    this._useAlternateScreen = config.useAlternateScreen ?? env.OTUI_USE_ALTERNATE_SCREEN;
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
@@ -17630,9 +17691,6 @@ Captured output:
     if (this.memorySnapshotInterval > 0) {
       this.startMemorySnapshotTimer();
     }
-    if (env.OTUI_OVERRIDE_STDOUT) {
-      this.stdout.write = this.interceptStdoutWrite.bind(this);
-    }
     process.on("SIGWINCH", this.sigwinchHandler);
     process.on("warning", this.warningHandler);
     process.on("uncaughtException", this.handleError);
@@ -17652,7 +17710,7 @@ Captured output:
     this.addExitListeners();
     const stdinParserMaxBufferBytes = config.stdinParserMaxBufferBytes ?? DEFAULT_STDIN_PARSER_MAX_BUFFER_BYTES;
     this.stdinParser = new StdinParser({
-      timeoutMs: 10,
+      timeoutMs: 20,
       maxPendingBytes: stdinParserMaxBufferBytes,
       armTimeouts: true,
       onTimeoutFlush: () => {
@@ -17671,7 +17729,9 @@ Captured output:
       ...config.consoleOptions ?? {},
       clock: this.clock
     });
-    this.useConsole = config.useConsole ?? true;
+    this.consoleMode = config.consoleMode ?? "console-overlay";
+    this.applyScreenMode(screenMode, false, false);
+    this.externalOutputMode = externalOutputMode;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
     this._onDestroy = config.onDestroy;
     global.requestAnimationFrame = (callback) => {
@@ -17807,16 +17867,23 @@ Captured output:
     }
   }
   async activateFrame() {
-    await this.loop();
-    this.updateScheduled = false;
-    this.resolveIdleIfNeeded();
+    if (!this.updateScheduled) {
+      this.resolveIdleIfNeeded();
+      return;
+    }
+    try {
+      await this.loop();
+    } finally {
+      this.updateScheduled = false;
+      this.resolveIdleIfNeeded();
+    }
   }
-  get useConsole() {
-    return this._useConsole;
+  get consoleMode() {
+    return this._useConsole ? "console-overlay" : "disabled";
   }
-  set useConsole(value) {
-    this._useConsole = value;
-    if (value) {
+  set consoleMode(mode) {
+    this._useConsole = mode === "console-overlay";
+    if (this._useConsole) {
       this.console.activate();
     } else {
       this.console.deactivate();
@@ -17866,6 +17933,20 @@ Captured output:
   get useThread() {
     return this._useThread;
   }
+  get targetFps() {
+    return this._targetFps;
+  }
+  set targetFps(targetFps) {
+    this._targetFps = targetFps;
+    this.targetFrameTime = 1000 / this._targetFps;
+  }
+  get maxFps() {
+    return this._maxFps;
+  }
+  set maxFps(maxFps) {
+    this._maxFps = maxFps;
+    this.minTargetFrameTime = 1000 / this._maxFps;
+  }
   get useMouse() {
     return this._useMouse;
   }
@@ -17879,8 +17960,37 @@ Captured output:
       this.disableMouse();
     }
   }
-  get experimental_splitHeight() {
-    return this._splitHeight;
+  get screenMode() {
+    return this._screenMode;
+  }
+  set screenMode(mode) {
+    if (this.externalOutputMode === "capture-stdout" && mode !== "split-footer") {
+      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+    }
+    this.applyScreenMode(mode);
+  }
+  get footerHeight() {
+    return this._footerHeight;
+  }
+  set footerHeight(footerHeight) {
+    const normalizedFooterHeight = normalizeFooterHeight(footerHeight);
+    if (normalizedFooterHeight === this._footerHeight) {
+      return;
+    }
+    this._footerHeight = normalizedFooterHeight;
+    if (this.screenMode === "split-footer") {
+      this.applyScreenMode("split-footer");
+    }
+  }
+  get externalOutputMode() {
+    return this._externalOutputMode;
+  }
+  set externalOutputMode(mode) {
+    if (mode === "capture-stdout" && this.screenMode !== "split-footer") {
+      throw new Error('externalOutputMode "capture-stdout" requires screenMode "split-footer"');
+    }
+    this._externalOutputMode = mode;
+    this.stdout.write = mode === "capture-stdout" ? this.interceptStdoutWrite : this.realStdoutWrite;
   }
   get liveRequestCount() {
     return this.liveRequestCounter;
@@ -17904,61 +18014,75 @@ Captured output:
     const flags = use ? KITTY_FLAG_DISAMBIGUATE | KITTY_FLAG_ALTERNATE_KEYS : 0;
     this.lib.setKittyKeyboardFlags(this.rendererPtr, flags);
   }
-  set experimental_splitHeight(splitHeight) {
-    if (splitHeight < 0)
-      splitHeight = 0;
+  interceptStdoutWrite = (chunk, encoding, callback) => {
+    const text = chunk.toString();
+    capture.write("stdout", text);
+    if (this._splitHeight > 0) {
+      this.requestRender();
+    }
+    if (typeof callback === "function") {
+      process.nextTick(callback);
+    }
+    return true;
+  };
+  applyScreenMode(screenMode, emitResize = true, requestRender = true) {
+    const prevScreenMode = this._screenMode;
     const prevSplitHeight = this._splitHeight;
-    if (splitHeight > 0) {
-      this._splitHeight = splitHeight;
-      this.renderOffset = this._terminalHeight - this._splitHeight;
-      this.height = this._splitHeight;
-      if (prevSplitHeight === 0) {
-        this.useConsole = false;
-        capture.on("write", this.captureCallback);
-        const freedLines = this._terminalHeight - this._splitHeight;
+    const nextSplitHeight = screenMode === "split-footer" ? this._footerHeight : 0;
+    if (prevScreenMode === screenMode && prevSplitHeight === nextSplitHeight) {
+      return;
+    }
+    const prevUseAlternateScreen = prevScreenMode === "alternate-screen";
+    const nextUseAlternateScreen = screenMode === "alternate-screen";
+    const terminalScreenModeChanged = this._terminalIsSetup && prevUseAlternateScreen !== nextUseAlternateScreen;
+    const leavingSplitFooter = prevSplitHeight > 0 && nextSplitHeight === 0;
+    if (this._terminalIsSetup && leavingSplitFooter) {
+      this.flushStdoutCache(this._terminalHeight, true);
+    }
+    if (this._terminalIsSetup && !terminalScreenModeChanged) {
+      if (prevSplitHeight === 0 && nextSplitHeight > 0) {
+        const freedLines = this._terminalHeight - nextSplitHeight;
         const scrollDown = ANSI.scrollDown(freedLines);
         this.writeOut(scrollDown);
-      } else if (prevSplitHeight > this._splitHeight) {
-        const freedLines = prevSplitHeight - this._splitHeight;
+      } else if (prevSplitHeight > nextSplitHeight && nextSplitHeight > 0) {
+        const freedLines = prevSplitHeight - nextSplitHeight;
         const scrollDown = ANSI.scrollDown(freedLines);
         this.writeOut(scrollDown);
-      } else if (prevSplitHeight < this._splitHeight) {
-        const additionalLines = this._splitHeight - prevSplitHeight;
+      } else if (prevSplitHeight < nextSplitHeight && prevSplitHeight > 0) {
+        const additionalLines = nextSplitHeight - prevSplitHeight;
         const scrollUp = ANSI.scrollUp(additionalLines);
         this.writeOut(scrollUp);
       }
-    } else {
-      if (prevSplitHeight > 0) {
-        this.flushStdoutCache(this._terminalHeight, true);
-        capture.off("write", this.captureCallback);
-        this.useConsole = true;
-      }
-      this._splitHeight = 0;
-      this.renderOffset = 0;
-      this.height = this._terminalHeight;
     }
+    if (prevSplitHeight === 0 && nextSplitHeight > 0) {
+      capture.on("write", this.captureCallback);
+    } else if (prevSplitHeight > 0 && nextSplitHeight === 0) {
+      capture.off("write", this.captureCallback);
+    }
+    this._screenMode = screenMode;
+    this._splitHeight = nextSplitHeight;
+    this.renderOffset = nextSplitHeight > 0 ? this._terminalHeight - nextSplitHeight : 0;
     this.width = this._terminalWidth;
+    this.height = nextSplitHeight > 0 ? nextSplitHeight : this._terminalHeight;
     this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
     this.lib.resizeRenderer(this.rendererPtr, this.width, this.height);
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
+    this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this._console.resize(this.width, this.height);
     this.root.resize(this.width, this.height);
-    this.emit("resize" /* RESIZE */, this.width, this.height);
-    this.requestRender();
-  }
-  interceptStdoutWrite = (chunk, encoding, callback) => {
-    const text = chunk.toString();
-    capture.write("stdout", text);
-    if (this._splitHeight > 0) {
-      this.requestRender();
+    if (terminalScreenModeChanged) {
+      this.lib.suspendRenderer(this.rendererPtr);
+      this.lib.setupTerminal(this.rendererPtr, nextUseAlternateScreen);
+      if (this._useMouse) {
+        this.enableMouse();
+      }
     }
-    if (typeof callback === "function") {
-      process.nextTick(callback);
+    if (emitResize) {
+      this.emit("resize" /* RESIZE */, this.width, this.height);
+    }
+    if (requestRender) {
+      this.requestRender();
     }
-    return true;
-  };
-  disableStdoutInterception() {
-    this.stdout.write = this.realStdoutWrite;
   }
   flushStdoutCache(space, force = false) {
     if (capture.size === 0 && !force)
@@ -18012,7 +18136,7 @@ Captured output:
       privateCapabilityRepliesActive: true,
       explicitWidthCprActive: true
     });
-    this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
+    this.lib.setupTerminal(this.rendererPtr, this._screenMode === "alternate-screen");
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
     if (this.debugOverlay.enabled) {
       this.lib.setDebugOverlay(this.rendererPtr, true, this.debugOverlay.corner);
@@ -18585,6 +18709,7 @@ Captured output:
   internalStart() {
     if (!this._isRunning && !this._isDestroyed) {
       this._isRunning = true;
+      this.updateScheduled = false;
       if (this.memorySnapshotInterval > 0) {
         this.startMemorySnapshotTimer();
       }
@@ -18672,15 +18797,15 @@ Captured output:
     this._isDestroyed = true;
     this._destroyPending = true;
     if (this.rendering) {
+      this.prepareDestroyDuringRender();
       return;
     }
     this.finalizeDestroy();
   }
-  finalizeDestroy() {
-    if (this._destroyFinalized)
+  cleanupBeforeDestroy() {
+    if (this._destroyCleanupPrepared)
       return;
-    this._destroyFinalized = true;
-    this._destroyPending = false;
+    this._destroyCleanupPrepared = true;
     process.removeListener("SIGWINCH", this.sigwinchHandler);
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
@@ -18698,14 +18823,8 @@ Captured output:
     }
     if (this.memorySnapshotTimer) {
       this.clock.clearInterval(this.memorySnapshotTimer);
+      this.memorySnapshotTimer = null;
     }
-    if (this._paletteDetector) {
-      this._paletteDetector.cleanup();
-      this._paletteDetector = null;
-    }
-    this._paletteDetectionPromise = null;
-    this._cachedPalette = null;
-    this.emit("destroy" /* DESTROY */);
     if (this.renderTimeout) {
       this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
@@ -18718,23 +18837,41 @@ Captured output:
       explicitWidthCprActive: false
     }, true);
     this.setCapturedRenderable(undefined);
+    this.stdin.removeListener("data", this.stdinListener);
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.externalOutputMode = "passthrough";
+    if (this._splitHeight > 0) {
+      this.flushStdoutCache(this._splitHeight, true);
+    }
+  }
+  prepareDestroyDuringRender() {
+    this.cleanupBeforeDestroy();
+    this.lib.suspendRenderer(this.rendererPtr);
+  }
+  finalizeDestroy() {
+    if (this._destroyFinalized)
+      return;
+    this._destroyFinalized = true;
+    this._destroyPending = false;
+    this.cleanupBeforeDestroy();
+    if (this._paletteDetector) {
+      this._paletteDetector.cleanup();
+      this._paletteDetector = null;
+    }
+    this._paletteDetectionPromise = null;
+    this._cachedPalette = null;
+    this.emit("destroy" /* DESTROY */);
     try {
       this.root.destroyRecursively();
     } catch (e) {
       console.error("Error destroying root renderable:", e instanceof Error ? e.stack : String(e));
     }
-    this.stdin.removeListener("data", this.stdinListener);
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(false);
-    }
     this.stdinParser?.destroy();
     this.stdinParser = null;
     this.oscSubscribers.clear();
     this._console.destroy();
-    this.disableStdoutInterception();
-    if (this._splitHeight > 0) {
-      this.flushStdoutCache(this._splitHeight, true);
-    }
     this.lib.destroyRenderer(this.rendererPtr);
     rendererTracker.removeRenderer(this);
     if (this._onDestroy) {
@@ -19031,5 +19168,5 @@ Captured output:
 
 export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=FADF3B6ED313220564756E2164756E21
-//# sourceMappingURL=index-mdxq0qtt.js.map
+//# debugId=AAC1AF32CFE7F73F64756E2164756E21
+//# sourceMappingURL=index-wv534m5j.js.map