@opentui/core 0.1.102 → 0.1.103

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

@@ -1969,23 +1969,126 @@ class InternalKeyHandler extends KeyHandler {
 }
 
 // src/lib/RGBA.ts
+var COLOR_TAG_RGB = 256;
+var COLOR_TAG_DEFAULT = 257;
+var DEFAULT_FOREGROUND_RGB = [255, 255, 255];
+var DEFAULT_BACKGROUND_RGB = [0, 0, 0];
+var RGBA_BUFFER_STRIDE = 5;
+var ANSI16_RGB = [
+  [0, 0, 0],
+  [128, 0, 0],
+  [0, 128, 0],
+  [128, 128, 0],
+  [0, 0, 128],
+  [128, 0, 128],
+  [0, 128, 128],
+  [192, 192, 192],
+  [128, 128, 128],
+  [255, 0, 0],
+  [0, 255, 0],
+  [255, 255, 0],
+  [0, 0, 255],
+  [255, 0, 255],
+  [0, 255, 255],
+  [255, 255, 255]
+];
+var ANSI_256_CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
+function normalizeColorTag(tag) {
+  const normalizedTag = tag != null && Number.isFinite(tag) ? Math.round(tag) : COLOR_TAG_RGB;
+  if (normalizedTag === COLOR_TAG_RGB || normalizedTag === COLOR_TAG_DEFAULT) {
+    return normalizedTag;
+  }
+  if (Number.isInteger(normalizedTag) && normalizedTag >= 0 && normalizedTag <= 255) {
+    return normalizedTag;
+  }
+  return COLOR_TAG_RGB;
+}
+function normalizeRGBABuffer(buffer) {
+  if (buffer.length === RGBA_BUFFER_STRIDE) {
+    buffer[4] = normalizeColorTag(buffer[4]);
+    return buffer;
+  }
+  const normalized = new Float32Array(RGBA_BUFFER_STRIDE);
+  normalized[0] = buffer[0] ?? 0;
+  normalized[1] = buffer[1] ?? 0;
+  normalized[2] = buffer[2] ?? 0;
+  normalized[3] = buffer[3] ?? 0;
+  normalized[4] = COLOR_TAG_RGB;
+  return normalized;
+}
+function withTag(rgba, tag) {
+  const tagged = RGBA.clone(rgba);
+  tagged.tag = tag;
+  return tagged;
+}
+function rgbaForAnsi256Index(index) {
+  const [r, g, b] = ansi256IndexToRgb(index);
+  return RGBA.fromInts(r, g, b);
+}
+function normalizeIndexedColorIndex(index) {
+  if (!Number.isInteger(index) || index < 0 || index > 255) {
+    throw new RangeError(`Indexed color must be an integer in the range 0..255, got ${index}`);
+  }
+  return index;
+}
+function ansi256IndexToRgb(index) {
+  const normalizedIndex = normalizeIndexedColorIndex(index);
+  if (normalizedIndex < ANSI16_RGB.length) {
+    return ANSI16_RGB[normalizedIndex];
+  }
+  if (normalizedIndex < 232) {
+    const cubeIndex = normalizedIndex - 16;
+    const r = Math.floor(cubeIndex / 36);
+    const g = Math.floor(cubeIndex / 6) % 6;
+    const b = cubeIndex % 6;
+    return [ANSI_256_CUBE_LEVELS[r], ANSI_256_CUBE_LEVELS[g], ANSI_256_CUBE_LEVELS[b]];
+  }
+  const value = 8 + (normalizedIndex - 232) * 10;
+  return [value, value, value];
+}
+function decodeColorTag(tag) {
+  if (tag === COLOR_TAG_DEFAULT) {
+    return { kind: "default" };
+  }
+  if (tag === COLOR_TAG_RGB) {
+    return { kind: "rgb" };
+  }
+  return { kind: "indexed", index: normalizeIndexedColorIndex(tag) };
+}
+
 class RGBA {
   buffer;
   constructor(buffer) {
-    this.buffer = buffer;
+    this.buffer = normalizeRGBABuffer(buffer);
   }
   static fromArray(array) {
     return new RGBA(array);
   }
-  static fromValues(r, g, b, a = 1) {
-    return new RGBA(new Float32Array([r, g, b, a]));
+  static fromValues(r, g, b, a = 1, tag = COLOR_TAG_RGB) {
+    return new RGBA(new Float32Array([r, g, b, a, normalizeColorTag(tag)]));
+  }
+  static clone(rgba) {
+    return RGBA.fromValues(rgba.r, rgba.g, rgba.b, rgba.a, rgba.tag);
   }
-  static fromInts(r, g, b, a = 255) {
-    return new RGBA(new Float32Array([r / 255, g / 255, b / 255, a / 255]));
+  static fromInts(r, g, b, a = 255, tag = COLOR_TAG_RGB) {
+    return new RGBA(new Float32Array([r / 255, g / 255, b / 255, a / 255, normalizeColorTag(tag)]));
   }
   static fromHex(hex) {
     return hexToRgb(hex);
   }
+  static fromIndex(index, snapshot) {
+    const normalizedIndex = normalizeIndexedColorIndex(index);
+    return withTag(snapshot ? parseColor(snapshot) : rgbaForAnsi256Index(normalizedIndex), normalizedIndex);
+  }
+  static defaultForeground(snapshot) {
+    return withTag(snapshot ? parseColor(snapshot) : RGBA.fromInts(...DEFAULT_FOREGROUND_RGB), COLOR_TAG_DEFAULT);
+  }
+  static defaultBackground(snapshot) {
+    return withTag(snapshot ? parseColor(snapshot) : RGBA.fromInts(...DEFAULT_BACKGROUND_RGB), COLOR_TAG_DEFAULT);
+  }
+  static getIntentTag(rgba) {
+    return rgba.tag;
+  }
   toInts() {
     return [Math.round(this.r * 255), Math.round(this.g * 255), Math.round(this.b * 255), Math.round(this.a * 255)];
   }
@@ -2013,6 +2116,12 @@ class RGBA {
   set a(value) {
     this.buffer[3] = value;
   }
+  get tag() {
+    return normalizeColorTag(this.buffer[4]);
+  }
+  set tag(value) {
+    this.buffer[4] = normalizeColorTag(value);
+  }
   map(fn) {
     return [fn(this.r), fn(this.g), fn(this.b), fn(this.a)];
   }
@@ -2022,9 +2131,15 @@ class RGBA {
   equals(other) {
     if (!other)
       return false;
-    return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a;
+    return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a && this.tag === other.tag;
   }
 }
+function normalizeColorValue(value) {
+  if (value == null)
+    return null;
+  const rgba = parseColor(value);
+  return { rgba, tag: rgba.tag };
+}
 function hexToRgb(hex) {
   hex = hex.replace(/^#/, "");
   if (hex.length === 3) {
@@ -10663,6 +10778,38 @@ class TerminalPalette {
 function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
   return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock);
 }
+var DEFAULT_FOREGROUND_FALLBACK = RGBA.fromInts(...DEFAULT_FOREGROUND_RGB);
+var DEFAULT_BACKGROUND_FALLBACK = RGBA.fromInts(...DEFAULT_BACKGROUND_RGB);
+var fallbackAnsi256Palette = null;
+function getFallbackAnsi256Palette() {
+  if (!fallbackAnsi256Palette) {
+    fallbackAnsi256Palette = Array.from({ length: 256 }, (_, index) => {
+      const [r, g, b] = ansi256IndexToRgb(index);
+      return RGBA.fromInts(r, g, b);
+    });
+  }
+  return fallbackAnsi256Palette;
+}
+function normalizeTerminalPalette(colors) {
+  const fallbackPalette = getFallbackAnsi256Palette();
+  return {
+    palette: Array.from({ length: 256 }, (_, index) => {
+      const detected = colors?.palette[index];
+      return detected ? RGBA.fromHex(detected) : RGBA.clone(fallbackPalette[index]);
+    }),
+    defaultForeground: colors?.defaultForeground ? RGBA.fromHex(colors.defaultForeground) : RGBA.clone(DEFAULT_FOREGROUND_FALLBACK),
+    defaultBackground: colors?.defaultBackground ? RGBA.fromHex(colors.defaultBackground) : RGBA.clone(DEFAULT_BACKGROUND_FALLBACK)
+  };
+}
+function buildTerminalPaletteSignature(colors) {
+  const normalized = normalizeTerminalPalette(colors);
+  const paletteSignature = normalized.palette.map((color) => color.toInts().join(",")).join(";");
+  return [
+    paletteSignature,
+    normalized.defaultForeground.toInts().join(","),
+    normalized.defaultBackground.toInts().join(",")
+  ].join("|");
+}
 
 // src/lib/paste.ts
 var PASTE_TEXT_DECODER = new TextDecoder;
@@ -10760,6 +10907,7 @@ class OptimizedBuffer {
   _widthMethod;
   respectAlpha = false;
   _rawBuffers = null;
+  _rawColorTags = null;
   _destroyed = false;
   get ptr() {
     return this.bufferPtr;
@@ -10768,23 +10916,38 @@ class OptimizedBuffer {
     if (this._destroyed)
       throw new Error(`Buffer ${this.id} is destroyed`);
   }
+  ensureRawBufferViews() {
+    if (this._rawBuffers !== null && this._rawColorTags !== null) {
+      return;
+    }
+    const size = this._width * this._height;
+    const charPtr = this.lib.bufferGetCharPtr(this.bufferPtr);
+    const fgPtr = this.lib.bufferGetFgPtr(this.bufferPtr);
+    const bgPtr = this.lib.bufferGetBgPtr(this.bufferPtr);
+    const fgTagPtr = this.lib.bufferGetFgTagPtr(this.bufferPtr);
+    const bgTagPtr = this.lib.bufferGetBgTagPtr(this.bufferPtr);
+    const attributesPtr = this.lib.bufferGetAttributesPtr(this.bufferPtr);
+    this._rawBuffers = {
+      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
+      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
+      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
+      attributes: new Uint32Array(toArrayBuffer(attributesPtr, 0, size * 4))
+    };
+    this._rawColorTags = {
+      fg: new Uint16Array(toArrayBuffer(fgTagPtr, 0, size * 2)),
+      bg: new Uint16Array(toArrayBuffer(bgTagPtr, 0, size * 2))
+    };
+  }
   get buffers() {
     this.guard();
-    if (this._rawBuffers === null) {
-      const size = this._width * this._height;
-      const charPtr = this.lib.bufferGetCharPtr(this.bufferPtr);
-      const fgPtr = this.lib.bufferGetFgPtr(this.bufferPtr);
-      const bgPtr = this.lib.bufferGetBgPtr(this.bufferPtr);
-      const attributesPtr = this.lib.bufferGetAttributesPtr(this.bufferPtr);
-      this._rawBuffers = {
-        char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
-        fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
-        bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
-        attributes: new Uint32Array(toArrayBuffer(attributesPtr, 0, size * 4))
-      };
-    }
+    this.ensureRawBufferViews();
     return this._rawBuffers;
   }
+  get rawColorTags() {
+    this.guard();
+    this.ensureRawBufferViews();
+    return this._rawColorTags;
+  }
   constructor(lib, ptr2, width, height, options) {
     this.id = options.id || `fb_${OptimizedBuffer.fbIdCounter++}`;
     this.lib = lib;
@@ -10829,6 +10992,7 @@ class OptimizedBuffer {
   getSpanLines() {
     this.guard();
     const { char, fg: fg2, bg: bg2, attributes } = this.buffers;
+    const { fg: fgTag, bg: bgTag } = this.rawColorTags;
     const lines = [];
     const CHAR_FLAG_CONTINUATION = 3221225472 | 0;
     const CHAR_FLAG_MASK = 3221225472 | 0;
@@ -10843,8 +11007,8 @@ class OptimizedBuffer {
       for (let x = 0;x < this._width; x++) {
         const i = y * this._width + x;
         const cp = char[i];
-        const cellFg = RGBA.fromValues(fg2[i * 4], fg2[i * 4 + 1], fg2[i * 4 + 2], fg2[i * 4 + 3]);
-        const cellBg = RGBA.fromValues(bg2[i * 4], bg2[i * 4 + 1], bg2[i * 4 + 2], bg2[i * 4 + 3]);
+        const cellFg = RGBA.fromValues(fg2[i * 4], fg2[i * 4 + 1], fg2[i * 4 + 2], fg2[i * 4 + 3], fgTag[i]);
+        const cellBg = RGBA.fromValues(bg2[i * 4], bg2[i * 4 + 1], bg2[i * 4 + 2], bg2[i * 4 + 3], bgTag[i]);
         const cellAttrs = attributes[i] & 255;
         const isContinuation = (cp & CHAR_FLAG_MASK) === CHAR_FLAG_CONTINUATION;
         const cellChar = isContinuation ? "" : lineChars[charIdx++] ?? " ";
@@ -10972,6 +11136,7 @@ class OptimizedBuffer {
     this._width = width;
     this._height = height;
     this._rawBuffers = null;
+    this._rawColorTags = null;
     this.lib.bufferResize(this.bufferPtr, width, height);
   }
   drawBox(options) {
@@ -11665,16 +11830,30 @@ var StyledChunkStruct = defineStruct([
       unpackTransform: rgbaUnpackTransform
     }
   ],
+  ["fg_tag", "u16", { default: COLOR_TAG_RGB }],
+  ["bg_tag", "u16", { default: COLOR_TAG_RGB }],
   ["attributes", "u32", { default: 0 }],
   ["link", "char*", { default: "" }],
   ["link_len", "u64", { lengthOf: "link" }]
 ], {
   mapValue: (chunk) => {
+    const normalizedFg = normalizeColorValue(chunk.fg ?? null);
+    const normalizedBg = normalizeColorValue(chunk.bg ?? null);
     if (!chunk.link || typeof chunk.link === "string") {
-      return chunk;
+      return {
+        ...chunk,
+        fg: normalizedFg?.rgba ?? null,
+        bg: normalizedBg?.rgba ?? null,
+        fg_tag: normalizedFg?.tag ?? COLOR_TAG_RGB,
+        bg_tag: normalizedBg?.tag ?? COLOR_TAG_RGB
+      };
     }
     return {
       ...chunk,
+      fg: normalizedFg?.rgba ?? null,
+      bg: normalizedBg?.rgba ?? null,
+      fg_tag: normalizedFg?.tag ?? COLOR_TAG_RGB,
+      bg_tag: normalizedBg?.tag ?? COLOR_TAG_RGB,
       link: chunk.link.url
     };
   }
@@ -11703,6 +11882,7 @@ var TerminalCapabilitiesStruct = defineStruct([
   ["kitty_keyboard", "bool_u8"],
   ["kitty_graphics", "bool_u8"],
   ["rgb", "bool_u8"],
+  ["ansi256", "bool_u8"],
   ["unicode", UnicodeMethodEnum],
   ["sgr_pixels", "bool_u8"],
   ["color_scheme_updates", "bool_u8"],
@@ -11966,10 +12146,18 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    rendererSetPaletteState: {
+      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
     queryPixelResolution: {
       args: ["ptr"],
       returns: "void"
     },
+    queryThemeColors: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createOptimizedBuffer: {
       args: ["u32", "u32", "bool", "u8", "ptr", "usize"],
       returns: "ptr"
@@ -12006,6 +12194,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    bufferGetFgTagPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetBgTagPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
     bufferGetAttributesPtr: {
       args: ["ptr"],
       returns: "ptr"
@@ -12807,7 +13003,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     syntaxStyleRegister: {
-      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u8"],
+      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u32"],
       returns: "u32"
     },
     syntaxStyleResolveByName: {
@@ -13216,6 +13412,18 @@ class FFIRenderLib {
     const height = this.opentui.symbols.getBufferHeight(bufferPtr);
     return new OptimizedBuffer(this, bufferPtr, width, height, { id: "current buffer", widthMethod: "unicode" });
   }
+  rendererSetPaletteState(renderer, palette, defaultForeground, defaultBackground, paletteEpoch) {
+    const paletteBuffer = new Float32Array(palette.length * 4);
+    for (let index = 0;index < palette.length; index++) {
+      const color = palette[index];
+      const base = index * 4;
+      paletteBuffer[base] = color.r;
+      paletteBuffer[base + 1] = color.g;
+      paletteBuffer[base + 2] = color.b;
+      paletteBuffer[base + 3] = color.a;
+    }
+    this.opentui.symbols.rendererSetPaletteState(renderer, paletteBuffer, paletteBuffer.length, defaultForeground.buffer, defaultBackground.buffer, paletteEpoch >>> 0);
+  }
   bufferGetCharPtr(buffer) {
     const ptr5 = this.opentui.symbols.bufferGetCharPtr(buffer);
     if (!ptr5) {
@@ -13237,6 +13445,20 @@ class FFIRenderLib {
     }
     return ptr5;
   }
+  bufferGetFgTagPtr(buffer) {
+    const ptr5 = this.opentui.symbols.bufferGetFgTagPtr(buffer);
+    if (!ptr5) {
+      throw new Error("Failed to get fg tag pointer");
+    }
+    return ptr5;
+  }
+  bufferGetBgTagPtr(buffer) {
+    const ptr5 = this.opentui.symbols.bufferGetBgTagPtr(buffer);
+    if (!ptr5) {
+      throw new Error("Failed to get bg tag pointer");
+    }
+    return ptr5;
+  }
   bufferGetAttributesPtr(buffer) {
     const ptr5 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
     if (!ptr5) {
@@ -13494,6 +13716,9 @@ class FFIRenderLib {
   queryPixelResolution(renderer) {
     this.opentui.symbols.queryPixelResolution(renderer);
   }
+  queryThemeColors(renderer) {
+    this.opentui.symbols.queryThemeColors(renderer);
+  }
   writeOut(renderer, data) {
     const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
     if (bytes.length === 0)
@@ -14198,6 +14423,7 @@ class FFIRenderLib {
       kitty_keyboard: caps.kitty_keyboard,
       kitty_graphics: caps.kitty_graphics,
       rgb: caps.rgb,
+      ansi256: caps.ansi256,
       unicode: caps.unicode,
       sgr_pixels: caps.sgr_pixels,
       color_scheme_updates: caps.color_scheme_updates,
@@ -17629,6 +17855,7 @@ class CodeRenderable extends TextBufferRenderable {
       this._highlightsDirty = true;
       this._highlightSnapshotId++;
       if (this._streaming && !this._drawUnstyledText && this._filetype) {
+        this.requestRender();
         return;
       }
       this.textBuffer.setText(value);
@@ -20430,7 +20657,7 @@ function parsePixelResolution(sequence) {
   return null;
 }
 
-// src/renderer.ts
+// src/renderer-theme-mode.ts
 var OSC_THEME_RESPONSE = /\x1b](10|11);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 function scaleOscThemeComponent(component) {
   const value = parseInt(component, 16);
@@ -20451,6 +20678,131 @@ function inferThemeModeFromBackgroundColor(color) {
   const brightness = (r * 299 + g * 587 + b * 114) / 1000;
   return brightness > 128 ? "light" : "dark";
 }
+
+class RendererThemeMode {
+  host;
+  clock;
+  static QUERY_TIMEOUT_MS = 250;
+  _themeMode = null;
+  themeQueryPending = true;
+  themeOscForeground = null;
+  themeOscBackground = null;
+  themeRefreshTimeoutId = null;
+  waiters = new Set;
+  constructor(host, clock2) {
+    this.host = host;
+    this.clock = clock2;
+  }
+  get themeMode() {
+    return this._themeMode;
+  }
+  waitForThemeMode(timeoutMs, isDestroyed) {
+    if (this._themeMode !== null || isDestroyed || timeoutMs === 0) {
+      return Promise.resolve(this._themeMode);
+    }
+    return new Promise((resolve4) => {
+      const waiter = {
+        resolve: resolve4,
+        timeoutHandle: null
+      };
+      if (timeoutMs > 0) {
+        waiter.timeoutHandle = this.clock.setTimeout(() => {
+          this.waiters.delete(waiter);
+          waiter.timeoutHandle = null;
+          resolve4(this._themeMode);
+        }, timeoutMs);
+      }
+      this.waiters.add(waiter);
+    });
+  }
+  cancelRefresh() {
+    if (this.themeRefreshTimeoutId === null) {
+      return;
+    }
+    this.clock.clearTimeout(this.themeRefreshTimeoutId);
+    this.themeRefreshTimeoutId = null;
+    this.themeQueryPending = false;
+  }
+  dispose() {
+    this.cancelRefresh();
+    for (const waiter of this.waiters) {
+      if (waiter.timeoutHandle !== null) {
+        this.clock.clearTimeout(waiter.timeoutHandle);
+      }
+      waiter.resolve(this._themeMode);
+    }
+    this.waiters.clear();
+  }
+  handleSequence(sequence) {
+    if (sequence === "\x1B[?997;1n" || sequence === "\x1B[?997;2n") {
+      this.requestThemeOscColors();
+      return { handled: true, changedMode: null };
+    }
+    let handledOscThemeResponse = false;
+    let match;
+    OSC_THEME_RESPONSE.lastIndex = 0;
+    while (match = OSC_THEME_RESPONSE.exec(sequence)) {
+      handledOscThemeResponse = true;
+      const color = oscThemeColorToHex(match[2], match[3], match[4], match[5]);
+      if (match[1] === "10") {
+        this.themeOscForeground = color;
+      } else {
+        this.themeOscBackground = color;
+      }
+    }
+    if (!handledOscThemeResponse) {
+      return { handled: false, changedMode: null };
+    }
+    if (!this.themeQueryPending) {
+      return { handled: true, changedMode: null };
+    }
+    if (!this.themeOscForeground || !this.themeOscBackground) {
+      return { handled: true, changedMode: null };
+    }
+    const nextMode = inferThemeModeFromBackgroundColor(this.themeOscBackground);
+    const changedMode = this.applyThemeMode(nextMode);
+    this.completeThemeQuery();
+    return { handled: true, changedMode };
+  }
+  clearThemeRefreshTimeout() {
+    if (this.themeRefreshTimeoutId === null) {
+      return;
+    }
+    this.clock.clearTimeout(this.themeRefreshTimeoutId);
+    this.themeRefreshTimeoutId = null;
+  }
+  completeThemeQuery() {
+    this.clearThemeRefreshTimeout();
+    this.themeQueryPending = false;
+  }
+  requestThemeOscColors() {
+    this.themeQueryPending = true;
+    this.themeOscForeground = null;
+    this.themeOscBackground = null;
+    this.host.queryThemeColors();
+    this.clearThemeRefreshTimeout();
+    this.themeRefreshTimeoutId = this.clock.setTimeout(() => {
+      this.completeThemeQuery();
+    }, RendererThemeMode.QUERY_TIMEOUT_MS);
+  }
+  applyThemeMode(mode) {
+    const changed = this._themeMode !== mode;
+    this._themeMode = mode;
+    if (!changed) {
+      return null;
+    }
+    for (const waiter of this.waiters) {
+      if (waiter.timeoutHandle !== null) {
+        this.clock.clearTimeout(waiter.timeoutHandle);
+      }
+      waiter.resolve(mode);
+    }
+    this.waiters.clear();
+    return mode;
+  }
+}
+
+// src/renderer.ts
 registerEnvVar({
   name: "OTUI_DUMP_CAPTURES",
   description: "Dump captured stdout and console caches when the renderer exit handler runs.",
@@ -20905,18 +21257,20 @@ class CliRenderer extends EventEmitter9 {
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
   _paletteDetector = null;
+  _paletteCache = new Map;
   _cachedPalette = null;
   _paletteDetectionPromise = null;
+  _paletteDetectionSize = 0;
+  _paletteEpoch = 0;
+  _publishedPaletteSignature = null;
+  _palettePublishGeneration = 0;
   _onDestroy;
-  _themeMode = null;
-  _themeModeSource = "none";
-  _themeFallbackPending = true;
-  _themeOscForeground = null;
-  _themeOscBackground = null;
+  themeModeState;
   _terminalFocusState = null;
   sequenceHandlers = [];
   prependedInputHandlers = [];
   shouldRestoreModesOnNextFocus = false;
+  themeModeHandler;
   idleResolvers = [];
   _debugInputs = [];
   _debugModeEnabled = env.OTUI_DEBUG;
@@ -20996,7 +21350,7 @@ Captured external output:
     this.rendererPtr = rendererPtr;
     this.clearOnShutdown = config.clearOnShutdown ?? true;
     this.lib.setClearOnShutdown(this.rendererPtr, this.clearOnShutdown);
-    const forwardEnvKeys = config.forwardEnvKeys ?? [...DEFAULT_FORWARDED_ENV_KEYS];
+    const forwardEnvKeys = config.forwardEnvKeys ?? (config.remote ? [] : [...DEFAULT_FORWARDED_ENV_KEYS]);
     for (const key of forwardEnvKeys) {
       const value = process.env[key];
       if (value === undefined)
@@ -21019,6 +21373,18 @@ Captured external output:
     this.targetFps = config.targetFps || 30;
     this.maxFps = config.maxFps || 60;
     this.clock = config.clock ?? new SystemClock;
+    this.themeModeState = new RendererThemeMode({
+      queryThemeColors: () => {
+        this.lib.queryThemeColors(this.rendererPtr);
+      }
+    }, this.clock);
+    this.themeModeHandler = (sequence) => {
+      const result = this.themeModeState.handleSequence(sequence);
+      if (result.changedMode) {
+        this.emit("theme_mode" /* THEME_MODE */, result.changedMode);
+      }
+      return result.handled;
+    };
     this.memorySnapshotInterval = config.memorySnapshotInterval ?? 0;
     this.gatherStats = config.gatherStats || false;
     this.maxStatSamples = config.maxStatSamples || 300;
@@ -21380,39 +21746,13 @@ Captured external output:
     return this._capabilities;
   }
   get themeMode() {
-    return this._themeMode;
+    return this.themeModeState.themeMode;
   }
   waitForThemeMode(timeoutMs = 1000) {
     if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
       throw new Error("timeoutMs must be a non-negative finite number");
     }
-    if (this._themeMode !== null || this._isDestroyed || timeoutMs === 0) {
-      return Promise.resolve(this._themeMode);
-    }
-    return new Promise((resolve4) => {
-      let timeoutHandle = null;
-      const cleanup = () => {
-        if (timeoutHandle !== null) {
-          this.clock.clearTimeout(timeoutHandle);
-          timeoutHandle = null;
-        }
-        this.off("theme_mode" /* THEME_MODE */, handleThemeMode);
-        this.off("destroy" /* DESTROY */, handleDestroy);
-      };
-      const finish = () => {
-        cleanup();
-        resolve4(this._themeMode);
-      };
-      const handleThemeMode = () => {
-        finish();
-      };
-      const handleDestroy = () => {
-        finish();
-      };
-      this.on("theme_mode" /* THEME_MODE */, handleThemeMode);
-      this.on("destroy" /* DESTROY */, handleDestroy);
-      timeoutHandle = this.clock.setTimeout(finish, timeoutMs);
-    });
+    return this.themeModeState.waitForThemeMode(timeoutMs, this._isDestroyed);
   }
   getDebugInputs() {
     return [...this._debugInputs];
@@ -22219,6 +22559,7 @@ Captured external output:
       }, 120);
     }
     this.queryPixelResolution();
+    this.ensureNativePaletteState();
   }
   stdinListener = ((chunk) => {
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -22261,6 +22602,10 @@ Captured external output:
     }
     this.lib.processCapabilityResponse(this.rendererPtr, sequence);
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
+    if (hasStandardCapabilitySignature) {
+      this.forceFullRepaintRequested = true;
+      this.requestRender();
+    }
     this.emit("capabilities" /* CAPABILITIES */, this._capabilities);
     const hadPendingSplitStartupCursorSeed = this.pendingSplitStartupCursorSeed;
     if (hadPendingSplitStartupCursorSeed && hasCursorReport && this._screenMode === "split-footer" && this._externalOutputMode === "capture-stdout") {
@@ -22302,52 +22647,6 @@ Captured external output:
     }
     return false;
   }).bind(this);
-  themeModeHandler = ((sequence) => {
-    if (sequence === "\x1B[?997;1n") {
-      this.applyThemeMode("dark", "csi");
-      this._themeFallbackPending = false;
-      return true;
-    }
-    if (sequence === "\x1B[?997;2n") {
-      this.applyThemeMode("light", "csi");
-      this._themeFallbackPending = false;
-      return true;
-    }
-    let handledOscThemeResponse = false;
-    let match;
-    OSC_THEME_RESPONSE.lastIndex = 0;
-    while (match = OSC_THEME_RESPONSE.exec(sequence)) {
-      handledOscThemeResponse = true;
-      const color = oscThemeColorToHex(match[2], match[3], match[4], match[5]);
-      if (match[1] === "10") {
-        this._themeOscForeground = color;
-      } else {
-        this._themeOscBackground = color;
-      }
-    }
-    if (!handledOscThemeResponse) {
-      return false;
-    }
-    if (!this._themeFallbackPending) {
-      return true;
-    }
-    if (this._themeOscForeground && this._themeOscBackground) {
-      this.applyThemeMode(inferThemeModeFromBackgroundColor(this._themeOscBackground), "osc");
-      this._themeFallbackPending = false;
-    }
-    return true;
-  }).bind(this);
-  applyThemeMode(mode, source) {
-    if (source === "osc" && this._themeModeSource === "csi") {
-      return;
-    }
-    const changed = this._themeMode !== mode;
-    this._themeMode = mode;
-    this._themeModeSource = source;
-    if (changed) {
-      this.emit("theme_mode" /* THEME_MODE */, mode);
-    }
-  }
   dispatchSequenceHandlers(sequence) {
     if (this._debugModeEnabled) {
       this._debugInputs.push({
@@ -22882,6 +23181,7 @@ Captured external output:
     });
     this.stdinParser?.reset();
     this.stdin.removeListener("data", this.stdinListener);
+    this.themeModeState.cancelRefresh();
     this.lib.suspendRenderer(this.rendererPtr);
     if (this.stdin.setRawMode) {
       this.stdin.setRawMode(false);
@@ -22982,6 +23282,7 @@ Captured external output:
       this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
+    this.themeModeState.cancelRefresh();
     this._isRunning = false;
     this.waitingForPixelResolution = false;
     this.updateStdinParserProtocolContext({
@@ -23015,8 +23316,14 @@ Captured external output:
       this._paletteDetector.cleanup();
       this._paletteDetector = null;
     }
+    this._paletteCache.clear();
     this._paletteDetectionPromise = null;
+    this._paletteDetectionSize = 0;
     this._cachedPalette = null;
+    this._publishedPaletteSignature = null;
+    this._paletteEpoch = 0;
+    this._palettePublishGeneration = 0;
+    this.themeModeState.dispose();
     this.emit("destroy" /* DESTROY */);
     try {
       this.root.destroyRecursively();
@@ -23156,9 +23463,10 @@ Captured external output:
       this.flushPendingSplitCommits(forceSplitRepaint);
       this.pendingSplitFooterTransition = null;
     } else {
+      const force = this.forceFullRepaintRequested;
       this.forceFullRepaintRequested = false;
       this.pendingSplitFooterTransition = null;
-      this.lib.render(this.rendererPtr, false);
+      this.lib.render(this.rendererPtr, force);
     }
     this.renderingNative = false;
   }
@@ -23303,13 +23611,63 @@ Captured external output:
     }
   }
   get paletteDetectionStatus() {
-    if (this._cachedPalette)
-      return "cached";
     if (this._paletteDetectionPromise)
       return "detecting";
+    if (this._paletteCache.size > 0)
+      return "cached";
     return "idle";
   }
+  getCachedPaletteBySize(size) {
+    const exactMatch = this._paletteCache.get(size);
+    if (exactMatch) {
+      return exactMatch;
+    }
+    const largerSize = [...this._paletteCache.keys()].sort((a, b) => a - b).find((candidate) => candidate >= size);
+    if (largerSize === undefined) {
+      return null;
+    }
+    const source = this._paletteCache.get(largerSize);
+    if (!source) {
+      return null;
+    }
+    const projected = {
+      ...source,
+      palette: source.palette.slice(0, size)
+    };
+    this._paletteCache.set(size, projected);
+    return projected;
+  }
+  ensurePaletteDetector() {
+    if (!this._paletteDetector) {
+      const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
+      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
+        subscribeOsc: this.subscribeOsc.bind(this)
+      }, this.clock);
+    }
+    return this._paletteDetector;
+  }
+  syncNativePaletteState(colors) {
+    const signature = buildTerminalPaletteSignature(colors);
+    if (this._publishedPaletteSignature !== null && this._publishedPaletteSignature !== signature) {
+      this._paletteEpoch = this._paletteEpoch + 1 >>> 0;
+    }
+    this._publishedPaletteSignature = signature;
+    const normalized = normalizeTerminalPalette(colors);
+    this.lib.rendererSetPaletteState(this.rendererPtr, normalized.palette, normalized.defaultForeground, normalized.defaultBackground, this._paletteEpoch);
+  }
+  ensureNativePaletteState() {
+    if (!this._terminalIsSetup || this._isDestroyed)
+      return;
+    const publishGeneration = this._palettePublishGeneration;
+    this.getPalette({ size: 256 }).then((colors) => {
+      if (this._palettePublishGeneration === publishGeneration) {
+        this.syncNativePaletteState(colors);
+      }
+      this.requestRender();
+    }).catch(() => {});
+  }
   clearPaletteCache() {
+    this._paletteCache.clear();
     this._cachedPalette = null;
   }
   async getPalette(options) {
@@ -23317,31 +23675,65 @@ Captured external output:
       throw new Error("Cannot detect palette while renderer is suspended");
     }
     const requestedSize = options?.size ?? 16;
-    if (this._cachedPalette && this._cachedPalette.palette.length !== requestedSize) {
-      this._cachedPalette = null;
-    }
-    if (this._cachedPalette) {
-      return this._cachedPalette;
+    const detectionTimeout = options?.timeout;
+    const cachedPalette = this.getCachedPaletteBySize(requestedSize);
+    if (cachedPalette) {
+      this._cachedPalette = cachedPalette;
+      return cachedPalette;
     }
     if (this._paletteDetectionPromise) {
-      return this._paletteDetectionPromise;
-    }
-    if (!this._paletteDetector) {
-      const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
-      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
-        subscribeOsc: this.subscribeOsc.bind(this)
-      }, this.clock);
+      if (this._paletteDetectionSize >= requestedSize) {
+        return this._paletteDetectionPromise.then((palette) => {
+          const cached = this.getCachedPaletteBySize(requestedSize);
+          if (cached) {
+            this._cachedPalette = cached;
+            return cached;
+          }
+          const projected = {
+            ...palette,
+            palette: palette.palette.slice(0, requestedSize)
+          };
+          this._paletteCache.set(requestedSize, projected);
+          this._cachedPalette = projected;
+          return projected;
+        });
+      }
+      await this._paletteDetectionPromise;
+      const afterWait = this.getCachedPaletteBySize(requestedSize);
+      if (afterWait) {
+        this._cachedPalette = afterWait;
+        return afterWait;
+      }
     }
-    this._paletteDetectionPromise = this._paletteDetector.detect(options).then((result) => {
+    const detector = this.ensurePaletteDetector();
+    const publishGeneration = this._palettePublishGeneration;
+    this._paletteDetectionSize = requestedSize;
+    this._paletteDetectionPromise = detector.detect({ ...options, timeout: detectionTimeout }).then((result) => {
+      this._paletteCache.set(result.palette.length, result);
       this._cachedPalette = result;
       this._paletteDetectionPromise = null;
+      this._paletteDetectionSize = 0;
+      if (this._palettePublishGeneration === publishGeneration) {
+        if (result.palette.length >= 256) {
+          this.syncNativePaletteState(result);
+        } else if (this._terminalIsSetup && !this._paletteCache.has(256)) {
+          this.ensureNativePaletteState();
+        }
+      }
       return result;
+    }).catch((error) => {
+      this._paletteDetectionPromise = null;
+      this._paletteDetectionSize = 0;
+      throw error;
     });
-    return this._paletteDetectionPromise;
+    const detected = await this._paletteDetectionPromise;
+    const finalPalette = this.getCachedPaletteBySize(requestedSize) ?? detected;
+    this._cachedPalette = finalPalette;
+    return finalPalette;
   }
 }
 
-export { __toESM, __commonJS, __export, __require, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, ANSI, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, TextRenderable, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, calculateRenderGeometry, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, COLOR_TAG_RGB, COLOR_TAG_DEFAULT, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, decodeColorTag, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, ANSI, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, TextRenderable, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, calculateRenderGeometry, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=F970487203C0DBFC64756E2164756E21
-//# sourceMappingURL=index-qpcsqve6.js.map
+//# debugId=B1BCF94D9F983F0164756E2164756E21
+//# sourceMappingURL=index-4pvh4sbk.js.map