@opentui/core 0.1.86 → 0.1.88

package/{index-4sjb8n0n.js → index-nkrr8a4c.js}

@@ -1793,600 +1793,9 @@ var BorderCharArrays = {
   heavy: borderCharsToArray(BorderChars.heavy)
 };
 
-// src/lib/parse.keypress.ts
-import { Buffer as Buffer2 } from "buffer";
-
-// src/lib/parse.keypress-kitty.ts
-var kittyKeyMap = {
-  27: "escape",
-  9: "tab",
-  13: "return",
-  127: "backspace",
-  57344: "escape",
-  57345: "return",
-  57346: "tab",
-  57347: "backspace",
-  57348: "insert",
-  57349: "delete",
-  57350: "left",
-  57351: "right",
-  57352: "up",
-  57353: "down",
-  57354: "pageup",
-  57355: "pagedown",
-  57356: "home",
-  57357: "end",
-  57364: "f1",
-  57365: "f2",
-  57366: "f3",
-  57367: "f4",
-  57368: "f5",
-  57369: "f6",
-  57370: "f7",
-  57371: "f8",
-  57372: "f9",
-  57373: "f10",
-  57374: "f11",
-  57375: "f12",
-  57376: "f13",
-  57377: "f14",
-  57378: "f15",
-  57379: "f16",
-  57380: "f17",
-  57381: "f18",
-  57382: "f19",
-  57383: "f20",
-  57384: "f21",
-  57385: "f22",
-  57386: "f23",
-  57387: "f24",
-  57388: "f25",
-  57389: "f26",
-  57390: "f27",
-  57391: "f28",
-  57392: "f29",
-  57393: "f30",
-  57394: "f31",
-  57395: "f32",
-  57396: "f33",
-  57397: "f34",
-  57398: "f35",
-  57399: "kp0",
-  57400: "kp1",
-  57401: "kp2",
-  57402: "kp3",
-  57403: "kp4",
-  57404: "kp5",
-  57405: "kp6",
-  57406: "kp7",
-  57407: "kp8",
-  57408: "kp9",
-  57409: "kpdecimal",
-  57410: "kpdivide",
-  57411: "kpmultiply",
-  57412: "kpminus",
-  57413: "kpplus",
-  57414: "kpenter",
-  57415: "kpequal",
-  57428: "mediaplay",
-  57429: "mediapause",
-  57430: "mediaplaypause",
-  57431: "mediareverse",
-  57432: "mediastop",
-  57433: "mediafastforward",
-  57434: "mediarewind",
-  57435: "medianext",
-  57436: "mediaprev",
-  57437: "mediarecord",
-  57438: "volumedown",
-  57439: "volumeup",
-  57440: "mute",
-  57441: "leftshift",
-  57442: "leftctrl",
-  57443: "leftalt",
-  57444: "leftsuper",
-  57445: "lefthyper",
-  57446: "leftmeta",
-  57447: "rightshift",
-  57448: "rightctrl",
-  57449: "rightalt",
-  57450: "rightsuper",
-  57451: "righthyper",
-  57452: "rightmeta",
-  57453: "iso_level3_shift",
-  57454: "iso_level5_shift"
-};
-function fromKittyMods(mod) {
-  return {
-    shift: !!(mod & 1),
-    alt: !!(mod & 2),
-    ctrl: !!(mod & 4),
-    super: !!(mod & 8),
-    hyper: !!(mod & 16),
-    meta: !!(mod & 32),
-    capsLock: !!(mod & 64),
-    numLock: !!(mod & 128)
-  };
-}
-var functionalKeyMap = {
-  A: "up",
-  B: "down",
-  C: "right",
-  D: "left",
-  H: "home",
-  F: "end",
-  P: "f1",
-  Q: "f2",
-  R: "f3",
-  S: "f4"
-};
-var tildeKeyMap = {
-  "1": "home",
-  "2": "insert",
-  "3": "delete",
-  "4": "end",
-  "5": "pageup",
-  "6": "pagedown",
-  "7": "home",
-  "8": "end",
-  "11": "f1",
-  "12": "f2",
-  "13": "f3",
-  "14": "f4",
-  "15": "f5",
-  "17": "f6",
-  "18": "f7",
-  "19": "f8",
-  "20": "f9",
-  "21": "f10",
-  "23": "f11",
-  "24": "f12"
-};
-function parseKittySpecialKey(sequence) {
-  const specialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Z~])$/;
-  const match = specialKeyRe.exec(sequence);
-  if (!match)
-    return null;
-  const keyNumOrOne = match[1];
-  const modifierStr = match[2];
-  const eventTypeStr = match[3];
-  const terminator = match[4];
-  let keyName;
-  if (terminator === "~") {
-    keyName = tildeKeyMap[keyNumOrOne];
-  } else {
-    if (keyNumOrOne !== "1")
-      return null;
-    keyName = functionalKeyMap[terminator];
-  }
-  if (!keyName)
-    return null;
-  const key = {
-    name: keyName,
-    ctrl: false,
-    meta: false,
-    shift: false,
-    option: false,
-    number: false,
-    sequence,
-    raw: sequence,
-    eventType: "press",
-    source: "kitty",
-    super: false,
-    hyper: false,
-    capsLock: false,
-    numLock: false
-  };
-  if (modifierStr) {
-    const modifierMask = parseInt(modifierStr, 10);
-    if (!isNaN(modifierMask) && modifierMask > 1) {
-      const mods = fromKittyMods(modifierMask - 1);
-      key.shift = mods.shift;
-      key.ctrl = mods.ctrl;
-      key.meta = mods.alt || mods.meta;
-      key.option = mods.alt;
-      key.super = mods.super;
-      key.hyper = mods.hyper;
-      key.capsLock = mods.capsLock;
-      key.numLock = mods.numLock;
-    }
-  }
-  if (eventTypeStr === "1" || !eventTypeStr) {
-    key.eventType = "press";
-  } else if (eventTypeStr === "2") {
-    key.eventType = "press";
-    key.repeated = true;
-  } else if (eventTypeStr === "3") {
-    key.eventType = "release";
-  }
-  return key;
-}
-function parseKittyKeyboard(sequence) {
-  const specialResult = parseKittySpecialKey(sequence);
-  if (specialResult)
-    return specialResult;
-  const kittyRe = /^\x1b\[([^\x1b]+)u$/;
-  const match = kittyRe.exec(sequence);
-  if (!match)
-    return null;
-  const params = match[1];
-  const fields = params.split(";");
-  if (fields.length < 1)
-    return null;
-  const key = {
-    name: "",
-    ctrl: false,
-    meta: false,
-    shift: false,
-    option: false,
-    number: false,
-    sequence,
-    raw: sequence,
-    eventType: "press",
-    source: "kitty",
-    super: false,
-    hyper: false,
-    capsLock: false,
-    numLock: false
-  };
-  let text = "";
-  const field1 = fields[0]?.split(":") || [];
-  const codepointStr = field1[0];
-  if (!codepointStr)
-    return null;
-  const codepoint = parseInt(codepointStr, 10);
-  if (isNaN(codepoint))
-    return null;
-  let shiftedCodepoint;
-  let baseCodepoint;
-  if (field1[1]) {
-    const shifted = parseInt(field1[1], 10);
-    if (!isNaN(shifted) && shifted > 0 && shifted <= 1114111) {
-      shiftedCodepoint = shifted;
-    }
-  }
-  if (field1[2]) {
-    const base = parseInt(field1[2], 10);
-    if (!isNaN(base) && base > 0 && base <= 1114111) {
-      baseCodepoint = base;
-    }
-  }
-  const knownKey = kittyKeyMap[codepoint];
-  if (knownKey) {
-    key.name = knownKey;
-    key.code = `[${codepoint}u`;
-  } else {
-    if (codepoint > 0 && codepoint <= 1114111) {
-      const char = String.fromCodePoint(codepoint);
-      key.name = char;
-      if (baseCodepoint) {
-        key.baseCode = baseCodepoint;
-      }
-    } else {
-      return null;
-    }
-  }
-  if (fields[1]) {
-    const field2 = fields[1].split(":");
-    const modifierStr = field2[0];
-    const eventTypeStr = field2[1];
-    if (modifierStr) {
-      const modifierMask = parseInt(modifierStr, 10);
-      if (!isNaN(modifierMask) && modifierMask > 1) {
-        const mods = fromKittyMods(modifierMask - 1);
-        key.shift = mods.shift;
-        key.ctrl = mods.ctrl;
-        key.meta = mods.alt || mods.meta;
-        key.option = mods.alt;
-        key.super = mods.super;
-        key.hyper = mods.hyper;
-        key.capsLock = mods.capsLock;
-        key.numLock = mods.numLock;
-      }
-    }
-    if (eventTypeStr === "1" || !eventTypeStr) {
-      key.eventType = "press";
-    } else if (eventTypeStr === "2") {
-      key.eventType = "press";
-      key.repeated = true;
-    } else if (eventTypeStr === "3") {
-      key.eventType = "release";
-    } else {
-      key.eventType = "press";
-    }
-  }
-  if (fields[2]) {
-    const codepoints = fields[2].split(":");
-    for (const cpStr of codepoints) {
-      const cp = parseInt(cpStr, 10);
-      if (!isNaN(cp) && cp > 0 && cp <= 1114111) {
-        text += String.fromCodePoint(cp);
-      }
-    }
-  }
-  if (text === "") {
-    const isPrintable = key.name.length > 0 && !kittyKeyMap[codepoint];
-    if (isPrintable) {
-      if (key.shift && shiftedCodepoint) {
-        text = String.fromCodePoint(shiftedCodepoint);
-      } else if (key.shift && key.name.length === 1) {
-        text = key.name.toLocaleUpperCase();
-      } else {
-        text = key.name;
-      }
-    }
-  }
-  if (key.name === " " && key.shift && !key.ctrl && !key.meta) {
-    text = " ";
-  }
-  if (text) {
-    key.sequence = text;
-  }
-  return key;
-}
-
-// src/lib/parse.keypress.ts
-var metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
-var fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
-var keyName = {
-  OP: "f1",
-  OQ: "f2",
-  OR: "f3",
-  OS: "f4",
-  "[11~": "f1",
-  "[12~": "f2",
-  "[13~": "f3",
-  "[14~": "f4",
-  "[[A": "f1",
-  "[[B": "f2",
-  "[[C": "f3",
-  "[[D": "f4",
-  "[[E": "f5",
-  "[15~": "f5",
-  "[17~": "f6",
-  "[18~": "f7",
-  "[19~": "f8",
-  "[20~": "f9",
-  "[21~": "f10",
-  "[23~": "f11",
-  "[24~": "f12",
-  "[A": "up",
-  "[B": "down",
-  "[C": "right",
-  "[D": "left",
-  "[E": "clear",
-  "[F": "end",
-  "[H": "home",
-  OA: "up",
-  OB: "down",
-  OC: "right",
-  OD: "left",
-  OE: "clear",
-  OF: "end",
-  OH: "home",
-  "[1~": "home",
-  "[2~": "insert",
-  "[3~": "delete",
-  "[4~": "end",
-  "[5~": "pageup",
-  "[6~": "pagedown",
-  "[[5~": "pageup",
-  "[[6~": "pagedown",
-  "[7~": "home",
-  "[8~": "end",
-  "[a": "up",
-  "[b": "down",
-  "[c": "right",
-  "[d": "left",
-  "[e": "clear",
-  f: "right",
-  b: "left",
-  p: "up",
-  n: "down",
-  "[2$": "insert",
-  "[3$": "delete",
-  "[5$": "pageup",
-  "[6$": "pagedown",
-  "[7$": "home",
-  "[8$": "end",
-  Oa: "up",
-  Ob: "down",
-  Oc: "right",
-  Od: "left",
-  Oe: "clear",
-  "[2^": "insert",
-  "[3^": "delete",
-  "[5^": "pageup",
-  "[6^": "pagedown",
-  "[7^": "home",
-  "[8^": "end",
-  "[Z": "tab"
-};
-var nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
-var isShiftKey = (code) => {
-  return ["[a", "[b", "[c", "[d", "[e", "[2$", "[3$", "[5$", "[6$", "[7$", "[8$", "[Z"].includes(code);
-};
-var isCtrlKey = (code) => {
-  return ["Oa", "Ob", "Oc", "Od", "Oe", "[2^", "[3^", "[5^", "[6^", "[7^", "[8^"].includes(code);
-};
-var modifyOtherKeysRe = /^\x1b\[27;(\d+);(\d+)~$/;
-var parseKeypress = (s = "", options = {}) => {
-  let parts;
-  if (Buffer2.isBuffer(s)) {
-    if (s[0] > 127 && s[1] === undefined) {
-      s[0] -= 128;
-      s = "\x1B" + String(s);
-    } else {
-      s = String(s);
-    }
-  } else if (s !== undefined && typeof s !== "string") {
-    s = String(s);
-  } else if (!s) {
-    s = "";
-  }
-  if (/^\x1b\[<\d+;\d+;\d+[Mm]$/.test(s)) {
-    return null;
-  }
-  if (s.startsWith("\x1B[M") && s.length >= 6) {
-    return null;
-  }
-  if (/^\x1b\[\d+;\d+;\d+t$/.test(s)) {
-    return null;
-  }
-  if (/^\x1b\[\d+;\d+R$/.test(s)) {
-    return null;
-  }
-  if (/^\x1b\[\?[\d;]+c$/.test(s)) {
-    return null;
-  }
-  if (/^\x1b\[\?[\d;]+\$y$/.test(s)) {
-    return null;
-  }
-  if (s === "\x1B[I" || s === "\x1B[O") {
-    return null;
-  }
-  if (/^\x1b\][\d;].*(\x1b\\|\x07)$/.test(s)) {
-    return null;
-  }
-  if (s === "\x1B[200~" || s === "\x1B[201~") {
-    return null;
-  }
-  const key = {
-    name: "",
-    ctrl: false,
-    meta: false,
-    shift: false,
-    option: false,
-    number: false,
-    sequence: s,
-    raw: s,
-    eventType: "press",
-    source: "raw"
-  };
-  key.sequence = key.sequence || s || key.name;
-  if (options.useKittyKeyboard) {
-    const kittyResult = parseKittyKeyboard(s);
-    if (kittyResult) {
-      return kittyResult;
-    }
-  }
-  const modifyOtherKeysMatch = modifyOtherKeysRe.exec(s);
-  if (modifyOtherKeysMatch) {
-    const modifier = parseInt(modifyOtherKeysMatch[1], 10) - 1;
-    const charCode = parseInt(modifyOtherKeysMatch[2], 10);
-    key.ctrl = !!(modifier & 4);
-    key.meta = !!(modifier & 2);
-    key.shift = !!(modifier & 1);
-    key.option = !!(modifier & 2);
-    key.super = !!(modifier & 8);
-    key.hyper = !!(modifier & 16);
-    if (charCode === 13) {
-      key.name = "return";
-    } else if (charCode === 27) {
-      key.name = "escape";
-    } else if (charCode === 9) {
-      key.name = "tab";
-    } else if (charCode === 32) {
-      key.name = "space";
-    } else if (charCode === 127 || charCode === 8) {
-      key.name = "backspace";
-    } else {
-      const char = String.fromCharCode(charCode);
-      key.name = char;
-      key.sequence = char;
-      if (charCode >= 48 && charCode <= 57) {
-        key.number = true;
-      }
-    }
-    return key;
-  }
-  if (s === "\r" || s === "\x1B\r") {
-    key.name = "return";
-    key.meta = s.length === 2;
-  } else if (s === `
-` || s === `\x1B
-`) {
-    key.name = "linefeed";
-    key.meta = s.length === 2;
-  } else if (s === "\t") {
-    key.name = "tab";
-  } else if (s === "\b" || s === "\x1B\b" || s === "\x7F" || s === "\x1B\x7F") {
-    key.name = "backspace";
-    key.meta = s.charAt(0) === "\x1B";
-  } else if (s === "\x1B" || s === "\x1B\x1B") {
-    key.name = "escape";
-    key.meta = s.length === 2;
-  } else if (s === " " || s === "\x1B ") {
-    key.name = "space";
-    key.meta = s.length === 2;
-  } else if (s === "\x00") {
-    key.name = "space";
-    key.ctrl = true;
-  } else if (s.length === 1 && s <= "\x1A") {
-    key.name = String.fromCharCode(s.charCodeAt(0) + 97 - 1);
-    key.ctrl = true;
-  } else if (s.length === 1 && s >= "0" && s <= "9") {
-    key.name = s;
-    key.number = true;
-  } else if (s.length === 1 && s >= "a" && s <= "z") {
-    key.name = s;
-  } else if (s.length === 1 && s >= "A" && s <= "Z") {
-    key.name = s.toLowerCase();
-    key.shift = true;
-  } else if (s.length === 1) {
-    key.name = s;
-  } else if (parts = metaKeyCodeRe.exec(s)) {
-    key.meta = true;
-    const char = parts[1];
-    const isUpperCase = /^[A-Z]$/.test(char);
-    if (char === "F") {
-      key.name = "right";
-    } else if (char === "B") {
-      key.name = "left";
-    } else if (isUpperCase) {
-      key.shift = true;
-      key.name = char;
-    } else {
-      key.name = char;
-    }
-  } else if (s.length === 2 && s[0] === "\x1B" && s[1] <= "\x1A") {
-    key.meta = true;
-    key.ctrl = true;
-    key.name = String.fromCharCode(s.charCodeAt(1) + 97 - 1);
-  } else if (parts = fnKeyRe.exec(s)) {
-    const segs = [...s];
-    if (segs[0] === "\x1B" && segs[1] === "\x1B") {
-      key.option = true;
-      key.meta = true;
-    }
-    const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
-    const modifier = parseInt(parts[3] || parts[5] || "1", 10) - 1;
-    key.ctrl = !!(modifier & 4);
-    key.meta = !!(modifier & 2);
-    key.shift = !!(modifier & 1);
-    key.option = !!(modifier & 2);
-    key.super = !!(modifier & 8);
-    key.hyper = !!(modifier & 16);
-    key.code = code;
-    const keyNameResult = keyName[code];
-    if (keyNameResult) {
-      key.name = keyNameResult;
-      key.shift = isShiftKey(code) || key.shift;
-      key.ctrl = isCtrlKey(code) || key.ctrl;
-    } else {
-      key.name = "";
-      key.code = undefined;
-    }
-  } else if (s === "\x1B[3~") {
-    key.name = "delete";
-    key.meta = false;
-    key.code = "[3~";
-  }
-  return key;
-};
-
 // src/lib/KeyHandler.ts
 import { EventEmitter } from "events";
+
 class KeyEvent {
   name;
   ctrl;
@@ -2441,11 +1850,14 @@ class KeyEvent {
 }
 
 class PasteEvent {
-  text;
+  type = "paste";
+  bytes;
+  metadata;
   _defaultPrevented = false;
   _propagationStopped = false;
-  constructor(text) {
-    this.text = text;
+  constructor(bytes, metadata) {
+    this.bytes = bytes;
+    this.metadata = metadata;
   }
   get defaultPrevented() {
     return this._defaultPrevented;
@@ -2462,16 +1874,7 @@ class PasteEvent {
 }
 
 class KeyHandler extends EventEmitter {
-  useKittyKeyboard;
-  constructor(useKittyKeyboard = false) {
-    super();
-    this.useKittyKeyboard = useKittyKeyboard;
-  }
-  processInput(data) {
-    const parsedKey = parseKeypress(data, { useKittyKeyboard: this.useKittyKeyboard });
-    if (!parsedKey) {
-      return false;
-    }
+  processParsedKey(parsedKey) {
     try {
       switch (parsedKey.eventType) {
         case "press":
@@ -2485,15 +1888,14 @@ class KeyHandler extends EventEmitter {
           break;
       }
     } catch (error) {
-      console.error(`[KeyHandler] Error processing input:`, error);
+      console.error(`[KeyHandler] Error processing parsed key:`, error);
       return true;
     }
     return true;
   }
-  processPaste(data) {
+  processPaste(bytes, metadata) {
     try {
-      const cleanedData = Bun.stripANSI(data);
-      this.emit("paste", new PasteEvent(cleanedData));
+      this.emit("paste", new PasteEvent(bytes, metadata));
     } catch (error) {
       console.error(`[KeyHandler] Error processing paste:`, error);
     }
@@ -2502,9 +1904,6 @@ class KeyHandler extends EventEmitter {
 
 class InternalKeyHandler extends KeyHandler {
   renderableHandlers = new Map;
-  constructor(useKittyKeyboard = false) {
-    super(useKittyKeyboard);
-  }
   emit(event, ...args) {
     return this.emitWithPriority(event, ...args);
   }
@@ -5448,785 +4847,1169 @@ var pallet_default = {
   }
 };
 
-// src/lib/ascii.font.ts
-var fonts = {
-  tiny: tiny_default,
-  block: block_default,
-  shade: shade_default,
-  slick: slick_default,
-  huge: huge_default,
-  grid: grid_default,
-  pallet: pallet_default
-};
-var parsedFonts = {};
-function parseColorTags(text) {
-  const segments = [];
-  let currentIndex = 0;
-  const colorTagRegex = /<c(\d+)>(.*?)<\/c\d+>/g;
-  let lastIndex = 0;
-  let match;
-  while ((match = colorTagRegex.exec(text)) !== null) {
-    if (match.index > lastIndex) {
-      const plainText = text.slice(lastIndex, match.index);
-      if (plainText) {
-        segments.push({ text: plainText, colorIndex: 0 });
-      }
+// src/lib/ascii.font.ts
+var fonts = {
+  tiny: tiny_default,
+  block: block_default,
+  shade: shade_default,
+  slick: slick_default,
+  huge: huge_default,
+  grid: grid_default,
+  pallet: pallet_default
+};
+var parsedFonts = {};
+function parseColorTags(text) {
+  const segments = [];
+  let currentIndex = 0;
+  const colorTagRegex = /<c(\d+)>(.*?)<\/c\d+>/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = colorTagRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      const plainText = text.slice(lastIndex, match.index);
+      if (plainText) {
+        segments.push({ text: plainText, colorIndex: 0 });
+      }
+    }
+    const colorIndex = parseInt(match[1]) - 1;
+    const taggedText = match[2];
+    segments.push({ text: taggedText, colorIndex: Math.max(0, colorIndex) });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    const remainingText = text.slice(lastIndex);
+    if (remainingText) {
+      segments.push({ text: remainingText, colorIndex: 0 });
+    }
+  }
+  return segments;
+}
+function getParsedFont(fontKey) {
+  if (!parsedFonts[fontKey]) {
+    const fontDef = fonts[fontKey];
+    const parsedChars = {};
+    for (const [char, lines] of Object.entries(fontDef.chars)) {
+      parsedChars[char] = lines.map((line) => parseColorTags(line));
+    }
+    parsedFonts[fontKey] = {
+      ...fontDef,
+      colors: fontDef.colors || 1,
+      chars: parsedChars
+    };
+  }
+  return parsedFonts[fontKey];
+}
+function measureText({ text, font = "tiny" }) {
+  const fontDef = getParsedFont(font);
+  if (!fontDef) {
+    console.warn(`Font '${font}' not found`);
+    return { width: 0, height: 0 };
+  }
+  let currentX = 0;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i].toUpperCase();
+    const charDef = fontDef.chars[char];
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "];
+      if (spaceChar && spaceChar[0]) {
+        let spaceWidth = 0;
+        for (const segment of spaceChar[0]) {
+          spaceWidth += segment.text.length;
+        }
+        currentX += spaceWidth;
+      } else {
+        currentX += 1;
+      }
+      continue;
+    }
+    let charWidth = 0;
+    if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length;
+      }
+    }
+    currentX += charWidth;
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size;
+    }
+  }
+  return {
+    width: currentX,
+    height: fontDef.lines
+  };
+}
+function getCharacterPositions(text, font = "tiny") {
+  const fontDef = getParsedFont(font);
+  if (!fontDef) {
+    return [0];
+  }
+  const positions = [0];
+  let currentX = 0;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i].toUpperCase();
+    const charDef = fontDef.chars[char];
+    let charWidth = 0;
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "];
+      if (spaceChar && spaceChar[0]) {
+        for (const segment of spaceChar[0]) {
+          charWidth += segment.text.length;
+        }
+      } else {
+        charWidth = 1;
+      }
+    } else if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length;
+      }
+    }
+    currentX += charWidth;
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size;
+    }
+    positions.push(currentX);
+  }
+  return positions;
+}
+function coordinateToCharacterIndex(x, text, font = "tiny") {
+  const positions = getCharacterPositions(text, font);
+  if (x < 0) {
+    return 0;
+  }
+  for (let i = 0;i < positions.length - 1; i++) {
+    const currentPos = positions[i];
+    const nextPos = positions[i + 1];
+    if (x >= currentPos && x < nextPos) {
+      const charMidpoint = currentPos + (nextPos - currentPos) / 2;
+      return x < charMidpoint ? i : i + 1;
+    }
+  }
+  if (positions.length > 0 && x >= positions[positions.length - 1]) {
+    return text.length;
+  }
+  return 0;
+}
+function renderFontToFrameBuffer(buffer, {
+  text,
+  x = 0,
+  y = 0,
+  color = [RGBA.fromInts(255, 255, 255, 255)],
+  backgroundColor = RGBA.fromInts(0, 0, 0, 255),
+  font = "tiny"
+}) {
+  const width = buffer.width;
+  const height = buffer.height;
+  const fontDef = getParsedFont(font);
+  if (!fontDef) {
+    console.warn(`Font '${font}' not found`);
+    return { width: 0, height: 0 };
+  }
+  const colors = Array.isArray(color) ? color : [color];
+  if (y < 0 || y + fontDef.lines > height) {
+    return { width: 0, height: fontDef.lines };
+  }
+  let currentX = x;
+  const startX = x;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i].toUpperCase();
+    const charDef = fontDef.chars[char];
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "];
+      if (spaceChar && spaceChar[0]) {
+        let spaceWidth = 0;
+        for (const segment of spaceChar[0]) {
+          spaceWidth += segment.text.length;
+        }
+        currentX += spaceWidth;
+      } else {
+        currentX += 1;
+      }
+      continue;
+    }
+    let charWidth = 0;
+    if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length;
+      }
+    }
+    if (currentX >= width)
+      break;
+    if (currentX + charWidth < 0) {
+      currentX += charWidth + fontDef.letterspace_size;
+      continue;
+    }
+    for (let lineIdx = 0;lineIdx < fontDef.lines && lineIdx < charDef.length; lineIdx++) {
+      const segments = charDef[lineIdx];
+      const renderY = y + lineIdx;
+      if (renderY >= 0 && renderY < height) {
+        let segmentX = currentX;
+        for (const segment of segments) {
+          const segmentColor = colors[segment.colorIndex] || colors[0];
+          for (let charIdx = 0;charIdx < segment.text.length; charIdx++) {
+            const renderX = segmentX + charIdx;
+            if (renderX >= 0 && renderX < width) {
+              const fontChar = segment.text[charIdx];
+              if (fontChar !== " ") {
+                buffer.setCellWithAlphaBlending(renderX, renderY, fontChar, parseColor(segmentColor), parseColor(backgroundColor));
+              }
+            }
+          }
+          segmentX += segment.text.length;
+        }
+      }
+    }
+    currentX += charWidth;
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size;
+    }
+  }
+  return {
+    width: currentX - startX,
+    height: fontDef.lines
+  };
+}
+
+// src/types.ts
+var TextAttributes = {
+  NONE: 0,
+  BOLD: 1 << 0,
+  DIM: 1 << 1,
+  ITALIC: 1 << 2,
+  UNDERLINE: 1 << 3,
+  BLINK: 1 << 4,
+  INVERSE: 1 << 5,
+  HIDDEN: 1 << 6,
+  STRIKETHROUGH: 1 << 7
+};
+var ATTRIBUTE_BASE_BITS = 8;
+var ATTRIBUTE_BASE_MASK = 255;
+function getBaseAttributes(attr) {
+  return attr & ATTRIBUTE_BASE_MASK;
+}
+var DebugOverlayCorner;
+((DebugOverlayCorner2) => {
+  DebugOverlayCorner2[DebugOverlayCorner2["topLeft"] = 0] = "topLeft";
+  DebugOverlayCorner2[DebugOverlayCorner2["topRight"] = 1] = "topRight";
+  DebugOverlayCorner2[DebugOverlayCorner2["bottomLeft"] = 2] = "bottomLeft";
+  DebugOverlayCorner2[DebugOverlayCorner2["bottomRight"] = 3] = "bottomRight";
+})(DebugOverlayCorner ||= {});
+
+// src/utils.ts
+function createTextAttributes({
+  bold = false,
+  italic = false,
+  underline = false,
+  dim = false,
+  blink = false,
+  inverse = false,
+  hidden = false,
+  strikethrough = false
+} = {}) {
+  let attributes = TextAttributes.NONE;
+  if (bold)
+    attributes |= TextAttributes.BOLD;
+  if (italic)
+    attributes |= TextAttributes.ITALIC;
+  if (underline)
+    attributes |= TextAttributes.UNDERLINE;
+  if (dim)
+    attributes |= TextAttributes.DIM;
+  if (blink)
+    attributes |= TextAttributes.BLINK;
+  if (inverse)
+    attributes |= TextAttributes.INVERSE;
+  if (hidden)
+    attributes |= TextAttributes.HIDDEN;
+  if (strikethrough)
+    attributes |= TextAttributes.STRIKETHROUGH;
+  return attributes;
+}
+var ATTRIBUTE_BASE_MASK2 = 255;
+var LINK_ID_SHIFT = 8;
+var LINK_ID_PAYLOAD_MASK = 16777215;
+function attributesWithLink(baseAttributes, linkId) {
+  const base = baseAttributes & ATTRIBUTE_BASE_MASK2;
+  const linkBits = (linkId & LINK_ID_PAYLOAD_MASK) << LINK_ID_SHIFT;
+  return base | linkBits;
+}
+function getLinkId(attributes) {
+  return attributes >>> LINK_ID_SHIFT & LINK_ID_PAYLOAD_MASK;
+}
+function visualizeRenderableTree(renderable, maxDepth = 10) {
+  function buildTreeLines(node, prefix = "", parentPrefix = "", isLastChild = true, depth = 0) {
+    if (depth >= maxDepth) {
+      return [`${prefix}${node.id} ... (max depth reached)`];
     }
-    const colorIndex = parseInt(match[1]) - 1;
-    const taggedText = match[2];
-    segments.push({ text: taggedText, colorIndex: Math.max(0, colorIndex) });
-    lastIndex = match.index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    const remainingText = text.slice(lastIndex);
-    if (remainingText) {
-      segments.push({ text: remainingText, colorIndex: 0 });
+    const lines = [];
+    const children = node.getChildren();
+    lines.push(`${prefix}${node.id}`);
+    if (children.length > 0) {
+      const lastChildIndex = children.length - 1;
+      children.forEach((child, index) => {
+        const childIsLast = index === lastChildIndex;
+        const connector = childIsLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const childPrefix = parentPrefix + (isLastChild ? "    " : "\u2502   ");
+        const childLines = buildTreeLines(child, childPrefix + connector, childPrefix, childIsLast, depth + 1);
+        lines.push(...childLines);
+      });
     }
+    return lines;
   }
-  return segments;
+  const treeLines = buildTreeLines(renderable);
+  console.log(`Renderable Tree:
+` + treeLines.join(`
+`));
 }
-function getParsedFont(fontKey) {
-  if (!parsedFonts[fontKey]) {
-    const fontDef = fonts[fontKey];
-    const parsedChars = {};
-    for (const [char, lines] of Object.entries(fontDef.chars)) {
-      parsedChars[char] = lines.map((line) => parseColorTags(line));
-    }
-    parsedFonts[fontKey] = {
-      ...fontDef,
-      colors: fontDef.colors || 1,
-      chars: parsedChars
-    };
+
+// src/lib/styled-text.ts
+var BrandedStyledText = Symbol.for("@opentui/core/StyledText");
+function isStyledText(obj) {
+  return obj && obj[BrandedStyledText];
+}
+
+class StyledText {
+  [BrandedStyledText] = true;
+  chunks;
+  constructor(chunks) {
+    this.chunks = chunks;
   }
-  return parsedFonts[fontKey];
 }
-function measureText({ text, font = "tiny" }) {
-  const fontDef = getParsedFont(font);
-  if (!fontDef) {
-    console.warn(`Font '${font}' not found`);
-    return { width: 0, height: 0 };
+function stringToStyledText(content) {
+  const chunk = {
+    __isChunk: true,
+    text: content
+  };
+  return new StyledText([chunk]);
+}
+function applyStyle(input, style) {
+  if (typeof input === "object" && "__isChunk" in input) {
+    const existingChunk = input;
+    const fg = style.fg ? parseColor(style.fg) : existingChunk.fg;
+    const bg = style.bg ? parseColor(style.bg) : existingChunk.bg;
+    const newAttrs = createTextAttributes(style);
+    const mergedAttrs = existingChunk.attributes ? existingChunk.attributes | newAttrs : newAttrs;
+    return {
+      __isChunk: true,
+      text: existingChunk.text,
+      fg,
+      bg,
+      attributes: mergedAttrs,
+      link: existingChunk.link
+    };
+  } else {
+    const plainTextStr = String(input);
+    const fg = style.fg ? parseColor(style.fg) : undefined;
+    const bg = style.bg ? parseColor(style.bg) : undefined;
+    const attributes = createTextAttributes(style);
+    return {
+      __isChunk: true,
+      text: plainTextStr,
+      fg,
+      bg,
+      attributes
+    };
   }
-  let currentX = 0;
-  for (let i = 0;i < text.length; i++) {
-    const char = text[i].toUpperCase();
-    const charDef = fontDef.chars[char];
-    if (!charDef) {
-      const spaceChar = fontDef.chars[" "];
-      if (spaceChar && spaceChar[0]) {
-        let spaceWidth = 0;
-        for (const segment of spaceChar[0]) {
-          spaceWidth += segment.text.length;
-        }
-        currentX += spaceWidth;
-      } else {
-        currentX += 1;
-      }
-      continue;
+}
+var black = (input) => applyStyle(input, { fg: "black" });
+var red = (input) => applyStyle(input, { fg: "red" });
+var green = (input) => applyStyle(input, { fg: "green" });
+var yellow = (input) => applyStyle(input, { fg: "yellow" });
+var blue = (input) => applyStyle(input, { fg: "blue" });
+var magenta = (input) => applyStyle(input, { fg: "magenta" });
+var cyan = (input) => applyStyle(input, { fg: "cyan" });
+var white = (input) => applyStyle(input, { fg: "white" });
+var brightBlack = (input) => applyStyle(input, { fg: "brightBlack" });
+var brightRed = (input) => applyStyle(input, { fg: "brightRed" });
+var brightGreen = (input) => applyStyle(input, { fg: "brightGreen" });
+var brightYellow = (input) => applyStyle(input, { fg: "brightYellow" });
+var brightBlue = (input) => applyStyle(input, { fg: "brightBlue" });
+var brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" });
+var brightCyan = (input) => applyStyle(input, { fg: "brightCyan" });
+var brightWhite = (input) => applyStyle(input, { fg: "brightWhite" });
+var bgBlack = (input) => applyStyle(input, { bg: "black" });
+var bgRed = (input) => applyStyle(input, { bg: "red" });
+var bgGreen = (input) => applyStyle(input, { bg: "green" });
+var bgYellow = (input) => applyStyle(input, { bg: "yellow" });
+var bgBlue = (input) => applyStyle(input, { bg: "blue" });
+var bgMagenta = (input) => applyStyle(input, { bg: "magenta" });
+var bgCyan = (input) => applyStyle(input, { bg: "cyan" });
+var bgWhite = (input) => applyStyle(input, { bg: "white" });
+var bold = (input) => applyStyle(input, { bold: true });
+var italic = (input) => applyStyle(input, { italic: true });
+var underline = (input) => applyStyle(input, { underline: true });
+var strikethrough = (input) => applyStyle(input, { strikethrough: true });
+var dim = (input) => applyStyle(input, { dim: true });
+var reverse = (input) => applyStyle(input, { reverse: true });
+var blink = (input) => applyStyle(input, { blink: true });
+var fg = (color) => (input) => applyStyle(input, { fg: color });
+var bg = (color) => (input) => applyStyle(input, { bg: color });
+var link = (url) => (input) => {
+  const chunk = typeof input === "object" && "__isChunk" in input ? input : {
+    __isChunk: true,
+    text: String(input)
+  };
+  return {
+    ...chunk,
+    link: { url }
+  };
+};
+function t(strings, ...values) {
+  const chunks = [];
+  for (let i = 0;i < strings.length; i++) {
+    const raw = strings[i];
+    if (raw) {
+      chunks.push({
+        __isChunk: true,
+        text: raw,
+        attributes: 0
+      });
     }
-    let charWidth = 0;
-    if (charDef[0]) {
-      for (const segment of charDef[0]) {
-        charWidth += segment.text.length;
+    const val = values[i];
+    if (typeof val === "object" && "__isChunk" in val) {
+      chunks.push(val);
+    } else if (val !== undefined) {
+      const plainTextStr = String(val);
+      chunks.push({
+        __isChunk: true,
+        text: plainTextStr,
+        attributes: 0
+      });
+    }
+  }
+  return new StyledText(chunks);
+}
+
+// src/lib/hast-styled-text.ts
+function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
+  const chunks = [];
+  if (node.type === "text") {
+    const stylesToMerge = parentStyles.length > 0 ? parentStyles : ["default"];
+    const mergedStyle = syntaxStyle.mergeStyles(...stylesToMerge);
+    chunks.push({
+      __isChunk: true,
+      text: node.value,
+      fg: mergedStyle.fg,
+      bg: mergedStyle.bg,
+      attributes: mergedStyle.attributes
+    });
+  } else if (node.type === "element") {
+    let currentStyles = [...parentStyles];
+    if (node.properties?.className) {
+      const classes = node.properties.className.split(" ");
+      for (const cls of classes) {
+        currentStyles.push(cls);
       }
     }
-    currentX += charWidth;
-    if (i < text.length - 1) {
-      currentX += fontDef.letterspace_size;
+    for (const child of node.children) {
+      chunks.push(...hastToTextChunks(child, syntaxStyle, currentStyles));
     }
   }
-  return {
-    width: currentX,
-    height: fontDef.lines
-  };
+  return chunks;
 }
-function getCharacterPositions(text, font = "tiny") {
-  const fontDef = getParsedFont(font);
-  if (!fontDef) {
-    return [0];
+function hastToStyledText(hast, syntaxStyle) {
+  const chunks = hastToTextChunks(hast, syntaxStyle);
+  return new StyledText(chunks);
+}
+
+// src/lib/clock.ts
+class SystemClock {
+  now() {
+    return Date.now();
   }
-  const positions = [0];
-  let currentX = 0;
-  for (let i = 0;i < text.length; i++) {
-    const char = text[i].toUpperCase();
-    const charDef = fontDef.chars[char];
-    let charWidth = 0;
-    if (!charDef) {
-      const spaceChar = fontDef.chars[" "];
-      if (spaceChar && spaceChar[0]) {
-        for (const segment of spaceChar[0]) {
-          charWidth += segment.text.length;
-        }
-      } else {
-        charWidth = 1;
-      }
-    } else if (charDef[0]) {
-      for (const segment of charDef[0]) {
-        charWidth += segment.text.length;
-      }
-    }
-    currentX += charWidth;
-    if (i < text.length - 1) {
-      currentX += fontDef.letterspace_size;
-    }
-    positions.push(currentX);
+  setTimeout(fn, delayMs) {
+    return globalThis.setTimeout(fn, delayMs);
+  }
+  clearTimeout(handle) {
+    globalThis.clearTimeout(handle);
+  }
+  setInterval(fn, delayMs) {
+    return globalThis.setInterval(fn, delayMs);
+  }
+  clearInterval(handle) {
+    globalThis.clearInterval(handle);
   }
-  return positions;
 }
-function coordinateToCharacterIndex(x, text, font = "tiny") {
-  const positions = getCharacterPositions(text, font);
-  if (x < 0) {
-    return 0;
+
+// src/lib/parse.keypress.ts
+import { Buffer as Buffer2 } from "buffer";
+
+// src/lib/parse.keypress-kitty.ts
+var kittyKeyMap = {
+  27: "escape",
+  9: "tab",
+  13: "return",
+  127: "backspace",
+  57344: "escape",
+  57345: "return",
+  57346: "tab",
+  57347: "backspace",
+  57348: "insert",
+  57349: "delete",
+  57350: "left",
+  57351: "right",
+  57352: "up",
+  57353: "down",
+  57354: "pageup",
+  57355: "pagedown",
+  57356: "home",
+  57357: "end",
+  57358: "capslock",
+  57359: "scrolllock",
+  57360: "numlock",
+  57361: "printscreen",
+  57362: "pause",
+  57363: "menu",
+  57364: "f1",
+  57365: "f2",
+  57366: "f3",
+  57367: "f4",
+  57368: "f5",
+  57369: "f6",
+  57370: "f7",
+  57371: "f8",
+  57372: "f9",
+  57373: "f10",
+  57374: "f11",
+  57375: "f12",
+  57376: "f13",
+  57377: "f14",
+  57378: "f15",
+  57379: "f16",
+  57380: "f17",
+  57381: "f18",
+  57382: "f19",
+  57383: "f20",
+  57384: "f21",
+  57385: "f22",
+  57386: "f23",
+  57387: "f24",
+  57388: "f25",
+  57389: "f26",
+  57390: "f27",
+  57391: "f28",
+  57392: "f29",
+  57393: "f30",
+  57394: "f31",
+  57395: "f32",
+  57396: "f33",
+  57397: "f34",
+  57398: "f35",
+  57399: "kp0",
+  57400: "kp1",
+  57401: "kp2",
+  57402: "kp3",
+  57403: "kp4",
+  57404: "kp5",
+  57405: "kp6",
+  57406: "kp7",
+  57407: "kp8",
+  57408: "kp9",
+  57409: "kpdecimal",
+  57410: "kpdivide",
+  57411: "kpmultiply",
+  57412: "kpminus",
+  57413: "kpplus",
+  57414: "kpenter",
+  57415: "kpequal",
+  57416: "kpseparator",
+  57417: "kpleft",
+  57418: "kpright",
+  57419: "kpup",
+  57420: "kpdown",
+  57421: "kppageup",
+  57422: "kppagedown",
+  57423: "kphome",
+  57424: "kpend",
+  57425: "kpinsert",
+  57426: "kpdelete",
+  57427: "clear",
+  57428: "mediaplay",
+  57429: "mediapause",
+  57430: "mediaplaypause",
+  57431: "mediareverse",
+  57432: "mediastop",
+  57433: "mediafastforward",
+  57434: "mediarewind",
+  57435: "medianext",
+  57436: "mediaprev",
+  57437: "mediarecord",
+  57438: "volumedown",
+  57439: "volumeup",
+  57440: "mute",
+  57441: "leftshift",
+  57442: "leftctrl",
+  57443: "leftalt",
+  57444: "leftsuper",
+  57445: "lefthyper",
+  57446: "leftmeta",
+  57447: "rightshift",
+  57448: "rightctrl",
+  57449: "rightalt",
+  57450: "rightsuper",
+  57451: "righthyper",
+  57452: "rightmeta",
+  57453: "iso_level3_shift",
+  57454: "iso_level5_shift"
+};
+function fromKittyMods(mod) {
+  return {
+    shift: !!(mod & 1),
+    alt: !!(mod & 2),
+    ctrl: !!(mod & 4),
+    super: !!(mod & 8),
+    hyper: !!(mod & 16),
+    meta: !!(mod & 32),
+    capsLock: !!(mod & 64),
+    numLock: !!(mod & 128)
+  };
+}
+var functionalKeyMap = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+  H: "home",
+  F: "end",
+  E: "clear",
+  P: "f1",
+  Q: "f2",
+  S: "f4"
+};
+var tildeKeyMap = {
+  "1": "home",
+  "2": "insert",
+  "3": "delete",
+  "4": "end",
+  "5": "pageup",
+  "6": "pagedown",
+  "7": "home",
+  "8": "end",
+  "11": "f1",
+  "12": "f2",
+  "13": "f3",
+  "14": "f4",
+  "15": "f5",
+  "17": "f6",
+  "18": "f7",
+  "19": "f8",
+  "20": "f9",
+  "21": "f10",
+  "23": "f11",
+  "24": "f12",
+  "29": "menu",
+  "57427": "clear"
+};
+function parseKittySpecialKey(sequence) {
+  const specialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Z~])$/;
+  const match = specialKeyRe.exec(sequence);
+  if (!match)
+    return null;
+  const keyNumOrOne = match[1];
+  const modifierStr = match[2];
+  const eventTypeStr = match[3];
+  const terminator = match[4];
+  let keyName;
+  if (terminator === "~") {
+    keyName = tildeKeyMap[keyNumOrOne];
+  } else {
+    if (keyNumOrOne !== "1")
+      return null;
+    keyName = functionalKeyMap[terminator];
   }
-  for (let i = 0;i < positions.length - 1; i++) {
-    const currentPos = positions[i];
-    const nextPos = positions[i + 1];
-    if (x >= currentPos && x < nextPos) {
-      const charMidpoint = currentPos + (nextPos - currentPos) / 2;
-      return x < charMidpoint ? i : i + 1;
+  if (!keyName)
+    return null;
+  const key = {
+    name: keyName,
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    number: false,
+    sequence,
+    raw: sequence,
+    eventType: "press",
+    source: "kitty",
+    super: false,
+    hyper: false,
+    capsLock: false,
+    numLock: false
+  };
+  if (modifierStr) {
+    const modifierMask = parseInt(modifierStr, 10);
+    if (!isNaN(modifierMask) && modifierMask > 1) {
+      const mods = fromKittyMods(modifierMask - 1);
+      key.shift = mods.shift;
+      key.ctrl = mods.ctrl;
+      key.meta = mods.alt || mods.meta;
+      key.option = mods.alt;
+      key.super = mods.super;
+      key.hyper = mods.hyper;
+      key.capsLock = mods.capsLock;
+      key.numLock = mods.numLock;
     }
   }
-  if (positions.length > 0 && x >= positions[positions.length - 1]) {
-    return text.length;
+  if (eventTypeStr === "1" || !eventTypeStr) {
+    key.eventType = "press";
+  } else if (eventTypeStr === "2") {
+    key.eventType = "press";
+    key.repeated = true;
+  } else if (eventTypeStr === "3") {
+    key.eventType = "release";
   }
-  return 0;
+  return key;
 }
-function renderFontToFrameBuffer(buffer, {
-  text,
-  x = 0,
-  y = 0,
-  color = [RGBA.fromInts(255, 255, 255, 255)],
-  backgroundColor = RGBA.fromInts(0, 0, 0, 255),
-  font = "tiny"
-}) {
-  const width = buffer.width;
-  const height = buffer.height;
-  const fontDef = getParsedFont(font);
-  if (!fontDef) {
-    console.warn(`Font '${font}' not found`);
-    return { width: 0, height: 0 };
-  }
-  const colors = Array.isArray(color) ? color : [color];
-  if (y < 0 || y + fontDef.lines > height) {
-    return { width: 0, height: fontDef.lines };
-  }
-  let currentX = x;
-  const startX = x;
-  for (let i = 0;i < text.length; i++) {
-    const char = text[i].toUpperCase();
-    const charDef = fontDef.chars[char];
-    if (!charDef) {
-      const spaceChar = fontDef.chars[" "];
-      if (spaceChar && spaceChar[0]) {
-        let spaceWidth = 0;
-        for (const segment of spaceChar[0]) {
-          spaceWidth += segment.text.length;
-        }
-        currentX += spaceWidth;
-      } else {
-        currentX += 1;
-      }
-      continue;
-    }
-    let charWidth = 0;
-    if (charDef[0]) {
-      for (const segment of charDef[0]) {
-        charWidth += segment.text.length;
-      }
+function parseKittyKeyboard(sequence) {
+  const specialResult = parseKittySpecialKey(sequence);
+  if (specialResult)
+    return specialResult;
+  const kittyRe = /^\x1b\[([^\x1b]+)u$/;
+  const match = kittyRe.exec(sequence);
+  if (!match)
+    return null;
+  const params = match[1];
+  const fields = params.split(";");
+  if (fields.length < 1)
+    return null;
+  const key = {
+    name: "",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    number: false,
+    sequence,
+    raw: sequence,
+    eventType: "press",
+    source: "kitty",
+    super: false,
+    hyper: false,
+    capsLock: false,
+    numLock: false
+  };
+  let text = "";
+  const field1 = fields[0]?.split(":") || [];
+  const codepointStr = field1[0];
+  if (!codepointStr)
+    return null;
+  const codepoint = parseInt(codepointStr, 10);
+  if (isNaN(codepoint))
+    return null;
+  let shiftedCodepoint;
+  let baseCodepoint;
+  if (field1[1]) {
+    const shifted = parseInt(field1[1], 10);
+    if (!isNaN(shifted) && shifted > 0 && shifted <= 1114111) {
+      shiftedCodepoint = shifted;
     }
-    if (currentX >= width)
-      break;
-    if (currentX + charWidth < 0) {
-      currentX += charWidth + fontDef.letterspace_size;
-      continue;
+  }
+  if (field1[2]) {
+    const base = parseInt(field1[2], 10);
+    if (!isNaN(base) && base > 0 && base <= 1114111) {
+      baseCodepoint = base;
     }
-    for (let lineIdx = 0;lineIdx < fontDef.lines && lineIdx < charDef.length; lineIdx++) {
-      const segments = charDef[lineIdx];
-      const renderY = y + lineIdx;
-      if (renderY >= 0 && renderY < height) {
-        let segmentX = currentX;
-        for (const segment of segments) {
-          const segmentColor = colors[segment.colorIndex] || colors[0];
-          for (let charIdx = 0;charIdx < segment.text.length; charIdx++) {
-            const renderX = segmentX + charIdx;
-            if (renderX >= 0 && renderX < width) {
-              const fontChar = segment.text[charIdx];
-              if (fontChar !== " ") {
-                buffer.setCellWithAlphaBlending(renderX, renderY, fontChar, parseColor(segmentColor), parseColor(backgroundColor));
-              }
-            }
-          }
-          segmentX += segment.text.length;
-        }
+  }
+  const knownKey = kittyKeyMap[codepoint];
+  if (knownKey) {
+    key.name = knownKey;
+    key.code = `[${codepoint}u`;
+  } else if (codepoint === 0) {
+    key.name = "";
+  } else {
+    if (codepoint > 0 && codepoint <= 1114111) {
+      const char = String.fromCodePoint(codepoint);
+      key.name = char;
+      if (baseCodepoint) {
+        key.baseCode = baseCodepoint;
       }
-    }
-    currentX += charWidth;
-    if (i < text.length - 1) {
-      currentX += fontDef.letterspace_size;
+    } else {
+      return null;
     }
   }
-  return {
-    width: currentX - startX,
-    height: fontDef.lines
-  };
-}
-
-// src/types.ts
-var TextAttributes = {
-  NONE: 0,
-  BOLD: 1 << 0,
-  DIM: 1 << 1,
-  ITALIC: 1 << 2,
-  UNDERLINE: 1 << 3,
-  BLINK: 1 << 4,
-  INVERSE: 1 << 5,
-  HIDDEN: 1 << 6,
-  STRIKETHROUGH: 1 << 7
-};
-var ATTRIBUTE_BASE_BITS = 8;
-var ATTRIBUTE_BASE_MASK = 255;
-function getBaseAttributes(attr) {
-  return attr & ATTRIBUTE_BASE_MASK;
-}
-var DebugOverlayCorner;
-((DebugOverlayCorner2) => {
-  DebugOverlayCorner2[DebugOverlayCorner2["topLeft"] = 0] = "topLeft";
-  DebugOverlayCorner2[DebugOverlayCorner2["topRight"] = 1] = "topRight";
-  DebugOverlayCorner2[DebugOverlayCorner2["bottomLeft"] = 2] = "bottomLeft";
-  DebugOverlayCorner2[DebugOverlayCorner2["bottomRight"] = 3] = "bottomRight";
-})(DebugOverlayCorner ||= {});
-
-// src/utils.ts
-function createTextAttributes({
-  bold = false,
-  italic = false,
-  underline = false,
-  dim = false,
-  blink = false,
-  inverse = false,
-  hidden = false,
-  strikethrough = false
-} = {}) {
-  let attributes = TextAttributes.NONE;
-  if (bold)
-    attributes |= TextAttributes.BOLD;
-  if (italic)
-    attributes |= TextAttributes.ITALIC;
-  if (underline)
-    attributes |= TextAttributes.UNDERLINE;
-  if (dim)
-    attributes |= TextAttributes.DIM;
-  if (blink)
-    attributes |= TextAttributes.BLINK;
-  if (inverse)
-    attributes |= TextAttributes.INVERSE;
-  if (hidden)
-    attributes |= TextAttributes.HIDDEN;
-  if (strikethrough)
-    attributes |= TextAttributes.STRIKETHROUGH;
-  return attributes;
-}
-var ATTRIBUTE_BASE_MASK2 = 255;
-var LINK_ID_SHIFT = 8;
-var LINK_ID_PAYLOAD_MASK = 16777215;
-function attributesWithLink(baseAttributes, linkId) {
-  const base = baseAttributes & ATTRIBUTE_BASE_MASK2;
-  const linkBits = (linkId & LINK_ID_PAYLOAD_MASK) << LINK_ID_SHIFT;
-  return base | linkBits;
-}
-function getLinkId(attributes) {
-  return attributes >>> LINK_ID_SHIFT & LINK_ID_PAYLOAD_MASK;
-}
-function visualizeRenderableTree(renderable, maxDepth = 10) {
-  function buildTreeLines(node, prefix = "", parentPrefix = "", isLastChild = true, depth = 0) {
-    if (depth >= maxDepth) {
-      return [`${prefix}${node.id} ... (max depth reached)`];
+  if (fields[1]) {
+    const field2 = fields[1].split(":");
+    const modifierStr = field2[0];
+    const eventTypeStr = field2[1];
+    if (modifierStr) {
+      const modifierMask = parseInt(modifierStr, 10);
+      if (!isNaN(modifierMask) && modifierMask > 1) {
+        const mods = fromKittyMods(modifierMask - 1);
+        key.shift = mods.shift;
+        key.ctrl = mods.ctrl;
+        key.meta = mods.alt || mods.meta;
+        key.option = mods.alt;
+        key.super = mods.super;
+        key.hyper = mods.hyper;
+        key.capsLock = mods.capsLock;
+        key.numLock = mods.numLock;
+      }
     }
-    const lines = [];
-    const children = node.getChildren();
-    lines.push(`${prefix}${node.id}`);
-    if (children.length > 0) {
-      const lastChildIndex = children.length - 1;
-      children.forEach((child, index) => {
-        const childIsLast = index === lastChildIndex;
-        const connector = childIsLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-        const childPrefix = parentPrefix + (isLastChild ? "    " : "\u2502   ");
-        const childLines = buildTreeLines(child, childPrefix + connector, childPrefix, childIsLast, depth + 1);
-        lines.push(...childLines);
-      });
+    if (eventTypeStr === "1" || !eventTypeStr) {
+      key.eventType = "press";
+    } else if (eventTypeStr === "2") {
+      key.eventType = "press";
+      key.repeated = true;
+    } else if (eventTypeStr === "3") {
+      key.eventType = "release";
+    } else {
+      key.eventType = "press";
     }
-    return lines;
-  }
-  const treeLines = buildTreeLines(renderable);
-  console.log(`Renderable Tree:
-` + treeLines.join(`
-`));
-}
-
-// src/lib/styled-text.ts
-var BrandedStyledText = Symbol.for("@opentui/core/StyledText");
-function isStyledText(obj) {
-  return obj && obj[BrandedStyledText];
-}
-
-class StyledText {
-  [BrandedStyledText] = true;
-  chunks;
-  constructor(chunks) {
-    this.chunks = chunks;
   }
-}
-function stringToStyledText(content) {
-  const chunk = {
-    __isChunk: true,
-    text: content
-  };
-  return new StyledText([chunk]);
-}
-function applyStyle(input, style) {
-  if (typeof input === "object" && "__isChunk" in input) {
-    const existingChunk = input;
-    const fg = style.fg ? parseColor(style.fg) : existingChunk.fg;
-    const bg = style.bg ? parseColor(style.bg) : existingChunk.bg;
-    const newAttrs = createTextAttributes(style);
-    const mergedAttrs = existingChunk.attributes ? existingChunk.attributes | newAttrs : newAttrs;
-    return {
-      __isChunk: true,
-      text: existingChunk.text,
-      fg,
-      bg,
-      attributes: mergedAttrs,
-      link: existingChunk.link
-    };
-  } else {
-    const plainTextStr = String(input);
-    const fg = style.fg ? parseColor(style.fg) : undefined;
-    const bg = style.bg ? parseColor(style.bg) : undefined;
-    const attributes = createTextAttributes(style);
-    return {
-      __isChunk: true,
-      text: plainTextStr,
-      fg,
-      bg,
-      attributes
-    };
+  if (fields[2]) {
+    const codepoints = fields[2].split(":");
+    for (const cpStr of codepoints) {
+      const cp = parseInt(cpStr, 10);
+      if (!isNaN(cp) && cp > 0 && cp <= 1114111) {
+        text += String.fromCodePoint(cp);
+      }
+    }
   }
-}
-var black = (input) => applyStyle(input, { fg: "black" });
-var red = (input) => applyStyle(input, { fg: "red" });
-var green = (input) => applyStyle(input, { fg: "green" });
-var yellow = (input) => applyStyle(input, { fg: "yellow" });
-var blue = (input) => applyStyle(input, { fg: "blue" });
-var magenta = (input) => applyStyle(input, { fg: "magenta" });
-var cyan = (input) => applyStyle(input, { fg: "cyan" });
-var white = (input) => applyStyle(input, { fg: "white" });
-var brightBlack = (input) => applyStyle(input, { fg: "brightBlack" });
-var brightRed = (input) => applyStyle(input, { fg: "brightRed" });
-var brightGreen = (input) => applyStyle(input, { fg: "brightGreen" });
-var brightYellow = (input) => applyStyle(input, { fg: "brightYellow" });
-var brightBlue = (input) => applyStyle(input, { fg: "brightBlue" });
-var brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" });
-var brightCyan = (input) => applyStyle(input, { fg: "brightCyan" });
-var brightWhite = (input) => applyStyle(input, { fg: "brightWhite" });
-var bgBlack = (input) => applyStyle(input, { bg: "black" });
-var bgRed = (input) => applyStyle(input, { bg: "red" });
-var bgGreen = (input) => applyStyle(input, { bg: "green" });
-var bgYellow = (input) => applyStyle(input, { bg: "yellow" });
-var bgBlue = (input) => applyStyle(input, { bg: "blue" });
-var bgMagenta = (input) => applyStyle(input, { bg: "magenta" });
-var bgCyan = (input) => applyStyle(input, { bg: "cyan" });
-var bgWhite = (input) => applyStyle(input, { bg: "white" });
-var bold = (input) => applyStyle(input, { bold: true });
-var italic = (input) => applyStyle(input, { italic: true });
-var underline = (input) => applyStyle(input, { underline: true });
-var strikethrough = (input) => applyStyle(input, { strikethrough: true });
-var dim = (input) => applyStyle(input, { dim: true });
-var reverse = (input) => applyStyle(input, { reverse: true });
-var blink = (input) => applyStyle(input, { blink: true });
-var fg = (color) => (input) => applyStyle(input, { fg: color });
-var bg = (color) => (input) => applyStyle(input, { bg: color });
-var link = (url) => (input) => {
-  const chunk = typeof input === "object" && "__isChunk" in input ? input : {
-    __isChunk: true,
-    text: String(input)
-  };
-  return {
-    ...chunk,
-    link: { url }
-  };
-};
-function t(strings, ...values) {
-  const chunks = [];
-  for (let i = 0;i < strings.length; i++) {
-    const raw = strings[i];
-    if (raw) {
-      chunks.push({
-        __isChunk: true,
-        text: raw,
-        attributes: 0
-      });
+  if (text === "") {
+    const isPrintable = key.name.length > 0 && !kittyKeyMap[codepoint];
+    if (isPrintable) {
+      if (key.shift && shiftedCodepoint) {
+        text = String.fromCodePoint(shiftedCodepoint);
+      } else if (key.shift && key.name.length === 1) {
+        text = key.name.toLocaleUpperCase();
+      } else {
+        text = key.name;
+      }
     }
-    const val = values[i];
-    if (typeof val === "object" && "__isChunk" in val) {
-      chunks.push(val);
-    } else if (val !== undefined) {
-      const plainTextStr = String(val);
-      chunks.push({
-        __isChunk: true,
-        text: plainTextStr,
-        attributes: 0
-      });
+  }
+  if (key.name === " " && key.shift && !key.ctrl && !key.meta) {
+    text = " ";
+  }
+  if (text) {
+    if (codepoint === 0) {
+      key.name = text;
     }
+    key.sequence = text;
   }
-  return new StyledText(chunks);
+  if (codepoint === 0 && text === "") {
+    return null;
+  }
+  return key;
 }
 
-// src/lib/hast-styled-text.ts
-function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
-  const chunks = [];
-  if (node.type === "text") {
-    const stylesToMerge = parentStyles.length > 0 ? parentStyles : ["default"];
-    const mergedStyle = syntaxStyle.mergeStyles(...stylesToMerge);
-    chunks.push({
-      __isChunk: true,
-      text: node.value,
-      fg: mergedStyle.fg,
-      bg: mergedStyle.bg,
-      attributes: mergedStyle.attributes
-    });
-  } else if (node.type === "element") {
-    let currentStyles = [...parentStyles];
-    if (node.properties?.className) {
-      const classes = node.properties.className.split(" ");
-      for (const cls of classes) {
-        currentStyles.push(cls);
-      }
-    }
-    for (const child of node.children) {
-      chunks.push(...hastToTextChunks(child, syntaxStyle, currentStyles));
+// src/lib/parse.keypress.ts
+var metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
+var fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+var keyName = {
+  OP: "f1",
+  OQ: "f2",
+  OR: "f3",
+  OS: "f4",
+  "[11~": "f1",
+  "[12~": "f2",
+  "[13~": "f3",
+  "[14~": "f4",
+  "[[A": "f1",
+  "[[B": "f2",
+  "[[C": "f3",
+  "[[D": "f4",
+  "[[E": "f5",
+  "[15~": "f5",
+  "[17~": "f6",
+  "[18~": "f7",
+  "[19~": "f8",
+  "[20~": "f9",
+  "[21~": "f10",
+  "[23~": "f11",
+  "[24~": "f12",
+  "[29~": "menu",
+  "[57427~": "clear",
+  "[A": "up",
+  "[B": "down",
+  "[C": "right",
+  "[D": "left",
+  "[E": "clear",
+  "[F": "end",
+  "[H": "home",
+  "[P": "f1",
+  "[Q": "f2",
+  "[S": "f4",
+  OA: "up",
+  OB: "down",
+  OC: "right",
+  OD: "left",
+  OE: "clear",
+  OF: "end",
+  OH: "home",
+  "[1~": "home",
+  "[2~": "insert",
+  "[3~": "delete",
+  "[4~": "end",
+  "[5~": "pageup",
+  "[6~": "pagedown",
+  "[[5~": "pageup",
+  "[[6~": "pagedown",
+  "[7~": "home",
+  "[8~": "end",
+  "[a": "up",
+  "[b": "down",
+  "[c": "right",
+  "[d": "left",
+  "[e": "clear",
+  f: "right",
+  b: "left",
+  p: "up",
+  n: "down",
+  "[2$": "insert",
+  "[3$": "delete",
+  "[5$": "pageup",
+  "[6$": "pagedown",
+  "[7$": "home",
+  "[8$": "end",
+  Oa: "up",
+  Ob: "down",
+  Oc: "right",
+  Od: "left",
+  Oe: "clear",
+  "[2^": "insert",
+  "[3^": "delete",
+  "[5^": "pageup",
+  "[6^": "pagedown",
+  "[7^": "home",
+  "[8^": "end",
+  "[Z": "tab"
+};
+var nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
+var isShiftKey = (code) => {
+  return ["[a", "[b", "[c", "[d", "[e", "[2$", "[3$", "[5$", "[6$", "[7$", "[8$", "[Z"].includes(code);
+};
+var isCtrlKey = (code) => {
+  return ["Oa", "Ob", "Oc", "Od", "Oe", "[2^", "[3^", "[5^", "[6^", "[7^", "[8^"].includes(code);
+};
+var modifyOtherKeysRe = /^\x1b\[27;(\d+);(\d+)~$/;
+var parseKeypress = (s = "", options = {}) => {
+  let parts;
+  if (Buffer2.isBuffer(s)) {
+    if (s[0] > 127 && s[1] === undefined) {
+      s[0] -= 128;
+      s = "\x1B" + String(s);
+    } else {
+      s = String(s);
     }
+  } else if (s !== undefined && typeof s !== "string") {
+    s = String(s);
+  } else if (!s) {
+    s = "";
   }
-  return chunks;
-}
-function hastToStyledText(hast, syntaxStyle) {
-  const chunks = hastToTextChunks(hast, syntaxStyle);
-  return new StyledText(chunks);
-}
-
-// src/lib/scroll-acceleration.ts
-class LinearScrollAccel {
-  tick(_now) {
-    return 1;
-  }
-  reset() {}
-}
-
-class MacOSScrollAccel {
-  opts;
-  lastTickTime = 0;
-  velocityHistory = [];
-  historySize = 3;
-  streakTimeout = 150;
-  minTickInterval = 6;
-  constructor(opts = {}) {
-    this.opts = opts;
+  if (/^\x1b\[<\d+;\d+;\d+[Mm]$/.test(s)) {
+    return null;
   }
-  tick(now = Date.now()) {
-    const A = this.opts.A ?? 0.8;
-    const tau = this.opts.tau ?? 3;
-    const maxMultiplier = this.opts.maxMultiplier ?? 6;
-    const dt = this.lastTickTime ? now - this.lastTickTime : Infinity;
-    if (dt === Infinity || dt > this.streakTimeout) {
-      this.lastTickTime = now;
-      this.velocityHistory = [];
-      return 1;
-    }
-    if (dt < this.minTickInterval) {
-      return 1;
-    }
-    this.lastTickTime = now;
-    this.velocityHistory.push(dt);
-    if (this.velocityHistory.length > this.historySize) {
-      this.velocityHistory.shift();
-    }
-    const avgInterval = this.velocityHistory.reduce((a, b) => a + b, 0) / this.velocityHistory.length;
-    const referenceInterval = 100;
-    const velocity = referenceInterval / avgInterval;
-    const x = velocity / tau;
-    const multiplier = 1 + A * (Math.exp(x) - 1);
-    return Math.min(multiplier, maxMultiplier);
+  if (/^\[<\d+;\d+;\d+[Mm]$/.test(s)) {
+    return null;
   }
-  reset() {
-    this.lastTickTime = 0;
-    this.velocityHistory = [];
+  if (/^\x1b\[<[\d;]*$/.test(s)) {
+    return null;
   }
-}
-
-// src/lib/stdin-buffer.ts
-import { EventEmitter as EventEmitter2 } from "events";
-var ESC = "\x1B";
-var BRACKETED_PASTE_START = "\x1B[200~";
-var BRACKETED_PASTE_END = "\x1B[201~";
-function isCompleteSequence(data) {
-  if (!data.startsWith(ESC)) {
-    return "not-escape";
+  if (/^\[<[\d;]*$/.test(s)) {
+    return null;
   }
-  if (data.length === 1) {
-    return "incomplete";
+  if (s.startsWith("\x1B[M") && s.length >= 6) {
+    return null;
   }
-  const afterEsc = data.slice(1);
-  if (afterEsc.startsWith(ESC)) {
-    return isCompleteSequence(afterEsc);
+  if (/^\x1b\[\d+;\d+;\d+t$/.test(s)) {
+    return null;
   }
-  if (afterEsc.startsWith("[")) {
-    if (afterEsc.startsWith("[M")) {
-      return data.length >= 6 ? "complete" : "incomplete";
-    }
-    return isCompleteCsiSequence(data);
+  if (/^\x1b\[\d+;\d+R$/.test(s)) {
+    return null;
   }
-  if (afterEsc.startsWith("]")) {
-    return isCompleteOscSequence(data);
+  if (/^\x1b\[\?[\d;]+c$/.test(s)) {
+    return null;
   }
-  if (afterEsc.startsWith("P")) {
-    return isCompleteDcsSequence(data);
+  if (/^\x1b\[\?[\d;]+\$y$/.test(s)) {
+    return null;
   }
-  if (afterEsc.startsWith("_")) {
-    return isCompleteApcSequence(data);
+  if (s === "\x1B[I" || s === "\x1B[O") {
+    return null;
   }
-  if (afterEsc.startsWith("O")) {
-    return afterEsc.length >= 2 ? "complete" : "incomplete";
+  if (/^\x1b\][\d;].*(\x1b\\|\x07)$/.test(s)) {
+    return null;
   }
-  if (afterEsc.length === 1) {
-    return "complete";
+  if (s === "\x1B[200~" || s === "\x1B[201~") {
+    return null;
   }
-  return "complete";
-}
-function isCompleteCsiSequence(data) {
-  if (!data.startsWith(ESC + "[")) {
-    return "complete";
-  }
-  if (data.length < 3) {
-    return "incomplete";
-  }
-  const payload = data.slice(2);
-  const lastChar = payload[payload.length - 1];
-  const lastCharCode = lastChar.charCodeAt(0);
-  if (lastCharCode >= 64 && lastCharCode <= 126) {
-    if (payload.startsWith("<")) {
-      const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
-      if (mouseMatch) {
-        return "complete";
-      }
-      if (lastChar === "M" || lastChar === "m") {
-        const parts = payload.slice(1, -1).split(";");
-        if (parts.length === 3 && parts.every((p) => /^\d+$/.test(p))) {
-          return "complete";
-        }
-      }
-      return "incomplete";
+  const key = {
+    name: "",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    number: false,
+    sequence: s,
+    raw: s,
+    eventType: "press",
+    source: "raw"
+  };
+  key.sequence = key.sequence || s || key.name;
+  if (options.useKittyKeyboard) {
+    const kittyResult = parseKittyKeyboard(s);
+    if (kittyResult) {
+      return kittyResult;
     }
-    return "complete";
-  }
-  return "incomplete";
-}
-function isCompleteOscSequence(data) {
-  if (!data.startsWith(ESC + "]")) {
-    return "complete";
-  }
-  if (data.endsWith(ESC + "\\") || data.endsWith("\x07")) {
-    return "complete";
-  }
-  return "incomplete";
-}
-function isCompleteDcsSequence(data) {
-  if (!data.startsWith(ESC + "P")) {
-    return "complete";
-  }
-  if (data.endsWith(ESC + "\\")) {
-    return "complete";
-  }
-  return "incomplete";
-}
-function isCompleteApcSequence(data) {
-  if (!data.startsWith(ESC + "_")) {
-    return "complete";
-  }
-  if (data.endsWith(ESC + "\\")) {
-    return "complete";
   }
-  return "incomplete";
-}
-function isNestedEscapeSequenceStart(char) {
-  return char === "[" || char === "]" || char === "O" || char === "N" || char === "P" || char === "_";
-}
-function extractCompleteSequences(buffer) {
-  const sequences = [];
-  let pos = 0;
-  while (pos < buffer.length) {
-    const remaining = buffer.slice(pos);
-    if (remaining.startsWith(ESC)) {
-      let seqEnd = 1;
-      while (seqEnd <= remaining.length) {
-        const candidate = remaining.slice(0, seqEnd);
-        const status = isCompleteSequence(candidate);
-        if (status === "complete") {
-          sequences.push(candidate);
-          pos += seqEnd;
-          break;
-        } else if (status === "incomplete") {
-          if (candidate === ESC + ESC) {
-            const nextChar = remaining[seqEnd];
-            if (seqEnd < remaining.length && !isNestedEscapeSequenceStart(nextChar)) {
-              sequences.push(candidate);
-              pos += seqEnd;
-              break;
-            }
-          }
-          seqEnd++;
-        } else {
-          sequences.push(candidate);
-          pos += seqEnd;
-          break;
-        }
-      }
-      if (seqEnd > remaining.length) {
-        return { sequences, remainder: remaining };
-      }
+  const modifyOtherKeysMatch = modifyOtherKeysRe.exec(s);
+  if (modifyOtherKeysMatch) {
+    const modifier = parseInt(modifyOtherKeysMatch[1], 10) - 1;
+    const charCode = parseInt(modifyOtherKeysMatch[2], 10);
+    key.ctrl = !!(modifier & 4);
+    key.meta = !!(modifier & 2);
+    key.shift = !!(modifier & 1);
+    key.option = !!(modifier & 2);
+    key.super = !!(modifier & 8);
+    key.hyper = !!(modifier & 16);
+    if (charCode === 13) {
+      key.name = "return";
+    } else if (charCode === 27) {
+      key.name = "escape";
+    } else if (charCode === 9) {
+      key.name = "tab";
+    } else if (charCode === 32) {
+      key.name = "space";
+    } else if (charCode === 127 || charCode === 8) {
+      key.name = "backspace";
     } else {
-      const code = remaining.charCodeAt(0);
-      if (code >= 55296 && code <= 56319) {
-        if (remaining.length === 1) {
-          return { sequences, remainder: remaining };
-        }
-        const next = remaining.charCodeAt(1);
-        if (next >= 56320 && next <= 57343) {
-          sequences.push(remaining.slice(0, 2));
-          pos += 2;
-        } else {
-          sequences.push(remaining[0]);
-          pos++;
-        }
-      } else {
-        sequences.push(remaining[0]);
-        pos++;
+      const char = String.fromCharCode(charCode);
+      key.name = char;
+      key.sequence = char;
+      if (charCode >= 48 && charCode <= 57) {
+        key.number = true;
       }
     }
+    return key;
   }
-  return { sequences, remainder: "" };
-}
-
-class StdinBuffer extends EventEmitter2 {
-  buffer = "";
-  timeout = null;
-  timeoutMs;
-  pasteMode = false;
-  pasteBuffer = "";
-  constructor(options = {}) {
-    super();
-    this.timeoutMs = options.timeout ?? 10;
-  }
-  process(data) {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
-    }
-    let str;
-    if (Buffer.isBuffer(data)) {
-      if (data.length === 1 && data[0] > 127) {
-        const byte = data[0] - 128;
-        str = "\x1B" + String.fromCharCode(byte);
-      } else {
-        str = data.toString();
-      }
+  if (s === "\r" || s === "\x1B\r") {
+    key.name = "return";
+    key.meta = s.length === 2;
+  } else if (s === `
+` || s === `\x1B
+`) {
+    key.name = "linefeed";
+    key.meta = s.length === 2;
+  } else if (s === "\t") {
+    key.name = "tab";
+  } else if (s === "\b" || s === "\x1B\b" || s === "\x7F" || s === "\x1B\x7F") {
+    key.name = "backspace";
+    key.meta = s.charAt(0) === "\x1B";
+  } else if (s === "\x1B" || s === "\x1B\x1B") {
+    key.name = "escape";
+    key.meta = s.length === 2;
+  } else if (s === " " || s === "\x1B ") {
+    key.name = "space";
+    key.meta = s.length === 2;
+  } else if (s === "\x00") {
+    key.name = "space";
+    key.ctrl = true;
+  } else if (s.length === 1 && s <= "\x1A") {
+    key.name = String.fromCharCode(s.charCodeAt(0) + 97 - 1);
+    key.ctrl = true;
+  } else if (s.length === 1 && s >= "0" && s <= "9") {
+    key.name = s;
+    key.number = true;
+  } else if (s.length === 1 && s >= "a" && s <= "z") {
+    key.name = s;
+  } else if (s.length === 1 && s >= "A" && s <= "Z") {
+    key.name = s.toLowerCase();
+    key.shift = true;
+  } else if (s.length === 1 || s.length === 2 && s.codePointAt(0) > 65535) {
+    key.name = s;
+  } else if (parts = metaKeyCodeRe.exec(s)) {
+    key.meta = true;
+    const char = parts[1];
+    const isUpperCase = /^[A-Z]$/.test(char);
+    if (char === "F") {
+      key.name = "right";
+    } else if (char === "B") {
+      key.name = "left";
+    } else if (isUpperCase) {
+      key.shift = true;
+      key.name = char;
     } else {
-      str = data;
-    }
-    if (str.length === 0 && this.buffer.length === 0) {
-      this.emit("data", "");
-      return;
-    }
-    this.buffer += str;
-    if (this.pasteMode) {
-      this.pasteBuffer += this.buffer;
-      this.buffer = "";
-      const endIndex = this.pasteBuffer.indexOf(BRACKETED_PASTE_END);
-      if (endIndex !== -1) {
-        const pastedContent = this.pasteBuffer.slice(0, endIndex);
-        const remaining = this.pasteBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
-        this.pasteMode = false;
-        this.pasteBuffer = "";
-        this.emit("paste", pastedContent);
-        if (remaining.length > 0) {
-          this.process(remaining);
-        }
-      }
-      return;
-    }
-    const startIndex = this.buffer.indexOf(BRACKETED_PASTE_START);
-    if (startIndex !== -1) {
-      if (startIndex > 0) {
-        const beforePaste = this.buffer.slice(0, startIndex);
-        const result2 = extractCompleteSequences(beforePaste);
-        for (const sequence of result2.sequences) {
-          this.emit("data", sequence);
-        }
-      }
-      this.buffer = this.buffer.slice(startIndex + BRACKETED_PASTE_START.length);
-      this.pasteMode = true;
-      this.pasteBuffer = this.buffer;
-      this.buffer = "";
-      const endIndex = this.pasteBuffer.indexOf(BRACKETED_PASTE_END);
-      if (endIndex !== -1) {
-        const pastedContent = this.pasteBuffer.slice(0, endIndex);
-        const remaining = this.pasteBuffer.slice(endIndex + BRACKETED_PASTE_END.length);
-        this.pasteMode = false;
-        this.pasteBuffer = "";
-        this.emit("paste", pastedContent);
-        if (remaining.length > 0) {
-          this.process(remaining);
-        }
-      }
-      return;
+      key.name = char;
     }
-    const result = extractCompleteSequences(this.buffer);
-    this.buffer = result.remainder;
-    for (const sequence of result.sequences) {
-      this.emit("data", sequence);
+  } else if (s.length === 2 && s[0] === "\x1B" && s[1] <= "\x1A") {
+    key.meta = true;
+    key.ctrl = true;
+    key.name = String.fromCharCode(s.charCodeAt(1) + 97 - 1);
+  } else if (parts = fnKeyRe.exec(s)) {
+    const segs = [...s];
+    if (segs[0] === "\x1B" && segs[1] === "\x1B") {
+      key.option = true;
+      key.meta = true;
     }
-    if (this.buffer.length > 0) {
-      this.timeout = setTimeout(() => {
-        const flushed = this.flush();
-        for (const sequence of flushed) {
-          this.emit("data", sequence);
-        }
-      }, this.timeoutMs);
+    const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
+    const modifier = parseInt(parts[3] || parts[5] || "1", 10) - 1;
+    key.ctrl = key.ctrl || !!(modifier & 4);
+    key.meta = key.meta || !!(modifier & 2);
+    key.shift = key.shift || !!(modifier & 1);
+    key.option = key.option || !!(modifier & 2);
+    key.super = !!(modifier & 8);
+    key.hyper = !!(modifier & 16);
+    key.code = code;
+    const keyNameResult = keyName[code];
+    if (keyNameResult) {
+      key.name = keyNameResult;
+      key.shift = isShiftKey(code) || key.shift;
+      key.ctrl = isCtrlKey(code) || key.ctrl;
+    } else {
+      key.name = "";
+      key.code = undefined;
     }
+  } else if (s === "\x1B[3~") {
+    key.name = "delete";
+    key.meta = false;
+    key.code = "[3~";
+  }
+  return key;
+};
+
+// src/lib/scroll-acceleration.ts
+class LinearScrollAccel {
+  tick(_now) {
+    return 1;
+  }
+  reset() {}
+}
+
+class MacOSScrollAccel {
+  opts;
+  lastTickTime = 0;
+  velocityHistory = [];
+  historySize = 3;
+  streakTimeout = 150;
+  minTickInterval = 6;
+  constructor(opts = {}) {
+    this.opts = opts;
   }
-  flush() {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
+  tick(now = Date.now()) {
+    const A = this.opts.A ?? 0.8;
+    const tau = this.opts.tau ?? 3;
+    const maxMultiplier = this.opts.maxMultiplier ?? 6;
+    const dt = this.lastTickTime ? now - this.lastTickTime : Infinity;
+    if (dt === Infinity || dt > this.streakTimeout) {
+      this.lastTickTime = now;
+      this.velocityHistory = [];
+      return 1;
     }
-    if (this.buffer.length === 0) {
-      return [];
+    if (dt < this.minTickInterval) {
+      return 1;
     }
-    const sequences = [this.buffer];
-    this.buffer = "";
-    return sequences;
-  }
-  clear() {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
+    this.lastTickTime = now;
+    this.velocityHistory.push(dt);
+    if (this.velocityHistory.length > this.historySize) {
+      this.velocityHistory.shift();
     }
-    this.buffer = "";
-    this.pasteMode = false;
-    this.pasteBuffer = "";
-  }
-  getBuffer() {
-    return this.buffer;
+    const avgInterval = this.velocityHistory.reduce((a, b) => a + b, 0) / this.velocityHistory.length;
+    const referenceInterval = 100;
+    const velocity = referenceInterval / avgInterval;
+    const x = velocity / tau;
+    const multiplier = 1 + A * (Math.exp(x) - 1);
+    return Math.min(multiplier, maxMultiplier);
   }
-  destroy() {
-    this.clear();
+  reset() {
+    this.lastTickTime = 0;
+    this.velocityHistory = [];
   }
 }
 
@@ -6533,7 +6316,8 @@ class MouseParser {
     this.mouseButtonsPressed.clear();
   }
   decodeInput(data) {
-    return data.toString();
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    return buf.toString("latin1");
   }
   parseMouseEvent(data) {
     const str = this.decodeInput(data);
@@ -6853,200 +6637,1068 @@ class ASCIIFontSelectionHelper {
         startCharIndex = coordinateToCharacterIndex(selStart.x, text, font);
       }
     }
-    if (selEnd.y < 0) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selEnd.y >= 0 && selEnd.y <= height - 1) {
-      if (selEnd.x >= 0) {
-        endCharIndex = coordinateToCharacterIndex(selEnd.x, text, font);
-      } else {
-        endCharIndex = 0;
+    if (selEnd.y < 0) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    } else if (selEnd.y >= 0 && selEnd.y <= height - 1) {
+      if (selEnd.x >= 0) {
+        endCharIndex = coordinateToCharacterIndex(selEnd.x, text, font);
+      } else {
+        endCharIndex = 0;
+      }
+    }
+    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
+      this.localSelection = { start: startCharIndex, end: endCharIndex };
+    } else {
+      this.localSelection = null;
+    }
+    return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
+  }
+}
+
+// src/lib/singleton.ts
+var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
+function singleton(key, factory) {
+  const bag = globalThis[singletonCacheSymbol] ??= {};
+  if (!(key in bag)) {
+    bag[key] = factory();
+  }
+  return bag[key];
+}
+function destroySingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  if (bag && key in bag) {
+    delete bag[key];
+  }
+}
+function hasSingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  return bag && key in bag;
+}
+
+// src/lib/env.ts
+var envRegistry = singleton("env-registry", () => ({}));
+function registerEnvVar(config) {
+  const existing = envRegistry[config.name];
+  if (existing) {
+    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default) {
+      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
+    }
+    return;
+  }
+  envRegistry[config.name] = config;
+}
+function normalizeBoolean(value) {
+  const lowerValue = value.toLowerCase();
+  return ["true", "1", "on", "yes"].includes(lowerValue);
+}
+function parseEnvValue(config) {
+  const envValue = process.env[config.name];
+  if (envValue === undefined && config.default !== undefined) {
+    return config.default;
+  }
+  if (envValue === undefined) {
+    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
+  }
+  switch (config.type) {
+    case "boolean":
+      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
+    case "number":
+      const numValue = Number(envValue);
+      if (isNaN(numValue)) {
+        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
+      }
+      return numValue;
+    case "string":
+    default:
+      return envValue;
+  }
+}
+
+class EnvStore {
+  parsedValues = new Map;
+  get(key) {
+    if (this.parsedValues.has(key)) {
+      return this.parsedValues.get(key);
+    }
+    if (!(key in envRegistry)) {
+      throw new Error(`Environment variable ${key} is not registered.`);
+    }
+    try {
+      const value = parseEnvValue(envRegistry[key]);
+      this.parsedValues.set(key, value);
+      return value;
+    } catch (error) {
+      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  has(key) {
+    return key in envRegistry;
+  }
+  clearCache() {
+    this.parsedValues.clear();
+  }
+}
+var envStore = singleton("env-store", () => new EnvStore);
+function clearEnvCache() {
+  envStore.clearCache();
+}
+function generateEnvMarkdown() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `# Environment Variables
+
+No environment variables registered.
+`;
+  }
+  let markdown = `# Environment Variables
+
+`;
+  for (const config of configs) {
+    markdown += `## ${config.name}
+
+`;
+    markdown += `${config.description}
+
+`;
+    markdown += `**Type:** \`${config.type || "string"}\`  
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      markdown += `**Default:** \`${defaultValue}\`
+`;
+    } else {
+      markdown += `**Default:** *Required*
+`;
+    }
+    markdown += `
+`;
+  }
+  return markdown;
+}
+function generateEnvColored() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `\x1B[1;36mEnvironment Variables\x1B[0m
+
+No environment variables registered.
+`;
+  }
+  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
+
+`;
+  for (const config of configs) {
+    output += `\x1B[1;33m${config.name}\x1B[0m
+`;
+    output += `${config.description}
+`;
+    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
+`;
+    } else {
+      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
+`;
+    }
+    output += `
+`;
+  }
+  return output;
+}
+var env = new Proxy({}, {
+  get(target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return envStore.get(prop);
+  },
+  has(target, prop) {
+    return envStore.has(prop);
+  },
+  ownKeys() {
+    return Object.keys(envRegistry);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    if (envStore.has(prop)) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => envStore.get(prop)
+      };
+    }
+    return;
+  }
+});
+
+// src/lib/stdin-parser.ts
+import { Buffer as Buffer3 } from "buffer";
+var DEFAULT_TIMEOUT_MS = 10;
+var DEFAULT_MAX_PENDING_BYTES = 64 * 1024;
+var INITIAL_PENDING_CAPACITY = 256;
+var ESC = 27;
+var BEL = 7;
+var BRACKETED_PASTE_START = Buffer3.from("\x1B[200~");
+var BRACKETED_PASTE_END = Buffer3.from("\x1B[201~");
+var EMPTY_BYTES = new Uint8Array(0);
+var KEY_DECODER = new TextDecoder;
+var RXVT_DOLLAR_CSI_RE = /^\x1b\[\d+\$$/;
+var SYSTEM_CLOCK = new SystemClock;
+
+class ByteQueue {
+  buf;
+  start = 0;
+  end = 0;
+  constructor(capacity = INITIAL_PENDING_CAPACITY) {
+    this.buf = new Uint8Array(capacity);
+  }
+  get length() {
+    return this.end - this.start;
+  }
+  get capacity() {
+    return this.buf.length;
+  }
+  view() {
+    return this.buf.subarray(this.start, this.end);
+  }
+  take() {
+    const chunk = this.view();
+    this.start = 0;
+    this.end = 0;
+    return chunk;
+  }
+  append(chunk) {
+    if (chunk.length === 0) {
+      return;
+    }
+    this.ensureCapacity(this.length + chunk.length);
+    this.buf.set(chunk, this.end);
+    this.end += chunk.length;
+  }
+  consume(count) {
+    if (count <= 0) {
+      return;
+    }
+    if (count >= this.length) {
+      this.start = 0;
+      this.end = 0;
+      return;
+    }
+    this.start += count;
+    if (this.start >= this.buf.length / 2) {
+      this.buf.copyWithin(0, this.start, this.end);
+      this.end -= this.start;
+      this.start = 0;
+    }
+  }
+  clear() {
+    this.start = 0;
+    this.end = 0;
+  }
+  reset(capacity = INITIAL_PENDING_CAPACITY) {
+    this.buf = new Uint8Array(capacity);
+    this.start = 0;
+    this.end = 0;
+  }
+  ensureCapacity(requiredLength) {
+    const currentLength = this.length;
+    if (requiredLength <= this.buf.length) {
+      const availableAtEnd = this.buf.length - this.end;
+      if (availableAtEnd >= requiredLength - currentLength) {
+        return;
+      }
+      this.buf.copyWithin(0, this.start, this.end);
+      this.end = currentLength;
+      this.start = 0;
+      if (requiredLength <= this.buf.length) {
+        return;
       }
     }
-    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
-      this.localSelection = { start: startCharIndex, end: endCharIndex };
-    } else {
-      this.localSelection = null;
+    let nextCapacity = this.buf.length;
+    while (nextCapacity < requiredLength) {
+      nextCapacity *= 2;
     }
-    return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
+    const next = new Uint8Array(nextCapacity);
+    next.set(this.view(), 0);
+    this.buf = next;
+    this.start = 0;
+    this.end = currentLength;
   }
 }
-
-// src/lib/singleton.ts
-var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
-function singleton(key, factory) {
-  const bag = globalThis[singletonCacheSymbol] ??= {};
-  if (!(key in bag)) {
-    bag[key] = factory();
+function normalizePositiveOption(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return fallback;
   }
-  return bag[key];
+  return Math.floor(value);
 }
-function destroySingleton(key) {
-  const bag = globalThis[singletonCacheSymbol];
-  if (bag && key in bag) {
-    delete bag[key];
+function utf8SequenceLength(first) {
+  if (first < 128)
+    return 1;
+  if (first >= 194 && first <= 223)
+    return 2;
+  if (first >= 224 && first <= 239)
+    return 3;
+  if (first >= 240 && first <= 244)
+    return 4;
+  return 0;
+}
+function bytesEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
   }
+  return true;
 }
-function hasSingleton(key) {
-  const bag = globalThis[singletonCacheSymbol];
-  return bag && key in bag;
+function isMouseSgrSequence(sequence) {
+  if (sequence.length < 7) {
+    return false;
+  }
+  if (sequence[0] !== ESC || sequence[1] !== 91 || sequence[2] !== 60) {
+    return false;
+  }
+  const final = sequence[sequence.length - 1];
+  if (final !== 77 && final !== 109) {
+    return false;
+  }
+  let part = 0;
+  let hasDigit = false;
+  for (let index = 3;index < sequence.length - 1; index += 1) {
+    const byte = sequence[index];
+    if (byte >= 48 && byte <= 57) {
+      hasDigit = true;
+      continue;
+    }
+    if (byte === 59 && hasDigit && part < 2) {
+      part += 1;
+      hasDigit = false;
+      continue;
+    }
+    return false;
+  }
+  return part === 2 && hasDigit;
 }
-
-// src/lib/env.ts
-var envRegistry = singleton("env-registry", () => ({}));
-function registerEnvVar(config) {
-  const existing = envRegistry[config.name];
-  if (existing) {
-    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default) {
-      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
+function concatBytes(left, right) {
+  if (left.length === 0) {
+    return right;
+  }
+  if (right.length === 0) {
+    return left;
+  }
+  const combined = new Uint8Array(left.length + right.length);
+  combined.set(left, 0);
+  combined.set(right, left.length);
+  return combined;
+}
+function indexOfBytes(haystack, needle) {
+  if (needle.length === 0) {
+    return 0;
+  }
+  const limit = haystack.length - needle.length;
+  for (let offset = 0;offset <= limit; offset += 1) {
+    let matched = true;
+    for (let index = 0;index < needle.length; index += 1) {
+      if (haystack[offset + index] !== needle[index]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      return offset;
     }
-    return;
   }
-  envRegistry[config.name] = config;
+  return -1;
 }
-function normalizeBoolean(value) {
-  const lowerValue = value.toLowerCase();
-  return ["true", "1", "on", "yes"].includes(lowerValue);
+function decodeLatin1(bytes) {
+  return Buffer3.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("latin1");
 }
-function parseEnvValue(config) {
-  const envValue = process.env[config.name];
-  if (envValue === undefined && config.default !== undefined) {
-    return config.default;
+function decodeUtf8(bytes) {
+  return KEY_DECODER.decode(bytes);
+}
+function createPasteCollector() {
+  return {
+    tail: EMPTY_BYTES,
+    parts: [],
+    totalLength: 0
+  };
+}
+function joinPasteBytes(parts, totalLength) {
+  if (totalLength === 0) {
+    return EMPTY_BYTES;
   }
-  if (envValue === undefined) {
-    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
+  if (parts.length === 1) {
+    return parts[0];
   }
-  switch (config.type) {
-    case "boolean":
-      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
-    case "number":
-      const numValue = Number(envValue);
-      if (isNaN(numValue)) {
-        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
+  const bytes = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of parts) {
+    bytes.set(part, offset);
+    offset += part.length;
+  }
+  return bytes;
+}
+
+class StdinParser {
+  pending = new ByteQueue(INITIAL_PENDING_CAPACITY);
+  events = [];
+  timeoutMs;
+  maxPendingBytes;
+  armTimeouts;
+  onTimeoutFlush;
+  useKittyKeyboard;
+  mouseParser = new MouseParser;
+  clock;
+  timeoutId = null;
+  destroyed = false;
+  pendingSinceMs = null;
+  forceFlush = false;
+  justFlushedEsc = false;
+  state = { tag: "ground" };
+  cursor = 0;
+  unitStart = 0;
+  paste = null;
+  constructor(options = {}) {
+    this.timeoutMs = normalizePositiveOption(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+    this.maxPendingBytes = normalizePositiveOption(options.maxPendingBytes, DEFAULT_MAX_PENDING_BYTES);
+    this.armTimeouts = options.armTimeouts ?? true;
+    this.onTimeoutFlush = options.onTimeoutFlush ?? null;
+    this.useKittyKeyboard = options.useKittyKeyboard ?? true;
+    this.clock = options.clock ?? SYSTEM_CLOCK;
+  }
+  get bufferCapacity() {
+    return this.pending.capacity;
+  }
+  push(data) {
+    this.ensureAlive();
+    if (data.length === 0) {
+      this.emitKeyOrResponse("unknown", "");
+      return;
+    }
+    let remainder = data;
+    while (remainder.length > 0) {
+      if (this.paste) {
+        remainder = this.consumePasteBytes(remainder);
+        continue;
+      }
+      const immediatePasteStartIndex = this.state.tag === "ground" && this.pending.length === 0 ? indexOfBytes(remainder, BRACKETED_PASTE_START) : -1;
+      const appendEnd = immediatePasteStartIndex === -1 ? remainder.length : immediatePasteStartIndex + BRACKETED_PASTE_START.length;
+      this.pending.append(remainder.subarray(0, appendEnd));
+      remainder = remainder.subarray(appendEnd);
+      this.scanPending();
+      if (this.paste && this.pending.length > 0) {
+        remainder = this.consumePasteBytes(this.takePendingBytes());
+        continue;
+      }
+      if (!this.paste && this.pending.length > this.maxPendingBytes) {
+        this.flushPendingOverflow();
+        this.scanPending();
+        if (this.paste && this.pending.length > 0) {
+          remainder = this.consumePasteBytes(this.takePendingBytes());
+        }
+      }
+    }
+    this.reconcileTimeoutState();
+  }
+  read() {
+    this.ensureAlive();
+    if (this.events.length === 0 && this.forceFlush) {
+      this.scanPending();
+      this.reconcileTimeoutState();
+    }
+    return this.events.shift() ?? null;
+  }
+  drain(onEvent) {
+    this.ensureAlive();
+    while (true) {
+      if (this.destroyed) {
+        return;
+      }
+      const event = this.read();
+      if (!event) {
+        return;
+      }
+      onEvent(event);
+    }
+  }
+  flushTimeout(nowMsValue = this.clock.now()) {
+    this.ensureAlive();
+    if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
+      return;
+    }
+    if (nowMsValue < this.pendingSinceMs || nowMsValue - this.pendingSinceMs < this.timeoutMs) {
+      return;
+    }
+    this.forceFlush = true;
+  }
+  reset() {
+    if (this.destroyed) {
+      return;
+    }
+    this.clearTimeout();
+    this.resetState();
+  }
+  resetMouseState() {
+    this.ensureAlive();
+    this.mouseParser.reset();
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.clearTimeout();
+    this.destroyed = true;
+    this.resetState();
+  }
+  ensureAlive() {
+    if (this.destroyed) {
+      throw new Error("StdinParser has been destroyed");
+    }
+  }
+  scanPending() {
+    while (!this.paste) {
+      const bytes = this.pending.view();
+      if (this.state.tag === "ground" && this.cursor >= bytes.length) {
+        this.pending.clear();
+        this.cursor = 0;
+        this.unitStart = 0;
+        this.pendingSinceMs = null;
+        this.forceFlush = false;
+        return;
+      }
+      const byte = this.cursor < bytes.length ? bytes[this.cursor] : -1;
+      switch (this.state.tag) {
+        case "ground": {
+          this.unitStart = this.cursor;
+          if (this.justFlushedEsc) {
+            if (byte === 91) {
+              this.justFlushedEsc = false;
+              this.cursor += 1;
+              this.state = { tag: "esc_recovery" };
+              continue;
+            }
+            this.justFlushedEsc = false;
+          }
+          if (byte === ESC) {
+            this.cursor += 1;
+            this.state = { tag: "esc" };
+            continue;
+          }
+          if (byte < 128) {
+            this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.cursor, this.cursor + 1)));
+            this.consumePrefix(this.cursor + 1);
+            continue;
+          }
+          const expected = utf8SequenceLength(byte);
+          if (expected === 0) {
+            if (!this.forceFlush && this.cursor + 1 === bytes.length) {
+              this.markPending();
+              return;
+            }
+            this.emitLegacyHighByte(byte);
+            this.consumePrefix(this.cursor + 1);
+            continue;
+          }
+          this.cursor += 1;
+          this.state = { tag: "utf8", expected, seen: 1 };
+          continue;
+        }
+        case "utf8": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitLegacyHighByte(bytes[this.unitStart]);
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.unitStart + 1);
+            continue;
+          }
+          if ((byte & 192) !== 128) {
+            this.emitLegacyHighByte(bytes[this.unitStart]);
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.unitStart + 1);
+            continue;
+          }
+          const nextSeen = this.state.seen + 1;
+          this.cursor += 1;
+          if (nextSeen < this.state.expected) {
+            this.state = { tag: "utf8", expected: this.state.expected, seen: nextSeen };
+            continue;
+          }
+          this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.unitStart, this.cursor)));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+          continue;
+        }
+        case "esc": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            const flushedLoneEsc = this.cursor === this.unitStart + 1 && bytes[this.unitStart] === ESC;
+            this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.unitStart, this.cursor)));
+            this.justFlushedEsc = flushedLoneEsc;
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          switch (byte) {
+            case 91:
+              this.cursor += 1;
+              this.state = { tag: "csi" };
+              continue;
+            case 79:
+              this.cursor += 1;
+              this.state = { tag: "ss3" };
+              continue;
+            case 93:
+              this.cursor += 1;
+              this.state = { tag: "osc", sawEsc: false };
+              continue;
+            case 80:
+              this.cursor += 1;
+              this.state = { tag: "dcs", sawEsc: false };
+              continue;
+            case 95:
+              this.cursor += 1;
+              this.state = { tag: "apc", sawEsc: false };
+              continue;
+            case ESC:
+              this.cursor += 1;
+              continue;
+            default:
+              this.cursor += 1;
+              this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.unitStart, this.cursor)));
+              this.state = { tag: "ground" };
+              this.consumePrefix(this.cursor);
+              continue;
+          }
+        }
+        case "ss3": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          this.cursor += 1;
+          this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.unitStart, this.cursor)));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+          continue;
+        }
+        case "esc_recovery": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.unitStart, this.cursor)));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte === 60) {
+            this.cursor += 1;
+            this.state = { tag: "esc_less_mouse" };
+            continue;
+          }
+          if (byte === 77) {
+            this.cursor += 1;
+            this.state = { tag: "esc_less_x10_mouse" };
+            continue;
+          }
+          this.emitKeyOrResponse("unknown", decodeUtf8(bytes.subarray(this.unitStart, this.unitStart + 1)));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.unitStart + 1);
+          continue;
+        }
+        case "csi": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte === 77 && this.cursor === this.unitStart + 2) {
+            const end = this.cursor + 4;
+            if (bytes.length < end) {
+              if (!this.forceFlush) {
+                this.markPending();
+                return;
+              }
+              this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, bytes.length));
+              this.state = { tag: "ground" };
+              this.consumePrefix(bytes.length);
+              continue;
+            }
+            this.emitMouse(bytes.subarray(this.unitStart, end), "x10");
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          if (byte === 36) {
+            const candidateEnd = this.cursor + 1;
+            const candidate = decodeUtf8(bytes.subarray(this.unitStart, candidateEnd));
+            if (RXVT_DOLLAR_CSI_RE.test(candidate)) {
+              this.emitKeyOrResponse("csi", candidate);
+              this.state = { tag: "ground" };
+              this.consumePrefix(candidateEnd);
+              continue;
+            }
+            if (!this.forceFlush && candidateEnd >= bytes.length) {
+              this.markPending();
+              return;
+            }
+          }
+          if (byte === 91 && this.cursor === this.unitStart + 2) {
+            this.cursor += 1;
+            continue;
+          }
+          if (byte >= 64 && byte <= 126) {
+            const end = this.cursor + 1;
+            const rawBytes = bytes.subarray(this.unitStart, end);
+            if (bytesEqual(rawBytes, BRACKETED_PASTE_START)) {
+              this.state = { tag: "ground" };
+              this.consumePrefix(end);
+              this.paste = createPasteCollector();
+              continue;
+            }
+            if (isMouseSgrSequence(rawBytes)) {
+              this.emitMouse(rawBytes, "sgr");
+              this.state = { tag: "ground" };
+              this.consumePrefix(end);
+              continue;
+            }
+            this.emitKeyOrResponse("csi", decodeUtf8(rawBytes));
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          this.cursor += 1;
+          continue;
+        }
+        case "osc": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (this.state.sawEsc) {
+            if (byte === 92) {
+              const end = this.cursor + 1;
+              this.emitOpaqueResponse("osc", bytes.subarray(this.unitStart, end));
+              this.state = { tag: "ground" };
+              this.consumePrefix(end);
+              continue;
+            }
+            this.state = { tag: "osc", sawEsc: false };
+            continue;
+          }
+          if (byte === BEL) {
+            const end = this.cursor + 1;
+            this.emitOpaqueResponse("osc", bytes.subarray(this.unitStart, end));
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          if (byte === ESC) {
+            this.cursor += 1;
+            this.state = { tag: "osc", sawEsc: true };
+            continue;
+          }
+          this.cursor += 1;
+          continue;
+        }
+        case "dcs": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (this.state.sawEsc) {
+            if (byte === 92) {
+              const end = this.cursor + 1;
+              this.emitOpaqueResponse("dcs", bytes.subarray(this.unitStart, end));
+              this.state = { tag: "ground" };
+              this.consumePrefix(end);
+              continue;
+            }
+            this.state = { tag: "dcs", sawEsc: false };
+            continue;
+          }
+          if (byte === ESC) {
+            this.cursor += 1;
+            this.state = { tag: "dcs", sawEsc: true };
+            continue;
+          }
+          this.cursor += 1;
+          continue;
+        }
+        case "apc": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (this.state.sawEsc) {
+            if (byte === 92) {
+              const end = this.cursor + 1;
+              this.emitOpaqueResponse("apc", bytes.subarray(this.unitStart, end));
+              this.state = { tag: "ground" };
+              this.consumePrefix(end);
+              continue;
+            }
+            this.state = { tag: "apc", sawEsc: false };
+            continue;
+          }
+          if (byte === ESC) {
+            this.cursor += 1;
+            this.state = { tag: "apc", sawEsc: true };
+            continue;
+          }
+          this.cursor += 1;
+          continue;
+        }
+        case "esc_less_mouse": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte >= 48 && byte <= 57 || byte === 59) {
+            this.cursor += 1;
+            continue;
+          }
+          if (byte === 77 || byte === 109) {
+            const end = this.cursor + 1;
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, end));
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+          continue;
+        }
+        case "esc_less_x10_mouse": {
+          const end = this.unitStart + 5;
+          if (bytes.length < end) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, bytes.length));
+            this.state = { tag: "ground" };
+            this.consumePrefix(bytes.length);
+            continue;
+          }
+          this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, end));
+          this.state = { tag: "ground" };
+          this.consumePrefix(end);
+          continue;
+        }
       }
-      return numValue;
-    case "string":
-    default:
-      return envValue;
-  }
-}
-
-class EnvStore {
-  parsedValues = new Map;
-  get(key) {
-    if (this.parsedValues.has(key)) {
-      return this.parsedValues.get(key);
-    }
-    if (!(key in envRegistry)) {
-      throw new Error(`Environment variable ${key} is not registered.`);
     }
-    try {
-      const value = parseEnvValue(envRegistry[key]);
-      this.parsedValues.set(key, value);
-      return value;
-    } catch (error) {
-      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  emitKeyOrResponse(protocol, raw) {
+    const parsed = parseKeypress(raw, { useKittyKeyboard: this.useKittyKeyboard });
+    if (parsed) {
+      this.events.push({
+        type: "key",
+        raw: parsed.raw,
+        key: parsed
+      });
+      return;
     }
+    this.events.push({
+      type: "response",
+      protocol,
+      sequence: raw
+    });
   }
-  has(key) {
-    return key in envRegistry;
+  emitMouse(rawBytes, encoding) {
+    const event = this.mouseParser.parseMouseEvent(rawBytes);
+    if (!event) {
+      this.emitOpaqueResponse("unknown", rawBytes);
+      return;
+    }
+    this.events.push({
+      type: "mouse",
+      raw: decodeLatin1(rawBytes),
+      encoding,
+      event
+    });
   }
-  clearCache() {
-    this.parsedValues.clear();
+  emitLegacyHighByte(byte) {
+    const parsed = parseKeypress(Buffer3.from([byte]), { useKittyKeyboard: this.useKittyKeyboard });
+    if (parsed) {
+      this.events.push({
+        type: "key",
+        raw: parsed.raw,
+        key: parsed
+      });
+      return;
+    }
+    this.events.push({
+      type: "response",
+      protocol: "unknown",
+      sequence: String.fromCharCode(byte)
+    });
   }
-}
-var envStore = singleton("env-store", () => new EnvStore);
-function clearEnvCache() {
-  envStore.clearCache();
-}
-function generateEnvMarkdown() {
-  const configs = Object.values(envRegistry);
-  if (configs.length === 0) {
-    return `# Environment Variables
-
-No environment variables registered.
-`;
+  emitOpaqueResponse(protocol, rawBytes) {
+    this.events.push({
+      type: "response",
+      protocol,
+      sequence: decodeLatin1(rawBytes)
+    });
   }
-  let markdown = `# Environment Variables
-
-`;
-  for (const config of configs) {
-    markdown += `## ${config.name}
-
-`;
-    markdown += `${config.description}
-
-`;
-    markdown += `**Type:** \`${config.type || "string"}\`  
-`;
-    if (config.default !== undefined) {
-      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
-      markdown += `**Default:** \`${defaultValue}\`
-`;
-    } else {
-      markdown += `**Default:** *Required*
-`;
+  consumePrefix(endExclusive) {
+    this.pending.consume(endExclusive);
+    this.cursor = 0;
+    this.unitStart = 0;
+    this.pendingSinceMs = null;
+    this.forceFlush = false;
+  }
+  takePendingBytes() {
+    const buffered = this.pending.take();
+    this.cursor = 0;
+    this.unitStart = 0;
+    this.pendingSinceMs = null;
+    this.forceFlush = false;
+    return buffered;
+  }
+  flushPendingOverflow() {
+    if (this.pending.length === 0) {
+      return;
     }
-    markdown += `
-`;
-  }
-  return markdown;
-}
-function generateEnvColored() {
-  const configs = Object.values(envRegistry);
-  if (configs.length === 0) {
-    return `\x1B[1;36mEnvironment Variables\x1B[0m
-
-No environment variables registered.
-`;
+    this.emitOpaqueResponse("unknown", this.pending.view());
+    this.pending.clear();
+    this.cursor = 0;
+    this.unitStart = 0;
+    this.pendingSinceMs = null;
+    this.forceFlush = false;
+    this.state = { tag: "ground" };
+  }
+  markPending() {
+    this.pendingSinceMs = this.clock.now();
+  }
+  consumePasteBytes(chunk) {
+    const paste = this.paste;
+    const combined = concatBytes(paste.tail, chunk);
+    const endIndex = indexOfBytes(combined, BRACKETED_PASTE_END);
+    if (endIndex !== -1) {
+      this.pushPasteBytes(combined.subarray(0, endIndex));
+      this.events.push({
+        type: "paste",
+        bytes: joinPasteBytes(paste.parts, paste.totalLength)
+      });
+      this.paste = null;
+      return combined.subarray(endIndex + BRACKETED_PASTE_END.length);
+    }
+    const keep = Math.min(BRACKETED_PASTE_END.length - 1, combined.length);
+    const stableLength = combined.length - keep;
+    if (stableLength > 0) {
+      this.pushPasteBytes(combined.subarray(0, stableLength));
+    }
+    paste.tail = Uint8Array.from(combined.subarray(stableLength));
+    return EMPTY_BYTES;
   }
-  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
-
-`;
-  for (const config of configs) {
-    output += `\x1B[1;33m${config.name}\x1B[0m
-`;
-    output += `${config.description}
-`;
-    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
-`;
-    if (config.default !== undefined) {
-      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
-      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
-`;
-    } else {
-      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
-`;
+  pushPasteBytes(bytes) {
+    if (bytes.length === 0) {
+      return;
     }
-    output += `
-`;
+    this.paste.parts.push(Uint8Array.from(bytes));
+    this.paste.totalLength += bytes.length;
   }
-  return output;
-}
-var env = new Proxy({}, {
-  get(target, prop) {
-    if (typeof prop !== "string") {
+  reconcileTimeoutState() {
+    if (!this.armTimeouts) {
       return;
     }
-    return envStore.get(prop);
-  },
-  has(target, prop) {
-    return envStore.has(prop);
-  },
-  ownKeys() {
-    return Object.keys(envRegistry);
-  },
-  getOwnPropertyDescriptor(target, prop) {
-    if (envStore.has(prop)) {
-      return {
-        enumerable: true,
-        configurable: true,
-        get: () => envStore.get(prop)
-      };
+    if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
+      this.clearTimeout();
+      return;
     }
-    return;
+    this.clearTimeout();
+    this.timeoutId = this.clock.setTimeout(() => {
+      this.timeoutId = null;
+      if (this.destroyed) {
+        return;
+      }
+      try {
+        this.flushTimeout(this.clock.now());
+        this.onTimeoutFlush?.();
+      } catch (error) {
+        console.error("stdin parser timeout flush failed", error);
+      }
+    }, this.timeoutMs);
   }
-});
+  clearTimeout() {
+    if (!this.timeoutId) {
+      return;
+    }
+    this.clock.clearTimeout(this.timeoutId);
+    this.timeoutId = null;
+  }
+  resetState() {
+    this.pending.reset(INITIAL_PENDING_CAPACITY);
+    this.events.length = 0;
+    this.pendingSinceMs = null;
+    this.forceFlush = false;
+    this.justFlushedEsc = false;
+    this.state = { tag: "ground" };
+    this.cursor = 0;
+    this.unitStart = 0;
+    this.paste = null;
+    this.mouseParser.reset();
+  }
+}
 
 // src/lib/tree-sitter-styled-text.ts
 registerEnvVar({ name: "OTUI_TS_STYLE_WARN", default: false, description: "Enable warnings for missing syntax styles" });
@@ -7262,7 +7914,7 @@ async function treeSitterToStyledText(content, filetype, syntaxStyle, client, op
 }
 
 // src/lib/tree-sitter/client.ts
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 
 // src/lib/debounce.ts
 var TIMERS_MAP = new Map;
@@ -7477,7 +8129,7 @@ function addDefaultParsers(parsers) {
 }
 var isUrl = (path) => path.startsWith("http://") || path.startsWith("https://");
 
-class TreeSitterClient extends EventEmitter3 {
+class TreeSitterClient extends EventEmitter2 {
   initialized = false;
   worker;
   buffers = new Map;
@@ -7929,7 +8581,7 @@ class TreeSitterClient extends EventEmitter3 {
 // src/lib/data-paths.ts
 import os from "os";
 import path from "path";
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
 // src/lib/validate-dir-name.ts
 function isValidDirectoryName(name) {
@@ -7993,7 +8645,7 @@ registerEnvVar({
   default: ""
 });
 
-class DataPathsManager extends EventEmitter4 {
+class DataPathsManager extends EventEmitter3 {
   _appName;
   _globalConfigPath;
   _globalConfigFile;
@@ -8125,11 +8777,11 @@ function pathToFiletype(path2) {
 }
 
 // src/lib/tree-sitter/assets/update.ts
-import { readFile, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import * as path3 from "path";
 
 // src/lib/tree-sitter/download-utils.ts
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir, readFile, writeFile } from "fs/promises";
 import * as path2 from "path";
 
 class DownloadUtils {
@@ -8155,7 +8807,7 @@ class DownloadUtils {
       const cacheFile = path2.join(cacheDir, cacheSubdir, cacheFileName);
       await mkdir(path2.dirname(cacheFile), { recursive: true });
       try {
-        const cachedContent = await Bun.file(cacheFile).arrayBuffer();
+        const cachedContent = await readFile(cacheFile);
         if (cachedContent.byteLength > 0) {
           console.log(`Loaded from cache: ${cacheFile} (${source})`);
           return { content: cachedContent, filePath: cacheFile };
@@ -8167,7 +8819,7 @@ class DownloadUtils {
         if (!response.ok) {
           return { error: `Failed to fetch from ${source}: ${response.statusText}` };
         }
-        const content = await response.arrayBuffer();
+        const content = Buffer.from(await response.arrayBuffer());
         try {
           await writeFile(cacheFile, Buffer.from(content));
           console.log(`Cached: ${source}`);
@@ -8181,7 +8833,7 @@ class DownloadUtils {
     } else {
       try {
         console.log(`Loading from local path: ${source}`);
-        const content = await Bun.file(source).arrayBuffer();
+        const content = await readFile(source);
         return { content, filePath: source };
       } catch (error) {
         return { error: `Error loading from local path ${source}: ${error}` };
@@ -8198,7 +8850,7 @@ class DownloadUtils {
         if (!response.ok) {
           return { error: `Failed to fetch from ${source}: ${response.statusText}` };
         }
-        const content = await response.arrayBuffer();
+        const content = Buffer.from(await response.arrayBuffer());
         await writeFile(targetPath, Buffer.from(content));
         console.log(`Downloaded: ${source} -> ${targetPath}`);
         return { content, filePath: targetPath };
@@ -8208,7 +8860,7 @@ class DownloadUtils {
     } else {
       try {
         console.log(`Copying from local path: ${source}`);
-        const content = await Bun.file(source).arrayBuffer();
+        const content = await readFile(source);
         await writeFile(targetPath, Buffer.from(content));
         return { content, filePath: targetPath };
       } catch (error) {
@@ -8259,7 +8911,7 @@ async function loadConfig(configPath) {
     ext = path3.extname(resolvedConfigPath);
   }
   if (ext === ".json") {
-    const configContent = await readFile(resolvedConfigPath, "utf-8");
+    const configContent = await readFile2(resolvedConfigPath, "utf-8");
     return JSON.parse(configContent);
   } else if (ext === ".ts" || ext === ".js") {
     const { default: configContent } = await import(resolvedConfigPath);
@@ -8287,7 +8939,7 @@ async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputP
       console.log(`    Using local query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
       try {
         const localPath = path3.resolve(path3.dirname(configPath), queryUrl);
-        const content = await readFile(localPath, "utf-8");
+        const content = await readFile2(localPath, "utf-8");
         if (content.trim()) {
           queryContents.push(content);
           console.log(`    \u2713 Loaded ${content.split(`
@@ -9149,6 +9801,7 @@ function createExtmarksController(editBuffer, editorView) {
 }
 
 // src/lib/terminal-palette.ts
+var SYSTEM_CLOCK2 = new SystemClock;
 var OSC4_RESPONSE = /\x1b]4;(\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 var OSC_SPECIAL_RESPONSE = /\x1b](\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 function scaleComponent(comp) {
@@ -9172,80 +9825,138 @@ class TerminalPalette {
   stdin;
   stdout;
   writeFn;
-  activeListeners = [];
-  activeTimers = [];
+  activeQuerySessions = [];
   inLegacyTmux;
-  constructor(stdin, stdout, writeFn, isLegacyTmux) {
+  oscSource;
+  clock;
+  constructor(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
     this.stdin = stdin;
     this.stdout = stdout;
     this.writeFn = writeFn || ((data) => stdout.write(data));
     this.inLegacyTmux = isLegacyTmux ?? false;
+    this.oscSource = oscSource;
+    this.clock = clock ?? SYSTEM_CLOCK2;
   }
   writeOsc(osc) {
     const data = this.inLegacyTmux ? wrapForTmux(osc) : osc;
     return this.writeFn(data);
   }
   cleanup() {
-    for (const { event, handler } of this.activeListeners) {
-      this.stdin.removeListener(event, handler);
+    for (const cleanupSession of [...this.activeQuerySessions]) {
+      cleanupSession();
     }
-    this.activeListeners = [];
-    for (const timer of this.activeTimers) {
-      clearTimeout(timer);
+    this.activeQuerySessions = [];
+  }
+  subscribeInput(handler) {
+    if (this.oscSource) {
+      return this.oscSource.subscribeOsc((sequence) => {
+        handler(sequence);
+      });
     }
-    this.activeTimers = [];
+    this.stdin.on("data", handler);
+    return () => {
+      this.stdin.removeListener("data", handler);
+    };
+  }
+  createQuerySession() {
+    const timers = new Set;
+    const subscriptions = new Set;
+    let closed = false;
+    const cleanup = () => {
+      if (closed)
+        return;
+      closed = true;
+      for (const timer of timers) {
+        this.clock.clearTimeout(timer);
+      }
+      timers.clear();
+      for (const unsubscribe of subscriptions) {
+        unsubscribe();
+      }
+      subscriptions.clear();
+      const idx = this.activeQuerySessions.indexOf(cleanup);
+      if (idx !== -1)
+        this.activeQuerySessions.splice(idx, 1);
+    };
+    this.activeQuerySessions.push(cleanup);
+    return {
+      setTimer: (fn, ms) => {
+        const timer = this.clock.setTimeout(fn, ms);
+        timers.add(timer);
+        return timer;
+      },
+      resetTimer: (existing, fn, ms) => {
+        if (existing) {
+          this.clock.clearTimeout(existing);
+          timers.delete(existing);
+        }
+        const timer = this.clock.setTimeout(fn, ms);
+        timers.add(timer);
+        return timer;
+      },
+      subscribeInput: (handler) => {
+        const unsubscribe = this.subscribeInput(handler);
+        subscriptions.add(unsubscribe);
+        return () => {
+          if (!subscriptions.has(unsubscribe))
+            return;
+          subscriptions.delete(unsubscribe);
+          unsubscribe();
+        };
+      },
+      cleanup
+    };
   }
   async detectOSCSupport(timeoutMs = 300) {
     const out = this.stdout;
-    const inp = this.stdin;
-    if (!out.isTTY || !inp.isTTY)
+    if (!out.isTTY || !this.stdin.isTTY)
       return false;
     return new Promise((resolve4) => {
+      const session = this.createQuerySession();
       let buffer = "";
+      let settled = false;
+      const finish = (supported) => {
+        if (settled)
+          return;
+        settled = true;
+        session.cleanup();
+        resolve4(supported);
+      };
       const onData = (chunk) => {
         buffer += chunk.toString();
         OSC4_RESPONSE.lastIndex = 0;
         if (OSC4_RESPONSE.test(buffer)) {
-          cleanup();
-          resolve4(true);
+          finish(true);
         }
       };
-      const onTimeout = () => {
-        cleanup();
-        resolve4(false);
-      };
-      const cleanup = () => {
-        clearTimeout(timer);
-        inp.removeListener("data", onData);
-        const listenerIdx = this.activeListeners.findIndex((l) => l.handler === onData);
-        if (listenerIdx !== -1)
-          this.activeListeners.splice(listenerIdx, 1);
-        const timerIdx = this.activeTimers.indexOf(timer);
-        if (timerIdx !== -1)
-          this.activeTimers.splice(timerIdx, 1);
-      };
-      const timer = setTimeout(onTimeout, timeoutMs);
-      this.activeTimers.push(timer);
-      inp.on("data", onData);
-      this.activeListeners.push({ event: "data", handler: onData });
+      session.setTimer(() => {
+        finish(false);
+      }, timeoutMs);
+      session.subscribeInput(onData);
       this.writeOsc("\x1B]4;0;?\x07");
     });
   }
   async queryPalette(indices, timeoutMs = 1200) {
     const out = this.stdout;
-    const inp = this.stdin;
     const results = new Map;
     indices.forEach((i) => results.set(i, null));
-    if (!out.isTTY || !inp.isTTY) {
+    if (!out.isTTY || !this.stdin.isTTY) {
       return results;
     }
     return new Promise((resolve4) => {
+      const session = this.createQuerySession();
       let buffer = "";
-      let lastResponseTime = Date.now();
       let idleTimer = null;
+      let settled = false;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        session.cleanup();
+        resolve4(results);
+      };
       const onData = (chunk) => {
         buffer += chunk.toString();
-        lastResponseTime = Date.now();
         let m;
         OSC4_RESPONSE.lastIndex = 0;
         while (m = OSC4_RESPONSE.exec(buffer)) {
@@ -9257,50 +9968,18 @@ class TerminalPalette {
           buffer = buffer.slice(-4096);
         const done = [...results.values()].filter((v) => v !== null).length;
         if (done === results.size) {
-          cleanup();
-          resolve4(results);
+          finish();
           return;
         }
-        if (idleTimer)
-          clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-          cleanup();
-          resolve4(results);
-        }, 150);
-        if (idleTimer)
-          this.activeTimers.push(idleTimer);
-      };
-      const onTimeout = () => {
-        cleanup();
-        resolve4(results);
-      };
-      const cleanup = () => {
-        clearTimeout(timer);
-        if (idleTimer)
-          clearTimeout(idleTimer);
-        inp.removeListener("data", onData);
-        const listenerIdx = this.activeListeners.findIndex((l) => l.handler === onData);
-        if (listenerIdx !== -1)
-          this.activeListeners.splice(listenerIdx, 1);
-        const timerIdx = this.activeTimers.indexOf(timer);
-        if (timerIdx !== -1)
-          this.activeTimers.splice(timerIdx, 1);
-        if (idleTimer) {
-          const idleTimerIdx = this.activeTimers.indexOf(idleTimer);
-          if (idleTimerIdx !== -1)
-            this.activeTimers.splice(idleTimerIdx, 1);
-        }
+        idleTimer = session.resetTimer(idleTimer, finish, 150);
       };
-      const timer = setTimeout(onTimeout, timeoutMs);
-      this.activeTimers.push(timer);
-      inp.on("data", onData);
-      this.activeListeners.push({ event: "data", handler: onData });
+      session.setTimer(finish, timeoutMs);
+      session.subscribeInput(onData);
       this.writeOsc(indices.map((i) => `\x1B]4;${i};?\x07`).join(""));
     });
   }
   async querySpecialColors(timeoutMs = 1200) {
     const out = this.stdout;
-    const inp = this.stdin;
     const results = {
       10: null,
       11: null,
@@ -9312,12 +9991,21 @@ class TerminalPalette {
       17: null,
       19: null
     };
-    if (!out.isTTY || !inp.isTTY) {
+    if (!out.isTTY || !this.stdin.isTTY) {
       return results;
     }
     return new Promise((resolve4) => {
+      const session = this.createQuerySession();
       let buffer = "";
       let idleTimer = null;
+      let settled = false;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        session.cleanup();
+        resolve4(results);
+      };
       const onData = (chunk) => {
         buffer += chunk.toString();
         let updated = false;
@@ -9334,46 +10022,15 @@ class TerminalPalette {
           buffer = buffer.slice(-4096);
         const done = Object.values(results).filter((v) => v !== null).length;
         if (done === Object.keys(results).length) {
-          cleanup();
-          resolve4(results);
+          finish();
           return;
         }
         if (!updated)
           return;
-        if (idleTimer)
-          clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-          cleanup();
-          resolve4(results);
-        }, 150);
-        if (idleTimer)
-          this.activeTimers.push(idleTimer);
-      };
-      const onTimeout = () => {
-        cleanup();
-        resolve4(results);
+        idleTimer = session.resetTimer(idleTimer, finish, 150);
       };
-      const cleanup = () => {
-        clearTimeout(timer);
-        if (idleTimer)
-          clearTimeout(idleTimer);
-        inp.removeListener("data", onData);
-        const listenerIdx = this.activeListeners.findIndex((l) => l.handler === onData);
-        if (listenerIdx !== -1)
-          this.activeListeners.splice(listenerIdx, 1);
-        const timerIdx = this.activeTimers.indexOf(timer);
-        if (timerIdx !== -1)
-          this.activeTimers.splice(timerIdx, 1);
-        if (idleTimer) {
-          const idleTimerIdx = this.activeTimers.indexOf(idleTimer);
-          if (idleTimerIdx !== -1)
-            this.activeTimers.splice(idleTimerIdx, 1);
-        }
-      };
-      const timer = setTimeout(onTimeout, timeoutMs);
-      this.activeTimers.push(timer);
-      inp.on("data", onData);
-      this.activeListeners.push({ event: "data", handler: onData });
+      session.setTimer(finish, timeoutMs);
+      session.subscribeInput(onData);
       this.writeOsc([
         "\x1B]10;?\x07",
         "\x1B]11;?\x07",
@@ -9423,8 +10080,17 @@ class TerminalPalette {
     };
   }
 }
-function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux) {
-  return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux);
+function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
+  return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock);
+}
+
+// src/lib/paste.ts
+var PASTE_TEXT_DECODER = new TextDecoder;
+function decodePasteBytes(bytes) {
+  return PASTE_TEXT_DECODER.decode(bytes);
+}
+function stripAnsiSequences(text) {
+  return Bun.stripANSI(text);
 }
 
 // src/lib/detect-links.ts
@@ -9470,8 +10136,8 @@ function detectLinks(chunks, context) {
 }
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr4 } from "bun:ffi";
-import { existsSync as existsSync2 } from "fs";
-import { EventEmitter as EventEmitter5 } from "events";
+import { existsSync as existsSync2, writeFileSync } from "fs";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/buffer.ts
 import { toArrayBuffer, ptr } from "bun:ffi";
@@ -10463,19 +11129,19 @@ var EncodedCharStruct = defineStruct([
   ["char", "u32"]
 ]);
 var LineInfoStruct = defineStruct([
-  ["starts", ["u32"]],
-  ["startsLen", "u32", { lengthOf: "starts" }],
-  ["widths", ["u32"]],
-  ["widthsLen", "u32", { lengthOf: "widths" }],
+  ["startCols", ["u32"]],
+  ["startColsLen", "u32", { lengthOf: "startCols" }],
+  ["widthCols", ["u32"]],
+  ["widthColsLen", "u32", { lengthOf: "widthCols" }],
   ["sources", ["u32"]],
   ["sourcesLen", "u32", { lengthOf: "sources" }],
   ["wraps", ["u32"]],
   ["wrapsLen", "u32", { lengthOf: "wraps" }],
-  ["maxWidth", "u32"]
+  ["widthColsMax", "u32"]
 ]);
 var MeasureResultStruct = defineStruct([
   ["lineCount", "u32"],
-  ["maxWidth", "u32"]
+  ["widthColsMax", "u32"]
 ]);
 var CursorStateStruct = defineStruct([
   ["x", "u32"],
@@ -10602,11 +11268,11 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
-var CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2 };
-var CURSOR_ID_TO_STYLE = ["block", "line", "underline"];
+var CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2, default: 3 };
+var CURSOR_ID_TO_STYLE = ["block", "line", "underline", "default"];
 var MOUSE_STYLE_TO_ID = { default: 0, pointer: 1, text: 2, crosshair: 3, move: 4, "not-allowed": 5 };
 var globalTraceSymbols = null;
-var globalFFILogWriter = null;
+var globalFFILogPath = null;
 var exitHandlerRegistered = false;
 function toPointer(value) {
   if (typeof value === "bigint") {
@@ -11595,24 +12261,21 @@ function convertToDebugSymbols(symbols) {
   if (!globalTraceSymbols) {
     globalTraceSymbols = {};
   }
-  if (env.OTUI_DEBUG_FFI && !globalFFILogWriter) {
+  if (env.OTUI_DEBUG_FFI && !globalFFILogPath) {
     const now = new Date;
     const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
-    const logFilePath = `ffi_otui_debug_${timestamp}.log`;
-    globalFFILogWriter = Bun.file(logFilePath).writer();
+    globalFFILogPath = `ffi_otui_debug_${timestamp}.log`;
   }
   const debugSymbols = {};
   let hasTracing = false;
   Object.entries(symbols).forEach(([key, value]) => {
     debugSymbols[key] = value;
   });
-  if (env.OTUI_DEBUG_FFI && globalFFILogWriter) {
-    const writer = globalFFILogWriter;
+  if (env.OTUI_DEBUG_FFI && globalFFILogPath) {
+    const logPath = globalFFILogPath;
     const writeSync = (msg) => {
-      const buffer = new TextEncoder().encode(msg + `
-`);
-      writer.write(buffer);
-      writer.flush();
+      writeFileSync(logPath, msg + `
+`, { flag: "a" });
     };
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
@@ -11646,11 +12309,6 @@ function convertToDebugSymbols(symbols) {
   if ((env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) && !exitHandlerRegistered) {
     exitHandlerRegistered = true;
     process.on("exit", () => {
-      try {
-        if (globalFFILogWriter) {
-          globalFFILogWriter.end();
-        }
-      } catch (e) {}
       if (globalTraceSymbols) {
         const allStats = [];
         for (const [key, timings] of Object.entries(globalTraceSymbols)) {
@@ -11703,15 +12361,15 @@ function convertToDebugSymbols(symbols) {
           const countWidth = Math.max(callsHeader.length, ...allStats.map((s) => String(s.count).length));
           const totalWidth = Math.max(totalHeader.length, ...allStats.map((s) => s.total.toFixed(2).length));
           const avgWidth = Math.max(avgHeader.length, ...allStats.map((s) => s.average.toFixed(2).length));
-          const minWidth = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
-          const maxWidth = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
+          const statWidthMin = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
+          const statWidthMax = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
           const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
           const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
           const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
-          lines.push(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
-          lines.push(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
+          lines.push(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(statWidthMin)} | ${maxHeader.padStart(statWidthMax)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
+          lines.push(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(statWidthMin)}-+-${"-".repeat(statWidthMax)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
           allStats.forEach((stat) => {
-            lines.push(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
+            lines.push(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(statWidthMin)} | ${stat.max.toFixed(2).padStart(statWidthMax)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
           });
         }
         lines.push("-------------------------------------------------------------------------------------------------------------------------");
@@ -11745,7 +12403,7 @@ class FFIRenderLib {
   decoder = new TextDecoder;
   logCallbackWrapper;
   eventCallbackWrapper;
-  _nativeEvents = new EventEmitter5;
+  _nativeEvents = new EventEmitter4;
   _anyEventHandlers = [];
   nativeSpanFeedCallbackWrapper = null;
   nativeSpanFeedHandlers = new Map;
@@ -12351,10 +13009,13 @@ class FFIRenderLib {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
     this.textBufferViewGetLineInfoDirect(view, ptr4(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
+    const lineStartCols = struct.startCols;
+    const lineWidthCols = struct.widthCols;
+    const lineWidthColsMax = struct.widthColsMax;
     return {
-      maxLineWidth: struct.maxWidth,
-      lineStarts: struct.starts,
-      lineWidths: struct.widths,
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
       lineSources: struct.sources,
       lineWraps: struct.wraps
     };
@@ -12363,10 +13024,13 @@ class FFIRenderLib {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
     this.textBufferViewGetLogicalLineInfoDirect(view, ptr4(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
+    const lineStartCols = struct.startCols;
+    const lineWidthCols = struct.widthCols;
+    const lineWidthColsMax = struct.widthColsMax;
     return {
-      maxLineWidth: struct.maxWidth,
-      lineStarts: struct.starts,
-      lineWidths: struct.widths,
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
       lineSources: struct.sources,
       lineWraps: struct.wraps
     };
@@ -12542,10 +13206,13 @@ class FFIRenderLib {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
     this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr4(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
+    const lineStartCols = struct.startCols;
+    const lineWidthCols = struct.widthCols;
+    const lineWidthColsMax = struct.widthColsMax;
     return {
-      maxLineWidth: struct.maxWidth,
-      lineStarts: struct.starts,
-      lineWidths: struct.widths,
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
       lineSources: struct.sources,
       lineWraps: struct.wraps
     };
@@ -12554,10 +13221,13 @@ class FFIRenderLib {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
     this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr4(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
+    const lineStartCols = struct.startCols;
+    const lineWidthCols = struct.widthCols;
+    const lineWidthColsMax = struct.widthColsMax;
     return {
-      maxLineWidth: struct.maxWidth,
-      lineStarts: struct.starts,
-      lineWidths: struct.widths,
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
       lineSources: struct.sources,
       lineWraps: struct.wraps
     };
@@ -13240,7 +13910,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -13333,7 +14003,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter6 {
+class BaseRenderable extends EventEmitter5 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -14715,7 +15385,7 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 import { Console } from "console";
 import fs from "fs";
 import path4 from "path";
@@ -14723,9 +15393,9 @@ import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
-class Capture extends EventEmitter7 {
+class Capture extends EventEmitter6 {
   output = [];
   constructor() {
     super();
@@ -14854,7 +15524,7 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter8 {
+class TerminalConsoleCache extends EventEmitter7 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -14998,7 +15668,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter8 {
+class TerminalConsole extends EventEmitter7 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -15027,6 +15697,7 @@ class TerminalConsole extends EventEmitter8 {
     height: 0
   };
   _autoScrollInterval = null;
+  clock;
   _keyBindingsMap;
   _keyAliasMap;
   _keyBindings;
@@ -15066,6 +15737,7 @@ class TerminalConsole extends EventEmitter8 {
   constructor(renderer, options = {}) {
     super();
     this.renderer = renderer;
+    this.clock = options.clock ?? new SystemClock;
     this.options = { ...DEFAULT_CONSOLE_OPTIONS, ...options };
     this.keyHandler = this.handleKeyPress.bind(this);
     this._debugModeEnabled = this.options.startInDebugMode;
@@ -15621,13 +16293,13 @@ class TerminalConsole extends EventEmitter8 {
   }
   stopAutoScroll() {
     if (this._autoScrollInterval !== null) {
-      clearInterval(this._autoScrollInterval);
+      this.clock.clearInterval(this._autoScrollInterval);
       this._autoScrollInterval = null;
     }
   }
   startAutoScroll(direction) {
     this.stopAutoScroll();
-    this._autoScrollInterval = setInterval(() => {
+    this._autoScrollInterval = this.clock.setInterval(() => {
       if (direction === "up") {
         if (this.scrollTopIndex > 0) {
           this.scrollTopIndex--;
@@ -15841,7 +16513,7 @@ class Clipboard {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter9 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -16036,6 +16708,7 @@ var KITTY_FLAG_EVENT_TYPES = 2;
 var KITTY_FLAG_ALTERNATE_KEYS = 4;
 var KITTY_FLAG_ALL_KEYS_AS_ESCAPES = 8;
 var KITTY_FLAG_REPORT_TEXT = 16;
+var DEFAULT_STDIN_PARSER_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 function buildKittyKeyboardFlags(config) {
   if (!config) {
     return 0;
@@ -16169,7 +16842,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter9 {
+class CliRenderer extends EventEmitter8 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -16204,6 +16877,7 @@ class CliRenderer extends EventEmitter9 {
   postProcessFns = [];
   backgroundColor = RGBA.fromInts(0, 0, 0, 0);
   waitingForPixelResolution = false;
+  clock;
   rendering = false;
   renderingNative = false;
   renderTimeout = null;
@@ -16231,7 +16905,9 @@ class CliRenderer extends EventEmitter9 {
   _console;
   _resolution = null;
   _keyHandler;
-  _stdinBuffer;
+  stdinParser = null;
+  oscSubscribers = new Set;
+  hasLoggedStdinParserError = false;
   animationRequest = new Map;
   resizeTimeoutId = null;
   capabilityTimeoutId = null;
@@ -16260,7 +16936,6 @@ class CliRenderer extends EventEmitter9 {
     }
   };
   _useConsole = true;
-  mouseParser = new MouseParser;
   sigwinchHandler = (() => {
     const width = this.stdout.columns || 80;
     const height = this.stdout.rows || 24;
@@ -16279,7 +16954,7 @@ class CliRenderer extends EventEmitter9 {
   _paletteDetectionPromise = null;
   _onDestroy;
   _themeMode = null;
-  inputHandlers = [];
+  sequenceHandlers = [];
   prependedInputHandlers = [];
   shouldRestoreModesOnNextFocus = false;
   idleResolvers = [];
@@ -16396,7 +17071,7 @@ Captured output:
     process.on("beforeExit", this.exitHandler);
     const kittyConfig = config.useKittyKeyboard ?? {};
     const useKittyForParsing = kittyConfig !== null;
-    this._keyHandler = new InternalKeyHandler(useKittyForParsing);
+    this._keyHandler = new InternalKeyHandler;
     this._keyHandler.on("keypress", (event) => {
       if (this.exitOnCtrlC && event.name === "c" && event.ctrl) {
         process.nextTick(() => {
@@ -16406,8 +17081,22 @@ Captured output:
       }
     });
     this.addExitListeners();
-    this._stdinBuffer = new StdinBuffer({ timeout: 5 });
-    this._console = new TerminalConsole(this, config.consoleOptions);
+    this.clock = config.clock ?? new SystemClock;
+    const stdinParserMaxBufferBytes = config.stdinParserMaxBufferBytes ?? DEFAULT_STDIN_PARSER_MAX_BUFFER_BYTES;
+    this.stdinParser = new StdinParser({
+      timeoutMs: 10,
+      maxPendingBytes: stdinParserMaxBufferBytes,
+      armTimeouts: true,
+      onTimeoutFlush: () => {
+        this.drainStdinParser();
+      },
+      useKittyKeyboard: useKittyForParsing,
+      clock: this.clock
+    });
+    this._console = new TerminalConsole(this, {
+      ...config.consoleOptions ?? {},
+      clock: this.clock
+    });
     this.useConsole = config.useConsole ?? true;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
     this._onDestroy = config.onDestroy;
@@ -16521,14 +17210,14 @@ Captured output:
     }
     if (!this.updateScheduled && !this.renderTimeout) {
       this.updateScheduled = true;
-      const now = Date.now();
+      const now = this.clock.now();
       const elapsed = now - this.lastTime;
       const delay = Math.max(this.minTargetFrameTime - elapsed, 0);
       if (delay === 0) {
         process.nextTick(() => this.activateFrame());
         return;
       }
-      setTimeout(() => this.activateFrame(), delay);
+      this.clock.setTimeout(() => this.activateFrame(), delay);
     }
   }
   async activateFrame() {
@@ -16714,7 +17403,7 @@ Captured output:
   disableMouse() {
     this._useMouse = false;
     this.setCapturedRenderable(undefined);
-    this.mouseParser.reset();
+    this.stdinParser?.resetMouseState();
     this.lib.disableMouse(this.rendererPtr);
   }
   enableKittyKeyboard(flags = 3) {
@@ -16741,7 +17430,7 @@ Captured output:
         this.automaticMemorySnapshot = true;
       }
     }
-    this.capabilityTimeoutId = setTimeout(() => {
+    this.capabilityTimeoutId = this.clock.setTimeout(() => {
       this.capabilityTimeoutId = null;
       this.removeInputHandler(this.capabilityHandler);
     }, 5000);
@@ -16750,20 +17439,31 @@ Captured output:
     }
     this.queryPixelResolution();
   }
-  stdinListener = ((data) => {
-    if (this._useMouse && this.handleMouseData(data)) {
+  stdinListener = ((chunk) => {
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (!this.stdinParser)
       return;
+    try {
+      this.stdinParser.push(data);
+      this.drainStdinParser();
+    } catch (error) {
+      this.handleStdinParserFailure(error);
     }
-    this._stdinBuffer.process(data);
   }).bind(this);
   addInputHandler(handler) {
-    this.inputHandlers.push(handler);
+    this.sequenceHandlers.push(handler);
   }
   prependInputHandler(handler) {
-    this.inputHandlers.unshift(handler);
+    this.sequenceHandlers.unshift(handler);
   }
   removeInputHandler(handler) {
-    this.inputHandlers = this.inputHandlers.filter((h2) => h2 !== handler);
+    this.sequenceHandlers = this.sequenceHandlers.filter((candidate) => candidate !== handler);
+  }
+  subscribeOsc(handler) {
+    this.oscSubscribers.add(handler);
+    return () => {
+      this.oscSubscribers.delete(handler);
+    };
   }
   capabilityHandler = ((sequence) => {
     if (isCapabilityResponse(sequence)) {
@@ -16807,6 +17507,67 @@ Captured output:
     }
     return false;
   }).bind(this);
+  dispatchSequenceHandlers(sequence) {
+    if (this._debugModeEnabled) {
+      this._debugInputs.push({
+        timestamp: new Date().toISOString(),
+        sequence
+      });
+    }
+    for (const handler of this.sequenceHandlers) {
+      if (handler(sequence)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  drainStdinParser() {
+    if (!this.stdinParser)
+      return;
+    this.stdinParser.drain((event) => {
+      this.handleStdinEvent(event);
+    });
+  }
+  handleStdinEvent(event) {
+    switch (event.type) {
+      case "key":
+        if (this.dispatchSequenceHandlers(event.raw)) {
+          return;
+        }
+        this._keyHandler.processParsedKey(event.key);
+        return;
+      case "mouse":
+        if (this._useMouse && this.processSingleMouseEvent(event.event)) {
+          return;
+        }
+        this.dispatchSequenceHandlers(event.raw);
+        return;
+      case "paste":
+        this._keyHandler.processPaste(event.bytes, event.metadata);
+        return;
+      case "response":
+        if (event.protocol === "osc") {
+          for (const subscriber of this.oscSubscribers) {
+            subscriber(event.sequence);
+          }
+        }
+        this.dispatchSequenceHandlers(event.sequence);
+        return;
+    }
+  }
+  handleStdinParserFailure(error) {
+    if (!this.hasLoggedStdinParserError) {
+      this.hasLoggedStdinParserError = true;
+      if (true) {
+        console.error("[stdin-parser-error] parser failure, resetting parser", error);
+      }
+    }
+    try {
+      this.stdinParser?.reset();
+    } catch (resetError) {
+      console.error("stdin parser reset failed after parser error", resetError);
+    }
+  }
   setupInput() {
     for (const handler of this.prependedInputHandlers) {
       this.addInputHandler(handler);
@@ -16825,31 +17586,11 @@ Captured output:
     this.addInputHandler(this.capabilityHandler);
     this.addInputHandler(this.focusHandler);
     this.addInputHandler(this.themeModeHandler);
-    this.addInputHandler((sequence) => {
-      return this._keyHandler.processInput(sequence);
-    });
     if (this.stdin.setRawMode) {
       this.stdin.setRawMode(true);
     }
     this.stdin.resume();
-    this.stdin.setEncoding("utf8");
     this.stdin.on("data", this.stdinListener);
-    this._stdinBuffer.on("data", (sequence) => {
-      if (this._debugModeEnabled) {
-        this._debugInputs.push({
-          timestamp: new Date().toISOString(),
-          sequence
-        });
-      }
-      for (const handler of this.inputHandlers) {
-        if (handler(sequence)) {
-          return;
-        }
-      }
-    });
-    this._stdinBuffer.on("paste", (data) => {
-      this._keyHandler.processPaste(data);
-    });
   }
   dispatchMouseEvent(target, attributes) {
     const event = new MouseEvent(target, attributes);
@@ -16866,18 +17607,6 @@ Captured output:
     }
     return event;
   }
-  handleMouseData(data) {
-    const mouseEvents = this.mouseParser.parseAllMouseEvents(data);
-    if (mouseEvents.length === 0)
-      return false;
-    let anyHandled = false;
-    for (const mouseEvent of mouseEvents) {
-      if (this.processSingleMouseEvent(mouseEvent)) {
-        anyHandled = true;
-      }
-    }
-    return anyHandled;
-  }
   processSingleMouseEvent(mouseEvent) {
     if (this._splitHeight > 0) {
       if (mouseEvent.y < this.renderOffset) {
@@ -17052,13 +17781,13 @@ Captured output:
   }
   startMemorySnapshotTimer() {
     this.stopMemorySnapshotTimer();
-    this.memorySnapshotTimer = setInterval(() => {
+    this.memorySnapshotTimer = this.clock.setInterval(() => {
       this.takeMemorySnapshot();
     }, this.memorySnapshotInterval);
   }
   stopMemorySnapshotTimer() {
     if (this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
+      this.clock.clearInterval(this.memorySnapshotTimer);
       this.memorySnapshotTimer = null;
     }
   }
@@ -17067,7 +17796,7 @@ Captured output:
     if (this._isRunning && interval > 0) {
       this.startMemorySnapshotTimer();
     } else if (interval <= 0 && this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
+      this.clock.clearInterval(this.memorySnapshotTimer);
       this.memorySnapshotTimer = null;
     }
   }
@@ -17079,10 +17808,10 @@ Captured output:
       return;
     }
     if (this.resizeTimeoutId !== null) {
-      clearTimeout(this.resizeTimeoutId);
+      this.clock.clearTimeout(this.resizeTimeoutId);
       this.resizeTimeoutId = null;
     }
-    this.resizeTimeoutId = setTimeout(() => {
+    this.resizeTimeoutId = this.clock.setTimeout(() => {
       this.resizeTimeoutId = null;
       this.processResize(width, height);
     }, this.resizeDebounceDelay);
@@ -17099,7 +17828,7 @@ Captured output:
     this._terminalHeight = height;
     this.queryPixelResolution();
     this.setCapturedRenderable(undefined);
-    this.mouseParser.reset();
+    this.stdinParser?.resetMouseState();
     if (this._splitHeight > 0) {
       if (width < prevWidth) {
         const start = this._terminalHeight - this._splitHeight * 2;
@@ -17262,7 +17991,7 @@ Captured output:
     this._suspendedMouseEnabled = this._useMouse;
     this.disableMouse();
     this.removeExitListeners();
-    this._stdinBuffer.clear();
+    this.stdinParser?.reset();
     this.stdin.removeListener("data", this.stdinListener);
     this.lib.suspendRenderer(this.rendererPtr);
     if (this.stdin.setRawMode) {
@@ -17295,7 +18024,7 @@ Captured output:
   internalPause() {
     this._isRunning = false;
     if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
+      this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
     if (!this.rendering) {
@@ -17310,11 +18039,11 @@ Captured output:
     if (this.isRunning && !this._isDestroyed) {
       this._isRunning = false;
       if (this.memorySnapshotTimer) {
-        clearInterval(this.memorySnapshotTimer);
+        this.clock.clearInterval(this.memorySnapshotTimer);
         this.memorySnapshotTimer = null;
       }
       if (this.renderTimeout) {
-        clearTimeout(this.renderTimeout);
+        this.clock.clearTimeout(this.renderTimeout);
         this.renderTimeout = null;
       }
       if (!this.rendering) {
@@ -17345,15 +18074,15 @@ Captured output:
     capture.removeListener("write", this.captureCallback);
     this.removeExitListeners();
     if (this.resizeTimeoutId !== null) {
-      clearTimeout(this.resizeTimeoutId);
+      this.clock.clearTimeout(this.resizeTimeoutId);
       this.resizeTimeoutId = null;
     }
     if (this.capabilityTimeoutId !== null) {
-      clearTimeout(this.capabilityTimeoutId);
+      this.clock.clearTimeout(this.capabilityTimeoutId);
       this.capabilityTimeoutId = null;
     }
     if (this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
+      this.clock.clearInterval(this.memorySnapshotTimer);
     }
     if (this._paletteDetector) {
       this._paletteDetector.cleanup();
@@ -17363,7 +18092,7 @@ Captured output:
     this._cachedPalette = null;
     this.emit("destroy" /* DESTROY */);
     if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
+      this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
     this._isRunning = false;
@@ -17374,16 +18103,18 @@ Captured output:
     } catch (e) {
       console.error("Error destroying root renderable:", e instanceof Error ? e.stack : String(e));
     }
-    this._stdinBuffer.destroy();
+    this.stdin.removeListener("data", this.stdinListener);
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.stdinParser?.destroy();
+    this.stdinParser = null;
+    this.oscSubscribers.clear();
     this._console.destroy();
     this.disableStdoutInterception();
     if (this._splitHeight > 0) {
       this.flushStdoutCache(this._splitHeight, true);
     }
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(false);
-    }
-    this.stdin.removeListener("data", this.stdinListener);
     this.lib.destroyRenderer(this.rendererPtr);
     rendererTracker.removeRenderer(this);
     if (this._onDestroy) {
@@ -17398,7 +18129,7 @@ Captured output:
   startRenderLoop() {
     if (!this._isRunning)
       return;
-    this.lastTime = Date.now();
+    this.lastTime = this.clock.now();
     this.frameCount = 0;
     this.lastFpsTime = this.lastTime;
     this.currentFps = 0;
@@ -17410,11 +18141,11 @@ Captured output:
     this.renderTimeout = null;
     this.rendering = true;
     if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
+      this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
     try {
-      const now = Date.now();
+      const now = this.clock.now();
       const elapsed = now - this.lastTime;
       const deltaTime = elapsed;
       this.lastTime = now;
@@ -17465,12 +18196,12 @@ Captured output:
           const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
           const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
           this.immediateRerenderRequested = false;
-          this.renderTimeout = setTimeout(() => {
+          this.renderTimeout = this.clock.setTimeout(() => {
             this.renderTimeout = null;
             this.loop();
           }, delay);
         } else {
-          clearTimeout(this.renderTimeout);
+          this.clock.clearTimeout(this.renderTimeout);
           this.renderTimeout = null;
         }
       }
@@ -17665,7 +18396,9 @@ Captured output:
     }
     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);
+      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
+        subscribeOsc: this.subscribeOsc.bind(this)
+      }, this.clock);
     }
     this._paletteDetectionPromise = this._paletteDetector.detect(options).then((result) => {
       this._cachedPalette = result;
@@ -17676,7 +18409,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, 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, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, 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, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, 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, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=18A382B09D14760A64756E2164756E21
-//# sourceMappingURL=index-4sjb8n0n.js.map
+//# debugId=CCC74025BA5612C764756E2164756E21
+//# sourceMappingURL=index-nkrr8a4c.js.map