@opentui/core 0.2.15 → 0.3.0

package/{index-3fq5hq97.js → index-081xws23.js}

@@ -5844,6 +5844,24 @@ var keyName = {
   OE: "clear",
   OF: "end",
   OH: "home",
+  OM: "return",
+  Oj: "*",
+  Ok: "+",
+  Ol: ",",
+  Om: "-",
+  On: ".",
+  Oo: "/",
+  Op: "0",
+  Oq: "1",
+  Or: "2",
+  Os: "3",
+  Ot: "4",
+  Ou: "5",
+  Ov: "6",
+  Ow: "7",
+  Ox: "8",
+  Oy: "9",
+  OX: "=",
   "[1~": "home",
   "[2~": "insert",
   "[3~": "delete",
@@ -5904,6 +5922,25 @@ var getCtrlKeyName = (charCode) => {
   }
   return;
 };
+var ss3NumpadPrintable = {
+  Op: "0",
+  Oq: "1",
+  Or: "2",
+  Os: "3",
+  Ot: "4",
+  Ou: "5",
+  Ov: "6",
+  Ow: "7",
+  Ox: "8",
+  Oy: "9",
+  Oj: "*",
+  Ok: "+",
+  Ol: ",",
+  Om: "-",
+  On: ".",
+  Oo: "/",
+  OX: "="
+};
 var modifyOtherKeysRe = /^\x1b\[27;(\d+);(\d+)~$/;
 var parseKeypress = (s = "", options = {}) => {
   let parts;
@@ -6076,6 +6113,13 @@ var parseKeypress = (s = "", options = {}) => {
       key.name = keyNameResult;
       key.shift = isShiftKey(code) || key.shift;
       key.ctrl = isCtrlKey(code) || key.ctrl;
+      const ss3Char = ss3NumpadPrintable[code];
+      if (ss3Char !== undefined) {
+        key.sequence = ss3Char;
+        if (key.name >= "0" && key.name <= "9") {
+          key.number = true;
+        }
+      }
     } else {
       key.name = "";
       key.code = undefined;
@@ -7238,6 +7282,12 @@ function concatBytes(left, right) {
   combined.set(right, left.length);
   return combined;
 }
+function withEscPrefix(bytes) {
+  const prefixed = new Uint8Array(bytes.length + 1);
+  prefixed[0] = ESC;
+  prefixed.set(bytes, 1);
+  return prefixed;
+}
 function indexOfBytes(haystack, needle) {
   if (needle.length === 0) {
     return 0;
@@ -8194,7 +8244,13 @@ class StdinParser {
           }
           if (byte === 77 || byte === 109) {
             const end = this.cursor + 1;
-            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, end));
+            const rawBytes = bytes.subarray(this.unitStart, end);
+            const prefixed = withEscPrefix(rawBytes);
+            if (isMouseSgrSequence(prefixed)) {
+              this.emitMouse(prefixed, "sgr");
+            } else {
+              this.emitOpaqueResponse("unknown", rawBytes);
+            }
             this.state = { tag: "ground" };
             this.consumePrefix(end);
             continue;
@@ -8216,7 +8272,8 @@ class StdinParser {
             this.consumePrefix(bytes.length);
             continue;
           }
-          this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, end));
+          const rawBytes = bytes.subarray(this.unitStart, end);
+          this.emitMouse(withEscPrefix(rawBytes), "x10");
           this.state = { tag: "ground" };
           this.consumePrefix(end);
           continue;
@@ -10012,16 +10069,20 @@ class ExtmarksController {
       if (virtualExtmark && currentOffset === virtualExtmark.end) {
         const startCursor = this.offsetToPosition(virtualExtmark.start);
         const endCursor = this.offsetToPosition(virtualExtmark.end);
-        const deleteOffset = virtualExtmark.start;
-        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        const deleteOffset2 = virtualExtmark.start;
+        const deleteLength2 = virtualExtmark.end - virtualExtmark.start;
         this.deleteExtmarkById(virtualExtmark.id);
         this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
-        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.adjustExtmarksAfterDeletion(deleteOffset2, deleteLength2);
         this.updateHighlights();
         return;
       }
       this.originalDeleteCharBackward();
-      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+      const deleteOffset = this.editorView.getVisualCursor().offset;
+      const deleteLength = currentOffset - deleteOffset;
+      if (deleteLength > 0) {
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+      }
     };
     this.editBuffer.deleteChar = () => {
       if (this.destroyed) {
@@ -10030,12 +10091,7 @@ class ExtmarksController {
       }
       this.saveSnapshot();
       const currentOffset = this.editorView.getVisualCursor().offset;
-      const textLength = this.editBuffer.getText().length;
       const hadSelection = this.editorView.hasSelection();
-      if (currentOffset >= textLength) {
-        this.originalDeleteChar();
-        return;
-      }
       if (hadSelection) {
         this.originalDeleteChar();
         return;
@@ -10046,15 +10102,19 @@ class ExtmarksController {
         const startCursor = this.offsetToPosition(virtualExtmark.start);
         const endCursor = this.offsetToPosition(virtualExtmark.end);
         const deleteOffset = virtualExtmark.start;
-        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        const deleteLength2 = virtualExtmark.end - virtualExtmark.start;
         this.deleteExtmarkById(virtualExtmark.id);
         this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
-        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength2);
         this.updateHighlights();
         return;
       }
+      const deleteEndOffset = this.getNextCursorOffset(currentOffset);
+      const deleteLength = deleteEndOffset - currentOffset;
       this.originalDeleteChar();
-      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+      if (deleteLength > 0) {
+        this.adjustExtmarksAfterDeletion(currentOffset, deleteLength);
+      }
     };
     this.editBuffer.deleteRange = (startLine, startCol, endLine, endCol) => {
       if (this.destroyed) {
@@ -10106,7 +10166,10 @@ class ExtmarksController {
       this.saveSnapshot();
       const currentOffset = this.editorView.getVisualCursor().offset;
       this.originalInsertText(text);
-      this.adjustExtmarksAfterInsertion(currentOffset, text.length);
+      const insertLength = this.editorView.getVisualCursor().offset - currentOffset;
+      if (insertLength > 0) {
+        this.adjustExtmarksAfterInsertion(currentOffset, insertLength);
+      }
     };
     this.editBuffer.insertChar = (char) => {
       if (this.destroyed) {
@@ -10116,7 +10179,10 @@ class ExtmarksController {
       this.saveSnapshot();
       const currentOffset = this.editorView.getVisualCursor().offset;
       this.originalInsertChar(char);
-      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+      const insertLength = this.editorView.getVisualCursor().offset - currentOffset;
+      if (insertLength > 0) {
+        this.adjustExtmarksAfterInsertion(currentOffset, insertLength);
+      }
     };
     this.editBuffer.setText = (text) => {
       if (this.destroyed) {
@@ -10245,6 +10311,12 @@ class ExtmarksController {
   positionToOffset(row, col) {
     return this.editBuffer.positionToOffset(row, col);
   }
+  getNextCursorOffset(currentOffset) {
+    this.originalMoveCursorRight();
+    const nextOffset = this.editorView.getVisualCursor().offset;
+    this.originalSetCursorByOffset(currentOffset);
+    return nextOffset;
+  }
   updateHighlights() {
     this.editBuffer.clearAllHighlights();
     for (const extmark of this.extmarks.values()) {
@@ -12280,6 +12352,7 @@ var VisualCursorStruct = defineStruct([
   ["offset", "u32"]
 ]);
 var UnicodeMethodEnum = defineEnum({ wcwidth: 0, unicode: 1 }, "u8");
+var TerminalMultiplexerEnum = defineEnum({ none: 0, tmux: 1, zellij: 2, screen: 3, unknown: 4 }, "u8");
 var TerminalCapabilitiesStruct = defineStruct([
   ["kitty_keyboard", "bool_u8"],
   ["kitty_graphics", "bool_u8"],
@@ -12298,7 +12371,8 @@ var TerminalCapabilitiesStruct = defineStruct([
   ["osc52", "bool_u8"],
   ["notifications", "bool_u8"],
   ["explicit_cursor_positioning", "bool_u8"],
-  ["in_tmux", "bool_u8"],
+  ["remote", "bool_u8"],
+  ["multiplexer", TerminalMultiplexerEnum],
   ["term_name", "char*"],
   ["term_name_len", "u64", { lengthOf: "term_name" }],
   ["term_version", "char*"],
@@ -12364,6 +12438,17 @@ var AllocatorStatsStruct = defineStruct([
   ["largeAllocations", "u64"],
   ["requestedBytesValid", "bool_u8"]
 ]);
+var NativeRenderStatsStruct = defineStruct([
+  ["lastFrameTime", "f64"],
+  ["averageFrameTime", "f64"],
+  ["renderTime", "f64"],
+  ["stdoutWriteTime", "f64"],
+  ["frameCount", "u64"],
+  ["cellsUpdated", "u32"],
+  ["averageCellsUpdated", "u32"],
+  ["renderTimeValid", "bool_u8"],
+  ["stdoutWriteTimeValid", "bool_u8"]
+]);
 var GrowthPolicyEnum = defineEnum({ grow: 0, block: 1 }, "u8");
 var NativeSpanFeedOptionsStruct = defineStruct([
   ["chunkSize", "u32", { default: 64 * 1024 }],
@@ -12515,7 +12600,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     createRenderer: {
-      args: ["u32", "u32", "bool", "bool"],
+      args: ["u32", "u32", "u8", "u8", "ptr"],
       returns: "ptr"
     },
     setTerminalEnvVar: {
@@ -12570,17 +12655,21 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u32", "u32", "u32"],
       returns: "void"
     },
+    getRenderStats: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     render: {
       args: ["ptr", "bool"],
-      returns: "void"
+      returns: "u8"
     },
     repaintSplitFooter: {
       args: ["ptr", "u32", "bool"],
-      returns: "u32"
+      returns: "u64"
     },
     commitSplitFooterSnapshot: {
       args: ["ptr", "ptr", "u32", "bool", "bool", "u32", "bool", "bool", "bool"],
-      returns: "u32"
+      returns: "u64"
     },
     getNextBuffer: {
       args: ["ptr"],
@@ -12842,7 +12931,7 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i64"],
       returns: "void"
     },
-    dumpStdoutBuffer: {
+    dumpOutputBuffer: {
       args: ["ptr", "i64"],
       returns: "void"
     },
@@ -13883,9 +13972,10 @@ class FFIRenderLib {
     return callback;
   }
   createRenderer(width, height, options = {}) {
-    const testing = options.testing ?? false;
-    const remote = options.remote ?? false;
-    return this.opentui.symbols.createRenderer(width, height, ffiBool(testing), ffiBool(remote));
+    const bufferedOutputKind = options.bufferedOutput === "memory" ? 1 : 0;
+    const remoteMode = options.remote === undefined ? 0 : options.remote ? 2 : 1;
+    const feedPtr = options.feedPtr ?? null;
+    return this.opentui.symbols.createRenderer(width, height, bufferedOutputKind, remoteMode, feedPtr);
   }
   setTerminalEnvVar(renderer, key, value) {
     const keyBytes = this.encoder.encode(key);
@@ -13928,6 +14018,20 @@ class FFIRenderLib {
   updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers) {
     this.opentui.symbols.updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers);
   }
+  getRenderStats(renderer) {
+    const statsBuffer = new ArrayBuffer(NativeRenderStatsStruct.size);
+    this.opentui.symbols.getRenderStats(renderer, ptr(statsBuffer));
+    const stats = NativeRenderStatsStruct.unpack(statsBuffer);
+    return {
+      nativeLastFrameTime: stats.lastFrameTime,
+      nativeAverageFrameTime: stats.averageFrameTime,
+      nativeFrameCount: toNumber(stats.frameCount),
+      cellsUpdated: stats.cellsUpdated,
+      averageCellsUpdated: stats.averageCellsUpdated,
+      nativeRenderTime: stats.renderTimeValid ? stats.renderTime : undefined,
+      nativeStdoutWriteTime: stats.stdoutWriteTimeValid ? stats.stdoutWriteTime : undefined
+    };
+  }
   getNextBuffer(renderer) {
     const bufferPtr = this.opentui.symbols.getNextBuffer(renderer);
     if (!bufferPtr) {
@@ -14116,13 +14220,20 @@ class FFIRenderLib {
     this.opentui.symbols.setCursorStyleOptions(renderer, ptr(buffer));
   }
   render(renderer, force) {
-    this.opentui.symbols.render(renderer, ffiBool(force));
+    return this.opentui.symbols.render(renderer, ffiBool(force));
+  }
+  unpackRenderOperationResult(value) {
+    const packed = typeof value === "bigint" ? value : BigInt(value);
+    return {
+      renderOffset: Number(packed & 0xffffffffn),
+      status: Number(packed >> 32n & 0xffn)
+    };
   }
   repaintSplitFooter(renderer, pinnedRenderOffset, force) {
-    return this.opentui.symbols.repaintSplitFooter(renderer, pinnedRenderOffset, ffiBool(force));
+    return this.unpackRenderOperationResult(this.opentui.symbols.repaintSplitFooter(renderer, pinnedRenderOffset, ffiBool(force)));
   }
   commitSplitFooterSnapshot(renderer, snapshot, rowColumns, startOnNewLine, trailingNewline, pinnedRenderOffset, force, beginFrame = true, finalizeFrame = true) {
-    return this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, ffiBool(startOnNewLine), ffiBool(trailingNewline), pinnedRenderOffset, ffiBool(force), ffiBool(beginFrame), ffiBool(finalizeFrame));
+    return this.unpackRenderOperationResult(this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, ffiBool(startOnNewLine), ffiBool(trailingNewline), pinnedRenderOffset, ffiBool(force), ffiBool(beginFrame), ffiBool(finalizeFrame)));
   }
   createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
     if (Number.isNaN(width) || Number.isNaN(height)) {
@@ -14199,9 +14310,9 @@ class FFIRenderLib {
     const ts = timestamp ?? Date.now();
     this.opentui.symbols.dumpBuffers(renderer, ts);
   }
-  dumpStdoutBuffer(renderer, timestamp) {
+  dumpOutputBuffer(renderer, timestamp) {
     const ts = timestamp ?? Date.now();
-    this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
+    this.opentui.symbols.dumpOutputBuffer(renderer, ts);
   }
   restoreTerminalModes(renderer) {
     this.opentui.symbols.restoreTerminalModes(renderer);
@@ -14957,7 +15068,8 @@ class FFIRenderLib {
       osc52: caps.osc52,
       notifications: caps.notifications,
       explicit_cursor_positioning: caps.explicit_cursor_positioning,
-      in_tmux: caps.in_tmux,
+      remote: caps.remote,
+      multiplexer: caps.multiplexer,
       terminal: {
         name: caps.term_name ?? "",
         version: caps.term_version ?? "",
@@ -19085,6 +19197,292 @@ class TextRenderable extends TextBufferRenderable {
   }
 }
 
+// src/NativeSpanFeed.ts
+function toNumber2(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
+
+class NativeSpanFeed {
+  static create(options) {
+    const lib = resolveRenderLib();
+    const streamPtr = lib.createNativeSpanFeed(options);
+    const stream = new NativeSpanFeed(streamPtr);
+    lib.registerNativeSpanFeedStream(streamPtr, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(streamPtr);
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(streamPtr);
+      lib.destroyNativeSpanFeed(streamPtr);
+      throw new Error(`Failed to attach stream: ${status}`);
+    }
+    return stream;
+  }
+  static attach(streamPtr, _options) {
+    const lib = resolveRenderLib();
+    const stream = new NativeSpanFeed(streamPtr);
+    lib.registerNativeSpanFeedStream(streamPtr, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(streamPtr);
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(streamPtr);
+      throw new Error(`Failed to attach stream: ${status}`);
+    }
+    return stream;
+  }
+  streamPtr;
+  lib = resolveRenderLib();
+  eventHandler;
+  chunkMap = new Map;
+  chunkSizes = new Map;
+  dataHandlers = new Set;
+  errorHandlers = new Set;
+  drainBuffer = null;
+  stateBuffer = null;
+  closed = false;
+  destroyed = false;
+  draining = false;
+  pendingDataAvailable = false;
+  pendingClose = false;
+  closing = false;
+  pendingAsyncHandlers = 0;
+  inCallback = false;
+  closeQueued = false;
+  idleResolvers = [];
+  constructor(streamPtr) {
+    this.streamPtr = streamPtr;
+    this.eventHandler = (eventId, arg0, arg1) => {
+      this.handleEvent(eventId, arg0, arg1);
+    };
+    this.ensureDrainBuffer();
+  }
+  ensureDrainBuffer() {
+    if (this.drainBuffer)
+      return;
+    const capacity = 256;
+    this.drainBuffer = new Uint8Array(capacity * SpanInfoStruct.size);
+  }
+  onData(handler) {
+    this.dataHandlers.add(handler);
+    if (this.pendingDataAvailable) {
+      this.pendingDataAvailable = false;
+      this.drainAll();
+    }
+    return () => this.dataHandlers.delete(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  hasPinnedChunks() {
+    if (!this.stateBuffer)
+      return false;
+    for (const refcount of this.stateBuffer) {
+      if (refcount > 0)
+        return true;
+    }
+    return false;
+  }
+  isBackpressured() {
+    return this.pendingAsyncHandlers > 0 || this.pendingDataAvailable || this.hasPinnedChunks();
+  }
+  close() {
+    if (this.destroyed)
+      return;
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0) {
+      this.pendingClose = true;
+      if (!this.closeQueued) {
+        this.closeQueued = true;
+        queueMicrotask(() => {
+          this.closeQueued = false;
+          this.processPendingClose();
+        });
+      }
+      return;
+    }
+    this.performClose();
+  }
+  processPendingClose() {
+    if (!this.pendingClose || this.destroyed)
+      return;
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0)
+      return;
+    this.pendingClose = false;
+    this.performClose();
+    this.resolveIdleIfNeeded();
+  }
+  performClose() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    if (!this.closed) {
+      const status = this.lib.streamClose(this.streamPtr);
+      if (status !== 0) {
+        this.closing = false;
+        return;
+      }
+      this.closed = true;
+    }
+    this.finalizeDestroy();
+  }
+  finalizeDestroy() {
+    if (this.destroyed)
+      return;
+    this.lib.unregisterNativeSpanFeedStream(this.streamPtr);
+    this.lib.destroyNativeSpanFeed(this.streamPtr);
+    this.destroyed = true;
+    this.chunkMap.clear();
+    this.chunkSizes.clear();
+    this.stateBuffer = null;
+    this.drainBuffer = null;
+    this.dataHandlers.clear();
+    this.errorHandlers.clear();
+    this.pendingDataAvailable = false;
+    this.resolveIdleIfNeeded();
+  }
+  isIdle() {
+    return !this.inCallback && !this.draining && this.pendingAsyncHandlers === 0 && !this.pendingDataAvailable && !this.hasPinnedChunks();
+  }
+  resolveIdleIfNeeded() {
+    if (!this.isIdle())
+      return;
+    const resolvers = this.idleResolvers.splice(0);
+    for (const resolve3 of resolvers) {
+      resolve3();
+    }
+  }
+  idle() {
+    if (this.isIdle())
+      return Promise.resolve();
+    return new Promise((resolve3) => {
+      this.idleResolvers.push(resolve3);
+    });
+  }
+  handleEvent(eventId, arg0, arg1) {
+    this.inCallback = true;
+    try {
+      switch (eventId) {
+        case 8 /* StateBuffer */: {
+          const len = toNumber2(arg1);
+          if (len > 0 && arg0) {
+            const buffer = toArrayBuffer(arg0, 0, len);
+            this.stateBuffer = new Uint8Array(buffer);
+          }
+          break;
+        }
+        case 7 /* DataAvailable */: {
+          if (this.closing)
+            break;
+          if (this.dataHandlers.size === 0) {
+            this.pendingDataAvailable = true;
+            break;
+          }
+          this.drainAll();
+          break;
+        }
+        case 2 /* ChunkAdded */: {
+          const chunkLen = toNumber2(arg1);
+          if (chunkLen > 0 && arg0) {
+            if (!this.chunkMap.has(arg0)) {
+              const buffer = toArrayBuffer(arg0, 0, chunkLen);
+              this.chunkMap.set(arg0, buffer);
+            }
+            this.chunkSizes.set(arg0, chunkLen);
+          }
+          break;
+        }
+        case 6 /* Error */: {
+          const code = toNumber2(arg0);
+          for (const handler of this.errorHandlers)
+            handler(code);
+          break;
+        }
+        case 5 /* Closed */: {
+          this.closed = true;
+          break;
+        }
+        default:
+          break;
+      }
+    } finally {
+      this.inCallback = false;
+      this.resolveIdleIfNeeded();
+    }
+  }
+  decrementRefcount(chunkIndex) {
+    if (this.stateBuffer && chunkIndex < this.stateBuffer.length) {
+      const prev = this.stateBuffer[chunkIndex];
+      this.stateBuffer[chunkIndex] = prev > 0 ? prev - 1 : 0;
+    }
+  }
+  drainOnce() {
+    if (!this.drainBuffer || this.draining || this.pendingClose)
+      return 0;
+    const capacity = Math.floor(this.drainBuffer.byteLength / SpanInfoStruct.size);
+    if (capacity === 0)
+      return 0;
+    const count = this.lib.streamDrainSpans(this.streamPtr, this.drainBuffer, capacity);
+    if (count === 0)
+      return 0;
+    this.draining = true;
+    const spans = SpanInfoStruct.unpackList(this.drainBuffer.buffer, count);
+    let firstError = null;
+    try {
+      for (const span of spans) {
+        if (span.len === 0)
+          continue;
+        let buffer = this.chunkMap.get(span.chunkPtr);
+        if (!buffer) {
+          const size = this.chunkSizes.get(span.chunkPtr);
+          if (!size)
+            continue;
+          buffer = toArrayBuffer(span.chunkPtr, 0, size);
+          this.chunkMap.set(span.chunkPtr, buffer);
+        }
+        if (span.offset + span.len > buffer.byteLength)
+          continue;
+        const slice = new Uint8Array(buffer, span.offset, span.len);
+        let asyncResults = null;
+        for (const handler of this.dataHandlers) {
+          try {
+            const result = handler(slice);
+            if (result && typeof result.then === "function") {
+              asyncResults ??= [];
+              asyncResults.push(result);
+            }
+          } catch (e) {
+            firstError ??= e;
+          }
+        }
+        const shouldStopAfterThisSpan = this.pendingClose;
+        if (asyncResults) {
+          const chunkIndex = span.chunkIndex;
+          this.pendingAsyncHandlers += 1;
+          Promise.allSettled(asyncResults).then(() => {
+            this.decrementRefcount(chunkIndex);
+            this.pendingAsyncHandlers -= 1;
+            this.processPendingClose();
+            this.resolveIdleIfNeeded();
+          });
+        } else {
+          this.decrementRefcount(span.chunkIndex);
+        }
+        if (shouldStopAfterThisSpan)
+          break;
+      }
+    } finally {
+      this.draining = false;
+      this.resolveIdleIfNeeded();
+    }
+    if (firstError)
+      throw firstError;
+    return count;
+  }
+  drainAll() {
+    let count = this.drainOnce();
+    while (count > 0) {
+      count = this.drainOnce();
+    }
+  }
+}
+
 // src/console.ts
 import { EventEmitter as EventEmitter8 } from "events";
 import { Console } from "console";
@@ -21560,8 +21958,9 @@ class ExternalOutputQueue {
   writeSnapshot(commit) {
     this.commits.push(commit);
   }
-  peek() {
-    return this.commits;
+  peek(limit = Number.POSITIVE_INFINITY) {
+    const clampedLimit = Number.isFinite(limit) ? Math.max(1, Math.trunc(limit)) : this.commits.length;
+    return this.commits.slice(0, clampedLimit);
   }
   claim(limit = Number.POSITIVE_INFINITY) {
     if (this.commits.length === 0) {
@@ -21577,11 +21976,13 @@ class ExternalOutputQueue {
     this.commits = this.commits.slice(clampedLimit);
     return output;
   }
-  clear() {
-    for (const commit of this.commits) {
+  drop(count) {
+    for (const commit of this.commits.splice(0, count)) {
       commit.snapshot.destroy();
     }
-    this.commits = [];
+  }
+  clear() {
+    this.drop(this.commits.length);
   }
 }
 var CHAR_FLAG_CONTINUATION = 3221225472 >>> 0;
@@ -21651,6 +22052,9 @@ class ScrollbackSnapshotRenderContext extends EventEmitter9 {
 }
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
+  "ZELLIJ",
+  "ZELLIJ_SESSION_NAME",
+  "ZELLIJ_PANE_ID",
   "TERM",
   "OPENTUI_GRAPHICS",
   "TERM_PROGRAM",
@@ -21665,11 +22069,15 @@ var DEFAULT_FORWARDED_ENV_KEYS = [
   "OPENTUI_FORCE_UNICODE",
   "OPENTUI_FORCE_NOZWJ",
   "OPENTUI_FORCE_EXPLICIT_WIDTH",
+  "OPENTUI_NOTIFICATION_PROTOCOL",
+  "OPENTUI_NOTIFICATIONS",
   "WT_SESSION",
   "STY",
   "WSL_DISTRO_NAME",
   "WSL_INTEROP"
 ];
+var NATIVE_RENDER_STATUS_SKIPPED = 1;
+var NATIVE_RENDER_STATUS_FAILED = 2;
 var KITTY_FLAG_DISAMBIGUATE = 1;
 var KITTY_FLAG_EVENT_TYPES = 2;
 var KITTY_FLAG_ALTERNATE_KEYS = 4;
@@ -21744,61 +22152,36 @@ var MouseButton;
   MouseButton2[MouseButton2["WHEEL_UP"] = 4] = "WHEEL_UP";
   MouseButton2[MouseButton2["WHEEL_DOWN"] = 5] = "WHEEL_DOWN";
 })(MouseButton ||= {});
-var rendererTracker = singleton("RendererTracker", () => {
-  const renderers = new Set;
-  return {
-    addRenderer: (renderer) => {
-      renderers.add(renderer);
-    },
-    removeRenderer: (renderer) => {
-      renderers.delete(renderer);
-      if (renderers.size === 0) {
-        process.stdin.pause();
-        if (hasSingleton("tree-sitter-client")) {
-          getTreeSitterClient().destroy();
-          destroySingleton("tree-sitter-client");
-        }
-      }
-    }
-  };
-});
+var rendererTracker = singleton("RendererTracker", () => ({
+  renderers: new Set,
+  streamOwners: new WeakMap
+}));
 async function createCliRenderer(config = {}) {
   if (process.argv.includes("--delay-start")) {
     await new Promise((resolve3) => setTimeout(resolve3, 5000));
   }
-  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 geometry = calculateRenderGeometry(screenMode, width, height, footerHeight);
-  const ziglib = resolveRenderLib();
-  const rendererPtr = ziglib.createRenderer(geometry.renderWidth, geometry.renderHeight, {
-    remote: config.remote ?? false,
-    testing: config.testing ?? false
-  });
-  if (!rendererPtr) {
-    throw new Error("Failed to create renderer");
-  }
-  if (config.useThread === undefined) {
-    config.useThread = true;
-  }
-  if (process.platform === "linux") {
-    config.useThread = false;
-  }
-  ziglib.setUseThread(rendererPtr, config.useThread);
-  const kittyConfig = config.useKittyKeyboard ?? {};
-  const kittyFlags = buildKittyKeyboardFlags(kittyConfig);
-  ziglib.setKittyKeyboardFlags(rendererPtr, kittyFlags);
-  const renderer = new CliRenderer(ziglib, rendererPtr, stdin, stdout, width, height, config);
-  if (!config.testing) {
+  const stdin = config.stdin ?? process.stdin;
+  const stdout = config.stdout ?? process.stdout;
+  const width = stdout.columns || config.width || 80;
+  const height = stdout.rows || config.height || 24;
+  const renderer = new CliRenderer(stdin, stdout, width, height, config);
+  try {
     await renderer.setupTerminal();
+    return renderer;
+  } catch (error) {
+    try {
+      renderer.destroy();
+    } catch (destroyError) {
+      console.error("Error destroying partially-set-up renderer:", destroyError);
+    }
+    throw error;
   }
-  return renderer;
 }
 var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["RESIZE"] = "resize";
+  CliRenderEvents2["FRAME"] = "frame";
+  CliRenderEvents2["EXTERNAL_OUTPUT"] = "external_output";
   CliRenderEvents2["FOCUS"] = "focus";
   CliRenderEvents2["BLUR"] = "blur";
   CliRenderEvents2["FOCUSED_RENDERABLE"] = "focused_renderable";
@@ -21834,6 +22217,7 @@ class CliRenderer extends EventEmitter9 {
   _destroyPending = false;
   _destroyFinalized = false;
   _destroyCleanupPrepared = false;
+  _streamLeaseAcquired = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -22013,22 +22397,79 @@ Captured external output:
   warningHandler = ((warning) => {
     console.warn(JSON.stringify(warning.message, null, 2));
   }).bind(this);
+  _usesProcessStdout;
+  _feed = null;
+  _detachFeed = null;
+  _detachFeedError = null;
+  feedIdleRenderScheduled = false;
   get controlState() {
     return this._controlState;
   }
-  constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
+  constructor(stdin, stdout, width, height, config = {}) {
     super();
-    rendererTracker.addRenderer(this);
     this.stdin = stdin;
     this.stdout = stdout;
+    this._usesProcessStdout = stdout === process.stdout;
     this.realStdoutWrite = stdout.write;
-    this.lib = lib;
-    this._terminalWidth = stdout.columns ?? width;
-    this._terminalHeight = stdout.rows ?? height;
-    this._useThread = config.useThread === undefined ? false : config.useThread;
+    const lib = resolveRenderLib();
+    const useMemoryBufferedOutput = config.bufferedOutput === "memory";
+    const useFeedOutput = !this._usesProcessStdout && !useMemoryBufferedOutput;
     const { screenMode, footerHeight, externalOutputMode } = resolveModes(config);
+    const initialGeometry = calculateRenderGeometry(screenMode, width, height, footerHeight);
+    const remoteMode = config.remote ?? (useFeedOutput ? true : undefined);
+    if (rendererTracker.streamOwners.get(stdin)) {
+      throw new Error("Cannot create CliRenderer: stdin is already used by another CliRenderer");
+    }
+    if (rendererTracker.streamOwners.get(stdout)) {
+      throw new Error("Cannot create CliRenderer: stdout is already used by another CliRenderer");
+    }
+    let feed = null;
+    if (useFeedOutput) {
+      try {
+        feed = NativeSpanFeed.create();
+      } catch (error) {
+        throw new Error(`Failed to allocate NativeSpanFeed for custom stdout: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    let rendererPtr;
+    try {
+      rendererPtr = lib.createRenderer(initialGeometry.renderWidth, initialGeometry.renderHeight, {
+        remote: remoteMode,
+        feedPtr: feed?.streamPtr ?? null,
+        bufferedOutput: config.bufferedOutput
+      });
+    } catch (error) {
+      feed?.close();
+      throw error;
+    }
+    if (!rendererPtr) {
+      feed?.close();
+      throw new Error("Failed to create renderer");
+    }
+    if (config.useThread === undefined)
+      config.useThread = true;
+    if (process.platform === "linux")
+      config.useThread = false;
+    lib.setUseThread(rendererPtr, config.useThread);
+    const kittyConfig = config.useKittyKeyboard ?? {};
+    const kittyFlags = buildKittyKeyboardFlags(kittyConfig);
+    lib.setKittyKeyboardFlags(rendererPtr, kittyFlags);
+    this._feed = feed;
+    if (feed) {
+      this._detachFeed = feed.onData((bytes) => {
+        return new Promise((resolve3) => {
+          this.realStdoutWrite.call(this.stdout, bytes, () => resolve3());
+        });
+      });
+      this._detachFeedError = feed.onError((code) => {
+        console.error(`[CliRenderer] NativeSpanFeed error: code=${code}`);
+      });
+    }
+    this.lib = lib;
+    this._terminalWidth = width;
+    this._terminalHeight = height;
+    this._useThread = config.useThread;
     this._externalOutputMode = externalOutputMode;
-    const initialGeometry = calculateRenderGeometry(screenMode, this._terminalWidth, this._terminalHeight, footerHeight);
     this.width = initialGeometry.renderWidth;
     this.height = initialGeometry.renderHeight;
     this._splitHeight = initialGeometry.effectiveFooterHeight;
@@ -22037,7 +22478,7 @@ Captured external output:
     this.rendererPtr = rendererPtr;
     this.clearOnShutdown = config.clearOnShutdown ?? true;
     this.lib.setClearOnShutdown(this.rendererPtr, this.clearOnShutdown);
-    const forwardEnvKeys = config.forwardEnvKeys ?? (config.remote ? [] : [...DEFAULT_FORWARDED_ENV_KEYS]);
+    const forwardEnvKeys = config.forwardEnvKeys ?? (config.remote === false ? [...DEFAULT_FORWARDED_ENV_KEYS] : []);
     for (const key of forwardEnvKeys) {
       const value = process.env[key];
       if (value === undefined)
@@ -22090,12 +22531,13 @@ Captured external output:
     if (this.memorySnapshotInterval > 0) {
       this.startMemorySnapshotTimer();
     }
-    process.on("SIGWINCH", this.sigwinchHandler);
+    if (this._usesProcessStdout) {
+      process.on("SIGWINCH", this.sigwinchHandler);
+    }
     process.on("warning", this.warningHandler);
     process.on("uncaughtException", this.handleError);
     process.on("unhandledRejection", this.handleError);
     process.on("beforeExit", this.exitHandler);
-    const kittyConfig = config.useKittyKeyboard ?? {};
     const useKittyForParsing = kittyConfig !== null;
     this._keyHandler = new InternalKeyHandler;
     this._keyHandler.on("keypress", (event) => {
@@ -22131,6 +22573,10 @@ Captured external output:
     });
     this.consoleMode = config.consoleMode ?? "console-overlay";
     this.applyScreenMode(screenMode, false, false);
+    rendererTracker.streamOwners.set(stdin, this);
+    rendererTracker.streamOwners.set(stdout, this);
+    this._streamLeaseAcquired = true;
+    rendererTracker.renderers.add(this);
     this.stdout.write = externalOutputMode === "capture-stdout" ? this.interceptStdoutWrite : this.realStdoutWrite;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
     this._onDestroy = config.onDestroy;
@@ -22153,9 +22599,19 @@ Captured external output:
         if (this._splitHeight > 0) {
           this.flushStdoutCache(this._splitHeight);
         }
+        return "rendered";
       };
     }
-    this.setupInput();
+    try {
+      this.setupInput();
+    } catch (error) {
+      try {
+        this.destroy();
+      } catch (destroyError) {
+        console.error("Error destroying renderer after input setup failure:", destroyError);
+      }
+      throw error;
+    }
   }
   addExitListeners() {
     if (this._exitListenersAdded || this.exitSignals.length === 0)
@@ -22260,7 +22716,7 @@ Captured external output:
     return this._frameId;
   }
   writeOut(chunk, encoding, callback) {
-    if (this.rendererPtr && this._useThread) {
+    if (this.rendererPtr && (this._useThread || this._feed !== null)) {
       const data = typeof chunk === "string" ? chunk : chunk?.toString() ?? "";
       this.lib.writeOut(this.rendererPtr, data);
       if (typeof callback === "function") {
@@ -22270,6 +22726,30 @@ Captured external output:
     }
     return this.realStdoutWrite.call(this.stdout, chunk, encoding, callback);
   }
+  scheduleRenderAfterFeedIdle() {
+    const feed = this._feed;
+    if (!feed || this.feedIdleRenderScheduled || this._isDestroyed)
+      return;
+    this.feedIdleRenderScheduled = true;
+    feed.idle().then(() => {
+      this.feedIdleRenderScheduled = false;
+      if (this._isDestroyed) {
+        this.resolveIdleIfNeeded();
+        return;
+      }
+      if (this._isRunning) {
+        if (!this.renderTimeout && !this.rendering) {
+          this.renderTimeout = this.clock.setTimeout(() => {
+            this.renderTimeout = null;
+            this.loop();
+          }, 0);
+        }
+        return;
+      }
+      this.requestRender();
+      this.resolveIdleIfNeeded();
+    });
+  }
   requestRender() {
     if (this._controlState === "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
       return;
@@ -22320,7 +22800,9 @@ Captured external output:
     return this._isRunning;
   }
   isIdleNow() {
-    return !this._isRunning && !this.rendering && !this.renderTimeout && !this.updateScheduled && !this.immediateRerenderRequested;
+    if (this._isDestroyed)
+      return true;
+    return !this._isRunning && !this.rendering && !this.renderTimeout && !this.updateScheduled && !this.feedIdleRenderScheduled && !this.immediateRerenderRequested;
   }
   resolveIdleIfNeeded() {
     if (!this.isIdleNow())
@@ -22339,6 +22821,13 @@ Captured external output:
       this.idleResolvers.push(resolve3);
     });
   }
+  getSchedulerState() {
+    return {
+      isRunning: this._isRunning,
+      isRendering: this.rendering,
+      hasScheduledRender: Boolean(this.renderTimeout || this.updateScheduled || this.immediateRerenderRequested)
+    };
+  }
   get resolution() {
     return this._resolution;
   }
@@ -22941,6 +23430,9 @@ Captured external output:
   }
   enqueueSplitCommit(commit) {
     this.externalOutputQueue.writeSnapshot(commit);
+    if (this.listenerCount("external_output" /* EXTERNAL_OUTPUT */) > 0) {
+      this.emit("external_output" /* EXTERNAL_OUTPUT */, commit);
+    }
   }
   createStdoutSnapshotCommit(line, trailingNewline) {
     const snapshotContext = new ScrollbackSnapshotRenderContext(this.width, 1, this.widthMethod);
@@ -23021,23 +23513,43 @@ Captured external output:
     return commits;
   }
   flushPendingSplitCommits(forceFooterRepaint = false, drainAll = false) {
-    const commits = this.externalOutputQueue.claim(drainAll ? Number.POSITIVE_INFINITY : this.maxSplitCommitsPerFrame);
+    const commits = this.externalOutputQueue.peek(drainAll ? Number.POSITIVE_INFINITY : this.maxSplitCommitsPerFrame);
     let hasCommittedOutput = false;
     const lastCommitIndex = commits.length - 1;
+    let acceptedCommits = 0;
+    let nativeBackpressured = false;
     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);
-        this.recordSplitCommit(commit);
-        hasCommittedOutput = true;
-      } finally {
-        commit.snapshot.destroy();
+      const nativeResult = this.lib.commitSplitFooterSnapshot(this.rendererPtr, commit.snapshot, commit.rowColumns, commit.startOnNewLine, commit.trailingNewline, this.getSplitPinnedRenderOffset(), forceCommit, beginFrame, finalizeFrame);
+      if (nativeResult.status === NATIVE_RENDER_STATUS_SKIPPED) {
+        nativeBackpressured = true;
+        break;
       }
+      if (nativeResult.status === NATIVE_RENDER_STATUS_FAILED) {
+        nativeBackpressured = true;
+        break;
+      }
+      this.renderOffset = nativeResult.renderOffset;
+      this.recordSplitCommit(commit);
+      hasCommittedOutput = true;
+      acceptedCommits++;
+    }
+    if (acceptedCommits > 0) {
+      this.externalOutputQueue.drop(acceptedCommits);
+    }
+    if (nativeBackpressured) {
+      this.scheduleRenderAfterFeedIdle();
+      return "backpressured";
     }
     if (!hasCommittedOutput) {
-      this.renderOffset = this.lib.repaintSplitFooter(this.rendererPtr, this.getSplitPinnedRenderOffset(), forceFooterRepaint);
+      const nativeResult = this.lib.repaintSplitFooter(this.rendererPtr, this.getSplitPinnedRenderOffset(), forceFooterRepaint);
+      if (nativeResult.status === NATIVE_RENDER_STATUS_SKIPPED || nativeResult.status === NATIVE_RENDER_STATUS_FAILED) {
+        this.scheduleRenderAfterFeedIdle();
+        return "backpressured";
+      }
+      this.renderOffset = nativeResult.renderOffset;
     }
     this.pendingSplitFooterTransition = null;
     if (this.externalOutputQueue.size > 0) {
@@ -23045,6 +23557,7 @@ Captured external output:
     } else {
       this.applyPendingExternalOutputModeIfReady();
     }
+    return "rendered";
   }
   interceptStdoutWrite = (chunk, encoding, callback) => {
     const resolvedCallback = typeof encoding === "function" ? encoding : callback;
@@ -23075,8 +23588,8 @@ Captured external output:
   isSplitCursorSeedFrameBlocked() {
     return this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout" && this._splitHeight > 0 && this.pendingSplitStartupCursorSeed && this.splitStartupSeedTimeoutId !== null;
   }
-  canFlushSplitOutputBeforeTransition(allowSuspended = false) {
-    return this._terminalIsSetup && (allowSuspended || this._controlState !== "explicit_suspended" /* EXPLICIT_SUSPENDED */) && !this.isSplitCursorSeedFrameBlocked();
+  canFlushSplitOutputBeforeTransition(allowSuspended = false, allowUnsetup = false) {
+    return (this._terminalIsSetup || allowUnsetup) && (allowSuspended || this._controlState !== "explicit_suspended" /* EXPLICIT_SUSPENDED */) && !this.isSplitCursorSeedFrameBlocked();
   }
   clearSplitStartupCursorSeed() {
     this.pendingSplitStartupCursorSeed = false;
@@ -23095,7 +23608,7 @@ Captured external output:
     if (this._screenMode !== "split-footer" || this._splitHeight <= 0 || this._externalOutputMode !== "capture-stdout" && !(options.allowPassthrough && hasDeferredCapturedOutput)) {
       return;
     }
-    if (!this.canFlushSplitOutputBeforeTransition(options.allowSuspended ?? false)) {
+    if (!this.canFlushSplitOutputBeforeTransition(options.allowSuspended ?? false, options.allowUnsetup ?? false)) {
       return;
     }
     if (this.externalOutputQueue.size === 0 && !forceFooterRepaint) {
@@ -23390,6 +23903,7 @@ Captured external output:
     if (this.shouldSyncNativePaletteState()) {
       this.refreshPalette();
     }
+    await this._feed?.idle();
   }
   stdinListener = ((chunk) => {
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -23858,6 +24372,11 @@ Captured external output:
     this.emit("resize" /* RESIZE */, this.width, this.height);
     this.requestRender();
   }
+  resize(width, height) {
+    if (this._isDestroyed)
+      return;
+    this.processResize(width, height);
+  }
   setBackgroundColor(color) {
     const parsedColor = parseColor(color);
     this.lib.setBackgroundColor(this.rendererPtr, parsedColor);
@@ -23891,7 +24410,7 @@ Captured external output:
     this.lib.setTerminalTitle(this.rendererPtr, title);
   }
   resetTerminalBgColor() {
-    process.stdout.write("\x1B]111\x07");
+    this.writeOut("\x1B]111\x07");
   }
   copyToClipboardOSC52(text, target) {
     return this.clipboard.copyToClipboardOSC52(text, target);
@@ -23908,8 +24427,8 @@ Captured external output:
   dumpBuffers(timestamp) {
     this.lib.dumpBuffers(this.rendererPtr, timestamp);
   }
-  dumpStdoutBuffer(timestamp) {
-    this.lib.dumpStdoutBuffer(this.rendererPtr, timestamp);
+  dumpOutputBuffer(timestamp) {
+    this.lib.dumpOutputBuffer(this.rendererPtr, timestamp);
   }
   static setCursorPosition(renderer, x, y, visible = true) {
     const lib = resolveRenderLib();
@@ -23997,6 +24516,7 @@ Captured external output:
   suspend() {
     this._previousControlState = this._controlState;
     this._controlState = "explicit_suspended" /* EXPLICIT_SUSPENDED */;
+    this.updateScheduled = false;
     this.internalPause();
     if (this._terminalIsSetup) {
       this.clearSplitStartupCursorSeed();
@@ -24105,7 +24625,9 @@ Captured external output:
     if (this._destroyCleanupPrepared)
       return;
     this._destroyCleanupPrepared = true;
-    process.removeListener("SIGWINCH", this.sigwinchHandler);
+    if (this._usesProcessStdout) {
+      process.removeListener("SIGWINCH", this.sigwinchHandler);
+    }
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
     process.removeListener("warning", this.warningHandler);
@@ -24141,7 +24663,19 @@ Captured external output:
     this.setCapturedRenderable(undefined);
     this.stdin.removeListener("data", this.stdinListener);
     if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(false);
+      try {
+        this.stdin.setRawMode(false);
+      } catch (e) {
+        console.error("Error disabling raw mode during destroy:", e);
+      }
+    }
+    try {
+      this.stdin.pause();
+    } catch (e) {
+      console.error("Error pausing stdin during destroy:", e);
+    }
+    if (this._feed !== null && this._splitHeight > 0 && !this._terminalIsSetup) {
+      this.flushPendingSplitOutputBeforeTransition(false, { allowSuspended: true, allowUnsetup: true });
     }
     this.externalOutputMode = "passthrough";
     if (this._splitHeight > 0) {
@@ -24191,8 +24725,43 @@ Captured external output:
     this.pendingExternalOutputMode = null;
     this.stdout.write = this.realStdoutWrite;
     this.externalOutputQueue.clear();
-    this.lib.destroyRenderer(this.rendererPtr);
-    rendererTracker.removeRenderer(this);
+    if (this._feed) {
+      try {
+        this._feed.drainAll();
+      } catch (e) {
+        console.error("Error draining NativeSpanFeed during destroy:", e);
+      }
+    }
+    try {
+      this.lib.destroyRenderer(this.rendererPtr);
+    } catch (e) {
+      console.error("Error in lib.destroyRenderer during destroy:", e);
+    }
+    rendererTracker.renderers.delete(this);
+    if (rendererTracker.renderers.size === 0 && hasSingleton("tree-sitter-client")) {
+      getTreeSitterClient().destroy();
+      destroySingleton("tree-sitter-client");
+    }
+    if (this._feed) {
+      try {
+        this._feed.drainAll();
+      } catch (e) {
+        console.error("Error draining NativeSpanFeed shutdown frames:", e);
+      }
+      this._detachFeed?.();
+      this._detachFeed = null;
+      this._detachFeedError?.();
+      this._detachFeedError = null;
+      this._feed.close();
+      this._feed = null;
+    }
+    if (this._streamLeaseAcquired) {
+      if (rendererTracker.streamOwners.get(this.stdin) === this)
+        rendererTracker.streamOwners.delete(this.stdin);
+      if (rendererTracker.streamOwners.get(this.stdout) === this)
+        rendererTracker.streamOwners.delete(this.stdout);
+      this._streamLeaseAcquired = false;
+    }
     if (this._onDestroy) {
       try {
         this._onDestroy();
@@ -24260,25 +24829,49 @@ Captured external output:
       }
       this._console.renderToBuffer(this.nextRenderBuffer);
       if (!this._isDestroyed) {
-        this.renderNative();
-        if (this._useMouse && this.lib.getHitGridDirty(this.rendererPtr)) {
-          this.recheckHoverState();
-        }
-        const overallFrameTime = performance.now() - overallStart;
-        this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
-        if (this.gatherStats) {
-          this.collectStatSample(overallFrameTime);
-        }
-        if (this._isRunning || this.immediateRerenderRequested) {
-          const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
-          const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
-          this.immediateRerenderRequested = false;
-          this.renderTimeout = this.clock.setTimeout(() => {
+        const nativeStatus = this.renderNative() ?? "rendered";
+        if (nativeStatus === "rendered") {
+          if (this._useMouse && this.lib.getHitGridDirty(this.rendererPtr)) {
+            this.recheckHoverState();
+          }
+          const overallFrameTime = performance.now() - overallStart;
+          this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
+          if (this.listenerCount("frame" /* FRAME */) > 0) {
+            this.emit("frame" /* FRAME */, {
+              frameId: this.frameId
+            });
+          }
+          if (this.gatherStats) {
+            this.collectStatSample(overallFrameTime);
+          }
+          if (this._isRunning || this.immediateRerenderRequested) {
+            const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
+            const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
+            this.immediateRerenderRequested = false;
+            this.renderTimeout = this.clock.setTimeout(() => {
+              this.renderTimeout = null;
+              this.loop();
+            }, delay);
+          } else {
+            this.clock.clearTimeout(this.renderTimeout);
             this.renderTimeout = null;
-            this.loop();
-          }, delay);
+          }
+        } else if (nativeStatus === "skipped") {
+          const overallFrameTime = performance.now() - overallStart;
+          if (this._isRunning || this.immediateRerenderRequested) {
+            const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
+            const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
+            this.immediateRerenderRequested = false;
+            this.renderTimeout = this.clock.setTimeout(() => {
+              this.renderTimeout = null;
+              this.loop();
+            }, delay);
+          } else {
+            this.clock.clearTimeout(this.renderTimeout);
+            this.renderTimeout = null;
+          }
         } else {
-          this.clock.clearTimeout(this.renderTimeout);
+          this.immediateRerenderRequested = false;
           this.renderTimeout = null;
         }
       }
@@ -24300,22 +24893,32 @@ Captured external output:
       throw new Error("Rendering called concurrently");
     }
     this.renderingNative = true;
-    if (this.isSplitCursorSeedFrameBlocked()) {
-      this.renderingNative = false;
-      return;
-    }
-    if (this._splitHeight > 0 && this._externalOutputMode === "capture-stdout") {
-      const forceSplitRepaint = this.forceFullRepaintRequested;
-      this.forceFullRepaintRequested = false;
-      this.flushPendingSplitCommits(forceSplitRepaint, this.pendingExternalOutputMode === "passthrough");
-      this.pendingSplitFooterTransition = null;
-    } else {
+    try {
+      if (this.isSplitCursorSeedFrameBlocked()) {
+        return "skipped";
+      }
+      if (this._splitHeight > 0 && this._externalOutputMode === "capture-stdout") {
+        const forceSplitRepaint = this.forceFullRepaintRequested;
+        const status = this.flushPendingSplitCommits(forceSplitRepaint, this.pendingExternalOutputMode === "passthrough");
+        if (status === "backpressured") {
+          return "backpressured";
+        }
+        this.forceFullRepaintRequested = false;
+        this.pendingSplitFooterTransition = null;
+        return "rendered";
+      }
       const force = this.forceFullRepaintRequested;
+      const nativeStatus = this.lib.render(this.rendererPtr, force);
+      if (nativeStatus === NATIVE_RENDER_STATUS_SKIPPED || nativeStatus === NATIVE_RENDER_STATUS_FAILED) {
+        this.scheduleRenderAfterFeedIdle();
+        return "backpressured";
+      }
       this.forceFullRepaintRequested = false;
       this.pendingSplitFooterTransition = null;
-      this.lib.render(this.rendererPtr, force);
+      return "rendered";
+    } finally {
+      this.renderingNative = false;
     }
-    this.renderingNative = false;
   }
   collectStatSample(frameTime) {
     this.frameTimes.push(frameTime);
@@ -24323,19 +24926,25 @@ Captured external output:
       this.frameTimes.shift();
     }
   }
+  getNativeStats() {
+    return this.lib.getRenderStats(this.rendererPtr);
+  }
   getStats() {
+    const nativeStats = this.getNativeStats();
     const frameTimes = [...this.frameTimes];
     const sum = frameTimes.reduce((acc, time) => acc + time, 0);
     const avg = frameTimes.length ? sum / frameTimes.length : 0;
     const min = frameTimes.length ? Math.min(...frameTimes) : 0;
     const max = frameTimes.length ? Math.max(...frameTimes) : 0;
     return {
+      ...nativeStats,
       fps: this.renderStats.fps,
       frameCount: this.renderStats.frameCount,
       frameTimes,
       averageFrameTime: avg,
       minFrameTime: min,
-      maxFrameTime: max
+      maxFrameTime: max,
+      frameCallbackTime: this.renderStats.frameCallbackTime
     };
   }
   resetStats() {
@@ -24486,7 +25095,7 @@ Captured external output:
   }
   ensurePaletteDetector() {
     if (!this._paletteDetector) {
-      const isTmux = Boolean(this.capabilities?.in_tmux || this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux"));
+      const isTmux = Boolean(this.capabilities?.multiplexer === "tmux" || this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux"));
       const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
       this._paletteDetector = createTerminalPalette({
         stdin: this.stdin,
@@ -24565,7 +25174,7 @@ Captured external output:
     }
     const terminal = this._capabilities?.terminal;
     const hasTmuxVersion = terminal?.name?.toLowerCase() === "tmux" && Boolean(terminal.version);
-    if (this._capabilities?.in_tmux && !hasTmuxVersion) {
+    if (this._capabilities?.multiplexer === "tmux" && !hasTmuxVersion) {
       await this.waitForXtVersion();
       const afterCapabilityWait = this.getCachedPaletteBySize(requestedSize);
       if (afterCapabilityWait) {
@@ -24620,7 +25229,7 @@ Captured external output:
   }
 }
 
-export { __export, __require, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, 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, terminalNamedSingleStrokeKeys, 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, stringWidth2 as stringWidth, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, detectLinks, toArrayBuffer, 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 };
+export { __export, __require, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, 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, terminalNamedSingleStrokeKeys, 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, stringWidth2 as stringWidth, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, 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, NativeSpanFeed, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=4B41C39B0C423CD964756E2164756E21
-//# sourceMappingURL=index-3fq5hq97.js.map
+//# debugId=F97AFCBE61BE955464756E2164756E21
+//# sourceMappingURL=index-081xws23.js.map