vterm.js 0.1.0 → 0.2.0

package/src/screen.ts

@@ -16,16 +16,18 @@
  * - 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 (DECRQSS, XTGETTCAP)
+ * - DCS sequences (consumed and ignored, XTVERSION response)
+ * - 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
- * - Text reflow on resize
+ * - DECSTR soft terminal reset
  *
  * @see https://terminfo.dev for the feature matrix
  * @see https://github.com/beorn/vterm for the monorepo
@@ -67,6 +69,18 @@ export interface ScreenOptions {
   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
@@ -91,10 +105,14 @@ export interface Screen {
   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,
@@ -117,175 +135,2059 @@ 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
 
-  // Grid state
-  let grid: ScreenCell[][] = createGrid(cols, rows)
-  let altGrid: ScreenCell[][] = createGrid(cols, rows)
+  // Main and alternate screen buffers
+  let mainGrid: ScreenCell[][] = makeGrid(cols, rows)
+  let altGrid: ScreenCell[][] = makeGrid(cols, rows)
+  let grid = mainGrid
   let scrollback: ScreenCell[][] = []
 
-  // Cursor state
-  let cursorX = 0
-  let cursorY = 0
-  let cursorVisible = true
+  // Cursor
+  let curX = 0
+  let curY = 0
+  let curVisible = true
   let cursorShape: "block" | "underline" | "bar" = "block"
   let cursorBlinking = true
-  let savedCursor = { x: 0, y: 0, attrs: emptyCell() }
 
-  // SGR state
-  let attrs = emptyCell()
+  // 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,
+  }
 
-  // Mode flags
-  let altScreen = false
-  let autoWrap = true
-  let originMode = false
-  let insertMode = 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
 
-  // Scroll region
+  // Kitty keyboard protocol
+  let kittyKeyboardFlags = 0
+  let kittyKeyboardStack: number[] = []
+
+  // Kitty graphics protocol
+  let hasKittyGraphics = false
+
+  // Scroll region (inclusive, 0-based)
   let scrollTop = 0
   let scrollBottom = rows - 1
 
-  // OSC state
-  let title = ""
-
-  // Viewport
+  // Viewport scroll offset
   let viewportOffset = 0
 
+  // Character set: true = DEC Special Graphics (G0)
+  let charsetG0 = false
+
+  // Clipboard (OSC 52)
+  let clipboard = ""
+
+  // Semantic prompt zones (OSC 133)
+  let semanticZones: SemanticZone[] = []
+
+  // Sixel graphics (DCS q)
+  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 state: "ground" | "escape" | "csi" | "osc" | "dcs" | "apc" = "ground"
-  let paramStr = ""
-  let oscStr = ""
-  let intermediates = ""
-  let wrapPending = false
+  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()
 
-  // TODO: implement full parser and operations
-  // This is the skeleton — the full implementation will cover all 111 terminfo.dev features
+  // ── Grid helpers ──
 
-  function createGrid(w: number, h: number): ScreenCell[][] {
+  function makeGrid(c: number, r: number): ScreenCell[][] {
     const g: ScreenCell[][] = []
-    for (let i = 0; i < h; i++) {
-      g.push(createRow(w))
+    for (let row = 0; row < r; row++) {
+      g.push(makeRow(c))
     }
     return g
   }
 
-  function createRow(w: number): ScreenCell[] {
+  function makeRow(c: number): ScreenCell[] {
     const row: ScreenCell[] = []
-    for (let i = 0; i < w; i++) {
-      row.push(emptyCell())
+    for (let col = 0; col < c; col++) {
+      row.push(EMPTY_CELL)
     }
     return row
   }
 
-  function process(data: Uint8Array): void {
-    for (let i = 0; i < data.length; i++) {
-      const byte = data[i]!
-      processByte(byte, data, i)
+  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 processByte(_byte: number, _data: Uint8Array, _index: number): void {
-    // TODO: Full state machine parser
-    // Will handle: C0 controls, ESC sequences, CSI sequences, OSC, DCS, APC
+  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
   }
 
-  function resize(newCols: number, newRows: number): void {
-    // TODO: resize with reflow
-    cols = newCols
-    rows = newRows
-    grid = createGrid(cols, rows)
+  // ── 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
+        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") {
+            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 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
+    }
+
+    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 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 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++) {
+      r[col] = emptyCell()
+    }
+  }
+
+  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 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
+      }
+    }
+  }
+
+  // ── 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
+    }
+
+    // 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
   }
 
