vterm.js 0.3.0 → 0.4.0

package/src/screen.ts

@@ -1,2355 +0,0 @@
-/**
- * vterm.js — Modern terminal emulator
- *
- * Full VT/ECMA-48/xterm standards coverage. Pure TypeScript, zero dependencies.
- * Targets 100% of terminfo.dev's feature matrix:
- *
- * - All SGR attributes (bold, faint, italic, underline styles, overline, strikethrough, blink, hidden, inverse)
- * - 16-color, 256-color, 24-bit truecolor (foreground, background, underline color)
- * - Full cursor control (CUP, CUU/CUD/CUF/CUB, CPR, CHA, CNL, CPL, HVP, save/restore)
- * - Cursor shape (DECSCUSR — block, underline, bar, blinking variants)
- * - Erase operations (ED 0/1/2/3, EL 0/1/2, ECH)
- * - Editing operations (ICH, DCH, IL, DL, REP)
- * - Scroll regions (DECSTBM, SU, SD) with content preservation
- * - DEC private modes (alt screen, auto-wrap, origin, insert, reverse video, bracketed paste)
- * - Mouse tracking (X10, normal, button, any-event, SGR format)
- * - Focus tracking (mode 1004)
- * - Application cursor keys & keypad
- * - Synchronized output (mode 2026)
- * - Kitty keyboard protocol (CSI u / progressive enhancement)
- * - Scrollback buffer with configurable limit
- * - Wide character support (CJK, emoji ZWJ, regional indicators, VS-16)
- * - OSC sequences (title, hyperlinks, clipboard, colors)
- * - DCS sequences (XTVERSION, DECRQSS, XTGETTCAP, Sixel)
- * - APC sequences (Kitty graphics protocol — parsed, query responses)
- * - DA1/DA2/DA3 device attribute responses
- * - DSR (device status report) responses
- * - DECRPM (mode reporting)
- * - Character sets (DEC Special Graphics, UTF-8)
- * - Full C0/C1 control code handling
- * - DECSTR soft terminal reset
- *
- * @see https://terminfo.dev for the feature matrix
- * @see https://github.com/beorn/vterm for the monorepo
- */
-
-// ── Types ──────────────────────────────────────────────────────────────
-
-export interface CellColor {
-  r: number
-  g: number
-  b: number
-}
-
-export type UnderlineStyle = "none" | "single" | "double" | "curly" | "dotted" | "dashed"
-
-export interface ScreenCell {
-  char: string
-  fg: CellColor | null
-  bg: CellColor | null
-  bold: boolean
-  faint: boolean
-  italic: boolean
-  underline: UnderlineStyle
-  underlineColor: CellColor | null
-  overline: boolean
-  strikethrough: boolean
-  inverse: boolean
-  hidden: boolean
-  blink: boolean
-  wide: boolean
-  url: string | null
-}
-
-export interface ScreenOptions {
-  cols?: number
-  rows?: number
-  scrollbackLimit?: number
-  /** Callback for DA1/DA2/DSR responses — write these back to the PTY */
-  onResponse?: (data: string) => void
-}
-
-export interface SemanticZone {
-  type: "prompt" | "command" | "output"
-  startRow: number
-  startCol: number
-}
-
-export interface SixelImage {
-  data: string
-  row: number // cursor row when sixel started
-  col: number // cursor col when sixel started
-}
-
-export interface Screen {
-  readonly cols: number
-  readonly rows: number
-
-  process(data: Uint8Array): void
-  resize(cols: number, rows: number): void
-  reset(): void
-
-  getCell(row: number, col: number): ScreenCell
-  getLine(row: number): ScreenCell[]
-  getText(): string
-  getTextRange(startRow: number, startCol: number, endRow: number, endCol: number): string
-
-  getCursorPosition(): { x: number; y: number }
-  getCursorVisible(): boolean
-  getCursorShape(): "block" | "underline" | "bar"
-  getCursorBlinking(): boolean
-
-  getTitle(): string
-  getMode(mode: string): boolean
-  getClipboard(): string
-  getCwd(): string
-  getNotifications(): string[]
-
-  getScrollbackLength(): number
-  getViewportOffset(): number
-  scrollViewport(delta: number): void
-
-  getSemanticZones(): SemanticZone[]
-  getSixelImages(): SixelImage[]
-}
-
-// ── Implementation ─────────────────────────────────────────────────────
-
-/** Frozen sentinel for unwritten cells — never mutate, copy-on-write in writeChar(). */
-const EMPTY_CELL: ScreenCell = Object.freeze({
-  char: "",
-  fg: null,
-  bg: null,
-  bold: false,
-  faint: false,
-  italic: false,
-  underline: "none" as UnderlineStyle,
-  underlineColor: null,
-  overline: false,
-  strikethrough: false,
-  inverse: false,
-  hidden: false,
-  blink: false,
-  wide: false,
-  url: null,
-})
-
-function emptyCell(): ScreenCell {
-  return { ...EMPTY_CELL }
-}
-
-// ── ANSI 256-color palette ─────────────────────────────────────────────
-
-const ANSI_16: readonly CellColor[] = [
-  { r: 0x00, g: 0x00, b: 0x00 }, // 0  Black
-  { r: 0x80, g: 0x00, b: 0x00 }, // 1  Red
-  { r: 0x00, g: 0x80, b: 0x00 }, // 2  Green
-  { r: 0x80, g: 0x80, b: 0x00 }, // 3  Yellow
-  { r: 0x00, g: 0x00, b: 0x80 }, // 4  Blue
-  { r: 0x80, g: 0x00, b: 0x80 }, // 5  Magenta
-  { r: 0x00, g: 0x80, b: 0x80 }, // 6  Cyan
-  { r: 0xc0, g: 0xc0, b: 0xc0 }, // 7  White
-  { r: 0x80, g: 0x80, b: 0x80 }, // 8  Bright Black
-  { r: 0xff, g: 0x00, b: 0x00 }, // 9  Bright Red
-  { r: 0x00, g: 0xff, b: 0x00 }, // 10 Bright Green
-  { r: 0xff, g: 0xff, b: 0x00 }, // 11 Bright Yellow
-  { r: 0x00, g: 0x00, b: 0xff }, // 12 Bright Blue
-  { r: 0xff, g: 0x00, b: 0xff }, // 13 Bright Magenta
-  { r: 0x00, g: 0xff, b: 0xff }, // 14 Bright Cyan
-  { r: 0xff, g: 0xff, b: 0xff }, // 15 Bright White
-]
-
-function buildPalette256(): CellColor[] {
-  const palette: CellColor[] = [...ANSI_16]
-  const levels = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
-  for (let r = 0; r < 6; r++) {
-    for (let g = 0; g < 6; g++) {
-      for (let b = 0; b < 6; b++) {
-        palette.push({ r: levels[r]!, g: levels[g]!, b: levels[b]! })
-      }
-    }
-  }
-  for (let i = 0; i < 24; i++) {
-    const v = 8 + i * 10
-    palette.push({ r: v, g: v, b: v })
-  }
-  return palette
-}
-
-const PALETTE_256 = buildPalette256()
-
-// ── DEC Special Graphics character set ─────────────────────────────────
-
-const DEC_SPECIAL_GRAPHICS: Record<string, string> = {
-  j: "\u2518", // ┘
-  k: "\u2510", // ┐
-  l: "\u250c", // ┌
-  m: "\u2514", // └
-  n: "\u253c", // ┼
-  q: "\u2500", // ─
-  t: "\u251c", // ├
-  u: "\u2524", // ┤
-  v: "\u2534", // ┴
-  w: "\u252c", // ┬
-  x: "\u2502", // │
-  a: "\u2592", // ▒
-  f: "\u00b0", // °
-  g: "\u00b1", // ±
-  "~": "\u00b7", // ·
-  y: "\u2264", // ≤
-  z: "\u2265", // ≥
-  "{": "\u03c0", // π
-  "|": "\u2260", // ≠
-  "}": "\u00a3", // £
-}
-
-// ── Unicode width & character classification ────────────────────────────
-
-function isWide(codePoint: number): boolean {
-  return (
-    (codePoint >= 0x1100 && codePoint <= 0x115f) || // Hangul Jamo
-    (codePoint >= 0x231a && codePoint <= 0x231b) || // Watch, Hourglass
-    (codePoint >= 0x2614 && codePoint <= 0x2615) || // Umbrella, Hot Beverage
-    (codePoint >= 0x2648 && codePoint <= 0x2653) || // Zodiac signs
-    codePoint === 0x267f || // Wheelchair
-    codePoint === 0x2693 || // Anchor
-    codePoint === 0x26a1 || // High Voltage
-    codePoint === 0x26ce || // Ophiuchus
-    codePoint === 0x26d4 || // No Entry
-    codePoint === 0x2705 || // Check Mark
-    codePoint === 0x2728 || // Sparkles
-    codePoint === 0x274c || // Cross Mark
-    codePoint === 0x274e || // Cross Mark variant
-    (codePoint >= 0x2753 && codePoint <= 0x2755) || // Question marks
-    (codePoint >= 0x2795 && codePoint <= 0x2797) || // Plus, Minus, Division
-    codePoint === 0x27b0 || // Curly Loop
-    codePoint === 0x27bf || // Double Curly Loop
-    (codePoint >= 0x2e80 && codePoint <= 0x303e) || // CJK Radicals
-    (codePoint >= 0x3041 && codePoint <= 0x33bf) || // Hiragana, Katakana, Bopomofo, etc.
-    (codePoint >= 0x3400 && codePoint <= 0x4dbf) || // CJK Unified Extension A
-    (codePoint >= 0x4e00 && codePoint <= 0xa4cf) || // CJK Unified Ideographs
-    (codePoint >= 0xa960 && codePoint <= 0xa97c) || // Hangul Jamo Extended-A
-    (codePoint >= 0xac00 && codePoint <= 0xd7a3) || // Hangul Syllables
-    (codePoint >= 0xf900 && codePoint <= 0xfaff) || // CJK Compatibility Ideographs
-    (codePoint >= 0xfe10 && codePoint <= 0xfe19) || // Vertical Forms
-    (codePoint >= 0xfe30 && codePoint <= 0xfe6b) || // CJK Compatibility Forms
-    (codePoint >= 0xff01 && codePoint <= 0xff60) || // Fullwidth Forms
-    (codePoint >= 0xffe0 && codePoint <= 0xffe6) || // Fullwidth Signs
-    codePoint === 0x1f004 || // Mahjong Tile
-    codePoint === 0x1f0cf || // Playing Card
-    (codePoint >= 0x1f170 && codePoint <= 0x1f171) || // A/B buttons
-    (codePoint >= 0x1f17e && codePoint <= 0x1f17f) || // O/P buttons
-    codePoint === 0x1f18e || // AB button
-    (codePoint >= 0x1f191 && codePoint <= 0x1f19a) || // Squared symbols
-    (codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff) || // Regional Indicators
-    (codePoint >= 0x1f200 && codePoint <= 0x1f202) || // Enclosed CJK
-    (codePoint >= 0x1f300 && codePoint <= 0x1f9ff) || // Misc Symbols/Emoticons
-    (codePoint >= 0x1fa00 && codePoint <= 0x1faff) || // Extended Symbols & Pictographs
-    (codePoint >= 0x20000 && codePoint <= 0x2fffd) || // CJK Extension B-F
-    (codePoint >= 0x30000 && codePoint <= 0x3fffd) // CJK Extension G+
-  )
-}
-
-function isCombining(cp: number): boolean {
-  return (
-    (cp >= 0x0300 && cp <= 0x036f) || // Combining Diacritical Marks
-    (cp >= 0x0483 && cp <= 0x0489) || // Cyrillic combining
-    (cp >= 0x0591 && cp <= 0x05bd) || // Hebrew
-    cp === 0x05bf || // Hebrew
-    (cp >= 0x05c1 && cp <= 0x05c2) || // Hebrew
-    (cp >= 0x05c4 && cp <= 0x05c5) || // Hebrew
-    cp === 0x05c7 || // Hebrew
-    (cp >= 0x0610 && cp <= 0x061a) || // Arabic
-    (cp >= 0x064b && cp <= 0x065f) || // Arabic
-    cp === 0x0670 || // Arabic
-    (cp >= 0x06d6 && cp <= 0x06dc) || // Arabic
-    (cp >= 0x06df && cp <= 0x06e4) || // Arabic
-    (cp >= 0x06e7 && cp <= 0x06e8) || // Arabic
-    (cp >= 0x06ea && cp <= 0x06ed) || // Arabic
-    (cp >= 0x0730 && cp <= 0x074a) || // Syriac
-    (cp >= 0x0900 && cp <= 0x0903) || // Devanagari
-    (cp >= 0x093a && cp <= 0x094f) || // Devanagari
-    (cp >= 0x0951 && cp <= 0x0957) || // Devanagari
-    (cp >= 0x0962 && cp <= 0x0963) || // Devanagari
-    cp === 0x0e31 || // Thai
-    (cp >= 0x0e34 && cp <= 0x0e3a) || // Thai
-    (cp >= 0x0e47 && cp <= 0x0e4e) || // Thai
-    (cp >= 0x1ab0 && cp <= 0x1aff) || // Combining Diacritical Marks Extended
-    (cp >= 0x1dc0 && cp <= 0x1dff) || // Combining Diacritical Marks Supplement
-    (cp >= 0x20d0 && cp <= 0x20ff) || // Combining Diacritical Marks for Symbols
-    (cp >= 0xfe00 && cp <= 0xfe0f) || // Variation Selectors
-    (cp >= 0xe0100 && cp <= 0xe01ef) // Variation Selectors Supplement
-  )
-}
-
-function isRegionalIndicator(cp: number): boolean {
-  return cp >= 0x1f1e6 && cp <= 0x1f1ff
-}
-
-function isZWJ(cp: number): boolean {
-  return cp === 0x200d
-}
-
-function isVS16(cp: number): boolean {
-  return cp === 0xfe0f
-}
-
-function isEmojiModifier(cp: number): boolean {
-  return cp >= 0x1f3fb && cp <= 0x1f3ff // Skin tone modifiers
-}
-
-// ── Internal attrs interface ───────────────────────────────────────────
-
-interface Attrs {
-  fg: CellColor | null
-  bg: CellColor | null
-  bold: boolean
-  faint: boolean
-  italic: boolean
-  underline: UnderlineStyle
-  underlineColor: CellColor | null
-  overline: boolean
-  strikethrough: boolean
-  inverse: boolean
-  hidden: boolean
-  blink: boolean
-  url: string | null
-}
-
-// ── Screen factory ─────────────────────────────────────────────────────
-
-export function createScreen(options: ScreenOptions = {}): Screen {
-  let cols = options.cols ?? 80
-  let rows = options.rows ?? 24
-  const scrollbackLimit = options.scrollbackLimit ?? 1000
-  const onResponse = options.onResponse
-
-  // Main and alternate screen buffers
-  let mainGrid: ScreenCell[][] = makeGrid(cols, rows)
-  let altGrid: ScreenCell[][] = makeGrid(cols, rows)
-  let grid = mainGrid
-  let scrollback: ScreenCell[][] = []
-
-  // Cursor
-  let curX = 0
-  let curY = 0
-  let curVisible = true
-  let cursorShape: "block" | "underline" | "bar" = "block"
-  let cursorBlinking = true
-
-  // DECSC/DECRC saved state
-  interface SavedState {
-    curX: number
-    curY: number
-    attrs: Attrs
-    originMode: boolean
-    autoWrap: boolean
-    charsetG0: boolean // true = DEC Special Graphics
-  }
-  let savedState: SavedState = {
-    curX: 0,
-    curY: 0,
-    attrs: resetAttrs(),
-    originMode: false,
-    autoWrap: true,
-    charsetG0: false,
-  }
-
-  // Saved cursor for alt screen (separate from DECSC)
-  let savedCurX = 0
-  let savedCurY = 0
-
-  // Current drawing attributes
-  let attrs: Attrs = resetAttrs()
-
-  // Terminal state
-  let title = ""
-  let useAltScreen = false
-  let bracketedPaste = false
-  let applicationCursor = false
-  let applicationKeypad = false
-  let autoWrap = true
-  let mouseTracking = false
-  let mouseTrackingMode = 0 // 1000, 1002, 1003
-  let sgrMouse = false
-  let focusTracking = false
-  let originMode = false
-  let insertMode = false
-  let reverseVideo = false
-  let syncOutput = false
-
-  // Kitty keyboard protocol
-  // Headless design: we implement the full push/pop/query state machine so that
-  // applications can negotiate keyboard encoding modes. The flags are stored and
-  // queryable (CSI ? u responds correctly), and a host can read them to decide
-  // how to encode keypresses. The actual key encoding lives in the host layer
-  // (e.g. termless's encodeKeyToAnsi), not here — separation of concerns.
-  let kittyKeyboardFlags = 0
-  let kittyKeyboardStack: number[] = []
-
-  // Kitty graphics protocol
-  // Headless design: we parse the APC G protocol and respond to queries so that
-  // applications relying on the query→response handshake work correctly. We don't
-  // store image data because there's no pixel framebuffer — unlike sixel where we
-  // preserve the raw data for consumers, kitty graphics payloads are chunked and
-  // stateful, making storage without rendering impractical.
-  let hasKittyGraphics = false
-
-  // Scroll region (inclusive, 0-based)
-  let scrollTop = 0
-  let scrollBottom = rows - 1
-
-  // Viewport scroll offset
-  let viewportOffset = 0
-
-  // Character set: true = DEC Special Graphics (G0)
-  let charsetG0 = false
-
-  // Clipboard (OSC 52)
-  let clipboard = ""
-
-  // Current working directory (OSC 7)
-  let cwd = ""
-
-  // Notifications (OSC 9)
-  let notifications: string[] = []
-
-  // Semantic prompt zones (OSC 133 / OSC 633)
-  let semanticZones: SemanticZone[] = []
-
-  // Sixel graphics (DCS q)
-  // Headless design: we parse sixel data and store it for consumers (e.g. a GUI
-  // renderer could use getSixelImages() to display them). We don't decode pixels
-  // because there's no framebuffer to render into — but preserving the data means
-  // a host application gets full fidelity without re-parsing the stream.
-  let hasSixel = false
-  let sixelImages: SixelImage[] = []
-
-  // Soft-wrap tracking: true if the line break at end of this row was caused by auto-wrap
-  let mainSoftWrapped: boolean[] = new Array(rows).fill(false)
-  let altSoftWrapped: boolean[] = new Array(rows).fill(false)
-  let softWrapped = mainSoftWrapped
-
-  // Last printed character for REP
-  let lastChar = ""
-
-  // Unicode sequence state
-  let pendingRegionalIndicator: string | null = null // First RI waiting for pair
-  let afterZWJ = false // Next character should join with previous cell
-
-  // Parser state
-  let parserState:
-    | "ground"
-    | "escape"
-    | "escape_charset"
-    | "csi"
-    | "osc"
-    | "dcs"
-    | "dcs_passthrough"
-    | "osc_st"
-    | "dcs_st"
-    | "apc"
-    | "apc_st" = "ground"
-  let escBuf = ""
-  let oscBuf = ""
-  let dcsBuf = ""
-  let dcsStartRow = 0
-  let dcsStartCol = 0
-  let apcBuf = ""
-
-  // Decoder for incoming bytes
-  const decoder = new TextDecoder()
-
-  // ── Grid helpers ──
-
-  function makeGrid(c: number, r: number): ScreenCell[][] {
-    const g: ScreenCell[][] = []
-    for (let row = 0; row < r; row++) {
-      g.push(makeRow(c))
-    }
-    return g
-  }
-
-  function makeRow(c: number): ScreenCell[] {
-    const row: ScreenCell[] = []
-    for (let col = 0; col < c; col++) {
-      row.push(EMPTY_CELL)
-    }
-    return row
-  }
-
-  function resetAttrs(): Attrs {
-    return {
-      fg: null,
-      bg: null,
-      bold: false,
-      faint: false,
-      italic: false,
-      underline: "none",
-      underlineColor: null,
-      overline: false,
-      strikethrough: false,
-      inverse: false,
-      hidden: false,
-      blink: false,
-      url: null,
-    }
-  }
-
-  function clampCursor(): void {
-    if (curX < 0) curX = 0
-    if (curX >= cols) curX = cols - 1
-    if (curY < 0) curY = 0
-    if (curY >= rows) curY = rows - 1
-  }
-
-  // ── Scrolling ──
-
-  function scrollUp(top: number, bottom: number): void {
-    // Move top row to scrollback (only if main screen & top of screen)
-    if (grid === mainGrid && top === 0) {
-      scrollback.push(grid[0]!)
-      if (scrollback.length > scrollbackLimit * 2) {
-        scrollback.splice(0, scrollback.length - scrollbackLimit)
-      }
-    }
-    for (let i = top; i < bottom; i++) {
-      grid[i] = grid[i + 1]!
-      softWrapped[i] = softWrapped[i + 1]!
-    }
-    grid[bottom] = makeRow(cols)
-    softWrapped[bottom] = false
-  }
-
-  function scrollDown(top: number, bottom: number): void {
-    for (let i = bottom; i > top; i--) {
-      grid[i] = grid[i - 1]!
-      softWrapped[i] = softWrapped[i - 1]!
-    }
-    grid[top] = makeRow(cols)
-    softWrapped[top] = false
-  }
-
-  // ── Character writing ──
-
-  /** Find the previous non-spacer cell (the cell before curX, skipping wide-char spacers) */
-  function getPrevCell(): { cell: ScreenCell; col: number } | null {
-    if (curX === 0 && curY === 0) return null
-    let prevCol = curX - 1
-    let prevRow = curY
-    if (prevCol < 0) {
-      prevRow--
-      if (prevRow < 0) return null
-      prevCol = cols - 1
-    }
-    const row = grid[prevRow]!
-    let cell = row[prevCol]!
-    // If we landed on a spacer (empty char after a wide character), go back one more
-    if (cell !== EMPTY_CELL && cell.char === "" && prevCol > 0) {
-      prevCol--
-      cell = row[prevCol]!
-    }
-    if (cell === EMPTY_CELL) return null
-    return { cell, col: prevCol }
-  }
-
-  /** Widen a cell to 2 columns, adding a spacer cell after it */
-  function widenCell(row: ScreenCell[], col: number, cell: ScreenCell): void {
-    cell.wide = true
-    if (col + 1 < cols) {
-      let spacer = row[col + 1]!
-      if (spacer === EMPTY_CELL) {
-        spacer = { ...EMPTY_CELL }
-        row[col + 1] = spacer
-      }
-      spacer.char = ""
-      spacer.fg = null
-      spacer.bg = null
-      spacer.bold = false
-      spacer.faint = false
-      spacer.italic = false
-      spacer.underline = "none"
-      spacer.underlineColor = null
-      spacer.overline = false
-      spacer.strikethrough = false
-      spacer.inverse = false
-      spacer.hidden = false
-      spacer.blink = false
-      spacer.wide = false
-      spacer.url = null
-    }
-  }
-
-  function writeChar(ch: string): void {
-    // Apply DEC Special Graphics character mapping
-    if (charsetG0 && ch.length === 1) {
-      const mapped = DEC_SPECIAL_GRAPHICS[ch]
-      if (mapped) ch = mapped
-    }
-
-    const codePoint = ch.codePointAt(0) ?? 0
-
-    // ── VS-16 (U+FE0F): widen previous character to emoji presentation ──
-    if (isVS16(codePoint)) {
-      const prev = getPrevCell()
-      if (prev && !prev.cell.wide) {
-        prev.cell.char += ch
-        const row = grid[curY === 0 && curX === 0 ? 0 : curY]!
-        widenCell(row, prev.col, prev.cell)
-        // Advance cursor past the spacer
-        curX = prev.col + 2
-        if (curX >= cols) curX = cols - 1
-      }
-      return
-    }
-
-    // ── Combining characters: append to previous cell, zero width ──
-    if (isCombining(codePoint) && !isVS16(codePoint)) {
-      const prev = getPrevCell()
-      if (prev) {
-        prev.cell.char += ch
-      }
-      return
-    }
-
-    // ── Emoji modifier (skin tone): append to previous cell, zero width ──
-    if (isEmojiModifier(codePoint)) {
-      const prev = getPrevCell()
-      if (prev) {
-        prev.cell.char += ch
-      }
-      return
-    }
-
-    // ── ZWJ (U+200D): append to previous cell, flag for next char ──
-    if (isZWJ(codePoint)) {
-      const prev = getPrevCell()
-      if (prev) {
-        prev.cell.char += ch
-        afterZWJ = true
-      }
-      return
-    }
-
-    // ── After ZWJ: append this character to the previous cell ──
-    if (afterZWJ) {
-      afterZWJ = false
-      const prev = getPrevCell()
-      if (prev) {
-        prev.cell.char += ch
-        // The ZWJ sequence stays in the same wide cell
-        return
-      }
-    }
-
-    // ── Regional Indicators: pair into flag emoji ──
-    if (isRegionalIndicator(codePoint)) {
-      if (pendingRegionalIndicator !== null) {
-        // Second RI: combine with first to form a flag, render as wide
-        const flag = pendingRegionalIndicator + ch
-        pendingRegionalIndicator = null
-        // Write the combined flag as a wide character
-        writeCharCore(flag, true)
-        return
-      } else {
-        // First RI: store and wait for second
-        pendingRegionalIndicator = ch
-        return
-      }
-    }
-
-    // Flush any pending regional indicator that wasn't paired
-    if (pendingRegionalIndicator !== null) {
-      const ri = pendingRegionalIndicator
-      pendingRegionalIndicator = null
-      writeCharCore(ri, true)
-    }
-
-    const wide = isWide(codePoint)
-    writeCharCore(ch, wide)
-  }
-
-  function writeCharCore(ch: string, wide: boolean): void {
-    const charWidth = wide ? 2 : 1
-
-    // Handle autowrap at end of line
-    if (curX + charWidth > cols) {
-      if (autoWrap) {
-        // Mark this row as soft-wrapped (auto-wrap caused the line break)
-        softWrapped[curY] = true
-        curX = 0
-        curY++
-        if (curY > scrollBottom) {
-          curY = scrollBottom
-          scrollUp(scrollTop, scrollBottom)
-        }
-      } else {
-        curX = cols - charWidth
-      }
-    }
-
-    // Insert mode: shift existing characters right before writing
-    if (insertMode) {
-      const row = grid[curY]!
-      for (let i = 0; i < charWidth; i++) {
-        row.splice(curX, 0, EMPTY_CELL)
-        row.pop()
-      }
-    }
-
-    // Copy-on-write: if cell is the shared EMPTY_CELL sentinel, create a fresh object
-    const row = grid[curY]!
-    let cell = row[curX]!
-    if (cell === EMPTY_CELL) {
-      cell = { ...EMPTY_CELL }
-      row[curX] = cell
-    }
-    cell.char = ch
-    cell.fg = attrs.fg ? { ...attrs.fg } : null
-    cell.bg = attrs.bg ? { ...attrs.bg } : null
-    cell.bold = attrs.bold
-    cell.faint = attrs.faint
-    cell.italic = attrs.italic
-    cell.underline = attrs.underline
-    cell.underlineColor = attrs.underlineColor ? { ...attrs.underlineColor } : null
-    cell.overline = attrs.overline
-    cell.strikethrough = attrs.strikethrough
-    cell.inverse = attrs.inverse
-    cell.hidden = attrs.hidden
-    cell.blink = attrs.blink
-    cell.wide = wide
-    cell.url = attrs.url
-
-    if (wide) {
-      widenCell(row, curX, cell)
-    }
-
-    curX += charWidth
-    lastChar = ch
-  }
-
-  // ── CSI handler ──
-
-  function handleCSI(params: string, intermediates: string, finalByte: string): void {
-    const parts = params.split(";").map((s) => (s === "" ? 0 : parseInt(s, 10)))
-
-    // CSI with intermediates
-    if (intermediates === " ") {
-      if (finalByte === "q") {
-        // DECSCUSR - Set Cursor Shape
-        const ps = parts[0] ?? 0
-        switch (ps) {
-          case 0:
-          case 1:
-            cursorShape = "block"
-            cursorBlinking = true
-            break
-          case 2:
-            cursorShape = "block"
-            cursorBlinking = false
-            break
-          case 3:
-            cursorShape = "underline"
-            cursorBlinking = true
-            break
-          case 4:
-            cursorShape = "underline"
-            cursorBlinking = false
-            break
-          case 5:
-            cursorShape = "bar"
-            cursorBlinking = true
-            break
-          case 6:
-            cursorShape = "bar"
-            cursorBlinking = false
-            break
-        }
-      }
-      return
-    }
-
-    if (intermediates === "!") {
-      if (finalByte === "p") {
-        // DECSTR - Soft Terminal Reset
-        softReset()
-      }
-      return
-    }
-
-    if (intermediates === "$") {
-      // Mode reporting is handled in CSI private
-      return
-    }
-
-    switch (finalByte) {
-      case "A": // CUU - Cursor Up
-        curY -= Math.max(parts[0] ?? 1, 1)
-        clampCursor()
-        break
-      case "B": // CUD - Cursor Down
-        curY += Math.max(parts[0] ?? 1, 1)
-        clampCursor()
-        break
-      case "C": // CUF - Cursor Forward
-        curX += Math.max(parts[0] ?? 1, 1)
-        clampCursor()
-        break
-      case "D": // CUB - Cursor Back
-        curX -= Math.max(parts[0] ?? 1, 1)
-        clampCursor()
-        break
-      case "E": // CNL - Cursor Next Line
-        curY += Math.max(parts[0] ?? 1, 1)
-        curX = 0
-        clampCursor()
-        break
-      case "F": // CPL - Cursor Previous Line
-        curY -= Math.max(parts[0] ?? 1, 1)
-        curX = 0
-        clampCursor()
-        break
-      case "G": // CHA - Cursor Horizontal Absolute
-        curX = (parts[0] ?? 1) - 1
-        clampCursor()
-        break
-      case "H": // CUP - Cursor Position
-      case "f": // HVP - same as CUP
-        if (originMode) {
-          // DECOM: positions are relative to scroll region
-          curY = scrollTop + (parts[0] ?? 1) - 1
-          curX = (parts[1] ?? 1) - 1
-          // Clamp to scroll region bounds
-          if (curY < scrollTop) curY = scrollTop
-          if (curY > scrollBottom) curY = scrollBottom
-          if (curX < 0) curX = 0
-          if (curX >= cols) curX = cols - 1
-        } else {
-          curY = (parts[0] ?? 1) - 1
-          curX = (parts[1] ?? 1) - 1
-          clampCursor()
-        }
-        break
-      case "J": // ED - Erase in Display
-        handleEraseDisplay(parts[0] ?? 0)
-        break
-      case "K": // EL - Erase in Line
-        handleEraseLine(parts[0] ?? 0)
-        break
-      case "L": // IL - Insert Lines
-        handleInsertLines(Math.max(parts[0] ?? 1, 1))
-        break
-      case "M": // DL - Delete Lines
-        handleDeleteLines(Math.max(parts[0] ?? 1, 1))
-        break
-      case "P": // DCH - Delete Characters
-        handleDeleteChars(Math.max(parts[0] ?? 1, 1))
-        break
-      case "@": // ICH - Insert Characters
-        handleInsertChars(Math.max(parts[0] ?? 1, 1))
-        break
-      case "X": // ECH - Erase Characters
-        handleEraseChars(Math.max(parts[0] ?? 1, 1))
-        break
-      case "S": // SU - Scroll Up
-        for (let i = 0; i < Math.max(parts[0] ?? 1, 1); i++) {
-          scrollUp(scrollTop, scrollBottom)
-        }
-        break
-      case "T": // SD - Scroll Down
-        for (let i = 0; i < Math.max(parts[0] ?? 1, 1); i++) {
-          scrollDown(scrollTop, scrollBottom)
-        }
-        break
-      case "b": // REP - Repeat preceding character
-        if (lastChar) {
-          const count = Math.max(parts[0] ?? 1, 1)
-          for (let i = 0; i < count; i++) {
-            writeChar(lastChar)
-          }
-        }
-        break
-      case "d": // VPA - Line Position Absolute
-        curY = (parts[0] ?? 1) - 1
-        clampCursor()
-        break
-      case "m": // SGR - Select Graphic Rendition
-        handleSGR(params)
-        break
-      case "r": // DECSTBM - Set Scrolling Region
-        scrollTop = (parts[0] ?? 1) - 1
-        scrollBottom = (parts[1] ?? rows) - 1
-        if (scrollTop < 0) scrollTop = 0
-        if (scrollBottom >= rows) scrollBottom = rows - 1
-        if (scrollTop > scrollBottom) {
-          scrollTop = 0
-          scrollBottom = rows - 1
-        }
-        curX = 0
-        curY = originMode ? scrollTop : 0
-        break
-      case "n": // DSR - Device Status Report
-        if (onResponse) {
-          if (parts[0] === 5) {
-            // Status report - OK
-            onResponse("\x1b[0n")
-          } else if (parts[0] === 6) {
-            // Cursor position report
-            onResponse(`\x1b[${curY + 1};${curX + 1}R`)
-          }
-        }
-        break
-      case "c": // DA1 - Primary Device Attributes
-        if (onResponse) {
-          if (params === "" || params === "0") {
-            // VT200 (62) + sixel (4). We include sixel because we parse and
-            // preserve sixel data via getSixelImages() — applications checking
-            // DA1 for sixel support before sending image data will work correctly.
-            onResponse("\x1b[?62;4c")
-          }
-        }
-        break
-      case "h": // SM - Set Mode (non-private)
-        for (const code of parts) {
-          if (code === 4) insertMode = true // IRM - Insert/Replace Mode
-        }
-        break
-      case "l": // RM - Reset Mode (non-private)
-        for (const code of parts) {
-          if (code === 4) insertMode = false
-        }
-        break
-      case "s": // SCP - Save Cursor Position
-        savedCurX = curX
-        savedCurY = curY
-        break
-      case "u": // RCP - Restore Cursor Position
-        curX = savedCurX
-        curY = savedCurY
-        clampCursor()
-        break
-      default:
-        break
-    }
-  }
-
-  function handleCSIGt(params: string, _intermediates: string, finalByte: string): void {
-    const parts = params.split(";").map((s) => (s === "" ? 0 : parseInt(s, 10)))
-
-    // CSI > sequences
-    if (finalByte === "c") {
-      // DA2 - Secondary Device Attributes
-      if (onResponse) {
-        if (params === "" || params === "0") {
-          onResponse("\x1b[>1;100;0c")
-        }
-      }
-    } else if (finalByte === "q") {
-      // XTVERSION
-      if (onResponse) {
-        if (params === "" || params === "0") {
-          onResponse("\x1bP>|vterm.js 0.1.0\x1b\\")
-        }
-      }
-    } else if (finalByte === "u") {
-      // CSI > flags u — Push keyboard mode (Kitty keyboard protocol)
-      kittyKeyboardStack.push(kittyKeyboardFlags)
-      kittyKeyboardFlags = parts[0] ?? 0
-    }
-  }
-
-  function handleCSILt(_params: string, _intermediates: string, finalByte: string): void {
-    // CSI < sequences
-    if (finalByte === "u") {
-      // CSI < u — Pop keyboard mode (Kitty keyboard protocol)
-      kittyKeyboardFlags = kittyKeyboardStack.pop() ?? 0
-    }
-  }
-
-  function handleCSIEq(params: string, _intermediates: string, finalByte: string): void {
-    // CSI = sequences
-    if (finalByte === "c") {
-      // DA3 - Tertiary Device Attributes
-      if (onResponse) {
-        if (params === "" || params === "0") {
-          onResponse("\x1bP!|00000000\x1b\\")
-        }
-      }
-    }
-  }
-
-  function handleCSIPrivate(params: string, intermediates: string, finalByte: string): void {
-    const parts = params.split(";").map((s) => (s === "" ? 0 : parseInt(s, 10)))
-
-    // CSI ? u — Query keyboard mode (Kitty keyboard protocol)
-    if (finalByte === "u") {
-      if (onResponse) {
-        onResponse(`\x1b[?${kittyKeyboardFlags}u`)
-      }
-      return
-    }
-
-    // DECRPM - Mode reporting: CSI ? Pd $ p
-    if (intermediates === "$" && finalByte === "p") {
-      if (onResponse) {
-        const mode = parts[0] ?? 0
-        let value = 0 // 0 = not recognized
-        switch (mode) {
-          case 1:
-            value = applicationCursor ? 1 : 2
-            break
-          case 6:
-            value = originMode ? 1 : 2
-            break
-          case 7:
-            value = autoWrap ? 1 : 2
-            break
-          case 25:
-            value = curVisible ? 1 : 2
-            break
-          case 47:
-          case 1047:
-          case 1049:
-            value = useAltScreen ? 1 : 2
-            break
-          case 66:
-            value = applicationKeypad ? 1 : 2
-            break
-          case 1000:
-          case 1002:
-          case 1003:
-            value = mouseTracking ? 1 : 2
-            break
-          case 1004:
-            value = focusTracking ? 1 : 2
-            break
-          case 1006:
-            value = sgrMouse ? 1 : 2
-            break
-          case 2004:
-            value = bracketedPaste ? 1 : 2
-            break
-          case 2026:
-            value = syncOutput ? 1 : 2
-            break
-          case 5:
-            value = reverseVideo ? 1 : 2
-            break
-          case 4:
-            value = insertMode ? 1 : 2
-            break
-        }
-        onResponse(`\x1b[?${mode};${value}$y`)
-      }
-      return
-    }
-
-    // DECSED / DECSEL — selective erase (CSI ? J / CSI ? K)
-    // We treat selective erase same as normal erase (no DECSCA protection tracking)
-    if (finalByte === "J") {
-      handleEraseDisplay(parts[0] ?? 0)
-      return
-    }
-    if (finalByte === "K") {
-      handleEraseLine(parts[0] ?? 0)
-      return
-    }
-
-    const set = finalByte === "h"
-
-    for (const code of parts) {
-      switch (code) {
-        case 1: // DECCKM - Application Cursor
-          applicationCursor = set
-          break
-        case 4: // IRM - Insert Mode (via DEC private)
-          insertMode = set
-          break
-        case 5: // DECSCNM - Reverse Video
-          reverseVideo = set
-          break
-        case 6: // DECOM - Origin Mode
-          originMode = set
-          break
-        case 7: // DECAWM - Autowrap Mode
-          autoWrap = set
-          break
-        case 25: // DECTCEM - Cursor Visible
-          curVisible = set
-          break
-        case 47: // Alternate screen buffer (old)
-        case 1047: // Alternate screen buffer
-          if (set && !useAltScreen) {
-            useAltScreen = true
-            grid = altGrid
-            softWrapped = altSoftWrapped
-          } else if (!set && useAltScreen) {
-            useAltScreen = false
-            grid = mainGrid
-            softWrapped = mainSoftWrapped
-          }
-          break
-        case 66: // DECNKM - Application Keypad
-          applicationKeypad = set
-          break
-        case 9: // X10 mouse tracking
-          mouseTracking = set
-          mouseTrackingMode = set ? 9 : 0
-          break
-        case 1000: // Mouse tracking (basic)
-          mouseTracking = set
-          mouseTrackingMode = set ? 1000 : 0
-          break
-        case 1002: // Mouse tracking (button events)
-          mouseTracking = set
-          mouseTrackingMode = set ? 1002 : 0
-          break
-        case 1003: // Mouse tracking (all events)
-          mouseTracking = set
-          mouseTrackingMode = set ? 1003 : 0
-          break
-        case 1015: // urxvt mouse encoding
-          mouseTracking = set
-          mouseTrackingMode = set ? 1015 : 0
-          break
-        case 1016: // SGR pixel mouse
-          mouseTracking = set
-          mouseTrackingMode = set ? 1016 : 0
-          break
-        case 1004: // Focus tracking
-          focusTracking = set
-          break
-        case 1006: // SGR mouse mode
-          sgrMouse = set
-          break
-        case 1049: // Alternate screen buffer + save/restore cursor
-          if (set && !useAltScreen) {
-            savedCurX = curX
-            savedCurY = curY
-            useAltScreen = true
-            altGrid = makeGrid(cols, rows)
-            altSoftWrapped = new Array(rows).fill(false)
-            grid = altGrid
-            softWrapped = altSoftWrapped
-            curX = 0
-            curY = 0
-          } else if (!set && useAltScreen) {
-            useAltScreen = false
-            grid = mainGrid
-            softWrapped = mainSoftWrapped
-            curX = savedCurX
-            curY = savedCurY
-            clampCursor()
-          }
-          break
-        case 2004: // Bracketed paste
-          bracketedPaste = set
-          break
-        case 2026: // Synchronized output
-          syncOutput = set
-          break
-      }
-    }
-  }
-
-  // ── Erase operations ──
-
-  function handleEraseDisplay(mode: number): void {
-    switch (mode) {
-      case 0: // Erase from cursor to end
-        eraseCells(curY, curX, curY, cols - 1)
-        for (let row = curY + 1; row < rows; row++) {
-          eraseCells(row, 0, row, cols - 1)
-        }
-        break
-      case 1: // Erase from start to cursor
-        for (let row = 0; row < curY; row++) {
-          eraseCells(row, 0, row, cols - 1)
-        }
-        eraseCells(curY, 0, curY, curX)
-        break
-      case 2: // Erase entire display
-      case 3: // Erase entire display + scrollback
-        for (let row = 0; row < rows; row++) {
-          eraseCells(row, 0, row, cols - 1)
-        }
-        if (mode === 3) {
-          scrollback.length = 0
-        }
-        break
-    }
-  }
-
-  function handleEraseLine(mode: number): void {
-    switch (mode) {
-      case 0: // Erase from cursor to end of line
-        eraseCells(curY, curX, curY, cols - 1)
-        break
-      case 1: // Erase from start to cursor
-        eraseCells(curY, 0, curY, curX)
-        break
-      case 2: // Erase entire line
-        eraseCells(curY, 0, curY, cols - 1)
-        break
-    }
-  }
-
-  function eraseCells(row: number, startCol: number, _endRow: number, endCol: number): void {
-    const r = grid[row]
-    if (!r) return
-    for (let col = startCol; col <= endCol && col < cols; col++) {
-      const cell = emptyCell()
-      // Fill erased cells with the current background color
-      if (attrs.bg) {
-        cell.bg = { ...attrs.bg }
-      }
-      r[col] = cell
-    }
-  }
-
-  function handleInsertLines(count: number): void {
-    if (curY < scrollTop || curY > scrollBottom) return
-    for (let i = 0; i < count; i++) {
-      scrollDown(curY, scrollBottom)
-    }
-  }
-
-  function handleDeleteLines(count: number): void {
-    if (curY < scrollTop || curY > scrollBottom) return
-    for (let i = 0; i < count; i++) {
-      scrollUp(curY, scrollBottom)
-    }
-  }
-
-  function handleDeleteChars(count: number): void {
-    const row = grid[curY]
-    if (!row) return
-    for (let i = 0; i < count; i++) {
-      if (curX < cols) {
-        row.splice(curX, 1)
-        row.push(emptyCell())
-      }
-    }
-  }
-
-  function handleInsertChars(count: number): void {
-    const row = grid[curY]
-    if (!row) return
-    for (let i = 0; i < count; i++) {
-      row.splice(curX, 0, emptyCell())
-      row.pop()
-    }
-  }
-
-  function handleEraseChars(count: number): void {
-    const row = grid[curY]
-    if (!row) return
-    for (let i = 0; i < count && curX + i < cols; i++) {
-      row[curX + i] = emptyCell()
-    }
-  }
-
-  // ── SGR (Select Graphic Rendition) ──
-
-  function handleSGR(rawParams: string): void {
-    const segments = rawParams.split(";")
-    const params: number[] = []
-    const subParams = new Map<number, number[]>()
-    for (const seg of segments) {
-      if (seg.includes(":")) {
-        const subs = seg.split(":").map((s) => (s === "" ? 0 : parseInt(s, 10)))
-        subParams.set(params.length, subs)
-        params.push(subs[0]!)
-      } else {
-        params.push(seg === "" ? 0 : parseInt(seg, 10))
-      }
-    }
-
-    if (params.length === 0 || (params.length === 1 && params[0] === 0)) {
-      attrs = resetAttrs()
-      return
-    }
-
-    let i = 0
-    while (i < params.length) {
-      const code = params[i]!
-      switch (code) {
-        case 0:
-          attrs = resetAttrs()
-          break
-        case 1:
-          attrs.bold = true
-          break
-        case 2:
-          attrs.faint = true
-          break
-        case 3:
-          attrs.italic = true
-          break
-        case 4: {
-          // SGR 4 with optional sub-parameter: 4:0=none, 4:1=single, 4:3=curly, etc.
-          const subs = subParams.get(i)
-          if (subs && subs.length > 1) {
-            const sub = subs[1]!
-            switch (sub) {
-              case 0:
-                attrs.underline = "none"
-                break
-              case 1:
-                attrs.underline = "single"
-                break
-              case 2:
-                attrs.underline = "double"
-                break
-              case 3:
-                attrs.underline = "curly"
-                break
-              case 4:
-                attrs.underline = "dotted"
-                break
-              case 5:
-                attrs.underline = "dashed"
-                break
-              default:
-                attrs.underline = "single"
-                break
-            }
-          } else {
-            attrs.underline = "single"
-          }
-          break
-        }
-        case 5: // Slow blink
-          attrs.blink = true
-          break
-        case 6: // Rapid blink (treat same as blink)
-          attrs.blink = true
-          break
-        case 7:
-          attrs.inverse = true
-          break
-        case 8: // Hidden/conceal
-          attrs.hidden = true
-          break
-        case 9:
-          attrs.strikethrough = true
-          break
-        case 21: // Double underline
-          attrs.underline = "double"
-          break
-        case 22: // Normal intensity (neither bold nor faint)
-          attrs.bold = false
-          attrs.faint = false
-          break
-        case 23:
-          attrs.italic = false
-          break
-        case 24:
-          attrs.underline = "none"
-          break
-        case 25: // Blink off
-          attrs.blink = false
-          break
-        case 27:
-          attrs.inverse = false
-          break
-        case 28: // Reveal (turn off hidden/conceal)
-          attrs.hidden = false
-          break
-        case 29:
-          attrs.strikethrough = false
-          break
-        // Foreground colors 30-37
-        case 30:
-        case 31:
-        case 32:
-        case 33:
-        case 34:
-        case 35:
-        case 36:
-        case 37:
-          attrs.fg = { ...PALETTE_256[code - 30]! }
-          break
-        case 38: {
-          // Extended foreground: 38;5;N (256) or 38;2;R;G;B (truecolor)
-          // Also handle colon form: 38:5:N or 38:2:R:G:B
-          const subs = subParams.get(i)
-          if (subs && subs.length >= 3) {
-            const result = parseExtendedColorFromSubs(subs)
-            if (result) attrs.fg = result
-          } else {
-            const result = parseExtendedColor(params, i)
-            if (result) {
-              attrs.fg = result.color
-              i = result.nextIndex - 1
-            }
-          }
-          break
-        }
-        case 39: // Default foreground
-          attrs.fg = null
-          break
-        // Background colors 40-47
-        case 40:
-        case 41:
-        case 42:
-        case 43:
-        case 44:
-        case 45:
-        case 46:
-        case 47:
-          attrs.bg = { ...PALETTE_256[code - 40]! }
-          break
-        case 48: {
-          // Extended background: 48;5;N (256) or 48;2;R;G;B (truecolor)
-          const subs = subParams.get(i)
-          if (subs && subs.length >= 3) {
-            const result = parseExtendedColorFromSubs(subs)
-            if (result) attrs.bg = result
-          } else {
-            const result = parseExtendedColor(params, i)
-            if (result) {
-              attrs.bg = result.color
-              i = result.nextIndex - 1
-            }
-          }
-          break
-        }
-        case 49: // Default background
-          attrs.bg = null
-          break
-        case 53: // Overline
-          attrs.overline = true
-          break
-        case 55: // Overline off
-          attrs.overline = false
-          break
-        case 58: {
-          // Underline color: 58;5;N (256) or 58;2;R;G;B (truecolor)
-          // Also handle colon form: 58:5:N or 58:2:R:G:B
-          const subs = subParams.get(i)
-          if (subs && subs.length >= 3) {
-            const result = parseExtendedColorFromSubs(subs)
-            if (result) attrs.underlineColor = result
-          } else {
-            const result = parseExtendedColor(params, i)
-            if (result) {
-              attrs.underlineColor = result.color
-              i = result.nextIndex - 1
-            }
-          }
-          break
-        }
-        case 59: // Default underline color
-          attrs.underlineColor = null
-          break
-        // Bright foreground 90-97
-        case 90:
-        case 91:
-        case 92:
-        case 93:
-        case 94:
-        case 95:
-        case 96:
-        case 97:
-          attrs.fg = { ...PALETTE_256[code - 90 + 8]! }
-          break
-        // Bright background 100-107
-        case 100:
-        case 101:
-        case 102:
-        case 103:
-        case 104:
-        case 105:
-        case 106:
-        case 107:
-          attrs.bg = { ...PALETTE_256[code - 100 + 8]! }
-          break
-      }
-      i++
-    }
-  }
-
-  function parseExtendedColor(params: number[], startIndex: number): { color: CellColor; nextIndex: number } | null {
-    if (startIndex + 1 >= params.length) return null
-
-    const type = params[startIndex + 1]
-    if (type === 5 && startIndex + 2 < params.length) {
-      const idx = params[startIndex + 2]!
-      const color = PALETTE_256[idx] ?? { r: 0, g: 0, b: 0 }
-      return { color: { ...color }, nextIndex: startIndex + 3 }
-    } else if (type === 2 && startIndex + 4 < params.length) {
-      return {
-        color: {
-          r: params[startIndex + 2]!,
-          g: params[startIndex + 3]!,
-          b: params[startIndex + 4]!,
-        },
-        nextIndex: startIndex + 5,
-      }
-    }
-    return null
-  }
-
-  /** Parse extended color from colon sub-parameters (e.g., 38:2:R:G:B or 38:5:N) */
-  function parseExtendedColorFromSubs(subs: number[]): CellColor | null {
-    if (subs.length < 3) return null
-    const type = subs[1]
-    if (type === 5 && subs.length >= 3) {
-      const idx = subs[2]!
-      const color = PALETTE_256[idx] ?? { r: 0, g: 0, b: 0 }
-      return { ...color }
-    } else if (type === 2) {
-      // Can be 38:2:R:G:B or 38:2:colorspace:R:G:B
-      if (subs.length >= 5) {
-        // 38:2:R:G:B (no colorspace) or 38:2:cs:R:G:B
-        // If subs.length >= 6, assume colorspace variant
-        if (subs.length >= 6) {
-          return { r: subs[3]!, g: subs[4]!, b: subs[5]! }
-        }
-        return { r: subs[2]!, g: subs[3]!, b: subs[4]! }
-      } else if (subs.length >= 4) {
-        return { r: subs[2]!, g: subs[3]!, b: 0 }
-      }
-    }
-    return null
-  }
-
-  // ── OSC handler ──
-
-  function handleOSC(oscString: string): void {
-    const semicolonIdx = oscString.indexOf(";")
-    if (semicolonIdx === -1) return
-
-    const code = parseInt(oscString.substring(0, semicolonIdx), 10)
-    const value = oscString.substring(semicolonIdx + 1)
-
-    switch (code) {
-      case 0: // Set icon name and window title
-      case 2: // Set window title
-        title = value
-        break
-      case 133: {
-        // Semantic prompt markers (FinalTerm / shell integration)
-        // Value format: "X" or "X;params" where X is A/B/C/D
-        const marker = value.charAt(0)
-        switch (marker) {
-          case "A": // Start of prompt
-            semanticZones.push({ type: "prompt", startRow: curY, startCol: curX })
-            break
-          case "B": // End of prompt / start of command
-            semanticZones.push({ type: "command", startRow: curY, startCol: curX })
-            break
-          case "C": // End of command / start of output
-            semanticZones.push({ type: "output", startRow: curY, startCol: curX })
-            break
-          case "D": // End of output (exit code in params, ignored for storage)
-            break
-        }
-        break
-      }
-      case 1: // Set icon name (ignore)
-        break
-      case 7: // Current working directory: OSC 7 ; file://host/path ST
-        cwd = value
-        break
-      case 8: {
-        // Hyperlink: OSC 8 ; params ; url ST
-        // Format: 8;params;url  or  8;;url  or 8;;  (close)
-        const secondSemicolon = value.indexOf(";")
-        if (secondSemicolon !== -1) {
-          const url = value.substring(secondSemicolon + 1)
-          attrs.url = url || null
-        }
-        break
-      }
-      case 10: // Foreground color query
-        if (value === "?" && onResponse) {
-          // Default foreground (white-ish)
-          onResponse("\x1b]10;rgb:ffff/ffff/ffff\x1b\\")
-        }
-        break
-      case 11: // Background color query
-        if (value === "?" && onResponse) {
-          // Default background (black)
-          onResponse("\x1b]11;rgb:0000/0000/0000\x1b\\")
-        }
-        break
-      case 52: {
-        // Clipboard: OSC 52 ; selection ; base64-data ST
-        const clipSemi = value.indexOf(";")
-        if (clipSemi !== -1) {
-          const data = value.substring(clipSemi + 1)
-          if (data === "?") {
-            // Query clipboard
-            if (onResponse) {
-              const encoded = btoa(clipboard)
-              onResponse(`\x1b]52;c;${encoded}\x1b\\`)
-            }
-          } else {
-            // Set clipboard
-            try {
-              clipboard = atob(data)
-            } catch {
-              clipboard = ""
-            }
-            if (onResponse) {
-              onResponse(`\x1b]52;c;${data}\x1b\\`)
-            }
-          }
-        }
-        break
-      }
-      case 9: // Notifications: OSC 9 ; message ST (iTerm2/ConEmu convention)
-        notifications.push(value)
-        break
-      case 633: {
-        // VS Code shell integration (OSC 633 is a superset of OSC 133)
-        // Maps to the same semantic zone model as FinalTerm markers.
-        const marker = value.charAt(0)
-        switch (marker) {
-          case "A":
-            semanticZones.push({ type: "prompt", startRow: curY, startCol: curX })
-            break
-          case "B":
-            semanticZones.push({ type: "command", startRow: curY, startCol: curX })
-            break
-          case "C":
-            semanticZones.push({ type: "output", startRow: curY, startCol: curX })
-            break
-          case "D":
-            break
-        }
-        break
-      }
-      case 1337: {
-        // iTerm2 proprietary sequences
-        if (value === "ReportCellSize" && onResponse) {
-          // Report default 8x16 pixel cell size (standard monospace ratio)
-          onResponse("\x1b]1337;ReportCellSize=16;8\x1b\\")
-        } else if (value === "RequestCapabilities" && onResponse) {
-          // Report empty capabilities (protocol supported, no iTerm2-specific features)
-          onResponse("\x1b]1337;Capabilities=\x1b\\")
-        }
-        // Inline images (File=...) are silently consumed — no pixel framebuffer
-        break
-      }
-    }
-  }
-
-  // ── DCS handler ──
-
-  function handleDCS(data: string): void {
-    // Sixel graphics: DCS [Ps;Ps;Ps] q [sixel-data]
-    const match = data.match(/^(\d*(?:;\d*)*)q(.*)$/s)
-    if (match) {
-      hasSixel = true
-      sixelImages.push({
-        data: match[2]!,
-        row: dcsStartRow,
-        col: dcsStartCol,
-      })
-      return
-    }
-
-    // DECRQSS: DCS $ q Pt ST → response DCS Ps $ r Pt ST
-    if (data.startsWith("$q") && onResponse) {
-      const pt = data.substring(2)
-      if (pt === '"p') {
-        // DECSCL - Conformance level: VT200 mode, 8-bit controls
-        onResponse('\x1bP1$r62;1"p\x1b\\')
-      } else {
-        // Not recognized
-        onResponse("\x1bP0$r\x1b\\")
-      }
-      return
-    }
-
-    // XTGETTCAP: DCS + q hex ST → response DCS 1 + r hex = hexvalue ST
-    if (data.startsWith("+q") && onResponse) {
-      const hexName = data.substring(2)
-      if (hexName === "544e") {
-        // "TN" = terminal name → "vterm"
-        const hexValue = Array.from(new TextEncoder().encode("vterm"))
-          .map((b) => b.toString(16).padStart(2, "0"))
-          .join("")
-        onResponse(`\x1bP1+r544e=${hexValue}\x1b\\`)
-      } else {
-        // Unknown capability
-        onResponse("\x1bP0+r\x1b\\")
-      }
-      return
-    }
-
-    // Other DCS sequences are consumed and ignored
-  }
-
-  // ── APC handler ──
-
-  function handleAPC(data: string): void {
-    if (!data.startsWith("G")) return
-
-    hasKittyGraphics = true
-
-    // Parse key=value pairs
-    const semicolonIdx = data.indexOf(";")
-    const kvPart = semicolonIdx >= 0 ? data.substring(1, semicolonIdx) : data.substring(1)
-
-    const params: Record<string, string> = {}
-    for (const pair of kvPart.split(",")) {
-      const eqIdx = pair.indexOf("=")
-      if (eqIdx >= 0) {
-        params[pair.substring(0, eqIdx)] = pair.substring(eqIdx + 1)
-      }
-    }
-
-    // Handle query action
-    if (params.a === "q" && onResponse) {
-      // Respond: OK
-      onResponse(`\x1b_Gi=${params.i ?? "0"};OK\x1b\\`)
-    }
-  }
-
-  // ── Soft reset (DECSTR) ──
-
-  function softReset(): void {
-    // Reset modes to defaults
-    insertMode = false
-    originMode = false
-    autoWrap = true
-    curVisible = true
-    kittyKeyboardFlags = 0
-    kittyKeyboardStack = []
-    cursorShape = "block"
-    cursorBlinking = true
-    applicationCursor = false
-    applicationKeypad = false
-    reverseVideo = false
-
-    // Reset scroll region
-    scrollTop = 0
-    scrollBottom = rows - 1
-
-    // Reset attributes
-    attrs = resetAttrs()
-
-    // Reset character set
-    charsetG0 = false
-
-    // Reset cursor to home
-    curX = 0
-    curY = 0
-  }
-
-  // ── Full reset ──
-
-  function fullReset(): void {
-    mainGrid = makeGrid(cols, rows)
-    altGrid = makeGrid(cols, rows)
-    grid = mainGrid
-    scrollback = []
-    curX = 0
-    curY = 0
-    curVisible = true
-    cursorShape = "block"
-    cursorBlinking = true
-    savedCurX = 0
-    savedCurY = 0
-    savedState = { curX: 0, curY: 0, attrs: resetAttrs(), originMode: false, autoWrap: true, charsetG0: false }
-    attrs = resetAttrs()
-    title = ""
-    useAltScreen = false
-    bracketedPaste = false
-    applicationCursor = false
-    applicationKeypad = false
-    autoWrap = true
-    mouseTracking = false
-    mouseTrackingMode = 0
-    sgrMouse = false
-    focusTracking = false
-    originMode = false
-    insertMode = false
-    reverseVideo = false
-    syncOutput = false
-    kittyKeyboardFlags = 0
-    kittyKeyboardStack = []
-    hasKittyGraphics = false
-    hasSixel = false
-    sixelImages = []
-    scrollTop = 0
-    scrollBottom = rows - 1
-    viewportOffset = 0
-    charsetG0 = false
-    clipboard = ""
-    cwd = ""
-    notifications = []
-    lastChar = ""
-    pendingRegionalIndicator = null
-    afterZWJ = false
-    parserState = "ground"
-    escBuf = ""
-    oscBuf = ""
-    apcBuf = ""
-    semanticZones = []
-    mainSoftWrapped = new Array(rows).fill(false)
-    altSoftWrapped = new Array(rows).fill(false)
-    softWrapped = mainSoftWrapped
-  }
-
-  // ── Main parser ──
-
-  function process(data: Uint8Array): void {
-    const text = decoder.decode(data, { stream: true })
-
-    for (let i = 0; i < text.length; i++) {
-      const ch = text[i]!
-      const code = text.charCodeAt(i)
-
-      switch (parserState) {
-        case "ground":
-          if (code === 0x1b) {
-            parserState = "escape"
-            escBuf = ""
-          } else if (code === 0x07) {
-            // BEL — ignore
-          } else if (code === 0x08) {
-            // BS - Backspace
-            if (curX > 0) curX--
-          } else if (code === 0x09) {
-            // TAB
-            curX = Math.min((Math.floor(curX / 8) + 1) * 8, cols - 1)
-          } else if (code === 0x0a || code === 0x0b || code === 0x0c) {
-            // LF, VT, FF — linefeed (hard break — clear any soft-wrap flag)
-            softWrapped[curY] = false
-            curY++
-            if (curY > scrollBottom) {
-              curY = scrollBottom
-              scrollUp(scrollTop, scrollBottom)
-            }
-          } else if (code === 0x0d) {
-            // CR - Carriage Return
-            curX = 0
-          } else if (code >= 0x20) {
-            // Handle surrogate pairs for characters > U+FFFF
-            let char = ch
-            if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
-              const nextCode = text.charCodeAt(i + 1)
-              if (nextCode >= 0xdc00 && nextCode <= 0xdfff) {
-                char = ch + text[i + 1]!
-                i++
-              }
-            }
-            writeChar(char)
-          }
-          break
-
-        case "escape":
-          if (ch === "[") {
-            parserState = "csi"
-            escBuf = ""
-          } else if (ch === "]") {
-            parserState = "osc"
-            oscBuf = ""
-          } else if (ch === "P") {
-            parserState = "dcs"
-            escBuf = ""
-            dcsBuf = ""
-            dcsStartRow = curY
-            dcsStartCol = curX
-          } else if (ch === "c") {
-            // RIS - Reset to Initial State
-            fullReset()
-            parserState = "ground"
-          } else if (ch === "D") {
-            // IND - Index (move cursor down, scroll if needed)
-            curY++
-            if (curY > scrollBottom) {
-              curY = scrollBottom
-              scrollUp(scrollTop, scrollBottom)
-            }
-            parserState = "ground"
-          } else if (ch === "M") {
-            // RI - Reverse Index (move cursor up, scroll if needed)
-            curY--
-            if (curY < scrollTop) {
-              curY = scrollTop
-              scrollDown(scrollTop, scrollBottom)
-            }
-            parserState = "ground"
-          } else if (ch === "7") {
-            // DECSC - Save Cursor + attributes + modes
-            savedState = {
-              curX,
-              curY,
-              attrs: {
-                ...attrs,
-                fg: attrs.fg ? { ...attrs.fg } : null,
-                bg: attrs.bg ? { ...attrs.bg } : null,
-                underlineColor: attrs.underlineColor ? { ...attrs.underlineColor } : null,
-              },
-              originMode,
-              autoWrap,
-              charsetG0,
-            }
-            parserState = "ground"
-          } else if (ch === "8") {
-            // DECRC - Restore Cursor + attributes + modes
-            curX = savedState.curX
-            curY = savedState.curY
-            attrs = {
-              ...savedState.attrs,
-              fg: savedState.attrs.fg ? { ...savedState.attrs.fg } : null,
-              bg: savedState.attrs.bg ? { ...savedState.attrs.bg } : null,
-              underlineColor: savedState.attrs.underlineColor ? { ...savedState.attrs.underlineColor } : null,
-            }
-            originMode = savedState.originMode
-            autoWrap = savedState.autoWrap
-            charsetG0 = savedState.charsetG0
-            clampCursor()
-            parserState = "ground"
-          } else if (ch === "E") {
-            // NEL - Next Line
-            curX = 0
-            curY++
-            if (curY > scrollBottom) {
-              curY = scrollBottom
-              scrollUp(scrollTop, scrollBottom)
-            }
-            parserState = "ground"
-          } else if (ch === "(") {
-            // Designate G0 character set
-            parserState = "escape_charset"
-          } else if (ch === ")") {
-            // Designate G1 character set (ignored, just consume next byte)
-            parserState = "escape_charset"
-          } else if (ch === "=") {
-            // DECKPAM - Application Keypad Mode
-            applicationKeypad = true
-            parserState = "ground"
-          } else if (ch === ">") {
-            // DECKPNM - Normal Keypad Mode
-            applicationKeypad = false
-            parserState = "ground"
-          } else if (ch === "_") {
-            // APC - Application Program Command
-            parserState = "apc"
-            apcBuf = ""
-          } else {
-            // Unknown escape — return to ground
-            parserState = "ground"
-          }
-          break
-
-        case "escape_charset":
-          // Character set designation: ESC ( 0 = DEC Special Graphics, ESC ( B = ASCII
-          if (ch === "0") {
-            charsetG0 = true
-          } else {
-            charsetG0 = false // B = ASCII, or any other
-          }
-          parserState = "ground"
-          break
-
-        case "csi": {
-          if (code >= 0x40 && code <= 0x7e) {
-            // Final byte — dispatch CSI
-            // Extract intermediates (characters 0x20-0x2F between params and final)
-            let paramPart = escBuf
-            let intermediatePart = ""
-
-            // Check for intermediates at the end of escBuf
-            // Intermediates are 0x20-0x2F: space ! " # $ % & ' ( ) * + , - . /
-            let j = paramPart.length - 1
-            while (j >= 0) {
-              const c = paramPart.charCodeAt(j)
-              if (c >= 0x20 && c <= 0x2f) {
-                j--
-              } else {
-                break
-              }
-            }
-            if (j < paramPart.length - 1) {
-              intermediatePart = paramPart.substring(j + 1)
-              paramPart = paramPart.substring(0, j + 1)
-            }
-
-            if (paramPart.startsWith("?")) {
-              handleCSIPrivate(paramPart.substring(1), intermediatePart, ch)
-            } else if (paramPart.startsWith(">")) {
-              handleCSIGt(paramPart.substring(1), intermediatePart, ch)
-            } else if (paramPart.startsWith("<")) {
-              handleCSILt(paramPart.substring(1), intermediatePart, ch)
-            } else if (paramPart.startsWith("=")) {
-              handleCSIEq(paramPart.substring(1), intermediatePart, ch)
-            } else {
-              handleCSI(paramPart, intermediatePart, ch)
-            }
-            parserState = "ground"
-          } else if (escBuf.length >= 256) {
-            parserState = "ground"
-          } else {
-            escBuf += ch
-          }
-          break
-        }
-
-        case "osc":
-          if (code === 0x07) {
-            // BEL terminates OSC
-            handleOSC(oscBuf)
-            parserState = "ground"
-          } else if (code === 0x1b) {
-            // ESC might be start of ST (\x1b\\)
-            parserState = "osc_st"
-          } else if (oscBuf.length >= 4096) {
-            parserState = "ground"
-          } else {
-            oscBuf += ch
-          }
-          break
-
-        case "osc_st":
-          if (ch === "\\") {
-            // ST (String Terminator) — end of OSC
-            handleOSC(oscBuf)
-          }
-          parserState = "ground"
-          break
-
-        case "dcs":
-          // Accumulate DCS data until ST (ESC \) or BEL
-          if (code === 0x1b) {
-            parserState = "dcs_st"
-          } else if (code === 0x07) {
-            // BEL terminates DCS
-            handleDCS(dcsBuf)
-            parserState = "ground"
-          } else {
-            dcsBuf += ch
-          }
-          break
-
-        case "dcs_st":
-          // Expecting backslash to complete ST
-          if (ch === "\\") {
-            // ST (String Terminator) — end of DCS
-            handleDCS(dcsBuf)
-          }
-          parserState = "ground"
-          break
-
-        case "dcs_passthrough":
-          // Consume until ST
-          if (code === 0x1b) {
-            parserState = "dcs_st"
-          }
-          break
-
-        case "apc":
-          if (code === 0x1b) {
-            parserState = "apc_st"
-          } else if (code === 0x07) {
-            // BEL terminates APC
-            handleAPC(apcBuf)
-            parserState = "ground"
-          } else {
-            apcBuf += ch
-          }
-          break
-
-        case "apc_st":
-          if (ch === "\\") {
-            // ST (String Terminator) — end of APC
-            handleAPC(apcBuf)
-          }
-          parserState = "ground"
-          break
-      }
-    }
-  }
-
-  // ── Resize ──
-
-  /**
-   * Reconstruct logical lines from a grid, joining rows that were soft-wrapped.
-   * Returns an array of logical lines, each being an array of ScreenCells (may be longer than cols).
-   */
-  function getLogicalLines(srcGrid: ScreenCell[][], srcSoftWrapped: boolean[], srcRows: number): ScreenCell[][] {
-    const logical: ScreenCell[][] = []
-    let currentLine: ScreenCell[] = []
-
-    for (let r = 0; r < srcRows; r++) {
-      const row = srcGrid[r]
-      if (!row) continue
-      // Append this row's cells to the current logical line
-      for (let c = 0; c < row.length; c++) {
-        currentLine.push(row[c]!)
-      }
-      if (srcSoftWrapped[r]) {
-        // This row was soft-wrapped — continue accumulating into same logical line
-        continue
-      }
-      // Hard break (or last row): finalize this logical line
-      logical.push(currentLine)
-      currentLine = []
-    }
-    // If there's a dangling line (shouldn't happen, but be safe)
-    if (currentLine.length > 0) {
-      logical.push(currentLine)
-    }
-    return logical
-  }
-
-  /**
-   * Re-wrap logical lines to a new column width, producing grid rows and soft-wrap flags.
-   */
-  function rewrapLines(logicalLines: ScreenCell[][], newCols: number): { rows: ScreenCell[][]; wrapped: boolean[] } {
-    const outRows: ScreenCell[][] = []
-    const outWrapped: boolean[] = []
-
-    for (const line of logicalLines) {
-      // Trim trailing empty cells from logical line
-      let lineLen = line.length
-      while (lineLen > 0) {
-        const cell = line[lineLen - 1]!
-        if (cell === EMPTY_CELL || (cell.char === "" && !cell.wide)) {
-          lineLen--
-        } else {
-          break
-        }
-      }
-
-      if (lineLen === 0) {
-        // Empty logical line — produce one empty row
-        outRows.push(makeRow(newCols))
-        outWrapped.push(false)
-        continue
-      }
-
-      // Wrap the logical line content into rows of newCols width
-      let pos = 0
-      while (pos < lineLen) {
-        const row = makeRow(newCols)
-        let col = 0
-        while (col < newCols && pos < lineLen) {
-          const cell = line[pos]!
-          if (cell.wide && col + 2 > newCols) {
-            // Wide char doesn't fit — leave rest of row empty, wrap to next
-            break
-          }
-          row[col] = cell === EMPTY_CELL ? EMPTY_CELL : { ...cell }
-          col++
-          pos++
-          // If cell was wide, the next cell in the logical line is the spacer
-          // which we already advanced past via pos++
-        }
-        const moreContent = pos < lineLen
-        outRows.push(row)
-        outWrapped.push(moreContent) // soft-wrapped if there's more content to come
-      }
-    }
-
-    return { rows: outRows, wrapped: outWrapped }
-  }
-
-  /**
-   * Trim trailing empty rows from reflowed result, so they don't push content off the top
-   * when we take the last newRows rows.
-   */
-  function trimTrailingEmptyRows(result: { rows: ScreenCell[][]; wrapped: boolean[] }): void {
-    while (result.rows.length > 1) {
-      const lastRow = result.rows[result.rows.length - 1]!
-      const isEmpty = lastRow.every((cell) => cell === EMPTY_CELL || (cell.char === "" && !cell.wide))
-      if (isEmpty && !result.wrapped[result.rows.length - 2]) {
-        // The row before wasn't soft-wrapped and this row is empty — trim it
-        result.rows.pop()
-        result.wrapped.pop()
-      } else {
-        break
-      }
-    }
-  }
-
-  function resize(newCols: number, newRows: number): void {
-    // Reflow main grid
-    const mainLogical = getLogicalLines(mainGrid, mainSoftWrapped, rows)
-    const mainResult = rewrapLines(mainLogical, newCols)
-    trimTrailingEmptyRows(mainResult)
-
-    // Reflow alt grid (usually not reflowed, but do it for consistency)
-    const altLogical = getLogicalLines(altGrid, altSoftWrapped, rows)
-    const altResult = rewrapLines(altLogical, newCols)
-    trimTrailingEmptyRows(altResult)
-
-    // Build new grids: if reflowed content fits, place at top; if it overflows, take the last newRows
-    const newMain = makeGrid(newCols, newRows)
-    const newMainWrapped: boolean[] = new Array(newRows).fill(false)
-    const mainStartRow = Math.max(0, mainResult.rows.length - newRows)
-    for (let r = 0; r < newRows && mainStartRow + r < mainResult.rows.length; r++) {
-      newMain[r] = mainResult.rows[mainStartRow + r]!
-      newMainWrapped[r] = mainResult.wrapped[mainStartRow + r]!
-    }
-
-    // Build new alt grid
-    const newAlt = makeGrid(newCols, newRows)
-    const newAltWrapped: boolean[] = new Array(newRows).fill(false)
-    const altStartRow = Math.max(0, altResult.rows.length - newRows)
-    for (let r = 0; r < newRows && altStartRow + r < altResult.rows.length; r++) {
-      newAlt[r] = altResult.rows[altStartRow + r]!
-      newAltWrapped[r] = altResult.wrapped[altStartRow + r]!
-    }
-
-    mainGrid = newMain
-    altGrid = newAlt
-    mainSoftWrapped = newMainWrapped
-    altSoftWrapped = newAltWrapped
-    grid = useAltScreen ? altGrid : mainGrid
-    softWrapped = useAltScreen ? altSoftWrapped : mainSoftWrapped
-    cols = newCols
-    rows = newRows
-    scrollTop = 0
-    scrollBottom = rows - 1
-    clampCursor()
-  }
-
-  // ── Accessors ──
-
-  function getCell(row: number, col: number): ScreenCell {
-    const r = grid[row]
-    if (!r || col >= cols) return emptyCell()
-    return { ...r[col]! }
-  }
-
-  function getLine(row: number): ScreenCell[] {
-    const r = grid[row]
-    if (!r) return makeRow(cols)
-    return r.map((cell) => ({ ...cell }))
-  }
-
-  function getText(): string {
-    const lines: string[] = []
-    for (let r = 0; r < rows; r++) {
-      lines.push(rowToString(grid[r]!))
-    }
-    return lines.join("\n")
-  }
-
-  function rowToString(row: ScreenCell[]): string {
-    let line = ""
-    for (let i = 0; i < row.length; i++) {
-      const cell = row[i]!
-      if (cell.wide) {
-        line += cell.char
-      } else if (cell.char === "") {
-        if (i > 0 && row[i - 1]?.wide) {
-          continue
-        }
-        line += " "
-      } else {
-        line += cell.char
-      }
-    }
-    return line.replace(/\s+$/, "")
-  }
-
-  function getTextRange(startRow: number, startCol: number, endRow: number, endCol: number): string {
-    const parts: string[] = []
-
-    for (let row = startRow; row <= endRow; row++) {
-      const r = grid[row]
-      if (!r) continue
-
-      const colStart = row === startRow ? startCol : 0
-      const colEnd = row === endRow ? endCol : cols
-
-      let line = ""
-      for (let col = colStart; col < colEnd; col++) {
-        const cell = r[col]
-        if (!cell) continue
-        if (cell.char === "" && col > 0 && r[col - 1]?.wide) continue
-        line += cell.char || " "
-      }
-      parts.push(line.replace(/\s+$/, ""))
-    }
-
-    return parts.join("\n")
-  }
-
-  function getMode(mode: string): boolean {
-    switch (mode) {
-      case "altScreen":
-        return useAltScreen
-      case "cursorVisible":
-        return curVisible
-      case "bracketedPaste":
-        return bracketedPaste
-      case "applicationCursor":
-        return applicationCursor
-      case "applicationKeypad":
-        return applicationKeypad
-      case "autoWrap":
-        return autoWrap
-      case "mouseTracking":
-        return mouseTracking
-      case "focusTracking":
-        return focusTracking
-      case "originMode":
-        return originMode
-      case "insertMode":
-        return insertMode
-      case "reverseVideo":
-        return reverseVideo
-      case "syncOutput":
-        return syncOutput
-      case "sgrMouse":
-        return sgrMouse
-      case "pixelMouse":
-        return mouseTrackingMode === 1016
-      case "leftRightMargin":
-        return false // Not implemented yet
-      case "kittyKeyboard":
-        return kittyKeyboardFlags > 0
-      case "kittyGraphics":
-        return hasKittyGraphics
-      case "sixel":
-        return hasSixel
-      default:
-        return false
-    }
-  }
-
-  // Suppress unused variable warnings
-  void [mouseTrackingMode]
-
-  return {
-    get cols() {
-      return cols
-    },
-    get rows() {
-      return rows
-    },
-    process,
-    resize,
-    reset: fullReset,
-    getCell,
-    getLine,
-    getText,
-    getTextRange,
-    getCursorPosition: () => ({ x: curX, y: curY }),
-    getCursorVisible: () => curVisible,
-    getCursorShape: () => cursorShape,
-    getCursorBlinking: () => cursorBlinking,
-    getTitle: () => title,
-    getMode,
-    getClipboard: () => clipboard,
-    getCwd: () => cwd,
-    getNotifications: () => [...notifications],
-    getScrollbackLength: () => scrollback.length,
-    getViewportOffset: () => viewportOffset,
-    scrollViewport: (delta: number) => {
-      viewportOffset = Math.max(0, Math.min(scrollback.length, viewportOffset + delta))
-    },
-    getSemanticZones: () => semanticZones.map((z) => ({ ...z })),
-    getSixelImages: () => sixelImages.map((img) => ({ ...img })),
-  }
-}