@fairyhunter13/opentui-core 0.1.114 → 0.1.116

package/src/lib/stdin-parser.test.ts

@@ -1,2290 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Buffer } from "node:buffer"
-import { ManualClock } from "../testing/manual-clock.js"
-import type { Clock, TimerHandle } from "./clock.js"
-import type { ScrollInfo } from "./parse.mouse"
-import { StdinParser, type StdinEvent, type StdinParserOptions } from "./stdin-parser.js"
-
-type KeySnap = {
-  type: "key"
-  raw: string
-  name: string
-  ctrl: boolean
-  meta: boolean
-  shift: boolean
-  eventType: string
-}
-type MouseSnap = { type: "mouse"; raw: string; encoding: "sgr" | "x10"; event: Record<string, unknown> }
-type PasteSnap = { type: "paste"; bytes: Uint8Array }
-type RespSnap = { type: "response"; protocol: string; sequence: string }
-type Snap = KeySnap | MouseSnap | PasteSnap | RespSnap
-
-const K_DEFAULTS = { ctrl: false, meta: false, shift: false, eventType: "press" }
-const TEST_TIMEOUT_MS = 10
-type KOpts = { raw?: string; ctrl?: boolean; meta?: boolean; shift?: boolean; eventType?: string }
-
-function k(name: string, opts: KOpts = {}): KeySnap {
-  return { type: "key", raw: opts.raw ?? name, name, ...K_DEFAULTS, ...opts }
-}
-
-function resp(protocol: string, sequence: string): RespSnap {
-  return { type: "response", protocol, sequence }
-}
-
-function paste(text: string): PasteSnap {
-  return { type: "paste", bytes: Uint8Array.from(Buffer.from(text)) }
-}
-
-const NO_MODS = { shift: false, alt: false, ctrl: false }
-
-function sgr(
-  raw: string,
-  evType: string,
-  x: number,
-  y: number,
-  opts: { button?: number; mods?: Partial<typeof NO_MODS>; scroll?: ScrollInfo } = {},
-): MouseSnap {
-  const event: Record<string, unknown> = {
-    type: evType,
-    button: opts.button ?? 0,
-    x,
-    y,
-    modifiers: { ...NO_MODS, ...opts.mods },
-  }
-  if (opts.scroll) event.scroll = opts.scroll
-  return { type: "mouse", raw, encoding: "sgr", event }
-}
-
-function x10m(
-  raw: string,
-  evType: string,
-  x: number,
-  y: number,
-  opts: { button?: number; mods?: Partial<typeof NO_MODS>; scroll?: ScrollInfo } = {},
-): MouseSnap {
-  const event: Record<string, unknown> = {
-    type: evType,
-    button: opts.button ?? 0,
-    x,
-    y,
-    modifiers: { ...NO_MODS, ...opts.mods },
-  }
-  if (opts.scroll) event.scroll = opts.scroll
-  return { type: "mouse", raw, encoding: "x10", event }
-}
-
-function createParser(options: StdinParserOptions = {}): StdinParser {
-  return new StdinParser({ armTimeouts: false, clock: new ManualClock(), ...options })
-}
-
-function createTimedParser(options: StdinParserOptions = {}): { parser: StdinParser; clock: ManualClock } {
-  const clock = new ManualClock()
-  return { parser: new StdinParser({ armTimeouts: true, clock, timeoutMs: TEST_TIMEOUT_MS, ...options }), clock }
-}
-
-function snapshotEvent(event: StdinEvent): Snap {
-  switch (event.type) {
-    case "key":
-      return {
-        type: "key",
-        raw: event.raw,
-        name: event.key.name,
-        ctrl: event.key.ctrl,
-        meta: event.key.meta,
-        shift: event.key.shift,
-        eventType: event.key.eventType,
-      }
-    case "mouse": {
-      const ev: Record<string, unknown> = { ...event.event }
-      if (!ev.scroll) delete ev.scroll
-      return { type: "mouse", raw: event.raw, encoding: event.encoding, event: ev }
-    }
-    case "paste":
-      return { type: "paste", bytes: event.bytes }
-    case "response":
-      return { type: "response", protocol: event.protocol, sequence: event.sequence }
-  }
-}
-
-function snap(parser: StdinParser): Snap[] {
-  const events: StdinEvent[] = []
-  parser.drain((e) => events.push(e))
-  return events.map(snapshotEvent)
-}
-
-type ChunkInput = string | number[] | Uint8Array
-
-function buf(input: ChunkInput): Uint8Array {
-  if (typeof input === "string") return Buffer.from(input)
-  return input instanceof Uint8Array ? input : Uint8Array.from(input)
-}
-
-function latin1(input: number[] | Uint8Array): string {
-  return Buffer.from(buf(input)).toString("latin1")
-}
-
-function snapChunks(chunks: ChunkInput[], opts?: StdinParserOptions): Snap[] {
-  const p = createParser(opts)
-  try {
-    for (const chunk of chunks) p.push(buf(chunk))
-    return snap(p)
-  } finally {
-    p.destroy()
-  }
-}
-
-function concatChunks(chunks: ChunkInput[]): Uint8Array {
-  return Buffer.concat(chunks.map((chunk) => Buffer.from(buf(chunk))))
-}
-
-function x10bytes(rawButton: number, x: number, y: number): number[] {
-  return [0x1b, 0x5b, 0x4d, rawButton + 32, x + 33, y + 33]
-}
-
-type Case = [label: string, input: ChunkInput, expected: Snap[]]
-
-function table(cases: Case[], opts?: StdinParserOptions) {
-  for (const [label, input, expected] of cases) {
-    test(label, () => {
-      const p = createParser(opts)
-      try {
-        p.push(buf(input))
-        expect(snap(p)).toEqual(expected)
-      } finally {
-        p.destroy()
-      }
-    })
-  }
-}
-
-/** push each byte individually, assert same result as whole-chunk push */
-function assertChunkInvariant(input: Uint8Array, opts?: StdinParserOptions) {
-  const whole = createParser(opts)
-  const split = createParser(opts)
-  try {
-    whole.push(input)
-    const expected = snap(whole)
-    for (let i = 0; i < input.length; i++) split.push(input.subarray(i, i + 1))
-    expect(snap(split)).toEqual(expected)
-  } finally {
-    whole.destroy()
-    split.destroy()
-  }
-}
-
-describe("StdinParser", () => {
-  describe("printable ASCII", () => {
-    test("lowercase a-z", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("abcdefghijklmnopqrstuvwxyz"))
-        expect(snap(p)).toEqual("abcdefghijklmnopqrstuvwxyz".split("").map((c) => k(c)))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("uppercase A-Z produce shifted keys", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
-        expect(snap(p)).toEqual(
-          "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((c) => k(c.toLowerCase(), { raw: c, shift: true })),
-        )
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("digits 0-9", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("0123456789"))
-        expect(snap(p)).toEqual("0123456789".split("").map((c) => k(c)))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("common symbols", () => {
-      const p = createParser()
-      try {
-        const syms = "!@#$%^&*()-_=+[]{}|;':,./<>?`~"
-        p.push(Buffer.from(syms))
-        expect(snap(p)).toEqual(syms.split("").map((c) => k(c)))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("space produces key named space", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from(" "))
-        expect(snap(p)).toEqual([k("space", { raw: " " })])
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("control characters", () => {
-    // Map of special control bytes that get their own key name instead of ctrl+letter
-    const special: Record<number, [string, KOpts]> = {
-      0x00: ["space", { ctrl: true }],
-      0x08: ["backspace", {}],
-      0x09: ["tab", {}],
-      0x0a: ["linefeed", {}],
-      0x0d: ["return", {}],
-    }
-
-    const cases: Case[] = []
-    for (let byte = 0; byte <= 0x1a; byte++) {
-      if (byte === 0x1b) continue // ESC tested separately
-      const raw = String.fromCharCode(byte)
-      const sp = special[byte]
-      if (sp) {
-        cases.push([`0x${byte.toString(16).padStart(2, "0")} → ${sp[0]}`, [byte], [k(sp[0], { raw, ...sp[1] })]])
-      } else {
-        const letter = String.fromCharCode(byte + 96)
-        cases.push([
-          `ctrl+${letter} (0x${byte.toString(16).padStart(2, "0")})`,
-          [byte],
-          [k(letter, { raw, ctrl: true })],
-        ])
-      }
-    }
-    cases.push(["0x7f → backspace", [0x7f], [k("backspace", { raw: "\x7f" })]])
-
-    table(cases)
-  })
-
-  describe("special keys", () => {
-    table([
-      ["return", "\r", [k("return", { raw: "\r" })]],
-      ["linefeed", "\n", [k("linefeed", { raw: "\n" })]],
-      ["tab", "\t", [k("tab", { raw: "\t" })]],
-      ["backspace (0x08)", "\b", [k("backspace", { raw: "\b" })]],
-      ["backspace (0x7f)", "\x7f", [k("backspace", { raw: "\x7f" })]],
-      ["escape (lone, no timeout)", "\x1b", []], // stays pending without timeout
-      ["shift-tab", "\x1b[Z", [k("tab", { raw: "\x1b[Z", shift: true })]],
-      ["ctrl+space", "\x00", [k("space", { raw: "\x00", ctrl: true })]],
-    ])
-
-    test("lone ESC with timeout produces escape key", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("arrows and navigation", () => {
-    table([
-      // CSI arrows
-      ["up", "\x1b[A", [k("up", { raw: "\x1b[A" })]],
-      ["down", "\x1b[B", [k("down", { raw: "\x1b[B" })]],
-      ["right", "\x1b[C", [k("right", { raw: "\x1b[C" })]],
-      ["left", "\x1b[D", [k("left", { raw: "\x1b[D" })]],
-      ["home", "\x1b[H", [k("home", { raw: "\x1b[H" })]],
-      ["end", "\x1b[F", [k("end", { raw: "\x1b[F" })]],
-      ["clear", "\x1b[E", [k("clear", { raw: "\x1b[E" })]],
-      // tilde navigation
-      ["home ~", "\x1b[1~", [k("home", { raw: "\x1b[1~" })]],
-      ["insert ~", "\x1b[2~", [k("insert", { raw: "\x1b[2~" })]],
-      ["delete ~", "\x1b[3~", [k("delete", { raw: "\x1b[3~" })]],
-      ["end ~", "\x1b[4~", [k("end", { raw: "\x1b[4~" })]],
-      ["pgup ~", "\x1b[5~", [k("pageup", { raw: "\x1b[5~" })]],
-      ["pgdn ~", "\x1b[6~", [k("pagedown", { raw: "\x1b[6~" })]],
-      // rxvt
-      ["home rxvt", "\x1b[7~", [k("home", { raw: "\x1b[7~" })]],
-      ["end rxvt", "\x1b[8~", [k("end", { raw: "\x1b[8~" })]],
-    ])
-  })
-
-  describe("function keys", () => {
-    // ESC [ n ~ form
-    const tildeF: [string, string][] = [
-      ["f1", "11"],
-      ["f2", "12"],
-      ["f3", "13"],
-      ["f4", "14"],
-      ["f5", "15"],
-      ["f6", "17"],
-      ["f7", "18"],
-      ["f8", "19"],
-      ["f9", "20"],
-      ["f10", "21"],
-      ["f11", "23"],
-      ["f12", "24"],
-    ]
-    table(tildeF.map(([name, num]) => [`${name} (CSI ${num}~)`, `\x1b[${num}~`, [k(name, { raw: `\x1b[${num}~` })]]))
-
-    // ESC O letter (SS3) form — F1-F4
-    table([
-      ["f1 (SS3)", "\x1bOP", [k("f1", { raw: "\x1bOP" })]],
-      ["f2 (SS3)", "\x1bOQ", [k("f2", { raw: "\x1bOQ" })]],
-      ["f3 (SS3)", "\x1bOR", [k("f3", { raw: "\x1bOR" })]],
-      ["f4 (SS3)", "\x1bOS", [k("f4", { raw: "\x1bOS" })]],
-    ])
-  })
-
-  describe("double-bracket CSI variants", () => {
-    table([
-      ["f1 ([[A)", "\x1b[[A", [k("f1", { raw: "\x1b[[A" })]],
-      ["f2 ([[B)", "\x1b[[B", [k("f2", { raw: "\x1b[[B" })]],
-      ["f3 ([[C)", "\x1b[[C", [k("f3", { raw: "\x1b[[C" })]],
-      ["f4 ([[D)", "\x1b[[D", [k("f4", { raw: "\x1b[[D" })]],
-      ["f5 ([[E)", "\x1b[[E", [k("f5", { raw: "\x1b[[E" })]],
-      ["pageup ([[5~)", "\x1b[[5~", [k("pageup", { raw: "\x1b[[5~" })]],
-      ["pagedown ([[6~)", "\x1b[[6~", [k("pagedown", { raw: "\x1b[[6~" })]],
-    ])
-  })
-
-  describe("SS3 sequences", () => {
-    table([
-      ["up", "\x1bOA", [k("up", { raw: "\x1bOA" })]],
-      ["down", "\x1bOB", [k("down", { raw: "\x1bOB" })]],
-      ["right", "\x1bOC", [k("right", { raw: "\x1bOC" })]],
-      ["left", "\x1bOD", [k("left", { raw: "\x1bOD" })]],
-      ["home", "\x1bOH", [k("home", { raw: "\x1bOH" })]],
-      ["end", "\x1bOF", [k("end", { raw: "\x1bOF" })]],
-      ["clear", "\x1bOE", [k("clear", { raw: "\x1bOE" })]],
-    ])
-
-    test("SS3 interrupted by embedded ESC flushes partial then restarts", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1bO\x1bOA"))
-        const s = snap(p)
-        expect(s).toHaveLength(2)
-        expect(s[0]).toEqual(resp("unknown", "\x1bO"))
-        expect(s[1]).toEqual(k("up", { raw: "\x1bOA" }))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("SS3 timeout-flushed as unknown response", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1bO"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1bO")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("SS3 timeout flush does not swallow later text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1bO"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1bO")])
-
-        parser.push(Buffer.from("a"))
-        expect(snap(parser)).toEqual([k("a")])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("modifier combinations", () => {
-    // CSI 1;modifier letter format
-    const modTable: [string, number, KOpts][] = [
-      ["shift", 2, { shift: true }],
-      ["alt", 3, { meta: true }],
-      ["shift+alt", 4, { shift: true, meta: true }],
-      ["ctrl", 5, { ctrl: true }],
-      ["shift+ctrl", 6, { shift: true, ctrl: true }],
-      ["alt+ctrl", 7, { meta: true, ctrl: true }],
-    ]
-
-    const arrows: [string, string][] = [
-      ["up", "A"],
-      ["down", "B"],
-      ["right", "C"],
-      ["left", "D"],
-    ]
-
-    const cases: Case[] = []
-    for (const [modName, modNum, modOpts] of modTable) {
-      for (const [keyName, letter] of arrows) {
-        const seq = `\x1b[1;${modNum}${letter}`
-        cases.push([`${modName}+${keyName}`, seq, [k(keyName, { raw: seq, ...modOpts })]])
-      }
-    }
-    table(cases)
-
-    // rxvt shift variants
-    table([
-      ["shift+up (rxvt)", "\x1b[a", [k("up", { raw: "\x1b[a", shift: true })]],
-      ["shift+down (rxvt)", "\x1b[b", [k("down", { raw: "\x1b[b", shift: true })]],
-      ["shift+right (rxvt)", "\x1b[c", [k("right", { raw: "\x1b[c", shift: true })]],
-      ["shift+left (rxvt)", "\x1b[d", [k("left", { raw: "\x1b[d", shift: true })]],
-    ])
-
-    // rxvt ctrl variants
-    table([
-      ["ctrl+up (rxvt)", "\x1bOa", [k("up", { raw: "\x1bOa", ctrl: true })]],
-      ["ctrl+down (rxvt)", "\x1bOb", [k("down", { raw: "\x1bOb", ctrl: true })]],
-      ["ctrl+right (rxvt)", "\x1bOc", [k("right", { raw: "\x1bOc", ctrl: true })]],
-      ["ctrl+left (rxvt)", "\x1bOd", [k("left", { raw: "\x1bOd", ctrl: true })]],
-    ])
-
-    // rxvt $ (shift) and ^ (ctrl) on tilde keys
-    table([
-      ["shift+insert (rxvt $)", "\x1b[2$", [k("insert", { raw: "\x1b[2$", shift: true })]],
-      ["shift+delete (rxvt $)", "\x1b[3$", [k("delete", { raw: "\x1b[3$", shift: true })]],
-      ["shift+pgup (rxvt $)", "\x1b[5$", [k("pageup", { raw: "\x1b[5$", shift: true })]],
-      ["shift+pgdn (rxvt $)", "\x1b[6$", [k("pagedown", { raw: "\x1b[6$", shift: true })]],
-      ["ctrl+insert (rxvt ^)", "\x1b[2^", [k("insert", { raw: "\x1b[2^", ctrl: true })]],
-      ["ctrl+delete (rxvt ^)", "\x1b[3^", [k("delete", { raw: "\x1b[3^", ctrl: true })]],
-      ["ctrl+pgup (rxvt ^)", "\x1b[5^", [k("pageup", { raw: "\x1b[5^", ctrl: true })]],
-      ["ctrl+pgdn (rxvt ^)", "\x1b[6^", [k("pagedown", { raw: "\x1b[6^", ctrl: true })]],
-    ])
-  })
-
-  describe("meta key combinations", () => {
-    test("meta+lowercase letters", () => {
-      const p = createParser()
-      try {
-        // Push all ESC+letter pairs at once — each should produce meta+key
-        for (const ch of "acdeghijklmoqrstuvwxyz".split("")) {
-          p.push(Buffer.from(`\x1b${ch}`))
-        }
-        const s = snap(p)
-        for (let i = 0; i < s.length; i++) {
-          const ch = "acdeghijklmoqrstuvwxyz"[i]!
-          expect(s[i]).toEqual(k(ch, { raw: `\x1b${ch}`, meta: true }))
-        }
-      } finally {
-        p.destroy()
-      }
-    })
-
-    // Lowercase ESC+b / ESC+f stay literal meta chords, while uppercase ESC+B / ESC+F
-    // preserve the old-style meta+arrow behavior from `main`.
-    table([
-      ["meta+b (literal chord)", "\x1bb", [k("b", { raw: "\x1bb", meta: true })]],
-      ["meta+f (literal chord)", "\x1bf", [k("f", { raw: "\x1bf", meta: true })]],
-      ["meta+B (old-style left)", "\x1bB", [k("left", { raw: "\x1bB", meta: true })]],
-      ["meta+F (old-style right)", "\x1bF", [k("right", { raw: "\x1bF", meta: true })]],
-      ["meta+n (plain letter)", "\x1bn", [k("n", { raw: "\x1bn", meta: true })]],
-      ["meta+p (plain letter)", "\x1bp", [k("p", { raw: "\x1bp", meta: true })]],
-    ])
-
-    table([
-      ["meta+return", "\x1b\r", [k("return", { raw: "\x1b\r", meta: true })]],
-      ["meta+linefeed", "\x1b\n", [k("linefeed", { raw: "\x1b\n", meta: true })]],
-      ["meta+backspace", "\x1b\x7f", [k("backspace", { raw: "\x1b\x7f", meta: true })]],
-      ["meta+backspace (0x08)", "\x1b\b", [k("backspace", { raw: "\x1b\b", meta: true })]],
-      ["meta+space", "\x1b ", [k("space", { raw: "\x1b ", meta: true })]],
-    ])
-
-    test("meta+escape (requires timeout for \\x1b\\x1b)", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b\x1b"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b\x1b", meta: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    table([["double-ESC + [A → meta+up", "\x1b\x1b[A", [k("up", { raw: "\x1b\x1b[A", meta: true })]]])
-
-    test("meta+uppercase sets shift", () => {
-      const p = createParser()
-      try {
-        // ESC + uppercase letter → meta + shift + name (uppercase preserved in parseKeypress)
-        // Excluding B and F which map to arrow keys
-        p.push(Buffer.from("\x1bA"))
-        const s = snap(p)
-        expect(s).toEqual([k("A", { raw: "\x1bA", meta: true, shift: true })])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("meta+ctrl+letter", () => {
-      const p = createParser()
-      try {
-        // ESC + ctrl char (e.g. ESC + 0x01 = meta+ctrl+a)
-        p.push(Uint8Array.from([0x1b, 0x01]))
-        expect(snap(p)).toEqual([k("a", { raw: "\x1b\x01", meta: true, ctrl: true })])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("meta+digit", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b5"))
-        expect(snap(p)).toEqual([k("5", { raw: "\x1b5", meta: true })])
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("kitty keyboard protocol", () => {
-    // CSI codepoint u format
-    table([
-      ["a key", "\x1b[97u", [k("a", { raw: "\x1b[97u" })]],
-      ["shift+a", "\x1b[97;2u", [k("a", { raw: "\x1b[97;2u", shift: true })]],
-      ["ctrl+a", "\x1b[97;5u", [k("a", { raw: "\x1b[97;5u", ctrl: true })]],
-      ["alt+a", "\x1b[97;3u", [k("a", { raw: "\x1b[97;3u", meta: true })]],
-      ["ctrl+shift+a", "\x1b[97;6u", [k("a", { raw: "\x1b[97;6u", ctrl: true, shift: true })]],
-      ["a release", "\x1b[97;1:3u", [k("a", { raw: "\x1b[97;1:3u", eventType: "release" })]],
-      ["escape", "\x1b[27u", [k("escape", { raw: "\x1b[27u" })]],
-      ["return", "\x1b[13u", [k("return", { raw: "\x1b[13u" })]],
-      ["tab", "\x1b[9u", [k("tab", { raw: "\x1b[9u" })]],
-      ["backspace", "\x1b[127u", [k("backspace", { raw: "\x1b[127u" })]],
-      ["delete", "\x1b[57349u", [k("delete", { raw: "\x1b[57349u" })]],
-      ["insert", "\x1b[57348u", [k("insert", { raw: "\x1b[57348u" })]],
-      ["f1", "\x1b[57364u", [k("f1", { raw: "\x1b[57364u" })]],
-      ["f12", "\x1b[57375u", [k("f12", { raw: "\x1b[57375u" })]],
-    ])
-
-    // CSI 1;modifier:event letter format (kitty functional keys)
-    table([
-      ["up press", "\x1b[1;1:1A", [k("up", { raw: "\x1b[1;1:1A" })]],
-      ["up release", "\x1b[1;1:3A", [k("up", { raw: "\x1b[1;1:3A", eventType: "release" })]],
-      ["ctrl+right", "\x1b[1;5:1C", [k("right", { raw: "\x1b[1;5:1C", ctrl: true })]],
-      ["shift+left", "\x1b[1;2:1D", [k("left", { raw: "\x1b[1;2:1D", shift: true })]],
-      ["home", "\x1b[1;1:1H", [k("home", { raw: "\x1b[1;1:1H" })]],
-      ["end release", "\x1b[1;1:3F", [k("end", { raw: "\x1b[1;1:3F", eventType: "release" })]],
-      ["f1 press", "\x1b[1;1:1P", [k("f1", { raw: "\x1b[1;1:1P" })]],
-    ])
-
-    // CSI number;modifier:event ~ format (kitty tilde keys)
-    table([
-      ["pageup press", "\x1b[5;1:1~", [k("pageup", { raw: "\x1b[5;1:1~" })]],
-      ["ctrl+delete", "\x1b[3;5:1~", [k("delete", { raw: "\x1b[3;5:1~", ctrl: true })]],
-      ["insert release", "\x1b[2;1:3~", [k("insert", { raw: "\x1b[2;1:3~", eventType: "release" })]],
-    ])
-  })
-
-  describe("modifyOtherKeys", () => {
-    table([
-      ["shift+return", "\x1b[27;2;13~", [k("return", { raw: "\x1b[27;2;13~", shift: true })]],
-      ["ctrl+return", "\x1b[27;5;13~", [k("return", { raw: "\x1b[27;5;13~", ctrl: true })]],
-      ["ctrl+escape", "\x1b[27;5;27~", [k("escape", { raw: "\x1b[27;5;27~", ctrl: true })]],
-      ["alt+tab", "\x1b[27;3;9~", [k("tab", { raw: "\x1b[27;3;9~", meta: true })]],
-      ["shift+space", "\x1b[27;2;32~", [k("space", { raw: "\x1b[27;2;32~", shift: true })]],
-      ["ctrl+backspace", "\x1b[27;5;127~", [k("backspace", { raw: "\x1b[27;5;127~", ctrl: true })]],
-      ["shift+digit 5", "\x1b[27;2;53~", [k("5", { raw: "\x1b[27;2;53~", shift: true })]],
-    ])
-  })
-
-  describe("mouse: SGR protocol", () => {
-    table([
-      // Button press/release
-      ["left down", "\x1b[<0;1;1M", [sgr("\x1b[<0;1;1M", "down", 0, 0)]],
-      ["left up", "\x1b[<0;1;1m", [sgr("\x1b[<0;1;1m", "up", 0, 0)]],
-      ["middle down", "\x1b[<1;1;1M", [sgr("\x1b[<1;1;1M", "down", 0, 0, { button: 1 })]],
-      ["middle up", "\x1b[<1;1;1m", [sgr("\x1b[<1;1;1m", "up", 0, 0, { button: 1 })]],
-      ["right down", "\x1b[<2;1;1M", [sgr("\x1b[<2;1;1M", "down", 0, 0, { button: 2 })]],
-      ["right up", "\x1b[<2;1;1m", [sgr("\x1b[<2;1;1m", "up", 0, 0, { button: 2 })]],
-      // Scroll
-      [
-        "scroll up",
-        "\x1b[<64;10;5M",
-        [sgr("\x1b[<64;10;5M", "scroll", 9, 4, { scroll: { direction: "up", delta: 1 } })],
-      ],
-      [
-        "scroll down",
-        "\x1b[<65;10;5M",
-        [sgr("\x1b[<65;10;5M", "scroll", 9, 4, { button: 1, scroll: { direction: "down", delta: 1 } })],
-      ],
-      [
-        "scroll left",
-        "\x1b[<66;10;5M",
-        [sgr("\x1b[<66;10;5M", "scroll", 9, 4, { button: 2, scroll: { direction: "left", delta: 1 } })],
-      ],
-      [
-        "scroll right",
-        "\x1b[<67;10;5M",
-        [sgr("\x1b[<67;10;5M", "scroll", 9, 4, { button: 0, scroll: { direction: "right", delta: 1 } })],
-      ],
-      // Motion (no button)
-      ["move", "\x1b[<35;20;10M", [sgr("\x1b[<35;20;10M", "move", 19, 9)]],
-      // Large coordinates
-      ["large coords", "\x1b[<0;300;200M", [sgr("\x1b[<0;300;200M", "down", 299, 199)]],
-      // Modifiers
-      ["shift+left down", "\x1b[<4;1;1M", [sgr("\x1b[<4;1;1M", "down", 0, 0, { mods: { shift: true } })]],
-      ["alt+left down", "\x1b[<8;1;1M", [sgr("\x1b[<8;1;1M", "down", 0, 0, { mods: { alt: true } })]],
-      ["ctrl+left down", "\x1b[<16;1;1M", [sgr("\x1b[<16;1;1M", "down", 0, 0, { mods: { ctrl: true } })]],
-    ])
-
-    test("drag detection after button down", () => {
-      const p = createParser()
-      try {
-        // Button 0 down, then motion with button 0 flag
-        p.push(Buffer.from("\x1b[<0;5;5M\x1b[<32;6;5M"))
-        const s = snap(p)
-        expect(s).toHaveLength(2)
-        expect(s[0]).toEqual(sgr("\x1b[<0;5;5M", "down", 4, 4))
-        expect(s[1]).toEqual(sgr("\x1b[<32;6;5M", "drag", 5, 4))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("split SGR across two pushes", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[<64;10;"))
-        expect(snap(p)).toEqual([])
-        p.push(Buffer.from("5M"))
-        expect(snap(p)).toEqual([sgr("\x1b[<64;10;5M", "scroll", 9, 4, { scroll: { direction: "up", delta: 1 } })])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("multiple mouse events in one push", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[<0;1;1M\x1b[<0;2;1M\x1b[<0;2;1m"))
-        const s = snap(p)
-        expect(s).toHaveLength(3)
-        expect(s[0]).toEqual(sgr("\x1b[<0;1;1M", "down", 0, 0))
-        expect(s[1]).toEqual(sgr("\x1b[<0;2;1M", "down", 1, 0))
-        expect(s[2]).toEqual(sgr("\x1b[<0;2;1m", "up", 1, 0))
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("mouse: X10 protocol", () => {
-    // X10: ESC [ M <button+32> <x+33> <y+33>
-    const leftDown = x10bytes(0, 0, 0)
-    const middleDown = x10bytes(1, 0, 0)
-    const rightDown = x10bytes(2, 0, 0)
-    const release = x10bytes(3, 0, 0)
-    const at1020 = x10bytes(0, 10, 20)
-    const move = x10bytes(35, 4, 5)
-    const scrollUp = x10bytes(64, 2, 3)
-    const shiftLeftDown = x10bytes(4, 0, 0)
-    const ctrlScrollUp = x10bytes(80, 7, 8)
-
-    table([
-      ["left down (0,0)", leftDown, [x10m(latin1(leftDown), "down", 0, 0)]],
-      ["middle down", middleDown, [x10m(latin1(middleDown), "down", 0, 0, { button: 1 })]],
-      ["right down", rightDown, [x10m(latin1(rightDown), "down", 0, 0, { button: 2 })]],
-      ["release", release, [x10m(latin1(release), "up", 0, 0)]],
-      ["at position 10,20", at1020, [x10m(latin1(at1020), "down", 10, 20)]],
-      ["move with no button", move, [x10m(latin1(move), "move", 4, 5, { button: -1 })]],
-      ["scroll up", scrollUp, [x10m(latin1(scrollUp), "scroll", 2, 3, { scroll: { direction: "up", delta: 1 } })]],
-      ["shift+left down", shiftLeftDown, [x10m(latin1(shiftLeftDown), "down", 0, 0, { mods: { shift: true } })]],
-      [
-        "ctrl+scroll up",
-        ctrlScrollUp,
-        [x10m(latin1(ctrlScrollUp), "scroll", 7, 8, { mods: { ctrl: true }, scroll: { direction: "up", delta: 1 } })],
-      ],
-    ])
-
-    test("X10 mouse followed by key", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[M !!x"))
-        const s = snap(p)
-        expect(s).toHaveLength(2)
-        expect(s[0]).toEqual(x10m("\x1b[M !!", "down", 0, 0))
-        expect(s[1]).toEqual(k("x"))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("split X10 across pushes waits for payload", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[M"))
-        expect(snap(p)).toEqual([])
-        p.push(Buffer.from(" !!"))
-        expect(snap(p)).toEqual([x10m("\x1b[M !!", "down", 0, 0)])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("delayed X10 continuation after timed-out escape stays opaque", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("[M"))
-        expect(snap(parser)).toEqual([])
-        parser.push(Buffer.from(" !!"))
-        expect(snap(parser)).toEqual([resp("unknown", "[M !!")])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("UTF-8 handling", () => {
-    table([
-      ["2-byte (é)", "\u00e9", [k("\u00e9")]],
-      ["3-byte (中)", "\u4e2d", [k("\u4e2d")]],
-      ["4-byte (👍)", "👍", [k("👍")]],
-      ["multiple utf-8 chars", "日本語", [k("日"), k("本"), k("語")]],
-    ])
-
-    test("2-byte split at byte boundary", () => {
-      const bytes = Buffer.from("é")
-      expect(bytes.length).toBe(2)
-      const p = createParser()
-      try {
-        p.push(bytes.subarray(0, 1))
-        expect(snap(p)).toEqual([])
-        p.push(bytes.subarray(1))
-        expect(snap(p)).toEqual([k("é")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("3-byte split at every boundary", () => {
-      const bytes = Buffer.from("中")
-      expect(bytes.length).toBe(3)
-      for (let split = 1; split < bytes.length; split++) {
-        const p = createParser()
-        try {
-          p.push(bytes.subarray(0, split))
-          expect(snap(p)).toEqual([])
-          p.push(bytes.subarray(split))
-          expect(snap(p)).toEqual([k("中")])
-        } finally {
-          p.destroy()
-        }
-      }
-    })
-
-    test("4-byte split at every boundary", () => {
-      const bytes = Buffer.from("👍")
-      expect(bytes.length).toBe(4)
-      for (let split = 1; split < bytes.length; split++) {
-        const p = createParser()
-        try {
-          p.push(bytes.subarray(0, split))
-          expect(snap(p)).toEqual([])
-          p.push(bytes.subarray(split))
-          expect(snap(p)).toEqual([k("👍")])
-        } finally {
-          p.destroy()
-        }
-      }
-    })
-
-    test("invalid UTF-8 lead (0xC0) followed by ASCII falls back to legacy high-byte", () => {
-      const p = createParser()
-      try {
-        p.push(Uint8Array.from([0xc0, 0x41]))
-        const s = snap(p)
-        expect(s).toHaveLength(2)
-        // 0xC0 - 128 = 0x40 = '@', treated as ESC + '@' → legacy path
-        expect(s[0]!.type).toBe("key")
-        expect(s[1]).toEqual(k("a", { raw: "A", shift: true }))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("invalid continuation byte after valid lead falls back to legacy", () => {
-      const p = createParser()
-      try {
-        p.push(Uint8Array.from([0xe9])) // valid 3-byte lead
-        expect(snap(p)).toEqual([]) // waits for continuation
-        p.push(Buffer.from("x")) // not a continuation byte
-        const s = snap(p)
-        expect(s).toEqual([
-          k("i", { raw: "\x1bi", meta: true }), // 0xe9 → legacy: 0xe9-128=0x69='i', ESC prefix
-          k("x"),
-        ])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("legacy single high-byte on timeout", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Uint8Array.from([0xe9]))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("i", { raw: "\x1bi", meta: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("high byte 0xFF on timeout → meta+backspace", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Uint8Array.from([0xff]))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        // 0xFF - 128 = 0x7F = DEL, so ESC + DEL = meta+backspace
-        expect(snap(parser)).toEqual([k("backspace", { raw: "\x1b\x7f", meta: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("protocol responses", () => {
-    table([
-      // OSC (BEL-terminated)
-      ["OSC (BEL)", "\x1b]4;0;#ffffff\x07", [resp("osc", "\x1b]4;0;#ffffff\x07")]],
-      // OSC (ESC \\ terminated)
-      ["OSC (ST)", "\x1b]4;0;rgb:ff/ff/ff\x1b\\", [resp("osc", "\x1b]4;0;rgb:ff/ff/ff\x1b\\")]],
-      // DCS
-      ["DCS", "\x1bP>|kitty(0.40.1)\x1b\\", [resp("dcs", "\x1bP>|kitty(0.40.1)\x1b\\")]],
-      // APC
-      ["APC", "\x1b_Gi=1;OK\x1b\\", [resp("apc", "\x1b_Gi=1;OK\x1b\\")]],
-      // Focus
-      ["focus in", "\x1b[I", [resp("csi", "\x1b[I")]],
-      ["focus out", "\x1b[O", [resp("csi", "\x1b[O")]],
-      // DA (Device Attributes)
-      ["DA1", "\x1b[?62;1;2;6;7;8;9;15;22c", [resp("csi", "\x1b[?62;1;2;6;7;8;9;15;22c")]],
-      // CPR (Cursor Position Report)
-      ["CPR", "\x1b[24;80R", [resp("csi", "\x1b[24;80R")]],
-      // Window/cell size
-      ["window size", "\x1b[4;600;800t", [resp("csi", "\x1b[4;600;800t")]],
-      // Mode report
-      ["mode report", "\x1b[?2004;1$y", [resp("csi", "\x1b[?2004;1$y")]],
-    ])
-
-    test("all three protocol responses in one push", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b]4;0;#fff\x07\x1bP>|test\x1b\\\x1b_OK\x1b\\"))
-        expect(snap(p)).toEqual([
-          resp("osc", "\x1b]4;0;#fff\x07"),
-          resp("dcs", "\x1bP>|test\x1b\\"),
-          resp("apc", "\x1b_OK\x1b\\"),
-        ])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("split OSC across pushes", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b]4;0;"))
-        expect(snap(p)).toEqual([])
-        p.push(Buffer.from("#ffffff\x07"))
-        expect(snap(p)).toEqual([resp("osc", "\x1b]4;0;#ffffff\x07")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("split DCS terminator ESC \\ across pushes", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1bPtest\x1b"))
-        expect(snap(p)).toEqual([])
-        p.push(Buffer.from("\\"))
-        expect(snap(p)).toEqual([resp("dcs", "\x1bPtest\x1b\\")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("focus events interleaved with keys", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("a\x1b[Ib\x1b[Oc"))
-        expect(snap(p)).toEqual([k("a"), resp("csi", "\x1b[I"), k("b"), resp("csi", "\x1b[O"), k("c")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("partial OSC flushes on timeout as unknown", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b]incomplete"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b]incomplete")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial DCS flushes on timeout as unknown", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1bPpartial"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1bPpartial")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial APC flushes on timeout as unknown", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b_partial"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b_partial")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial generic CSI flushes on timeout as unknown", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[123"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[123")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial kitty CSI stays pending after timeout", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[118;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial kitty CSI stays pending after timeout when split after first semicolon", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[97;"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("2u"))
-        expect(snap(parser)).toEqual([k("a", { shift: true, raw: "\x1b[97;2u" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial kitty alternate-key CSI stays pending after timeout", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[97:65;"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("6:1u"))
-        expect(snap(parser)).toEqual([k("a", { raw: "\x1b[97:65;6:1u", ctrl: true, shift: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial kitty CSI stays pending after timeout for higher modifier bits", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[97;9"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("u"))
-        const event = parser.read()
-        expect(event?.type).toBe("key")
-        if (!event || event.type !== "key") throw new Error("expected key event")
-        expect(event.raw).toBe("\x1b[97;9u")
-        expect(event.key.name).toBe("a")
-        expect(event.key.super).toBe(true)
-        expect(parser.read()).toBeNull()
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial kitty special-key CSI stays pending after timeout", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[1;1:"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("3A"))
-        expect(snap(parser)).toEqual([k("up", { raw: "\x1b[1;1:3A", eventType: "release" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial SGR mouse CSI stays pending after timeout", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[<35;20"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from(";5m"))
-        expect(snap(parser)).toEqual([sgr("\x1b[<35;20;5m", "move", 19, 4)])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("split CSI across reads reassembles after timeout", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        // Kitty Ctrl+V release split across two reads
-        parser.push(Buffer.from("\x1b[118;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        // Stays pending — not flushed
-        expect(snap(parser)).toEqual([])
-        parser.push(Buffer.from(";3u"))
-        expect(snap(parser)).toEqual([k("v", { ctrl: true, raw: "\x1b[118;5;3u" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("split kitty escape CSI across reads reassembles after timeout", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[27;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-        parser.push(Buffer.from("u"))
-        expect(snap(parser)).toEqual([k("escape", { ctrl: true, raw: "\x1b[27;5u" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out standard one-semicolon CSI key flushes before later text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[1;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[1;5")])
-
-        parser.push(Buffer.from("A"))
-        expect(snap(parser)).toEqual([k("a", { raw: "A", shift: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out one-semicolon CSI response flushes before later text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[24;80"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[24;80")])
-
-        parser.push(Buffer.from("R"))
-        expect(snap(parser)).toEqual([k("r", { raw: "R", shift: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out partial kitty CSI resyncs on a later ESC", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[118;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("\x1b[A"))
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[118;5"), k("up", { raw: "\x1b[A" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out partial kitty CSI flushes before unrelated later text", () => {
-      const { parser, clock } = createTimedParser({ protocolContext: { kittyKeyboardEnabled: true } })
-      try {
-        parser.push(Buffer.from("\x1b[118;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("a"))
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[118;5"), k("a")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial generic CSI timeout flush does not swallow later text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[123"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[123")])
-
-        parser.push(Buffer.from("a"))
-        expect(snap(parser)).toEqual([k("a")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial large-parameter CSI flushes on timeout before later text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[80;120"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[80;120")])
-
-        parser.push(Buffer.from("a"))
-        expect(snap(parser)).toEqual([k("a")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial OSC timeout flush does not swallow later text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b]52;c;"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b]52;c;")])
-
-        parser.push(Buffer.from("abc"))
-        expect(snap(parser)).toEqual([k("a"), k("b"), k("c")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial OSC timeout flush does not swallow later escape sequences", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b]52;c;"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b]52;c;")])
-
-        parser.push(Buffer.from("\x1b[A"))
-        expect(snap(parser)).toEqual([k("up", { raw: "\x1b[A" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("protocol context", () => {
-    test("partial explicit-width CPR stays pending after timeout when probe is active", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { explicitWidthCprActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[1;2"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("R"))
-        expect(snap(parser)).toEqual([resp("csi", "\x1b[1;2R")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial explicit-width CPR flushes before later text when probe is inactive", () => {
-      const { parser, clock } = createTimedParser()
-
-      try {
-        parser.push(Buffer.from("\x1b[1;2"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[1;2")])
-
-        parser.push(Buffer.from("R"))
-        expect(snap(parser)).toEqual([k("r", { raw: "R", shift: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial pixel resolution response stays pending after timeout while query is active", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { pixelResolutionQueryActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[4;1080;192"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("0t"))
-        expect(snap(parser)).toEqual([resp("csi", "\x1b[4;1080;1920t")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial DECRPM stays pending after timeout while capability probe is active", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { privateCapabilityRepliesActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[?1016;2$"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("y"))
-        expect(snap(parser)).toEqual([resp("csi", "\x1b[?1016;2$y")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("partial DA1 stays pending after timeout while capability probe is active", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { privateCapabilityRepliesActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[?62;"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("c"))
-        expect(snap(parser)).toEqual([resp("csi", "\x1b[?62;c")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out modified CSI key still flushes before later final byte", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { explicitWidthCprActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[1;5"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("A"))
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[1;5"), k("a", { raw: "A", shift: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("generic row/col CPR does not reassemble during explicit-width probe window", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { explicitWidthCprActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[24;80"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[24;80")])
-
-        parser.push(Buffer.from("R"))
-        expect(snap(parser)).toEqual([k("r", { raw: "R", shift: true })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("deferred explicit-width CPR flushes when probe context is cleared", () => {
-      const { parser, clock } = createTimedParser({
-        protocolContext: { explicitWidthCprActive: true },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[1;2"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([])
-
-        parser.updateProtocolContext({ explicitWidthCprActive: false })
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[1;2")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out pending explicit-width CPR does not rearm until more bytes arrive", () => {
-      const clock = new ManualClock()
-      let timeoutFlushes = 0
-      let parser!: StdinParser
-      parser = new StdinParser({
-        armTimeouts: true,
-        clock,
-        timeoutMs: TEST_TIMEOUT_MS,
-        protocolContext: { explicitWidthCprActive: true },
-        onTimeoutFlush: () => {
-          timeoutFlushes += 1
-          parser.drain(() => {})
-        },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[1;2"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(1)
-
-        clock.advance(50)
-        expect(timeoutFlushes).toBe(1)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from(";"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(2)
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out pending private reply does not rearm until more bytes arrive", () => {
-      const clock = new ManualClock()
-      let timeoutFlushes = 0
-      let parser!: StdinParser
-      parser = new StdinParser({
-        armTimeouts: true,
-        clock,
-        timeoutMs: TEST_TIMEOUT_MS,
-        protocolContext: { privateCapabilityRepliesActive: true },
-        onTimeoutFlush: () => {
-          timeoutFlushes += 1
-          parser.drain(() => {})
-        },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[?1016;2$"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(1)
-
-        clock.advance(50)
-        expect(timeoutFlushes).toBe(1)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from(";"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(2)
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("bracketed paste", () => {
-    table([
-      ["simple paste", "\x1b[200~hello\x1b[201~", [paste("hello")]],
-      ["empty paste", "\x1b[200~\x1b[201~", [paste("")]],
-      ["paste with newlines", "\x1b[200~line1\nline2\x1b[201~", [paste("line1\nline2")]],
-      ["paste with tabs", "\x1b[200~a\tb\x1b[201~", [paste("a\tb")]],
-      ["paste with ESC in body", "\x1b[200~abc\x1bdef\x1b[201~", [paste("abc\x1bdef")]],
-    ])
-
-    test("split paste start marker across pushes", () => {
-      const start = "\x1b[200~"
-      for (let split = 1; split < start.length; split++) {
-        const p = createParser()
-        try {
-          p.push(Buffer.from(start.slice(0, split)))
-          p.push(Buffer.from(start.slice(split) + "hi\x1b[201~"))
-          expect(snap(p)).toEqual([paste("hi")])
-        } finally {
-          p.destroy()
-        }
-      }
-    })
-
-    test("split paste end marker at every boundary", () => {
-      const end = "\x1b[201~"
-      for (let split = 1; split < end.length; split++) {
-        const p = createParser()
-        try {
-          p.push(Buffer.from("\x1b[200~hello"))
-          p.push(Buffer.from(end.slice(0, split)))
-          expect(snap(p)).toEqual([])
-          p.push(Buffer.from(end.slice(split)))
-          expect(snap(p)).toEqual([paste("hello")])
-        } finally {
-          p.destroy()
-        }
-      }
-    })
-
-    test("paste body bytes do not alias caller buffers across pushes", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~"))
-
-        const chunk = Buffer.from("hello")
-        p.push(chunk)
-        chunk.fill(0x78)
-
-        p.push(Buffer.from("\x1b[201~"))
-        expect(snap(p)).toEqual([paste("hello")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("near-match end markers are part of paste body", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~abc\x1b[202~def\x1b[201~"))
-        expect(snap(p)).toEqual([paste("abc\x1b[202~def")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("doubled ESC before paste end marker", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~abc\x1b"))
-        expect(snap(p)).toEqual([])
-        p.push(Buffer.from("\x1b[201~"))
-        expect(snap(p)).toEqual([paste("abc\x1b")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("large paste does not grow parser buffer", () => {
-      const p = createParser({ maxPendingBytes: 32 })
-      const payload = "x".repeat(100_000)
-      try {
-        p.push(Buffer.from(`\x1b[200~${payload}\x1b[201~z`))
-        expect(snap(p)).toEqual([paste(payload), k("z")])
-        expect(p.bufferCapacity).toBeLessThanOrEqual(512)
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("large paste across many small chunks", () => {
-      const p = createParser({ maxPendingBytes: 32 })
-      try {
-        p.push(Buffer.from("\x1b[200~"))
-        for (let i = 0; i < 1000; i++) p.push(Buffer.from("chunk "))
-        p.push(Buffer.from("\x1b[201~"))
-        const s = snap(p)
-        expect(s).toHaveLength(1)
-        expect(s[0]!.type).toBe("paste")
-        expect((s[0] as PasteSnap).bytes).toHaveLength(6000)
-        expect(p.bufferCapacity).toBeLessThanOrEqual(512)
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("trailing bytes after paste end are parsed normally", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~hello\x1b[201~\x1b[A"))
-        expect(snap(p)).toEqual([paste("hello"), k("up", { raw: "\x1b[A" })])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("back-to-back pastes", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~first\x1b[201~\x1b[200~second\x1b[201~"))
-        expect(snap(p)).toEqual([paste("first"), paste("second")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("paste with UTF-8 content", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~日本語👍\x1b[201~"))
-        expect(snap(p)).toEqual([paste("日本語👍")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("paste with UTF-8 split across chunks", () => {
-      const p = createParser()
-      const emoji = Buffer.from("👍")
-      try {
-        p.push(Buffer.from("\x1b[200~"))
-        p.push(emoji.subarray(0, 2))
-        p.push(emoji.subarray(2))
-        p.push(Buffer.from("\x1b[201~"))
-        expect(snap(p)).toEqual([paste("👍")])
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("ESC-less SGR continuation recovery", () => {
-    test("after timed-out ESC, continuation is not split into text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("[<35;20;5m"))
-        expect(snap(parser)).toEqual([resp("unknown", "[<35;20;5m")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("after timed-out ESC, split continuation across pushes is not split into text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("["))
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from("<35;20;5m"))
-        expect(snap(parser)).toEqual([resp("unknown", "[<35;20;5m")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("after timed-out ESC, partial [< waits, then timeout flushes as one response", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("[<35;20"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "[<35;20")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("after timed-out ESC, [< followed by non-digit aborts immediately", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("[<x"))
-        const s = snap(parser)
-        expect(s).toHaveLength(2)
-        expect(s[0]).toEqual(resp("unknown", "[<"))
-        expect(s[1]).toEqual(k("x"))
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("without prior flushed ESC, [< stays literal text", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("[<35;20;5m"))
-        expect(snap(p)).toEqual("[<35;20;5m".split("").map((char) => k(char)))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("without prior flushed ESC, standalone [ then < stay as individual keys", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("["))
-        expect(snap(p)).toEqual([k("[")])
-        p.push(Buffer.from("<"))
-        expect(snap(p)).toEqual([k("<")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("after timed-out ESC, bare [ waits for more and then flushes as text", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("["))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("[")])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("timeout behavior", () => {
-    test("default timeout at exact boundary (19ms no fire, 20ms fires)", () => {
-      const clock = new ManualClock()
-      const parser = new StdinParser({ armTimeouts: true, clock })
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(19)
-        expect(snap(parser)).toEqual([])
-        clock.advance(1)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("configured timeout at exact boundary (9ms no fire, 10ms fires)", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(9)
-        expect(snap(parser)).toEqual([])
-        clock.advance(1)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("flushTimeout() only flushes when caller reports elapsed timeout", () => {
-      const parser = createParser({ timeoutMs: TEST_TIMEOUT_MS })
-      try {
-        parser.push(Buffer.from("\x1b"))
-
-        parser.flushTimeout(TEST_TIMEOUT_MS - 1)
-        expect(snap(parser)).toEqual([])
-
-        parser.flushTimeout(TEST_TIMEOUT_MS)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timeout resets when more bytes arrive", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[<35;20;"))
-        clock.advance(9) // almost timeout
-        parser.push(Buffer.from("5")) // new byte resets timer
-        expect(snap(parser)).toEqual([])
-        clock.advance(9) // almost timeout again
-        expect(snap(parser)).toEqual([])
-        parser.push(Buffer.from("m")) // complete
-        expect(snap(parser)).toEqual([sgr("\x1b[<35;20;5m", "move", 19, 4)])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out pending kitty CSI does not rearm until more bytes arrive", () => {
-      const clock = new ManualClock()
-      let timeoutFlushes = 0
-      let parser!: StdinParser
-      parser = new StdinParser({
-        armTimeouts: true,
-        clock,
-        timeoutMs: TEST_TIMEOUT_MS,
-        protocolContext: { kittyKeyboardEnabled: true },
-        onTimeoutFlush: () => {
-          timeoutFlushes += 1
-          parser.drain(() => {})
-        },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[118;5"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(1)
-
-        clock.advance(50)
-        expect(timeoutFlushes).toBe(1)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from(";"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(2)
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timed-out pending SGR mouse CSI does not rearm until more bytes arrive", () => {
-      const clock = new ManualClock()
-      let timeoutFlushes = 0
-      let parser!: StdinParser
-      parser = new StdinParser({
-        armTimeouts: true,
-        clock,
-        timeoutMs: TEST_TIMEOUT_MS,
-        onTimeoutFlush: () => {
-          timeoutFlushes += 1
-          parser.drain(() => {})
-        },
-      })
-
-      try {
-        parser.push(Buffer.from("\x1b[<35;20"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(1)
-
-        clock.advance(50)
-        expect(timeoutFlushes).toBe(1)
-        expect(snap(parser)).toEqual([])
-
-        parser.push(Buffer.from(";"))
-        clock.advance(10)
-        expect(timeoutFlushes).toBe(2)
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("timeout does not fire during paste mode", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[200~partial"))
-        clock.advance(100) // way past timeout
-        expect(snap(parser)).toEqual([]) // still collecting paste
-        parser.push(Buffer.from("\x1b[201~"))
-        expect(snap(parser)).toEqual([paste("partial")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("multiple sequential timeouts", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("custom timeout delay", () => {
-      const { parser, clock } = createTimedParser({ timeoutMs: 50 })
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(49)
-        expect(snap(parser)).toEqual([])
-        clock.advance(1)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("data completing sequence before timeout cancels flush", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b"))
-        clock.advance(5) // halfway to timeout
-        parser.push(Buffer.from("[A")) // completes arrow sequence
-        expect(snap(parser)).toEqual([k("up", { raw: "\x1b[A" })])
-        clock.advance(100) // timeout would have fired, but sequence is done
-        expect(snap(parser)).toEqual([])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-
-  describe("embedded ESC abort", () => {
-    test("ESC inside partial CSI flushes as unknown, restarts", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[<35;\x1b[<35;20;5m"))
-        expect(snap(p)).toEqual([resp("unknown", "\x1b[<35;"), sgr("\x1b[<35;20;5m", "move", 19, 4)])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("ESC inside partial CSI with no following data", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[123\x1b"))
-        const s = snap(parser)
-        // first part flushed as unknown response, ESC starts new escape
-        expect(s).toEqual([resp("unknown", "\x1b[123")])
-        // the trailing ESC is pending
-        clock.advance(10)
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("ESC inside OSC restarts parsing", () => {
-      const p = createParser()
-      try {
-        // ESC ] ... ESC ESC [ A — the first ESC after OSC body starts ST check,
-        // but second ESC byte is not \, so sawEsc resets. Then ESC starts escape.
-        // Actually: \x1b]foo has sawEsc=false. Then \x1b sets sawEsc=true.
-        // Then [ is not \, so sawEsc resets to false and [ is consumed as content.
-        // Then \x1b sets sawEsc=true. Then \ (0x5c = \\) terminates OSC.
-        p.push(Buffer.from("\x1b]foo\x1b\\"))
-        expect(snap(p)).toEqual([resp("osc", "\x1b]foo\x1b\\")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("ESC in SS3 flushes partial as unknown", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1bO\x1b[A"))
-        expect(snap(p)).toEqual([resp("unknown", "\x1bO"), k("up", { raw: "\x1b[A" })])
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("chunk-shape invariance", () => {
-    const sequences = [
-      "abc", // multiple ASCII
-      "\x1b[A", // arrow
-      "\x1bOP", // SS3 F1
-      "\x1b[[A", // Cygwin F1
-      "\x1b[[5~", // putty pageup
-      "\x1b[<0;10;20M", // SGR mouse
-      "\x1b[M !!", // X10 mouse
-      "\x1b]4;0;#ffffff\x07", // OSC
-      "\x1bP>|test\x1b\\", // DCS
-      "\x1b_OK\x1b\\", // APC
-      "\x1b[200~hello\x1b[201~", // paste
-      "\x1b[I", // focus in
-      "\x1b[1;5A", // ctrl+up
-      "\x1b[97u", // kitty key
-      "\x1b[27;2;13~", // modifyOtherKeys
-    ]
-
-    for (const seq of sequences) {
-      test(`byte-at-a-time: ${JSON.stringify(seq).slice(1, -1).slice(0, 30)}`, () => {
-        assertChunkInvariant(Buffer.from(seq))
-      })
-    }
-
-    test("mixed stream byte-at-a-time", () => {
-      const stream = Buffer.concat([
-        Buffer.from("x"),
-        Buffer.from("\x1b[<64;10;5M"),
-        Buffer.from("\x1b[I"),
-        Buffer.from("\x1b]4;0;#fff\x07"),
-        Buffer.from("\x1b[200~paste\x1b[201~"),
-        Buffer.from("👍"),
-      ])
-      assertChunkInvariant(stream)
-    })
-
-    test("random two-chunk splits", () => {
-      const stream = Buffer.from("x\x1b[<64;10;5M\x1b[I\x1b]4;0;#fff\x07\x1b[200~p\x1b[201~y")
-      const whole = createParser()
-      try {
-        whole.push(stream)
-        const expected = snap(whole)
-        // Try splitting at every possible position
-        for (let split = 1; split < stream.length - 1; split++) {
-          const p = createParser()
-          try {
-            p.push(stream.subarray(0, split))
-            p.push(stream.subarray(split))
-            expect(snap(p)).toEqual(expected)
-          } finally {
-            p.destroy()
-          }
-        }
-      } finally {
-        whole.destroy()
-      }
-    })
-
-    const comboAtoms: Array<[label: string, input: ChunkInput]> = [
-      ["ascii", "xy"],
-      ["utf8", "👍"],
-      ["arrow", "\x1b[A"],
-      ["sgr", "\x1b[<64;10;5M"],
-      ["x10", x10bytes(0, 0, 0)],
-      ["osc", "\x1b]4;0;#fff\x07"],
-      ["paste", "\x1b[200~p\x1b[201~"],
-      ["kitty", "\x1b[97u"],
-    ]
-
-    for (const [firstLabel, first] of comboAtoms) {
-      for (const [secondLabel, second] of comboAtoms) {
-        test(`${firstLabel} + ${secondLabel} across every two-chunk split`, () => {
-          const stream = concatChunks([first, second])
-          const expected = snapChunks([stream])
-
-          expect(snapChunks([first, second])).toEqual(expected)
-          for (let split = 1; split < stream.length; split++) {
-            expect(snapChunks([stream.subarray(0, split), stream.subarray(split)])).toEqual(expected)
-          }
-        })
-      }
-    }
-  })
-
-  describe("state management", () => {
-    test("reset clears pending bytes and releases capacity", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b["))
-        expect(snap(p)).toEqual([])
-        p.push(Buffer.alloc(4096, 0x78)) // 'x' bytes to grow buffer
-        p.reset()
-        expect(snap(p)).toEqual([])
-        expect(p.bufferCapacity).toBeLessThanOrEqual(256)
-        // parser works normally after reset
-        p.push(Buffer.from("a"))
-        expect(snap(p)).toEqual([k("a")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("reset during paste mode clears paste state", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~partial paste"))
-        expect(snap(p)).toEqual([])
-        p.reset()
-        expect(snap(p)).toEqual([])
-        // parser works normally after reset
-        p.push(Buffer.from("a"))
-        expect(snap(p)).toEqual([k("a")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("reset during escape sequence clears state", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b["))
-        expect(snap(p)).toEqual([])
-        p.reset()
-        // After reset, the partial CSI is gone; new input starts fresh
-        p.push(Buffer.from("A"))
-        expect(snap(p)).toEqual([k("a", { raw: "A", shift: true })]) // 'A' = shift+a
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("double reset is safe", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b["))
-        p.reset()
-        p.reset()
-        p.push(Buffer.from("x"))
-        expect(snap(p)).toEqual([k("x")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("double destroy is safe", () => {
-      const p = createParser()
-      p.destroy()
-      expect(() => p.destroy()).not.toThrow()
-    })
-
-    test("push after destroy throws", () => {
-      const p = createParser()
-      p.destroy()
-      expect(() => p.push(Buffer.from("a"))).toThrow("destroyed")
-    })
-
-    test("read after destroy throws", () => {
-      const p = createParser()
-      p.destroy()
-      expect(() => p.read()).toThrow("destroyed")
-    })
-
-    test("drain after destroy throws", () => {
-      const p = createParser()
-      p.destroy()
-      expect(() => p.drain(() => {})).toThrow("destroyed")
-    })
-
-    test("destroy during drain stops iteration", () => {
-      const p = createParser()
-      p.push(Buffer.from("abc"))
-      let count = 0
-      expect(() => {
-        p.drain(() => {
-          count++
-          if (count === 1) p.destroy()
-        })
-      }).not.toThrow()
-      expect(count).toBe(1)
-    })
-
-    test("read returns null when queue is empty", () => {
-      const p = createParser()
-      try {
-        expect(p.read()).toBeNull()
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("read pops events one at a time", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("abc"))
-        const e1 = p.read()
-        const e2 = p.read()
-        const e3 = p.read()
-        const e4 = p.read()
-        expect(e1).not.toBeNull()
-        expect(e2).not.toBeNull()
-        expect(e3).not.toBeNull()
-        expect(e4).toBeNull()
-        expect(snapshotEvent(e1!)).toEqual(k("a"))
-        expect(snapshotEvent(e2!)).toEqual(k("b"))
-        expect(snapshotEvent(e3!)).toEqual(k("c"))
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("overflow flushes incomplete protocols as one unknown response and recovers", () => {
-      const longDigits = "1".repeat(40)
-      const longOsc = "a".repeat(40)
-      const longDcs = "x".repeat(40)
-      const cases: Array<[label: string, chunks: ChunkInput[], expected: Snap[]]> = [
-        ["CSI", [`\x1b[${longDigits}`], [resp("unknown", `\x1b[${longDigits}`)]],
-        ["OSC", [`\x1b]${longOsc}`], [resp("unknown", `\x1b]${longOsc}`)]],
-        ["DCS + recovery", [`\x1bP${longDcs}`, "z"], [resp("unknown", `\x1bP${longDcs}`), k("z")]],
-      ]
-
-      for (const [label, chunks, expected] of cases) {
-        expect(snapChunks(chunks, { maxPendingBytes: 16 })).toEqual(expected)
-      }
-    })
-  })
-
-  describe("multi-event interleaving", () => {
-    table([
-      [
-        "key + mouse",
-        "x\x1b[<64;10;5M",
-        [k("x"), sgr("\x1b[<64;10;5M", "scroll", 9, 4, { scroll: { direction: "up", delta: 1 } })],
-      ],
-      [
-        "mouse + key",
-        "\x1b[<64;10;5Mx",
-        [sgr("\x1b[<64;10;5M", "scroll", 9, 4, { scroll: { direction: "up", delta: 1 } }), k("x")],
-      ],
-      ["key + focus + key", "a\x1b[Ib", [k("a"), resp("csi", "\x1b[I"), k("b")]],
-      ["paste + key", "\x1b[200~hi\x1b[201~z", [paste("hi"), k("z")]],
-      ["multiple keys", "abc", [k("a"), k("b"), k("c")]],
-      [
-        "arrow + text + mouse",
-        "\x1b[Ax\x1b[<0;1;1M",
-        [k("up", { raw: "\x1b[A" }), k("x"), sgr("\x1b[<0;1;1M", "down", 0, 0)],
-      ],
-    ])
-
-    test("OSC + key + mouse + paste in one push", () => {
-      const p = createParser()
-      try {
-        const input = "\x1b]4;0;#fff\x07a\x1b[<0;1;1M\x1b[200~p\x1b[201~"
-        p.push(Buffer.from(input))
-        expect(snap(p)).toEqual([
-          resp("osc", "\x1b]4;0;#fff\x07"),
-          k("a"),
-          sgr("\x1b[<0;1;1M", "down", 0, 0),
-          paste("p"),
-        ])
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("negative and edge cases", () => {
-    test("push with empty buffer emits an empty key event", () => {
-      const p = createParser()
-      try {
-        p.push(new Uint8Array(0))
-        expect(snap(p)).toEqual([k("")])
-      } finally {
-        p.destroy()
-      }
-    })
-
-    test("drain with no events does not call callback", () => {
-      const p = createParser()
-      try {
-        let called = false
-        p.drain(() => {
-          called = true
-        })
-        expect(called).toBe(false)
-      } finally {
-        p.destroy()
-      }
-    })
-
-    table([
-      ["CSI with unknown final byte produces empty-name key", "\x1b[h", [k("", { raw: "\x1b[h" })]],
-      ["ESC followed by punctuation stays one empty-name key", "\x1b!", [k("", { raw: "\x1b!" })]],
-      ["ESC followed by N becomes meta+shift+N", "\x1bN", [k("N", { raw: "\x1bN", meta: true, shift: true })]],
-      ["malformed SGR mouse falls through as empty-name CSI key", "\x1b[<0M", [k("", { raw: "\x1b[<0M" })]],
-      ["bracketed paste end outside paste mode is a CSI response", "\x1b[201~", [resp("csi", "\x1b[201~")]],
-    ])
-
-    test("partial X10 times out as one unknown response", () => {
-      const { parser, clock } = createTimedParser()
-      try {
-        parser.push(Buffer.from("\x1b[M !"))
-        expect(snap(parser)).toEqual([])
-        clock.advance(10)
-        expect(snap(parser)).toEqual([resp("unknown", "\x1b[M !")])
-      } finally {
-        parser.destroy()
-      }
-    })
-
-    test("very long paste with partial end marker in every chunk", () => {
-      const p = createParser()
-      try {
-        p.push(Buffer.from("\x1b[200~"))
-        for (let i = 0; i < 100; i++) p.push(Buffer.from("\x1b[20"))
-        p.push(Buffer.from("\x1b[201~"))
-        expect(snap(p)).toEqual([paste("\x1b[20".repeat(100))])
-      } finally {
-        p.destroy()
-      }
-    })
-  })
-
-  describe("timer/clock disagreement race condition", () => {
-    test("timeout callback flushes even when now() reports slightly less elapsed time than timeoutMs", () => {
-      const inner = new ManualClock()
-      let insideTimerCallback = false
-
-      // Wraps ManualClock so that now() returns pendingSinceMs + timeoutMs - 1
-      // during the timeout callback, simulating runtime behavior where timer
-      // scheduling and now() sampling disagree by a small amount.
-      const disagreeingClock: Clock = {
-        now(): number {
-          if (insideTimerCallback) {
-            // Report 1ms less than the timeout requires — this is the
-            // race condition that kept bytes stuck before the fix.
-            return TEST_TIMEOUT_MS - 1
-          }
-          return inner.now()
-        },
-        setTimeout(fn: () => void, delayMs: number): TimerHandle {
-          return inner.setTimeout(() => {
-            insideTimerCallback = true
-            try {
-              fn()
-            } finally {
-              insideTimerCallback = false
-            }
-          }, delayMs)
-        },
-        clearTimeout(handle: TimerHandle): void {
-          inner.clearTimeout(handle)
-        },
-        setInterval(fn: () => void, delayMs: number): TimerHandle {
-          return inner.setInterval(fn, delayMs)
-        },
-        clearInterval(handle: TimerHandle): void {
-          inner.clearInterval(handle)
-        },
-      }
-
-      const parser = new StdinParser({ armTimeouts: true, clock: disagreeingClock, timeoutMs: TEST_TIMEOUT_MS })
-      try {
-        parser.push(Buffer.from("\x1b"))
-        expect(snap(parser)).toEqual([])
-
-        // Fire the timer — now() will report timeoutMs - 1 elapsed, but the
-        // timeout callback still force-flushes without re-checking elapsed time.
-        inner.advance(TEST_TIMEOUT_MS)
-
-        expect(snap(parser)).toEqual([k("escape", { raw: "\x1b" })])
-      } finally {
-        parser.destroy()
-      }
-    })
-  })
-})