@opentui/core 0.2.16 → 0.3.1

package/{index-qfwqv8y3.js → index-jx0p1c2f.js}

@@ -12352,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"],
@@ -12370,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*"],
@@ -12598,7 +12600,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     createRenderer: {
-      args: ["u32", "u32", "bool", "bool"],
+      args: ["u32", "u32", "u8", "u8", "ptr"],
       returns: "ptr"
     },
     setTerminalEnvVar: {
@@ -12659,15 +12661,15 @@ function getOpenTUILib(libPath) {
     },
     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"],
@@ -12929,7 +12931,7 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i64"],
       returns: "void"
     },
-    dumpStdoutBuffer: {
+    dumpOutputBuffer: {
       args: ["ptr", "i64"],
       returns: "void"
     },
@@ -13970,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);
@@ -14217,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)) {
@@ -14300,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);
@@ -15058,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 ?? "",
@@ -19186,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";
@@ -21226,6 +21523,10 @@ var ANSI = {
   switchToAlternateScreen: "\x1B[?1049h",
   switchToMainScreen: "\x1B[?1049l",
   reset: "\x1B[0m",
+  resetScrollRegion: "\x1B[r",
+  home: "\x1B[H",
+  clearScreen: "\x1B[2J",
+  clearSavedLines: "\x1B[3J",
   scrollDown: (lines) => `\x1B[${lines}T`,
   scrollUp: (lines) => `\x1B[${lines}S`,
   moveCursor: (row, col) => `\x1B[${row};${col}H`,
@@ -21661,8 +21962,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) {
@@ -21678,11 +21980,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;
@@ -21752,6 +22056,9 @@ class ScrollbackSnapshotRenderContext extends EventEmitter9 {
 }
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
+  "ZELLIJ",
+  "ZELLIJ_SESSION_NAME",
+  "ZELLIJ_PANE_ID",
   "TERM",
   "OPENTUI_GRAPHICS",
   "TERM_PROGRAM",
@@ -21766,11 +22073,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;
@@ -21845,57 +22156,30 @@ 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) => {
@@ -21937,6 +22221,7 @@ class CliRenderer extends EventEmitter9 {
   _destroyPending = false;
   _destroyFinalized = false;
   _destroyCleanupPrepared = false;
+  _streamLeaseAcquired = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -22116,22 +22401,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;
@@ -22140,7 +22482,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)
@@ -22193,12 +22535,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) => {
@@ -22234,6 +22577,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;
@@ -22256,9 +22603,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)
@@ -22363,7 +22720,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") {
@@ -22373,6 +22730,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;
@@ -22423,7 +22804,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())
@@ -22960,6 +23343,26 @@ Captured external output:
       }
     }
   }
+  resetSplitFooterForReplay(options = {}) {
+    if (this._isDestroyed)
+      return;
+    if (this._screenMode !== "split-footer" || this._externalOutputMode !== "capture-stdout") {
+      throw new Error('resetSplitFooterForReplay requires screenMode "split-footer" and externalOutputMode "capture-stdout"');
+    }
+    if (!this._terminalIsSetup || this._controlState === "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
+      throw new Error("resetSplitFooterForReplay requires an active terminal");
+    }
+    this.flushPendingSplitOutputBeforeTransition(true);
+    this.externalOutputQueue.clear();
+    this.abortSplitStartupCursorSeed();
+    this.clearPendingSplitFooterTransition();
+    this.resetSplitScrollback();
+    this.currentRenderBuffer.clear(this.backgroundColor);
+    this.nextRenderBuffer.clear(this.backgroundColor);
+    this.forceFullRepaintRequested = true;
+    this.writeOut(ANSI.resetScrollRegion + ANSI.reset + ANSI.home + ANSI.clearScreen + (options.clearSavedLines ? ANSI.clearSavedLines : "") + ANSI.home);
+    this.requestRender();
+  }
   getSnapshotWidth(value, fallback) {
     const rawValue = value ?? fallback;
     if (!Number.isFinite(rawValue)) {
@@ -23134,23 +23537,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) {
@@ -23158,6 +23581,7 @@ Captured external output:
     } else {
       this.applyPendingExternalOutputModeIfReady();
     }
+    return "rendered";
   }
   interceptStdoutWrite = (chunk, encoding, callback) => {
     const resolvedCallback = typeof encoding === "function" ? encoding : callback;
@@ -23188,8 +23612,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;
@@ -23208,7 +23632,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) {
@@ -23503,6 +23927,7 @@ Captured external output:
     if (this.shouldSyncNativePaletteState()) {
       this.refreshPalette();
     }
+    await this._feed?.idle();
   }
   stdinListener = ((chunk) => {
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -23971,6 +24396,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);
@@ -24004,7 +24434,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);
@@ -24021,8 +24451,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();
@@ -24110,6 +24540,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();
@@ -24218,7 +24649,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);
@@ -24254,7 +24687,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) {
@@ -24304,8 +24749,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();
@@ -24373,30 +24853,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.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(() => {
+        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;
         }
       }
@@ -24418,22 +24917,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);
@@ -24610,7 +25119,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,
@@ -24689,7 +25198,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) {
@@ -24744,7 +25253,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=E84D4FE4C755B03764756E2164756E21
-//# sourceMappingURL=index-qfwqv8y3.js.map
+//# debugId=98141239160B854E64756E2164756E21
+//# sourceMappingURL=index-jx0p1c2f.js.map