-  function reset(): void {
-    grid = createGrid(cols, rows)
-    altGrid = createGrid(cols, rows)
+  // ── Full reset ──
+
+  function fullReset(): void {
+    mainGrid = makeGrid(cols, rows)
+    altGrid = makeGrid(cols, rows)
+    grid = mainGrid
     scrollback = []
-    cursorX = 0
-    cursorY = 0
-    cursorVisible = true
+    curX = 0
+    curY = 0
+    curVisible = true
     cursorShape = "block"
     cursorBlinking = true
-    attrs = emptyCell()
-    altScreen = false
-    autoWrap = true
-    originMode = false
-    insertMode = false
+    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
-    title = ""
     viewportOffset = 0
-    state = "ground"
-    paramStr = ""
-    oscStr = ""
-    intermediates = ""
-    wrapPending = false
-  }
-
-  // Suppress unused variable warnings — these are used by the TODO implementation
-  void [
-    altGrid, scrollback, savedCursor, altScreen, originMode, insertMode,
-    bracketedPaste, applicationCursor, applicationKeypad, mouseTracking,
-    focusTracking, reverseVideo, syncOutput, scrollTop, scrollBottom,
-    viewportOffset, state, paramStr, oscStr, intermediates, wrapPending,
-    onResponse, scrollbackLimit,
-  ]
+    charsetG0 = false
+    clipboard = ""
+    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 === "_") {
+            // 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 {
+              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 "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 },
+    get cols() {
+      return cols
+    },
+    get rows() {
+      return rows
+    },
     process,
     resize,
-    reset,
-    getCell: (row, col) => grid[row]?.[col] ?? EMPTY_CELL,
-    getLine: (row) => grid[row] ?? [],
-    getText: () => grid.map(row => row.map(c => c.char || " ").join("").trimEnd()).join("\n"),
-    getTextRange: (_sr, _sc, _er, _ec) => "", // TODO
-    getCursorPosition: () => ({ x: cursorX, y: cursorY }),
-    getCursorVisible: () => cursorVisible,
+    reset: fullReset,
+    getCell,
+    getLine,
+    getText,
+    getTextRange,
+    getCursorPosition: () => ({ x: curX, y: curY }),
+    getCursorVisible: () => curVisible,
     getCursorShape: () => cursorShape,
     getCursorBlinking: () => cursorBlinking,
     getTitle: () => title,
-    getMode: (mode) => {
-      switch (mode) {
-        case "altScreen": return altScreen
-        case "autoWrap": return autoWrap
-        case "originMode": return originMode
-        case "insertMode": return insertMode
-        case "bracketedPaste": return bracketedPaste
-        case "applicationCursor": return applicationCursor
-        case "applicationKeypad": return applicationKeypad
-        case "mouseTracking": return mouseTracking
-        case "focusTracking": return focusTracking
-        case "reverseVideo": return reverseVideo
-        case "syncOutput": return syncOutput
-        case "cursorVisible": return cursorVisible
-        default: return false
-      }
-    },
+    getMode,
     getScrollbackLength: () => scrollback.length,
     getViewportOffset: () => viewportOffset,
-    scrollViewport: (delta) => {
+    scrollViewport: (delta: number) => {
       viewportOffset = Math.max(0, Math.min(scrollback.length, viewportOffset + delta))
     },
+    getSemanticZones: () => semanticZones.map((z) => ({ ...z })),
+    getSixelImages: () => sixelImages.map((img) => ({ ...img })),
   }
 }