@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/core.cjs

@@ -0,0 +1,3153 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  ANSI16_COLORS: () => ANSI16_COLORS,
+  ANSI256_COLORS: () => ANSI256_COLORS,
+  ANSI8_COLORS: () => ANSI8_COLORS,
+  SGR_RESET: () => SGR_RESET,
+  TERMINAL_RENDER_PLANES: () => TERMINAL_RENDER_PLANES,
+  ansiColors: () => ansiColors,
+  ansiStyles: () => ansiStyles,
+  charCellWidth: () => charCellWidth,
+  createTerminal: () => createTerminal,
+  detectTerminalColorCapability: () => detectTerminalColorCapability,
+  isSafeRelativeHref: () => isSafeRelativeHref,
+  normalizeNewlines: () => normalizeNewlines,
+  parseAnsiSgr: () => parseAnsiSgr,
+  parsePathQuery: () => parsePathQuery,
+  resolveUserPath: () => resolveUserPath,
+  rgbToAnsi256: () => rgbToAnsi256,
+  sanitizeDomHref: () => sanitizeDomHref,
+  sanitizeTerminalHref: () => sanitizeTerminalHref,
+  suggestParentHint: () => suggestParentHint,
+  suggestPaths: () => suggestPaths,
+  truecolorBgOpen: () => truecolorBgOpen,
+  truecolorFgOpen: () => truecolorFgOpen
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/ansi-palette.ts
+var ANSI_PALETTE_HEX = Object.freeze({
+  black: "#000000",
+  red: "#c91b00",
+  green: "#00c200",
+  yellow: "#c7c400",
+  blue: "#0225c7",
+  magenta: "#c930c7",
+  cyan: "#00c5c7",
+  white: "#c7c7c7",
+  blackBright: "#686868",
+  redBright: "#ff6e67",
+  greenBright: "#5ffa68",
+  yellowBright: "#fffc67",
+  blueBright: "#6871ff",
+  magentaBright: "#ff76ff",
+  cyanBright: "#5ffdff",
+  whiteBright: "#ffffff"
+});
+function ansiHexToRgb(hex) {
+  const h = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (h.length !== 6)
+    return void 0;
+  const r = Number.parseInt(h.slice(0, 2), 16);
+  const g = Number.parseInt(h.slice(2, 4), 16);
+  const b = Number.parseInt(h.slice(4, 6), 16);
+  if (!Number.isFinite(r) || !Number.isFinite(g) || !Number.isFinite(b))
+    return void 0;
+  return { r, g, b };
+}
+var ANSI_PALETTE_RGB = Object.freeze(
+  Object.fromEntries(
+    Object.entries(ANSI_PALETTE_HEX).map(([k, v]) => [k, ansiHexToRgb(v)])
+  )
+);
+function isAnsiColorName(name) {
+  return typeof name === "string" && Object.prototype.hasOwnProperty.call(ANSI_PALETTE_HEX, name);
+}
+function ansiColorRgb(name, palette) {
+  if (!isAnsiColorName(name))
+    return void 0;
+  const custom = palette?.[name];
+  if (custom)
+    return ansiHexToRgb(custom) ?? ANSI_PALETTE_RGB[name];
+  return ANSI_PALETTE_RGB[name];
+}
+
+// src/core/ansi/colors.ts
+var ANSI8_COLOR_NAMES = Object.freeze([
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white"
+]);
+var ANSI16_COLOR_NAMES = Object.freeze([
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "blackBright",
+  "redBright",
+  "greenBright",
+  "yellowBright",
+  "blueBright",
+  "magentaBright",
+  "cyanBright",
+  "whiteBright"
+]);
+var ESC = "\x1B[";
+var SGR_RESET = `${ESC}0m`;
+var SGR_BOLD = `${ESC}1m`;
+var SGR_DIM = `${ESC}2m`;
+var SGR_ITALIC = `${ESC}3m`;
+var SGR_UNDERLINE = `${ESC}4m`;
+var SGR_INVERSE = `${ESC}7m`;
+function toAnsi8ColorName(name) {
+  switch (name) {
+    case "black":
+    case "red":
+    case "green":
+    case "yellow":
+    case "blue":
+    case "magenta":
+    case "cyan":
+    case "white":
+      return name;
+    case "blackBright":
+      return "black";
+    case "redBright":
+      return "red";
+    case "greenBright":
+      return "green";
+    case "yellowBright":
+      return "yellow";
+    case "blueBright":
+      return "blue";
+    case "magentaBright":
+      return "magenta";
+    case "cyanBright":
+      return "cyan";
+    case "whiteBright":
+      return "white";
+  }
+}
+var ANSI16_FG_CODE = Object.freeze({
+  black: 30,
+  red: 31,
+  green: 32,
+  yellow: 33,
+  blue: 34,
+  magenta: 35,
+  cyan: 36,
+  white: 37,
+  blackBright: 90,
+  redBright: 91,
+  greenBright: 92,
+  yellowBright: 93,
+  blueBright: 94,
+  magentaBright: 95,
+  cyanBright: 96,
+  whiteBright: 97
+});
+var ANSI16_BG_CODE = Object.freeze({
+  black: 40,
+  red: 41,
+  green: 42,
+  yellow: 43,
+  blue: 44,
+  magenta: 45,
+  cyan: 46,
+  white: 47,
+  blackBright: 100,
+  redBright: 101,
+  greenBright: 102,
+  yellowBright: 103,
+  blueBright: 104,
+  magentaBright: 105,
+  cyanBright: 106,
+  whiteBright: 107
+});
+function ansi8FgOpen(name) {
+  const base = toAnsi8ColorName(name);
+  const idx = ANSI8_COLOR_NAMES.indexOf(base);
+  return `${ESC}${30 + (idx < 0 ? 7 : idx)}m`;
+}
+function ansi8BgOpen(name) {
+  const base = toAnsi8ColorName(name);
+  const idx = ANSI8_COLOR_NAMES.indexOf(base);
+  return `${ESC}${40 + (idx < 0 ? 0 : idx)}m`;
+}
+function ansi16FgOpen(name) {
+  return `${ESC}${ANSI16_FG_CODE[name]}m`;
+}
+function ansi16BgOpen(name) {
+  return `${ESC}${ANSI16_BG_CODE[name]}m`;
+}
+function ansi256FgOpen(index) {
+  const n = clampAnsiIndex(index);
+  return `${ESC}38;5;${n}m`;
+}
+function ansi256BgOpen(index) {
+  const n = clampAnsiIndex(index);
+  return `${ESC}48;5;${n}m`;
+}
+function truecolorFgOpen(rgb) {
+  return `${ESC}38;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
+}
+function truecolorBgOpen(rgb) {
+  return `${ESC}48;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
+}
+function ansi256ToRgb(index) {
+  const n = clampAnsiIndex(index);
+  if (n < 16) {
+    const name = ANSI16_COLOR_NAMES[n] ?? "white";
+    return ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
+  }
+  if (n >= 232) {
+    const c = 8 + (n - 232) * 10;
+    return { r: c, g: c, b: c };
+  }
+  const i = n - 16;
+  const rr = Math.floor(i / 36);
+  const gg = Math.floor(i % 36 / 6);
+  const bb = i % 6;
+  const levels = [0, 95, 135, 175, 215, 255];
+  return { r: levels[rr], g: levels[gg], b: levels[bb] };
+}
+function rgbToAnsi256(rgb) {
+  const r = clampByte(rgb.r);
+  const g = clampByte(rgb.g);
+  const b = clampByte(rgb.b);
+  const levels = [0, 95, 135, 175, 215, 255];
+  const nearestLevelIndex = (v) => {
+    let best = 0;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < levels.length; i++) {
+      const d = (v - levels[i]) ** 2;
+      if (d < bestDist) {
+        bestDist = d;
+        best = i;
+      }
+    }
+    return best;
+  };
+  const ri = nearestLevelIndex(r);
+  const gi = nearestLevelIndex(g);
+  const bi = nearestLevelIndex(b);
+  const cubeIndex = 16 + 36 * ri + 6 * gi + bi;
+  const cube = ansi256ToRgb(cubeIndex);
+  const cubeDist = (r - cube.r) ** 2 + (g - cube.g) ** 2 + (b - cube.b) ** 2;
+  const gray = Math.round((r + g + b) / 3);
+  const grayIndex = gray < 8 ? 16 : gray > 248 ? 231 : 232 + Math.round((gray - 8) / 10);
+  const grayRgb = ansi256ToRgb(grayIndex);
+  const grayDist = (r - grayRgb.r) ** 2 + (g - grayRgb.g) ** 2 + (b - grayRgb.b) ** 2;
+  return grayDist < cubeDist ? grayIndex : cubeIndex;
+}
+function ansi8Palette() {
+  return ANSI8_COLOR_NAMES.map((name, index) => {
+    const rgb = ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
+    return Object.freeze({
+      level: 8,
+      index,
+      name,
+      rgb,
+      fgOpen: ansi8FgOpen(name),
+      bgOpen: ansi8BgOpen(name)
+    });
+  });
+}
+function ansi16Palette() {
+  return ANSI16_COLOR_NAMES.map((name, index) => {
+    const rgb = ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
+    return Object.freeze({
+      level: 16,
+      index,
+      name,
+      rgb,
+      fgOpen: ansi16FgOpen(name),
+      bgOpen: ansi16BgOpen(name)
+    });
+  });
+}
+function ansi256Palette() {
+  const out = [];
+  for (let index = 0; index < 256; index++) {
+    out.push(
+      Object.freeze({
+        level: 256,
+        index,
+        rgb: ansi256ToRgb(index),
+        fgOpen: ansi256FgOpen(index),
+        bgOpen: ansi256BgOpen(index)
+      })
+    );
+  }
+  return Object.freeze(out);
+}
+function clampAnsiIndex(n) {
+  if (!Number.isFinite(n))
+    return 0;
+  return Math.max(0, Math.min(255, Math.trunc(n)));
+}
+function clampByte(n) {
+  if (!Number.isFinite(n))
+    return 0;
+  return Math.max(0, Math.min(255, Math.round(n)));
+}
+
+// src/ansi-styles.ts
+var ESC2 = "\x1B[";
+function createStyle(open, close) {
+  return Object.freeze({ open, close });
+}
+var ansiStyles = Object.freeze({
+  reset: createStyle(SGR_RESET, SGR_RESET),
+  bold: createStyle(SGR_BOLD, `${ESC2}22m`),
+  dim: createStyle(SGR_DIM, `${ESC2}22m`),
+  italic: createStyle(SGR_ITALIC, `${ESC2}23m`),
+  underline: createStyle(SGR_UNDERLINE, `${ESC2}24m`),
+  inverse: createStyle(SGR_INVERSE, `${ESC2}27m`),
+  // 16-color named helpers (common subset of `ansi-styles`).
+  black: createStyle(ansi16FgOpen("black"), `${ESC2}39m`),
+  red: createStyle(ansi16FgOpen("red"), `${ESC2}39m`),
+  green: createStyle(ansi16FgOpen("green"), `${ESC2}39m`),
+  yellow: createStyle(ansi16FgOpen("yellow"), `${ESC2}39m`),
+  blue: createStyle(ansi16FgOpen("blue"), `${ESC2}39m`),
+  magenta: createStyle(ansi16FgOpen("magenta"), `${ESC2}39m`),
+  cyan: createStyle(ansi16FgOpen("cyan"), `${ESC2}39m`),
+  white: createStyle(ansi16FgOpen("white"), `${ESC2}39m`),
+  blackBright: createStyle(ansi16FgOpen("blackBright"), `${ESC2}39m`),
+  redBright: createStyle(ansi16FgOpen("redBright"), `${ESC2}39m`),
+  greenBright: createStyle(ansi16FgOpen("greenBright"), `${ESC2}39m`),
+  yellowBright: createStyle(ansi16FgOpen("yellowBright"), `${ESC2}39m`),
+  blueBright: createStyle(ansi16FgOpen("blueBright"), `${ESC2}39m`),
+  magentaBright: createStyle(ansi16FgOpen("magentaBright"), `${ESC2}39m`),
+  cyanBright: createStyle(ansi16FgOpen("cyanBright"), `${ESC2}39m`),
+  whiteBright: createStyle(ansi16FgOpen("whiteBright"), `${ESC2}39m`),
+  bgBlack: createStyle(ansi16BgOpen("black"), `${ESC2}49m`),
+  bgRed: createStyle(ansi16BgOpen("red"), `${ESC2}49m`),
+  bgGreen: createStyle(ansi16BgOpen("green"), `${ESC2}49m`),
+  bgYellow: createStyle(ansi16BgOpen("yellow"), `${ESC2}49m`),
+  bgBlue: createStyle(ansi16BgOpen("blue"), `${ESC2}49m`),
+  bgMagenta: createStyle(ansi16BgOpen("magenta"), `${ESC2}49m`),
+  bgCyan: createStyle(ansi16BgOpen("cyan"), `${ESC2}49m`),
+  bgWhite: createStyle(ansi16BgOpen("white"), `${ESC2}49m`),
+  bgBlackBright: createStyle(ansi16BgOpen("blackBright"), `${ESC2}49m`),
+  bgRedBright: createStyle(ansi16BgOpen("redBright"), `${ESC2}49m`),
+  bgGreenBright: createStyle(ansi16BgOpen("greenBright"), `${ESC2}49m`),
+  bgYellowBright: createStyle(ansi16BgOpen("yellowBright"), `${ESC2}49m`),
+  bgBlueBright: createStyle(ansi16BgOpen("blueBright"), `${ESC2}49m`),
+  bgMagentaBright: createStyle(ansi16BgOpen("magentaBright"), `${ESC2}49m`),
+  bgCyanBright: createStyle(ansi16BgOpen("cyanBright"), `${ESC2}49m`),
+  bgWhiteBright: createStyle(ansi16BgOpen("whiteBright"), `${ESC2}49m`),
+  color: Object.freeze({
+    ansi256: (idx) => ansi256FgOpen(idx),
+    ansi16m: (r, g, b) => truecolorFgOpen({ r, g, b })
+  }),
+  bgColor: Object.freeze({
+    ansi256: (idx) => ansi256BgOpen(idx),
+    ansi16m: (r, g, b) => truecolorBgOpen({ r, g, b })
+  })
+});
+var ANSI8_COLORS = ansi8Palette();
+var ANSI16_COLORS = ansi16Palette();
+var ANSI256_COLORS = ansi256Palette();
+function ansiColors(level) {
+  if (level === 8)
+    return ANSI8_COLORS;
+  if (level === 16)
+    return ANSI16_COLORS;
+  return ANSI256_COLORS;
+}
+
+// src/utils/env.ts
+function firstNonEmptyEnv(env, primary, legacy) {
+  const primaryValue = env?.[primary];
+  if (String(primaryValue ?? "").trim() !== "")
+    return primaryValue;
+  if (!legacy)
+    return void 0;
+  const legacyValue = env?.[legacy];
+  if (String(legacyValue ?? "").trim() !== "")
+    return legacyValue;
+  return void 0;
+}
+
+// src/core/ansi/capability.ts
+function parseColorMode(raw) {
+  const v = String(raw ?? "").trim().toLowerCase();
+  if (!v)
+    return null;
+  if (v === "truecolor" || v === "24bit" || v === "rgb")
+    return "truecolor";
+  if (v === "ansi256" || v === "256" || v === "xterm256" || v === "xterm-256color") {
+    return "ansi256";
+  }
+  if (v === "ansi16" || v === "16")
+    return "ansi16";
+  if (v === "ansi8" || v === "8")
+    return "ansi8";
+  return null;
+}
+function levelForMode(mode) {
+  if (mode === "ansi8")
+    return 8;
+  if (mode === "ansi16")
+    return 16;
+  return 256;
+}
+function detectTerminalColorCapability(opts) {
+  const env = opts?.env ?? {};
+  const isTTY = opts?.isTTY ?? false;
+  const platform = String(opts?.platform ?? "").trim().toLowerCase();
+  const isWindows = platform === "win32" || String(env.OS ?? "").trim().toLowerCase() === "windows_nt";
+  const forced = parseColorMode(firstNonEmptyEnv(env, "VUE_TUI_COLOR_MODE", "DIMCODE_COLOR_MODE"));
+  if (forced)
+    return { mode: forced, level: levelForMode(forced) };
+  if (!isTTY)
+    return { mode: "truecolor", level: 256 };
+  const termProgram = String(env.TERM_PROGRAM ?? "").toLowerCase();
+  const isAppleTerminal = termProgram.includes("apple_terminal");
+  const colorterm = String(env.COLORTERM ?? "").toLowerCase();
+  if (!isAppleTerminal && (colorterm.includes("truecolor") || colorterm.includes("24bit"))) {
+    return { mode: "truecolor", level: 256 };
+  }
+  if (termProgram.includes("vscode"))
+    return { mode: "truecolor", level: 256 };
+  if (termProgram.includes("wezterm") || termProgram.includes("alacritty") || termProgram.includes("ghostty") || termProgram.includes("kitty") || termProgram.includes("iterm") || termProgram.includes("windows terminal") || termProgram.includes("windowsterminal") || termProgram.includes("tabby") || termProgram.includes("hyper") || termProgram.includes("rio") || termProgram.includes("contour")) {
+    return { mode: "truecolor", level: 256 };
+  }
+  const term = String(env.TERM ?? "").toLowerCase();
+  if (isWindows) {
+    const hasWindowsTerminal = "WT_SESSION" in env || "WT_PROFILE_ID" in env || "WT_ID" in env;
+    const hasWezterm = "WEZTERM_EXECUTABLE" in env || "WEZTERM_PANE" in env;
+    const hasAlacritty = "ALACRITTY_LOG" in env || "ALACRITTY_WINDOW_ID" in env;
+    const hasTabby = "TABBY_CONFIG_DIRECTORY" in env;
+    if (hasWindowsTerminal || hasWezterm || hasAlacritty || hasTabby)
+      return { mode: "truecolor", level: 256 };
+    if (term.includes("xterm") && term.includes("256color"))
+      return { mode: "truecolor", level: 256 };
+  }
+  if (term.includes("256color"))
+    return { mode: "ansi256", level: 256 };
+  if (term.includes("color"))
+    return { mode: "ansi16", level: 16 };
+  if (term.includes("dumb"))
+    return { mode: "ansi8", level: 8 };
+  return { mode: "ansi16", level: 16 };
+}
+
+// src/core/ansi/sgr.ts
+var ESC3 = "\x1B";
+function ansi16ToColorName(code) {
+  switch (code) {
+    case 30:
+      return "black";
+    case 31:
+      return "red";
+    case 32:
+      return "green";
+    case 33:
+      return "yellow";
+    case 34:
+      return "blue";
+    case 35:
+      return "magenta";
+    case 36:
+      return "cyan";
+    case 37:
+      return "white";
+    case 90:
+      return "blackBright";
+    case 91:
+      return "redBright";
+    case 92:
+      return "greenBright";
+    case 93:
+      return "yellowBright";
+    case 94:
+      return "blueBright";
+    case 95:
+      return "magentaBright";
+    case 96:
+      return "cyanBright";
+    case 97:
+      return "whiteBright";
+    default:
+      return void 0;
+  }
+}
+function ansi16BgToColorName(code) {
+  const fgCode = code >= 40 && code <= 47 ? code - 10 : code >= 100 && code <= 107 ? code - 10 : null;
+  if (fgCode == null)
+    return void 0;
+  return ansi16ToColorName(fgCode);
+}
+var ANSI16_RGB = {
+  black: { r: 0, g: 0, b: 0 },
+  red: { r: 201, g: 27, b: 0 },
+  green: { r: 0, g: 194, b: 0 },
+  yellow: { r: 199, g: 196, b: 0 },
+  blue: { r: 2, g: 37, b: 199 },
+  magenta: { r: 201, g: 48, b: 199 },
+  cyan: { r: 0, g: 197, b: 199 },
+  white: { r: 199, g: 199, b: 199 },
+  blackBright: { r: 104, g: 104, b: 104 },
+  redBright: { r: 255, g: 110, b: 103 },
+  greenBright: { r: 95, g: 250, b: 104 },
+  yellowBright: { r: 255, g: 252, b: 103 },
+  blueBright: { r: 104, g: 113, b: 255 },
+  magentaBright: { r: 255, g: 118, b: 255 },
+  cyanBright: { r: 95, g: 253, b: 255 },
+  whiteBright: { r: 255, g: 255, b: 255 }
+};
+function nearestAnsi16(r, g, b) {
+  let best = "white";
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const [name, rgb] of Object.entries(ANSI16_RGB)) {
+    const dr = r - rgb.r;
+    const dg = g - rgb.g;
+    const db = b - rgb.b;
+    const d = dr * dr + dg * dg + db * db;
+    if (d < bestDist) {
+      bestDist = d;
+      best = name;
+    }
+  }
+  return best;
+}
+function ansi256ToRgb2(index) {
+  const n = Math.max(0, Math.min(255, Math.trunc(index)));
+  if (n < 16) {
+    const map = [
+      "black",
+      "red",
+      "green",
+      "yellow",
+      "blue",
+      "magenta",
+      "cyan",
+      "white",
+      "blackBright",
+      "redBright",
+      "greenBright",
+      "yellowBright",
+      "blueBright",
+      "magentaBright",
+      "cyanBright",
+      "whiteBright"
+    ];
+    const name = map[n] ?? "white";
+    return ANSI16_RGB[name];
+  }
+  if (n >= 232) {
+    const c = 8 + (n - 232) * 10;
+    return { r: c, g: c, b: c };
+  }
+  const i = n - 16;
+  const rr = Math.floor(i / 36);
+  const gg = Math.floor(i % 36 / 6);
+  const bb = i % 6;
+  const toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
+  return { r: toComponent(rr), g: toComponent(gg), b: toComponent(bb) };
+}
+function applyAnsiSgrStyle(current, codes) {
+  let next = { ...current };
+  for (let i = 0; i < codes.length; i++) {
+    const code = codes[i];
+    if (code === 0) {
+      next = {};
+      continue;
+    }
+    if (code === 1) {
+      next = { ...next, bold: true };
+    } else if (code === 2) {
+      next = { ...next, dim: true };
+    } else if (code === 3) {
+      next = { ...next, italic: true };
+    } else if (code === 4) {
+      next = { ...next, underline: true };
+    } else if (code === 7) {
+      next = { ...next, inverse: true };
+    } else if (code === 22) {
+      next = { ...next, bold: false, dim: false };
+    } else if (code === 23) {
+      next = { ...next, italic: false };
+    } else if (code === 24) {
+      next = { ...next, underline: false };
+    } else if (code === 27) {
+      next = { ...next, inverse: false };
+    } else if (code === 39) {
+      next = { ...next, fg: void 0 };
+    } else if (code === 49) {
+      next = { ...next, bg: void 0 };
+    } else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+      const fg = ansi16ToColorName(code);
+      next = { ...next, fg: fg ?? next.fg };
+    } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+      const bg = ansi16BgToColorName(code);
+      next = { ...next, bg: bg ?? next.bg };
+    } else if (code === 38 || code === 48) {
+      const mode = codes[i + 1];
+      if (mode === 5) {
+        const idx = codes[i + 2];
+        if (idx != null) {
+          const { r, g, b } = ansi256ToRgb2(idx);
+          const name = nearestAnsi16(r, g, b);
+          next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
+        }
+        i += 2;
+      } else if (mode === 2) {
+        const r = codes[i + 2];
+        const g = codes[i + 3];
+        const b = codes[i + 4];
+        if (r != null && g != null && b != null) {
+          const name = nearestAnsi16(r, g, b);
+          next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
+        }
+        i += 4;
+      }
+    }
+  }
+  return next;
+}
+function parseAnsiSgr(input, baseStyle = {}) {
+  const segments = [];
+  let style = { ...baseStyle };
+  let lastIndex = 0;
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] !== ESC3 || input[i + 1] !== "[")
+      continue;
+    let j = i + 2;
+    while (j < input.length) {
+      const c = input.charCodeAt(j);
+      if (c >= 48 && c <= 57 || c === 59) {
+        j++;
+        continue;
+      }
+      break;
+    }
+    if (j >= input.length || input[j] !== "m")
+      continue;
+    if (i > lastIndex)
+      segments.push({ text: input.slice(lastIndex, i), style });
+    const body = input.slice(i + 2, j);
+    const codes = body.split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
+    style = applyAnsiSgrStyle(style, codes.length ? codes : [0]);
+    lastIndex = j + 1;
+    i = j;
+  }
+  if (lastIndex < input.length)
+    segments.push({ text: input.slice(lastIndex), style });
+  return segments;
+}
+
+// src/core/buffer/width.ts
+var fullWidthRanges = [
+  [4352, 4447],
+  [9001, 9002],
+  [11904, 42191],
+  [44032, 55203],
+  [63744, 64255],
+  [65040, 65049],
+  [65072, 65135],
+  [65280, 65376],
+  [65504, 65510]
+];
+var ambiguousWidthRanges = [
+  [161, 161],
+  [164, 164],
+  [167, 168],
+  [170, 170],
+  [173, 174],
+  [176, 180],
+  [182, 186],
+  [188, 191],
+  [198, 198],
+  [208, 208],
+  [215, 216],
+  [222, 225],
+  [230, 230],
+  [232, 234],
+  [236, 237],
+  [240, 240],
+  [242, 243],
+  [247, 250],
+  [252, 252],
+  [254, 254],
+  [257, 257],
+  [273, 273],
+  [275, 275],
+  [283, 283],
+  [294, 295],
+  [299, 299],
+  [305, 307],
+  [312, 312],
+  [319, 322],
+  [324, 324],
+  [328, 331],
+  [333, 333],
+  [338, 339],
+  [358, 359],
+  [363, 363],
+  [462, 462],
+  [464, 464],
+  [466, 466],
+  [468, 468],
+  [470, 470],
+  [472, 472],
+  [474, 474],
+  [476, 476],
+  [593, 593],
+  [609, 609],
+  [708, 708],
+  [711, 711],
+  [713, 715],
+  [717, 717],
+  [720, 720],
+  [728, 731],
+  [733, 733],
+  [735, 735],
+  [913, 929],
+  [931, 937],
+  [945, 961],
+  [963, 969],
+  [1025, 1025],
+  [1040, 1103],
+  [1105, 1105],
+  [8208, 8213],
+  [8216, 8217],
+  [8220, 8221],
+  [8224, 8226],
+  [8228, 8231],
+  [8240, 8240],
+  [8242, 8243],
+  [8245, 8245],
+  [8251, 8251],
+  [8254, 8254],
+  [8308, 8308],
+  [8319, 8319],
+  [8321, 8324],
+  [8364, 8364],
+  [8451, 8451],
+  [8453, 8453],
+  [8457, 8457],
+  [8467, 8467],
+  [8470, 8470],
+  [8481, 8482],
+  [8486, 8486],
+  [8491, 8491],
+  [8531, 8532],
+  [8539, 8542],
+  [8544, 8555],
+  [8560, 8569],
+  [8585, 8585],
+  [8592, 8601],
+  [8632, 8633],
+  [8658, 8658],
+  [8660, 8660],
+  [8679, 8679],
+  [8704, 8704],
+  [8706, 8707],
+  [8711, 8712],
+  [8715, 8715],
+  [8719, 8719],
+  [8721, 8721],
+  [8725, 8725],
+  [8730, 8730],
+  [8733, 8736],
+  [8739, 8739],
+  [8741, 8741],
+  [8743, 8748],
+  [8750, 8750],
+  [8756, 8759],
+  [8764, 8765],
+  [8776, 8776],
+  [8780, 8780],
+  [8786, 8786],
+  [8800, 8801],
+  [8804, 8807],
+  [8810, 8811],
+  [8814, 8815],
+  [8834, 8835],
+  [8838, 8839],
+  [8853, 8853],
+  [8857, 8857],
+  [8869, 8869],
+  [8895, 8895],
+  [8978, 8978],
+  [9312, 9449],
+  [9451, 9471],
+  [9600, 9615],
+  [9618, 9621],
+  [9632, 9633],
+  [9635, 9641],
+  [9650, 9651],
+  [9654, 9655],
+  [9660, 9661],
+  [9664, 9665],
+  [9670, 9672],
+  [9675, 9675],
+  [9678, 9681],
+  [9698, 9701],
+  [9711, 9711],
+  [9733, 9734],
+  [9737, 9737],
+  [9742, 9743],
+  [9756, 9756],
+  [9758, 9758],
+  [9792, 9792],
+  [9794, 9794],
+  [9824, 9825],
+  [9827, 9829],
+  [9831, 9834],
+  [9836, 9837],
+  [9839, 9839],
+  [10045, 10045],
+  [10102, 10111],
+  [11094, 11094],
+  [57344, 63743],
+  [65533, 65533]
+];
+function isFullWidthCodePoint(codePoint) {
+  if (codePoint < 4352 || codePoint > 65510)
+    return false;
+  for (const [start, end] of fullWidthRanges) {
+    if (codePoint < start)
+      return false;
+    if (codePoint <= end)
+      return true;
+  }
+  return false;
+}
+function isAmbiguousWidthCodePoint(codePoint) {
+  if (codePoint < 161 || codePoint > 65533)
+    return false;
+  for (const [start, end] of ambiguousWidthRanges) {
+    if (codePoint < start)
+      return false;
+    if (codePoint <= end)
+      return true;
+  }
+  return false;
+}
+function isEmojiLike(codePoint) {
+  return codePoint >= 127744 && codePoint <= 129791 || codePoint >= 127462 && codePoint <= 127487;
+}
+var extendedPictographicRe = null;
+try {
+  extendedPictographicRe = new RegExp("\\p{Extended_Pictographic}", "u");
+} catch {
+  extendedPictographicRe = null;
+}
+var emojiPresentationRe = null;
+try {
+  emojiPresentationRe = new RegExp("\\p{Emoji_Presentation}", "u");
+} catch {
+  emojiPresentationRe = null;
+}
+var emojiRe = null;
+try {
+  emojiRe = new RegExp("\\p{Emoji}", "u");
+} catch {
+  emojiRe = null;
+}
+function normalizeCustomWidth(width) {
+  return width === 2 ? 2 : 1;
+}
+function charCellWidth(text, provider = "default") {
+  if (!text)
+    return 1;
+  if (typeof provider === "function")
+    return normalizeCustomWidth(provider(text));
+  if (provider !== "cjk" && text.length === 1) {
+    const code = text.charCodeAt(0);
+    if (code < 4352)
+      return 1;
+  }
+  const codePoint = text.codePointAt(0);
+  if (codePoint == null)
+    return 1;
+  const hasVs16 = text.includes("\uFE0F");
+  if (isFullWidthCodePoint(codePoint))
+    return 2;
+  if (provider === "cjk" && isAmbiguousWidthCodePoint(codePoint))
+    return 2;
+  if (isEmojiLike(codePoint))
+    return 2;
+  if (emojiPresentationRe?.test(text))
+    return 2;
+  if (text.includes("\u20E3"))
+    return 2;
+  if (hasVs16 && emojiRe?.test(text))
+    return 2;
+  if (extendedPictographicRe?.test(text)) {
+    if (codePoint <= 65535)
+      return hasVs16 ? 2 : 1;
+    return 2;
+  }
+  return 1;
+}
+
+// src/utils/url-safety.ts
+var ENCODED_ASCII_CONTROL_RE = /%(?:0[0-9a-f]|1[0-9a-f]|7f)/i;
+function hasControlCodePoint(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code <= 31 || code >= 127 && code <= 159)
+      return true;
+  }
+  return false;
+}
+function hasEncodedControl(value) {
+  let current = String(value ?? "");
+  for (let depth = 0; depth < 3; depth++) {
+    if (ENCODED_ASCII_CONTROL_RE.test(current))
+      return true;
+    let decoded;
+    try {
+      decoded = decodeURIComponent(current);
+    } catch {
+      return true;
+    }
+    if (hasControlCodePoint(decoded))
+      return true;
+    if (decoded === current)
+      return false;
+    current = decoded;
+  }
+  return ENCODED_ASCII_CONTROL_RE.test(current) || hasControlCodePoint(current);
+}
+
+// src/core/hyperlink.ts
+var SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+var BLOCKED_SCHEME_RE = /^(?:javascript|data|vbscript):/i;
+var SAFE_RELATIVE_HREF_RE = /^(?:[A-Za-z0-9._~!$&()*+,;=:@/?#-]|%[0-9A-Fa-f]{2})+$/u;
+function normalizeRawHref(value) {
+  if (typeof value !== "string")
+    return null;
+  const raw = value.trim();
+  if (!raw)
+    return null;
+  if (raw !== value)
+    return null;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code <= 31 || code >= 127 && code <= 159)
+      return null;
+  }
+  if (/\s/u.test(raw))
+    return null;
+  if (raw.startsWith("//"))
+    return null;
+  if (BLOCKED_SCHEME_RE.test(raw))
+    return null;
+  if (hasEncodedControl(raw))
+    return null;
+  return raw;
+}
+function hrefScheme(raw) {
+  return raw.match(SCHEME_RE)?.[0].toLowerCase() ?? null;
+}
+function parseSafeAbsoluteUrl(raw) {
+  if (raw.includes("\\"))
+    return null;
+  try {
+    return new URL(raw);
+  } catch {
+    return null;
+  }
+}
+function sanitizeAbsoluteHref(raw, options = {}) {
+  const url = parseSafeAbsoluteUrl(raw);
+  if (!url)
+    return null;
+  if (url.protocol === "http:" || url.protocol === "https:") {
+    if (!/^https?:\/\//i.test(raw))
+      return null;
+    return options.preserveHttpHref ? raw : url.toString();
+  }
+  if (url.protocol === "mailto:")
+    return raw;
+  return null;
+}
+function isSafeNormalizedRelativeHref(raw) {
+  if (raw.includes("\\"))
+    return false;
+  if (raw.startsWith("//"))
+    return false;
+  if (SCHEME_RE.test(raw))
+    return false;
+  if (hasEncodedControl(raw))
+    return false;
+  if (!SAFE_RELATIVE_HREF_RE.test(raw))
+    return false;
+  return raw.startsWith("#") || raw.startsWith("?") || raw.startsWith("/") || raw.startsWith("./") || raw.startsWith("../") || /^[A-Za-z0-9._~-]/u.test(raw);
+}
+function isSafeRelativeHref(value) {
+  const raw = normalizeRawHref(value);
+  return raw != null && isSafeNormalizedRelativeHref(raw);
+}
+function sanitizeTerminalHref(value, options = {}) {
+  const raw = normalizeRawHref(value);
+  if (!raw)
+    return null;
+  const sanitized = sanitizeAbsoluteHref(raw, { preserveHttpHref: true });
+  if (sanitized)
+    return sanitized;
+  if (options.allowFileUrls) {
+    const url = parseSafeAbsoluteUrl(raw);
+    if (url?.protocol === "file:")
+      return url.toString();
+  }
+  return null;
+}
+function sanitizeDomHref(value, options = {}) {
+  const raw = normalizeRawHref(value);
+  if (!raw)
+    return null;
+  const scheme = hrefScheme(raw);
+  if (!scheme) {
+    return options.allowRelative !== false && isSafeNormalizedRelativeHref(raw) ? raw : null;
+  }
+  return sanitizeAbsoluteHref(raw);
+}
+
+// src/core/render-plane.ts
+var TERMINAL_RENDER_PLANES = ["default", "transcript", "chrome", "overlay"];
+
+// src/utils/grapheme.ts
+var graphemeSegmenter = null;
+try {
+  const Segmenter = typeof Intl !== "undefined" ? Intl.Segmenter : void 0;
+  graphemeSegmenter = Segmenter ? new Segmenter(void 0, { granularity: "grapheme" }) : null;
+} catch {
+  graphemeSegmenter = null;
+}
+var unicodeMarkRe = null;
+try {
+  unicodeMarkRe = new RegExp("\\p{Mark}", "u");
+} catch {
+  unicodeMarkRe = null;
+}
+function needsGraphemeSegmentation(text) {
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp === 8205)
+      return true;
+    if (cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999)
+      return true;
+    if (isCombiningMark(cp))
+      return true;
+    if (cp >= 127995 && cp <= 127999)
+      return true;
+    if (cp >= 127462 && cp <= 127487)
+      return true;
+    if (cp >= 917504 && cp <= 917631)
+      return true;
+  }
+  return false;
+}
+function isVariationSelector(codePoint) {
+  return codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isCombiningMark(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || isDevanagariMark(codePoint) || unicodeMarkRe?.test(String.fromCodePoint(codePoint)) === true;
+}
+function isDevanagariMark(codePoint) {
+  return codePoint >= 2304 && codePoint <= 2307 || codePoint >= 2362 && codePoint <= 2364 || codePoint >= 2366 && codePoint <= 2383 || codePoint >= 2385 && codePoint <= 2391 || codePoint >= 2402 && codePoint <= 2403;
+}
+function isVirama(codePoint) {
+  return codePoint === 2381;
+}
+function isEmojiModifier(codePoint) {
+  return codePoint >= 127995 && codePoint <= 127999;
+}
+function isRegionalIndicator(codePoint) {
+  return codePoint >= 127462 && codePoint <= 127487;
+}
+function isEmojiTag(codePoint) {
+  return codePoint >= 917504 && codePoint <= 917631;
+}
+function fallbackGraphemeSegments(text) {
+  const out = [];
+  let segment = "";
+  let segmentStart = 0;
+  let pos = 0;
+  let regionalIndicators = 0;
+  let joinNext = false;
+  const pushSegment = () => {
+    if (segment)
+      out.push({ segment, index: segmentStart });
+  };
+  for (const ch of text) {
+    const codePoint = ch.codePointAt(0);
+    const chStart = pos;
+    pos += ch.length;
+    const attach = segment !== "" && (joinNext || codePoint === 8205 || isVariationSelector(codePoint) || isCombiningMark(codePoint) || isEmojiModifier(codePoint) || isEmojiTag(codePoint) || isRegionalIndicator(codePoint) && regionalIndicators === 1);
+    if (!attach) {
+      pushSegment();
+      segment = ch;
+      segmentStart = chStart;
+      regionalIndicators = isRegionalIndicator(codePoint) ? 1 : 0;
+    } else {
+      segment += ch;
+      if (isRegionalIndicator(codePoint))
+        regionalIndicators++;
+      else if (!isVariationSelector(codePoint) && !isCombiningMark(codePoint))
+        regionalIndicators = 0;
+    }
+    if (codePoint === 8205 || isVirama(codePoint))
+      joinNext = true;
+    else if (joinNext && !isVariationSelector(codePoint) && !isCombiningMark(codePoint)) {
+      joinNext = false;
+    }
+  }
+  pushSegment();
+  return out;
+}
+function segmentedGraphemes(text) {
+  if (!needsGraphemeSegmentation(text))
+    return null;
+  if (graphemeSegmenter)
+    return graphemeSegmenter.segment(text);
+  return fallbackGraphemeSegments(text);
+}
+
+// src/core/buffer/buffer.ts
+var DEFAULT_STYLE = Object.freeze({});
+var styleCache = /* @__PURE__ */ new WeakMap();
+var blankCellCache = /* @__PURE__ */ new WeakMap();
+var continuationCellCache = /* @__PURE__ */ new WeakMap();
+var cellCacheWidth1 = /* @__PURE__ */ new WeakMap();
+var cellCacheWidth2 = /* @__PURE__ */ new WeakMap();
+var MAX_CACHED_CELLS_PER_STYLE = 128;
+function normalizeStyle(style) {
+  if (!style)
+    return DEFAULT_STYLE;
+  if (Object.isFrozen(style))
+    return style;
+  const cached = styleCache.get(style);
+  if (cached)
+    return cached;
+  const frozen = Object.freeze({ ...style });
+  styleCache.set(style, frozen);
+  return frozen;
+}
+function getOrCreateCellCache(map, style) {
+  const cached = map.get(style);
+  if (cached)
+    return cached;
+  const next = /* @__PURE__ */ new Map();
+  map.set(style, next);
+  return next;
+}
+function createCell(ch, style, widthProvider) {
+  if (ch === " ")
+    return createBlankCell(style);
+  const normalizedStyle = normalizeStyle(style);
+  const width = charCellWidth(ch, widthProvider);
+  const map = width === 2 ? getOrCreateCellCache(cellCacheWidth2, normalizedStyle) : getOrCreateCellCache(cellCacheWidth1, normalizedStyle);
+  const cached = map.get(ch);
+  if (cached)
+    return cached;
+  const cell = { ch, width, style: normalizedStyle };
+  map.set(ch, cell);
+  if (map.size > MAX_CACHED_CELLS_PER_STYLE)
+    map.clear();
+  return cell;
+}
+function createBlankCell(style) {
+  const normalizedStyle = normalizeStyle(style);
+  const cached = blankCellCache.get(normalizedStyle);
+  if (cached)
+    return cached;
+  const cell = Object.freeze({
+    ch: " ",
+    width: 1,
+    style: normalizedStyle
+  });
+  blankCellCache.set(normalizedStyle, cell);
+  return cell;
+}
+function createContinuationCell(style) {
+  const normalizedStyle = normalizeStyle(style);
+  const cached = continuationCellCache.get(normalizedStyle);
+  if (cached)
+    return cached;
+  const cell = Object.freeze({
+    ch: "",
+    width: 1,
+    continuation: true,
+    style: normalizedStyle
+  });
+  continuationCellCache.set(normalizedStyle, cell);
+  return cell;
+}
+function createGridBuffer(cols, rows, options = {}) {
+  const safeCols = Math.max(0, Math.floor(cols));
+  const safeRows = Math.max(0, Math.floor(rows));
+  const blank = createBlankCell();
+  const grid = Array.from(
+    { length: safeRows },
+    () => Array.from({ length: safeCols }, () => blank)
+  );
+  return {
+    cols: safeCols,
+    rows: safeRows,
+    grid,
+    gridStart: 0,
+    dirtyBits: new Uint8Array(safeRows),
+    dirtyCount: safeRows || 0,
+    dirtyMin: safeRows ? 0 : Number.POSITIVE_INFINITY,
+    dirtyMax: safeRows ? safeRows - 1 : -1,
+    dirtyAll: safeRows > 0,
+    cursorX: 0,
+    cursorY: 0,
+    cursorVisible: true,
+    cursorStyle: DEFAULT_STYLE,
+    scrollback: [],
+    scrollbackLimit: 1e3,
+    rowPool: [],
+    soaFingerprints: null,
+    fingerprintFn: null,
+    widthProvider: options.widthProvider ?? "default"
+  };
+}
+function clamp(n, min, max) {
+  return Math.max(min, Math.min(max, n));
+}
+function setFingerprintFn(buffer, fn) {
+  buffer.fingerprintFn = fn;
+  const len = buffer.rows * buffer.cols;
+  if (!len) {
+    buffer.soaFingerprints = null;
+    return;
+  }
+  buffer.soaFingerprints = new Uint32Array(len);
+  for (let y = 0; y < buffer.rows; y++) {
+    const row = getBufferRow(buffer, y);
+    const physY = physicalRowIndex(buffer, y);
+    const base = physY * buffer.cols;
+    for (let x = 0; x < buffer.cols; x++) {
+      const cell = row[x];
+      buffer.soaFingerprints[base + x] = fn(cell.ch, cell.style);
+    }
+  }
+}
+function getRowFingerprints(buffer, y) {
+  if (!buffer.soaFingerprints)
+    return null;
+  const physY = physicalRowIndex(buffer, y);
+  const base = physY * buffer.cols;
+  return buffer.soaFingerprints.subarray(base, base + buffer.cols);
+}
+function updateCellFingerprint(buffer, physY, x, ch, style) {
+  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
+    return;
+  buffer.soaFingerprints[physY * buffer.cols + x] = buffer.fingerprintFn(ch, style);
+}
+function updateRangeFingerprint(buffer, physY, x0, x1, ch, style) {
+  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
+    return;
+  const fp = buffer.fingerprintFn(ch, style);
+  const base = physY * buffer.cols;
+  for (let x = x0; x < x1; x++) {
+    buffer.soaFingerprints[base + x] = fp;
+  }
+}
+function physicalRowIndex(buffer, y) {
+  return (buffer.gridStart + y) % buffer.rows;
+}
+function getBufferRow(buffer, y) {
+  return buffer.grid[physicalRowIndex(buffer, y)];
+}
+function getBufferCell(buffer, x, y) {
+  return getBufferRow(buffer, y)[x];
+}
+function markAllDirty(buffer) {
+  if (buffer.rows <= 0)
+    return;
+  buffer.dirtyAll = true;
+  buffer.dirtyCount = buffer.rows;
+  buffer.dirtyMin = 0;
+  buffer.dirtyMax = buffer.rows - 1;
+}
+function markDirty(buffer, y) {
+  if (buffer.dirtyAll)
+    return;
+  if (y < 0 || y >= buffer.rows)
+    return;
+  if (buffer.dirtyBits[y]) {
+    return;
+  }
+  buffer.dirtyBits[y] = 1;
+  buffer.dirtyCount++;
+  if (y < buffer.dirtyMin)
+    buffer.dirtyMin = y;
+  if (y > buffer.dirtyMax)
+    buffer.dirtyMax = y;
+}
+function clearCellRange(row, startX, endXExclusive) {
+  const blank = createBlankCell();
+  for (let x = startX; x < endXExclusive; x++)
+    row[x] = blank;
+}
+function clearWideIfOverwriting(row, x) {
+  const cell = row[x];
+  if (!cell)
+    return;
+  if (cell.continuation) {
+    if (x - 1 >= 0)
+      row[x - 1] = createBlankCell();
+    row[x] = createBlankCell();
+    return;
+  }
+  if (cell.width === 2) {
+    row[x] = createBlankCell();
+    if (x + 1 < row.length)
+      row[x + 1] = createBlankCell();
+  }
+}
+function putCell(buffer, x, y, ch, style) {
+  if (y < 0 || y >= buffer.rows)
+    return;
+  if (x < 0 || x >= buffer.cols)
+    return;
+  const row = getBufferRow(buffer, y);
+  const width = charCellWidth(ch, buffer.widthProvider);
+  const previous = row[x];
+  const next = width === 2 && x + 1 < buffer.cols ? row[x + 1] : void 0;
+  const previousWideOverlap = Boolean(
+    previous?.continuation || previous?.width === 2 || next?.continuation || next?.width === 2
+  );
+  clearWideIfOverwriting(row, x);
+  if (width === 2 && x + 1 < buffer.cols)
+    clearWideIfOverwriting(row, x + 1);
+  if (width === 2 && x + 1 >= buffer.cols) {
+    const blank = createBlankCell();
+    row[x] = blank;
+    if (buffer.soaFingerprints) {
+      if (previousWideOverlap) {
+        recomputeFingerprintsForRows(buffer, y, y + 1);
+      } else {
+        const physY = physicalRowIndex(buffer, y);
+        updateCellFingerprint(buffer, physY, x, blank.ch, blank.style);
+      }
+    }
+    markDirty(buffer, y);
+    return;
+  }
+  const cell = createCell(ch, style, buffer.widthProvider);
+  row[x] = cell;
+  if (width === 2 && x + 1 < buffer.cols)
+    row[x + 1] = createContinuationCell(style);
+  if (buffer.soaFingerprints) {
+    if (previousWideOverlap) {
+      recomputeFingerprintsForRows(buffer, y, y + 1);
+    } else {
+      const physY = physicalRowIndex(buffer, y);
+      updateCellFingerprint(buffer, physY, x, cell.ch, cell.style);
+      if (width === 2 && x + 1 < buffer.cols) {
+        updateCellFingerprint(buffer, physY, x + 1, "", cell.style);
+      }
+    }
+  }
+  markDirty(buffer, y);
+}
+function fillRect(buffer, x, y, w, h, ch = " ", style) {
+  if (w <= 0 || h <= 0 || buffer.cols === 0 || buffer.rows === 0)
+    return;
+  const x0 = clamp(Math.floor(x), 0, buffer.cols);
+  const y0 = clamp(Math.floor(y), 0, buffer.rows);
+  const x1 = clamp(Math.floor(x + w), 0, buffer.cols);
+  const y1 = clamp(Math.floor(y + h), 0, buffer.rows);
+  if (x1 <= x0 || y1 <= y0)
+    return;
+  const width = charCellWidth(ch, buffer.widthProvider);
+  if (width === 1) {
+    const fillCell2 = createCell(ch, style, buffer.widthProvider);
+    const blank2 = createBlankCell();
+    for (let yy = y0; yy < y1; yy++) {
+      const row = getBufferRow(buffer, yy);
+      const clearsLeftWideBase = Boolean(row[x0]?.continuation);
+      const clearsRightContinuation = Boolean(x1 < buffer.cols && row[x1]?.continuation);
+      if (clearsLeftWideBase)
+        clearWideIfOverwriting(row, x0);
+      row.fill(fillCell2, x0, x1);
+      if (clearsRightContinuation)
+        row[x1] = blank2;
+      if (buffer.soaFingerprints) {
+        if (clearsLeftWideBase || clearsRightContinuation) {
+          recomputeFingerprintsForRows(buffer, yy, yy + 1);
+        } else {
+          const physY = physicalRowIndex(buffer, yy);
+          updateRangeFingerprint(buffer, physY, x0, x1, fillCell2.ch, fillCell2.style);
+        }
+      }
+      markDirty(buffer, yy);
+    }
+    return;
+  }
+  const fillCell = createCell(ch, style, buffer.widthProvider);
+  const continuationCell = createContinuationCell(style);
+  const blank = createBlankCell();
+  for (let yy = y0; yy < y1; yy++) {
+    const row = getBufferRow(buffer, yy);
+    for (let xx = x0; xx < x1; ) {
+      clearWideIfOverwriting(row, xx);
+      if (xx + 1 >= x1 || xx + 1 >= buffer.cols) {
+        row[xx] = blank;
+        xx += 1;
+        continue;
+      }
+      clearWideIfOverwriting(row, xx + 1);
+      row[xx] = fillCell;
+      row[xx + 1] = continuationCell;
+      xx += 2;
+    }
+    recomputeFingerprintsForRows(buffer, yy, yy + 1);
+    markDirty(buffer, yy);
+  }
+}
+function clearRect(buffer, x, y, w, h) {
+  if (buffer.cols === 0 || buffer.rows === 0)
+    return;
+  if (x == null || y == null || w == null || h == null) {
+    const blank = createBlankCell();
+    for (let yy = 0; yy < buffer.rows; yy++) {
+      const row = getBufferRow(buffer, yy);
+      row.length = buffer.cols;
+      for (let xx = 0; xx < buffer.cols; xx++)
+        row[xx] = blank;
+    }
+    recomputeFingerprintsForRows(buffer, 0, buffer.rows);
+    markAllDirty(buffer);
+    buffer.cursorX = 0;
+    buffer.cursorY = 0;
+    return;
+  }
+  if (w <= 0 || h <= 0)
+    return;
+  const x0 = clamp(Math.floor(x), 0, buffer.cols);
+  const y0 = clamp(Math.floor(y), 0, buffer.rows);
+  const x1 = clamp(Math.floor(x + w), 0, buffer.cols);
+  const y1 = clamp(Math.floor(y + h), 0, buffer.rows);
+  if (x1 <= x0 || y1 <= y0)
+    return;
+  for (let yy = y0; yy < y1; yy++) {
+    const row = getBufferRow(buffer, yy);
+    if (row[x0]?.continuation)
+      clearWideIfOverwriting(row, x0);
+    clearCellRange(row, x0, x1);
+    if (x1 < buffer.cols && row[x1]?.continuation)
+      row[x1] = createBlankCell();
+    recomputeFingerprintsForRows(buffer, yy, yy + 1);
+    markDirty(buffer, yy);
+  }
+}
+function takePooledRow(buffer) {
+  const row = buffer.rowPool.pop();
+  return row ?? null;
+}
+function blankRow(buffer) {
+  const pooled = takePooledRow(buffer);
+  if (!pooled)
+    return Array.from({ length: buffer.cols }, () => createBlankCell());
+  pooled.length = buffer.cols;
+  const blank = createBlankCell();
+  for (let x = 0; x < buffer.cols; x++)
+    pooled[x] = blank;
+  return pooled;
+}
+function recomputeFingerprintsForRows(buffer, startY, endY) {
+  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
+    return;
+  for (let y = startY; y < endY; y++) {
+    const row = getBufferRow(buffer, y);
+    const physY = physicalRowIndex(buffer, y);
+    const base = physY * buffer.cols;
+    for (let x = 0; x < buffer.cols; x++) {
+      const cell = row[x];
+      buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+    }
+  }
+}
+function recomputeAllVisibleFingerprints(buffer) {
+  recomputeFingerprintsForRows(buffer, 0, buffer.rows);
+}
+function scrollBuffer(buffer, lines) {
+  const raw = Math.trunc(lines);
+  if (raw === 0 || buffer.rows === 0)
+    return;
+  const abs = Math.min(Math.abs(raw), buffer.rows);
+  const n = raw > 0 ? abs : -abs;
+  if (n > 0) {
+    for (let i = 0; i < n; i++) {
+      const removedIdx = buffer.gridStart;
+      const removed = buffer.grid[removedIdx];
+      if (buffer.scrollbackLimit > 0) {
+        buffer.scrollback.push(removed);
+        if (buffer.scrollback.length > buffer.scrollbackLimit) {
+          const excess = buffer.scrollback.length - buffer.scrollbackLimit;
+          const dropped = buffer.scrollback.splice(0, excess);
+          buffer.rowPool.push(...dropped);
+        }
+      } else {
+        buffer.rowPool.push(removed);
+      }
+      buffer.gridStart = (buffer.gridStart + 1) % buffer.rows;
+      const bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
+      buffer.grid[bottomIdx] = blankRow(buffer);
+    }
+  } else {
+    for (let i = 0; i < -n; i++) {
+      const bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
+      const removed = buffer.grid[bottomIdx];
+      buffer.rowPool.push(removed);
+      buffer.gridStart = (buffer.gridStart - 1 + buffer.rows) % buffer.rows;
+      buffer.grid[buffer.gridStart] = blankRow(buffer);
+    }
+  }
+  const inserted = Math.abs(n);
+  if (inserted >= buffer.rows) {
+    recomputeAllVisibleFingerprints(buffer);
+  } else if (n > 0) {
+    recomputeFingerprintsForRows(buffer, buffer.rows - inserted, buffer.rows);
+  } else {
+    recomputeFingerprintsForRows(buffer, 0, inserted);
+  }
+  markAllDirty(buffer);
+  buffer.cursorY = clamp(buffer.cursorY - n, 0, Math.max(0, buffer.rows - 1));
+}
+function scrollBufferRegion(buffer, startY, endY, lines) {
+  const n = Math.trunc(lines);
+  if (n === 0 || buffer.rows === 0)
+    return [];
+  const start = clamp(Math.floor(startY), 0, buffer.rows);
+  const end = clamp(Math.floor(endY), 0, buffer.rows);
+  const height = end - start;
+  if (height <= 0)
+    return [];
+  const absDelta = Math.abs(n);
+  const insertedRows = [];
+  const replaceRegionWithBlankRows = () => {
+    for (let y = start; y < end; y++) {
+      const physY = physicalRowIndex(buffer, y);
+      buffer.rowPool.push(buffer.grid[physY]);
+      buffer.grid[physY] = blankRow(buffer);
+      markDirty(buffer, y);
+      insertedRows.push(y);
+    }
+  };
+  if (absDelta >= height) {
+    replaceRegionWithBlankRows();
+    recomputeFingerprintsForRows(buffer, start, end);
+    if (buffer.cursorY >= start && buffer.cursorY < end)
+      buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
+    return insertedRows;
+  }
+  const regionRows = [];
+  for (let y = start; y < end; y++)
+    regionRows.push(getBufferRow(buffer, y));
+  const nextRows = Array.from({ length: height }, () => []);
+  if (n > 0) {
+    const movedCount = height - n;
+    for (let i = 0; i < movedCount; i++)
+      nextRows[i] = regionRows[i + n];
+    for (let i = 0; i < n; i++) {
+      buffer.rowPool.push(regionRows[i]);
+      const y = end - n + i;
+      nextRows[movedCount + i] = blankRow(buffer);
+      markDirty(buffer, y);
+      insertedRows.push(y);
+    }
+  } else {
+    const insertedCount = -n;
+    const movedCount = height - insertedCount;
+    for (let i = 0; i < insertedCount; i++) {
+      buffer.rowPool.push(regionRows[height - insertedCount + i]);
+      const y = start + i;
+      nextRows[i] = blankRow(buffer);
+      markDirty(buffer, y);
+      insertedRows.push(y);
+    }
+    for (let i = 0; i < movedCount; i++)
+      nextRows[insertedCount + i] = regionRows[i];
+  }
+  for (let i = 0; i < height; i++) {
+    const physY = physicalRowIndex(buffer, start + i);
+    buffer.grid[physY] = nextRows[i];
+  }
+  recomputeFingerprintsForRows(buffer, start, end);
+  if (buffer.cursorY >= start && buffer.cursorY < end)
+    buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
+  return insertedRows;
+}
+function resizeBuffer(buffer, cols, rows) {
+  const nextCols = Math.max(0, Math.floor(cols));
+  const nextRows = Math.max(0, Math.floor(rows));
+  if (nextCols === buffer.cols && nextRows === buffer.rows)
+    return;
+  const blank = createBlankCell();
+  const nextGrid = Array.from(
+    { length: nextRows },
+    () => Array.from({ length: nextCols }, () => blank)
+  );
+  const copyRows = Math.min(buffer.rows, nextRows);
+  const copyCols = Math.min(buffer.cols, nextCols);
+  for (let y = 0; y < copyRows; y++) {
+    const src = getBufferRow(buffer, y);
+    const dst = nextGrid[y];
+    for (let x = 0; x < copyCols; x++)
+      dst[x] = src[x];
+  }
+  if (nextCols > 0) {
+    for (let y = 0; y < nextGrid.length; y++) {
+      const row = nextGrid[y];
+      for (let x = 0; x < nextCols; x++) {
+        const cell = row[x];
+        if (cell.continuation) {
+          if (x === 0 || row[x - 1]?.width !== 2 || row[x - 1]?.continuation)
+            row[x] = blank;
+          continue;
+        }
+        if (cell.width === 2 && (x + 1 >= nextCols || !row[x + 1]?.continuation)) {
+          row[x] = blank;
+        }
+      }
+    }
+  }
+  for (let y = 0; y < buffer.rows; y++)
+    buffer.rowPool.push(getBufferRow(buffer, y));
+  buffer.grid = nextGrid;
+  buffer.gridStart = 0;
+  buffer.cols = nextCols;
+  buffer.rows = nextRows;
+  buffer.dirtyBits = new Uint8Array(nextRows);
+  buffer.dirtyCount = nextRows || 0;
+  buffer.dirtyMin = nextRows ? 0 : Number.POSITIVE_INFINITY;
+  buffer.dirtyMax = nextRows ? nextRows - 1 : -1;
+  buffer.dirtyAll = nextRows > 0;
+  buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols));
+  buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1));
+  if (buffer.fingerprintFn) {
+    const len = nextRows * nextCols;
+    if (len > 0) {
+      buffer.soaFingerprints = new Uint32Array(len);
+      for (let y = 0; y < nextRows; y++) {
+        const row = nextGrid[y];
+        const base = y * nextCols;
+        for (let x = 0; x < nextCols; x++) {
+          const cell = row[x];
+          buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+        }
+      }
+    } else {
+      buffer.soaFingerprints = null;
+    }
+  }
+}
+function snapshotText(buffer) {
+  const out = [];
+  for (let y = 0; y < buffer.rows; y++) {
+    const row = getBufferRow(buffer, y);
+    out.push(row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
+  }
+  return out;
+}
+
+// src/core/terminal/emitter.ts
+var emitterListeners = /* @__PURE__ */ new WeakMap();
+var Emitter = class {
+  constructor() {
+    emitterListeners.set(this, /* @__PURE__ */ new Map());
+  }
+  getListeners() {
+    return emitterListeners.get(this);
+  }
+  on(event, cb) {
+    const listeners = this.getListeners();
+    let set = listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+    }
+    set.add(cb);
+    return () => {
+      set.delete(cb);
+      if (set.size === 0)
+        listeners.delete(event);
+    };
+  }
+  emit(event, payload) {
+    const set = this.getListeners().get(event);
+    if (!set)
+      return;
+    for (const cb of set)
+      cb(payload);
+  }
+  clear() {
+    this.getListeners().clear();
+  }
+};
+
+// src/core/terminal/create-terminal.ts
+function isControlChar(ch) {
+  return ch === "\n" || ch === "\r" || ch === "	";
+}
+function mergePlanes(prev, next) {
+  if (!prev?.length)
+    return next?.length ? [...next] : null;
+  if (!next?.length)
+    return prev;
+  const merged = new Set(prev);
+  for (const plane of next)
+    merged.add(plane);
+  return Array.from(merged);
+}
+var TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals");
+function createCoverage(cols, rows) {
+  return Array.from({ length: rows }, () => new Uint8Array(cols));
+}
+function resizeCoverage(prev, cols, rows) {
+  const next = createCoverage(cols, rows);
+  const copyRows = Math.min(prev.length, rows);
+  for (let y = 0; y < copyRows; y++) {
+    const src = prev[y];
+    const dst = next[y];
+    dst.set(src.subarray(0, Math.min(src.length, cols)));
+  }
+  return next;
+}
+function setBufferClean(buffer) {
+  buffer.dirtyBits.fill(0);
+  buffer.dirtyCount = 0;
+  buffer.dirtyMin = Number.POSITIVE_INFINITY;
+  buffer.dirtyMax = -1;
+  buffer.dirtyAll = false;
+}
+function createPlaneState(cols, rows, widthProvider) {
+  const buffer = createGridBuffer(cols, rows, { widthProvider });
+  setBufferClean(buffer);
+  buffer.cursorVisible = false;
+  return {
+    buffer,
+    coverage: createCoverage(cols, rows)
+  };
+}
+function collectAndClearDirtyRows(buffer) {
+  if (buffer.rows === 0)
+    return [];
+  if (buffer.dirtyAll) {
+    buffer.dirtyAll = false;
+    buffer.dirtyBits.fill(0);
+    buffer.dirtyCount = 0;
+    buffer.dirtyMin = Number.POSITIVE_INFINITY;
+    buffer.dirtyMax = -1;
+    return null;
+  }
+  if (buffer.dirtyCount === 0)
+    return [];
+  const out = [];
+  const start = Math.max(0, buffer.dirtyMin);
+  const end = Math.min(buffer.rows - 1, buffer.dirtyMax);
+  for (let y = start; y <= end; y++) {
+    if (buffer.dirtyBits[y]) {
+      buffer.dirtyBits[y] = 0;
+      out.push(y);
+      if (out.length === buffer.dirtyCount)
+        break;
+    }
+  }
+  buffer.dirtyCount = 0;
+  buffer.dirtyMin = Number.POSITIVE_INFINITY;
+  buffer.dirtyMax = -1;
+  return out;
+}
+function peekDirtyRows(buffer) {
+  if (buffer.rows === 0)
+    return [];
+  if (buffer.dirtyAll)
+    return null;
+  if (buffer.dirtyCount === 0)
+    return [];
+  const out = [];
+  const start = Math.max(0, buffer.dirtyMin);
+  const end = Math.min(buffer.rows - 1, buffer.dirtyMax);
+  for (let y = start; y <= end; y++) {
+    if (buffer.dirtyBits[y]) {
+      out.push(y);
+      if (out.length === buffer.dirtyCount)
+        break;
+    }
+  }
+  return out;
+}
+function clearPlaneCoverageRow(state, y) {
+  if (y < 0 || y >= state.buffer.rows)
+    return;
+  const row = getBufferRow(state.buffer, y);
+  const blank = createBlankCell();
+  row.length = state.buffer.cols;
+  for (let x = 0; x < state.buffer.cols; x++)
+    row[x] = blank;
+  state.coverage[y]?.fill(0);
+  markDirty(state.buffer, y);
+}
+function markPlaneCoverageRange(state, x0, y0, x1, y1, value) {
+  for (let y = y0; y < y1; y++) {
+    const row = state.coverage[y];
+    if (!row)
+      continue;
+    row.fill(value, x0, x1);
+  }
+}
+function markPlaneCoverageForPut(state, x, y, ch, prevCell) {
+  const row = state.coverage[y];
+  if (!row)
+    return;
+  if (prevCell?.continuation && x > 0)
+    row[x - 1] = 1;
+  if (prevCell?.width === 2 && x + 1 < row.length)
+    row[x + 1] = 1;
+  row[x] = 1;
+  if (ch !== " " && x + 1 < row.length) {
+    const next = getBufferCell(state.buffer, x, y);
+    if (next.width === 2)
+      row[x + 1] = 1;
+  }
+}
+function scrollPlaneCoverage(state, lines) {
+  const n = Math.trunc(lines);
+  if (n === 0 || state.coverage.length === 0)
+    return;
+  const rows = state.coverage.length;
+  const cols = state.buffer.cols;
+  if (Math.abs(n) >= rows) {
+    for (const row of state.coverage)
+      row.fill(0);
+    return;
+  }
+  if (n > 0) {
+    state.coverage.splice(0, n);
+    for (let i = 0; i < n; i++)
+      state.coverage.push(new Uint8Array(cols));
+    return;
+  }
+  state.coverage.splice(rows + n, -n);
+  for (let i = 0; i < -n; i++)
+    state.coverage.unshift(new Uint8Array(cols));
+}
+function scrollPlaneCoverageRegion(state, startY, endY, lines) {
+  const n = Math.trunc(lines);
+  if (n === 0 || state.coverage.length === 0)
+    return;
+  const start = Math.max(0, Math.min(state.coverage.length, Math.floor(startY)));
+  const end = Math.max(0, Math.min(state.coverage.length, Math.floor(endY)));
+  const height = end - start;
+  if (height <= 0)
+    return;
+  const cols = state.buffer.cols;
+  if (Math.abs(n) >= height) {
+    for (let y = start; y < end; y++)
+      state.coverage[y] = new Uint8Array(cols);
+    return;
+  }
+  const region = state.coverage.slice(start, end);
+  const next = Array.from({ length: height }, () => new Uint8Array(0));
+  if (n > 0) {
+    const movedCount = height - n;
+    for (let i = 0; i < movedCount; i++)
+      next[i] = region[i + n];
+    for (let i = 0; i < n; i++)
+      next[movedCount + i] = new Uint8Array(cols);
+  } else {
+    const insertedCount = -n;
+    const movedCount = height - insertedCount;
+    for (let i = 0; i < insertedCount; i++)
+      next[i] = new Uint8Array(cols);
+    for (let i = 0; i < movedCount; i++)
+      next[insertedCount + i] = region[i];
+  }
+  for (let i = 0; i < height; i++)
+    state.coverage[start + i] = next[i];
+}
+function resizePlaneState(state, cols, rows) {
+  resizeBuffer(state.buffer, cols, rows);
+  state.coverage = resizeCoverage(state.coverage, state.buffer.cols, state.buffer.rows);
+}
+function normalizeDirtyRows(rows, totalRows) {
+  if (rows === null)
+    return null;
+  if (rows.length === 0)
+    return rows;
+  const out = [];
+  for (const y of rows) {
+    const yy = Math.floor(y);
+    if (yy < 0 || yy >= totalRows)
+      continue;
+    if (out[out.length - 1] === yy)
+      continue;
+    out.push(yy);
+  }
+  return out;
+}
+function createTerminal(opts) {
+  const widthProvider = opts.widthProvider ?? "default";
+  const emitter = new Emitter();
+  const compositeBuffer = createGridBuffer(opts.cols, opts.rows, {
+    widthProvider
+  });
+  const planeStates = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let batchingDepth = 0;
+  let pendingCommit = false;
+  let pendingCommitAllPlanes = false;
+  let pendingCommitPlanes = null;
+  const pendingPlaneScrollOps = /* @__PURE__ */ new Map();
+  const planeTerminals = /* @__PURE__ */ new Map();
+  let base;
+  compositeBuffer.cursorVisible = false;
+  function assertNotDisposed() {
+    if (disposed)
+      throw new Error("Terminal is disposed");
+  }
+  function getPlaneState(plane) {
+    let state = planeStates.get(plane);
+    if (!state) {
+      state = createPlaneState(compositeBuffer.cols, compositeBuffer.rows, widthProvider);
+      planeStates.set(plane, state);
+    }
+    return state;
+  }
+  function setCursorForPlane(plane, x, y, visible = true) {
+    const state = getPlaneState(plane);
+    state.buffer.cursorX = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
+    state.buffer.cursorY = Math.max(
+      0,
+      Math.min(state.buffer.rows ? state.buffer.rows - 1 : 0, Math.floor(y))
+    );
+    state.buffer.cursorVisible = visible;
+    markDirty(state.buffer, state.buffer.cursorY);
+  }
+  function putForPlane(plane, x, y, ch, style) {
+    const state = getPlaneState(plane);
+    if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols)
+      return;
+    const prevCell = getBufferCell(state.buffer, x, y);
+    putCell(state.buffer, x, y, ch, style);
+    markPlaneCoverageForPut(state, x, y, ch, prevCell);
+  }
+  function writeAtForPlane(plane, text, x, y, style) {
+    const state = getPlaneState(plane);
+    let cx = x;
+    let cy = y;
+    if (state.buffer.cols === 0 || state.buffer.rows === 0)
+      return { x: cx, y: cy };
+    const writeChar = (ch) => {
+      if (isControlChar(ch)) {
+        if (ch === "\n") {
+          cx = 0;
+          cy += 1;
+          if (cy >= state.buffer.rows) {
+            scrollBuffer(state.buffer, 1);
+            scrollPlaneCoverage(state, 1);
+            cy = state.buffer.rows - 1;
+          }
+        } else if (ch === "\r") {
+          cx = 0;
+        } else if (ch === "	") {
+          const tabSize = 4;
+          const next = Math.min(state.buffer.cols, cx + (tabSize - cx % tabSize));
+          for (; cx < next; cx++)
+            putForPlane(plane, cx, cy, " ", style);
+        }
+        return true;
+      }
+      if (cy < 0 || cy >= state.buffer.rows)
+        return false;
+      if (cx >= state.buffer.cols) {
+        cx = 0;
+        cy += 1;
+      }
+      if (cy >= state.buffer.rows) {
+        scrollBuffer(state.buffer, 1);
+        scrollPlaneCoverage(state, 1);
+        cy = state.buffer.rows - 1;
+      }
+      putForPlane(plane, cx, cy, ch, style);
+      const width = ch === " " ? 1 : getBufferCell(state.buffer, cx, cy).width || 1;
+      cx += width;
+      return true;
+    };
+    const segments = segmentedGraphemes(text);
+    if (segments) {
+      for (const seg of segments) {
+        if (!writeChar(seg.segment))
+          break;
+      }
+      return { x: cx, y: cy };
+    }
+    let i = 0;
+    for (; i < text.length; i++) {
+      const code = text.charCodeAt(i);
+      if (code > 127)
+        break;
+      if (!writeChar(text[i]))
+        return { x: cx, y: cy };
+    }
+    if (i < text.length) {
+      const rest = text.slice(i);
+      const restSegments = segmentedGraphemes(rest);
+      if (restSegments) {
+        for (const seg of restSegments) {
+          if (!writeChar(seg.segment))
+            break;
+        }
+      } else {
+        for (const ch of rest) {
+          if (!writeChar(ch))
+            break;
+        }
+      }
+    }
+    return { x: cx, y: cy };
+  }
+  function clearForPlane(plane, x, y, w, h) {
+    const state = getPlaneState(plane);
+    clearRect(state.buffer, x, y, w, h);
+    if (x == null || y == null || w == null || h == null) {
+      for (const row of state.coverage)
+        row.fill(1);
+      return;
+    }
+    if (w <= 0 || h <= 0)
+      return;
+    const x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
+    const y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y)));
+    const x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w)));
+    const y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
+    if (x1 <= x0 || y1 <= y0)
+      return;
+    markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
+  }
+  function fillForPlane(plane, x, y, w, h, ch, style) {
+    const state = getPlaneState(plane);
+    fillRect(state.buffer, x, y, w, h, ch ?? " ", style);
+    if (w <= 0 || h <= 0 || state.buffer.cols === 0 || state.buffer.rows === 0)
+      return;
+    const x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
+    const y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y)));
+    const x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w)));
+    const y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
+    if (x1 <= x0 || y1 <= y0)
+      return;
+    markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
+  }
+  function scrollForPlane(plane, lines) {
+    const state = getPlaneState(plane);
+    scrollBuffer(state.buffer, lines);
+    scrollPlaneCoverage(state, lines);
+  }
+  function normalizeScrollOperation(startY, endY, delta, totalRows) {
+    const start = Math.max(0, Math.min(totalRows, Math.floor(startY)));
+    const end = Math.max(0, Math.min(totalRows, Math.floor(endY)));
+    const height = end - start;
+    const lines = Math.trunc(delta);
+    if (height <= 0 || lines === 0 || Math.abs(lines) >= height)
+      return null;
+    return { startY: start, endY: end, delta: lines };
+  }
+  function recordPendingScrollOp(plane, op) {
+    const list = pendingPlaneScrollOps.get(plane) ?? [];
+    const last = list[list.length - 1];
+    if (last && last.startY === op.startY && last.endY === op.endY && Math.sign(last.delta) === Math.sign(op.delta)) {
+      const next = normalizeScrollOperation(
+        op.startY,
+        op.endY,
+        last.delta + op.delta,
+        compositeBuffer.rows
+      );
+      if (next)
+        list[list.length - 1] = next;
+      else
+        list.push(op);
+    } else {
+      list.push(op);
+    }
+    pendingPlaneScrollOps.set(plane, list);
+  }
+  function takePendingScrollOps(planes) {
+    const planesToTake = planes?.length ? planes : TERMINAL_RENDER_PLANES;
+    const out = [];
+    for (const plane of planesToTake) {
+      const ops = pendingPlaneScrollOps.get(plane);
+      if (!ops?.length)
+        continue;
+      pendingPlaneScrollOps.delete(plane);
+      for (const op of ops)
+        out.push({ plane, ...op });
+    }
+    return out.length ? out : null;
+  }
+  function higherPlanesFor(plane) {
+    const planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
+    if (planeIndex < 0)
+      return [];
+    return TERMINAL_RENDER_PLANES.slice(planeIndex + 1);
+  }
+  function higherPlaneCoverageKind(plane, y) {
+    const higherPlanes = higherPlanesFor(plane);
+    if (!higherPlanes.length || y < 0 || y >= compositeBuffer.rows)
+      return 0;
+    let covered = 0;
+    for (let x = 0; x < compositeBuffer.cols; x++) {
+      let cellCovered = false;
+      for (const higherPlane of higherPlanes) {
+        const state = planeStates.get(higherPlane);
+        if (state?.coverage[y]?.[x]) {
+          cellCovered = true;
+          break;
+        }
+      }
+      if (cellCovered)
+        covered++;
+    }
+    if (covered === 0)
+      return 0;
+    if (covered >= compositeBuffer.cols)
+      return 2;
+    return 1;
+  }
+  function addAffectedRows(out, op) {
+    for (let y = op.startY; y < op.endY; y++)
+      out.add(y);
+  }
+  function areDisjointSorted(ops) {
+    for (let i = 1; i < ops.length; i++) {
+      if (ops[i - 1].endY > ops[i].startY)
+        return false;
+    }
+    return true;
+  }
+  function groupedPendingScrollOps(pendingOps) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const pending of pendingOps) {
+      const list = grouped.get(pending.plane) ?? [];
+      list.push({
+        startY: pending.startY,
+        endY: pending.endY,
+        delta: pending.delta
+      });
+      grouped.set(pending.plane, list);
+    }
+    return grouped;
+  }
+  function prepareCompositeScrollOps(pendingOps) {
+    if (!pendingOps?.length) {
+      return {
+        scrollOperations: null,
+        extraDirtyRows: []
+      };
+    }
+    const scrollOperations = [];
+    const extraDirtyRows = /* @__PURE__ */ new Set();
+    const grouped = groupedPendingScrollOps(pendingOps);
+    for (const [plane, ops] of grouped) {
+      const sorted = [...ops].sort((a, b) => a.startY - b.startY || a.endY - b.endY);
+      if (!areDisjointSorted(sorted)) {
+        for (const op of ops)
+          addAffectedRows(extraDirtyRows, op);
+        continue;
+      }
+      for (const op of sorted) {
+        const blockedRows = /* @__PURE__ */ new Set();
+        const partiallyBlockedRows = /* @__PURE__ */ new Set();
+        for (let y = op.startY; y < op.endY; y++) {
+          const coverageKind = higherPlaneCoverageKind(plane, y);
+          if (coverageKind === 0)
+            continue;
+          blockedRows.add(y);
+          if (coverageKind === 1)
+            partiallyBlockedRows.add(y);
+        }
+        if (!blockedRows.size) {
+          scrollOperations.push({
+            startY: op.startY,
+            endY: op.endY,
+            delta: op.delta
+          });
+          continue;
+        }
+        const absDelta = Math.abs(op.delta);
+        for (let y = op.startY; y < op.endY; y++) {
+          if (partiallyBlockedRows.has(y))
+            extraDirtyRows.add(y);
+        }
+        let bandStart = -1;
+        const flushBand = (bandEnd) => {
+          if (bandStart < 0 || bandEnd <= bandStart)
+            return;
+          const bandHeight = bandEnd - bandStart;
+          if (absDelta >= bandHeight) {
+            for (let y = bandStart; y < bandEnd; y++)
+              extraDirtyRows.add(y);
+            bandStart = -1;
+            return;
+          }
+          scrollOperations.push({
+            startY: bandStart,
+            endY: bandEnd,
+            delta: op.delta
+          });
+          if (op.delta > 0) {
+            for (let y = bandEnd - absDelta; y < bandEnd; y++)
+              extraDirtyRows.add(y);
+          } else {
+            for (let y = bandStart; y < bandStart + absDelta; y++)
+              extraDirtyRows.add(y);
+          }
+          bandStart = -1;
+        };
+        for (let y = op.startY; y < op.endY; y++) {
+          if (blockedRows.has(y)) {
+            flushBand(y);
+            continue;
+          }
+          if (bandStart < 0)
+            bandStart = y;
+        }
+        flushBand(op.endY);
+      }
+    }
+    return {
+      scrollOperations: scrollOperations.length ? scrollOperations : null,
+      extraDirtyRows: Array.from(extraDirtyRows).sort((a, b) => a - b)
+    };
+  }
+  function dirtyRowsCoverRange(rows, startY, endY) {
+    if (rows === null)
+      return true;
+    if (!rows.length)
+      return false;
+    let idx = 0;
+    while (idx < rows.length && (rows[idx] ?? -1) < startY)
+      idx++;
+    for (let y = startY; y < endY; y++) {
+      if (rows[idx] !== y)
+        return false;
+      idx++;
+    }
+    return true;
+  }
+  function dropScrollOpsCoveredByDirtyRows(ops, dirtyRows) {
+    if (!ops?.length)
+      return null;
+    const next = ops.filter((op) => !dirtyRowsCoverRange(dirtyRows, op.startY, op.endY));
+    return next.length ? next : null;
+  }
+  function scrollRowsForPlane(plane, startY, endY, lines) {
+    const state = getPlaneState(plane);
+    const op = normalizeScrollOperation(startY, endY, lines, state.buffer.rows);
+    if (!op)
+      return;
+    scrollBufferRegion(state.buffer, op.startY, op.endY, op.delta);
+    scrollPlaneCoverageRegion(state, op.startY, op.endY, op.delta);
+    recordPendingScrollOp(plane, op);
+  }
+  function composeRows(rows, planes = TERMINAL_RENDER_PLANES) {
+    const blank = createBlankCell();
+    const fpFn = compositeBuffer.fingerprintFn;
+    const fpArr = compositeBuffer.soaFingerprints;
+    const rowList = rows ?? Array.from({ length: compositeBuffer.rows }, (_, index) => index);
+    for (const y of rowList) {
+      if (y < 0 || y >= compositeBuffer.rows)
+        continue;
+      const dst = getBufferRow(compositeBuffer, y);
+      dst.length = compositeBuffer.cols;
+      for (let x = 0; x < compositeBuffer.cols; x++)
+        dst[x] = blank;
+      for (const plane of planes) {
+        const state = planeStates.get(plane);
+        if (!state)
+          continue;
+        const src = getBufferRow(state.buffer, y);
+        const coverage = state.coverage[y];
+        if (!coverage)
+          continue;
+        for (let x = 0; x < compositeBuffer.cols; x++) {
+          if (coverage[x])
+            dst[x] = src[x];
+        }
+      }
+      const cols = compositeBuffer.cols;
+      for (let x = 0; x < cols; x++) {
+        const cell = dst[x];
+        if (cell.width === 2 && !cell.continuation) {
+          if (x + 1 >= cols || !dst[x + 1].continuation) {
+            dst[x] = blank;
+          }
+        } else if (cell.continuation) {
+          if (x === 0 || dst[x - 1].width !== 2 || dst[x - 1].continuation) {
+            dst[x] = blank;
+          }
+        }
+      }
+      if (fpFn && fpArr) {
+        const physY = (compositeBuffer.gridStart + y) % compositeBuffer.rows;
+        const base2 = physY * cols;
+        for (let x = 0; x < cols; x++) {
+          const cell = dst[x];
+          fpArr[base2 + x] = fpFn(cell.ch, cell.style);
+        }
+      }
+      markDirty(compositeBuffer, y);
+    }
+  }
+  function syncCompositeCursor() {
+    const prevVisible = compositeBuffer.cursorVisible;
+    const prevY = compositeBuffer.cursorY;
+    let nextPlane = null;
+    for (const plane of ["overlay", "chrome", "transcript", "default"]) {
+      const state = planeStates.get(plane);
+      if (state?.buffer.cursorVisible) {
+        nextPlane = state;
+        break;
+      }
+    }
+    compositeBuffer.cursorVisible = Boolean(nextPlane);
+    compositeBuffer.cursorX = nextPlane?.buffer.cursorX ?? 0;
+    compositeBuffer.cursorY = nextPlane?.buffer.cursorY ?? 0;
+    if (prevVisible)
+      markDirty(compositeBuffer, prevY);
+    if (compositeBuffer.cursorVisible)
+      markDirty(compositeBuffer, compositeBuffer.cursorY);
+  }
+  function syncCompositeForRead(planes) {
+    const planesToCompose = planes?.length ? planes : TERMINAL_RENDER_PLANES;
+    let composeAllRows = false;
+    const dirtyRows = /* @__PURE__ */ new Set();
+    for (const plane of planesToCompose) {
+      const state = planeStates.get(plane);
+      if (!state)
+        continue;
+      const rows = peekDirtyRows(state.buffer);
+      if (rows === null) {
+        composeAllRows = true;
+        break;
+      }
+      for (const y of rows)
+        dirtyRows.add(y);
+    }
+    if (composeAllRows || dirtyRows.size > 0)
+      composeRows(
+        composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b),
+        planesToCompose
+      );
+    syncCompositeCursor();
+  }
+  function readRowForPlanes(y, planes) {
+    assertNotDisposed();
+    if (y < 0 || y >= compositeBuffer.rows)
+      throw new RangeError("Row out of bounds");
+    composeRows([y], planes?.length ? planes : TERMINAL_RENDER_PLANES);
+    return getBufferRow(compositeBuffer, y);
+  }
+  function pendingDirtyRowsForPlanes(planes) {
+    const planesToCheck = planes?.length ? planes : TERMINAL_RENDER_PLANES;
+    let full = false;
+    const rows = /* @__PURE__ */ new Set();
+    for (const plane of planesToCheck) {
+      const state = planeStates.get(plane);
+      if (!state)
+        continue;
+      const dirty = peekDirtyRows(state.buffer);
+      if (dirty === null) {
+        full = true;
+        break;
+      }
+      for (const y of dirty)
+        rows.add(y);
+    }
+    if (full)
+      return null;
+    return Array.from(rows).sort((a, b) => a - b);
+  }
+  function createPlaneTerminalApi(plane) {
+    const existing = planeTerminals.get(plane);
+    if (existing)
+      return existing;
+    const api = {
+      resize(cols, rows) {
+        assertNotDisposed();
+        base.resize(cols, rows);
+      },
+      clear(x, y, w, h) {
+        assertNotDisposed();
+        clearForPlane(plane, x, y, w, h);
+      },
+      write(text, opts2) {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        const x = opts2?.x;
+        const y = opts2?.y;
+        const style = opts2?.style;
+        if (x == null || y == null) {
+          const next = writeAtForPlane(
+            plane,
+            text,
+            state.buffer.cursorX,
+            state.buffer.cursorY,
+            style ?? state.buffer.cursorStyle
+          );
+          state.buffer.cursorX = next.x;
+          state.buffer.cursorY = next.y;
+        } else {
+          writeAtForPlane(plane, text, x, y, style);
+        }
+      },
+      writeAnsi(text, opts2) {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        const x = opts2?.x;
+        const y = opts2?.y;
+        const positionedWrite = x != null && y != null;
+        let cx = positionedWrite ? x : state.buffer.cursorX;
+        let cy = positionedWrite ? y : state.buffer.cursorY;
+        let style = positionedWrite ? {} : state.buffer.cursorStyle;
+        for (const seg of parseAnsiSgr(text, style)) {
+          const next = writeAtForPlane(plane, seg.text, cx, cy, seg.style);
+          cx = next.x;
+          cy = next.y;
+          style = seg.style;
+        }
+        if (!positionedWrite) {
+          state.buffer.cursorX = cx;
+          state.buffer.cursorY = cy;
+          state.buffer.cursorStyle = style;
+        }
+      },
+      put(x, y, ch, style) {
+        assertNotDisposed();
+        putForPlane(plane, x, y, ch, style);
+      },
+      fill(x, y, w, h, ch, style) {
+        assertNotDisposed();
+        fillForPlane(plane, x, y, w, h, ch, style);
+      },
+      scroll(lines) {
+        assertNotDisposed();
+        scrollForPlane(plane, lines);
+      },
+      setCursor(x, y, visible) {
+        assertNotDisposed();
+        setCursorForPlane(plane, x, y, visible);
+      },
+      batch(fn) {
+        assertNotDisposed();
+        return base.batch(fn);
+      },
+      commit(meta) {
+        assertNotDisposed();
+        return base.commit({ planes: meta?.planes ?? [plane], sync: meta?.sync });
+      },
+      on(event, cb) {
+        assertNotDisposed();
+        return base.on(event, cb);
+      },
+      dispose() {
+        base.dispose();
+      },
+      size() {
+        assertNotDisposed();
+        return base.size();
+      },
+      snapshot() {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        return {
+          cols: state.buffer.cols,
+          rows: state.buffer.rows,
+          lines: snapshotText(state.buffer)
+        };
+      },
+      getCell(x, y) {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols)
+          throw new RangeError("Cell out of bounds");
+        return getBufferCell(state.buffer, x, y);
+      },
+      getRow(y) {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        if (y < 0 || y >= state.buffer.rows)
+          throw new RangeError("Row out of bounds");
+        return getBufferRow(state.buffer, y);
+      },
+      setScrollbackLimit(limit) {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit));
+        if (state.buffer.scrollback.length > state.buffer.scrollbackLimit) {
+          state.buffer.scrollback.splice(
+            0,
+            state.buffer.scrollback.length - state.buffer.scrollbackLimit
+          );
+        }
+      },
+      getScrollbackLines(count) {
+        assertNotDisposed();
+        const state = getPlaneState(plane);
+        const all = state.buffer.scrollback.map(
+          (row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join("")
+        );
+        if (count == null)
+          return all;
+        return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+      },
+      setFingerprintFn(fn) {
+        assertNotDisposed();
+        base.setFingerprintFn(fn);
+      },
+      getRowFingerprints(y) {
+        assertNotDisposed();
+        return base.getRowFingerprints(y);
+      }
+    };
+    planeTerminals.set(plane, api);
+    return api;
+  }
+  base = {
+    resize(cols, rows) {
+      assertNotDisposed();
+      const prevCols = compositeBuffer.cols;
+      const prevRows = compositeBuffer.rows;
+      resizeBuffer(compositeBuffer, cols, rows);
+      for (const state of planeStates.values())
+        resizePlaneState(state, cols, rows);
+      if (compositeBuffer.cols !== prevCols || compositeBuffer.rows !== prevRows)
+        emitter.emit("resize", { cols: compositeBuffer.cols, rows: compositeBuffer.rows });
+    },
+    clear(x, y, w, h) {
+      assertNotDisposed();
+      clearForPlane("default", x, y, w, h);
+    },
+    write(text, opts2) {
+      assertNotDisposed();
+      createPlaneTerminalApi("default").write(text, opts2);
+    },
+    writeAnsi(text, opts2) {
+      assertNotDisposed();
+      createPlaneTerminalApi("default").writeAnsi(text, opts2);
+    },
+    put(x, y, ch, style) {
+      assertNotDisposed();
+      putForPlane("default", x, y, ch, style);
+    },
+    fill(x, y, w, h, ch, style) {
+      assertNotDisposed();
+      fillForPlane("default", x, y, w, h, ch, style);
+    },
+    scroll(lines) {
+      assertNotDisposed();
+      scrollForPlane("default", lines);
+    },
+    setCursor(x, y, visible = true) {
+      assertNotDisposed();
+      setCursorForPlane("default", x, y, visible);
+    },
+    batch(fn) {
+      assertNotDisposed();
+      batchingDepth++;
+      try {
+        return fn();
+      } finally {
+        batchingDepth--;
+        if (batchingDepth === 0 && pendingCommit) {
+          pendingCommit = false;
+          const planes = pendingCommitAllPlanes ? null : pendingCommitPlanes;
+          pendingCommitAllPlanes = false;
+          pendingCommitPlanes = null;
+          base.commit({ planes });
+        }
+      }
+    },
+    commit(meta) {
+      assertNotDisposed();
+      if (batchingDepth > 0) {
+        pendingCommit = true;
+        if (!meta?.planes?.length) {
+          pendingCommitAllPlanes = true;
+          pendingCommitPlanes = null;
+        } else if (!pendingCommitAllPlanes) {
+          pendingCommitPlanes = mergePlanes(pendingCommitPlanes, meta.planes);
+        }
+        return pendingDirtyRowsForPlanes(meta?.planes ?? null);
+      }
+      const planesToCompose = meta?.planes?.length ? meta.planes : TERMINAL_RENDER_PLANES;
+      const pendingScrollOps = takePendingScrollOps(planesToCompose);
+      const preparedScroll = prepareCompositeScrollOps(pendingScrollOps);
+      let scrollOperations = preparedScroll.scrollOperations;
+      let composeAllRows = false;
+      const dirtyRows = /* @__PURE__ */ new Set();
+      for (const plane of planesToCompose) {
+        const state = planeStates.get(plane);
+        if (!state)
+          continue;
+        const rows = collectAndClearDirtyRows(state.buffer);
+        if (rows === null) {
+          composeAllRows = true;
+          break;
+        }
+        for (const y of rows)
+          dirtyRows.add(y);
+      }
+      for (const y of preparedScroll.extraDirtyRows)
+        dirtyRows.add(y);
+      const normalizedDirtyRows = composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b);
+      scrollOperations = dropScrollOpsCoveredByDirtyRows(scrollOperations, normalizedDirtyRows);
+      if (scrollOperations) {
+        for (const op of scrollOperations)
+          scrollBufferRegion(compositeBuffer, op.startY, op.endY, op.delta);
+      }
+      if (normalizedDirtyRows !== null && normalizedDirtyRows.length === 0) {
+        const pendingCompositeRows = collectAndClearDirtyRows(compositeBuffer);
+        if (pendingCompositeRows !== null && pendingCompositeRows.length === 0)
+          return pendingCompositeRows;
+        emitter.emit("commit", {
+          dirtyRows: pendingCompositeRows,
+          planes: meta?.planes ?? null,
+          sync: meta?.sync,
+          scrollOperations
+        });
+        return pendingCompositeRows;
+      }
+      composeRows(normalizedDirtyRows);
+      if (normalizedDirtyRows === null)
+        markAllDirty(compositeBuffer);
+      syncCompositeCursor();
+      const committedRows = collectAndClearDirtyRows(compositeBuffer);
+      if (committedRows !== null && committedRows.length === 0)
+        return committedRows;
+      emitter.emit("commit", {
+        dirtyRows: committedRows,
+        planes: meta?.planes ?? null,
+        sync: meta?.sync,
+        scrollOperations
+      });
+      return committedRows;
+    },
+    on(event, cb) {
+      assertNotDisposed();
+      return emitter.on(event, cb);
+    },
+    dispose() {
+      disposed = true;
+      emitter.clear();
+    },
+    size() {
+      assertNotDisposed();
+      return { cols: compositeBuffer.cols, rows: compositeBuffer.rows };
+    },
+    snapshot() {
+      assertNotDisposed();
+      if (batchingDepth === 0)
+        syncCompositeForRead();
+      const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+      return {
+        cols: source.cols,
+        rows: source.rows,
+        lines: snapshotText(source)
+      };
+    },
+    getCell(x, y) {
+      assertNotDisposed();
+      if (batchingDepth === 0)
+        syncCompositeForRead();
+      const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+      if (y < 0 || y >= source.rows || x < 0 || x >= source.cols)
+        throw new RangeError("Cell out of bounds");
+      return getBufferCell(source, x, y);
+    },
+    getRow(y) {
+      assertNotDisposed();
+      if (batchingDepth === 0)
+        syncCompositeForRead();
+      const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+      if (y < 0 || y >= source.rows)
+        throw new RangeError("Row out of bounds");
+      return getBufferRow(source, y);
+    },
+    setScrollbackLimit(limit) {
+      assertNotDisposed();
+      const state = getPlaneState("default");
+      state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit));
+      if (state.buffer.scrollback.length > state.buffer.scrollbackLimit) {
+        state.buffer.scrollback.splice(
+          0,
+          state.buffer.scrollback.length - state.buffer.scrollbackLimit
+        );
+      }
+    },
+    getScrollbackLines(count) {
+      assertNotDisposed();
+      const state = getPlaneState("default");
+      const all = state.buffer.scrollback.map(
+        (row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join("")
+      );
+      if (count == null)
+        return all;
+      return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+    },
+    setFingerprintFn(fn) {
+      assertNotDisposed();
+      setFingerprintFn(compositeBuffer, fn);
+    },
+    getRowFingerprints(y) {
+      assertNotDisposed();
+      return getRowFingerprints(compositeBuffer, y);
+    }
+  };
+  base[TERMINAL_PLANE_INTERNALS] = {
+    getPlaneTerminal: createPlaneTerminalApi,
+    readRowForPlanes,
+    resetRowsForRender(plane, dirtyRows) {
+      const state = getPlaneState(plane);
+      const rows = normalizeDirtyRows(dirtyRows, state.buffer.rows);
+      if (rows === null) {
+        for (let y = 0; y < state.buffer.rows; y++)
+          clearPlaneCoverageRow(state, y);
+        return;
+      }
+      for (const y of rows)
+        clearPlaneCoverageRow(state, y);
+    },
+    getRowCoverageKind(plane, y) {
+      const state = getPlaneState(plane);
+      if (y < 0 || y >= state.coverage.length)
+        return 0;
+      const row = state.coverage[y];
+      if (!row?.length)
+        return 0;
+      let covered = 0;
+      for (let x = 0; x < row.length; x++) {
+        if (row[x])
+          covered++;
+      }
+      if (covered === 0)
+        return 0;
+      if (covered >= row.length)
+        return 2;
+      return 1;
+    },
+    scrollRows(plane, startY, endY, lines) {
+      scrollRowsForPlane(plane, startY, endY, lines);
+    }
+  };
+  return base;
+}
+
+// src/utils/path.ts
+function normalizeSeparators(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    out += ch === "\\" ? "/" : ch;
+  }
+  return out;
+}
+function isAbsolutePath(path) {
+  const p = normalizeSeparators(path);
+  if (p.startsWith("/"))
+    return true;
+  return /^[A-Z]:\//i.test(p);
+}
+function stripTrailingSlash(path) {
+  const p = normalizeSeparators(path);
+  if (p === "/")
+    return p;
+  let end = p.length;
+  while (end > 0 && p.charCodeAt(end - 1) === 47)
+    end--;
+  return end === p.length ? p : p.slice(0, end);
+}
+function joinPath(base, next) {
+  const a = normalizeSeparators(base);
+  const b = normalizeSeparators(next);
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  if (a.endsWith("/"))
+    return `${a}${b.startsWith("/") ? b.slice(1) : b}`;
+  return `${a}/${b.startsWith("/") ? b.slice(1) : b}`;
+}
+function dirname(path) {
+  const p = stripTrailingSlash(path);
+  const normalized = normalizeSeparators(p);
+  if (normalized === "/")
+    return "/";
+  const drive = normalized.match(/^([A-Z]:)\//i)?.[1] ?? null;
+  const start = drive ? drive.length + 1 : 0;
+  const idx = normalized.lastIndexOf("/");
+  if (idx < start)
+    return drive ? `${drive}/` : "";
+  const out = normalized.slice(0, idx) || (drive ? `${drive}/` : "/");
+  return out;
+}
+function normalizePath(path) {
+  const raw = normalizeSeparators(path);
+  if (!raw)
+    return "";
+  const drive = raw.match(/^([A-Z]:)(\/|$)/i)?.[1] ?? null;
+  const rest = drive ? raw.slice(drive.length) : raw;
+  const absolute = rest.startsWith("/");
+  const parts = rest.split("/").filter(Boolean);
+  const stack = [];
+  for (const part of parts) {
+    if (part === ".")
+      continue;
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+        continue;
+      }
+      if (!absolute)
+        stack.push("..");
+      continue;
+    }
+    stack.push(part);
+  }
+  const prefix = drive ? `${drive}${absolute ? "/" : ""}` : absolute ? "/" : "";
+  const joined = stack.join("/");
+  const out = `${prefix}${joined}`;
+  return out || (absolute ? drive ? `${drive}/` : "/" : "");
+}
+function resolvePath(baseAbs, input) {
+  const b = normalizePath(baseAbs);
+  const i = normalizePath(input);
+  if (!b)
+    return i;
+  if (isAbsolutePath(i))
+    return i;
+  return normalizePath(joinPath(b, i));
+}
+
+// src/core/path-suggest.ts
+function lower(s) {
+  return s.toLowerCase();
+}
+function normalizePathInputSeparators(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === "\r")
+      continue;
+    out += ch === "\\" ? "/" : ch;
+  }
+  return out;
+}
+function stripCarriageReturns(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch !== "\r")
+      out += ch;
+  }
+  return out;
+}
+function stripLeadingDotSlash(input) {
+  let i = 0;
+  while (i + 1 < input.length && input.charCodeAt(i) === 46 && input.charCodeAt(i + 1) === 47) {
+    i += 2;
+  }
+  return i === 0 ? input : input.slice(i);
+}
+function stripLeadingSlashes(input) {
+  let i = 0;
+  while (i < input.length && input.charCodeAt(i) === 47)
+    i++;
+  return i === 0 ? input : input.slice(i);
+}
+function stripTrailingSlashes(input) {
+  let end = input.length;
+  while (end > 0 && input.charCodeAt(end - 1) === 47)
+    end--;
+  return end === input.length ? input : input.slice(0, end);
+}
+function collapseSlashes(input) {
+  let out = "";
+  let previousWasSlash = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const isSlash = ch === "/";
+    if (isSlash) {
+      if (!previousWasSlash)
+        out += "/";
+      previousWasSlash = true;
+      continue;
+    }
+    out += ch;
+    previousWasSlash = false;
+  }
+  return out;
+}
+function normalizeRelativePathForIgnore(input) {
+  return stripTrailingSlashes(
+    collapseSlashes(stripLeadingSlashes(stripLeadingDotSlash(normalizePathInputSeparators(input))))
+  );
+}
+function fuzzyScore(name, query) {
+  const n = lower(name);
+  const q = lower(query);
+  if (!q)
+    return 0;
+  if (n === q)
+    return 2e3;
+  if (n.startsWith(q))
+    return 1500 - (n.length - q.length);
+  const idx = n.indexOf(q);
+  if (idx >= 0)
+    return 1200 - idx;
+  let ni = 0;
+  let qi = 0;
+  let gaps = 0;
+  let lastMatch = -1;
+  while (ni < n.length && qi < q.length) {
+    if (n[ni] === q[qi]) {
+      if (lastMatch >= 0)
+        gaps += ni - lastMatch - 1;
+      lastMatch = ni;
+      qi++;
+    }
+    ni++;
+  }
+  if (qi !== q.length)
+    return null;
+  const maxGaps = Math.max(4, q.length * 2);
+  if (gaps > maxGaps)
+    return null;
+  return 800 - gaps;
+}
+function parsePathQuery(rawInput) {
+  const input = normalizePathInputSeparators(rawInput);
+  const lastSlash = input.lastIndexOf("/");
+  if (lastSlash < 0)
+    return { dirPrefix: "", query: input };
+  return {
+    dirPrefix: input.slice(0, lastSlash + 1),
+    query: input.slice(lastSlash + 1)
+  };
+}
+async function suggestPaths(options) {
+  const rawWorkspace = String(options.workspaceAbs ?? "");
+  const rawInput = String(options.input ?? "");
+  if (!rawWorkspace || rawWorkspace.includes("\0") || rawInput.includes("\0")) {
+    const safeWorkspaceAbs = normalizePath(rawWorkspace || ".");
+    return {
+      baseDirAbs: resolvePath(safeWorkspaceAbs, "."),
+      dirPrefix: "",
+      query: "",
+      suggestions: []
+    };
+  }
+  const workspaceAbs = normalizePath(rawWorkspace);
+  const input = normalizePathInputSeparators(rawInput);
+  const parsed = parsePathQuery(input);
+  let dirPrefix = parsed.dirPrefix;
+  let query = parsed.query;
+  let baseDirAbs = resolvePath(workspaceAbs, dirPrefix || ".");
+  let maxDepth = options.maxDepth ?? 0;
+  if (!query)
+    maxDepth = 0;
+  const allowHidden = Boolean(options.showHidden);
+  const allowDir = options.mode === "directory" || options.mode === "any" || options.mode === "file";
+  const allowFile = options.mode === "file" || options.mode === "any";
+  const max = Math.max(0, Math.floor(options.max));
+  if (max <= 0) {
+    return { baseDirAbs, dirPrefix, query, suggestions: [] };
+  }
+  const maxDepthClamped = Math.max(0, Math.floor(maxDepth || 0));
+  const keepCapacity = Math.max(500, Math.min(8e3, max * 40));
+  const maxScannedDirs = Math.max(200, Math.min(6e3, 800 + maxDepthClamped * 600));
+  const maxScannedEntries = Math.max(2e3, Math.min(8e4, max * 2e3));
+  const scored = [];
+  let scannedDirs = 0;
+  let scannedEntries = 0;
+  let scanAborted = false;
+  function cmpScored(a, b) {
+    if (a.score !== b.score)
+      return b.score - a.score;
+    if (a.depth !== b.depth)
+      return a.depth - b.depth;
+    return a.name.localeCompare(b.name);
+  }
+  function pruneScored() {
+    if (scored.length <= keepCapacity)
+      return;
+    scored.sort(cmpScored);
+    scored.length = keepCapacity;
+  }
+  function scoreItem(name, relPath, q) {
+    const byName = fuzzyScore(name, q);
+    const byPath = fuzzyScore(relPath, q);
+    if (byName == null && byPath == null)
+      return null;
+    if (byName != null && byPath != null)
+      return Math.max(byName + 50, byPath);
+    return byName ?? byPath;
+  }
+  async function searchDir(dirAbs, currentDepth, currentRelPath, preloadedEntries) {
+    if (scanAborted)
+      return;
+    if (currentDepth > maxDepth)
+      return;
+    if (dirAbs.includes("\0")) {
+      scanAborted = true;
+      return;
+    }
+    scannedDirs++;
+    if (scannedDirs > maxScannedDirs) {
+      scanAborted = true;
+      return;
+    }
+    let entries = [];
+    try {
+      entries = preloadedEntries ?? await options.listDir(dirAbs);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (scanAborted)
+        return;
+      scannedEntries++;
+      if (scannedEntries > maxScannedEntries) {
+        scanAborted = true;
+        return;
+      }
+      if (!allowHidden && !query && e.name.startsWith("."))
+        continue;
+      const itemRelPath = currentRelPath ? `${currentRelPath}/${e.name}` : e.name;
+      const normalizedRelPath = normalizeRelativePathForIgnore(`${dirPrefix}${itemRelPath}`);
+      const isDir = e.kind === "directory";
+      if (options.shouldIgnore?.({ normalizedRelPath, isDir }))
+        continue;
+      if (e.kind === "directory") {
+        if (!allowDir)
+          continue;
+        const score = scoreItem(e.name, itemRelPath, query);
+        if (score != null) {
+          scored.push({
+            score,
+            name: e.name,
+            kind: "directory",
+            depth: currentDepth,
+            relPath: itemRelPath
+          });
+          if (scored.length > keepCapacity * 2)
+            pruneScored();
+        }
+        await searchDir(`${dirAbs}/${e.name}`, currentDepth + 1, itemRelPath);
+        continue;
+      }
+      if (e.kind === "file") {
+        if (!allowFile)
+          continue;
+        const score = scoreItem(e.name, itemRelPath, query);
+        if (score != null) {
+          scored.push({
+            score,
+            name: e.name,
+            kind: "file",
+            depth: currentDepth,
+            relPath: itemRelPath
+          });
+          if (scored.length > keepCapacity * 2)
+            pruneScored();
+        }
+      }
+    }
+  }
+  let ok = true;
+  let baseEntries = null;
+  try {
+    baseEntries = await options.listDir(baseDirAbs);
+  } catch {
+    ok = false;
+  }
+  if (!ok && dirPrefix) {
+    const fallbackQuery = stripTrailingSlashes(input);
+    dirPrefix = "";
+    query = fallbackQuery;
+    baseDirAbs = workspaceAbs;
+    maxDepth = options.maxDepth ?? 0;
+    if (!query)
+      maxDepth = 0;
+    baseEntries = null;
+  }
+  await searchDir(baseDirAbs, 0, "", baseEntries ?? void 0);
+  pruneScored();
+  scored.sort(cmpScored);
+  const list = max ? scored.slice(0, max) : [];
+  const suggestions = list.map((s) => {
+    const suffix = s.kind === "directory" ? "/" : "";
+    const completion = `${dirPrefix}${s.relPath}${suffix}`;
+    const absPath = resolvePath(workspaceAbs, `${dirPrefix}${s.relPath}`);
+    return { kind: s.kind, display: completion, completion, absPath };
+  });
+  return { baseDirAbs, dirPrefix, query, suggestions };
+}
+function resolveUserPath(workspaceAbs, input, options) {
+  const raw = stripCarriageReturns(input ?? "").trim();
+  if (!raw)
+    return resolvePath(normalizePath(workspaceAbs), ".");
+  if (raw === "~" || raw.startsWith("~/")) {
+    const home = String(options?.homeDir ?? "").trim();
+    if (home) {
+      const rest = raw === "~" ? "" : raw.slice(2);
+      return resolvePath(normalizePath(home), rest);
+    }
+  }
+  const normalized = normalizePathInputSeparators(raw);
+  if (isAbsolutePath(normalized))
+    return normalizePath(normalized);
+  return resolvePath(normalizePath(workspaceAbs), normalized);
+}
+function suggestParentHint(path) {
+  const p = normalizePath(path);
+  const d = dirname(p);
+  return d ? joinPath(d, "..") : "..";
+}
+
+// src/utils/newlines.ts
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}